"use strict";
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 __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all3) => {
  for (var name28 in all3)
    __defProp(target, name28, { get: all3[name28], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// node_modules/non-error/index.js
function defineProperty(object4, key, value) {
  Object.defineProperty(object4, key, {
    value,
    writable: false,
    enumerable: false,
    configurable: false
  });
}
function stringify(value) {
  if (value === void 0) {
    return "undefined";
  }
  if (value === null) {
    return "null";
  }
  if (typeof value === "string") {
    return value;
  }
  if (typeof value === "number" || typeof value === "boolean") {
    return String(value);
  }
  if (typeof value === "bigint") {
    return `${value}n`;
  }
  if (typeof value === "symbol") {
    return value.toString();
  }
  if (typeof value === "function") {
    return `[Function${value.name ? ` ${value.name}` : " (anonymous)"}]`;
  }
  if (value instanceof Error) {
    try {
      return String(value);
    } catch {
      return "<Unserializable error>";
    }
  }
  try {
    return JSON.stringify(value);
  } catch {
    try {
      return String(value);
    } catch {
      return "<Unserializable value>";
    }
  }
}
var isNonErrorSymbol, NonError;
var init_non_error = __esm({
  "node_modules/non-error/index.js"() {
    "use strict";
    isNonErrorSymbol = /* @__PURE__ */ Symbol("isNonError");
    NonError = class _NonError extends Error {
      constructor(value, { superclass: Superclass = Error } = {}) {
        if (_NonError.isNonError(value)) {
          return value;
        }
        if (value instanceof Error) {
          throw new TypeError("Do not pass Error instances to NonError. Throw the error directly instead.");
        }
        super(`Non-error value: ${stringify(value)}`);
        if (Superclass !== Error) {
          Object.setPrototypeOf(this, Superclass.prototype);
        }
        defineProperty(this, "name", "NonError");
        defineProperty(this, isNonErrorSymbol, true);
        defineProperty(this, "isNonError", true);
        defineProperty(this, "value", value);
      }
      static isNonError(value) {
        return value?.[isNonErrorSymbol] === true;
      }
      static #handleCallback(callback, arguments_) {
        try {
          const result = callback(...arguments_);
          if (result && typeof result.then === "function") {
            return (async () => {
              try {
                return await result;
              } catch (error73) {
                if (error73 instanceof Error) {
                  throw error73;
                }
                throw new _NonError(error73);
              }
            })();
          }
          return result;
        } catch (error73) {
          if (error73 instanceof Error) {
            throw error73;
          }
          throw new _NonError(error73);
        }
      }
      static try(callback) {
        return _NonError.#handleCallback(callback, []);
      }
      static wrap(callback) {
        return (...arguments_) => _NonError.#handleCallback(callback, arguments_);
      }
      // This makes instanceof work even when using the `superclass` option
      static [Symbol.hasInstance](instance) {
        return _NonError.isNonError(instance);
      }
    };
  }
});

// node_modules/serialize-error/error-constructors.js
var list, errorConstructors, errorFactories;
var init_error_constructors = __esm({
  "node_modules/serialize-error/error-constructors.js"() {
    "use strict";
    list = [
      // Native ES errors https://262.ecma-international.org/12.0/#sec-well-known-intrinsic-objects
      Error,
      EvalError,
      RangeError,
      ReferenceError,
      SyntaxError,
      TypeError,
      URIError,
      AggregateError,
      // Built-in errors
      globalThis.DOMException,
      // Node-specific errors
      // https://nodejs.org/api/errors.html
      globalThis.AssertionError,
      globalThis.SystemError
    ].filter(Boolean).map((constructor) => [constructor.name, constructor]);
    errorConstructors = new Map(list);
    errorFactories = /* @__PURE__ */ new Map();
  }
});

// node_modules/serialize-error/index.js
function serializeError(value, options = {}) {
  const {
    maxDepth = Number.POSITIVE_INFINITY,
    useToJSON = true
  } = options;
  if (typeof value === "object" && value !== null) {
    return destroyCircular({
      from: value,
      seen: /* @__PURE__ */ new Set(),
      forceEnumerable: true,
      maxDepth,
      depth: 0,
      useToJSON,
      serialize: true
    });
  }
  if (typeof value === "function") {
    value = "<Function>";
  }
  return destroyCircular({
    from: new NonError(value),
    seen: /* @__PURE__ */ new Set(),
    forceEnumerable: true,
    maxDepth,
    depth: 0,
    useToJSON,
    serialize: true
  });
}
function isErrorLike(value) {
  return Boolean(value) && typeof value === "object" && typeof value.name === "string" && typeof value.message === "string" && typeof value.stack === "string";
}
var errorProperties, toJsonWasCalled, toJSON, newError, destroyCircular;
var init_serialize_error = __esm({
  "node_modules/serialize-error/index.js"() {
    "use strict";
    init_non_error();
    init_error_constructors();
    errorProperties = [
      {
        property: "name",
        enumerable: false
      },
      {
        property: "message",
        enumerable: false
      },
      {
        property: "stack",
        enumerable: false
      },
      {
        property: "code",
        enumerable: true
      },
      {
        property: "cause",
        enumerable: false
      },
      {
        property: "errors",
        enumerable: false
      }
    ];
    toJsonWasCalled = /* @__PURE__ */ new WeakSet();
    toJSON = (from) => {
      toJsonWasCalled.add(from);
      const json4 = from.toJSON();
      toJsonWasCalled.delete(from);
      return json4;
    };
    newError = (name28) => {
      if (name28 === "NonError") {
        return new NonError();
      }
      const factory12 = errorFactories.get(name28);
      if (factory12) {
        return factory12();
      }
      const ErrorConstructor = errorConstructors.get(name28) ?? Error;
      return ErrorConstructor === AggregateError ? new ErrorConstructor([]) : new ErrorConstructor();
    };
    destroyCircular = ({
      from,
      seen,
      to,
      forceEnumerable,
      maxDepth,
      depth,
      useToJSON,
      serialize
    }) => {
      if (!to) {
        if (Array.isArray(from)) {
          to = [];
        } else if (!serialize && isErrorLike(from)) {
          to = newError(from.name);
        } else {
          to = {};
        }
      }
      seen.add(from);
      if (depth >= maxDepth) {
        seen.delete(from);
        return to;
      }
      if (useToJSON && typeof from.toJSON === "function" && !toJsonWasCalled.has(from)) {
        seen.delete(from);
        return toJSON(from);
      }
      const continueDestroyCircular = (value) => destroyCircular({
        from: value,
        seen,
        forceEnumerable,
        maxDepth,
        depth: depth + 1,
        useToJSON,
        serialize
      });
      for (const key of Object.keys(from)) {
        const value = from[key];
        if (value && value instanceof Uint8Array && value.constructor.name === "Buffer") {
          to[key] = serialize ? "[object Buffer]" : value;
          continue;
        }
        if (value !== null && typeof value === "object" && typeof value.pipe === "function") {
          to[key] = serialize ? "[object Stream]" : value;
          continue;
        }
        if (typeof value === "function") {
          if (!serialize) {
            to[key] = value;
          }
          continue;
        }
        if (serialize && typeof value === "bigint") {
          to[key] = `${value}n`;
          continue;
        }
        if (!value || typeof value !== "object") {
          try {
            to[key] = value;
          } catch {
          }
          continue;
        }
        if (!seen.has(value)) {
          to[key] = continueDestroyCircular(value);
          continue;
        }
        to[key] = "[Circular]";
      }
      if (serialize || to instanceof Error) {
        for (const { property: property2, enumerable } of errorProperties) {
          const value = from[property2];
          if (value === void 0 || value === null) {
            continue;
          }
          const descriptor = Object.getOwnPropertyDescriptor(to, property2);
          if (descriptor?.configurable === false) {
            continue;
          }
          let processedValue = value;
          if (typeof value === "object") {
            processedValue = seen.has(value) ? "[Circular]" : continueDestroyCircular(value);
          }
          Object.defineProperty(to, property2, {
            value: processedValue,
            enumerable: forceEnumerable || enumerable,
            configurable: true,
            writable: true
          });
        }
      }
      seen.delete(from);
      return to;
    };
  }
});

// node_modules/dotenv/package.json
var require_package = __commonJS({
  "node_modules/dotenv/package.json"(exports2, module2) {
    module2.exports = {
      name: "dotenv",
      version: "17.3.1",
      description: "Loads environment variables from .env file",
      main: "lib/main.js",
      types: "lib/main.d.ts",
      exports: {
        ".": {
          types: "./lib/main.d.ts",
          require: "./lib/main.js",
          default: "./lib/main.js"
        },
        "./config": "./config.js",
        "./config.js": "./config.js",
        "./lib/env-options": "./lib/env-options.js",
        "./lib/env-options.js": "./lib/env-options.js",
        "./lib/cli-options": "./lib/cli-options.js",
        "./lib/cli-options.js": "./lib/cli-options.js",
        "./package.json": "./package.json"
      },
      scripts: {
        "dts-check": "tsc --project tests/types/tsconfig.json",
        lint: "standard",
        pretest: "npm run lint && npm run dts-check",
        test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
        "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
        prerelease: "npm test",
        release: "standard-version"
      },
      repository: {
        type: "git",
        url: "git://github.com/motdotla/dotenv.git"
      },
      homepage: "https://github.com/motdotla/dotenv#readme",
      funding: "https://dotenvx.com",
      keywords: [
        "dotenv",
        "env",
        ".env",
        "environment",
        "variables",
        "config",
        "settings"
      ],
      readmeFilename: "README.md",
      license: "BSD-2-Clause",
      devDependencies: {
        "@types/node": "^18.11.3",
        decache: "^4.6.2",
        sinon: "^14.0.1",
        standard: "^17.0.0",
        "standard-version": "^9.5.0",
        tap: "^19.2.0",
        typescript: "^4.8.4"
      },
      engines: {
        node: ">=12"
      },
      browser: {
        fs: false
      }
    };
  }
});

// node_modules/dotenv/lib/main.js
var require_main = __commonJS({
  "node_modules/dotenv/lib/main.js"(exports2, module2) {
    "use strict";
    var fs34 = require("fs");
    var path33 = require("path");
    var os = require("os");
    var crypto7 = require("crypto");
    var packageJson = require_package();
    var version3 = packageJson.version;
    var TIPS = [
      "\u{1F510} encrypt with Dotenvx: https://dotenvx.com",
      "\u{1F510} prevent committing .env to code: https://dotenvx.com/precommit",
      "\u{1F510} prevent building .env in docker: https://dotenvx.com/prebuild",
      "\u{1F916} agentic secret storage: https://dotenvx.com/as2",
      "\u26A1\uFE0F secrets for agents: https://dotenvx.com/as2",
      "\u{1F6E1}\uFE0F auth for agents: https://vestauth.com",
      "\u{1F6E0}\uFE0F  run anywhere with `dotenvx run -- yourcommand`",
      "\u2699\uFE0F  specify custom .env file path with { path: '/custom/path/.env' }",
      "\u2699\uFE0F  enable debug logging with { debug: true }",
      "\u2699\uFE0F  override existing env vars with { override: true }",
      "\u2699\uFE0F  suppress all logs with { quiet: true }",
      "\u2699\uFE0F  write to custom object with { processEnv: myObject }",
      "\u2699\uFE0F  load multiple .env files with { path: ['.env.local', '.env'] }"
    ];
    function _getRandomTip() {
      return TIPS[Math.floor(Math.random() * TIPS.length)];
    }
    function parseBoolean(value) {
      if (typeof value === "string") {
        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
      }
      return Boolean(value);
    }
    function supportsAnsi() {
      return process.stdout.isTTY;
    }
    function dim(text2) {
      return supportsAnsi() ? `\x1B[2m${text2}\x1B[0m` : text2;
    }
    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
    function parse4(src) {
      const obj = {};
      let lines = src.toString();
      lines = lines.replace(/\r\n?/mg, "\n");
      let match;
      while ((match = LINE.exec(lines)) != null) {
        const key = match[1];
        let value = match[2] || "";
        value = value.trim();
        const maybeQuote = value[0];
        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
        if (maybeQuote === '"') {
          value = value.replace(/\\n/g, "\n");
          value = value.replace(/\\r/g, "\r");
        }
        obj[key] = value;
      }
      return obj;
    }
    function _parseVault(options) {
      options = options || {};
      const vaultPath = _vaultPath(options);
      options.path = vaultPath;
      const result = DotenvModule.configDotenv(options);
      if (!result.parsed) {
        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
        err.code = "MISSING_DATA";
        throw err;
      }
      const keys2 = _dotenvKey(options).split(",");
      const length = keys2.length;
      let decrypted;
      for (let i = 0; i < length; i++) {
        try {
          const key = keys2[i].trim();
          const attrs = _instructions(result, key);
          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
          break;
        } catch (error73) {
          if (i + 1 >= length) {
            throw error73;
          }
        }
      }
      return DotenvModule.parse(decrypted);
    }
    function _warn(message) {
      console.error(`[dotenv@${version3}][WARN] ${message}`);
    }
    function _debug(message) {
      console.log(`[dotenv@${version3}][DEBUG] ${message}`);
    }
    function _log(message) {
      console.log(`[dotenv@${version3}] ${message}`);
    }
    function _dotenvKey(options) {
      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
        return options.DOTENV_KEY;
      }
      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
        return process.env.DOTENV_KEY;
      }
      return "";
    }
    function _instructions(result, dotenvKey) {
      let uri;
      try {
        uri = new URL(dotenvKey);
      } catch (error73) {
        if (error73.code === "ERR_INVALID_URL") {
          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
          err.code = "INVALID_DOTENV_KEY";
          throw err;
        }
        throw error73;
      }
      const key = uri.password;
      if (!key) {
        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
        err.code = "INVALID_DOTENV_KEY";
        throw err;
      }
      const environment = uri.searchParams.get("environment");
      if (!environment) {
        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
        err.code = "INVALID_DOTENV_KEY";
        throw err;
      }
      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
      const ciphertext = result.parsed[environmentKey];
      if (!ciphertext) {
        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
        throw err;
      }
      return { ciphertext, key };
    }
    function _vaultPath(options) {
      let possibleVaultPath = null;
      if (options && options.path && options.path.length > 0) {
        if (Array.isArray(options.path)) {
          for (const filepath of options.path) {
            if (fs34.existsSync(filepath)) {
              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
            }
          }
        } else {
          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
        }
      } else {
        possibleVaultPath = path33.resolve(process.cwd(), ".env.vault");
      }
      if (fs34.existsSync(possibleVaultPath)) {
        return possibleVaultPath;
      }
      return null;
    }
    function _resolveHome(envPath) {
      return envPath[0] === "~" ? path33.join(os.homedir(), envPath.slice(1)) : envPath;
    }
    function _configVault(options) {
      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
      if (debug || !quiet) {
        _log("Loading env from encrypted .env.vault");
      }
      const parsed = DotenvModule._parseVault(options);
      let processEnv = process.env;
      if (options && options.processEnv != null) {
        processEnv = options.processEnv;
      }
      DotenvModule.populate(processEnv, parsed, options);
      return { parsed };
    }
    function configDotenv(options) {
      const dotenvPath = path33.resolve(process.cwd(), ".env");
      let encoding = "utf8";
      let processEnv = process.env;
      if (options && options.processEnv != null) {
        processEnv = options.processEnv;
      }
      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
      if (options && options.encoding) {
        encoding = options.encoding;
      } else {
        if (debug) {
          _debug("No encoding is specified. UTF-8 is used by default");
        }
      }
      let optionPaths = [dotenvPath];
      if (options && options.path) {
        if (!Array.isArray(options.path)) {
          optionPaths = [_resolveHome(options.path)];
        } else {
          optionPaths = [];
          for (const filepath of options.path) {
            optionPaths.push(_resolveHome(filepath));
          }
        }
      }
      let lastError;
      const parsedAll = {};
      for (const path34 of optionPaths) {
        try {
          const parsed = DotenvModule.parse(fs34.readFileSync(path34, { encoding }));
          DotenvModule.populate(parsedAll, parsed, options);
        } catch (e) {
          if (debug) {
            _debug(`Failed to load ${path34} ${e.message}`);
          }
          lastError = e;
        }
      }
      const populated = DotenvModule.populate(processEnv, parsedAll, options);
      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
      if (debug || !quiet) {
        const keysCount = Object.keys(populated).length;
        const shortPaths = [];
        for (const filePath of optionPaths) {
          try {
            const relative = path33.relative(process.cwd(), filePath);
            shortPaths.push(relative);
          } catch (e) {
            if (debug) {
              _debug(`Failed to load ${filePath} ${e.message}`);
            }
            lastError = e;
          }
        }
        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
      }
      if (lastError) {
        return { parsed: parsedAll, error: lastError };
      } else {
        return { parsed: parsedAll };
      }
    }
    function config3(options) {
      if (_dotenvKey(options).length === 0) {
        return DotenvModule.configDotenv(options);
      }
      const vaultPath = _vaultPath(options);
      if (!vaultPath) {
        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
        return DotenvModule.configDotenv(options);
      }
      return DotenvModule._configVault(options);
    }
    function decrypt(encrypted, keyStr) {
      const key = Buffer.from(keyStr.slice(-64), "hex");
      let ciphertext = Buffer.from(encrypted, "base64");
      const nonce = ciphertext.subarray(0, 12);
      const authTag = ciphertext.subarray(-16);
      ciphertext = ciphertext.subarray(12, -16);
      try {
        const aesgcm = crypto7.createDecipheriv("aes-256-gcm", key, nonce);
        aesgcm.setAuthTag(authTag);
        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
      } catch (error73) {
        const isRange = error73 instanceof RangeError;
        const invalidKeyLength = error73.message === "Invalid key length";
        const decryptionFailed = error73.message === "Unsupported state or unable to authenticate data";
        if (isRange || invalidKeyLength) {
          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
          err.code = "INVALID_DOTENV_KEY";
          throw err;
        } else if (decryptionFailed) {
          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
          err.code = "DECRYPTION_FAILED";
          throw err;
        } else {
          throw error73;
        }
      }
    }
    function populate(processEnv, parsed, options = {}) {
      const debug = Boolean(options && options.debug);
      const override = Boolean(options && options.override);
      const populated = {};
      if (typeof parsed !== "object") {
        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
        err.code = "OBJECT_REQUIRED";
        throw err;
      }
      for (const key of Object.keys(parsed)) {
        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
          if (override === true) {
            processEnv[key] = parsed[key];
            populated[key] = parsed[key];
          }
          if (debug) {
            if (override === true) {
              _debug(`"${key}" is already defined and WAS overwritten`);
            } else {
              _debug(`"${key}" is already defined and was NOT overwritten`);
            }
          }
        } else {
          processEnv[key] = parsed[key];
          populated[key] = parsed[key];
        }
      }
      return populated;
    }
    var DotenvModule = {
      configDotenv,
      _configVault,
      _parseVault,
      config: config3,
      decrypt,
      parse: parse4,
      populate
    };
    module2.exports.configDotenv = DotenvModule.configDotenv;
    module2.exports._configVault = DotenvModule._configVault;
    module2.exports._parseVault = DotenvModule._parseVault;
    module2.exports.config = DotenvModule.config;
    module2.exports.decrypt = DotenvModule.decrypt;
    module2.exports.parse = DotenvModule.parse;
    module2.exports.populate = DotenvModule.populate;
    module2.exports = DotenvModule;
  }
});

// node_modules/ms/index.js
var require_ms = __commonJS({
  "node_modules/ms/index.js"(exports2, module2) {
    "use strict";
    var s = 1e3;
    var m = s * 60;
    var h = m * 60;
    var d = h * 24;
    var w = d * 7;
    var y = d * 365.25;
    module2.exports = function(val, options) {
      options = options || {};
      var type = typeof val;
      if (type === "string" && val.length > 0) {
        return parse4(val);
      } else if (type === "number" && isFinite(val)) {
        return options.long ? fmtLong(val) : fmtShort(val);
      }
      throw new Error(
        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
      );
    };
    function parse4(str) {
      str = String(str);
      if (str.length > 100) {
        return;
      }
      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
        str
      );
      if (!match) {
        return;
      }
      var n = parseFloat(match[1]);
      var type = (match[2] || "ms").toLowerCase();
      switch (type) {
        case "years":
        case "year":
        case "yrs":
        case "yr":
        case "y":
          return n * y;
        case "weeks":
        case "week":
        case "w":
          return n * w;
        case "days":
        case "day":
        case "d":
          return n * d;
        case "hours":
        case "hour":
        case "hrs":
        case "hr":
        case "h":
          return n * h;
        case "minutes":
        case "minute":
        case "mins":
        case "min":
        case "m":
          return n * m;
        case "seconds":
        case "second":
        case "secs":
        case "sec":
        case "s":
          return n * s;
        case "milliseconds":
        case "millisecond":
        case "msecs":
        case "msec":
        case "ms":
          return n;
        default:
          return void 0;
      }
    }
    function fmtShort(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d) {
        return Math.round(ms / d) + "d";
      }
      if (msAbs >= h) {
        return Math.round(ms / h) + "h";
      }
      if (msAbs >= m) {
        return Math.round(ms / m) + "m";
      }
      if (msAbs >= s) {
        return Math.round(ms / s) + "s";
      }
      return ms + "ms";
    }
    function fmtLong(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d) {
        return plural(ms, msAbs, d, "day");
      }
      if (msAbs >= h) {
        return plural(ms, msAbs, h, "hour");
      }
      if (msAbs >= m) {
        return plural(ms, msAbs, m, "minute");
      }
      if (msAbs >= s) {
        return plural(ms, msAbs, s, "second");
      }
      return ms + " ms";
    }
    function plural(ms, msAbs, n, name28) {
      var isPlural = msAbs >= n * 1.5;
      return Math.round(ms / n) + " " + name28 + (isPlural ? "s" : "");
    }
  }
});

// node_modules/debug/src/common.js
var require_common = __commonJS({
  "node_modules/debug/src/common.js"(exports2, module2) {
    "use strict";
    function setup(env2) {
      createDebug.debug = createDebug;
      createDebug.default = createDebug;
      createDebug.coerce = coerce;
      createDebug.disable = disable;
      createDebug.enable = enable;
      createDebug.enabled = enabled;
      createDebug.humanize = require_ms();
      createDebug.destroy = destroy;
      Object.keys(env2).forEach((key) => {
        createDebug[key] = env2[key];
      });
      createDebug.names = [];
      createDebug.skips = [];
      createDebug.formatters = {};
      function selectColor(namespace) {
        let hash3 = 0;
        for (let i = 0; i < namespace.length; i++) {
          hash3 = (hash3 << 5) - hash3 + namespace.charCodeAt(i);
          hash3 |= 0;
        }
        return createDebug.colors[Math.abs(hash3) % createDebug.colors.length];
      }
      createDebug.selectColor = selectColor;
      function createDebug(namespace) {
        let prevTime;
        let enableOverride = null;
        let namespacesCache;
        let enabledCache;
        function debug(...args) {
          if (!debug.enabled) {
            return;
          }
          const self2 = debug;
          const curr = Number(/* @__PURE__ */ new Date());
          const ms = curr - (prevTime || curr);
          self2.diff = ms;
          self2.prev = prevTime;
          self2.curr = curr;
          prevTime = curr;
          args[0] = createDebug.coerce(args[0]);
          if (typeof args[0] !== "string") {
            args.unshift("%O");
          }
          let index = 0;
          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
            if (match === "%%") {
              return "%";
            }
            index++;
            const formatter = createDebug.formatters[format];
            if (typeof formatter === "function") {
              const val = args[index];
              match = formatter.call(self2, val);
              args.splice(index, 1);
              index--;
            }
            return match;
          });
          createDebug.formatArgs.call(self2, args);
          const logFn = self2.log || createDebug.log;
          logFn.apply(self2, args);
        }
        debug.namespace = namespace;
        debug.useColors = createDebug.useColors();
        debug.color = createDebug.selectColor(namespace);
        debug.extend = extend4;
        debug.destroy = createDebug.destroy;
        Object.defineProperty(debug, "enabled", {
          enumerable: true,
          configurable: false,
          get: () => {
            if (enableOverride !== null) {
              return enableOverride;
            }
            if (namespacesCache !== createDebug.namespaces) {
              namespacesCache = createDebug.namespaces;
              enabledCache = createDebug.enabled(namespace);
            }
            return enabledCache;
          },
          set: (v) => {
            enableOverride = v;
          }
        });
        if (typeof createDebug.init === "function") {
          createDebug.init(debug);
        }
        return debug;
      }
      function extend4(namespace, delimiter) {
        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
        newDebug.log = this.log;
        return newDebug;
      }
      function enable(namespaces) {
        createDebug.save(namespaces);
        createDebug.namespaces = namespaces;
        createDebug.names = [];
        createDebug.skips = [];
        const split2 = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
        for (const ns of split2) {
          if (ns[0] === "-") {
            createDebug.skips.push(ns.slice(1));
          } else {
            createDebug.names.push(ns);
          }
        }
      }
      function matchesTemplate(search, template) {
        let searchIndex = 0;
        let templateIndex = 0;
        let starIndex = -1;
        let matchIndex = 0;
        while (searchIndex < search.length) {
          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
            if (template[templateIndex] === "*") {
              starIndex = templateIndex;
              matchIndex = searchIndex;
              templateIndex++;
            } else {
              searchIndex++;
              templateIndex++;
            }
          } else if (starIndex !== -1) {
            templateIndex = starIndex + 1;
            matchIndex++;
            searchIndex = matchIndex;
          } else {
            return false;
          }
        }
        while (templateIndex < template.length && template[templateIndex] === "*") {
          templateIndex++;
        }
        return templateIndex === template.length;
      }
      function disable() {
        const namespaces = [
          ...createDebug.names,
          ...createDebug.skips.map((namespace) => "-" + namespace)
        ].join(",");
        createDebug.enable("");
        return namespaces;
      }
      function enabled(name28) {
        for (const skip of createDebug.skips) {
          if (matchesTemplate(name28, skip)) {
            return false;
          }
        }
        for (const ns of createDebug.names) {
          if (matchesTemplate(name28, ns)) {
            return true;
          }
        }
        return false;
      }
      function coerce(val) {
        if (val instanceof Error) {
          return val.stack || val.message;
        }
        return val;
      }
      function destroy() {
        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
      }
      createDebug.enable(createDebug.load());
      return createDebug;
    }
    module2.exports = setup;
  }
});

// node_modules/debug/src/browser.js
var require_browser = __commonJS({
  "node_modules/debug/src/browser.js"(exports2, module2) {
    "use strict";
    exports2.formatArgs = formatArgs;
    exports2.save = save;
    exports2.load = load;
    exports2.useColors = useColors;
    exports2.storage = localstorage();
    exports2.destroy = /* @__PURE__ */ (() => {
      let warned = false;
      return () => {
        if (!warned) {
          warned = true;
          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
        }
      };
    })();
    exports2.colors = [
      "#0000CC",
      "#0000FF",
      "#0033CC",
      "#0033FF",
      "#0066CC",
      "#0066FF",
      "#0099CC",
      "#0099FF",
      "#00CC00",
      "#00CC33",
      "#00CC66",
      "#00CC99",
      "#00CCCC",
      "#00CCFF",
      "#3300CC",
      "#3300FF",
      "#3333CC",
      "#3333FF",
      "#3366CC",
      "#3366FF",
      "#3399CC",
      "#3399FF",
      "#33CC00",
      "#33CC33",
      "#33CC66",
      "#33CC99",
      "#33CCCC",
      "#33CCFF",
      "#6600CC",
      "#6600FF",
      "#6633CC",
      "#6633FF",
      "#66CC00",
      "#66CC33",
      "#9900CC",
      "#9900FF",
      "#9933CC",
      "#9933FF",
      "#99CC00",
      "#99CC33",
      "#CC0000",
      "#CC0033",
      "#CC0066",
      "#CC0099",
      "#CC00CC",
      "#CC00FF",
      "#CC3300",
      "#CC3333",
      "#CC3366",
      "#CC3399",
      "#CC33CC",
      "#CC33FF",
      "#CC6600",
      "#CC6633",
      "#CC9900",
      "#CC9933",
      "#CCCC00",
      "#CCCC33",
      "#FF0000",
      "#FF0033",
      "#FF0066",
      "#FF0099",
      "#FF00CC",
      "#FF00FF",
      "#FF3300",
      "#FF3333",
      "#FF3366",
      "#FF3399",
      "#FF33CC",
      "#FF33FF",
      "#FF6600",
      "#FF6633",
      "#FF9900",
      "#FF9933",
      "#FFCC00",
      "#FFCC33"
    ];
    function useColors() {
      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
        return true;
      }
      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
        return false;
      }
      let m;
      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
    }
    function formatArgs(args) {
      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
      if (!this.useColors) {
        return;
      }
      const c = "color: " + this.color;
      args.splice(1, 0, c, "color: inherit");
      let index = 0;
      let lastC = 0;
      args[0].replace(/%[a-zA-Z%]/g, (match) => {
        if (match === "%%") {
          return;
        }
        index++;
        if (match === "%c") {
          lastC = index;
        }
      });
      args.splice(lastC, 0, c);
    }
    exports2.log = console.debug || console.log || (() => {
    });
    function save(namespaces) {
      try {
        if (namespaces) {
          exports2.storage.setItem("debug", namespaces);
        } else {
          exports2.storage.removeItem("debug");
        }
      } catch (error73) {
      }
    }
    function load() {
      let r;
      try {
        r = exports2.storage.getItem("debug") || exports2.storage.getItem("DEBUG");
      } catch (error73) {
      }
      if (!r && typeof process !== "undefined" && "env" in process) {
        r = process.env.DEBUG;
      }
      return r;
    }
    function localstorage() {
      try {
        return localStorage;
      } catch (error73) {
      }
    }
    module2.exports = require_common()(exports2);
    var { formatters } = module2.exports;
    formatters.j = function(v) {
      try {
        return JSON.stringify(v);
      } catch (error73) {
        return "[UnexpectedJSONParseError]: " + error73.message;
      }
    };
  }
});

// node_modules/has-flag/index.js
var require_has_flag = __commonJS({
  "node_modules/has-flag/index.js"(exports2, module2) {
    "use strict";
    module2.exports = (flag, argv) => {
      argv = argv || process.argv;
      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
      const pos = argv.indexOf(prefix + flag);
      const terminatorPos = argv.indexOf("--");
      return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
    };
  }
});

// node_modules/supports-color/index.js
var require_supports_color = __commonJS({
  "node_modules/supports-color/index.js"(exports2, module2) {
    "use strict";
    var os = require("os");
    var hasFlag = require_has_flag();
    var env2 = process.env;
    var forceColor;
    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false")) {
      forceColor = false;
    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
      forceColor = true;
    }
    if ("FORCE_COLOR" in env2) {
      forceColor = env2.FORCE_COLOR.length === 0 || parseInt(env2.FORCE_COLOR, 10) !== 0;
    }
    function translateLevel(level) {
      if (level === 0) {
        return false;
      }
      return {
        level,
        hasBasic: true,
        has256: level >= 2,
        has16m: level >= 3
      };
    }
    function supportsColor(stream4) {
      if (forceColor === false) {
        return 0;
      }
      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
        return 3;
      }
      if (hasFlag("color=256")) {
        return 2;
      }
      if (stream4 && !stream4.isTTY && forceColor !== true) {
        return 0;
      }
      const min = forceColor ? 1 : 0;
      if (process.platform === "win32") {
        const osRelease = os.release().split(".");
        if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
          return Number(osRelease[2]) >= 14931 ? 3 : 2;
        }
        return 1;
      }
      if ("CI" in env2) {
        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env2) || env2.CI_NAME === "codeship") {
          return 1;
        }
        return min;
      }
      if ("TEAMCITY_VERSION" in env2) {
        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
      }
      if (env2.COLORTERM === "truecolor") {
        return 3;
      }
      if ("TERM_PROGRAM" in env2) {
        const version3 = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
        switch (env2.TERM_PROGRAM) {
          case "iTerm.app":
            return version3 >= 3 ? 3 : 2;
          case "Apple_Terminal":
            return 2;
        }
      }
      if (/-256(color)?$/i.test(env2.TERM)) {
        return 2;
      }
      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
        return 1;
      }
      if ("COLORTERM" in env2) {
        return 1;
      }
      if (env2.TERM === "dumb") {
        return min;
      }
      return min;
    }
    function getSupportLevel(stream4) {
      const level = supportsColor(stream4);
      return translateLevel(level);
    }
    module2.exports = {
      supportsColor: getSupportLevel,
      stdout: getSupportLevel(process.stdout),
      stderr: getSupportLevel(process.stderr)
    };
  }
});

// node_modules/debug/src/node.js
var require_node = __commonJS({
  "node_modules/debug/src/node.js"(exports2, module2) {
    "use strict";
    var tty = require("tty");
    var util4 = require("util");
    exports2.init = init;
    exports2.log = log;
    exports2.formatArgs = formatArgs;
    exports2.save = save;
    exports2.load = load;
    exports2.useColors = useColors;
    exports2.destroy = util4.deprecate(
      () => {
      },
      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
    );
    exports2.colors = [6, 2, 3, 4, 5, 1];
    try {
      const supportsColor = require_supports_color();
      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
        exports2.colors = [
          20,
          21,
          26,
          27,
          32,
          33,
          38,
          39,
          40,
          41,
          42,
          43,
          44,
          45,
          56,
          57,
          62,
          63,
          68,
          69,
          74,
          75,
          76,
          77,
          78,
          79,
          80,
          81,
          92,
          93,
          98,
          99,
          112,
          113,
          128,
          129,
          134,
          135,
          148,
          149,
          160,
          161,
          162,
          163,
          164,
          165,
          166,
          167,
          168,
          169,
          170,
          171,
          172,
          173,
          178,
          179,
          184,
          185,
          196,
          197,
          198,
          199,
          200,
          201,
          202,
          203,
          204,
          205,
          206,
          207,
          208,
          209,
          214,
          215,
          220,
          221
        ];
      }
    } catch (error73) {
    }
    exports2.inspectOpts = Object.keys(process.env).filter((key) => {
      return /^debug_/i.test(key);
    }).reduce((obj, key) => {
      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
        return k.toUpperCase();
      });
      let val = process.env[key];
      if (/^(yes|on|true|enabled)$/i.test(val)) {
        val = true;
      } else if (/^(no|off|false|disabled)$/i.test(val)) {
        val = false;
      } else if (val === "null") {
        val = null;
      } else {
        val = Number(val);
      }
      obj[prop] = val;
      return obj;
    }, {});
    function useColors() {
      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(process.stderr.fd);
    }
    function formatArgs(args) {
      const { namespace: name28, useColors: useColors2 } = this;
      if (useColors2) {
        const c = this.color;
        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
        const prefix = `  ${colorCode};1m${name28} \x1B[0m`;
        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
        args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
      } else {
        args[0] = getDate() + name28 + " " + args[0];
      }
    }
    function getDate() {
      if (exports2.inspectOpts.hideDate) {
        return "";
      }
      return (/* @__PURE__ */ new Date()).toISOString() + " ";
    }
    function log(...args) {
      return process.stderr.write(util4.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
    }
    function save(namespaces) {
      if (namespaces) {
        process.env.DEBUG = namespaces;
      } else {
        delete process.env.DEBUG;
      }
    }
    function load() {
      return process.env.DEBUG;
    }
    function init(debug) {
      debug.inspectOpts = {};
      const keys2 = Object.keys(exports2.inspectOpts);
      for (let i = 0; i < keys2.length; i++) {
        debug.inspectOpts[keys2[i]] = exports2.inspectOpts[keys2[i]];
      }
    }
    module2.exports = require_common()(exports2);
    var { formatters } = module2.exports;
    formatters.o = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
    };
    formatters.O = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v, this.inspectOpts);
    };
  }
});

// node_modules/debug/src/index.js
var require_src = __commonJS({
  "node_modules/debug/src/index.js"(exports2, module2) {
    "use strict";
    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
      module2.exports = require_browser();
    } else {
      module2.exports = require_node();
    }
  }
});

// node_modules/depd/index.js
var require_depd = __commonJS({
  "node_modules/depd/index.js"(exports2, module2) {
    "use strict";
    var relative = require("path").relative;
    module2.exports = depd;
    var basePath = process.cwd();
    function containsNamespace(str, namespace) {
      var vals = str.split(/[ ,]+/);
      var ns = String(namespace).toLowerCase();
      for (var i = 0; i < vals.length; i++) {
        var val = vals[i];
        if (val && (val === "*" || val.toLowerCase() === ns)) {
          return true;
        }
      }
      return false;
    }
    function convertDataDescriptorToAccessor(obj, prop, message) {
      var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
      var value = descriptor.value;
      descriptor.get = function getter() {
        return value;
      };
      if (descriptor.writable) {
        descriptor.set = function setter(val) {
          return value = val;
        };
      }
      delete descriptor.value;
      delete descriptor.writable;
      Object.defineProperty(obj, prop, descriptor);
      return descriptor;
    }
    function createArgumentsString(arity) {
      var str = "";
      for (var i = 0; i < arity; i++) {
        str += ", arg" + i;
      }
      return str.substr(2);
    }
    function createStackString(stack) {
      var str = this.name + ": " + this.namespace;
      if (this.message) {
        str += " deprecated " + this.message;
      }
      for (var i = 0; i < stack.length; i++) {
        str += "\n    at " + stack[i].toString();
      }
      return str;
    }
    function depd(namespace) {
      if (!namespace) {
        throw new TypeError("argument namespace is required");
      }
      var stack = getStack();
      var site = callSiteLocation(stack[1]);
      var file3 = site[0];
      function deprecate(message) {
        log.call(deprecate, message);
      }
      deprecate._file = file3;
      deprecate._ignored = isignored(namespace);
      deprecate._namespace = namespace;
      deprecate._traced = istraced(namespace);
      deprecate._warned = /* @__PURE__ */ Object.create(null);
      deprecate.function = wrapfunction;
      deprecate.property = wrapproperty;
      return deprecate;
    }
    function eehaslisteners(emitter, type) {
      var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
      return count > 0;
    }
    function isignored(namespace) {
      if (process.noDeprecation) {
        return true;
      }
      var str = process.env.NO_DEPRECATION || "";
      return containsNamespace(str, namespace);
    }
    function istraced(namespace) {
      if (process.traceDeprecation) {
        return true;
      }
      var str = process.env.TRACE_DEPRECATION || "";
      return containsNamespace(str, namespace);
    }
    function log(message, site) {
      var haslisteners = eehaslisteners(process, "deprecation");
      if (!haslisteners && this._ignored) {
        return;
      }
      var caller;
      var callFile;
      var callSite;
      var depSite;
      var i = 0;
      var seen = false;
      var stack = getStack();
      var file3 = this._file;
      if (site) {
        depSite = site;
        callSite = callSiteLocation(stack[1]);
        callSite.name = depSite.name;
        file3 = callSite[0];
      } else {
        i = 2;
        depSite = callSiteLocation(stack[i]);
        callSite = depSite;
      }
      for (; i < stack.length; i++) {
        caller = callSiteLocation(stack[i]);
        callFile = caller[0];
        if (callFile === file3) {
          seen = true;
        } else if (callFile === this._file) {
          file3 = this._file;
        } else if (seen) {
          break;
        }
      }
      var key = caller ? depSite.join(":") + "__" + caller.join(":") : void 0;
      if (key !== void 0 && key in this._warned) {
        return;
      }
      this._warned[key] = true;
      var msg = message;
      if (!msg) {
        msg = callSite === depSite || !callSite.name ? defaultMessage(depSite) : defaultMessage(callSite);
      }
      if (haslisteners) {
        var err = DeprecationError(this._namespace, msg, stack.slice(i));
        process.emit("deprecation", err);
        return;
      }
      var format = process.stderr.isTTY ? formatColor : formatPlain;
      var output = format.call(this, msg, caller, stack.slice(i));
      process.stderr.write(output + "\n", "utf8");
    }
    function callSiteLocation(callSite) {
      var file3 = callSite.getFileName() || "<anonymous>";
      var line = callSite.getLineNumber();
      var colm = callSite.getColumnNumber();
      if (callSite.isEval()) {
        file3 = callSite.getEvalOrigin() + ", " + file3;
      }
      var site = [file3, line, colm];
      site.callSite = callSite;
      site.name = callSite.getFunctionName();
      return site;
    }
    function defaultMessage(site) {
      var callSite = site.callSite;
      var funcName = site.name;
      if (!funcName) {
        funcName = "<anonymous@" + formatLocation(site) + ">";
      }
      var context2 = callSite.getThis();
      var typeName = context2 && callSite.getTypeName();
      if (typeName === "Object") {
        typeName = void 0;
      }
      if (typeName === "Function") {
        typeName = context2.name || typeName;
      }
      return typeName && callSite.getMethodName() ? typeName + "." + funcName : funcName;
    }
    function formatPlain(msg, caller, stack) {
      var timestamp = (/* @__PURE__ */ new Date()).toUTCString();
      var formatted = timestamp + " " + this._namespace + " deprecated " + msg;
      if (this._traced) {
        for (var i = 0; i < stack.length; i++) {
          formatted += "\n    at " + stack[i].toString();
        }
        return formatted;
      }
      if (caller) {
        formatted += " at " + formatLocation(caller);
      }
      return formatted;
    }
    function formatColor(msg, caller, stack) {
      var formatted = "\x1B[36;1m" + this._namespace + "\x1B[22;39m \x1B[33;1mdeprecated\x1B[22;39m \x1B[0m" + msg + "\x1B[39m";
      if (this._traced) {
        for (var i = 0; i < stack.length; i++) {
          formatted += "\n    \x1B[36mat " + stack[i].toString() + "\x1B[39m";
        }
        return formatted;
      }
      if (caller) {
        formatted += " \x1B[36m" + formatLocation(caller) + "\x1B[39m";
      }
      return formatted;
    }
    function formatLocation(callSite) {
      return relative(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
    }
    function getStack() {
      var limit = Error.stackTraceLimit;
      var obj = {};
      var prep = Error.prepareStackTrace;
      Error.prepareStackTrace = prepareObjectStackTrace;
      Error.stackTraceLimit = Math.max(10, limit);
      Error.captureStackTrace(obj);
      var stack = obj.stack.slice(1);
      Error.prepareStackTrace = prep;
      Error.stackTraceLimit = limit;
      return stack;
    }
    function prepareObjectStackTrace(obj, stack) {
      return stack;
    }
    function wrapfunction(fn, message) {
      if (typeof fn !== "function") {
        throw new TypeError("argument fn must be a function");
      }
      var args = createArgumentsString(fn.length);
      var stack = getStack();
      var site = callSiteLocation(stack[1]);
      site.name = fn.name;
      var deprecatedfn = new Function(
        "fn",
        "log",
        "deprecate",
        "message",
        "site",
        '"use strict"\nreturn function (' + args + ") {log.call(deprecate, message, site)\nreturn fn.apply(this, arguments)\n}"
      )(fn, log, this, message, site);
      return deprecatedfn;
    }
    function wrapproperty(obj, prop, message) {
      if (!obj || typeof obj !== "object" && typeof obj !== "function") {
        throw new TypeError("argument obj must be object");
      }
      var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
      if (!descriptor) {
        throw new TypeError("must call property on owner object");
      }
      if (!descriptor.configurable) {
        throw new TypeError("property must be configurable");
      }
      var deprecate = this;
      var stack = getStack();
      var site = callSiteLocation(stack[1]);
      site.name = prop;
      if ("value" in descriptor) {
        descriptor = convertDataDescriptorToAccessor(obj, prop, message);
      }
      var get2 = descriptor.get;
      var set3 = descriptor.set;
      if (typeof get2 === "function") {
        descriptor.get = function getter() {
          log.call(deprecate, message, site);
          return get2.apply(this, arguments);
        };
      }
      if (typeof set3 === "function") {
        descriptor.set = function setter() {
          log.call(deprecate, message, site);
          return set3.apply(this, arguments);
        };
      }
      Object.defineProperty(obj, prop, descriptor);
    }
    function DeprecationError(namespace, message, stack) {
      var error73 = new Error();
      var stackString;
      Object.defineProperty(error73, "constructor", {
        value: DeprecationError
      });
      Object.defineProperty(error73, "message", {
        configurable: true,
        enumerable: false,
        value: message,
        writable: true
      });
      Object.defineProperty(error73, "name", {
        enumerable: false,
        configurable: true,
        value: "DeprecationError",
        writable: true
      });
      Object.defineProperty(error73, "namespace", {
        configurable: true,
        enumerable: false,
        value: namespace,
        writable: true
      });
      Object.defineProperty(error73, "stack", {
        configurable: true,
        enumerable: false,
        get: function() {
          if (stackString !== void 0) {
            return stackString;
          }
          return stackString = createStackString.call(this, stack);
        },
        set: function setter(val) {
          stackString = val;
        }
      });
      return error73;
    }
  }
});

// node_modules/setprototypeof/index.js
var require_setprototypeof = __commonJS({
  "node_modules/setprototypeof/index.js"(exports2, module2) {
    "use strict";
    module2.exports = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);
    function setProtoOf(obj, proto) {
      obj.__proto__ = proto;
      return obj;
    }
    function mixinProperties(obj, proto) {
      for (var prop in proto) {
        if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
          obj[prop] = proto[prop];
        }
      }
      return obj;
    }
  }
});

// node_modules/statuses/codes.json
var require_codes = __commonJS({
  "node_modules/statuses/codes.json"(exports2, module2) {
    module2.exports = {
      "100": "Continue",
      "101": "Switching Protocols",
      "102": "Processing",
      "103": "Early Hints",
      "200": "OK",
      "201": "Created",
      "202": "Accepted",
      "203": "Non-Authoritative Information",
      "204": "No Content",
      "205": "Reset Content",
      "206": "Partial Content",
      "207": "Multi-Status",
      "208": "Already Reported",
      "226": "IM Used",
      "300": "Multiple Choices",
      "301": "Moved Permanently",
      "302": "Found",
      "303": "See Other",
      "304": "Not Modified",
      "305": "Use Proxy",
      "307": "Temporary Redirect",
      "308": "Permanent Redirect",
      "400": "Bad Request",
      "401": "Unauthorized",
      "402": "Payment Required",
      "403": "Forbidden",
      "404": "Not Found",
      "405": "Method Not Allowed",
      "406": "Not Acceptable",
      "407": "Proxy Authentication Required",
      "408": "Request Timeout",
      "409": "Conflict",
      "410": "Gone",
      "411": "Length Required",
      "412": "Precondition Failed",
      "413": "Payload Too Large",
      "414": "URI Too Long",
      "415": "Unsupported Media Type",
      "416": "Range Not Satisfiable",
      "417": "Expectation Failed",
      "418": "I'm a Teapot",
      "421": "Misdirected Request",
      "422": "Unprocessable Entity",
      "423": "Locked",
      "424": "Failed Dependency",
      "425": "Too Early",
      "426": "Upgrade Required",
      "428": "Precondition Required",
      "429": "Too Many Requests",
      "431": "Request Header Fields Too Large",
      "451": "Unavailable For Legal Reasons",
      "500": "Internal Server Error",
      "501": "Not Implemented",
      "502": "Bad Gateway",
      "503": "Service Unavailable",
      "504": "Gateway Timeout",
      "505": "HTTP Version Not Supported",
      "506": "Variant Also Negotiates",
      "507": "Insufficient Storage",
      "508": "Loop Detected",
      "509": "Bandwidth Limit Exceeded",
      "510": "Not Extended",
      "511": "Network Authentication Required"
    };
  }
});

// node_modules/statuses/index.js
var require_statuses = __commonJS({
  "node_modules/statuses/index.js"(exports2, module2) {
    "use strict";
    var codes = require_codes();
    module2.exports = status;
    status.message = codes;
    status.code = createMessageToStatusCodeMap(codes);
    status.codes = createStatusCodeList(codes);
    status.redirect = {
      300: true,
      301: true,
      302: true,
      303: true,
      305: true,
      307: true,
      308: true
    };
    status.empty = {
      204: true,
      205: true,
      304: true
    };
    status.retry = {
      502: true,
      503: true,
      504: true
    };
    function createMessageToStatusCodeMap(codes2) {
      var map3 = {};
      Object.keys(codes2).forEach(function forEachCode(code) {
        var message = codes2[code];
        var status2 = Number(code);
        map3[message.toLowerCase()] = status2;
      });
      return map3;
    }
    function createStatusCodeList(codes2) {
      return Object.keys(codes2).map(function mapCode(code) {
        return Number(code);
      });
    }
    function getStatusCode(message) {
      var msg = message.toLowerCase();
      if (!Object.prototype.hasOwnProperty.call(status.code, msg)) {
        throw new Error('invalid status message: "' + message + '"');
      }
      return status.code[msg];
    }
    function getStatusMessage(code) {
      if (!Object.prototype.hasOwnProperty.call(status.message, code)) {
        throw new Error("invalid status code: " + code);
      }
      return status.message[code];
    }
    function status(code) {
      if (typeof code === "number") {
        return getStatusMessage(code);
      }
      if (typeof code !== "string") {
        throw new TypeError("code must be a number or string");
      }
      var n = parseInt(code, 10);
      if (!isNaN(n)) {
        return getStatusMessage(n);
      }
      return getStatusCode(code);
    }
  }
});

// node_modules/inherits/inherits_browser.js
var require_inherits_browser = __commonJS({
  "node_modules/inherits/inherits_browser.js"(exports2, module2) {
    "use strict";
    if (typeof Object.create === "function") {
      module2.exports = function inherits2(ctor, superCtor) {
        if (superCtor) {
          ctor.super_ = superCtor;
          ctor.prototype = Object.create(superCtor.prototype, {
            constructor: {
              value: ctor,
              enumerable: false,
              writable: true,
              configurable: true
            }
          });
        }
      };
    } else {
      module2.exports = function inherits2(ctor, superCtor) {
        if (superCtor) {
          ctor.super_ = superCtor;
          var TempCtor = function() {
          };
          TempCtor.prototype = superCtor.prototype;
          ctor.prototype = new TempCtor();
          ctor.prototype.constructor = ctor;
        }
      };
    }
  }
});

// node_modules/inherits/inherits.js
var require_inherits = __commonJS({
  "node_modules/inherits/inherits.js"(exports2, module2) {
    "use strict";
    try {
      util4 = require("util");
      if (typeof util4.inherits !== "function") throw "";
      module2.exports = util4.inherits;
    } catch (e) {
      module2.exports = require_inherits_browser();
    }
    var util4;
  }
});

// node_modules/toidentifier/index.js
var require_toidentifier = __commonJS({
  "node_modules/toidentifier/index.js"(exports2, module2) {
    "use strict";
    module2.exports = toIdentifier;
    function toIdentifier(str) {
      return str.split(" ").map(function(token) {
        return token.slice(0, 1).toUpperCase() + token.slice(1);
      }).join("").replace(/[^ _0-9a-z]/gi, "");
    }
  }
});

// node_modules/http-errors/index.js
var require_http_errors = __commonJS({
  "node_modules/http-errors/index.js"(exports2, module2) {
    "use strict";
    var deprecate = require_depd()("http-errors");
    var setPrototypeOf = require_setprototypeof();
    var statuses = require_statuses();
    var inherits2 = require_inherits();
    var toIdentifier = require_toidentifier();
    module2.exports = createError;
    module2.exports.HttpError = createHttpErrorConstructor();
    module2.exports.isHttpError = createIsHttpErrorFunction(module2.exports.HttpError);
    populateConstructorExports(module2.exports, statuses.codes, module2.exports.HttpError);
    function codeClass(status) {
      return Number(String(status).charAt(0) + "00");
    }
    function createError() {
      var err;
      var msg;
      var status = 500;
      var props = {};
      for (var i = 0; i < arguments.length; i++) {
        var arg = arguments[i];
        var type = typeof arg;
        if (type === "object" && arg instanceof Error) {
          err = arg;
          status = err.status || err.statusCode || status;
        } else if (type === "number" && i === 0) {
          status = arg;
        } else if (type === "string") {
          msg = arg;
        } else if (type === "object") {
          props = arg;
        } else {
          throw new TypeError("argument #" + (i + 1) + " unsupported type " + type);
        }
      }
      if (typeof status === "number" && (status < 400 || status >= 600)) {
        deprecate("non-error status code; use only 4xx or 5xx status codes");
      }
      if (typeof status !== "number" || !statuses.message[status] && (status < 400 || status >= 600)) {
        status = 500;
      }
      var HttpError = createError[status] || createError[codeClass(status)];
      if (!err) {
        err = HttpError ? new HttpError(msg) : new Error(msg || statuses.message[status]);
        Error.captureStackTrace(err, createError);
      }
      if (!HttpError || !(err instanceof HttpError) || err.status !== status) {
        err.expose = status < 500;
        err.status = err.statusCode = status;
      }
      for (var key in props) {
        if (key !== "status" && key !== "statusCode") {
          err[key] = props[key];
        }
      }
      return err;
    }
    function createHttpErrorConstructor() {
      function HttpError() {
        throw new TypeError("cannot construct abstract class");
      }
      inherits2(HttpError, Error);
      return HttpError;
    }
    function createClientErrorConstructor(HttpError, name28, code) {
      var className = toClassName(name28);
      function ClientError(message) {
        var msg = message != null ? message : statuses.message[code];
        var err = new Error(msg);
        Error.captureStackTrace(err, ClientError);
        setPrototypeOf(err, ClientError.prototype);
        Object.defineProperty(err, "message", {
          enumerable: true,
          configurable: true,
          value: msg,
          writable: true
        });
        Object.defineProperty(err, "name", {
          enumerable: false,
          configurable: true,
          value: className,
          writable: true
        });
        return err;
      }
      inherits2(ClientError, HttpError);
      nameFunc(ClientError, className);
      ClientError.prototype.status = code;
      ClientError.prototype.statusCode = code;
      ClientError.prototype.expose = true;
      return ClientError;
    }
    function createIsHttpErrorFunction(HttpError) {
      return function isHttpError(val) {
        if (!val || typeof val !== "object") {
          return false;
        }
        if (val instanceof HttpError) {
          return true;
        }
        return val instanceof Error && typeof val.expose === "boolean" && typeof val.statusCode === "number" && val.status === val.statusCode;
      };
    }
    function createServerErrorConstructor(HttpError, name28, code) {
      var className = toClassName(name28);
      function ServerError(message) {
        var msg = message != null ? message : statuses.message[code];
        var err = new Error(msg);
        Error.captureStackTrace(err, ServerError);
        setPrototypeOf(err, ServerError.prototype);
        Object.defineProperty(err, "message", {
          enumerable: true,
          configurable: true,
          value: msg,
          writable: true
        });
        Object.defineProperty(err, "name", {
          enumerable: false,
          configurable: true,
          value: className,
          writable: true
        });
        return err;
      }
      inherits2(ServerError, HttpError);
      nameFunc(ServerError, className);
      ServerError.prototype.status = code;
      ServerError.prototype.statusCode = code;
      ServerError.prototype.expose = false;
      return ServerError;
    }
    function nameFunc(func, name28) {
      var desc = Object.getOwnPropertyDescriptor(func, "name");
      if (desc && desc.configurable) {
        desc.value = name28;
        Object.defineProperty(func, "name", desc);
      }
    }
    function populateConstructorExports(exports3, codes, HttpError) {
      codes.forEach(function forEachCode(code) {
        var CodeError;
        var name28 = toIdentifier(statuses.message[code]);
        switch (codeClass(code)) {
          case 400:
            CodeError = createClientErrorConstructor(HttpError, name28, code);
            break;
          case 500:
            CodeError = createServerErrorConstructor(HttpError, name28, code);
            break;
        }
        if (CodeError) {
          exports3[code] = CodeError;
          exports3[name28] = CodeError;
        }
      });
    }
    function toClassName(name28) {
      return name28.slice(-5) === "Error" ? name28 : name28 + "Error";
    }
  }
});

// node_modules/bytes/index.js
var require_bytes = __commonJS({
  "node_modules/bytes/index.js"(exports2, module2) {
    "use strict";
    module2.exports = bytes;
    module2.exports.format = format;
    module2.exports.parse = parse4;
    var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
    var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
    var map3 = {
      b: 1,
      kb: 1 << 10,
      mb: 1 << 20,
      gb: 1 << 30,
      tb: Math.pow(1024, 4),
      pb: Math.pow(1024, 5)
    };
    var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
    function bytes(value, options) {
      if (typeof value === "string") {
        return parse4(value);
      }
      if (typeof value === "number") {
        return format(value, options);
      }
      return null;
    }
    function format(value, options) {
      if (!Number.isFinite(value)) {
        return null;
      }
      var mag = Math.abs(value);
      var thousandsSeparator = options && options.thousandsSeparator || "";
      var unitSeparator = options && options.unitSeparator || "";
      var decimalPlaces = options && options.decimalPlaces !== void 0 ? options.decimalPlaces : 2;
      var fixedDecimals = Boolean(options && options.fixedDecimals);
      var unit = options && options.unit || "";
      if (!unit || !map3[unit.toLowerCase()]) {
        if (mag >= map3.pb) {
          unit = "PB";
        } else if (mag >= map3.tb) {
          unit = "TB";
        } else if (mag >= map3.gb) {
          unit = "GB";
        } else if (mag >= map3.mb) {
          unit = "MB";
        } else if (mag >= map3.kb) {
          unit = "KB";
        } else {
          unit = "B";
        }
      }
      var val = value / map3[unit.toLowerCase()];
      var str = val.toFixed(decimalPlaces);
      if (!fixedDecimals) {
        str = str.replace(formatDecimalsRegExp, "$1");
      }
      if (thousandsSeparator) {
        str = str.split(".").map(function(s, i) {
          return i === 0 ? s.replace(formatThousandsRegExp, thousandsSeparator) : s;
        }).join(".");
      }
      return str + unitSeparator + unit;
    }
    function parse4(val) {
      if (typeof val === "number" && !isNaN(val)) {
        return val;
      }
      if (typeof val !== "string") {
        return null;
      }
      var results = parseRegExp.exec(val);
      var floatValue;
      var unit = "b";
      if (!results) {
        floatValue = parseInt(val, 10);
        unit = "b";
      } else {
        floatValue = parseFloat(results[1]);
        unit = results[4].toLowerCase();
      }
      if (isNaN(floatValue)) {
        return null;
      }
      return Math.floor(map3[unit] * floatValue);
    }
  }
});

// node_modules/safer-buffer/safer.js
var require_safer = __commonJS({
  "node_modules/safer-buffer/safer.js"(exports2, module2) {
    "use strict";
    var buffer = require("buffer");
    var Buffer3 = buffer.Buffer;
    var safer = {};
    var key;
    for (key in buffer) {
      if (!buffer.hasOwnProperty(key)) continue;
      if (key === "SlowBuffer" || key === "Buffer") continue;
      safer[key] = buffer[key];
    }
    var Safer = safer.Buffer = {};
    for (key in Buffer3) {
      if (!Buffer3.hasOwnProperty(key)) continue;
      if (key === "allocUnsafe" || key === "allocUnsafeSlow") continue;
      Safer[key] = Buffer3[key];
    }
    safer.Buffer.prototype = Buffer3.prototype;
    if (!Safer.from || Safer.from === Uint8Array.from) {
      Safer.from = function(value, encodingOrOffset, length) {
        if (typeof value === "number") {
          throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value);
        }
        if (value && typeof value.length === "undefined") {
          throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
        }
        return Buffer3(value, encodingOrOffset, length);
      };
    }
    if (!Safer.alloc) {
      Safer.alloc = function(size, fill, encoding) {
        if (typeof size !== "number") {
          throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size);
        }
        if (size < 0 || size >= 2 * (1 << 30)) {
          throw new RangeError('The value "' + size + '" is invalid for option "size"');
        }
        var buf = Buffer3(size);
        if (!fill || fill.length === 0) {
          buf.fill(0);
        } else if (typeof encoding === "string") {
          buf.fill(fill, encoding);
        } else {
          buf.fill(fill);
        }
        return buf;
      };
    }
    if (!safer.kStringMaxLength) {
      try {
        safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
      } catch (e) {
      }
    }
    if (!safer.constants) {
      safer.constants = {
        MAX_LENGTH: safer.kMaxLength
      };
      if (safer.kStringMaxLength) {
        safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
      }
    }
    module2.exports = safer;
  }
});

// node_modules/iconv-lite/lib/bom-handling.js
var require_bom_handling = __commonJS({
  "node_modules/iconv-lite/lib/bom-handling.js"(exports2) {
    "use strict";
    var BOMChar = "\uFEFF";
    exports2.PrependBOM = PrependBOMWrapper;
    function PrependBOMWrapper(encoder, options) {
      this.encoder = encoder;
      this.addBOM = true;
    }
    PrependBOMWrapper.prototype.write = function(str) {
      if (this.addBOM) {
        str = BOMChar + str;
        this.addBOM = false;
      }
      return this.encoder.write(str);
    };
    PrependBOMWrapper.prototype.end = function() {
      return this.encoder.end();
    };
    exports2.StripBOM = StripBOMWrapper;
    function StripBOMWrapper(decoder, options) {
      this.decoder = decoder;
      this.pass = false;
      this.options = options || {};
    }
    StripBOMWrapper.prototype.write = function(buf) {
      var res = this.decoder.write(buf);
      if (this.pass || !res) {
        return res;
      }
      if (res[0] === BOMChar) {
        res = res.slice(1);
        if (typeof this.options.stripBOM === "function") {
          this.options.stripBOM();
        }
      }
      this.pass = true;
      return res;
    };
    StripBOMWrapper.prototype.end = function() {
      return this.decoder.end();
    };
  }
});

// node_modules/iconv-lite/lib/helpers/merge-exports.js
var require_merge_exports = __commonJS({
  "node_modules/iconv-lite/lib/helpers/merge-exports.js"(exports2, module2) {
    "use strict";
    var hasOwn = typeof Object.hasOwn === "undefined" ? Function.call.bind(Object.prototype.hasOwnProperty) : Object.hasOwn;
    function mergeModules(target, module3) {
      for (var key in module3) {
        if (hasOwn(module3, key)) {
          target[key] = module3[key];
        }
      }
    }
    module2.exports = mergeModules;
  }
});

// node_modules/iconv-lite/encodings/internal.js
var require_internal = __commonJS({
  "node_modules/iconv-lite/encodings/internal.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    module2.exports = {
      // Encodings
      utf8: { type: "_internal", bomAware: true },
      cesu8: { type: "_internal", bomAware: true },
      unicode11utf8: "utf8",
      ucs2: { type: "_internal", bomAware: true },
      utf16le: "ucs2",
      binary: { type: "_internal" },
      base64: { type: "_internal" },
      hex: { type: "_internal" },
      // Codec.
      _internal: InternalCodec
    };
    function InternalCodec(codecOptions, iconv) {
      this.enc = codecOptions.encodingName;
      this.bomAware = codecOptions.bomAware;
      if (this.enc === "base64") {
        this.encoder = InternalEncoderBase64;
      } else if (this.enc === "utf8") {
        this.encoder = InternalEncoderUtf8;
      } else if (this.enc === "cesu8") {
        this.enc = "utf8";
        this.encoder = InternalEncoderCesu8;
        if (Buffer3.from("eda0bdedb2a9", "hex").toString() !== "\u{1F4A9}") {
          this.decoder = InternalDecoderCesu8;
          this.defaultCharUnicode = iconv.defaultCharUnicode;
        }
      }
    }
    InternalCodec.prototype.encoder = InternalEncoder;
    InternalCodec.prototype.decoder = InternalDecoder;
    var StringDecoder = require("string_decoder").StringDecoder;
    function InternalDecoder(options, codec3) {
      this.decoder = new StringDecoder(codec3.enc);
    }
    InternalDecoder.prototype.write = function(buf) {
      if (!Buffer3.isBuffer(buf)) {
        buf = Buffer3.from(buf);
      }
      return this.decoder.write(buf);
    };
    InternalDecoder.prototype.end = function() {
      return this.decoder.end();
    };
    function InternalEncoder(options, codec3) {
      this.enc = codec3.enc;
    }
    InternalEncoder.prototype.write = function(str) {
      return Buffer3.from(str, this.enc);
    };
    InternalEncoder.prototype.end = function() {
    };
    function InternalEncoderBase64(options, codec3) {
      this.prevStr = "";
    }
    InternalEncoderBase64.prototype.write = function(str) {
      str = this.prevStr + str;
      var completeQuads = str.length - str.length % 4;
      this.prevStr = str.slice(completeQuads);
      str = str.slice(0, completeQuads);
      return Buffer3.from(str, "base64");
    };
    InternalEncoderBase64.prototype.end = function() {
      return Buffer3.from(this.prevStr, "base64");
    };
    function InternalEncoderCesu8(options, codec3) {
    }
    InternalEncoderCesu8.prototype.write = function(str) {
      var buf = Buffer3.alloc(str.length * 3);
      var bufIdx = 0;
      for (var i = 0; i < str.length; i++) {
        var charCode = str.charCodeAt(i);
        if (charCode < 128) {
          buf[bufIdx++] = charCode;
        } else if (charCode < 2048) {
          buf[bufIdx++] = 192 + (charCode >>> 6);
          buf[bufIdx++] = 128 + (charCode & 63);
        } else {
          buf[bufIdx++] = 224 + (charCode >>> 12);
          buf[bufIdx++] = 128 + (charCode >>> 6 & 63);
          buf[bufIdx++] = 128 + (charCode & 63);
        }
      }
      return buf.slice(0, bufIdx);
    };
    InternalEncoderCesu8.prototype.end = function() {
    };
    function InternalDecoderCesu8(options, codec3) {
      this.acc = 0;
      this.contBytes = 0;
      this.accBytes = 0;
      this.defaultCharUnicode = codec3.defaultCharUnicode;
    }
    InternalDecoderCesu8.prototype.write = function(buf) {
      var acc = this.acc;
      var contBytes = this.contBytes;
      var accBytes = this.accBytes;
      var res = "";
      for (var i = 0; i < buf.length; i++) {
        var curByte = buf[i];
        if ((curByte & 192) !== 128) {
          if (contBytes > 0) {
            res += this.defaultCharUnicode;
            contBytes = 0;
          }
          if (curByte < 128) {
            res += String.fromCharCode(curByte);
          } else if (curByte < 224) {
            acc = curByte & 31;
            contBytes = 1;
            accBytes = 1;
          } else if (curByte < 240) {
            acc = curByte & 15;
            contBytes = 2;
            accBytes = 1;
          } else {
            res += this.defaultCharUnicode;
          }
        } else {
          if (contBytes > 0) {
            acc = acc << 6 | curByte & 63;
            contBytes--;
            accBytes++;
            if (contBytes === 0) {
              if (accBytes === 2 && acc < 128 && acc > 0) {
                res += this.defaultCharUnicode;
              } else if (accBytes === 3 && acc < 2048) {
                res += this.defaultCharUnicode;
              } else {
                res += String.fromCharCode(acc);
              }
            }
          } else {
            res += this.defaultCharUnicode;
          }
        }
      }
      this.acc = acc;
      this.contBytes = contBytes;
      this.accBytes = accBytes;
      return res;
    };
    InternalDecoderCesu8.prototype.end = function() {
      var res = 0;
      if (this.contBytes > 0) {
        res += this.defaultCharUnicode;
      }
      return res;
    };
    function InternalEncoderUtf8(options, codec3) {
      this.highSurrogate = "";
    }
    InternalEncoderUtf8.prototype.write = function(str) {
      if (this.highSurrogate) {
        str = this.highSurrogate + str;
        this.highSurrogate = "";
      }
      if (str.length > 0) {
        var charCode = str.charCodeAt(str.length - 1);
        if (charCode >= 55296 && charCode < 56320) {
          this.highSurrogate = str[str.length - 1];
          str = str.slice(0, str.length - 1);
        }
      }
      return Buffer3.from(str, this.enc);
    };
    InternalEncoderUtf8.prototype.end = function() {
      if (this.highSurrogate) {
        var str = this.highSurrogate;
        this.highSurrogate = "";
        return Buffer3.from(str, this.enc);
      }
    };
  }
});

// node_modules/iconv-lite/encodings/utf32.js
var require_utf32 = __commonJS({
  "node_modules/iconv-lite/encodings/utf32.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2._utf32 = Utf32Codec;
    function Utf32Codec(codecOptions, iconv) {
      this.iconv = iconv;
      this.bomAware = true;
      this.isLE = codecOptions.isLE;
    }
    exports2.utf32le = { type: "_utf32", isLE: true };
    exports2.utf32be = { type: "_utf32", isLE: false };
    exports2.ucs4le = "utf32le";
    exports2.ucs4be = "utf32be";
    Utf32Codec.prototype.encoder = Utf32Encoder;
    Utf32Codec.prototype.decoder = Utf32Decoder;
    function Utf32Encoder(options, codec3) {
      this.isLE = codec3.isLE;
      this.highSurrogate = 0;
    }
    Utf32Encoder.prototype.write = function(str) {
      var src = Buffer3.from(str, "ucs2");
      var dst = Buffer3.alloc(src.length * 2);
      var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;
      var offset = 0;
      for (var i = 0; i < src.length; i += 2) {
        var code = src.readUInt16LE(i);
        var isHighSurrogate = code >= 55296 && code < 56320;
        var isLowSurrogate = code >= 56320 && code < 57344;
        if (this.highSurrogate) {
          if (isHighSurrogate || !isLowSurrogate) {
            write32.call(dst, this.highSurrogate, offset);
            offset += 4;
          } else {
            var codepoint = (this.highSurrogate - 55296 << 10 | code - 56320) + 65536;
            write32.call(dst, codepoint, offset);
            offset += 4;
            this.highSurrogate = 0;
            continue;
          }
        }
        if (isHighSurrogate) {
          this.highSurrogate = code;
        } else {
          write32.call(dst, code, offset);
          offset += 4;
          this.highSurrogate = 0;
        }
      }
      if (offset < dst.length) {
        dst = dst.slice(0, offset);
      }
      return dst;
    };
    Utf32Encoder.prototype.end = function() {
      if (!this.highSurrogate) {
        return;
      }
      var buf = Buffer3.alloc(4);
      if (this.isLE) {
        buf.writeUInt32LE(this.highSurrogate, 0);
      } else {
        buf.writeUInt32BE(this.highSurrogate, 0);
      }
      this.highSurrogate = 0;
      return buf;
    };
    function Utf32Decoder(options, codec3) {
      this.isLE = codec3.isLE;
      this.badChar = codec3.iconv.defaultCharUnicode.charCodeAt(0);
      this.overflow = [];
    }
    Utf32Decoder.prototype.write = function(src) {
      if (src.length === 0) {
        return "";
      }
      var i = 0;
      var codepoint = 0;
      var dst = Buffer3.alloc(src.length + 4);
      var offset = 0;
      var isLE = this.isLE;
      var overflow = this.overflow;
      var badChar = this.badChar;
      if (overflow.length > 0) {
        for (; i < src.length && overflow.length < 4; i++) {
          overflow.push(src[i]);
        }
        if (overflow.length === 4) {
          if (isLE) {
            codepoint = overflow[i] | overflow[i + 1] << 8 | overflow[i + 2] << 16 | overflow[i + 3] << 24;
          } else {
            codepoint = overflow[i + 3] | overflow[i + 2] << 8 | overflow[i + 1] << 16 | overflow[i] << 24;
          }
          overflow.length = 0;
          offset = _writeCodepoint(dst, offset, codepoint, badChar);
        }
      }
      for (; i < src.length - 3; i += 4) {
        if (isLE) {
          codepoint = src[i] | src[i + 1] << 8 | src[i + 2] << 16 | src[i + 3] << 24;
        } else {
          codepoint = src[i + 3] | src[i + 2] << 8 | src[i + 1] << 16 | src[i] << 24;
        }
        offset = _writeCodepoint(dst, offset, codepoint, badChar);
      }
      for (; i < src.length; i++) {
        overflow.push(src[i]);
      }
      return dst.slice(0, offset).toString("ucs2");
    };
    function _writeCodepoint(dst, offset, codepoint, badChar) {
      if (codepoint < 0 || codepoint > 1114111) {
        codepoint = badChar;
      }
      if (codepoint >= 65536) {
        codepoint -= 65536;
        var high = 55296 | codepoint >> 10;
        dst[offset++] = high & 255;
        dst[offset++] = high >> 8;
        var codepoint = 56320 | codepoint & 1023;
      }
      dst[offset++] = codepoint & 255;
      dst[offset++] = codepoint >> 8;
      return offset;
    }
    Utf32Decoder.prototype.end = function() {
      this.overflow.length = 0;
    };
    exports2.utf32 = Utf32AutoCodec;
    exports2.ucs4 = "utf32";
    function Utf32AutoCodec(options, iconv) {
      this.iconv = iconv;
    }
    Utf32AutoCodec.prototype.encoder = Utf32AutoEncoder;
    Utf32AutoCodec.prototype.decoder = Utf32AutoDecoder;
    function Utf32AutoEncoder(options, codec3) {
      options = options || {};
      if (options.addBOM === void 0) {
        options.addBOM = true;
      }
      this.encoder = codec3.iconv.getEncoder(options.defaultEncoding || "utf-32le", options);
    }
    Utf32AutoEncoder.prototype.write = function(str) {
      return this.encoder.write(str);
    };
    Utf32AutoEncoder.prototype.end = function() {
      return this.encoder.end();
    };
    function Utf32AutoDecoder(options, codec3) {
      this.decoder = null;
      this.initialBufs = [];
      this.initialBufsLen = 0;
      this.options = options || {};
      this.iconv = codec3.iconv;
    }
    Utf32AutoDecoder.prototype.write = function(buf) {
      if (!this.decoder) {
        this.initialBufs.push(buf);
        this.initialBufsLen += buf.length;
        if (this.initialBufsLen < 32) {
          return "";
        }
        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var resStr = "";
        for (var i = 0; i < this.initialBufs.length; i++) {
          resStr += this.decoder.write(this.initialBufs[i]);
        }
        this.initialBufs.length = this.initialBufsLen = 0;
        return resStr;
      }
      return this.decoder.write(buf);
    };
    Utf32AutoDecoder.prototype.end = function() {
      if (!this.decoder) {
        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var resStr = "";
        for (var i = 0; i < this.initialBufs.length; i++) {
          resStr += this.decoder.write(this.initialBufs[i]);
        }
        var trail = this.decoder.end();
        if (trail) {
          resStr += trail;
        }
        this.initialBufs.length = this.initialBufsLen = 0;
        return resStr;
      }
      return this.decoder.end();
    };
    function detectEncoding(bufs, defaultEncoding) {
      var b = [];
      var charsProcessed = 0;
      var invalidLE = 0;
      var invalidBE = 0;
      var bmpCharsLE = 0;
      var bmpCharsBE = 0;
      outerLoop:
        for (var i = 0; i < bufs.length; i++) {
          var buf = bufs[i];
          for (var j = 0; j < buf.length; j++) {
            b.push(buf[j]);
            if (b.length === 4) {
              if (charsProcessed === 0) {
                if (b[0] === 255 && b[1] === 254 && b[2] === 0 && b[3] === 0) {
                  return "utf-32le";
                }
                if (b[0] === 0 && b[1] === 0 && b[2] === 254 && b[3] === 255) {
                  return "utf-32be";
                }
              }
              if (b[0] !== 0 || b[1] > 16) invalidBE++;
              if (b[3] !== 0 || b[2] > 16) invalidLE++;
              if (b[0] === 0 && b[1] === 0 && (b[2] !== 0 || b[3] !== 0)) bmpCharsBE++;
              if ((b[0] !== 0 || b[1] !== 0) && b[2] === 0 && b[3] === 0) bmpCharsLE++;
              b.length = 0;
              charsProcessed++;
              if (charsProcessed >= 100) {
                break outerLoop;
              }
            }
          }
        }
      if (bmpCharsBE - invalidBE > bmpCharsLE - invalidLE) return "utf-32be";
      if (bmpCharsBE - invalidBE < bmpCharsLE - invalidLE) return "utf-32le";
      return defaultEncoding || "utf-32le";
    }
  }
});

// node_modules/iconv-lite/encodings/utf16.js
var require_utf16 = __commonJS({
  "node_modules/iconv-lite/encodings/utf16.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2.utf16be = Utf16BECodec;
    function Utf16BECodec() {
    }
    Utf16BECodec.prototype.encoder = Utf16BEEncoder;
    Utf16BECodec.prototype.decoder = Utf16BEDecoder;
    Utf16BECodec.prototype.bomAware = true;
    function Utf16BEEncoder() {
    }
    Utf16BEEncoder.prototype.write = function(str) {
      var buf = Buffer3.from(str, "ucs2");
      for (var i = 0; i < buf.length; i += 2) {
        var tmp = buf[i];
        buf[i] = buf[i + 1];
        buf[i + 1] = tmp;
      }
      return buf;
    };
    Utf16BEEncoder.prototype.end = function() {
    };
    function Utf16BEDecoder() {
      this.overflowByte = -1;
    }
    Utf16BEDecoder.prototype.write = function(buf) {
      if (buf.length == 0) {
        return "";
      }
      var buf2 = Buffer3.alloc(buf.length + 1);
      var i = 0;
      var j = 0;
      if (this.overflowByte !== -1) {
        buf2[0] = buf[0];
        buf2[1] = this.overflowByte;
        i = 1;
        j = 2;
      }
      for (; i < buf.length - 1; i += 2, j += 2) {
        buf2[j] = buf[i + 1];
        buf2[j + 1] = buf[i];
      }
      this.overflowByte = i == buf.length - 1 ? buf[buf.length - 1] : -1;
      return buf2.slice(0, j).toString("ucs2");
    };
    Utf16BEDecoder.prototype.end = function() {
      this.overflowByte = -1;
    };
    exports2.utf16 = Utf16Codec;
    function Utf16Codec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    Utf16Codec.prototype.encoder = Utf16Encoder;
    Utf16Codec.prototype.decoder = Utf16Decoder;
    function Utf16Encoder(options, codec3) {
      options = options || {};
      if (options.addBOM === void 0) {
        options.addBOM = true;
      }
      this.encoder = codec3.iconv.getEncoder("utf-16le", options);
    }
    Utf16Encoder.prototype.write = function(str) {
      return this.encoder.write(str);
    };
    Utf16Encoder.prototype.end = function() {
      return this.encoder.end();
    };
    function Utf16Decoder(options, codec3) {
      this.decoder = null;
      this.initialBufs = [];
      this.initialBufsLen = 0;
      this.options = options || {};
      this.iconv = codec3.iconv;
    }
    Utf16Decoder.prototype.write = function(buf) {
      if (!this.decoder) {
        this.initialBufs.push(buf);
        this.initialBufsLen += buf.length;
        if (this.initialBufsLen < 16) {
          return "";
        }
        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var resStr = "";
        for (var i = 0; i < this.initialBufs.length; i++) {
          resStr += this.decoder.write(this.initialBufs[i]);
        }
        this.initialBufs.length = this.initialBufsLen = 0;
        return resStr;
      }
      return this.decoder.write(buf);
    };
    Utf16Decoder.prototype.end = function() {
      if (!this.decoder) {
        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var resStr = "";
        for (var i = 0; i < this.initialBufs.length; i++) {
          resStr += this.decoder.write(this.initialBufs[i]);
        }
        var trail = this.decoder.end();
        if (trail) {
          resStr += trail;
        }
        this.initialBufs.length = this.initialBufsLen = 0;
        return resStr;
      }
      return this.decoder.end();
    };
    function detectEncoding(bufs, defaultEncoding) {
      var b = [];
      var charsProcessed = 0;
      var asciiCharsLE = 0;
      var asciiCharsBE = 0;
      outerLoop:
        for (var i = 0; i < bufs.length; i++) {
          var buf = bufs[i];
          for (var j = 0; j < buf.length; j++) {
            b.push(buf[j]);
            if (b.length === 2) {
              if (charsProcessed === 0) {
                if (b[0] === 255 && b[1] === 254) return "utf-16le";
                if (b[0] === 254 && b[1] === 255) return "utf-16be";
              }
              if (b[0] === 0 && b[1] !== 0) asciiCharsBE++;
              if (b[0] !== 0 && b[1] === 0) asciiCharsLE++;
              b.length = 0;
              charsProcessed++;
              if (charsProcessed >= 100) {
                break outerLoop;
              }
            }
          }
        }
      if (asciiCharsBE > asciiCharsLE) return "utf-16be";
      if (asciiCharsBE < asciiCharsLE) return "utf-16le";
      return defaultEncoding || "utf-16le";
    }
  }
});

// node_modules/iconv-lite/encodings/utf7.js
var require_utf7 = __commonJS({
  "node_modules/iconv-lite/encodings/utf7.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2.utf7 = Utf7Codec;
    exports2.unicode11utf7 = "utf7";
    function Utf7Codec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    Utf7Codec.prototype.encoder = Utf7Encoder;
    Utf7Codec.prototype.decoder = Utf7Decoder;
    Utf7Codec.prototype.bomAware = true;
    var nonDirectChars = /[^A-Za-z0-9'\(\),-\.\/:\? \n\r\t]+/g;
    function Utf7Encoder(options, codec3) {
      this.iconv = codec3.iconv;
    }
    Utf7Encoder.prototype.write = function(str) {
      return Buffer3.from(str.replace(nonDirectChars, function(chunk) {
        return "+" + (chunk === "+" ? "" : this.iconv.encode(chunk, "utf16-be").toString("base64").replace(/=+$/, "")) + "-";
      }.bind(this)));
    };
    Utf7Encoder.prototype.end = function() {
    };
    function Utf7Decoder(options, codec3) {
      this.iconv = codec3.iconv;
      this.inBase64 = false;
      this.base64Accum = "";
    }
    var base64Regex2 = /[A-Za-z0-9\/+]/;
    var base64Chars = [];
    for (i = 0; i < 256; i++) {
      base64Chars[i] = base64Regex2.test(String.fromCharCode(i));
    }
    var i;
    var plusChar = "+".charCodeAt(0);
    var minusChar = "-".charCodeAt(0);
    var andChar = "&".charCodeAt(0);
    Utf7Decoder.prototype.write = function(buf) {
      var res = "";
      var lastI = 0;
      var inBase64 = this.inBase64;
      var base64Accum = this.base64Accum;
      for (var i2 = 0; i2 < buf.length; i2++) {
        if (!inBase64) {
          if (buf[i2] == plusChar) {
            res += this.iconv.decode(buf.slice(lastI, i2), "ascii");
            lastI = i2 + 1;
            inBase64 = true;
          }
        } else {
          if (!base64Chars[buf[i2]]) {
            if (i2 == lastI && buf[i2] == minusChar) {
              res += "+";
            } else {
              var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), "ascii");
              res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
            }
            if (buf[i2] != minusChar) {
              i2--;
            }
            lastI = i2 + 1;
            inBase64 = false;
            base64Accum = "";
          }
        }
      }
      if (!inBase64) {
        res += this.iconv.decode(buf.slice(lastI), "ascii");
      } else {
        var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii");
        var canBeDecoded = b64str.length - b64str.length % 8;
        base64Accum = b64str.slice(canBeDecoded);
        b64str = b64str.slice(0, canBeDecoded);
        res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
      }
      this.inBase64 = inBase64;
      this.base64Accum = base64Accum;
      return res;
    };
    Utf7Decoder.prototype.end = function() {
      var res = "";
      if (this.inBase64 && this.base64Accum.length > 0) {
        res = this.iconv.decode(Buffer3.from(this.base64Accum, "base64"), "utf16-be");
      }
      this.inBase64 = false;
      this.base64Accum = "";
      return res;
    };
    exports2.utf7imap = Utf7IMAPCodec;
    function Utf7IMAPCodec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;
    Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;
    Utf7IMAPCodec.prototype.bomAware = true;
    function Utf7IMAPEncoder(options, codec3) {
      this.iconv = codec3.iconv;
      this.inBase64 = false;
      this.base64Accum = Buffer3.alloc(6);
      this.base64AccumIdx = 0;
    }
    Utf7IMAPEncoder.prototype.write = function(str) {
      var inBase64 = this.inBase64;
      var base64Accum = this.base64Accum;
      var base64AccumIdx = this.base64AccumIdx;
      var buf = Buffer3.alloc(str.length * 5 + 10);
      var bufIdx = 0;
      for (var i2 = 0; i2 < str.length; i2++) {
        var uChar = str.charCodeAt(i2);
        if (uChar >= 32 && uChar <= 126) {
          if (inBase64) {
            if (base64AccumIdx > 0) {
              bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
              base64AccumIdx = 0;
            }
            buf[bufIdx++] = minusChar;
            inBase64 = false;
          }
          if (!inBase64) {
            buf[bufIdx++] = uChar;
            if (uChar === andChar) {
              buf[bufIdx++] = minusChar;
            }
          }
        } else {
          if (!inBase64) {
            buf[bufIdx++] = andChar;
            inBase64 = true;
          }
          if (inBase64) {
            base64Accum[base64AccumIdx++] = uChar >> 8;
            base64Accum[base64AccumIdx++] = uChar & 255;
            if (base64AccumIdx == base64Accum.length) {
              bufIdx += buf.write(base64Accum.toString("base64").replace(/\//g, ","), bufIdx);
              base64AccumIdx = 0;
            }
          }
        }
      }
      this.inBase64 = inBase64;
      this.base64AccumIdx = base64AccumIdx;
      return buf.slice(0, bufIdx);
    };
    Utf7IMAPEncoder.prototype.end = function() {
      var buf = Buffer3.alloc(10);
      var bufIdx = 0;
      if (this.inBase64) {
        if (this.base64AccumIdx > 0) {
          bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
          this.base64AccumIdx = 0;
        }
        buf[bufIdx++] = minusChar;
        this.inBase64 = false;
      }
      return buf.slice(0, bufIdx);
    };
    function Utf7IMAPDecoder(options, codec3) {
      this.iconv = codec3.iconv;
      this.inBase64 = false;
      this.base64Accum = "";
    }
    var base64IMAPChars = base64Chars.slice();
    base64IMAPChars[",".charCodeAt(0)] = true;
    Utf7IMAPDecoder.prototype.write = function(buf) {
      var res = "";
      var lastI = 0;
      var inBase64 = this.inBase64;
      var base64Accum = this.base64Accum;
      for (var i2 = 0; i2 < buf.length; i2++) {
        if (!inBase64) {
          if (buf[i2] == andChar) {
            res += this.iconv.decode(buf.slice(lastI, i2), "ascii");
            lastI = i2 + 1;
            inBase64 = true;
          }
        } else {
          if (!base64IMAPChars[buf[i2]]) {
            if (i2 == lastI && buf[i2] == minusChar) {
              res += "&";
            } else {
              var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), "ascii").replace(/,/g, "/");
              res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
            }
            if (buf[i2] != minusChar) {
              i2--;
            }
            lastI = i2 + 1;
            inBase64 = false;
            base64Accum = "";
          }
        }
      }
      if (!inBase64) {
        res += this.iconv.decode(buf.slice(lastI), "ascii");
      } else {
        var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii").replace(/,/g, "/");
        var canBeDecoded = b64str.length - b64str.length % 8;
        base64Accum = b64str.slice(canBeDecoded);
        b64str = b64str.slice(0, canBeDecoded);
        res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
      }
      this.inBase64 = inBase64;
      this.base64Accum = base64Accum;
      return res;
    };
    Utf7IMAPDecoder.prototype.end = function() {
      var res = "";
      if (this.inBase64 && this.base64Accum.length > 0) {
        res = this.iconv.decode(Buffer3.from(this.base64Accum, "base64"), "utf16-be");
      }
      this.inBase64 = false;
      this.base64Accum = "";
      return res;
    };
  }
});

// node_modules/iconv-lite/encodings/sbcs-codec.js
var require_sbcs_codec = __commonJS({
  "node_modules/iconv-lite/encodings/sbcs-codec.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2._sbcs = SBCSCodec;
    function SBCSCodec(codecOptions, iconv) {
      if (!codecOptions) {
        throw new Error("SBCS codec is called without the data.");
      }
      if (!codecOptions.chars || codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256) {
        throw new Error("Encoding '" + codecOptions.type + "' has incorrect 'chars' (must be of len 128 or 256)");
      }
      if (codecOptions.chars.length === 128) {
        var asciiString = "";
        for (var i = 0; i < 128; i++) {
          asciiString += String.fromCharCode(i);
        }
        codecOptions.chars = asciiString + codecOptions.chars;
      }
      this.decodeBuf = Buffer3.from(codecOptions.chars, "ucs2");
      var encodeBuf = Buffer3.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0));
      for (var i = 0; i < codecOptions.chars.length; i++) {
        encodeBuf[codecOptions.chars.charCodeAt(i)] = i;
      }
      this.encodeBuf = encodeBuf;
    }
    SBCSCodec.prototype.encoder = SBCSEncoder;
    SBCSCodec.prototype.decoder = SBCSDecoder;
    function SBCSEncoder(options, codec3) {
      this.encodeBuf = codec3.encodeBuf;
    }
    SBCSEncoder.prototype.write = function(str) {
      var buf = Buffer3.alloc(str.length);
      for (var i = 0; i < str.length; i++) {
        buf[i] = this.encodeBuf[str.charCodeAt(i)];
      }
      return buf;
    };
    SBCSEncoder.prototype.end = function() {
    };
    function SBCSDecoder(options, codec3) {
      this.decodeBuf = codec3.decodeBuf;
    }
    SBCSDecoder.prototype.write = function(buf) {
      var decodeBuf = this.decodeBuf;
      var newBuf = Buffer3.alloc(buf.length * 2);
      var idx1 = 0;
      var idx2 = 0;
      for (var i = 0; i < buf.length; i++) {
        idx1 = buf[i] * 2;
        idx2 = i * 2;
        newBuf[idx2] = decodeBuf[idx1];
        newBuf[idx2 + 1] = decodeBuf[idx1 + 1];
      }
      return newBuf.toString("ucs2");
    };
    SBCSDecoder.prototype.end = function() {
    };
  }
});

// node_modules/iconv-lite/encodings/sbcs-data.js
var require_sbcs_data = __commonJS({
  "node_modules/iconv-lite/encodings/sbcs-data.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      // Not supported by iconv, not sure why.
      10029: "maccenteuro",
      maccenteuro: {
        type: "_sbcs",
        chars: "\xC4\u0100\u0101\xC9\u0104\xD6\xDC\xE1\u0105\u010C\xE4\u010D\u0106\u0107\xE9\u0179\u017A\u010E\xED\u010F\u0112\u0113\u0116\xF3\u0117\xF4\xF6\xF5\xFA\u011A\u011B\xFC\u2020\xB0\u0118\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\u0119\xA8\u2260\u0123\u012E\u012F\u012A\u2264\u2265\u012B\u0136\u2202\u2211\u0142\u013B\u013C\u013D\u013E\u0139\u013A\u0145\u0146\u0143\xAC\u221A\u0144\u0147\u2206\xAB\xBB\u2026\xA0\u0148\u0150\xD5\u0151\u014C\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\u014D\u0154\u0155\u0158\u2039\u203A\u0159\u0156\u0157\u0160\u201A\u201E\u0161\u015A\u015B\xC1\u0164\u0165\xCD\u017D\u017E\u016A\xD3\xD4\u016B\u016E\xDA\u016F\u0170\u0171\u0172\u0173\xDD\xFD\u0137\u017B\u0141\u017C\u0122\u02C7"
      },
      808: "cp808",
      ibm808: "cp808",
      cp808: {
        type: "_sbcs",
        chars: "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0404\u0454\u0407\u0457\u040E\u045E\xB0\u2219\xB7\u221A\u2116\u20AC\u25A0\xA0"
      },
      mik: {
        type: "_sbcs",
        chars: "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2514\u2534\u252C\u251C\u2500\u253C\u2563\u2551\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2510\u2591\u2592\u2593\u2502\u2524\u2116\xA7\u2557\u255D\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      cp720: {
        type: "_sbcs",
        chars: "\x80\x81\xE9\xE2\x84\xE0\x86\xE7\xEA\xEB\xE8\xEF\xEE\x8D\x8E\x8F\x90\u0651\u0652\xF4\xA4\u0640\xFB\xF9\u0621\u0622\u0623\u0624\xA3\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0636\u0637\u0638\u0639\u063A\u0641\xB5\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u2261\u064B\u064C\u064D\u064E\u064F\u0650\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      // Aliases of generated encodings.
      ascii8bit: "ascii",
      usascii: "ascii",
      ansix34: "ascii",
      ansix341968: "ascii",
      ansix341986: "ascii",
      csascii: "ascii",
      cp367: "ascii",
      ibm367: "ascii",
      isoir6: "ascii",
      iso646us: "ascii",
      iso646irv: "ascii",
      us: "ascii",
      latin1: "iso88591",
      latin2: "iso88592",
      latin3: "iso88593",
      latin4: "iso88594",
      latin5: "iso88599",
      latin6: "iso885910",
      latin7: "iso885913",
      latin8: "iso885914",
      latin9: "iso885915",
      latin10: "iso885916",
      csisolatin1: "iso88591",
      csisolatin2: "iso88592",
      csisolatin3: "iso88593",
      csisolatin4: "iso88594",
      csisolatincyrillic: "iso88595",
      csisolatinarabic: "iso88596",
      csisolatingreek: "iso88597",
      csisolatinhebrew: "iso88598",
      csisolatin5: "iso88599",
      csisolatin6: "iso885910",
      l1: "iso88591",
      l2: "iso88592",
      l3: "iso88593",
      l4: "iso88594",
      l5: "iso88599",
      l6: "iso885910",
      l7: "iso885913",
      l8: "iso885914",
      l9: "iso885915",
      l10: "iso885916",
      isoir14: "iso646jp",
      isoir57: "iso646cn",
      isoir100: "iso88591",
      isoir101: "iso88592",
      isoir109: "iso88593",
      isoir110: "iso88594",
      isoir144: "iso88595",
      isoir127: "iso88596",
      isoir126: "iso88597",
      isoir138: "iso88598",
      isoir148: "iso88599",
      isoir157: "iso885910",
      isoir166: "tis620",
      isoir179: "iso885913",
      isoir199: "iso885914",
      isoir203: "iso885915",
      isoir226: "iso885916",
      cp819: "iso88591",
      ibm819: "iso88591",
      cyrillic: "iso88595",
      arabic: "iso88596",
      arabic8: "iso88596",
      ecma114: "iso88596",
      asmo708: "iso88596",
      greek: "iso88597",
      greek8: "iso88597",
      ecma118: "iso88597",
      elot928: "iso88597",
      hebrew: "iso88598",
      hebrew8: "iso88598",
      turkish: "iso88599",
      turkish8: "iso88599",
      thai: "iso885911",
      thai8: "iso885911",
      celtic: "iso885914",
      celtic8: "iso885914",
      isoceltic: "iso885914",
      tis6200: "tis620",
      tis62025291: "tis620",
      tis62025330: "tis620",
      1e4: "macroman",
      10006: "macgreek",
      10007: "maccyrillic",
      10079: "maciceland",
      10081: "macturkish",
      cspc8codepage437: "cp437",
      cspc775baltic: "cp775",
      cspc850multilingual: "cp850",
      cspcp852: "cp852",
      cspc862latinhebrew: "cp862",
      cpgr: "cp869",
      msee: "cp1250",
      mscyrl: "cp1251",
      msansi: "cp1252",
      msgreek: "cp1253",
      msturk: "cp1254",
      mshebr: "cp1255",
      msarab: "cp1256",
      winbaltrim: "cp1257",
      cp20866: "koi8r",
      20866: "koi8r",
      ibm878: "koi8r",
      cskoi8r: "koi8r",
      cp21866: "koi8u",
      21866: "koi8u",
      ibm1168: "koi8u",
      strk10482002: "rk1048",
      tcvn5712: "tcvn",
      tcvn57121: "tcvn",
      gb198880: "iso646cn",
      cn: "iso646cn",
      csiso14jisc6220ro: "iso646jp",
      jisc62201969ro: "iso646jp",
      jp: "iso646jp",
      cshproman8: "hproman8",
      r8: "hproman8",
      roman8: "hproman8",
      xroman8: "hproman8",
      ibm1051: "hproman8",
      mac: "macintosh",
      csmacintosh: "macintosh"
    };
  }
});

// node_modules/iconv-lite/encodings/sbcs-data-generated.js
var require_sbcs_data_generated = __commonJS({
  "node_modules/iconv-lite/encodings/sbcs-data-generated.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      "437": "cp437",
      "737": "cp737",
      "775": "cp775",
      "850": "cp850",
      "852": "cp852",
      "855": "cp855",
      "856": "cp856",
      "857": "cp857",
      "858": "cp858",
      "860": "cp860",
      "861": "cp861",
      "862": "cp862",
      "863": "cp863",
      "864": "cp864",
      "865": "cp865",
      "866": "cp866",
      "869": "cp869",
      "874": "windows874",
      "922": "cp922",
      "1046": "cp1046",
      "1124": "cp1124",
      "1125": "cp1125",
      "1129": "cp1129",
      "1133": "cp1133",
      "1161": "cp1161",
      "1162": "cp1162",
      "1163": "cp1163",
      "1250": "windows1250",
      "1251": "windows1251",
      "1252": "windows1252",
      "1253": "windows1253",
      "1254": "windows1254",
      "1255": "windows1255",
      "1256": "windows1256",
      "1257": "windows1257",
      "1258": "windows1258",
      "28591": "iso88591",
      "28592": "iso88592",
      "28593": "iso88593",
      "28594": "iso88594",
      "28595": "iso88595",
      "28596": "iso88596",
      "28597": "iso88597",
      "28598": "iso88598",
      "28599": "iso88599",
      "28600": "iso885910",
      "28601": "iso885911",
      "28603": "iso885913",
      "28604": "iso885914",
      "28605": "iso885915",
      "28606": "iso885916",
      "windows874": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\uFFFD\uFFFD\uFFFD\u2026\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "win874": "windows874",
      "cp874": "windows874",
      "windows1250": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\u0160\u2039\u015A\u0164\u017D\u0179\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0161\u203A\u015B\u0165\u017E\u017A\xA0\u02C7\u02D8\u0141\xA4\u0104\xA6\xA7\xA8\xA9\u015E\xAB\xAC\xAD\xAE\u017B\xB0\xB1\u02DB\u0142\xB4\xB5\xB6\xB7\xB8\u0105\u015F\xBB\u013D\u02DD\u013E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9"
      },
      "win1250": "windows1250",
      "cp1250": "windows1250",
      "windows1251": {
        "type": "_sbcs",
        "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u040C\u040B\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u045C\u045B\u045F\xA0\u040E\u045E\u0408\xA4\u0490\xA6\xA7\u0401\xA9\u0404\xAB\xAC\xAD\xAE\u0407\xB0\xB1\u0406\u0456\u0491\xB5\xB6\xB7\u0451\u2116\u0454\xBB\u0458\u0405\u0455\u0457\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
      },
      "win1251": "windows1251",
      "cp1251": "windows1251",
      "windows1252": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\u017D\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\u017E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "win1252": "windows1252",
      "cp1252": "windows1252",
      "windows1253": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0385\u0386\xA3\xA4\xA5\xA6\xA7\xA8\xA9\uFFFD\xAB\xAC\xAD\xAE\u2015\xB0\xB1\xB2\xB3\u0384\xB5\xB6\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD"
      },
      "win1253": "windows1253",
      "cp1253": "windows1253",
      "windows1254": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF"
      },
      "win1254": "windows1254",
      "cp1254": "windows1254",
      "windows1255": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\xA1\xA2\xA3\u20AA\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\xBF\u05B0\u05B1\u05B2\u05B3\u05B4\u05B5\u05B6\u05B7\u05B8\u05B9\u05BA\u05BB\u05BC\u05BD\u05BE\u05BF\u05C0\u05C1\u05C2\u05C3\u05F0\u05F1\u05F2\u05F3\u05F4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD"
      },
      "win1255": "windows1255",
      "cp1255": "windows1255",
      "windows1256": {
        "type": "_sbcs",
        "chars": "\u20AC\u067E\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0679\u2039\u0152\u0686\u0698\u0688\u06AF\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u06A9\u2122\u0691\u203A\u0153\u200C\u200D\u06BA\xA0\u060C\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\u06BE\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\u061B\xBB\xBC\xBD\xBE\u061F\u06C1\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\xD7\u0637\u0638\u0639\u063A\u0640\u0641\u0642\u0643\xE0\u0644\xE2\u0645\u0646\u0647\u0648\xE7\xE8\xE9\xEA\xEB\u0649\u064A\xEE\xEF\u064B\u064C\u064D\u064E\xF4\u064F\u0650\xF7\u0651\xF9\u0652\xFB\xFC\u200E\u200F\u06D2"
      },
      "win1256": "windows1256",
      "cp1256": "windows1256",
      "windows1257": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\xA8\u02C7\xB8\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\xAF\u02DB\uFFFD\xA0\uFFFD\xA2\xA3\xA4\uFFFD\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u02D9"
      },
      "win1257": "windows1257",
      "cp1257": "windows1257",
      "windows1258": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
      },
      "win1258": "windows1258",
      "cp1258": "windows1258",
      "iso88591": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "cp28591": "iso88591",
      "iso88592": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u02D8\u0141\xA4\u013D\u015A\xA7\xA8\u0160\u015E\u0164\u0179\xAD\u017D\u017B\xB0\u0105\u02DB\u0142\xB4\u013E\u015B\u02C7\xB8\u0161\u015F\u0165\u017A\u02DD\u017E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9"
      },
      "cp28592": "iso88592",
      "iso88593": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0126\u02D8\xA3\xA4\uFFFD\u0124\xA7\xA8\u0130\u015E\u011E\u0134\xAD\uFFFD\u017B\xB0\u0127\xB2\xB3\xB4\xB5\u0125\xB7\xB8\u0131\u015F\u011F\u0135\xBD\uFFFD\u017C\xC0\xC1\xC2\uFFFD\xC4\u010A\u0108\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\uFFFD\xD1\xD2\xD3\xD4\u0120\xD6\xD7\u011C\xD9\xDA\xDB\xDC\u016C\u015C\xDF\xE0\xE1\xE2\uFFFD\xE4\u010B\u0109\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\uFFFD\xF1\xF2\xF3\xF4\u0121\xF6\xF7\u011D\xF9\xFA\xFB\xFC\u016D\u015D\u02D9"
      },
      "cp28593": "iso88593",
      "iso88594": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0138\u0156\xA4\u0128\u013B\xA7\xA8\u0160\u0112\u0122\u0166\xAD\u017D\xAF\xB0\u0105\u02DB\u0157\xB4\u0129\u013C\u02C7\xB8\u0161\u0113\u0123\u0167\u014A\u017E\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\u012A\u0110\u0145\u014C\u0136\xD4\xD5\xD6\xD7\xD8\u0172\xDA\xDB\xDC\u0168\u016A\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\u012B\u0111\u0146\u014D\u0137\xF4\xF5\xF6\xF7\xF8\u0173\xFA\xFB\xFC\u0169\u016B\u02D9"
      },
      "cp28594": "iso88594",
      "iso88595": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0403\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0453\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F"
      },
      "cp28595": "iso88595",
      "iso88596": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\uFFFD\uFFFD\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u060C\xAD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u061B\uFFFD\uFFFD\uFFFD\u061F\uFFFD\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\u0638\u0639\u063A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "cp28596": "iso88596",
      "iso88597": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u2018\u2019\xA3\u20AC\u20AF\xA6\xA7\xA8\xA9\u037A\xAB\xAC\xAD\uFFFD\u2015\xB0\xB1\xB2\xB3\u0384\u0385\u0386\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD"
      },
      "cp28597": "iso88597",
      "iso88598": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2017\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD"
      },
      "cp28598": "iso88598",
      "iso88599": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF"
      },
      "cp28599": "iso88599",
      "iso885910": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0112\u0122\u012A\u0128\u0136\xA7\u013B\u0110\u0160\u0166\u017D\xAD\u016A\u014A\xB0\u0105\u0113\u0123\u012B\u0129\u0137\xB7\u013C\u0111\u0161\u0167\u017E\u2015\u016B\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\xCF\xD0\u0145\u014C\xD3\xD4\xD5\xD6\u0168\xD8\u0172\xDA\xDB\xDC\xDD\xDE\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\xEF\xF0\u0146\u014D\xF3\xF4\xF5\xF6\u0169\xF8\u0173\xFA\xFB\xFC\xFD\xFE\u0138"
      },
      "cp28600": "iso885910",
      "iso885911": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "cp28601": "iso885911",
      "iso885913": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u201D\xA2\xA3\xA4\u201E\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\u201C\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u2019"
      },
      "cp28603": "iso885913",
      "iso885914": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u1E02\u1E03\xA3\u010A\u010B\u1E0A\xA7\u1E80\xA9\u1E82\u1E0B\u1EF2\xAD\xAE\u0178\u1E1E\u1E1F\u0120\u0121\u1E40\u1E41\xB6\u1E56\u1E81\u1E57\u1E83\u1E60\u1EF3\u1E84\u1E85\u1E61\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0174\xD1\xD2\xD3\xD4\xD5\xD6\u1E6A\xD8\xD9\xDA\xDB\xDC\xDD\u0176\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0175\xF1\xF2\xF3\xF4\xF5\xF6\u1E6B\xF8\xF9\xFA\xFB\xFC\xFD\u0177\xFF"
      },
      "cp28604": "iso885914",
      "iso885915": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\u0160\xA7\u0161\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u017D\xB5\xB6\xB7\u017E\xB9\xBA\xBB\u0152\u0153\u0178\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "cp28605": "iso885915",
      "iso885916": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0105\u0141\u20AC\u201E\u0160\xA7\u0161\xA9\u0218\xAB\u0179\xAD\u017A\u017B\xB0\xB1\u010C\u0142\u017D\u201D\xB6\xB7\u017E\u010D\u0219\xBB\u0152\u0153\u0178\u017C\xC0\xC1\xC2\u0102\xC4\u0106\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0110\u0143\xD2\xD3\xD4\u0150\xD6\u015A\u0170\xD9\xDA\xDB\xDC\u0118\u021A\xDF\xE0\xE1\xE2\u0103\xE4\u0107\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0111\u0144\xF2\xF3\xF4\u0151\xF6\u015B\u0171\xF9\xFA\xFB\xFC\u0119\u021B\xFF"
      },
      "cp28606": "iso885916",
      "cp437": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm437": "cp437",
      "csibm437": "cp437",
      "cp737": {
        "type": "_sbcs",
        "chars": "\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u03C5\u03C6\u03C7\u03C8\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03C9\u03AC\u03AD\u03AE\u03CA\u03AF\u03CC\u03CD\u03CB\u03CE\u0386\u0388\u0389\u038A\u038C\u038E\u038F\xB1\u2265\u2264\u03AA\u03AB\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm737": "cp737",
      "csibm737": "cp737",
      "cp775": {
        "type": "_sbcs",
        "chars": "\u0106\xFC\xE9\u0101\xE4\u0123\xE5\u0107\u0142\u0113\u0156\u0157\u012B\u0179\xC4\xC5\xC9\xE6\xC6\u014D\xF6\u0122\xA2\u015A\u015B\xD6\xDC\xF8\xA3\xD8\xD7\xA4\u0100\u012A\xF3\u017B\u017C\u017A\u201D\xA6\xA9\xAE\xAC\xBD\xBC\u0141\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0104\u010C\u0118\u0116\u2563\u2551\u2557\u255D\u012E\u0160\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0172\u016A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u017D\u0105\u010D\u0119\u0117\u012F\u0161\u0173\u016B\u017E\u2518\u250C\u2588\u2584\u258C\u2590\u2580\xD3\xDF\u014C\u0143\xF5\xD5\xB5\u0144\u0136\u0137\u013B\u013C\u0146\u0112\u0145\u2019\xAD\xB1\u201C\xBE\xB6\xA7\xF7\u201E\xB0\u2219\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm775": "cp775",
      "csibm775": "cp775",
      "cp850": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u0131\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm850": "cp850",
      "csibm850": "cp850",
      "cp852": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\u016F\u0107\xE7\u0142\xEB\u0150\u0151\xEE\u0179\xC4\u0106\xC9\u0139\u013A\xF4\xF6\u013D\u013E\u015A\u015B\xD6\xDC\u0164\u0165\u0141\xD7\u010D\xE1\xED\xF3\xFA\u0104\u0105\u017D\u017E\u0118\u0119\xAC\u017A\u010C\u015F\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\u011A\u015E\u2563\u2551\u2557\u255D\u017B\u017C\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0102\u0103\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u0111\u0110\u010E\xCB\u010F\u0147\xCD\xCE\u011B\u2518\u250C\u2588\u2584\u0162\u016E\u2580\xD3\xDF\xD4\u0143\u0144\u0148\u0160\u0161\u0154\xDA\u0155\u0170\xFD\xDD\u0163\xB4\xAD\u02DD\u02DB\u02C7\u02D8\xA7\xF7\xB8\xB0\xA8\u02D9\u0171\u0158\u0159\u25A0\xA0"
      },
      "ibm852": "cp852",
      "csibm852": "cp852",
      "cp855": {
        "type": "_sbcs",
        "chars": "\u0452\u0402\u0453\u0403\u0451\u0401\u0454\u0404\u0455\u0405\u0456\u0406\u0457\u0407\u0458\u0408\u0459\u0409\u045A\u040A\u045B\u040B\u045C\u040C\u045E\u040E\u045F\u040F\u044E\u042E\u044A\u042A\u0430\u0410\u0431\u0411\u0446\u0426\u0434\u0414\u0435\u0415\u0444\u0424\u0433\u0413\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0445\u0425\u0438\u0418\u2563\u2551\u2557\u255D\u0439\u0419\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u043A\u041A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u043B\u041B\u043C\u041C\u043D\u041D\u043E\u041E\u043F\u2518\u250C\u2588\u2584\u041F\u044F\u2580\u042F\u0440\u0420\u0441\u0421\u0442\u0422\u0443\u0423\u0436\u0416\u0432\u0412\u044C\u042C\u2116\xAD\u044B\u042B\u0437\u0417\u0448\u0428\u044D\u042D\u0449\u0429\u0447\u0427\xA7\u25A0\xA0"
      },
      "ibm855": "cp855",
      "csibm855": "cp855",
      "cp856": {
        "type": "_sbcs",
        "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\xA3\uFFFD\xD7\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAE\xAC\xBD\xBC\uFFFD\xAB\xBB\u2591\u2592\u2593\u2502\u2524\uFFFD\uFFFD\uFFFD\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\uFFFD\uFFFD\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2518\u250C\u2588\u2584\xA6\uFFFD\u2580\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xB5\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm856": "cp856",
      "csibm856": "cp856",
      "cp857": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\u0131\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\u0130\xD6\xDC\xF8\xA3\xD8\u015E\u015F\xE1\xED\xF3\xFA\xF1\xD1\u011E\u011F\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xBA\xAA\xCA\xCB\xC8\uFFFD\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\uFFFD\xD7\xDA\xDB\xD9\xEC\xFF\xAF\xB4\xAD\xB1\uFFFD\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm857": "cp857",
      "csibm857": "cp857",
      "cp858": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u20AC\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm858": "cp858",
      "csibm858": "cp858",
      "cp860": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE3\xE0\xC1\xE7\xEA\xCA\xE8\xCD\xD4\xEC\xC3\xC2\xC9\xC0\xC8\xF4\xF5\xF2\xDA\xF9\xCC\xD5\xDC\xA2\xA3\xD9\u20A7\xD3\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xD2\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm860": "cp860",
      "csibm860": "cp860",
      "cp861": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xD0\xF0\xDE\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xFE\xFB\xDD\xFD\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xC1\xCD\xD3\xDA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm861": "cp861",
      "csibm861": "cp861",
      "cp862": {
        "type": "_sbcs",
        "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm862": "cp862",
      "csibm862": "cp862",
      "cp863": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xC2\xE0\xB6\xE7\xEA\xEB\xE8\xEF\xEE\u2017\xC0\xA7\xC9\xC8\xCA\xF4\xCB\xCF\xFB\xF9\xA4\xD4\xDC\xA2\xA3\xD9\xDB\u0192\xA6\xB4\xF3\xFA\xA8\xB8\xB3\xAF\xCE\u2310\xAC\xBD\xBC\xBE\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm863": "cp863",
      "csibm863": "cp863",
      "cp864": {
        "type": "_sbcs",
        "chars": "\0
\x07\b	\n\v\f\r\x1B !\"#$\u066A&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xB0\xB7\u2219\u221A\u2592\u2500\u2502\u253C\u2524\u252C\u251C\u2534\u2510\u250C\u2514\u2518\u03B2\u221E\u03C6\xB1\xBD\xBC\u2248\xAB\xBB\uFEF7\uFEF8\uFFFD\uFFFD\uFEFB\uFEFC\uFFFD\xA0\xAD\uFE82\xA3\xA4\uFE84\uFFFD\uFFFD\uFE8E\uFE8F\uFE95\uFE99\u060C\uFE9D\uFEA1\uFEA5\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFED1\u061B\uFEB1\uFEB5\uFEB9\u061F\xA2\uFE80\uFE81\uFE83\uFE85\uFECA\uFE8B\uFE8D\uFE91\uFE93\uFE97\uFE9B\uFE9F\uFEA3\uFEA7\uFEA9\uFEAB\uFEAD\uFEAF\uFEB3\uFEB7\uFEBB\uFEBF\uFEC1\uFEC5\uFECB\uFECF\xA6\xAC\xF7\xD7\uFEC9\u0640\uFED3\uFED7\uFEDB\uFEDF\uFEE3\uFEE7\uFEEB\uFEED\uFEEF\uFEF3\uFEBD\uFECC\uFECE\uFECD\uFEE1\uFE7D\u0651\uFEE5\uFEE9\uFEEC\uFEF0\uFEF2\uFED0\uFED5\uFEF5\uFEF6\uFEDD\uFED9\uFEF1\u25A0\uFFFD"
      },
      "ibm864": "cp864",
      "csibm864": "cp864",
      "cp865": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xA4\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm865": "cp865",
      "csibm865": "cp865",
      "cp866": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0404\u0454\u0407\u0457\u040E\u045E\xB0\u2219\xB7\u221A\u2116\xA4\u25A0\xA0"
      },
      "ibm866": "cp866",
      "csibm866": "cp866",
      "cp869": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0386\uFFFD\xB7\xAC\xA6\u2018\u2019\u0388\u2015\u0389\u038A\u03AA\u038C\uFFFD\uFFFD\u038E\u03AB\xA9\u038F\xB2\xB3\u03AC\xA3\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03CD\u0391\u0392\u0393\u0394\u0395\u0396\u0397\xBD\u0398\u0399\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u039A\u039B\u039C\u039D\u2563\u2551\u2557\u255D\u039E\u039F\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u03A0\u03A1\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u2518\u250C\u2588\u2584\u03B4\u03B5\u2580\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u0384\xAD\xB1\u03C5\u03C6\u03C7\xA7\u03C8\u0385\xB0\xA8\u03C9\u03CB\u03B0\u03CE\u25A0\xA0"
      },
      "ibm869": "cp869",
      "csibm869": "cp869",
      "cp922": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\u203E\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0160\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\u017D\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0161\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\u017E\xFF"
      },
      "ibm922": "cp922",
      "csibm922": "cp922",
      "cp1046": {
        "type": "_sbcs",
        "chars": "\uFE88\xD7\xF7\uF8F6\uF8F5\uF8F4\uF8F7\uFE71\x88\u25A0\u2502\u2500\u2510\u250C\u2514\u2518\uFE79\uFE7B\uFE7D\uFE7F\uFE77\uFE8A\uFEF0\uFEF3\uFEF2\uFECE\uFECF\uFED0\uFEF6\uFEF8\uFEFA\uFEFC\xA0\uF8FA\uF8F9\uF8F8\xA4\uF8FB\uFE8B\uFE91\uFE97\uFE9B\uFE9F\uFEA3\u060C\xAD\uFEA7\uFEB3\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFEB7\u061B\uFEBB\uFEBF\uFECA\u061F\uFECB\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\uFEC7\u0639\u063A\uFECC\uFE82\uFE84\uFE8E\uFED3\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFED7\uFEDB\uFEDF\uF8FC\uFEF5\uFEF7\uFEF9\uFEFB\uFEE3\uFEE7\uFEEC\uFEE9\uFFFD"
      },
      "ibm1046": "cp1046",
      "csibm1046": "cp1046",
      "cp1124": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0490\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0491\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F"
      },
      "ibm1124": "cp1124",
      "csibm1124": "cp1124",
      "cp1125": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0490\u0491\u0404\u0454\u0406\u0456\u0407\u0457\xB7\u221A\u2116\xA4\u25A0\xA0"
      },
      "ibm1125": "cp1125",
      "csibm1125": "cp1125",
      "cp1129": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
      },
      "ibm1129": "cp1129",
      "csibm1129": "cp1129",
      "cp1133": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E81\u0E82\u0E84\u0E87\u0E88\u0EAA\u0E8A\u0E8D\u0E94\u0E95\u0E96\u0E97\u0E99\u0E9A\u0E9B\u0E9C\u0E9D\u0E9E\u0E9F\u0EA1\u0EA2\u0EA3\u0EA5\u0EA7\u0EAB\u0EAD\u0EAE\uFFFD\uFFFD\uFFFD\u0EAF\u0EB0\u0EB2\u0EB3\u0EB4\u0EB5\u0EB6\u0EB7\u0EB8\u0EB9\u0EBC\u0EB1\u0EBB\u0EBD\uFFFD\uFFFD\uFFFD\u0EC0\u0EC1\u0EC2\u0EC3\u0EC4\u0EC8\u0EC9\u0ECA\u0ECB\u0ECC\u0ECD\u0EC6\uFFFD\u0EDC\u0EDD\u20AD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0ED0\u0ED1\u0ED2\u0ED3\u0ED4\u0ED5\u0ED6\u0ED7\u0ED8\u0ED9\uFFFD\uFFFD\xA2\xAC\xA6\uFFFD"
      },
      "ibm1133": "cp1133",
      "csibm1133": "cp1133",
      "cp1161": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E48\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\u0E49\u0E4A\u0E4B\u20AC\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\xA2\xAC\xA6\xA0"
      },
      "ibm1161": "cp1161",
      "csibm1161": "cp1161",
      "cp1162": {
        "type": "_sbcs",
        "chars": "\u20AC\x81\x82\x83\x84\u2026\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "ibm1162": "cp1162",
      "csibm1162": "cp1162",
      "cp1163": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
      },
      "ibm1163": "cp1163",
      "csibm1163": "cp1163",
      "maccroatian": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\u0160\u2122\xB4\xA8\u2260\u017D\xD8\u221E\xB1\u2264\u2265\u2206\xB5\u2202\u2211\u220F\u0161\u222B\xAA\xBA\u2126\u017E\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u0106\xAB\u010C\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u0110\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\uFFFD\xA9\u2044\xA4\u2039\u203A\xC6\xBB\u2013\xB7\u201A\u201E\u2030\xC2\u0107\xC1\u010D\xC8\xCD\xCE\xCF\xCC\xD3\xD4\u0111\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u03C0\xCB\u02DA\xB8\xCA\xE6\u02C7"
      },
      "maccyrillic": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\xA2\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u2202\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4"
      },
      "macgreek": {
        "type": "_sbcs",
        "chars": "\xC4\xB9\xB2\xC9\xB3\xD6\xDC\u0385\xE0\xE2\xE4\u0384\xA8\xE7\xE9\xE8\xEA\xEB\xA3\u2122\xEE\xEF\u2022\xBD\u2030\xF4\xF6\xA6\xAD\xF9\xFB\xFC\u2020\u0393\u0394\u0398\u039B\u039E\u03A0\xDF\xAE\xA9\u03A3\u03AA\xA7\u2260\xB0\u0387\u0391\xB1\u2264\u2265\xA5\u0392\u0395\u0396\u0397\u0399\u039A\u039C\u03A6\u03AB\u03A8\u03A9\u03AC\u039D\xAC\u039F\u03A1\u2248\u03A4\xAB\xBB\u2026\xA0\u03A5\u03A7\u0386\u0388\u0153\u2013\u2015\u201C\u201D\u2018\u2019\xF7\u0389\u038A\u038C\u038E\u03AD\u03AE\u03AF\u03CC\u038F\u03CD\u03B1\u03B2\u03C8\u03B4\u03B5\u03C6\u03B3\u03B7\u03B9\u03BE\u03BA\u03BB\u03BC\u03BD\u03BF\u03C0\u03CE\u03C1\u03C3\u03C4\u03B8\u03C9\u03C2\u03C7\u03C5\u03B6\u03CA\u03CB\u0390\u03B0\uFFFD"
      },
      "maciceland": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\xDD\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\xD0\xF0\xDE\xFE\xFD\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macroman": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macromania": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\u0102\u015E\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\u0103\u015F\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\u0162\u0163\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macthai": {
        "type": "_sbcs",
        "chars": "\xAB\xBB\u2026\uF88C\uF88F\uF892\uF895\uF898\uF88B\uF88E\uF891\uF894\uF897\u201C\u201D\uF899\uFFFD\u2022\uF884\uF889\uF885\uF886\uF887\uF888\uF88A\uF88D\uF890\uF893\uF896\u2018\u2019\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFEFF\u200B\u2013\u2014\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u2122\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\xAE\xA9\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "macturkish": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u011E\u011F\u0130\u0131\u015E\u015F\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\uFFFD\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macukraine": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\u0490\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u0491\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4"
      },
      "koi8r": {
        "type": "_sbcs",
        "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u2553\u2554\u2555\u2556\u2557\u2558\u2559\u255A\u255B\u255C\u255D\u255E\u255F\u2560\u2561\u0401\u2562\u2563\u2564\u2565\u2566\u2567\u2568\u2569\u256A\u256B\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "koi8u": {
        "type": "_sbcs",
        "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u255D\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "koi8ru": {
        "type": "_sbcs",
        "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u045E\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u040E\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "koi8t": {
        "type": "_sbcs",
        "chars": "\u049B\u0493\u201A\u0492\u201E\u2026\u2020\u2021\uFFFD\u2030\u04B3\u2039\u04B2\u04B7\u04B6\uFFFD\u049A\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u04EF\u04EE\u0451\xA4\u04E3\xA6\xA7\uFFFD\uFFFD\uFFFD\xAB\xAC\xAD\xAE\uFFFD\xB0\xB1\xB2\u0401\uFFFD\u04E2\xB6\xB7\uFFFD\u2116\uFFFD\xBB\uFFFD\uFFFD\uFFFD\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "armscii8": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\u0587\u0589)(\xBB\xAB\u2014.\u055D,-\u058A\u2026\u055C\u055B\u055E\u0531\u0561\u0532\u0562\u0533\u0563\u0534\u0564\u0535\u0565\u0536\u0566\u0537\u0567\u0538\u0568\u0539\u0569\u053A\u056A\u053B\u056B\u053C\u056C\u053D\u056D\u053E\u056E\u053F\u056F\u0540\u0570\u0541\u0571\u0542\u0572\u0543\u0573\u0544\u0574\u0545\u0575\u0546\u0576\u0547\u0577\u0548\u0578\u0549\u0579\u054A\u057A\u054B\u057B\u054C\u057C\u054D\u057D\u054E\u057E\u054F\u057F\u0550\u0580\u0551\u0581\u0552\u0582\u0553\u0583\u0554\u0584\u0555\u0585\u0556\u0586\u055A\uFFFD"
      },
      "rk1048": {
        "type": "_sbcs",
        "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u049A\u04BA\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u049B\u04BB\u045F\xA0\u04B0\u04B1\u04D8\xA4\u04E8\xA6\xA7\u0401\xA9\u0492\xAB\xAC\xAD\xAE\u04AE\xB0\xB1\u0406\u0456\u04E9\xB5\xB6\xB7\u0451\u2116\u0493\xBB\u04D9\u04A2\u04A3\u04AF\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
      },
      "tcvn": {
        "type": "_sbcs",
        "chars": "\0\xDA\u1EE4\u1EEA\u1EEC\u1EEE\x07\b	\n\v\f\r\u1EE8\u1EF0\u1EF2\u1EF6\u1EF8\xDD\u1EF4\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xC0\u1EA2\xC3\xC1\u1EA0\u1EB6\u1EAC\xC8\u1EBA\u1EBC\xC9\u1EB8\u1EC6\xCC\u1EC8\u0128\xCD\u1ECA\xD2\u1ECE\xD5\xD3\u1ECC\u1ED8\u1EDC\u1EDE\u1EE0\u1EDA\u1EE2\xD9\u1EE6\u0168\xA0\u0102\xC2\xCA\xD4\u01A0\u01AF\u0110\u0103\xE2\xEA\xF4\u01A1\u01B0\u0111\u1EB0\u0300\u0309\u0303\u0301\u0323\xE0\u1EA3\xE3\xE1\u1EA1\u1EB2\u1EB1\u1EB3\u1EB5\u1EAF\u1EB4\u1EAE\u1EA6\u1EA8\u1EAA\u1EA4\u1EC0\u1EB7\u1EA7\u1EA9\u1EAB\u1EA5\u1EAD\xE8\u1EC2\u1EBB\u1EBD\xE9\u1EB9\u1EC1\u1EC3\u1EC5\u1EBF\u1EC7\xEC\u1EC9\u1EC4\u1EBE\u1ED2\u0129\xED\u1ECB\xF2\u1ED4\u1ECF\xF5\xF3\u1ECD\u1ED3\u1ED5\u1ED7\u1ED1\u1ED9\u1EDD\u1EDF\u1EE1\u1EDB\u1EE3\xF9\u1ED6\u1EE7\u0169\xFA\u1EE5\u1EEB\u1EED\u1EEF\u1EE9\u1EF1\u1EF3\u1EF7\u1EF9\xFD\u1EF5\u1ED0"
      },
      "georgianacademy": {
        "type": "_sbcs",
        "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10EF\u10F0\u10F1\u10F2\u10F3\u10F4\u10F5\u10F6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "georgianps": {
        "type": "_sbcs",
        "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10F1\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10F2\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10F3\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10F4\u10EF\u10F0\u10F5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "pt154": {
        "type": "_sbcs",
        "chars": "\u0496\u0492\u04EE\u0493\u201E\u2026\u04B6\u04AE\u04B2\u04AF\u04A0\u04E2\u04A2\u049A\u04BA\u04B8\u0497\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u04B3\u04B7\u04A1\u04E3\u04A3\u049B\u04BB\u04B9\xA0\u040E\u045E\u0408\u04E8\u0498\u04B0\xA7\u0401\xA9\u04D8\xAB\xAC\u04EF\xAE\u049C\xB0\u04B1\u0406\u0456\u0499\u04E9\xB6\xB7\u0451\u2116\u04D9\xBB\u0458\u04AA\u04AB\u049D\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
      },
      "viscii": {
        "type": "_sbcs",
        "chars": "\0
\u1EB2\u1EB4\u1EAA\x07\b	\n\v\f\r\u1EF6\u1EF8\x1B\u1EF4 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\u1EA0\u1EAE\u1EB0\u1EB6\u1EA4\u1EA6\u1EA8\u1EAC\u1EBC\u1EB8\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EE2\u1EDA\u1EDC\u1EDE\u1ECA\u1ECE\u1ECC\u1EC8\u1EE6\u0168\u1EE4\u1EF2\xD5\u1EAF\u1EB1\u1EB7\u1EA5\u1EA7\u1EA9\u1EAD\u1EBD\u1EB9\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1ED1\u1ED3\u1ED5\u1ED7\u1EE0\u01A0\u1ED9\u1EDD\u1EDF\u1ECB\u1EF0\u1EE8\u1EEA\u1EEC\u01A1\u1EDB\u01AF\xC0\xC1\xC2\xC3\u1EA2\u0102\u1EB3\u1EB5\xC8\xC9\xCA\u1EBA\xCC\xCD\u0128\u1EF3\u0110\u1EE9\xD2\xD3\xD4\u1EA1\u1EF7\u1EEB\u1EED\xD9\xDA\u1EF9\u1EF5\xDD\u1EE1\u01B0\xE0\xE1\xE2\xE3\u1EA3\u0103\u1EEF\u1EAB\xE8\xE9\xEA\u1EBB\xEC\xED\u0129\u1EC9\u0111\u1EF1\xF2\xF3\xF4\xF5\u1ECF\u1ECD\u1EE5\xF9\xFA\u0169\u1EE7\xFD\u1EE3\u1EEE"
      },
      "iso646cn": {
        "type": "_sbcs",
        "chars": "\0
\x07\b	\n\v\f\r\x1B !\"#\xA5%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "iso646jp": {
        "type": "_sbcs",
        "chars": "\0
\x07\b	\n\v\f\r\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\xA5]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "hproman8": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xC0\xC2\xC8\xCA\xCB\xCE\xCF\xB4\u02CB\u02C6\xA8\u02DC\xD9\xDB\u20A4\xAF\xDD\xFD\xB0\xC7\xE7\xD1\xF1\xA1\xBF\xA4\xA3\xA5\xA7\u0192\xA2\xE2\xEA\xF4\xFB\xE1\xE9\xF3\xFA\xE0\xE8\xF2\xF9\xE4\xEB\xF6\xFC\xC5\xEE\xD8\xC6\xE5\xED\xF8\xE6\xC4\xEC\xD6\xDC\xC9\xEF\xDF\xD4\xC1\xC3\xE3\xD0\xF0\xCD\xCC\xD3\xD2\xD5\xF5\u0160\u0161\xDA\u0178\xFF\xDE\xFE\xB7\xB5\xB6\xBE\u2014\xBC\xBD\xAA\xBA\xAB\u25A0\xBB\xB1\uFFFD"
      },
      "macintosh": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "ascii": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "tis620": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      }
    };
  }
});

// node_modules/iconv-lite/encodings/dbcs-codec.js
var require_dbcs_codec = __commonJS({
  "node_modules/iconv-lite/encodings/dbcs-codec.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2._dbcs = DBCSCodec;
    var UNASSIGNED = -1;
    var GB18030_CODE = -2;
    var SEQ_START = -10;
    var NODE_START = -1e3;
    var UNASSIGNED_NODE = new Array(256);
    var DEF_CHAR = -1;
    for (i = 0; i < 256; i++) {
      UNASSIGNED_NODE[i] = UNASSIGNED;
    }
    var i;
    function DBCSCodec(codecOptions, iconv) {
      this.encodingName = codecOptions.encodingName;
      if (!codecOptions) {
        throw new Error("DBCS codec is called without the data.");
      }
      if (!codecOptions.table) {
        throw new Error("Encoding '" + this.encodingName + "' has no data.");
      }
      var mappingTable = codecOptions.table();
      this.decodeTables = [];
      this.decodeTables[0] = UNASSIGNED_NODE.slice(0);
      this.decodeTableSeq = [];
      for (var i2 = 0; i2 < mappingTable.length; i2++) {
        this._addDecodeChunk(mappingTable[i2]);
      }
      if (typeof codecOptions.gb18030 === "function") {
        this.gb18030 = codecOptions.gb18030();
        var commonThirdByteNodeIdx = this.decodeTables.length;
        this.decodeTables.push(UNASSIGNED_NODE.slice(0));
        var commonFourthByteNodeIdx = this.decodeTables.length;
        this.decodeTables.push(UNASSIGNED_NODE.slice(0));
        var firstByteNode = this.decodeTables[0];
        for (var i2 = 129; i2 <= 254; i2++) {
          var secondByteNode = this.decodeTables[NODE_START - firstByteNode[i2]];
          for (var j = 48; j <= 57; j++) {
            if (secondByteNode[j] === UNASSIGNED) {
              secondByteNode[j] = NODE_START - commonThirdByteNodeIdx;
            } else if (secondByteNode[j] > NODE_START) {
              throw new Error("gb18030 decode tables conflict at byte 2");
            }
            var thirdByteNode = this.decodeTables[NODE_START - secondByteNode[j]];
            for (var k = 129; k <= 254; k++) {
              if (thirdByteNode[k] === UNASSIGNED) {
                thirdByteNode[k] = NODE_START - commonFourthByteNodeIdx;
              } else if (thirdByteNode[k] === NODE_START - commonFourthByteNodeIdx) {
                continue;
              } else if (thirdByteNode[k] > NODE_START) {
                throw new Error("gb18030 decode tables conflict at byte 3");
              }
              var fourthByteNode = this.decodeTables[NODE_START - thirdByteNode[k]];
              for (var l = 48; l <= 57; l++) {
                if (fourthByteNode[l] === UNASSIGNED) {
                  fourthByteNode[l] = GB18030_CODE;
                }
              }
            }
          }
        }
      }
      this.defaultCharUnicode = iconv.defaultCharUnicode;
      this.encodeTable = [];
      this.encodeTableSeq = [];
      var skipEncodeChars = {};
      if (codecOptions.encodeSkipVals) {
        for (var i2 = 0; i2 < codecOptions.encodeSkipVals.length; i2++) {
          var val = codecOptions.encodeSkipVals[i2];
          if (typeof val === "number") {
            skipEncodeChars[val] = true;
          } else {
            for (var j = val.from; j <= val.to; j++) {
              skipEncodeChars[j] = true;
            }
          }
        }
      }
      this._fillEncodeTable(0, 0, skipEncodeChars);
      if (codecOptions.encodeAdd) {
        for (var uChar in codecOptions.encodeAdd) {
          if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar)) {
            this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]);
          }
        }
      }
      this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)];
      if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]["?"];
      if (this.defCharSB === UNASSIGNED) this.defCharSB = "?".charCodeAt(0);
    }
    DBCSCodec.prototype.encoder = DBCSEncoder;
    DBCSCodec.prototype.decoder = DBCSDecoder;
    DBCSCodec.prototype._getDecodeTrieNode = function(addr) {
      var bytes = [];
      for (; addr > 0; addr >>>= 8) {
        bytes.push(addr & 255);
      }
      if (bytes.length == 0) {
        bytes.push(0);
      }
      var node = this.decodeTables[0];
      for (var i2 = bytes.length - 1; i2 > 0; i2--) {
        var val = node[bytes[i2]];
        if (val == UNASSIGNED) {
          node[bytes[i2]] = NODE_START - this.decodeTables.length;
          this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));
        } else if (val <= NODE_START) {
          node = this.decodeTables[NODE_START - val];
        } else {
          throw new Error("Overwrite byte in " + this.encodingName + ", addr: " + addr.toString(16));
        }
      }
      return node;
    };
    DBCSCodec.prototype._addDecodeChunk = function(chunk) {
      var curAddr = parseInt(chunk[0], 16);
      var writeTable = this._getDecodeTrieNode(curAddr);
      curAddr = curAddr & 255;
      for (var k = 1; k < chunk.length; k++) {
        var part = chunk[k];
        if (typeof part === "string") {
          for (var l = 0; l < part.length; ) {
            var code = part.charCodeAt(l++);
            if (code >= 55296 && code < 56320) {
              var codeTrail = part.charCodeAt(l++);
              if (codeTrail >= 56320 && codeTrail < 57344) {
                writeTable[curAddr++] = 65536 + (code - 55296) * 1024 + (codeTrail - 56320);
              } else {
                throw new Error("Incorrect surrogate pair in " + this.encodingName + " at chunk " + chunk[0]);
              }
            } else if (code > 4080 && code <= 4095) {
              var len = 4095 - code + 2;
              var seq = [];
              for (var m = 0; m < len; m++) {
                seq.push(part.charCodeAt(l++));
              }
              writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length;
              this.decodeTableSeq.push(seq);
            } else {
              writeTable[curAddr++] = code;
            }
          }
        } else if (typeof part === "number") {
          var charCode = writeTable[curAddr - 1] + 1;
          for (var l = 0; l < part; l++) {
            writeTable[curAddr++] = charCode++;
          }
        } else {
          throw new Error("Incorrect type '" + typeof part + "' given in " + this.encodingName + " at chunk " + chunk[0]);
        }
      }
      if (curAddr > 255) {
        throw new Error("Incorrect chunk in " + this.encodingName + " at addr " + chunk[0] + ": too long" + curAddr);
      }
    };
    DBCSCodec.prototype._getEncodeBucket = function(uCode) {
      var high = uCode >> 8;
      if (this.encodeTable[high] === void 0) {
        this.encodeTable[high] = UNASSIGNED_NODE.slice(0);
      }
      return this.encodeTable[high];
    };
    DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) {
      var bucket = this._getEncodeBucket(uCode);
      var low = uCode & 255;
      if (bucket[low] <= SEQ_START) {
        this.encodeTableSeq[SEQ_START - bucket[low]][DEF_CHAR] = dbcsCode;
      } else if (bucket[low] == UNASSIGNED) {
        bucket[low] = dbcsCode;
      }
    };
    DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) {
      var uCode = seq[0];
      var bucket = this._getEncodeBucket(uCode);
      var low = uCode & 255;
      var node;
      if (bucket[low] <= SEQ_START) {
        node = this.encodeTableSeq[SEQ_START - bucket[low]];
      } else {
        node = {};
        if (bucket[low] !== UNASSIGNED) node[DEF_CHAR] = bucket[low];
        bucket[low] = SEQ_START - this.encodeTableSeq.length;
        this.encodeTableSeq.push(node);
      }
      for (var j = 1; j < seq.length - 1; j++) {
        var oldVal = node[uCode];
        if (typeof oldVal === "object") {
          node = oldVal;
        } else {
          node = node[uCode] = {};
          if (oldVal !== void 0) {
            node[DEF_CHAR] = oldVal;
          }
        }
      }
      uCode = seq[seq.length - 1];
      node[uCode] = dbcsCode;
    };
    DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix, skipEncodeChars) {
      var node = this.decodeTables[nodeIdx];
      var hasValues = false;
      var subNodeEmpty = {};
      for (var i2 = 0; i2 < 256; i2++) {
        var uCode = node[i2];
        var mbCode = prefix + i2;
        if (skipEncodeChars[mbCode]) {
          continue;
        }
        if (uCode >= 0) {
          this._setEncodeChar(uCode, mbCode);
          hasValues = true;
        } else if (uCode <= NODE_START) {
          var subNodeIdx = NODE_START - uCode;
          if (!subNodeEmpty[subNodeIdx]) {
            var newPrefix = mbCode << 8 >>> 0;
            if (this._fillEncodeTable(subNodeIdx, newPrefix, skipEncodeChars)) {
              hasValues = true;
            } else {
              subNodeEmpty[subNodeIdx] = true;
            }
          }
        } else if (uCode <= SEQ_START) {
          this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);
          hasValues = true;
        }
      }
      return hasValues;
    };
    function DBCSEncoder(options, codec3) {
      this.leadSurrogate = -1;
      this.seqObj = void 0;
      this.encodeTable = codec3.encodeTable;
      this.encodeTableSeq = codec3.encodeTableSeq;
      this.defaultCharSingleByte = codec3.defCharSB;
      this.gb18030 = codec3.gb18030;
    }
    DBCSEncoder.prototype.write = function(str) {
      var newBuf = Buffer3.alloc(str.length * (this.gb18030 ? 4 : 3));
      var leadSurrogate = this.leadSurrogate;
      var seqObj = this.seqObj;
      var nextChar = -1;
      var i2 = 0;
      var j = 0;
      while (true) {
        if (nextChar === -1) {
          if (i2 == str.length) break;
          var uCode = str.charCodeAt(i2++);
        } else {
          var uCode = nextChar;
          nextChar = -1;
        }
        if (uCode >= 55296 && uCode < 57344) {
          if (uCode < 56320) {
            if (leadSurrogate === -1) {
              leadSurrogate = uCode;
              continue;
            } else {
              leadSurrogate = uCode;
              uCode = UNASSIGNED;
            }
          } else {
            if (leadSurrogate !== -1) {
              uCode = 65536 + (leadSurrogate - 55296) * 1024 + (uCode - 56320);
              leadSurrogate = -1;
            } else {
              uCode = UNASSIGNED;
            }
          }
        } else if (leadSurrogate !== -1) {
          nextChar = uCode;
          uCode = UNASSIGNED;
          leadSurrogate = -1;
        }
        var dbcsCode = UNASSIGNED;
        if (seqObj !== void 0 && uCode != UNASSIGNED) {
          var resCode = seqObj[uCode];
          if (typeof resCode === "object") {
            seqObj = resCode;
            continue;
          } else if (typeof resCode === "number") {
            dbcsCode = resCode;
          } else if (resCode == void 0) {
            resCode = seqObj[DEF_CHAR];
            if (resCode !== void 0) {
              dbcsCode = resCode;
              nextChar = uCode;
            } else {
            }
          }
          seqObj = void 0;
        } else if (uCode >= 0) {
          var subtable = this.encodeTable[uCode >> 8];
          if (subtable !== void 0) {
            dbcsCode = subtable[uCode & 255];
          }
          if (dbcsCode <= SEQ_START) {
            seqObj = this.encodeTableSeq[SEQ_START - dbcsCode];
            continue;
          }
          if (dbcsCode == UNASSIGNED && this.gb18030) {
            var idx = findIdx(this.gb18030.uChars, uCode);
            if (idx != -1) {
              var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]);
              newBuf[j++] = 129 + Math.floor(dbcsCode / 12600);
              dbcsCode = dbcsCode % 12600;
              newBuf[j++] = 48 + Math.floor(dbcsCode / 1260);
              dbcsCode = dbcsCode % 1260;
              newBuf[j++] = 129 + Math.floor(dbcsCode / 10);
              dbcsCode = dbcsCode % 10;
              newBuf[j++] = 48 + dbcsCode;
              continue;
            }
          }
        }
        if (dbcsCode === UNASSIGNED) {
          dbcsCode = this.defaultCharSingleByte;
        }
        if (dbcsCode < 256) {
          newBuf[j++] = dbcsCode;
        } else if (dbcsCode < 65536) {
          newBuf[j++] = dbcsCode >> 8;
          newBuf[j++] = dbcsCode & 255;
        } else if (dbcsCode < 16777216) {
          newBuf[j++] = dbcsCode >> 16;
          newBuf[j++] = dbcsCode >> 8 & 255;
          newBuf[j++] = dbcsCode & 255;
        } else {
          newBuf[j++] = dbcsCode >>> 24;
          newBuf[j++] = dbcsCode >>> 16 & 255;
          newBuf[j++] = dbcsCode >>> 8 & 255;
          newBuf[j++] = dbcsCode & 255;
        }
      }
      this.seqObj = seqObj;
      this.leadSurrogate = leadSurrogate;
      return newBuf.slice(0, j);
    };
    DBCSEncoder.prototype.end = function() {
      if (this.leadSurrogate === -1 && this.seqObj === void 0) {
        return;
      }
      var newBuf = Buffer3.alloc(10);
      var j = 0;
      if (this.seqObj) {
        var dbcsCode = this.seqObj[DEF_CHAR];
        if (dbcsCode !== void 0) {
          if (dbcsCode < 256) {
            newBuf[j++] = dbcsCode;
          } else {
            newBuf[j++] = dbcsCode >> 8;
            newBuf[j++] = dbcsCode & 255;
          }
        } else {
        }
        this.seqObj = void 0;
      }
      if (this.leadSurrogate !== -1) {
        newBuf[j++] = this.defaultCharSingleByte;
        this.leadSurrogate = -1;
      }
      return newBuf.slice(0, j);
    };
    DBCSEncoder.prototype.findIdx = findIdx;
    function DBCSDecoder(options, codec3) {
      this.nodeIdx = 0;
      this.prevBytes = [];
      this.decodeTables = codec3.decodeTables;
      this.decodeTableSeq = codec3.decodeTableSeq;
      this.defaultCharUnicode = codec3.defaultCharUnicode;
      this.gb18030 = codec3.gb18030;
    }
    DBCSDecoder.prototype.write = function(buf) {
      var newBuf = Buffer3.alloc(buf.length * 2);
      var nodeIdx = this.nodeIdx;
      var prevBytes = this.prevBytes;
      var prevOffset = this.prevBytes.length;
      var seqStart = -this.prevBytes.length;
      var uCode;
      for (var i2 = 0, j = 0; i2 < buf.length; i2++) {
        var curByte = i2 >= 0 ? buf[i2] : prevBytes[i2 + prevOffset];
        var uCode = this.decodeTables[nodeIdx][curByte];
        if (uCode >= 0) {
        } else if (uCode === UNASSIGNED) {
          uCode = this.defaultCharUnicode.charCodeAt(0);
          i2 = seqStart;
        } else if (uCode === GB18030_CODE) {
          if (i2 >= 3) {
            var ptr = (buf[i2 - 3] - 129) * 12600 + (buf[i2 - 2] - 48) * 1260 + (buf[i2 - 1] - 129) * 10 + (curByte - 48);
          } else {
            var ptr = (prevBytes[i2 - 3 + prevOffset] - 129) * 12600 + ((i2 - 2 >= 0 ? buf[i2 - 2] : prevBytes[i2 - 2 + prevOffset]) - 48) * 1260 + ((i2 - 1 >= 0 ? buf[i2 - 1] : prevBytes[i2 - 1 + prevOffset]) - 129) * 10 + (curByte - 48);
          }
          var idx = findIdx(this.gb18030.gbChars, ptr);
          uCode = this.gb18030.uChars[idx] + ptr - this.gb18030.gbChars[idx];
        } else if (uCode <= NODE_START) {
          nodeIdx = NODE_START - uCode;
          continue;
        } else if (uCode <= SEQ_START) {
          var seq = this.decodeTableSeq[SEQ_START - uCode];
          for (var k = 0; k < seq.length - 1; k++) {
            uCode = seq[k];
            newBuf[j++] = uCode & 255;
            newBuf[j++] = uCode >> 8;
          }
          uCode = seq[seq.length - 1];
        } else {
          throw new Error("iconv-lite internal error: invalid decoding table value " + uCode + " at " + nodeIdx + "/" + curByte);
        }
        if (uCode >= 65536) {
          uCode -= 65536;
          var uCodeLead = 55296 | uCode >> 10;
          newBuf[j++] = uCodeLead & 255;
          newBuf[j++] = uCodeLead >> 8;
          uCode = 56320 | uCode & 1023;
        }
        newBuf[j++] = uCode & 255;
        newBuf[j++] = uCode >> 8;
        nodeIdx = 0;
        seqStart = i2 + 1;
      }
      this.nodeIdx = nodeIdx;
      this.prevBytes = seqStart >= 0 ? Array.prototype.slice.call(buf, seqStart) : prevBytes.slice(seqStart + prevOffset).concat(Array.prototype.slice.call(buf));
      return newBuf.slice(0, j).toString("ucs2");
    };
    DBCSDecoder.prototype.end = function() {
      var ret = "";
      while (this.prevBytes.length > 0) {
        ret += this.defaultCharUnicode;
        var bytesArr = this.prevBytes.slice(1);
        this.prevBytes = [];
        this.nodeIdx = 0;
        if (bytesArr.length > 0) {
          ret += this.write(bytesArr);
        }
      }
      this.prevBytes = [];
      this.nodeIdx = 0;
      return ret;
    };
    function findIdx(table, val) {
      if (table[0] > val) {
        return -1;
      }
      var l = 0;
      var r = table.length;
      while (l < r - 1) {
        var mid = l + (r - l + 1 >> 1);
        if (table[mid] <= val) {
          l = mid;
        } else {
          r = mid;
        }
      }
      return l;
    }
  }
});

// node_modules/iconv-lite/encodings/tables/shiftjis.json
var require_shiftjis = __commonJS({
  "node_modules/iconv-lite/encodings/tables/shiftjis.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 128],
      ["a1", "\uFF61", 62],
      ["8140", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7"],
      ["8180", "\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"],
      ["81b8", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"],
      ["81c8", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"],
      ["81da", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"],
      ["81f0", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"],
      ["81fc", "\u25EF"],
      ["824f", "\uFF10", 9],
      ["8260", "\uFF21", 25],
      ["8281", "\uFF41", 25],
      ["829f", "\u3041", 82],
      ["8340", "\u30A1", 62],
      ["8380", "\u30E0", 22],
      ["839f", "\u0391", 16, "\u03A3", 6],
      ["83bf", "\u03B1", 16, "\u03C3", 6],
      ["8440", "\u0410", 5, "\u0401\u0416", 25],
      ["8470", "\u0430", 5, "\u0451\u0436", 7],
      ["8480", "\u043E", 17],
      ["849f", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"],
      ["8740", "\u2460", 19, "\u2160", 9],
      ["875f", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"],
      ["877e", "\u337B"],
      ["8780", "\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"],
      ["889f", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"],
      ["8940", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186"],
      ["8980", "\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"],
      ["8a40", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B"],
      ["8a80", "\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"],
      ["8b40", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551"],
      ["8b80", "\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"],
      ["8c40", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8"],
      ["8c80", "\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"],
      ["8d40", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D"],
      ["8d80", "\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"],
      ["8e40", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62"],
      ["8e80", "\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"],
      ["8f40", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3"],
      ["8f80", "\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"],
      ["9040", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8"],
      ["9080", "\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"],
      ["9140", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB"],
      ["9180", "\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"],
      ["9240", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4"],
      ["9280", "\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"],
      ["9340", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC"],
      ["9380", "\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"],
      ["9440", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885"],
      ["9480", "\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"],
      ["9540", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577"],
      ["9580", "\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"],
      ["9640", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6"],
      ["9680", "\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"],
      ["9740", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32"],
      ["9780", "\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"],
      ["9840", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"],
      ["989f", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"],
      ["9940", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED"],
      ["9980", "\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"],
      ["9a40", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638"],
      ["9a80", "\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"],
      ["9b40", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80"],
      ["9b80", "\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"],
      ["9c40", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060"],
      ["9c80", "\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"],
      ["9d40", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B"],
      ["9d80", "\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"],
      ["9e40", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E"],
      ["9e80", "\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"],
      ["9f40", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF"],
      ["9f80", "\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"],
      ["e040", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD"],
      ["e080", "\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"],
      ["e140", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF"],
      ["e180", "\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"],
      ["e240", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0"],
      ["e280", "\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"],
      ["e340", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37"],
      ["e380", "\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"],
      ["e440", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264"],
      ["e480", "\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"],
      ["e540", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC"],
      ["e580", "\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"],
      ["e640", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7"],
      ["e680", "\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"],
      ["e740", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C"],
      ["e780", "\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"],
      ["e840", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599"],
      ["e880", "\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"],
      ["e940", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43"],
      ["e980", "\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"],
      ["ea40", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF"],
      ["ea80", "\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0\u582F\u69C7\u9059\u7464\u51DC\u7199"],
      ["ed40", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F"],
      ["ed80", "\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"],
      ["ee40", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559"],
      ["ee80", "\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"],
      ["eeef", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"],
      ["f040", "\uE000", 62],
      ["f080", "\uE03F", 124],
      ["f140", "\uE0BC", 62],
      ["f180", "\uE0FB", 124],
      ["f240", "\uE178", 62],
      ["f280", "\uE1B7", 124],
      ["f340", "\uE234", 62],
      ["f380", "\uE273", 124],
      ["f440", "\uE2F0", 62],
      ["f480", "\uE32F", 124],
      ["f540", "\uE3AC", 62],
      ["f580", "\uE3EB", 124],
      ["f640", "\uE468", 62],
      ["f680", "\uE4A7", 124],
      ["f740", "\uE524", 62],
      ["f780", "\uE563", 124],
      ["f840", "\uE5E0", 62],
      ["f880", "\uE61F", 124],
      ["f940", "\uE69C"],
      ["fa40", "\u2170", 9, "\u2160", 9, "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u2235\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A"],
      ["fa80", "\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F"],
      ["fb40", "\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19"],
      ["fb80", "\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9"],
      ["fc40", "\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"]
    ];
  }
});

// node_modules/iconv-lite/encodings/tables/eucjp.json
var require_eucjp = __commonJS({
  "node_modules/iconv-lite/encodings/tables/eucjp.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127],
      ["8ea1", "\uFF61", 62],
      ["a1a1", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7"],
      ["a2a1", "\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"],
      ["a2ba", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"],
      ["a2ca", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"],
      ["a2dc", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"],
      ["a2f2", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"],
      ["a2fe", "\u25EF"],
      ["a3b0", "\uFF10", 9],
      ["a3c1", "\uFF21", 25],
      ["a3e1", "\uFF41", 25],
      ["a4a1", "\u3041", 82],
      ["a5a1", "\u30A1", 85],
      ["a6a1", "\u0391", 16, "\u03A3", 6],
      ["a6c1", "\u03B1", 16, "\u03C3", 6],
      ["a7a1", "\u0410", 5, "\u0401\u0416", 25],
      ["a7d1", "\u0430", 5, "\u0451\u0436", 25],
      ["a8a1", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"],
      ["ada1", "\u2460", 19, "\u2160", 9],
      ["adc0", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"],
      ["addf", "\u337B\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"],
      ["b0a1", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"],
      ["b1a1", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC"],
      ["b2a1", "\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"],
      ["b3a1", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431"],
      ["b4a1", "\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"],
      ["b5a1", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC"],
      ["b6a1", "\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"],
      ["b7a1", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372"],
      ["b8a1", "\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"],
      ["b9a1", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC"],
      ["baa1", "\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"],
      ["bba1", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642"],
      ["bca1", "\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"],
      ["bda1", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F"],
      ["bea1", "\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"],
      ["bfa1", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE"],
      ["c0a1", "\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"],
      ["c1a1", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E"],
      ["c2a1", "\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"],
      ["c3a1", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5"],
      ["c4a1", "\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"],
      ["c5a1", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230"],
      ["c6a1", "\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"],
      ["c7a1", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6"],
      ["c8a1", "\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"],
      ["c9a1", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D"],
      ["caa1", "\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"],
      ["cba1", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80"],
      ["cca1", "\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"],
      ["cda1", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483"],
      ["cea1", "\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"],
      ["cfa1", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"],
      ["d0a1", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"],
      ["d1a1", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8"],
      ["d2a1", "\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"],
      ["d3a1", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709"],
      ["d4a1", "\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"],
      ["d5a1", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53"],
      ["d6a1", "\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"],
      ["d7a1", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A"],
      ["d8a1", "\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"],
      ["d9a1", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC"],
      ["daa1", "\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"],
      ["dba1", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD"],
      ["dca1", "\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"],
      ["dda1", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE"],
      ["dea1", "\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"],
      ["dfa1", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC"],
      ["e0a1", "\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"],
      ["e1a1", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670"],
      ["e2a1", "\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"],
      ["e3a1", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50"],
      ["e4a1", "\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"],
      ["e5a1", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A"],
      ["e6a1", "\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"],
      ["e7a1", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9"],
      ["e8a1", "\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"],
      ["e9a1", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759"],
      ["eaa1", "\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"],
      ["eba1", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B"],
      ["eca1", "\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"],
      ["eda1", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8"],
      ["eea1", "\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"],
      ["efa1", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E"],
      ["f0a1", "\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"],
      ["f1a1", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7"],
      ["f2a1", "\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"],
      ["f3a1", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0"],
      ["f4a1", "\u582F\u69C7\u9059\u7464\u51DC\u7199"],
      ["f9a1", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7"],
      ["faa1", "\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"],
      ["fba1", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA"],
      ["fca1", "\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"],
      ["fcf1", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"],
      ["8fa2af", "\u02D8\u02C7\xB8\u02D9\u02DD\xAF\u02DB\u02DA\uFF5E\u0384\u0385"],
      ["8fa2c2", "\xA1\xA6\xBF"],
      ["8fa2eb", "\xBA\xAA\xA9\xAE\u2122\xA4\u2116"],
      ["8fa6e1", "\u0386\u0388\u0389\u038A\u03AA"],
      ["8fa6e7", "\u038C"],
      ["8fa6e9", "\u038E\u03AB"],
      ["8fa6ec", "\u038F"],
      ["8fa6f1", "\u03AC\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03C2\u03CD\u03CB\u03B0\u03CE"],
      ["8fa7c2", "\u0402", 10, "\u040E\u040F"],
      ["8fa7f2", "\u0452", 10, "\u045E\u045F"],
      ["8fa9a1", "\xC6\u0110"],
      ["8fa9a4", "\u0126"],
      ["8fa9a6", "\u0132"],
      ["8fa9a8", "\u0141\u013F"],
      ["8fa9ab", "\u014A\xD8\u0152"],
      ["8fa9af", "\u0166\xDE"],
      ["8fa9c1", "\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0142\u0140\u0149\u014B\xF8\u0153\xDF\u0167\xFE"],
      ["8faaa1", "\xC1\xC0\xC4\xC2\u0102\u01CD\u0100\u0104\xC5\xC3\u0106\u0108\u010C\xC7\u010A\u010E\xC9\xC8\xCB\xCA\u011A\u0116\u0112\u0118"],
      ["8faaba", "\u011C\u011E\u0122\u0120\u0124\xCD\xCC\xCF\xCE\u01CF\u0130\u012A\u012E\u0128\u0134\u0136\u0139\u013D\u013B\u0143\u0147\u0145\xD1\xD3\xD2\xD6\xD4\u01D1\u0150\u014C\xD5\u0154\u0158\u0156\u015A\u015C\u0160\u015E\u0164\u0162\xDA\xD9\xDC\xDB\u016C\u01D3\u0170\u016A\u0172\u016E\u0168\u01D7\u01DB\u01D9\u01D5\u0174\xDD\u0178\u0176\u0179\u017D\u017B"],
      ["8faba1", "\xE1\xE0\xE4\xE2\u0103\u01CE\u0101\u0105\xE5\xE3\u0107\u0109\u010D\xE7\u010B\u010F\xE9\xE8\xEB\xEA\u011B\u0117\u0113\u0119\u01F5\u011D\u011F"],
      ["8fabbd", "\u0121\u0125\xED\xEC\xEF\xEE\u01D0"],
      ["8fabc5", "\u012B\u012F\u0129\u0135\u0137\u013A\u013E\u013C\u0144\u0148\u0146\xF1\xF3\xF2\xF6\xF4\u01D2\u0151\u014D\xF5\u0155\u0159\u0157\u015B\u015D\u0161\u015F\u0165\u0163\xFA\xF9\xFC\xFB\u016D\u01D4\u0171\u016B\u0173\u016F\u0169\u01D8\u01DC\u01DA\u01D6\u0175\xFD\xFF\u0177\u017A\u017E\u017C"],
      ["8fb0a1", "\u4E02\u4E04\u4E05\u4E0C\u4E12\u4E1F\u4E23\u4E24\u4E28\u4E2B\u4E2E\u4E2F\u4E30\u4E35\u4E40\u4E41\u4E44\u4E47\u4E51\u4E5A\u4E5C\u4E63\u4E68\u4E69\u4E74\u4E75\u4E79\u4E7F\u4E8D\u4E96\u4E97\u4E9D\u4EAF\u4EB9\u4EC3\u4ED0\u4EDA\u4EDB\u4EE0\u4EE1\u4EE2\u4EE8\u4EEF\u4EF1\u4EF3\u4EF5\u4EFD\u4EFE\u4EFF\u4F00\u4F02\u4F03\u4F08\u4F0B\u4F0C\u4F12\u4F15\u4F16\u4F17\u4F19\u4F2E\u4F31\u4F60\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E\u4F40\u4F42\u4F48\u4F49\u4F4B\u4F4C\u4F52\u4F54\u4F56\u4F58\u4F5F\u4F63\u4F6A\u4F6C\u4F6E\u4F71\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F7E\u4F81\u4F82\u4F84"],
      ["8fb1a1", "\u4F85\u4F89\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F94\u4F97\u4F99\u4F9A\u4F9E\u4F9F\u4FB2\u4FB7\u4FB9\u4FBB\u4FBC\u4FBD\u4FBE\u4FC0\u4FC1\u4FC5\u4FC6\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FCF\u4FD2\u4FDC\u4FE0\u4FE2\u4FF0\u4FF2\u4FFC\u4FFD\u4FFF\u5000\u5001\u5004\u5007\u500A\u500C\u500E\u5010\u5013\u5017\u5018\u501B\u501C\u501D\u501E\u5022\u5027\u502E\u5030\u5032\u5033\u5035\u5040\u5041\u5042\u5045\u5046\u504A\u504C\u504E\u5051\u5052\u5053\u5057\u5059\u505F\u5060\u5062\u5063\u5066\u5067\u506A\u506D\u5070\u5071\u503B\u5081\u5083\u5084\u5086\u508A\u508E\u508F\u5090"],
      ["8fb2a1", "\u5092\u5093\u5094\u5096\u509B\u509C\u509E", 4, "\u50AA\u50AF\u50B0\u50B9\u50BA\u50BD\u50C0\u50C3\u50C4\u50C7\u50CC\u50CE\u50D0\u50D3\u50D4\u50D8\u50DC\u50DD\u50DF\u50E2\u50E4\u50E6\u50E8\u50E9\u50EF\u50F1\u50F6\u50FA\u50FE\u5103\u5106\u5107\u5108\u510B\u510C\u510D\u510E\u50F2\u5110\u5117\u5119\u511B\u511C\u511D\u511E\u5123\u5127\u5128\u512C\u512D\u512F\u5131\u5133\u5134\u5135\u5138\u5139\u5142\u514A\u514F\u5153\u5155\u5157\u5158\u515F\u5164\u5166\u517E\u5183\u5184\u518B\u518E\u5198\u519D\u51A1\u51A3\u51AD\u51B8\u51BA\u51BC\u51BE\u51BF\u51C2"],
      ["8fb3a1", "\u51C8\u51CF\u51D1\u51D2\u51D3\u51D5\u51D8\u51DE\u51E2\u51E5\u51EE\u51F2\u51F3\u51F4\u51F7\u5201\u5202\u5205\u5212\u5213\u5215\u5216\u5218\u5222\u5228\u5231\u5232\u5235\u523C\u5245\u5249\u5255\u5257\u5258\u525A\u525C\u525F\u5260\u5261\u5266\u526E\u5277\u5278\u5279\u5280\u5282\u5285\u528A\u528C\u5293\u5295\u5296\u5297\u5298\u529A\u529C\u52A4\u52A5\u52A6\u52A7\u52AF\u52B0\u52B6\u52B7\u52B8\u52BA\u52BB\u52BD\u52C0\u52C4\u52C6\u52C8\u52CC\u52CF\u52D1\u52D4\u52D6\u52DB\u52DC\u52E1\u52E5\u52E8\u52E9\u52EA\u52EC\u52F0\u52F1\u52F4\u52F6\u52F7\u5300\u5303\u530A\u530B"],
      ["8fb4a1", "\u530C\u5311\u5313\u5318\u531B\u531C\u531E\u531F\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u5330\u5332\u5335\u533C\u533D\u533E\u5342\u534C\u534B\u5359\u535B\u5361\u5363\u5365\u536C\u536D\u5372\u5379\u537E\u5383\u5387\u5388\u538E\u5393\u5394\u5399\u539D\u53A1\u53A4\u53AA\u53AB\u53AF\u53B2\u53B4\u53B5\u53B7\u53B8\u53BA\u53BD\u53C0\u53C5\u53CF\u53D2\u53D3\u53D5\u53DA\u53DD\u53DE\u53E0\u53E6\u53E7\u53F5\u5402\u5413\u541A\u5421\u5427\u5428\u542A\u542F\u5431\u5434\u5435\u5443\u5444\u5447\u544D\u544F\u545E\u5462\u5464\u5466\u5467\u5469\u546B\u546D\u546E\u5474\u547F"],
      ["8fb5a1", "\u5481\u5483\u5485\u5488\u5489\u548D\u5491\u5495\u5496\u549C\u549F\u54A1\u54A6\u54A7\u54A9\u54AA\u54AD\u54AE\u54B1\u54B7\u54B9\u54BA\u54BB\u54BF\u54C6\u54CA\u54CD\u54CE\u54E0\u54EA\u54EC\u54EF\u54F6\u54FC\u54FE\u54FF\u5500\u5501\u5505\u5508\u5509\u550C\u550D\u550E\u5515\u552A\u552B\u5532\u5535\u5536\u553B\u553C\u553D\u5541\u5547\u5549\u554A\u554D\u5550\u5551\u5558\u555A\u555B\u555E\u5560\u5561\u5564\u5566\u557F\u5581\u5582\u5586\u5588\u558E\u558F\u5591\u5592\u5593\u5594\u5597\u55A3\u55A4\u55AD\u55B2\u55BF\u55C1\u55C3\u55C6\u55C9\u55CB\u55CC\u55CE\u55D1\u55D2"],
      ["8fb6a1", "\u55D3\u55D7\u55D8\u55DB\u55DE\u55E2\u55E9\u55F6\u55FF\u5605\u5608\u560A\u560D", 5, "\u5619\u562C\u5630\u5633\u5635\u5637\u5639\u563B\u563C\u563D\u563F\u5640\u5641\u5643\u5644\u5646\u5649\u564B\u564D\u564F\u5654\u565E\u5660\u5661\u5662\u5663\u5666\u5669\u566D\u566F\u5671\u5672\u5675\u5684\u5685\u5688\u568B\u568C\u5695\u5699\u569A\u569D\u569E\u569F\u56A6\u56A7\u56A8\u56A9\u56AB\u56AC\u56AD\u56B1\u56B3\u56B7\u56BE\u56C5\u56C9\u56CA\u56CB\u56CF\u56D0\u56CC\u56CD\u56D9\u56DC\u56DD\u56DF\u56E1\u56E4", 4, "\u56F1\u56EB\u56ED"],
      ["8fb7a1", "\u56F6\u56F7\u5701\u5702\u5707\u570A\u570C\u5711\u5715\u571A\u571B\u571D\u5720\u5722\u5723\u5724\u5725\u5729\u572A\u572C\u572E\u572F\u5733\u5734\u573D\u573E\u573F\u5745\u5746\u574C\u574D\u5752\u5762\u5765\u5767\u5768\u576B\u576D", 4, "\u5773\u5774\u5775\u5777\u5779\u577A\u577B\u577C\u577E\u5781\u5783\u578C\u5794\u5797\u5799\u579A\u579C\u579D\u579E\u579F\u57A1\u5795\u57A7\u57A8\u57A9\u57AC\u57B8\u57BD\u57C7\u57C8\u57CC\u57CF\u57D5\u57DD\u57DE\u57E4\u57E6\u57E7\u57E9\u57ED\u57F0\u57F5\u57F6\u57F8\u57FD\u57FE\u57FF\u5803\u5804\u5808\u5809\u57E1"],
      ["8fb8a1", "\u580C\u580D\u581B\u581E\u581F\u5820\u5826\u5827\u582D\u5832\u5839\u583F\u5849\u584C\u584D\u584F\u5850\u5855\u585F\u5861\u5864\u5867\u5868\u5878\u587C\u587F\u5880\u5881\u5887\u5888\u5889\u588A\u588C\u588D\u588F\u5890\u5894\u5896\u589D\u58A0\u58A1\u58A2\u58A6\u58A9\u58B1\u58B2\u58C4\u58BC\u58C2\u58C8\u58CD\u58CE\u58D0\u58D2\u58D4\u58D6\u58DA\u58DD\u58E1\u58E2\u58E9\u58F3\u5905\u5906\u590B\u590C\u5912\u5913\u5914\u8641\u591D\u5921\u5923\u5924\u5928\u592F\u5930\u5933\u5935\u5936\u593F\u5943\u5946\u5952\u5953\u5959\u595B\u595D\u595E\u595F\u5961\u5963\u596B\u596D"],
      ["8fb9a1", "\u596F\u5972\u5975\u5976\u5979\u597B\u597C\u598B\u598C\u598E\u5992\u5995\u5997\u599F\u59A4\u59A7\u59AD\u59AE\u59AF\u59B0\u59B3\u59B7\u59BA\u59BC\u59C1\u59C3\u59C4\u59C8\u59CA\u59CD\u59D2\u59DD\u59DE\u59DF\u59E3\u59E4\u59E7\u59EE\u59EF\u59F1\u59F2\u59F4\u59F7\u5A00\u5A04\u5A0C\u5A0D\u5A0E\u5A12\u5A13\u5A1E\u5A23\u5A24\u5A27\u5A28\u5A2A\u5A2D\u5A30\u5A44\u5A45\u5A47\u5A48\u5A4C\u5A50\u5A55\u5A5E\u5A63\u5A65\u5A67\u5A6D\u5A77\u5A7A\u5A7B\u5A7E\u5A8B\u5A90\u5A93\u5A96\u5A99\u5A9C\u5A9E\u5A9F\u5AA0\u5AA2\u5AA7\u5AAC\u5AB1\u5AB2\u5AB3\u5AB5\u5AB8\u5ABA\u5ABB\u5ABF"],
      ["8fbaa1", "\u5AC4\u5AC6\u5AC8\u5ACF\u5ADA\u5ADC\u5AE0\u5AE5\u5AEA\u5AEE\u5AF5\u5AF6\u5AFD\u5B00\u5B01\u5B08\u5B17\u5B34\u5B19\u5B1B\u5B1D\u5B21\u5B25\u5B2D\u5B38\u5B41\u5B4B\u5B4C\u5B52\u5B56\u5B5E\u5B68\u5B6E\u5B6F\u5B7C\u5B7D\u5B7E\u5B7F\u5B81\u5B84\u5B86\u5B8A\u5B8E\u5B90\u5B91\u5B93\u5B94\u5B96\u5BA8\u5BA9\u5BAC\u5BAD\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBC\u5BC0\u5BC1\u5BCD\u5BCF\u5BD6", 4, "\u5BE0\u5BEF\u5BF1\u5BF4\u5BFD\u5C0C\u5C17\u5C1E\u5C1F\u5C23\u5C26\u5C29\u5C2B\u5C2C\u5C2E\u5C30\u5C32\u5C35\u5C36\u5C59\u5C5A\u5C5C\u5C62\u5C63\u5C67\u5C68\u5C69"],
      ["8fbba1", "\u5C6D\u5C70\u5C74\u5C75\u5C7A\u5C7B\u5C7C\u5C7D\u5C87\u5C88\u5C8A\u5C8F\u5C92\u5C9D\u5C9F\u5CA0\u5CA2\u5CA3\u5CA6\u5CAA\u5CB2\u5CB4\u5CB5\u5CBA\u5CC9\u5CCB\u5CD2\u5CDD\u5CD7\u5CEE\u5CF1\u5CF2\u5CF4\u5D01\u5D06\u5D0D\u5D12\u5D2B\u5D23\u5D24\u5D26\u5D27\u5D31\u5D34\u5D39\u5D3D\u5D3F\u5D42\u5D43\u5D46\u5D48\u5D55\u5D51\u5D59\u5D4A\u5D5F\u5D60\u5D61\u5D62\u5D64\u5D6A\u5D6D\u5D70\u5D79\u5D7A\u5D7E\u5D7F\u5D81\u5D83\u5D88\u5D8A\u5D92\u5D93\u5D94\u5D95\u5D99\u5D9B\u5D9F\u5DA0\u5DA7\u5DAB\u5DB0\u5DB4\u5DB8\u5DB9\u5DC3\u5DC7\u5DCB\u5DD0\u5DCE\u5DD8\u5DD9\u5DE0\u5DE4"],
      ["8fbca1", "\u5DE9\u5DF8\u5DF9\u5E00\u5E07\u5E0D\u5E12\u5E14\u5E15\u5E18\u5E1F\u5E20\u5E2E\u5E28\u5E32\u5E35\u5E3E\u5E4B\u5E50\u5E49\u5E51\u5E56\u5E58\u5E5B\u5E5C\u5E5E\u5E68\u5E6A", 4, "\u5E70\u5E80\u5E8B\u5E8E\u5EA2\u5EA4\u5EA5\u5EA8\u5EAA\u5EAC\u5EB1\u5EB3\u5EBD\u5EBE\u5EBF\u5EC6\u5ECC\u5ECB\u5ECE\u5ED1\u5ED2\u5ED4\u5ED5\u5EDC\u5EDE\u5EE5\u5EEB\u5F02\u5F06\u5F07\u5F08\u5F0E\u5F19\u5F1C\u5F1D\u5F21\u5F22\u5F23\u5F24\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F34\u5F36\u5F3B\u5F3D\u5F3F\u5F40\u5F44\u5F45\u5F47\u5F4D\u5F50\u5F54\u5F58\u5F5B\u5F60\u5F63\u5F64\u5F67"],
      ["8fbda1", "\u5F6F\u5F72\u5F74\u5F75\u5F78\u5F7A\u5F7D\u5F7E\u5F89\u5F8D\u5F8F\u5F96\u5F9C\u5F9D\u5FA2\u5FA7\u5FAB\u5FA4\u5FAC\u5FAF\u5FB0\u5FB1\u5FB8\u5FC4\u5FC7\u5FC8\u5FC9\u5FCB\u5FD0", 4, "\u5FDE\u5FE1\u5FE2\u5FE8\u5FE9\u5FEA\u5FEC\u5FED\u5FEE\u5FEF\u5FF2\u5FF3\u5FF6\u5FFA\u5FFC\u6007\u600A\u600D\u6013\u6014\u6017\u6018\u601A\u601F\u6024\u602D\u6033\u6035\u6040\u6047\u6048\u6049\u604C\u6051\u6054\u6056\u6057\u605D\u6061\u6067\u6071\u607E\u607F\u6082\u6086\u6088\u608A\u608E\u6091\u6093\u6095\u6098\u609D\u609E\u60A2\u60A4\u60A5\u60A8\u60B0\u60B1\u60B7"],
      ["8fbea1", "\u60BB\u60BE\u60C2\u60C4\u60C8\u60C9\u60CA\u60CB\u60CE\u60CF\u60D4\u60D5\u60D9\u60DB\u60DD\u60DE\u60E2\u60E5\u60F2\u60F5\u60F8\u60FC\u60FD\u6102\u6107\u610A\u610C\u6110", 4, "\u6116\u6117\u6119\u611C\u611E\u6122\u612A\u612B\u6130\u6131\u6135\u6136\u6137\u6139\u6141\u6145\u6146\u6149\u615E\u6160\u616C\u6172\u6178\u617B\u617C\u617F\u6180\u6181\u6183\u6184\u618B\u618D\u6192\u6193\u6197\u6198\u619C\u619D\u619F\u61A0\u61A5\u61A8\u61AA\u61AD\u61B8\u61B9\u61BC\u61C0\u61C1\u61C2\u61CE\u61CF\u61D5\u61DC\u61DD\u61DE\u61DF\u61E1\u61E2\u61E7\u61E9\u61E5"],
      ["8fbfa1", "\u61EC\u61ED\u61EF\u6201\u6203\u6204\u6207\u6213\u6215\u621C\u6220\u6222\u6223\u6227\u6229\u622B\u6239\u623D\u6242\u6243\u6244\u6246\u624C\u6250\u6251\u6252\u6254\u6256\u625A\u625C\u6264\u626D\u626F\u6273\u627A\u627D\u628D\u628E\u628F\u6290\u62A6\u62A8\u62B3\u62B6\u62B7\u62BA\u62BE\u62BF\u62C4\u62CE\u62D5\u62D6\u62DA\u62EA\u62F2\u62F4\u62FC\u62FD\u6303\u6304\u630A\u630B\u630D\u6310\u6313\u6316\u6318\u6329\u632A\u632D\u6335\u6336\u6339\u633C\u6341\u6342\u6343\u6344\u6346\u634A\u634B\u634E\u6352\u6353\u6354\u6358\u635B\u6365\u6366\u636C\u636D\u6371\u6374\u6375"],
      ["8fc0a1", "\u6378\u637C\u637D\u637F\u6382\u6384\u6387\u638A\u6390\u6394\u6395\u6399\u639A\u639E\u63A4\u63A6\u63AD\u63AE\u63AF\u63BD\u63C1\u63C5\u63C8\u63CE\u63D1\u63D3\u63D4\u63D5\u63DC\u63E0\u63E5\u63EA\u63EC\u63F2\u63F3\u63F5\u63F8\u63F9\u6409\u640A\u6410\u6412\u6414\u6418\u641E\u6420\u6422\u6424\u6425\u6429\u642A\u642F\u6430\u6435\u643D\u643F\u644B\u644F\u6451\u6452\u6453\u6454\u645A\u645B\u645C\u645D\u645F\u6460\u6461\u6463\u646D\u6473\u6474\u647B\u647D\u6485\u6487\u648F\u6490\u6491\u6498\u6499\u649B\u649D\u649F\u64A1\u64A3\u64A6\u64A8\u64AC\u64B3\u64BD\u64BE\u64BF"],
      ["8fc1a1", "\u64C4\u64C9\u64CA\u64CB\u64CC\u64CE\u64D0\u64D1\u64D5\u64D7\u64E4\u64E5\u64E9\u64EA\u64ED\u64F0\u64F5\u64F7\u64FB\u64FF\u6501\u6504\u6508\u6509\u650A\u650F\u6513\u6514\u6516\u6519\u651B\u651E\u651F\u6522\u6526\u6529\u652E\u6531\u653A\u653C\u653D\u6543\u6547\u6549\u6550\u6552\u6554\u655F\u6560\u6567\u656B\u657A\u657D\u6581\u6585\u658A\u6592\u6595\u6598\u659D\u65A0\u65A3\u65A6\u65AE\u65B2\u65B3\u65B4\u65BF\u65C2\u65C8\u65C9\u65CE\u65D0\u65D4\u65D6\u65D8\u65DF\u65F0\u65F2\u65F4\u65F5\u65F9\u65FE\u65FF\u6600\u6604\u6608\u6609\u660D\u6611\u6612\u6615\u6616\u661D"],
      ["8fc2a1", "\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6631\u6633\u6639\u6637\u6640\u6645\u6646\u664A\u664C\u6651\u664E\u6657\u6658\u6659\u665B\u665C\u6660\u6661\u66FB\u666A\u666B\u666C\u667E\u6673\u6675\u667F\u6677\u6678\u6679\u667B\u6680\u667C\u668B\u668C\u668D\u6690\u6692\u6699\u669A\u669B\u669C\u669F\u66A0\u66A4\u66AD\u66B1\u66B2\u66B5\u66BB\u66BF\u66C0\u66C2\u66C3\u66C8\u66CC\u66CE\u66CF\u66D4\u66DB\u66DF\u66E8\u66EB\u66EC\u66EE\u66FA\u6705\u6707\u670E\u6713\u6719\u671C\u6720\u6722\u6733\u673E\u6745\u6747\u6748\u674C\u6754\u6755\u675D"],
      ["8fc3a1", "\u6766\u676C\u676E\u6774\u6776\u677B\u6781\u6784\u678E\u678F\u6791\u6793\u6796\u6798\u6799\u679B\u67B0\u67B1\u67B2\u67B5\u67BB\u67BC\u67BD\u67F9\u67C0\u67C2\u67C3\u67C5\u67C8\u67C9\u67D2\u67D7\u67D9\u67DC\u67E1\u67E6\u67F0\u67F2\u67F6\u67F7\u6852\u6814\u6819\u681D\u681F\u6828\u6827\u682C\u682D\u682F\u6830\u6831\u6833\u683B\u683F\u6844\u6845\u684A\u684C\u6855\u6857\u6858\u685B\u686B\u686E", 4, "\u6875\u6879\u687A\u687B\u687C\u6882\u6884\u6886\u6888\u6896\u6898\u689A\u689C\u68A1\u68A3\u68A5\u68A9\u68AA\u68AE\u68B2\u68BB\u68C5\u68C8\u68CC\u68CF"],
      ["8fc4a1", "\u68D0\u68D1\u68D3\u68D6\u68D9\u68DC\u68DD\u68E5\u68E8\u68EA\u68EB\u68EC\u68ED\u68F0\u68F1\u68F5\u68F6\u68FB\u68FC\u68FD\u6906\u6909\u690A\u6910\u6911\u6913\u6916\u6917\u6931\u6933\u6935\u6938\u693B\u6942\u6945\u6949\u694E\u6957\u695B\u6963\u6964\u6965\u6966\u6968\u6969\u696C\u6970\u6971\u6972\u697A\u697B\u697F\u6980\u698D\u6992\u6996\u6998\u69A1\u69A5\u69A6\u69A8\u69AB\u69AD\u69AF\u69B7\u69B8\u69BA\u69BC\u69C5\u69C8\u69D1\u69D6\u69D7\u69E2\u69E5\u69EE\u69EF\u69F1\u69F3\u69F5\u69FE\u6A00\u6A01\u6A03\u6A0F\u6A11\u6A15\u6A1A\u6A1D\u6A20\u6A24\u6A28\u6A30\u6A32"],
      ["8fc5a1", "\u6A34\u6A37\u6A3B\u6A3E\u6A3F\u6A45\u6A46\u6A49\u6A4A\u6A4E\u6A50\u6A51\u6A52\u6A55\u6A56\u6A5B\u6A64\u6A67\u6A6A\u6A71\u6A73\u6A7E\u6A81\u6A83\u6A86\u6A87\u6A89\u6A8B\u6A91\u6A9B\u6A9D\u6A9E\u6A9F\u6AA5\u6AAB\u6AAF\u6AB0\u6AB1\u6AB4\u6ABD\u6ABE\u6ABF\u6AC6\u6AC9\u6AC8\u6ACC\u6AD0\u6AD4\u6AD5\u6AD6\u6ADC\u6ADD\u6AE4\u6AE7\u6AEC\u6AF0\u6AF1\u6AF2\u6AFC\u6AFD\u6B02\u6B03\u6B06\u6B07\u6B09\u6B0F\u6B10\u6B11\u6B17\u6B1B\u6B1E\u6B24\u6B28\u6B2B\u6B2C\u6B2F\u6B35\u6B36\u6B3B\u6B3F\u6B46\u6B4A\u6B4D\u6B52\u6B56\u6B58\u6B5D\u6B60\u6B67\u6B6B\u6B6E\u6B70\u6B75\u6B7D"],
      ["8fc6a1", "\u6B7E\u6B82\u6B85\u6B97\u6B9B\u6B9F\u6BA0\u6BA2\u6BA3\u6BA8\u6BA9\u6BAC\u6BAD\u6BAE\u6BB0\u6BB8\u6BB9\u6BBD\u6BBE\u6BC3\u6BC4\u6BC9\u6BCC\u6BD6\u6BDA\u6BE1\u6BE3\u6BE6\u6BE7\u6BEE\u6BF1\u6BF7\u6BF9\u6BFF\u6C02\u6C04\u6C05\u6C09\u6C0D\u6C0E\u6C10\u6C12\u6C19\u6C1F\u6C26\u6C27\u6C28\u6C2C\u6C2E\u6C33\u6C35\u6C36\u6C3A\u6C3B\u6C3F\u6C4A\u6C4B\u6C4D\u6C4F\u6C52\u6C54\u6C59\u6C5B\u6C5C\u6C6B\u6C6D\u6C6F\u6C74\u6C76\u6C78\u6C79\u6C7B\u6C85\u6C86\u6C87\u6C89\u6C94\u6C95\u6C97\u6C98\u6C9C\u6C9F\u6CB0\u6CB2\u6CB4\u6CC2\u6CC6\u6CCD\u6CCF\u6CD0\u6CD1\u6CD2\u6CD4\u6CD6"],
      ["8fc7a1", "\u6CDA\u6CDC\u6CE0\u6CE7\u6CE9\u6CEB\u6CEC\u6CEE\u6CF2\u6CF4\u6D04\u6D07\u6D0A\u6D0E\u6D0F\u6D11\u6D13\u6D1A\u6D26\u6D27\u6D28\u6C67\u6D2E\u6D2F\u6D31\u6D39\u6D3C\u6D3F\u6D57\u6D5E\u6D5F\u6D61\u6D65\u6D67\u6D6F\u6D70\u6D7C\u6D82\u6D87\u6D91\u6D92\u6D94\u6D96\u6D97\u6D98\u6DAA\u6DAC\u6DB4\u6DB7\u6DB9\u6DBD\u6DBF\u6DC4\u6DC8\u6DCA\u6DCE\u6DCF\u6DD6\u6DDB\u6DDD\u6DDF\u6DE0\u6DE2\u6DE5\u6DE9\u6DEF\u6DF0\u6DF4\u6DF6\u6DFC\u6E00\u6E04\u6E1E\u6E22\u6E27\u6E32\u6E36\u6E39\u6E3B\u6E3C\u6E44\u6E45\u6E48\u6E49\u6E4B\u6E4F\u6E51\u6E52\u6E53\u6E54\u6E57\u6E5C\u6E5D\u6E5E"],
      ["8fc8a1", "\u6E62\u6E63\u6E68\u6E73\u6E7B\u6E7D\u6E8D\u6E93\u6E99\u6EA0\u6EA7\u6EAD\u6EAE\u6EB1\u6EB3\u6EBB\u6EBF\u6EC0\u6EC1\u6EC3\u6EC7\u6EC8\u6ECA\u6ECD\u6ECE\u6ECF\u6EEB\u6EED\u6EEE\u6EF9\u6EFB\u6EFD\u6F04\u6F08\u6F0A\u6F0C\u6F0D\u6F16\u6F18\u6F1A\u6F1B\u6F26\u6F29\u6F2A\u6F2F\u6F30\u6F33\u6F36\u6F3B\u6F3C\u6F2D\u6F4F\u6F51\u6F52\u6F53\u6F57\u6F59\u6F5A\u6F5D\u6F5E\u6F61\u6F62\u6F68\u6F6C\u6F7D\u6F7E\u6F83\u6F87\u6F88\u6F8B\u6F8C\u6F8D\u6F90\u6F92\u6F93\u6F94\u6F96\u6F9A\u6F9F\u6FA0\u6FA5\u6FA6\u6FA7\u6FA8\u6FAE\u6FAF\u6FB0\u6FB5\u6FB6\u6FBC\u6FC5\u6FC7\u6FC8\u6FCA"],
      ["8fc9a1", "\u6FDA\u6FDE\u6FE8\u6FE9\u6FF0\u6FF5\u6FF9\u6FFC\u6FFD\u7000\u7005\u7006\u7007\u700D\u7017\u7020\u7023\u702F\u7034\u7037\u7039\u703C\u7043\u7044\u7048\u7049\u704A\u704B\u7054\u7055\u705D\u705E\u704E\u7064\u7065\u706C\u706E\u7075\u7076\u707E\u7081\u7085\u7086\u7094", 4, "\u709B\u70A4\u70AB\u70B0\u70B1\u70B4\u70B7\u70CA\u70D1\u70D3\u70D4\u70D5\u70D6\u70D8\u70DC\u70E4\u70FA\u7103", 4, "\u710B\u710C\u710F\u711E\u7120\u712B\u712D\u712F\u7130\u7131\u7138\u7141\u7145\u7146\u7147\u714A\u714B\u7150\u7152\u7157\u715A\u715C\u715E\u7160"],
      ["8fcaa1", "\u7168\u7179\u7180\u7185\u7187\u718C\u7192\u719A\u719B\u71A0\u71A2\u71AF\u71B0\u71B2\u71B3\u71BA\u71BF\u71C0\u71C1\u71C4\u71CB\u71CC\u71D3\u71D6\u71D9\u71DA\u71DC\u71F8\u71FE\u7200\u7207\u7208\u7209\u7213\u7217\u721A\u721D\u721F\u7224\u722B\u722F\u7234\u7238\u7239\u7241\u7242\u7243\u7245\u724E\u724F\u7250\u7253\u7255\u7256\u725A\u725C\u725E\u7260\u7263\u7268\u726B\u726E\u726F\u7271\u7277\u7278\u727B\u727C\u727F\u7284\u7289\u728D\u728E\u7293\u729B\u72A8\u72AD\u72AE\u72B1\u72B4\u72BE\u72C1\u72C7\u72C9\u72CC\u72D5\u72D6\u72D8\u72DF\u72E5\u72F3\u72F4\u72FA\u72FB"],
      ["8fcba1", "\u72FE\u7302\u7304\u7305\u7307\u730B\u730D\u7312\u7313\u7318\u7319\u731E\u7322\u7324\u7327\u7328\u732C\u7331\u7332\u7335\u733A\u733B\u733D\u7343\u734D\u7350\u7352\u7356\u7358\u735D\u735E\u735F\u7360\u7366\u7367\u7369\u736B\u736C\u736E\u736F\u7371\u7377\u7379\u737C\u7380\u7381\u7383\u7385\u7386\u738E\u7390\u7393\u7395\u7397\u7398\u739C\u739E\u739F\u73A0\u73A2\u73A5\u73A6\u73AA\u73AB\u73AD\u73B5\u73B7\u73B9\u73BC\u73BD\u73BF\u73C5\u73C6\u73C9\u73CB\u73CC\u73CF\u73D2\u73D3\u73D6\u73D9\u73DD\u73E1\u73E3\u73E6\u73E7\u73E9\u73F4\u73F5\u73F7\u73F9\u73FA\u73FB\u73FD"],
      ["8fcca1", "\u73FF\u7400\u7401\u7404\u7407\u740A\u7411\u741A\u741B\u7424\u7426\u7428", 9, "\u7439\u7440\u7443\u7444\u7446\u7447\u744B\u744D\u7451\u7452\u7457\u745D\u7462\u7466\u7467\u7468\u746B\u746D\u746E\u7471\u7472\u7480\u7481\u7485\u7486\u7487\u7489\u748F\u7490\u7491\u7492\u7498\u7499\u749A\u749C\u749F\u74A0\u74A1\u74A3\u74A6\u74A8\u74A9\u74AA\u74AB\u74AE\u74AF\u74B1\u74B2\u74B5\u74B9\u74BB\u74BF\u74C8\u74C9\u74CC\u74D0\u74D3\u74D8\u74DA\u74DB\u74DE\u74DF\u74E4\u74E8\u74EA\u74EB\u74EF\u74F4\u74FA\u74FB\u74FC\u74FF\u7506"],
      ["8fcda1", "\u7512\u7516\u7517\u7520\u7521\u7524\u7527\u7529\u752A\u752F\u7536\u7539\u753D\u753E\u753F\u7540\u7543\u7547\u7548\u754E\u7550\u7552\u7557\u755E\u755F\u7561\u756F\u7571\u7579", 5, "\u7581\u7585\u7590\u7592\u7593\u7595\u7599\u759C\u75A2\u75A4\u75B4\u75BA\u75BF\u75C0\u75C1\u75C4\u75C6\u75CC\u75CE\u75CF\u75D7\u75DC\u75DF\u75E0\u75E1\u75E4\u75E7\u75EC\u75EE\u75EF\u75F1\u75F9\u7600\u7602\u7603\u7604\u7607\u7608\u760A\u760C\u760F\u7612\u7613\u7615\u7616\u7619\u761B\u761C\u761D\u761E\u7623\u7625\u7626\u7629\u762D\u7632\u7633\u7635\u7638\u7639"],
      ["8fcea1", "\u763A\u763C\u764A\u7640\u7641\u7643\u7644\u7645\u7649\u764B\u7655\u7659\u765F\u7664\u7665\u766D\u766E\u766F\u7671\u7674\u7681\u7685\u768C\u768D\u7695\u769B\u769C\u769D\u769F\u76A0\u76A2", 6, "\u76AA\u76AD\u76BD\u76C1\u76C5\u76C9\u76CB\u76CC\u76CE\u76D4\u76D9\u76E0\u76E6\u76E8\u76EC\u76F0\u76F1\u76F6\u76F9\u76FC\u7700\u7706\u770A\u770E\u7712\u7714\u7715\u7717\u7719\u771A\u771C\u7722\u7728\u772D\u772E\u772F\u7734\u7735\u7736\u7739\u773D\u773E\u7742\u7745\u7746\u774A\u774D\u774E\u774F\u7752\u7756\u7757\u775C\u775E\u775F\u7760\u7762"],
      ["8fcfa1", "\u7764\u7767\u776A\u776C\u7770\u7772\u7773\u7774\u777A\u777D\u7780\u7784\u778C\u778D\u7794\u7795\u7796\u779A\u779F\u77A2\u77A7\u77AA\u77AE\u77AF\u77B1\u77B5\u77BE\u77C3\u77C9\u77D1\u77D2\u77D5\u77D9\u77DE\u77DF\u77E0\u77E4\u77E6\u77EA\u77EC\u77F0\u77F1\u77F4\u77F8\u77FB\u7805\u7806\u7809\u780D\u780E\u7811\u781D\u7821\u7822\u7823\u782D\u782E\u7830\u7835\u7837\u7843\u7844\u7847\u7848\u784C\u784E\u7852\u785C\u785E\u7860\u7861\u7863\u7864\u7868\u786A\u786E\u787A\u787E\u788A\u788F\u7894\u7898\u78A1\u789D\u789E\u789F\u78A4\u78A8\u78AC\u78AD\u78B0\u78B1\u78B2\u78B3"],
      ["8fd0a1", "\u78BB\u78BD\u78BF\u78C7\u78C8\u78C9\u78CC\u78CE\u78D2\u78D3\u78D5\u78D6\u78E4\u78DB\u78DF\u78E0\u78E1\u78E6\u78EA\u78F2\u78F3\u7900\u78F6\u78F7\u78FA\u78FB\u78FF\u7906\u790C\u7910\u791A\u791C\u791E\u791F\u7920\u7925\u7927\u7929\u792D\u7931\u7934\u7935\u793B\u793D\u793F\u7944\u7945\u7946\u794A\u794B\u794F\u7951\u7954\u7958\u795B\u795C\u7967\u7969\u796B\u7972\u7979\u797B\u797C\u797E\u798B\u798C\u7991\u7993\u7994\u7995\u7996\u7998\u799B\u799C\u79A1\u79A8\u79A9\u79AB\u79AF\u79B1\u79B4\u79B8\u79BB\u79C2\u79C4\u79C7\u79C8\u79CA\u79CF\u79D4\u79D6\u79DA\u79DD\u79DE"],
      ["8fd1a1", "\u79E0\u79E2\u79E5\u79EA\u79EB\u79ED\u79F1\u79F8\u79FC\u7A02\u7A03\u7A07\u7A09\u7A0A\u7A0C\u7A11\u7A15\u7A1B\u7A1E\u7A21\u7A27\u7A2B\u7A2D\u7A2F\u7A30\u7A34\u7A35\u7A38\u7A39\u7A3A\u7A44\u7A45\u7A47\u7A48\u7A4C\u7A55\u7A56\u7A59\u7A5C\u7A5D\u7A5F\u7A60\u7A65\u7A67\u7A6A\u7A6D\u7A75\u7A78\u7A7E\u7A80\u7A82\u7A85\u7A86\u7A8A\u7A8B\u7A90\u7A91\u7A94\u7A9E\u7AA0\u7AA3\u7AAC\u7AB3\u7AB5\u7AB9\u7ABB\u7ABC\u7AC6\u7AC9\u7ACC\u7ACE\u7AD1\u7ADB\u7AE8\u7AE9\u7AEB\u7AEC\u7AF1\u7AF4\u7AFB\u7AFD\u7AFE\u7B07\u7B14\u7B1F\u7B23\u7B27\u7B29\u7B2A\u7B2B\u7B2D\u7B2E\u7B2F\u7B30"],
      ["8fd2a1", "\u7B31\u7B34\u7B3D\u7B3F\u7B40\u7B41\u7B47\u7B4E\u7B55\u7B60\u7B64\u7B66\u7B69\u7B6A\u7B6D\u7B6F\u7B72\u7B73\u7B77\u7B84\u7B89\u7B8E\u7B90\u7B91\u7B96\u7B9B\u7B9E\u7BA0\u7BA5\u7BAC\u7BAF\u7BB0\u7BB2\u7BB5\u7BB6\u7BBA\u7BBB\u7BBC\u7BBD\u7BC2\u7BC5\u7BC8\u7BCA\u7BD4\u7BD6\u7BD7\u7BD9\u7BDA\u7BDB\u7BE8\u7BEA\u7BF2\u7BF4\u7BF5\u7BF8\u7BF9\u7BFA\u7BFC\u7BFE\u7C01\u7C02\u7C03\u7C04\u7C06\u7C09\u7C0B\u7C0C\u7C0E\u7C0F\u7C19\u7C1B\u7C20\u7C25\u7C26\u7C28\u7C2C\u7C31\u7C33\u7C34\u7C36\u7C39\u7C3A\u7C46\u7C4A\u7C55\u7C51\u7C52\u7C53\u7C59", 5],
      ["8fd3a1", "\u7C61\u7C63\u7C67\u7C69\u7C6D\u7C6E\u7C70\u7C72\u7C79\u7C7C\u7C7D\u7C86\u7C87\u7C8F\u7C94\u7C9E\u7CA0\u7CA6\u7CB0\u7CB6\u7CB7\u7CBA\u7CBB\u7CBC\u7CBF\u7CC4\u7CC7\u7CC8\u7CC9\u7CCD\u7CCF\u7CD3\u7CD4\u7CD5\u7CD7\u7CD9\u7CDA\u7CDD\u7CE6\u7CE9\u7CEB\u7CF5\u7D03\u7D07\u7D08\u7D09\u7D0F\u7D11\u7D12\u7D13\u7D16\u7D1D\u7D1E\u7D23\u7D26\u7D2A\u7D2D\u7D31\u7D3C\u7D3D\u7D3E\u7D40\u7D41\u7D47\u7D48\u7D4D\u7D51\u7D53\u7D57\u7D59\u7D5A\u7D5C\u7D5D\u7D65\u7D67\u7D6A\u7D70\u7D78\u7D7A\u7D7B\u7D7F\u7D81\u7D82\u7D83\u7D85\u7D86\u7D88\u7D8B\u7D8C\u7D8D\u7D91\u7D96\u7D97\u7D9D"],
      ["8fd4a1", "\u7D9E\u7DA6\u7DA7\u7DAA\u7DB3\u7DB6\u7DB7\u7DB9\u7DC2", 4, "\u7DCC\u7DCD\u7DCE\u7DD7\u7DD9\u7E00\u7DE2\u7DE5\u7DE6\u7DEA\u7DEB\u7DED\u7DF1\u7DF5\u7DF6\u7DF9\u7DFA\u7E08\u7E10\u7E11\u7E15\u7E17\u7E1C\u7E1D\u7E20\u7E27\u7E28\u7E2C\u7E2D\u7E2F\u7E33\u7E36\u7E3F\u7E44\u7E45\u7E47\u7E4E\u7E50\u7E52\u7E58\u7E5F\u7E61\u7E62\u7E65\u7E6B\u7E6E\u7E6F\u7E73\u7E78\u7E7E\u7E81\u7E86\u7E87\u7E8A\u7E8D\u7E91\u7E95\u7E98\u7E9A\u7E9D\u7E9E\u7F3C\u7F3B\u7F3D\u7F3E\u7F3F\u7F43\u7F44\u7F47\u7F4F\u7F52\u7F53\u7F5B\u7F5C\u7F5D\u7F61\u7F63\u7F64\u7F65\u7F66\u7F6D"],
      ["8fd5a1", "\u7F71\u7F7D\u7F7E\u7F7F\u7F80\u7F8B\u7F8D\u7F8F\u7F90\u7F91\u7F96\u7F97\u7F9C\u7FA1\u7FA2\u7FA6\u7FAA\u7FAD\u7FB4\u7FBC\u7FBF\u7FC0\u7FC3\u7FC8\u7FCE\u7FCF\u7FDB\u7FDF\u7FE3\u7FE5\u7FE8\u7FEC\u7FEE\u7FEF\u7FF2\u7FFA\u7FFD\u7FFE\u7FFF\u8007\u8008\u800A\u800D\u800E\u800F\u8011\u8013\u8014\u8016\u801D\u801E\u801F\u8020\u8024\u8026\u802C\u802E\u8030\u8034\u8035\u8037\u8039\u803A\u803C\u803E\u8040\u8044\u8060\u8064\u8066\u806D\u8071\u8075\u8081\u8088\u808E\u809C\u809E\u80A6\u80A7\u80AB\u80B8\u80B9\u80C8\u80CD\u80CF\u80D2\u80D4\u80D5\u80D7\u80D8\u80E0\u80ED\u80EE"],
      ["8fd6a1", "\u80F0\u80F2\u80F3\u80F6\u80F9\u80FA\u80FE\u8103\u810B\u8116\u8117\u8118\u811C\u811E\u8120\u8124\u8127\u812C\u8130\u8135\u813A\u813C\u8145\u8147\u814A\u814C\u8152\u8157\u8160\u8161\u8167\u8168\u8169\u816D\u816F\u8177\u8181\u8190\u8184\u8185\u8186\u818B\u818E\u8196\u8198\u819B\u819E\u81A2\u81AE\u81B2\u81B4\u81BB\u81CB\u81C3\u81C5\u81CA\u81CE\u81CF\u81D5\u81D7\u81DB\u81DD\u81DE\u81E1\u81E4\u81EB\u81EC\u81F0\u81F1\u81F2\u81F5\u81F6\u81F8\u81F9\u81FD\u81FF\u8200\u8203\u820F\u8213\u8214\u8219\u821A\u821D\u8221\u8222\u8228\u8232\u8234\u823A\u8243\u8244\u8245\u8246"],
      ["8fd7a1", "\u824B\u824E\u824F\u8251\u8256\u825C\u8260\u8263\u8267\u826D\u8274\u827B\u827D\u827F\u8280\u8281\u8283\u8284\u8287\u8289\u828A\u828E\u8291\u8294\u8296\u8298\u829A\u829B\u82A0\u82A1\u82A3\u82A4\u82A7\u82A8\u82A9\u82AA\u82AE\u82B0\u82B2\u82B4\u82B7\u82BA\u82BC\u82BE\u82BF\u82C6\u82D0\u82D5\u82DA\u82E0\u82E2\u82E4\u82E8\u82EA\u82ED\u82EF\u82F6\u82F7\u82FD\u82FE\u8300\u8301\u8307\u8308\u830A\u830B\u8354\u831B\u831D\u831E\u831F\u8321\u8322\u832C\u832D\u832E\u8330\u8333\u8337\u833A\u833C\u833D\u8342\u8343\u8344\u8347\u834D\u834E\u8351\u8355\u8356\u8357\u8370\u8378"],
      ["8fd8a1", "\u837D\u837F\u8380\u8382\u8384\u8386\u838D\u8392\u8394\u8395\u8398\u8399\u839B\u839C\u839D\u83A6\u83A7\u83A9\u83AC\u83BE\u83BF\u83C0\u83C7\u83C9\u83CF\u83D0\u83D1\u83D4\u83DD\u8353\u83E8\u83EA\u83F6\u83F8\u83F9\u83FC\u8401\u8406\u840A\u840F\u8411\u8415\u8419\u83AD\u842F\u8439\u8445\u8447\u8448\u844A\u844D\u844F\u8451\u8452\u8456\u8458\u8459\u845A\u845C\u8460\u8464\u8465\u8467\u846A\u8470\u8473\u8474\u8476\u8478\u847C\u847D\u8481\u8485\u8492\u8493\u8495\u849E\u84A6\u84A8\u84A9\u84AA\u84AF\u84B1\u84B4\u84BA\u84BD\u84BE\u84C0\u84C2\u84C7\u84C8\u84CC\u84CF\u84D3"],
      ["8fd9a1", "\u84DC\u84E7\u84EA\u84EF\u84F0\u84F1\u84F2\u84F7\u8532\u84FA\u84FB\u84FD\u8502\u8503\u8507\u850C\u850E\u8510\u851C\u851E\u8522\u8523\u8524\u8525\u8527\u852A\u852B\u852F\u8533\u8534\u8536\u853F\u8546\u854F", 4, "\u8556\u8559\u855C", 6, "\u8564\u856B\u856F\u8579\u857A\u857B\u857D\u857F\u8581\u8585\u8586\u8589\u858B\u858C\u858F\u8593\u8598\u859D\u859F\u85A0\u85A2\u85A5\u85A7\u85B4\u85B6\u85B7\u85B8\u85BC\u85BD\u85BE\u85BF\u85C2\u85C7\u85CA\u85CB\u85CE\u85AD\u85D8\u85DA\u85DF\u85E0\u85E6\u85E8\u85ED\u85F3\u85F6\u85FC"],
      ["8fdaa1", "\u85FF\u8600\u8604\u8605\u860D\u860E\u8610\u8611\u8612\u8618\u8619\u861B\u861E\u8621\u8627\u8629\u8636\u8638\u863A\u863C\u863D\u8640\u8642\u8646\u8652\u8653\u8656\u8657\u8658\u8659\u865D\u8660", 4, "\u8669\u866C\u866F\u8675\u8676\u8677\u867A\u868D\u8691\u8696\u8698\u869A\u869C\u86A1\u86A6\u86A7\u86A8\u86AD\u86B1\u86B3\u86B4\u86B5\u86B7\u86B8\u86B9\u86BF\u86C0\u86C1\u86C3\u86C5\u86D1\u86D2\u86D5\u86D7\u86DA\u86DC\u86E0\u86E3\u86E5\u86E7\u8688\u86FA\u86FC\u86FD\u8704\u8705\u8707\u870B\u870E\u870F\u8710\u8713\u8714\u8719\u871E\u871F\u8721\u8723"],
      ["8fdba1", "\u8728\u872E\u872F\u8731\u8732\u8739\u873A\u873C\u873D\u873E\u8740\u8743\u8745\u874D\u8758\u875D\u8761\u8764\u8765\u876F\u8771\u8772\u877B\u8783", 6, "\u878B\u878C\u8790\u8793\u8795\u8797\u8798\u8799\u879E\u87A0\u87A3\u87A7\u87AC\u87AD\u87AE\u87B1\u87B5\u87BE\u87BF\u87C1\u87C8\u87C9\u87CA\u87CE\u87D5\u87D6\u87D9\u87DA\u87DC\u87DF\u87E2\u87E3\u87E4\u87EA\u87EB\u87ED\u87F1\u87F3\u87F8\u87FA\u87FF\u8801\u8803\u8806\u8809\u880A\u880B\u8810\u8819\u8812\u8813\u8814\u8818\u881A\u881B\u881C\u881E\u881F\u8828\u882D\u882E\u8830\u8832\u8835"],
      ["8fdca1", "\u883A\u883C\u8841\u8843\u8845\u8848\u8849\u884A\u884B\u884E\u8851\u8855\u8856\u8858\u885A\u885C\u885F\u8860\u8864\u8869\u8871\u8879\u887B\u8880\u8898\u889A\u889B\u889C\u889F\u88A0\u88A8\u88AA\u88BA\u88BD\u88BE\u88C0\u88CA", 4, "\u88D1\u88D2\u88D3\u88DB\u88DE\u88E7\u88EF\u88F0\u88F1\u88F5\u88F7\u8901\u8906\u890D\u890E\u890F\u8915\u8916\u8918\u8919\u891A\u891C\u8920\u8926\u8927\u8928\u8930\u8931\u8932\u8935\u8939\u893A\u893E\u8940\u8942\u8945\u8946\u8949\u894F\u8952\u8957\u895A\u895B\u895C\u8961\u8962\u8963\u896B\u896E\u8970\u8973\u8975\u897A"],
      ["8fdda1", "\u897B\u897C\u897D\u8989\u898D\u8990\u8994\u8995\u899B\u899C\u899F\u89A0\u89A5\u89B0\u89B4\u89B5\u89B6\u89B7\u89BC\u89D4", 4, "\u89E5\u89E9\u89EB\u89ED\u89F1\u89F3\u89F6\u89F9\u89FD\u89FF\u8A04\u8A05\u8A07\u8A0F\u8A11\u8A12\u8A14\u8A15\u8A1E\u8A20\u8A22\u8A24\u8A26\u8A2B\u8A2C\u8A2F\u8A35\u8A37\u8A3D\u8A3E\u8A40\u8A43\u8A45\u8A47\u8A49\u8A4D\u8A4E\u8A53\u8A56\u8A57\u8A58\u8A5C\u8A5D\u8A61\u8A65\u8A67\u8A75\u8A76\u8A77\u8A79\u8A7A\u8A7B\u8A7E\u8A7F\u8A80\u8A83\u8A86\u8A8B\u8A8F\u8A90\u8A92\u8A96\u8A97\u8A99\u8A9F\u8AA7\u8AA9\u8AAE\u8AAF\u8AB3"],
      ["8fdea1", "\u8AB6\u8AB7\u8ABB\u8ABE\u8AC3\u8AC6\u8AC8\u8AC9\u8ACA\u8AD1\u8AD3\u8AD4\u8AD5\u8AD7\u8ADD\u8ADF\u8AEC\u8AF0\u8AF4\u8AF5\u8AF6\u8AFC\u8AFF\u8B05\u8B06\u8B0B\u8B11\u8B1C\u8B1E\u8B1F\u8B0A\u8B2D\u8B30\u8B37\u8B3C\u8B42", 4, "\u8B48\u8B52\u8B53\u8B54\u8B59\u8B4D\u8B5E\u8B63\u8B6D\u8B76\u8B78\u8B79\u8B7C\u8B7E\u8B81\u8B84\u8B85\u8B8B\u8B8D\u8B8F\u8B94\u8B95\u8B9C\u8B9E\u8B9F\u8C38\u8C39\u8C3D\u8C3E\u8C45\u8C47\u8C49\u8C4B\u8C4F\u8C51\u8C53\u8C54\u8C57\u8C58\u8C5B\u8C5D\u8C59\u8C63\u8C64\u8C66\u8C68\u8C69\u8C6D\u8C73\u8C75\u8C76\u8C7B\u8C7E\u8C86"],
      ["8fdfa1", "\u8C87\u8C8B\u8C90\u8C92\u8C93\u8C99\u8C9B\u8C9C\u8CA4\u8CB9\u8CBA\u8CC5\u8CC6\u8CC9\u8CCB\u8CCF\u8CD6\u8CD5\u8CD9\u8CDD\u8CE1\u8CE8\u8CEC\u8CEF\u8CF0\u8CF2\u8CF5\u8CF7\u8CF8\u8CFE\u8CFF\u8D01\u8D03\u8D09\u8D12\u8D17\u8D1B\u8D65\u8D69\u8D6C\u8D6E\u8D7F\u8D82\u8D84\u8D88\u8D8D\u8D90\u8D91\u8D95\u8D9E\u8D9F\u8DA0\u8DA6\u8DAB\u8DAC\u8DAF\u8DB2\u8DB5\u8DB7\u8DB9\u8DBB\u8DC0\u8DC5\u8DC6\u8DC7\u8DC8\u8DCA\u8DCE\u8DD1\u8DD4\u8DD5\u8DD7\u8DD9\u8DE4\u8DE5\u8DE7\u8DEC\u8DF0\u8DBC\u8DF1\u8DF2\u8DF4\u8DFD\u8E01\u8E04\u8E05\u8E06\u8E0B\u8E11\u8E14\u8E16\u8E20\u8E21\u8E22"],
      ["8fe0a1", "\u8E23\u8E26\u8E27\u8E31\u8E33\u8E36\u8E37\u8E38\u8E39\u8E3D\u8E40\u8E41\u8E4B\u8E4D\u8E4E\u8E4F\u8E54\u8E5B\u8E5C\u8E5D\u8E5E\u8E61\u8E62\u8E69\u8E6C\u8E6D\u8E6F\u8E70\u8E71\u8E79\u8E7A\u8E7B\u8E82\u8E83\u8E89\u8E90\u8E92\u8E95\u8E9A\u8E9B\u8E9D\u8E9E\u8EA2\u8EA7\u8EA9\u8EAD\u8EAE\u8EB3\u8EB5\u8EBA\u8EBB\u8EC0\u8EC1\u8EC3\u8EC4\u8EC7\u8ECF\u8ED1\u8ED4\u8EDC\u8EE8\u8EEE\u8EF0\u8EF1\u8EF7\u8EF9\u8EFA\u8EED\u8F00\u8F02\u8F07\u8F08\u8F0F\u8F10\u8F16\u8F17\u8F18\u8F1E\u8F20\u8F21\u8F23\u8F25\u8F27\u8F28\u8F2C\u8F2D\u8F2E\u8F34\u8F35\u8F36\u8F37\u8F3A\u8F40\u8F41"],
      ["8fe1a1", "\u8F43\u8F47\u8F4F\u8F51", 4, "\u8F58\u8F5D\u8F5E\u8F65\u8F9D\u8FA0\u8FA1\u8FA4\u8FA5\u8FA6\u8FB5\u8FB6\u8FB8\u8FBE\u8FC0\u8FC1\u8FC6\u8FCA\u8FCB\u8FCD\u8FD0\u8FD2\u8FD3\u8FD5\u8FE0\u8FE3\u8FE4\u8FE8\u8FEE\u8FF1\u8FF5\u8FF6\u8FFB\u8FFE\u9002\u9004\u9008\u900C\u9018\u901B\u9028\u9029\u902F\u902A\u902C\u902D\u9033\u9034\u9037\u903F\u9043\u9044\u904C\u905B\u905D\u9062\u9066\u9067\u906C\u9070\u9074\u9079\u9085\u9088\u908B\u908C\u908E\u9090\u9095\u9097\u9098\u9099\u909B\u90A0\u90A1\u90A2\u90A5\u90B0\u90B2\u90B3\u90B4\u90B6\u90BD\u90CC\u90BE\u90C3"],
      ["8fe2a1", "\u90C4\u90C5\u90C7\u90C8\u90D5\u90D7\u90D8\u90D9\u90DC\u90DD\u90DF\u90E5\u90D2\u90F6\u90EB\u90EF\u90F0\u90F4\u90FE\u90FF\u9100\u9104\u9105\u9106\u9108\u910D\u9110\u9114\u9116\u9117\u9118\u911A\u911C\u911E\u9120\u9125\u9122\u9123\u9127\u9129\u912E\u912F\u9131\u9134\u9136\u9137\u9139\u913A\u913C\u913D\u9143\u9147\u9148\u914F\u9153\u9157\u9159\u915A\u915B\u9161\u9164\u9167\u916D\u9174\u9179\u917A\u917B\u9181\u9183\u9185\u9186\u918A\u918E\u9191\u9193\u9194\u9195\u9198\u919E\u91A1\u91A6\u91A8\u91AC\u91AD\u91AE\u91B0\u91B1\u91B2\u91B3\u91B6\u91BB\u91BC\u91BD\u91BF"],
      ["8fe3a1", "\u91C2\u91C3\u91C5\u91D3\u91D4\u91D7\u91D9\u91DA\u91DE\u91E4\u91E5\u91E9\u91EA\u91EC", 5, "\u91F7\u91F9\u91FB\u91FD\u9200\u9201\u9204\u9205\u9206\u9207\u9209\u920A\u920C\u9210\u9212\u9213\u9216\u9218\u921C\u921D\u9223\u9224\u9225\u9226\u9228\u922E\u922F\u9230\u9233\u9235\u9236\u9238\u9239\u923A\u923C\u923E\u9240\u9242\u9243\u9246\u9247\u924A\u924D\u924E\u924F\u9251\u9258\u9259\u925C\u925D\u9260\u9261\u9265\u9267\u9268\u9269\u926E\u926F\u9270\u9275", 4, "\u927B\u927C\u927D\u927F\u9288\u9289\u928A\u928D\u928E\u9292\u9297"],
      ["8fe4a1", "\u9299\u929F\u92A0\u92A4\u92A5\u92A7\u92A8\u92AB\u92AF\u92B2\u92B6\u92B8\u92BA\u92BB\u92BC\u92BD\u92BF", 4, "\u92C5\u92C6\u92C7\u92C8\u92CB\u92CC\u92CD\u92CE\u92D0\u92D3\u92D5\u92D7\u92D8\u92D9\u92DC\u92DD\u92DF\u92E0\u92E1\u92E3\u92E5\u92E7\u92E8\u92EC\u92EE\u92F0\u92F9\u92FB\u92FF\u9300\u9302\u9308\u930D\u9311\u9314\u9315\u931C\u931D\u931E\u931F\u9321\u9324\u9325\u9327\u9329\u932A\u9333\u9334\u9336\u9337\u9347\u9348\u9349\u9350\u9351\u9352\u9355\u9357\u9358\u935A\u935E\u9364\u9365\u9367\u9369\u936A\u936D\u936F\u9370\u9371\u9373\u9374\u9376"],
      ["8fe5a1", "\u937A\u937D\u937F\u9380\u9381\u9382\u9388\u938A\u938B\u938D\u938F\u9392\u9395\u9398\u939B\u939E\u93A1\u93A3\u93A4\u93A6\u93A8\u93AB\u93B4\u93B5\u93B6\u93BA\u93A9\u93C1\u93C4\u93C5\u93C6\u93C7\u93C9", 4, "\u93D3\u93D9\u93DC\u93DE\u93DF\u93E2\u93E6\u93E7\u93F9\u93F7\u93F8\u93FA\u93FB\u93FD\u9401\u9402\u9404\u9408\u9409\u940D\u940E\u940F\u9415\u9416\u9417\u941F\u942E\u942F\u9431\u9432\u9433\u9434\u943B\u943F\u943D\u9443\u9445\u9448\u944A\u944C\u9455\u9459\u945C\u945F\u9461\u9463\u9468\u946B\u946D\u946E\u946F\u9471\u9472\u9484\u9483\u9578\u9579"],
      ["8fe6a1", "\u957E\u9584\u9588\u958C\u958D\u958E\u959D\u959E\u959F\u95A1\u95A6\u95A9\u95AB\u95AC\u95B4\u95B6\u95BA\u95BD\u95BF\u95C6\u95C8\u95C9\u95CB\u95D0\u95D1\u95D2\u95D3\u95D9\u95DA\u95DD\u95DE\u95DF\u95E0\u95E4\u95E6\u961D\u961E\u9622\u9624\u9625\u9626\u962C\u9631\u9633\u9637\u9638\u9639\u963A\u963C\u963D\u9641\u9652\u9654\u9656\u9657\u9658\u9661\u966E\u9674\u967B\u967C\u967E\u967F\u9681\u9682\u9683\u9684\u9689\u9691\u9696\u969A\u969D\u969F\u96A4\u96A5\u96A6\u96A9\u96AE\u96AF\u96B3\u96BA\u96CA\u96D2\u5DB2\u96D8\u96DA\u96DD\u96DE\u96DF\u96E9\u96EF\u96F1\u96FA\u9702"],
      ["8fe7a1", "\u9703\u9705\u9709\u971A\u971B\u971D\u9721\u9722\u9723\u9728\u9731\u9733\u9741\u9743\u974A\u974E\u974F\u9755\u9757\u9758\u975A\u975B\u9763\u9767\u976A\u976E\u9773\u9776\u9777\u9778\u977B\u977D\u977F\u9780\u9789\u9795\u9796\u9797\u9799\u979A\u979E\u979F\u97A2\u97AC\u97AE\u97B1\u97B2\u97B5\u97B6\u97B8\u97B9\u97BA\u97BC\u97BE\u97BF\u97C1\u97C4\u97C5\u97C7\u97C9\u97CA\u97CC\u97CD\u97CE\u97D0\u97D1\u97D4\u97D7\u97D8\u97D9\u97DD\u97DE\u97E0\u97DB\u97E1\u97E4\u97EF\u97F1\u97F4\u97F7\u97F8\u97FA\u9807\u980A\u9819\u980D\u980E\u9814\u9816\u981C\u981E\u9820\u9823\u9826"],
      ["8fe8a1", "\u982B\u982E\u982F\u9830\u9832\u9833\u9835\u9825\u983E\u9844\u9847\u984A\u9851\u9852\u9853\u9856\u9857\u9859\u985A\u9862\u9863\u9865\u9866\u986A\u986C\u98AB\u98AD\u98AE\u98B0\u98B4\u98B7\u98B8\u98BA\u98BB\u98BF\u98C2\u98C5\u98C8\u98CC\u98E1\u98E3\u98E5\u98E6\u98E7\u98EA\u98F3\u98F6\u9902\u9907\u9908\u9911\u9915\u9916\u9917\u991A\u991B\u991C\u991F\u9922\u9926\u9927\u992B\u9931", 4, "\u9939\u993A\u993B\u993C\u9940\u9941\u9946\u9947\u9948\u994D\u994E\u9954\u9958\u9959\u995B\u995C\u995E\u995F\u9960\u999B\u999D\u999F\u99A6\u99B0\u99B1\u99B2\u99B5"],
      ["8fe9a1", "\u99B9\u99BA\u99BD\u99BF\u99C3\u99C9\u99D3\u99D4\u99D9\u99DA\u99DC\u99DE\u99E7\u99EA\u99EB\u99EC\u99F0\u99F4\u99F5\u99F9\u99FD\u99FE\u9A02\u9A03\u9A04\u9A0B\u9A0C\u9A10\u9A11\u9A16\u9A1E\u9A20\u9A22\u9A23\u9A24\u9A27\u9A2D\u9A2E\u9A33\u9A35\u9A36\u9A38\u9A47\u9A41\u9A44\u9A4A\u9A4B\u9A4C\u9A4E\u9A51\u9A54\u9A56\u9A5D\u9AAA\u9AAC\u9AAE\u9AAF\u9AB2\u9AB4\u9AB5\u9AB6\u9AB9\u9ABB\u9ABE\u9ABF\u9AC1\u9AC3\u9AC6\u9AC8\u9ACE\u9AD0\u9AD2\u9AD5\u9AD6\u9AD7\u9ADB\u9ADC\u9AE0\u9AE4\u9AE5\u9AE7\u9AE9\u9AEC\u9AF2\u9AF3\u9AF5\u9AF9\u9AFA\u9AFD\u9AFF", 4],
      ["8feaa1", "\u9B04\u9B05\u9B08\u9B09\u9B0B\u9B0C\u9B0D\u9B0E\u9B10\u9B12\u9B16\u9B19\u9B1B\u9B1C\u9B20\u9B26\u9B2B\u9B2D\u9B33\u9B34\u9B35\u9B37\u9B39\u9B3A\u9B3D\u9B48\u9B4B\u9B4C\u9B55\u9B56\u9B57\u9B5B\u9B5E\u9B61\u9B63\u9B65\u9B66\u9B68\u9B6A", 4, "\u9B73\u9B75\u9B77\u9B78\u9B79\u9B7F\u9B80\u9B84\u9B85\u9B86\u9B87\u9B89\u9B8A\u9B8B\u9B8D\u9B8F\u9B90\u9B94\u9B9A\u9B9D\u9B9E\u9BA6\u9BA7\u9BA9\u9BAC\u9BB0\u9BB1\u9BB2\u9BB7\u9BB8\u9BBB\u9BBC\u9BBE\u9BBF\u9BC1\u9BC7\u9BC8\u9BCE\u9BD0\u9BD7\u9BD8\u9BDD\u9BDF\u9BE5\u9BE7\u9BEA\u9BEB\u9BEF\u9BF3\u9BF7\u9BF8"],
      ["8feba1", "\u9BF9\u9BFA\u9BFD\u9BFF\u9C00\u9C02\u9C0B\u9C0F\u9C11\u9C16\u9C18\u9C19\u9C1A\u9C1C\u9C1E\u9C22\u9C23\u9C26", 4, "\u9C31\u9C35\u9C36\u9C37\u9C3D\u9C41\u9C43\u9C44\u9C45\u9C49\u9C4A\u9C4E\u9C4F\u9C50\u9C53\u9C54\u9C56\u9C58\u9C5B\u9C5D\u9C5E\u9C5F\u9C63\u9C69\u9C6A\u9C5C\u9C6B\u9C68\u9C6E\u9C70\u9C72\u9C75\u9C77\u9C7B\u9CE6\u9CF2\u9CF7\u9CF9\u9D0B\u9D02\u9D11\u9D17\u9D18\u9D1C\u9D1D\u9D1E\u9D2F\u9D30\u9D32\u9D33\u9D34\u9D3A\u9D3C\u9D45\u9D3D\u9D42\u9D43\u9D47\u9D4A\u9D53\u9D54\u9D5F\u9D63\u9D62\u9D65\u9D69\u9D6A\u9D6B\u9D70\u9D76\u9D77\u9D7B"],
      ["8feca1", "\u9D7C\u9D7E\u9D83\u9D84\u9D86\u9D8A\u9D8D\u9D8E\u9D92\u9D93\u9D95\u9D96\u9D97\u9D98\u9DA1\u9DAA\u9DAC\u9DAE\u9DB1\u9DB5\u9DB9\u9DBC\u9DBF\u9DC3\u9DC7\u9DC9\u9DCA\u9DD4\u9DD5\u9DD6\u9DD7\u9DDA\u9DDE\u9DDF\u9DE0\u9DE5\u9DE7\u9DE9\u9DEB\u9DEE\u9DF0\u9DF3\u9DF4\u9DFE\u9E0A\u9E02\u9E07\u9E0E\u9E10\u9E11\u9E12\u9E15\u9E16\u9E19\u9E1C\u9E1D\u9E7A\u9E7B\u9E7C\u9E80\u9E82\u9E83\u9E84\u9E85\u9E87\u9E8E\u9E8F\u9E96\u9E98\u9E9B\u9E9E\u9EA4\u9EA8\u9EAC\u9EAE\u9EAF\u9EB0\u9EB3\u9EB4\u9EB5\u9EC6\u9EC8\u9ECB\u9ED5\u9EDF\u9EE4\u9EE7\u9EEC\u9EED\u9EEE\u9EF0\u9EF1\u9EF2\u9EF5"],
      ["8feda1", "\u9EF8\u9EFF\u9F02\u9F03\u9F09\u9F0F\u9F10\u9F11\u9F12\u9F14\u9F16\u9F17\u9F19\u9F1A\u9F1B\u9F1F\u9F22\u9F26\u9F2A\u9F2B\u9F2F\u9F31\u9F32\u9F34\u9F37\u9F39\u9F3A\u9F3C\u9F3D\u9F3F\u9F41\u9F43", 4, "\u9F53\u9F55\u9F56\u9F57\u9F58\u9F5A\u9F5D\u9F5E\u9F68\u9F69\u9F6D", 4, "\u9F73\u9F75\u9F7A\u9F7D\u9F8F\u9F90\u9F91\u9F92\u9F94\u9F96\u9F97\u9F9E\u9FA1\u9FA2\u9FA3\u9FA5"]
    ];
  }
});

// node_modules/iconv-lite/encodings/tables/cp936.json
var require_cp936 = __commonJS({
  "node_modules/iconv-lite/encodings/tables/cp936.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127, "\u20AC"],
      ["8140", "\u4E02\u4E04\u4E05\u4E06\u4E0F\u4E12\u4E17\u4E1F\u4E20\u4E21\u4E23\u4E26\u4E29\u4E2E\u4E2F\u4E31\u4E33\u4E35\u4E37\u4E3C\u4E40\u4E41\u4E42\u4E44\u4E46\u4E4A\u4E51\u4E55\u4E57\u4E5A\u4E5B\u4E62\u4E63\u4E64\u4E65\u4E67\u4E68\u4E6A", 5, "\u4E72\u4E74", 9, "\u4E7F", 6, "\u4E87\u4E8A"],
      ["8180", "\u4E90\u4E96\u4E97\u4E99\u4E9C\u4E9D\u4E9E\u4EA3\u4EAA\u4EAF\u4EB0\u4EB1\u4EB4\u4EB6\u4EB7\u4EB8\u4EB9\u4EBC\u4EBD\u4EBE\u4EC8\u4ECC\u4ECF\u4ED0\u4ED2\u4EDA\u4EDB\u4EDC\u4EE0\u4EE2\u4EE6\u4EE7\u4EE9\u4EED\u4EEE\u4EEF\u4EF1\u4EF4\u4EF8\u4EF9\u4EFA\u4EFC\u4EFE\u4F00\u4F02", 6, "\u4F0B\u4F0C\u4F12", 4, "\u4F1C\u4F1D\u4F21\u4F23\u4F28\u4F29\u4F2C\u4F2D\u4F2E\u4F31\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E", 4, "\u4F44\u4F45\u4F47", 5, "\u4F52\u4F54\u4F56\u4F61\u4F62\u4F66\u4F68\u4F6A\u4F6B\u4F6D\u4F6E\u4F71\u4F72\u4F75\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F80\u4F81\u4F82\u4F85\u4F86\u4F87\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F95\u4F96\u4F98\u4F99\u4F9A\u4F9C\u4F9E\u4F9F\u4FA1\u4FA2"],
      ["8240", "\u4FA4\u4FAB\u4FAD\u4FB0", 4, "\u4FB6", 8, "\u4FC0\u4FC1\u4FC2\u4FC6\u4FC7\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FD2", 4, "\u4FD9\u4FDB\u4FE0\u4FE2\u4FE4\u4FE5\u4FE7\u4FEB\u4FEC\u4FF0\u4FF2\u4FF4\u4FF5\u4FF6\u4FF7\u4FF9\u4FFB\u4FFC\u4FFD\u4FFF", 11],
      ["8280", "\u500B\u500E\u5010\u5011\u5013\u5015\u5016\u5017\u501B\u501D\u501E\u5020\u5022\u5023\u5024\u5027\u502B\u502F", 10, "\u503B\u503D\u503F\u5040\u5041\u5042\u5044\u5045\u5046\u5049\u504A\u504B\u504D\u5050", 4, "\u5056\u5057\u5058\u5059\u505B\u505D", 7, "\u5066", 5, "\u506D", 8, "\u5078\u5079\u507A\u507C\u507D\u5081\u5082\u5083\u5084\u5086\u5087\u5089\u508A\u508B\u508C\u508E", 20, "\u50A4\u50A6\u50AA\u50AB\u50AD", 4, "\u50B3", 6, "\u50BC"],
      ["8340", "\u50BD", 17, "\u50D0", 5, "\u50D7\u50D8\u50D9\u50DB", 10, "\u50E8\u50E9\u50EA\u50EB\u50EF\u50F0\u50F1\u50F2\u50F4\u50F6", 4, "\u50FC", 9, "\u5108"],
      ["8380", "\u5109\u510A\u510C", 5, "\u5113", 13, "\u5122", 28, "\u5142\u5147\u514A\u514C\u514E\u514F\u5150\u5152\u5153\u5157\u5158\u5159\u515B\u515D", 4, "\u5163\u5164\u5166\u5167\u5169\u516A\u516F\u5172\u517A\u517E\u517F\u5183\u5184\u5186\u5187\u518A\u518B\u518E\u518F\u5190\u5191\u5193\u5194\u5198\u519A\u519D\u519E\u519F\u51A1\u51A3\u51A6", 4, "\u51AD\u51AE\u51B4\u51B8\u51B9\u51BA\u51BE\u51BF\u51C1\u51C2\u51C3\u51C5\u51C8\u51CA\u51CD\u51CE\u51D0\u51D2", 5],
      ["8440", "\u51D8\u51D9\u51DA\u51DC\u51DE\u51DF\u51E2\u51E3\u51E5", 5, "\u51EC\u51EE\u51F1\u51F2\u51F4\u51F7\u51FE\u5204\u5205\u5209\u520B\u520C\u520F\u5210\u5213\u5214\u5215\u521C\u521E\u521F\u5221\u5222\u5223\u5225\u5226\u5227\u522A\u522C\u522F\u5231\u5232\u5234\u5235\u523C\u523E\u5244", 5, "\u524B\u524E\u524F\u5252\u5253\u5255\u5257\u5258"],
      ["8480", "\u5259\u525A\u525B\u525D\u525F\u5260\u5262\u5263\u5264\u5266\u5268\u526B\u526C\u526D\u526E\u5270\u5271\u5273", 9, "\u527E\u5280\u5283", 4, "\u5289", 6, "\u5291\u5292\u5294", 6, "\u529C\u52A4\u52A5\u52A6\u52A7\u52AE\u52AF\u52B0\u52B4", 9, "\u52C0\u52C1\u52C2\u52C4\u52C5\u52C6\u52C8\u52CA\u52CC\u52CD\u52CE\u52CF\u52D1\u52D3\u52D4\u52D5\u52D7\u52D9", 5, "\u52E0\u52E1\u52E2\u52E3\u52E5", 10, "\u52F1", 7, "\u52FB\u52FC\u52FD\u5301\u5302\u5303\u5304\u5307\u5309\u530A\u530B\u530C\u530E"],
      ["8540", "\u5311\u5312\u5313\u5314\u5318\u531B\u531C\u531E\u531F\u5322\u5324\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u532F", 9, "\u533C\u533D\u5340\u5342\u5344\u5346\u534B\u534C\u534D\u5350\u5354\u5358\u5359\u535B\u535D\u5365\u5368\u536A\u536C\u536D\u5372\u5376\u5379\u537B\u537C\u537D\u537E\u5380\u5381\u5383\u5387\u5388\u538A\u538E\u538F"],
      ["8580", "\u5390", 4, "\u5396\u5397\u5399\u539B\u539C\u539E\u53A0\u53A1\u53A4\u53A7\u53AA\u53AB\u53AC\u53AD\u53AF", 6, "\u53B7\u53B8\u53B9\u53BA\u53BC\u53BD\u53BE\u53C0\u53C3", 4, "\u53CE\u53CF\u53D0\u53D2\u53D3\u53D5\u53DA\u53DC\u53DD\u53DE\u53E1\u53E2\u53E7\u53F4\u53FA\u53FE\u53FF\u5400\u5402\u5405\u5407\u540B\u5414\u5418\u5419\u541A\u541C\u5422\u5424\u5425\u542A\u5430\u5433\u5436\u5437\u543A\u543D\u543F\u5441\u5442\u5444\u5445\u5447\u5449\u544C\u544D\u544E\u544F\u5451\u545A\u545D", 4, "\u5463\u5465\u5467\u5469", 7, "\u5474\u5479\u547A\u547E\u547F\u5481\u5483\u5485\u5487\u5488\u5489\u548A\u548D\u5491\u5493\u5497\u5498\u549C\u549E\u549F\u54A0\u54A1"],
      ["8640", "\u54A2\u54A5\u54AE\u54B0\u54B2\u54B5\u54B6\u54B7\u54B9\u54BA\u54BC\u54BE\u54C3\u54C5\u54CA\u54CB\u54D6\u54D8\u54DB\u54E0", 4, "\u54EB\u54EC\u54EF\u54F0\u54F1\u54F4", 5, "\u54FB\u54FE\u5500\u5502\u5503\u5504\u5505\u5508\u550A", 4, "\u5512\u5513\u5515", 5, "\u551C\u551D\u551E\u551F\u5521\u5525\u5526"],
      ["8680", "\u5528\u5529\u552B\u552D\u5532\u5534\u5535\u5536\u5538\u5539\u553A\u553B\u553D\u5540\u5542\u5545\u5547\u5548\u554B", 4, "\u5551\u5552\u5553\u5554\u5557", 4, "\u555D\u555E\u555F\u5560\u5562\u5563\u5568\u5569\u556B\u556F", 5, "\u5579\u557A\u557D\u557F\u5585\u5586\u558C\u558D\u558E\u5590\u5592\u5593\u5595\u5596\u5597\u559A\u559B\u559E\u55A0", 6, "\u55A8", 8, "\u55B2\u55B4\u55B6\u55B8\u55BA\u55BC\u55BF", 4, "\u55C6\u55C7\u55C8\u55CA\u55CB\u55CE\u55CF\u55D0\u55D5\u55D7", 4, "\u55DE\u55E0\u55E2\u55E7\u55E9\u55ED\u55EE\u55F0\u55F1\u55F4\u55F6\u55F8", 4, "\u55FF\u5602\u5603\u5604\u5605"],
      ["8740", "\u5606\u5607\u560A\u560B\u560D\u5610", 7, "\u5619\u561A\u561C\u561D\u5620\u5621\u5622\u5625\u5626\u5628\u5629\u562A\u562B\u562E\u562F\u5630\u5633\u5635\u5637\u5638\u563A\u563C\u563D\u563E\u5640", 11, "\u564F", 4, "\u5655\u5656\u565A\u565B\u565D", 4],
      ["8780", "\u5663\u5665\u5666\u5667\u566D\u566E\u566F\u5670\u5672\u5673\u5674\u5675\u5677\u5678\u5679\u567A\u567D", 7, "\u5687", 6, "\u5690\u5691\u5692\u5694", 14, "\u56A4", 10, "\u56B0", 6, "\u56B8\u56B9\u56BA\u56BB\u56BD", 12, "\u56CB", 8, "\u56D5\u56D6\u56D8\u56D9\u56DC\u56E3\u56E5", 5, "\u56EC\u56EE\u56EF\u56F2\u56F3\u56F6\u56F7\u56F8\u56FB\u56FC\u5700\u5701\u5702\u5705\u5707\u570B", 6],
      ["8840", "\u5712", 9, "\u571D\u571E\u5720\u5721\u5722\u5724\u5725\u5726\u5727\u572B\u5731\u5732\u5734", 4, "\u573C\u573D\u573F\u5741\u5743\u5744\u5745\u5746\u5748\u5749\u574B\u5752", 4, "\u5758\u5759\u5762\u5763\u5765\u5767\u576C\u576E\u5770\u5771\u5772\u5774\u5775\u5778\u5779\u577A\u577D\u577E\u577F\u5780"],
      ["8880", "\u5781\u5787\u5788\u5789\u578A\u578D", 4, "\u5794", 6, "\u579C\u579D\u579E\u579F\u57A5\u57A8\u57AA\u57AC\u57AF\u57B0\u57B1\u57B3\u57B5\u57B6\u57B7\u57B9", 8, "\u57C4", 6, "\u57CC\u57CD\u57D0\u57D1\u57D3\u57D6\u57D7\u57DB\u57DC\u57DE\u57E1\u57E2\u57E3\u57E5", 7, "\u57EE\u57F0\u57F1\u57F2\u57F3\u57F5\u57F6\u57F7\u57FB\u57FC\u57FE\u57FF\u5801\u5803\u5804\u5805\u5808\u5809\u580A\u580C\u580E\u580F\u5810\u5812\u5813\u5814\u5816\u5817\u5818\u581A\u581B\u581C\u581D\u581F\u5822\u5823\u5825", 4, "\u582B", 4, "\u5831\u5832\u5833\u5834\u5836", 7],
      ["8940", "\u583E", 5, "\u5845", 6, "\u584E\u584F\u5850\u5852\u5853\u5855\u5856\u5857\u5859", 4, "\u585F", 5, "\u5866", 4, "\u586D", 16, "\u587F\u5882\u5884\u5886\u5887\u5888\u588A\u588B\u588C"],
      ["8980", "\u588D", 4, "\u5894", 4, "\u589B\u589C\u589D\u58A0", 7, "\u58AA", 17, "\u58BD\u58BE\u58BF\u58C0\u58C2\u58C3\u58C4\u58C6", 10, "\u58D2\u58D3\u58D4\u58D6", 13, "\u58E5", 5, "\u58ED\u58EF\u58F1\u58F2\u58F4\u58F5\u58F7\u58F8\u58FA", 7, "\u5903\u5905\u5906\u5908", 4, "\u590E\u5910\u5911\u5912\u5913\u5917\u5918\u591B\u591D\u591E\u5920\u5921\u5922\u5923\u5926\u5928\u592C\u5930\u5932\u5933\u5935\u5936\u593B"],
      ["8a40", "\u593D\u593E\u593F\u5940\u5943\u5945\u5946\u594A\u594C\u594D\u5950\u5952\u5953\u5959\u595B", 4, "\u5961\u5963\u5964\u5966", 12, "\u5975\u5977\u597A\u597B\u597C\u597E\u597F\u5980\u5985\u5989\u598B\u598C\u598E\u598F\u5990\u5991\u5994\u5995\u5998\u599A\u599B\u599C\u599D\u599F\u59A0\u59A1\u59A2\u59A6"],
      ["8a80", "\u59A7\u59AC\u59AD\u59B0\u59B1\u59B3", 5, "\u59BA\u59BC\u59BD\u59BF", 6, "\u59C7\u59C8\u59C9\u59CC\u59CD\u59CE\u59CF\u59D5\u59D6\u59D9\u59DB\u59DE", 4, "\u59E4\u59E6\u59E7\u59E9\u59EA\u59EB\u59ED", 11, "\u59FA\u59FC\u59FD\u59FE\u5A00\u5A02\u5A0A\u5A0B\u5A0D\u5A0E\u5A0F\u5A10\u5A12\u5A14\u5A15\u5A16\u5A17\u5A19\u5A1A\u5A1B\u5A1D\u5A1E\u5A21\u5A22\u5A24\u5A26\u5A27\u5A28\u5A2A", 6, "\u5A33\u5A35\u5A37", 4, "\u5A3D\u5A3E\u5A3F\u5A41", 4, "\u5A47\u5A48\u5A4B", 9, "\u5A56\u5A57\u5A58\u5A59\u5A5B", 5],
      ["8b40", "\u5A61\u5A63\u5A64\u5A65\u5A66\u5A68\u5A69\u5A6B", 8, "\u5A78\u5A79\u5A7B\u5A7C\u5A7D\u5A7E\u5A80", 17, "\u5A93", 6, "\u5A9C", 13, "\u5AAB\u5AAC"],
      ["8b80", "\u5AAD", 4, "\u5AB4\u5AB6\u5AB7\u5AB9", 4, "\u5ABF\u5AC0\u5AC3", 5, "\u5ACA\u5ACB\u5ACD", 4, "\u5AD3\u5AD5\u5AD7\u5AD9\u5ADA\u5ADB\u5ADD\u5ADE\u5ADF\u5AE2\u5AE4\u5AE5\u5AE7\u5AE8\u5AEA\u5AEC", 4, "\u5AF2", 22, "\u5B0A", 11, "\u5B18", 25, "\u5B33\u5B35\u5B36\u5B38", 7, "\u5B41", 6],
      ["8c40", "\u5B48", 7, "\u5B52\u5B56\u5B5E\u5B60\u5B61\u5B67\u5B68\u5B6B\u5B6D\u5B6E\u5B6F\u5B72\u5B74\u5B76\u5B77\u5B78\u5B79\u5B7B\u5B7C\u5B7E\u5B7F\u5B82\u5B86\u5B8A\u5B8D\u5B8E\u5B90\u5B91\u5B92\u5B94\u5B96\u5B9F\u5BA7\u5BA8\u5BA9\u5BAC\u5BAD\u5BAE\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBB\u5BBC\u5BC0\u5BC1\u5BC3\u5BC8\u5BC9\u5BCA\u5BCB\u5BCD\u5BCE\u5BCF"],
      ["8c80", "\u5BD1\u5BD4", 8, "\u5BE0\u5BE2\u5BE3\u5BE6\u5BE7\u5BE9", 4, "\u5BEF\u5BF1", 6, "\u5BFD\u5BFE\u5C00\u5C02\u5C03\u5C05\u5C07\u5C08\u5C0B\u5C0C\u5C0D\u5C0E\u5C10\u5C12\u5C13\u5C17\u5C19\u5C1B\u5C1E\u5C1F\u5C20\u5C21\u5C23\u5C26\u5C28\u5C29\u5C2A\u5C2B\u5C2D\u5C2E\u5C2F\u5C30\u5C32\u5C33\u5C35\u5C36\u5C37\u5C43\u5C44\u5C46\u5C47\u5C4C\u5C4D\u5C52\u5C53\u5C54\u5C56\u5C57\u5C58\u5C5A\u5C5B\u5C5C\u5C5D\u5C5F\u5C62\u5C64\u5C67", 6, "\u5C70\u5C72", 6, "\u5C7B\u5C7C\u5C7D\u5C7E\u5C80\u5C83", 4, "\u5C89\u5C8A\u5C8B\u5C8E\u5C8F\u5C92\u5C93\u5C95\u5C9D", 4, "\u5CA4", 4],
      ["8d40", "\u5CAA\u5CAE\u5CAF\u5CB0\u5CB2\u5CB4\u5CB6\u5CB9\u5CBA\u5CBB\u5CBC\u5CBE\u5CC0\u5CC2\u5CC3\u5CC5", 5, "\u5CCC", 5, "\u5CD3", 5, "\u5CDA", 6, "\u5CE2\u5CE3\u5CE7\u5CE9\u5CEB\u5CEC\u5CEE\u5CEF\u5CF1", 9, "\u5CFC", 4],
      ["8d80", "\u5D01\u5D04\u5D05\u5D08", 5, "\u5D0F", 4, "\u5D15\u5D17\u5D18\u5D19\u5D1A\u5D1C\u5D1D\u5D1F", 4, "\u5D25\u5D28\u5D2A\u5D2B\u5D2C\u5D2F", 4, "\u5D35", 7, "\u5D3F", 7, "\u5D48\u5D49\u5D4D", 10, "\u5D59\u5D5A\u5D5C\u5D5E", 10, "\u5D6A\u5D6D\u5D6E\u5D70\u5D71\u5D72\u5D73\u5D75", 12, "\u5D83", 21, "\u5D9A\u5D9B\u5D9C\u5D9E\u5D9F\u5DA0"],
      ["8e40", "\u5DA1", 21, "\u5DB8", 12, "\u5DC6", 6, "\u5DCE", 12, "\u5DDC\u5DDF\u5DE0\u5DE3\u5DE4\u5DEA\u5DEC\u5DED"],
      ["8e80", "\u5DF0\u5DF5\u5DF6\u5DF8", 4, "\u5DFF\u5E00\u5E04\u5E07\u5E09\u5E0A\u5E0B\u5E0D\u5E0E\u5E12\u5E13\u5E17\u5E1E", 7, "\u5E28", 4, "\u5E2F\u5E30\u5E32", 4, "\u5E39\u5E3A\u5E3E\u5E3F\u5E40\u5E41\u5E43\u5E46", 5, "\u5E4D", 6, "\u5E56", 4, "\u5E5C\u5E5D\u5E5F\u5E60\u5E63", 14, "\u5E75\u5E77\u5E79\u5E7E\u5E81\u5E82\u5E83\u5E85\u5E88\u5E89\u5E8C\u5E8D\u5E8E\u5E92\u5E98\u5E9B\u5E9D\u5EA1\u5EA2\u5EA3\u5EA4\u5EA8", 4, "\u5EAE", 4, "\u5EB4\u5EBA\u5EBB\u5EBC\u5EBD\u5EBF", 6],
      ["8f40", "\u5EC6\u5EC7\u5EC8\u5ECB", 5, "\u5ED4\u5ED5\u5ED7\u5ED8\u5ED9\u5EDA\u5EDC", 11, "\u5EE9\u5EEB", 8, "\u5EF5\u5EF8\u5EF9\u5EFB\u5EFC\u5EFD\u5F05\u5F06\u5F07\u5F09\u5F0C\u5F0D\u5F0E\u5F10\u5F12\u5F14\u5F16\u5F19\u5F1A\u5F1C\u5F1D\u5F1E\u5F21\u5F22\u5F23\u5F24"],
      ["8f80", "\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F32", 6, "\u5F3B\u5F3D\u5F3E\u5F3F\u5F41", 14, "\u5F51\u5F54\u5F59\u5F5A\u5F5B\u5F5C\u5F5E\u5F5F\u5F60\u5F63\u5F65\u5F67\u5F68\u5F6B\u5F6E\u5F6F\u5F72\u5F74\u5F75\u5F76\u5F78\u5F7A\u5F7D\u5F7E\u5F7F\u5F83\u5F86\u5F8D\u5F8E\u5F8F\u5F91\u5F93\u5F94\u5F96\u5F9A\u5F9B\u5F9D\u5F9E\u5F9F\u5FA0\u5FA2", 5, "\u5FA9\u5FAB\u5FAC\u5FAF", 5, "\u5FB6\u5FB8\u5FB9\u5FBA\u5FBB\u5FBE", 4, "\u5FC7\u5FC8\u5FCA\u5FCB\u5FCE\u5FD3\u5FD4\u5FD5\u5FDA\u5FDB\u5FDC\u5FDE\u5FDF\u5FE2\u5FE3\u5FE5\u5FE6\u5FE8\u5FE9\u5FEC\u5FEF\u5FF0\u5FF2\u5FF3\u5FF4\u5FF6\u5FF7\u5FF9\u5FFA\u5FFC\u6007"],
      ["9040", "\u6008\u6009\u600B\u600C\u6010\u6011\u6013\u6017\u6018\u601A\u601E\u601F\u6022\u6023\u6024\u602C\u602D\u602E\u6030", 4, "\u6036", 4, "\u603D\u603E\u6040\u6044", 6, "\u604C\u604E\u604F\u6051\u6053\u6054\u6056\u6057\u6058\u605B\u605C\u605E\u605F\u6060\u6061\u6065\u6066\u606E\u6071\u6072\u6074\u6075\u6077\u607E\u6080"],
      ["9080", "\u6081\u6082\u6085\u6086\u6087\u6088\u608A\u608B\u608E\u608F\u6090\u6091\u6093\u6095\u6097\u6098\u6099\u609C\u609E\u60A1\u60A2\u60A4\u60A5\u60A7\u60A9\u60AA\u60AE\u60B0\u60B3\u60B5\u60B6\u60B7\u60B9\u60BA\u60BD", 7, "\u60C7\u60C8\u60C9\u60CC", 4, "\u60D2\u60D3\u60D4\u60D6\u60D7\u60D9\u60DB\u60DE\u60E1", 4, "\u60EA\u60F1\u60F2\u60F5\u60F7\u60F8\u60FB", 4, "\u6102\u6103\u6104\u6105\u6107\u610A\u610B\u610C\u6110", 4, "\u6116\u6117\u6118\u6119\u611B\u611C\u611D\u611E\u6121\u6122\u6125\u6128\u6129\u612A\u612C", 18, "\u6140", 6],
      ["9140", "\u6147\u6149\u614B\u614D\u614F\u6150\u6152\u6153\u6154\u6156", 6, "\u615E\u615F\u6160\u6161\u6163\u6164\u6165\u6166\u6169", 6, "\u6171\u6172\u6173\u6174\u6176\u6178", 18, "\u618C\u618D\u618F", 4, "\u6195"],
      ["9180", "\u6196", 6, "\u619E", 8, "\u61AA\u61AB\u61AD", 9, "\u61B8", 5, "\u61BF\u61C0\u61C1\u61C3", 4, "\u61C9\u61CC", 4, "\u61D3\u61D5", 16, "\u61E7", 13, "\u61F6", 8, "\u6200", 5, "\u6207\u6209\u6213\u6214\u6219\u621C\u621D\u621E\u6220\u6223\u6226\u6227\u6228\u6229\u622B\u622D\u622F\u6230\u6231\u6232\u6235\u6236\u6238", 4, "\u6242\u6244\u6245\u6246\u624A"],
      ["9240", "\u624F\u6250\u6255\u6256\u6257\u6259\u625A\u625C", 6, "\u6264\u6265\u6268\u6271\u6272\u6274\u6275\u6277\u6278\u627A\u627B\u627D\u6281\u6282\u6283\u6285\u6286\u6287\u6288\u628B", 5, "\u6294\u6299\u629C\u629D\u629E\u62A3\u62A6\u62A7\u62A9\u62AA\u62AD\u62AE\u62AF\u62B0\u62B2\u62B3\u62B4\u62B6\u62B7\u62B8\u62BA\u62BE\u62C0\u62C1"],
      ["9280", "\u62C3\u62CB\u62CF\u62D1\u62D5\u62DD\u62DE\u62E0\u62E1\u62E4\u62EA\u62EB\u62F0\u62F2\u62F5\u62F8\u62F9\u62FA\u62FB\u6300\u6303\u6304\u6305\u6306\u630A\u630B\u630C\u630D\u630F\u6310\u6312\u6313\u6314\u6315\u6317\u6318\u6319\u631C\u6326\u6327\u6329\u632C\u632D\u632E\u6330\u6331\u6333", 5, "\u633B\u633C\u633E\u633F\u6340\u6341\u6344\u6347\u6348\u634A\u6351\u6352\u6353\u6354\u6356", 7, "\u6360\u6364\u6365\u6366\u6368\u636A\u636B\u636C\u636F\u6370\u6372\u6373\u6374\u6375\u6378\u6379\u637C\u637D\u637E\u637F\u6381\u6383\u6384\u6385\u6386\u638B\u638D\u6391\u6393\u6394\u6395\u6397\u6399", 6, "\u63A1\u63A4\u63A6\u63AB\u63AF\u63B1\u63B2\u63B5\u63B6\u63B9\u63BB\u63BD\u63BF\u63C0"],
      ["9340", "\u63C1\u63C2\u63C3\u63C5\u63C7\u63C8\u63CA\u63CB\u63CC\u63D1\u63D3\u63D4\u63D5\u63D7", 6, "\u63DF\u63E2\u63E4", 4, "\u63EB\u63EC\u63EE\u63EF\u63F0\u63F1\u63F3\u63F5\u63F7\u63F9\u63FA\u63FB\u63FC\u63FE\u6403\u6404\u6406", 4, "\u640D\u640E\u6411\u6412\u6415", 5, "\u641D\u641F\u6422\u6423\u6424"],
      ["9380", "\u6425\u6427\u6428\u6429\u642B\u642E", 5, "\u6435", 4, "\u643B\u643C\u643E\u6440\u6442\u6443\u6449\u644B", 6, "\u6453\u6455\u6456\u6457\u6459", 4, "\u645F", 7, "\u6468\u646A\u646B\u646C\u646E", 9, "\u647B", 6, "\u6483\u6486\u6488", 8, "\u6493\u6494\u6497\u6498\u649A\u649B\u649C\u649D\u649F", 4, "\u64A5\u64A6\u64A7\u64A8\u64AA\u64AB\u64AF\u64B1\u64B2\u64B3\u64B4\u64B6\u64B9\u64BB\u64BD\u64BE\u64BF\u64C1\u64C3\u64C4\u64C6", 6, "\u64CF\u64D1\u64D3\u64D4\u64D5\u64D6\u64D9\u64DA"],
      ["9440", "\u64DB\u64DC\u64DD\u64DF\u64E0\u64E1\u64E3\u64E5\u64E7", 24, "\u6501", 7, "\u650A", 7, "\u6513", 4, "\u6519", 8],
      ["9480", "\u6522\u6523\u6524\u6526", 4, "\u652C\u652D\u6530\u6531\u6532\u6533\u6537\u653A\u653C\u653D\u6540", 4, "\u6546\u6547\u654A\u654B\u654D\u654E\u6550\u6552\u6553\u6554\u6557\u6558\u655A\u655C\u655F\u6560\u6561\u6564\u6565\u6567\u6568\u6569\u656A\u656D\u656E\u656F\u6571\u6573\u6575\u6576\u6578", 14, "\u6588\u6589\u658A\u658D\u658E\u658F\u6592\u6594\u6595\u6596\u6598\u659A\u659D\u659E\u65A0\u65A2\u65A3\u65A6\u65A8\u65AA\u65AC\u65AE\u65B1", 7, "\u65BA\u65BB\u65BE\u65BF\u65C0\u65C2\u65C7\u65C8\u65C9\u65CA\u65CD\u65D0\u65D1\u65D3\u65D4\u65D5\u65D8", 7, "\u65E1\u65E3\u65E4\u65EA\u65EB"],
      ["9540", "\u65F2\u65F3\u65F4\u65F5\u65F8\u65F9\u65FB", 4, "\u6601\u6604\u6605\u6607\u6608\u6609\u660B\u660D\u6610\u6611\u6612\u6616\u6617\u6618\u661A\u661B\u661C\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6632\u6633\u6637", 4, "\u663D\u663F\u6640\u6642\u6644", 6, "\u664D\u664E\u6650\u6651\u6658"],
      ["9580", "\u6659\u665B\u665C\u665D\u665E\u6660\u6662\u6663\u6665\u6667\u6669", 4, "\u6671\u6672\u6673\u6675\u6678\u6679\u667B\u667C\u667D\u667F\u6680\u6681\u6683\u6685\u6686\u6688\u6689\u668A\u668B\u668D\u668E\u668F\u6690\u6692\u6693\u6694\u6695\u6698", 4, "\u669E", 8, "\u66A9", 4, "\u66AF", 4, "\u66B5\u66B6\u66B7\u66B8\u66BA\u66BB\u66BC\u66BD\u66BF", 25, "\u66DA\u66DE", 7, "\u66E7\u66E8\u66EA", 5, "\u66F1\u66F5\u66F6\u66F8\u66FA\u66FB\u66FD\u6701\u6702\u6703"],
      ["9640", "\u6704\u6705\u6706\u6707\u670C\u670E\u670F\u6711\u6712\u6713\u6716\u6718\u6719\u671A\u671C\u671E\u6720", 5, "\u6727\u6729\u672E\u6730\u6732\u6733\u6736\u6737\u6738\u6739\u673B\u673C\u673E\u673F\u6741\u6744\u6745\u6747\u674A\u674B\u674D\u6752\u6754\u6755\u6757", 4, "\u675D\u6762\u6763\u6764\u6766\u6767\u676B\u676C\u676E\u6771\u6774\u6776"],
      ["9680", "\u6778\u6779\u677A\u677B\u677D\u6780\u6782\u6783\u6785\u6786\u6788\u678A\u678C\u678D\u678E\u678F\u6791\u6792\u6793\u6794\u6796\u6799\u679B\u679F\u67A0\u67A1\u67A4\u67A6\u67A9\u67AC\u67AE\u67B1\u67B2\u67B4\u67B9", 7, "\u67C2\u67C5", 9, "\u67D5\u67D6\u67D7\u67DB\u67DF\u67E1\u67E3\u67E4\u67E6\u67E7\u67E8\u67EA\u67EB\u67ED\u67EE\u67F2\u67F5", 7, "\u67FE\u6801\u6802\u6803\u6804\u6806\u680D\u6810\u6812\u6814\u6815\u6818", 4, "\u681E\u681F\u6820\u6822", 6, "\u682B", 6, "\u6834\u6835\u6836\u683A\u683B\u683F\u6847\u684B\u684D\u684F\u6852\u6856", 5],
      ["9740", "\u685C\u685D\u685E\u685F\u686A\u686C", 7, "\u6875\u6878", 8, "\u6882\u6884\u6887", 7, "\u6890\u6891\u6892\u6894\u6895\u6896\u6898", 9, "\u68A3\u68A4\u68A5\u68A9\u68AA\u68AB\u68AC\u68AE\u68B1\u68B2\u68B4\u68B6\u68B7\u68B8"],
      ["9780", "\u68B9", 6, "\u68C1\u68C3", 5, "\u68CA\u68CC\u68CE\u68CF\u68D0\u68D1\u68D3\u68D4\u68D6\u68D7\u68D9\u68DB", 4, "\u68E1\u68E2\u68E4", 9, "\u68EF\u68F2\u68F3\u68F4\u68F6\u68F7\u68F8\u68FB\u68FD\u68FE\u68FF\u6900\u6902\u6903\u6904\u6906", 4, "\u690C\u690F\u6911\u6913", 11, "\u6921\u6922\u6923\u6925", 7, "\u692E\u692F\u6931\u6932\u6933\u6935\u6936\u6937\u6938\u693A\u693B\u693C\u693E\u6940\u6941\u6943", 16, "\u6955\u6956\u6958\u6959\u695B\u695C\u695F"],
      ["9840", "\u6961\u6962\u6964\u6965\u6967\u6968\u6969\u696A\u696C\u696D\u696F\u6970\u6972", 4, "\u697A\u697B\u697D\u697E\u697F\u6981\u6983\u6985\u698A\u698B\u698C\u698E", 5, "\u6996\u6997\u6999\u699A\u699D", 9, "\u69A9\u69AA\u69AC\u69AE\u69AF\u69B0\u69B2\u69B3\u69B5\u69B6\u69B8\u69B9\u69BA\u69BC\u69BD"],
      ["9880", "\u69BE\u69BF\u69C0\u69C2", 7, "\u69CB\u69CD\u69CF\u69D1\u69D2\u69D3\u69D5", 5, "\u69DC\u69DD\u69DE\u69E1", 11, "\u69EE\u69EF\u69F0\u69F1\u69F3", 9, "\u69FE\u6A00", 9, "\u6A0B", 11, "\u6A19", 5, "\u6A20\u6A22", 5, "\u6A29\u6A2B\u6A2C\u6A2D\u6A2E\u6A30\u6A32\u6A33\u6A34\u6A36", 6, "\u6A3F", 4, "\u6A45\u6A46\u6A48", 7, "\u6A51", 6, "\u6A5A"],
      ["9940", "\u6A5C", 4, "\u6A62\u6A63\u6A64\u6A66", 10, "\u6A72", 6, "\u6A7A\u6A7B\u6A7D\u6A7E\u6A7F\u6A81\u6A82\u6A83\u6A85", 8, "\u6A8F\u6A92", 4, "\u6A98", 7, "\u6AA1", 5],
      ["9980", "\u6AA7\u6AA8\u6AAA\u6AAD", 114, "\u6B25\u6B26\u6B28", 6],
      ["9a40", "\u6B2F\u6B30\u6B31\u6B33\u6B34\u6B35\u6B36\u6B38\u6B3B\u6B3C\u6B3D\u6B3F\u6B40\u6B41\u6B42\u6B44\u6B45\u6B48\u6B4A\u6B4B\u6B4D", 11, "\u6B5A", 7, "\u6B68\u6B69\u6B6B", 13, "\u6B7A\u6B7D\u6B7E\u6B7F\u6B80\u6B85\u6B88"],
      ["9a80", "\u6B8C\u6B8E\u6B8F\u6B90\u6B91\u6B94\u6B95\u6B97\u6B98\u6B99\u6B9C", 4, "\u6BA2", 7, "\u6BAB", 7, "\u6BB6\u6BB8", 6, "\u6BC0\u6BC3\u6BC4\u6BC6", 4, "\u6BCC\u6BCE\u6BD0\u6BD1\u6BD8\u6BDA\u6BDC", 4, "\u6BE2", 7, "\u6BEC\u6BED\u6BEE\u6BF0\u6BF1\u6BF2\u6BF4\u6BF6\u6BF7\u6BF8\u6BFA\u6BFB\u6BFC\u6BFE", 6, "\u6C08", 4, "\u6C0E\u6C12\u6C17\u6C1C\u6C1D\u6C1E\u6C20\u6C23\u6C25\u6C2B\u6C2C\u6C2D\u6C31\u6C33\u6C36\u6C37\u6C39\u6C3A\u6C3B\u6C3C\u6C3E\u6C3F\u6C43\u6C44\u6C45\u6C48\u6C4B", 4, "\u6C51\u6C52\u6C53\u6C56\u6C58"],
      ["9b40", "\u6C59\u6C5A\u6C62\u6C63\u6C65\u6C66\u6C67\u6C6B", 4, "\u6C71\u6C73\u6C75\u6C77\u6C78\u6C7A\u6C7B\u6C7C\u6C7F\u6C80\u6C84\u6C87\u6C8A\u6C8B\u6C8D\u6C8E\u6C91\u6C92\u6C95\u6C96\u6C97\u6C98\u6C9A\u6C9C\u6C9D\u6C9E\u6CA0\u6CA2\u6CA8\u6CAC\u6CAF\u6CB0\u6CB4\u6CB5\u6CB6\u6CB7\u6CBA\u6CC0\u6CC1\u6CC2\u6CC3\u6CC6\u6CC7\u6CC8\u6CCB\u6CCD\u6CCE\u6CCF\u6CD1\u6CD2\u6CD8"],
      ["9b80", "\u6CD9\u6CDA\u6CDC\u6CDD\u6CDF\u6CE4\u6CE6\u6CE7\u6CE9\u6CEC\u6CED\u6CF2\u6CF4\u6CF9\u6CFF\u6D00\u6D02\u6D03\u6D05\u6D06\u6D08\u6D09\u6D0A\u6D0D\u6D0F\u6D10\u6D11\u6D13\u6D14\u6D15\u6D16\u6D18\u6D1C\u6D1D\u6D1F", 5, "\u6D26\u6D28\u6D29\u6D2C\u6D2D\u6D2F\u6D30\u6D34\u6D36\u6D37\u6D38\u6D3A\u6D3F\u6D40\u6D42\u6D44\u6D49\u6D4C\u6D50\u6D55\u6D56\u6D57\u6D58\u6D5B\u6D5D\u6D5F\u6D61\u6D62\u6D64\u6D65\u6D67\u6D68\u6D6B\u6D6C\u6D6D\u6D70\u6D71\u6D72\u6D73\u6D75\u6D76\u6D79\u6D7A\u6D7B\u6D7D", 4, "\u6D83\u6D84\u6D86\u6D87\u6D8A\u6D8B\u6D8D\u6D8F\u6D90\u6D92\u6D96", 4, "\u6D9C\u6DA2\u6DA5\u6DAC\u6DAD\u6DB0\u6DB1\u6DB3\u6DB4\u6DB6\u6DB7\u6DB9", 5, "\u6DC1\u6DC2\u6DC3\u6DC8\u6DC9\u6DCA"],
      ["9c40", "\u6DCD\u6DCE\u6DCF\u6DD0\u6DD2\u6DD3\u6DD4\u6DD5\u6DD7\u6DDA\u6DDB\u6DDC\u6DDF\u6DE2\u6DE3\u6DE5\u6DE7\u6DE8\u6DE9\u6DEA\u6DED\u6DEF\u6DF0\u6DF2\u6DF4\u6DF5\u6DF6\u6DF8\u6DFA\u6DFD", 7, "\u6E06\u6E07\u6E08\u6E09\u6E0B\u6E0F\u6E12\u6E13\u6E15\u6E18\u6E19\u6E1B\u6E1C\u6E1E\u6E1F\u6E22\u6E26\u6E27\u6E28\u6E2A\u6E2C\u6E2E\u6E30\u6E31\u6E33\u6E35"],
      ["9c80", "\u6E36\u6E37\u6E39\u6E3B", 7, "\u6E45", 7, "\u6E4F\u6E50\u6E51\u6E52\u6E55\u6E57\u6E59\u6E5A\u6E5C\u6E5D\u6E5E\u6E60", 10, "\u6E6C\u6E6D\u6E6F", 14, "\u6E80\u6E81\u6E82\u6E84\u6E87\u6E88\u6E8A", 4, "\u6E91", 6, "\u6E99\u6E9A\u6E9B\u6E9D\u6E9E\u6EA0\u6EA1\u6EA3\u6EA4\u6EA6\u6EA8\u6EA9\u6EAB\u6EAC\u6EAD\u6EAE\u6EB0\u6EB3\u6EB5\u6EB8\u6EB9\u6EBC\u6EBE\u6EBF\u6EC0\u6EC3\u6EC4\u6EC5\u6EC6\u6EC8\u6EC9\u6ECA\u6ECC\u6ECD\u6ECE\u6ED0\u6ED2\u6ED6\u6ED8\u6ED9\u6EDB\u6EDC\u6EDD\u6EE3\u6EE7\u6EEA", 5],
      ["9d40", "\u6EF0\u6EF1\u6EF2\u6EF3\u6EF5\u6EF6\u6EF7\u6EF8\u6EFA", 7, "\u6F03\u6F04\u6F05\u6F07\u6F08\u6F0A", 4, "\u6F10\u6F11\u6F12\u6F16", 9, "\u6F21\u6F22\u6F23\u6F25\u6F26\u6F27\u6F28\u6F2C\u6F2E\u6F30\u6F32\u6F34\u6F35\u6F37", 6, "\u6F3F\u6F40\u6F41\u6F42"],
      ["9d80", "\u6F43\u6F44\u6F45\u6F48\u6F49\u6F4A\u6F4C\u6F4E", 9, "\u6F59\u6F5A\u6F5B\u6F5D\u6F5F\u6F60\u6F61\u6F63\u6F64\u6F65\u6F67", 5, "\u6F6F\u6F70\u6F71\u6F73\u6F75\u6F76\u6F77\u6F79\u6F7B\u6F7D", 6, "\u6F85\u6F86\u6F87\u6F8A\u6F8B\u6F8F", 12, "\u6F9D\u6F9E\u6F9F\u6FA0\u6FA2", 4, "\u6FA8", 10, "\u6FB4\u6FB5\u6FB7\u6FB8\u6FBA", 5, "\u6FC1\u6FC3", 5, "\u6FCA", 6, "\u6FD3", 10, "\u6FDF\u6FE2\u6FE3\u6FE4\u6FE5"],
      ["9e40", "\u6FE6", 7, "\u6FF0", 32, "\u7012", 7, "\u701C", 6, "\u7024", 6],
      ["9e80", "\u702B", 9, "\u7036\u7037\u7038\u703A", 17, "\u704D\u704E\u7050", 13, "\u705F", 11, "\u706E\u7071\u7072\u7073\u7074\u7077\u7079\u707A\u707B\u707D\u7081\u7082\u7083\u7084\u7086\u7087\u7088\u708B\u708C\u708D\u708F\u7090\u7091\u7093\u7097\u7098\u709A\u709B\u709E", 12, "\u70B0\u70B2\u70B4\u70B5\u70B6\u70BA\u70BE\u70BF\u70C4\u70C5\u70C6\u70C7\u70C9\u70CB", 12, "\u70DA"],
      ["9f40", "\u70DC\u70DD\u70DE\u70E0\u70E1\u70E2\u70E3\u70E5\u70EA\u70EE\u70F0", 6, "\u70F8\u70FA\u70FB\u70FC\u70FE", 10, "\u710B", 4, "\u7111\u7112\u7114\u7117\u711B", 10, "\u7127", 7, "\u7132\u7133\u7134"],
      ["9f80", "\u7135\u7137", 13, "\u7146\u7147\u7148\u7149\u714B\u714D\u714F", 12, "\u715D\u715F", 4, "\u7165\u7169", 4, "\u716F\u7170\u7171\u7174\u7175\u7176\u7177\u7179\u717B\u717C\u717E", 5, "\u7185", 4, "\u718B\u718C\u718D\u718E\u7190\u7191\u7192\u7193\u7195\u7196\u7197\u719A", 4, "\u71A1", 6, "\u71A9\u71AA\u71AB\u71AD", 5, "\u71B4\u71B6\u71B7\u71B8\u71BA", 8, "\u71C4", 9, "\u71CF", 4],
      ["a040", "\u71D6", 9, "\u71E1\u71E2\u71E3\u71E4\u71E6\u71E8", 5, "\u71EF", 9, "\u71FA", 11, "\u7207", 19],
      ["a080", "\u721B\u721C\u721E", 9, "\u7229\u722B\u722D\u722E\u722F\u7232\u7233\u7234\u723A\u723C\u723E\u7240", 6, "\u7249\u724A\u724B\u724E\u724F\u7250\u7251\u7253\u7254\u7255\u7257\u7258\u725A\u725C\u725E\u7260\u7263\u7264\u7265\u7268\u726A\u726B\u726C\u726D\u7270\u7271\u7273\u7274\u7276\u7277\u7278\u727B\u727C\u727D\u7282\u7283\u7285", 4, "\u728C\u728E\u7290\u7291\u7293", 11, "\u72A0", 11, "\u72AE\u72B1\u72B2\u72B3\u72B5\u72BA", 6, "\u72C5\u72C6\u72C7\u72C9\u72CA\u72CB\u72CC\u72CF\u72D1\u72D3\u72D4\u72D5\u72D6\u72D8\u72DA\u72DB"],
      ["a1a1", "\u3000\u3001\u3002\xB7\u02C9\u02C7\xA8\u3003\u3005\u2014\uFF5E\u2016\u2026\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 7, "\u3016\u3017\u3010\u3011\xB1\xD7\xF7\u2236\u2227\u2228\u2211\u220F\u222A\u2229\u2208\u2237\u221A\u22A5\u2225\u2220\u2312\u2299\u222B\u222E\u2261\u224C\u2248\u223D\u221D\u2260\u226E\u226F\u2264\u2265\u221E\u2235\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFF04\xA4\uFFE0\uFFE1\u2030\xA7\u2116\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u203B\u2192\u2190\u2191\u2193\u3013"],
      ["a2a1", "\u2170", 9],
      ["a2b1", "\u2488", 19, "\u2474", 19, "\u2460", 9],
      ["a2e5", "\u3220", 9],
      ["a2f1", "\u2160", 11],
      ["a3a1", "\uFF01\uFF02\uFF03\uFFE5\uFF05", 88, "\uFFE3"],
      ["a4a1", "\u3041", 82],
      ["a5a1", "\u30A1", 85],
      ["a6a1", "\u0391", 16, "\u03A3", 6],
      ["a6c1", "\u03B1", 16, "\u03C3", 6],
      ["a6e0", "\uFE35\uFE36\uFE39\uFE3A\uFE3F\uFE40\uFE3D\uFE3E\uFE41\uFE42\uFE43\uFE44"],
      ["a6ee", "\uFE3B\uFE3C\uFE37\uFE38\uFE31"],
      ["a6f4", "\uFE33\uFE34"],
      ["a7a1", "\u0410", 5, "\u0401\u0416", 25],
      ["a7d1", "\u0430", 5, "\u0451\u0436", 25],
      ["a840", "\u02CA\u02CB\u02D9\u2013\u2015\u2025\u2035\u2105\u2109\u2196\u2197\u2198\u2199\u2215\u221F\u2223\u2252\u2266\u2267\u22BF\u2550", 35, "\u2581", 6],
      ["a880", "\u2588", 7, "\u2593\u2594\u2595\u25BC\u25BD\u25E2\u25E3\u25E4\u25E5\u2609\u2295\u3012\u301D\u301E"],
      ["a8a1", "\u0101\xE1\u01CE\xE0\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA\u01DC\xFC\xEA\u0251"],
      ["a8bd", "\u0144\u0148"],
      ["a8c0", "\u0261"],
      ["a8c5", "\u3105", 36],
      ["a940", "\u3021", 8, "\u32A3\u338E\u338F\u339C\u339D\u339E\u33A1\u33C4\u33CE\u33D1\u33D2\u33D5\uFE30\uFFE2\uFFE4"],
      ["a959", "\u2121\u3231"],
      ["a95c", "\u2010"],
      ["a960", "\u30FC\u309B\u309C\u30FD\u30FE\u3006\u309D\u309E\uFE49", 9, "\uFE54\uFE55\uFE56\uFE57\uFE59", 8],
      ["a980", "\uFE62", 4, "\uFE68\uFE69\uFE6A\uFE6B"],
      ["a996", "\u3007"],
      ["a9a4", "\u2500", 75],
      ["aa40", "\u72DC\u72DD\u72DF\u72E2", 5, "\u72EA\u72EB\u72F5\u72F6\u72F9\u72FD\u72FE\u72FF\u7300\u7302\u7304", 5, "\u730B\u730C\u730D\u730F\u7310\u7311\u7312\u7314\u7318\u7319\u731A\u731F\u7320\u7323\u7324\u7326\u7327\u7328\u732D\u732F\u7330\u7332\u7333\u7335\u7336\u733A\u733B\u733C\u733D\u7340", 8],
      ["aa80", "\u7349\u734A\u734B\u734C\u734E\u734F\u7351\u7353\u7354\u7355\u7356\u7358", 7, "\u7361", 10, "\u736E\u7370\u7371"],
      ["ab40", "\u7372", 11, "\u737F", 4, "\u7385\u7386\u7388\u738A\u738C\u738D\u738F\u7390\u7392\u7393\u7394\u7395\u7397\u7398\u7399\u739A\u739C\u739D\u739E\u73A0\u73A1\u73A3", 5, "\u73AA\u73AC\u73AD\u73B1\u73B4\u73B5\u73B6\u73B8\u73B9\u73BC\u73BD\u73BE\u73BF\u73C1\u73C3", 4],
      ["ab80", "\u73CB\u73CC\u73CE\u73D2", 6, "\u73DA\u73DB\u73DC\u73DD\u73DF\u73E1\u73E2\u73E3\u73E4\u73E6\u73E8\u73EA\u73EB\u73EC\u73EE\u73EF\u73F0\u73F1\u73F3", 4],
      ["ac40", "\u73F8", 10, "\u7404\u7407\u7408\u740B\u740C\u740D\u740E\u7411", 8, "\u741C", 5, "\u7423\u7424\u7427\u7429\u742B\u742D\u742F\u7431\u7432\u7437", 4, "\u743D\u743E\u743F\u7440\u7442", 11],
      ["ac80", "\u744E", 6, "\u7456\u7458\u745D\u7460", 12, "\u746E\u746F\u7471", 4, "\u7478\u7479\u747A"],
      ["ad40", "\u747B\u747C\u747D\u747F\u7482\u7484\u7485\u7486\u7488\u7489\u748A\u748C\u748D\u748F\u7491", 10, "\u749D\u749F", 7, "\u74AA", 15, "\u74BB", 12],
      ["ad80", "\u74C8", 9, "\u74D3", 8, "\u74DD\u74DF\u74E1\u74E5\u74E7", 6, "\u74F0\u74F1\u74F2"],
      ["ae40", "\u74F3\u74F5\u74F8", 6, "\u7500\u7501\u7502\u7503\u7505", 7, "\u750E\u7510\u7512\u7514\u7515\u7516\u7517\u751B\u751D\u751E\u7520", 4, "\u7526\u7527\u752A\u752E\u7534\u7536\u7539\u753C\u753D\u753F\u7541\u7542\u7543\u7544\u7546\u7547\u7549\u754A\u754D\u7550\u7551\u7552\u7553\u7555\u7556\u7557\u7558"],
      ["ae80", "\u755D", 7, "\u7567\u7568\u7569\u756B", 6, "\u7573\u7575\u7576\u7577\u757A", 4, "\u7580\u7581\u7582\u7584\u7585\u7587"],
      ["af40", "\u7588\u7589\u758A\u758C\u758D\u758E\u7590\u7593\u7595\u7598\u759B\u759C\u759E\u75A2\u75A6", 4, "\u75AD\u75B6\u75B7\u75BA\u75BB\u75BF\u75C0\u75C1\u75C6\u75CB\u75CC\u75CE\u75CF\u75D0\u75D1\u75D3\u75D7\u75D9\u75DA\u75DC\u75DD\u75DF\u75E0\u75E1\u75E5\u75E9\u75EC\u75ED\u75EE\u75EF\u75F2\u75F3\u75F5\u75F6\u75F7\u75F8\u75FA\u75FB\u75FD\u75FE\u7602\u7604\u7606\u7607"],
      ["af80", "\u7608\u7609\u760B\u760D\u760E\u760F\u7611\u7612\u7613\u7614\u7616\u761A\u761C\u761D\u761E\u7621\u7623\u7627\u7628\u762C\u762E\u762F\u7631\u7632\u7636\u7637\u7639\u763A\u763B\u763D\u7641\u7642\u7644"],
      ["b040", "\u7645", 6, "\u764E", 5, "\u7655\u7657", 4, "\u765D\u765F\u7660\u7661\u7662\u7664", 6, "\u766C\u766D\u766E\u7670", 7, "\u7679\u767A\u767C\u767F\u7680\u7681\u7683\u7685\u7689\u768A\u768C\u768D\u768F\u7690\u7692\u7694\u7695\u7697\u7698\u769A\u769B"],
      ["b080", "\u769C", 7, "\u76A5", 8, "\u76AF\u76B0\u76B3\u76B5", 9, "\u76C0\u76C1\u76C3\u554A\u963F\u57C3\u6328\u54CE\u5509\u54C0\u7691\u764C\u853C\u77EE\u827E\u788D\u7231\u9698\u978D\u6C28\u5B89\u4FFA\u6309\u6697\u5CB8\u80FA\u6848\u80AE\u6602\u76CE\u51F9\u6556\u71AC\u7FF1\u8884\u50B2\u5965\u61CA\u6FB3\u82AD\u634C\u6252\u53ED\u5427\u7B06\u516B\u75A4\u5DF4\u62D4\u8DCB\u9776\u628A\u8019\u575D\u9738\u7F62\u7238\u767D\u67CF\u767E\u6446\u4F70\u8D25\u62DC\u7A17\u6591\u73ED\u642C\u6273\u822C\u9881\u677F\u7248\u626E\u62CC\u4F34\u74E3\u534A\u529E\u7ECA\u90A6\u5E2E\u6886\u699C\u8180\u7ED1\u68D2\u78C5\u868C\u9551\u508D\u8C24\u82DE\u80DE\u5305\u8912\u5265"],
      ["b140", "\u76C4\u76C7\u76C9\u76CB\u76CC\u76D3\u76D5\u76D9\u76DA\u76DC\u76DD\u76DE\u76E0", 4, "\u76E6", 7, "\u76F0\u76F3\u76F5\u76F6\u76F7\u76FA\u76FB\u76FD\u76FF\u7700\u7702\u7703\u7705\u7706\u770A\u770C\u770E", 10, "\u771B\u771C\u771D\u771E\u7721\u7723\u7724\u7725\u7727\u772A\u772B"],
      ["b180", "\u772C\u772E\u7730", 4, "\u7739\u773B\u773D\u773E\u773F\u7742\u7744\u7745\u7746\u7748", 7, "\u7752", 7, "\u775C\u8584\u96F9\u4FDD\u5821\u9971\u5B9D\u62B1\u62A5\u66B4\u8C79\u9C8D\u7206\u676F\u7891\u60B2\u5351\u5317\u8F88\u80CC\u8D1D\u94A1\u500D\u72C8\u5907\u60EB\u7119\u88AB\u5954\u82EF\u672C\u7B28\u5D29\u7EF7\u752D\u6CF5\u8E66\u8FF8\u903C\u9F3B\u6BD4\u9119\u7B14\u5F7C\u78A7\u84D6\u853D\u6BD5\u6BD9\u6BD6\u5E01\u5E87\u75F9\u95ED\u655D\u5F0A\u5FC5\u8F9F\u58C1\u81C2\u907F\u965B\u97AD\u8FB9\u7F16\u8D2C\u6241\u4FBF\u53D8\u535E\u8FA8\u8FA9\u8FAB\u904D\u6807\u5F6A\u8198\u8868\u9CD6\u618B\u522B\u762A\u5F6C\u658C\u6FD2\u6EE8\u5BBE\u6448\u5175\u51B0\u67C4\u4E19\u79C9\u997C\u70B3"],
      ["b240", "\u775D\u775E\u775F\u7760\u7764\u7767\u7769\u776A\u776D", 11, "\u777A\u777B\u777C\u7781\u7782\u7783\u7786", 5, "\u778F\u7790\u7793", 11, "\u77A1\u77A3\u77A4\u77A6\u77A8\u77AB\u77AD\u77AE\u77AF\u77B1\u77B2\u77B4\u77B6", 4],
      ["b280", "\u77BC\u77BE\u77C0", 12, "\u77CE", 8, "\u77D8\u77D9\u77DA\u77DD", 4, "\u77E4\u75C5\u5E76\u73BB\u83E0\u64AD\u62E8\u94B5\u6CE2\u535A\u52C3\u640F\u94C2\u7B94\u4F2F\u5E1B\u8236\u8116\u818A\u6E24\u6CCA\u9A73\u6355\u535C\u54FA\u8865\u57E0\u4E0D\u5E03\u6B65\u7C3F\u90E8\u6016\u64E6\u731C\u88C1\u6750\u624D\u8D22\u776C\u8E29\u91C7\u5F69\u83DC\u8521\u9910\u53C2\u8695\u6B8B\u60ED\u60E8\u707F\u82CD\u8231\u4ED3\u6CA7\u85CF\u64CD\u7CD9\u69FD\u66F9\u8349\u5395\u7B56\u4FA7\u518C\u6D4B\u5C42\u8E6D\u63D2\u53C9\u832C\u8336\u67E5\u78B4\u643D\u5BDF\u5C94\u5DEE\u8BE7\u62C6\u67F4\u8C7A\u6400\u63BA\u8749\u998B\u8C17\u7F20\u94F2\u4EA7\u9610\u98A4\u660C\u7316"],
      ["b340", "\u77E6\u77E8\u77EA\u77EF\u77F0\u77F1\u77F2\u77F4\u77F5\u77F7\u77F9\u77FA\u77FB\u77FC\u7803", 5, "\u780A\u780B\u780E\u780F\u7810\u7813\u7815\u7819\u781B\u781E\u7820\u7821\u7822\u7824\u7828\u782A\u782B\u782E\u782F\u7831\u7832\u7833\u7835\u7836\u783D\u783F\u7841\u7842\u7843\u7844\u7846\u7848\u7849\u784A\u784B\u784D\u784F\u7851\u7853\u7854\u7858\u7859\u785A"],
      ["b380", "\u785B\u785C\u785E", 11, "\u786F", 7, "\u7878\u7879\u787A\u787B\u787D", 6, "\u573A\u5C1D\u5E38\u957F\u507F\u80A0\u5382\u655E\u7545\u5531\u5021\u8D85\u6284\u949E\u671D\u5632\u6F6E\u5DE2\u5435\u7092\u8F66\u626F\u64A4\u63A3\u5F7B\u6F88\u90F4\u81E3\u8FB0\u5C18\u6668\u5FF1\u6C89\u9648\u8D81\u886C\u6491\u79F0\u57CE\u6A59\u6210\u5448\u4E58\u7A0B\u60E9\u6F84\u8BDA\u627F\u901E\u9A8B\u79E4\u5403\u75F4\u6301\u5319\u6C60\u8FDF\u5F1B\u9A70\u803B\u9F7F\u4F88\u5C3A\u8D64\u7FC5\u65A5\u70BD\u5145\u51B2\u866B\u5D07\u5BA0\u62BD\u916C\u7574\u8E0C\u7A20\u6101\u7B79\u4EC7\u7EF8\u7785\u4E11\u81ED\u521D\u51FA\u6A71\u53A8\u8E87\u9504\u96CF\u6EC1\u9664\u695A"],
      ["b440", "\u7884\u7885\u7886\u7888\u788A\u788B\u788F\u7890\u7892\u7894\u7895\u7896\u7899\u789D\u789E\u78A0\u78A2\u78A4\u78A6\u78A8", 7, "\u78B5\u78B6\u78B7\u78B8\u78BA\u78BB\u78BC\u78BD\u78BF\u78C0\u78C2\u78C3\u78C4\u78C6\u78C7\u78C8\u78CC\u78CD\u78CE\u78CF\u78D1\u78D2\u78D3\u78D6\u78D7\u78D8\u78DA", 9],
      ["b480", "\u78E4\u78E5\u78E6\u78E7\u78E9\u78EA\u78EB\u78ED", 4, "\u78F3\u78F5\u78F6\u78F8\u78F9\u78FB", 5, "\u7902\u7903\u7904\u7906", 6, "\u7840\u50A8\u77D7\u6410\u89E6\u5904\u63E3\u5DDD\u7A7F\u693D\u4F20\u8239\u5598\u4E32\u75AE\u7A97\u5E62\u5E8A\u95EF\u521B\u5439\u708A\u6376\u9524\u5782\u6625\u693F\u9187\u5507\u6DF3\u7EAF\u8822\u6233\u7EF0\u75B5\u8328\u78C1\u96CC\u8F9E\u6148\u74F7\u8BCD\u6B64\u523A\u8D50\u6B21\u806A\u8471\u56F1\u5306\u4ECE\u4E1B\u51D1\u7C97\u918B\u7C07\u4FC3\u8E7F\u7BE1\u7A9C\u6467\u5D14\u50AC\u8106\u7601\u7CB9\u6DEC\u7FE0\u6751\u5B58\u5BF8\u78CB\u64AE\u6413\u63AA\u632B\u9519\u642D\u8FBE\u7B54\u7629\u6253\u5927\u5446\u6B79\u50A3\u6234\u5E26\u6B86\u4EE3\u8D37\u888B\u5F85\u902E"],
      ["b540", "\u790D", 5, "\u7914", 9, "\u791F", 4, "\u7925", 14, "\u7935", 4, "\u793D\u793F\u7942\u7943\u7944\u7945\u7947\u794A", 8, "\u7954\u7955\u7958\u7959\u7961\u7963"],
      ["b580", "\u7964\u7966\u7969\u796A\u796B\u796C\u796E\u7970", 6, "\u7979\u797B", 4, "\u7982\u7983\u7986\u7987\u7988\u7989\u798B\u798C\u798D\u798E\u7990\u7991\u7992\u6020\u803D\u62C5\u4E39\u5355\u90F8\u63B8\u80C6\u65E6\u6C2E\u4F46\u60EE\u6DE1\u8BDE\u5F39\u86CB\u5F53\u6321\u515A\u8361\u6863\u5200\u6363\u8E48\u5012\u5C9B\u7977\u5BFC\u5230\u7A3B\u60BC\u9053\u76D7\u5FB7\u5F97\u7684\u8E6C\u706F\u767B\u7B49\u77AA\u51F3\u9093\u5824\u4F4E\u6EF4\u8FEA\u654C\u7B1B\u72C4\u6DA4\u7FDF\u5AE1\u62B5\u5E95\u5730\u8482\u7B2C\u5E1D\u5F1F\u9012\u7F14\u98A0\u6382\u6EC7\u7898\u70B9\u5178\u975B\u57AB\u7535\u4F43\u7538\u5E97\u60E6\u5960\u6DC0\u6BBF\u7889\u53FC\u96D5\u51CB\u5201\u6389\u540A\u9493\u8C03\u8DCC\u7239\u789F\u8776\u8FED\u8C0D\u53E0"],
      ["b640", "\u7993", 6, "\u799B", 11, "\u79A8", 10, "\u79B4", 4, "\u79BC\u79BF\u79C2\u79C4\u79C5\u79C7\u79C8\u79CA\u79CC\u79CE\u79CF\u79D0\u79D3\u79D4\u79D6\u79D7\u79D9", 5, "\u79E0\u79E1\u79E2\u79E5\u79E8\u79EA"],
      ["b680", "\u79EC\u79EE\u79F1", 6, "\u79F9\u79FA\u79FC\u79FE\u79FF\u7A01\u7A04\u7A05\u7A07\u7A08\u7A09\u7A0A\u7A0C\u7A0F", 4, "\u7A15\u7A16\u7A18\u7A19\u7A1B\u7A1C\u4E01\u76EF\u53EE\u9489\u9876\u9F0E\u952D\u5B9A\u8BA2\u4E22\u4E1C\u51AC\u8463\u61C2\u52A8\u680B\u4F97\u606B\u51BB\u6D1E\u515C\u6296\u6597\u9661\u8C46\u9017\u75D8\u90FD\u7763\u6BD2\u728A\u72EC\u8BFB\u5835\u7779\u8D4C\u675C\u9540\u809A\u5EA6\u6E21\u5992\u7AEF\u77ED\u953B\u6BB5\u65AD\u7F0E\u5806\u5151\u961F\u5BF9\u58A9\u5428\u8E72\u6566\u987F\u56E4\u949D\u76FE\u9041\u6387\u54C6\u591A\u593A\u579B\u8EB2\u6735\u8DFA\u8235\u5241\u60F0\u5815\u86FE\u5CE8\u9E45\u4FC4\u989D\u8BB9\u5A25\u6076\u5384\u627C\u904F\u9102\u997F\u6069\u800C\u513F\u8033\u5C14\u9975\u6D31\u4E8C"],
      ["b740", "\u7A1D\u7A1F\u7A21\u7A22\u7A24", 14, "\u7A34\u7A35\u7A36\u7A38\u7A3A\u7A3E\u7A40", 5, "\u7A47", 9, "\u7A52", 4, "\u7A58", 16],
      ["b780", "\u7A69", 6, "\u7A71\u7A72\u7A73\u7A75\u7A7B\u7A7C\u7A7D\u7A7E\u7A82\u7A85\u7A87\u7A89\u7A8A\u7A8B\u7A8C\u7A8E\u7A8F\u7A90\u7A93\u7A94\u7A99\u7A9A\u7A9B\u7A9E\u7AA1\u7AA2\u8D30\u53D1\u7F5A\u7B4F\u4F10\u4E4F\u9600\u6CD5\u73D0\u85E9\u5E06\u756A\u7FFB\u6A0A\u77FE\u9492\u7E41\u51E1\u70E6\u53CD\u8FD4\u8303\u8D29\u72AF\u996D\u6CDB\u574A\u82B3\u65B9\u80AA\u623F\u9632\u59A8\u4EFF\u8BBF\u7EBA\u653E\u83F2\u975E\u5561\u98DE\u80A5\u532A\u8BFD\u5420\u80BA\u5E9F\u6CB8\u8D39\u82AC\u915A\u5429\u6C1B\u5206\u7EB7\u575F\u711A\u6C7E\u7C89\u594B\u4EFD\u5FFF\u6124\u7CAA\u4E30\u5C01\u67AB\u8702\u5CF0\u950B\u98CE\u75AF\u70FD\u9022\u51AF\u7F1D\u8BBD\u5949\u51E4\u4F5B\u5426\u592B\u6577\u80A4\u5B75\u6276\u62C2\u8F90\u5E45\u6C1F\u7B26\u4F0F\u4FD8\u670D"],
      ["b840", "\u7AA3\u7AA4\u7AA7\u7AA9\u7AAA\u7AAB\u7AAE", 4, "\u7AB4", 10, "\u7AC0", 10, "\u7ACC", 9, "\u7AD7\u7AD8\u7ADA\u7ADB\u7ADC\u7ADD\u7AE1\u7AE2\u7AE4\u7AE7", 5, "\u7AEE\u7AF0\u7AF1\u7AF2\u7AF3"],
      ["b880", "\u7AF4", 4, "\u7AFB\u7AFC\u7AFE\u7B00\u7B01\u7B02\u7B05\u7B07\u7B09\u7B0C\u7B0D\u7B0E\u7B10\u7B12\u7B13\u7B16\u7B17\u7B18\u7B1A\u7B1C\u7B1D\u7B1F\u7B21\u7B22\u7B23\u7B27\u7B29\u7B2D\u6D6E\u6DAA\u798F\u88B1\u5F17\u752B\u629A\u8F85\u4FEF\u91DC\u65A7\u812F\u8151\u5E9C\u8150\u8D74\u526F\u8986\u8D4B\u590D\u5085\u4ED8\u961C\u7236\u8179\u8D1F\u5BCC\u8BA3\u9644\u5987\u7F1A\u5490\u5676\u560E\u8BE5\u6539\u6982\u9499\u76D6\u6E89\u5E72\u7518\u6746\u67D1\u7AFF\u809D\u8D76\u611F\u79C6\u6562\u8D63\u5188\u521A\u94A2\u7F38\u809B\u7EB2\u5C97\u6E2F\u6760\u7BD9\u768B\u9AD8\u818F\u7F94\u7CD5\u641E\u9550\u7A3F\u544A\u54E5\u6B4C\u6401\u6208\u9E3D\u80F3\u7599\u5272\u9769\u845B\u683C\u86E4\u9601\u9694\u94EC\u4E2A\u5404\u7ED9\u6839\u8DDF\u8015\u66F4\u5E9A\u7FB9"],
      ["b940", "\u7B2F\u7B30\u7B32\u7B34\u7B35\u7B36\u7B37\u7B39\u7B3B\u7B3D\u7B3F", 5, "\u7B46\u7B48\u7B4A\u7B4D\u7B4E\u7B53\u7B55\u7B57\u7B59\u7B5C\u7B5E\u7B5F\u7B61\u7B63", 10, "\u7B6F\u7B70\u7B73\u7B74\u7B76\u7B78\u7B7A\u7B7C\u7B7D\u7B7F\u7B81\u7B82\u7B83\u7B84\u7B86", 6, "\u7B8E\u7B8F"],
      ["b980", "\u7B91\u7B92\u7B93\u7B96\u7B98\u7B99\u7B9A\u7B9B\u7B9E\u7B9F\u7BA0\u7BA3\u7BA4\u7BA5\u7BAE\u7BAF\u7BB0\u7BB2\u7BB3\u7BB5\u7BB6\u7BB7\u7BB9", 7, "\u7BC2\u7BC3\u7BC4\u57C2\u803F\u6897\u5DE5\u653B\u529F\u606D\u9F9A\u4F9B\u8EAC\u516C\u5BAB\u5F13\u5DE9\u6C5E\u62F1\u8D21\u5171\u94A9\u52FE\u6C9F\u82DF\u72D7\u57A2\u6784\u8D2D\u591F\u8F9C\u83C7\u5495\u7B8D\u4F30\u6CBD\u5B64\u59D1\u9F13\u53E4\u86CA\u9AA8\u8C37\u80A1\u6545\u987E\u56FA\u96C7\u522E\u74DC\u5250\u5BE1\u6302\u8902\u4E56\u62D0\u602A\u68FA\u5173\u5B98\u51A0\u89C2\u7BA1\u9986\u7F50\u60EF\u704C\u8D2F\u5149\u5E7F\u901B\u7470\u89C4\u572D\u7845\u5F52\u9F9F\u95FA\u8F68\u9B3C\u8BE1\u7678\u6842\u67DC\u8DEA\u8D35\u523D\u8F8A\u6EDA\u68CD\u9505\u90ED\u56FD\u679C\u88F9\u8FC7\u54C8"],
      ["ba40", "\u7BC5\u7BC8\u7BC9\u7BCA\u7BCB\u7BCD\u7BCE\u7BCF\u7BD0\u7BD2\u7BD4", 4, "\u7BDB\u7BDC\u7BDE\u7BDF\u7BE0\u7BE2\u7BE3\u7BE4\u7BE7\u7BE8\u7BE9\u7BEB\u7BEC\u7BED\u7BEF\u7BF0\u7BF2", 4, "\u7BF8\u7BF9\u7BFA\u7BFB\u7BFD\u7BFF", 7, "\u7C08\u7C09\u7C0A\u7C0D\u7C0E\u7C10", 5, "\u7C17\u7C18\u7C19"],
      ["ba80", "\u7C1A", 4, "\u7C20", 5, "\u7C28\u7C29\u7C2B", 12, "\u7C39", 5, "\u7C42\u9AB8\u5B69\u6D77\u6C26\u4EA5\u5BB3\u9A87\u9163\u61A8\u90AF\u97E9\u542B\u6DB5\u5BD2\u51FD\u558A\u7F55\u7FF0\u64BC\u634D\u65F1\u61BE\u608D\u710A\u6C57\u6C49\u592F\u676D\u822A\u58D5\u568E\u8C6A\u6BEB\u90DD\u597D\u8017\u53F7\u6D69\u5475\u559D\u8377\u83CF\u6838\u79BE\u548C\u4F55\u5408\u76D2\u8C89\u9602\u6CB3\u6DB8\u8D6B\u8910\u9E64\u8D3A\u563F\u9ED1\u75D5\u5F88\u72E0\u6068\u54FC\u4EA8\u6A2A\u8861\u6052\u8F70\u54C4\u70D8\u8679\u9E3F\u6D2A\u5B8F\u5F18\u7EA2\u5589\u4FAF\u7334\u543C\u539A\u5019\u540E\u547C\u4E4E\u5FFD\u745A\u58F6\u846B\u80E1\u8774\u72D0\u7CCA\u6E56"],
      ["bb40", "\u7C43", 9, "\u7C4E", 36, "\u7C75", 5, "\u7C7E", 9],
      ["bb80", "\u7C88\u7C8A", 6, "\u7C93\u7C94\u7C96\u7C99\u7C9A\u7C9B\u7CA0\u7CA1\u7CA3\u7CA6\u7CA7\u7CA8\u7CA9\u7CAB\u7CAC\u7CAD\u7CAF\u7CB0\u7CB4", 4, "\u7CBA\u7CBB\u5F27\u864E\u552C\u62A4\u4E92\u6CAA\u6237\u82B1\u54D7\u534E\u733E\u6ED1\u753B\u5212\u5316\u8BDD\u69D0\u5F8A\u6000\u6DEE\u574F\u6B22\u73AF\u6853\u8FD8\u7F13\u6362\u60A3\u5524\u75EA\u8C62\u7115\u6DA3\u5BA6\u5E7B\u8352\u614C\u9EC4\u78FA\u8757\u7C27\u7687\u51F0\u60F6\u714C\u6643\u5E4C\u604D\u8C0E\u7070\u6325\u8F89\u5FBD\u6062\u86D4\u56DE\u6BC1\u6094\u6167\u5349\u60E0\u6666\u8D3F\u79FD\u4F1A\u70E9\u6C47\u8BB3\u8BF2\u7ED8\u8364\u660F\u5A5A\u9B42\u6D51\u6DF7\u8C41\u6D3B\u4F19\u706B\u83B7\u6216\u60D1\u970D\u8D27\u7978\u51FB\u573E\u57FA\u673A\u7578\u7A3D\u79EF\u7B95"],
      ["bc40", "\u7CBF\u7CC0\u7CC2\u7CC3\u7CC4\u7CC6\u7CC9\u7CCB\u7CCE", 6, "\u7CD8\u7CDA\u7CDB\u7CDD\u7CDE\u7CE1", 6, "\u7CE9", 5, "\u7CF0", 7, "\u7CF9\u7CFA\u7CFC", 13, "\u7D0B", 5],
      ["bc80", "\u7D11", 14, "\u7D21\u7D23\u7D24\u7D25\u7D26\u7D28\u7D29\u7D2A\u7D2C\u7D2D\u7D2E\u7D30", 6, "\u808C\u9965\u8FF9\u6FC0\u8BA5\u9E21\u59EC\u7EE9\u7F09\u5409\u6781\u68D8\u8F91\u7C4D\u96C6\u53CA\u6025\u75BE\u6C72\u5373\u5AC9\u7EA7\u6324\u51E0\u810A\u5DF1\u84DF\u6280\u5180\u5B63\u4F0E\u796D\u5242\u60B8\u6D4E\u5BC4\u5BC2\u8BA1\u8BB0\u65E2\u5FCC\u9645\u5993\u7EE7\u7EAA\u5609\u67B7\u5939\u4F73\u5BB6\u52A0\u835A\u988A\u8D3E\u7532\u94BE\u5047\u7A3C\u4EF7\u67B6\u9A7E\u5AC1\u6B7C\u76D1\u575A\u5C16\u7B3A\u95F4\u714E\u517C\u80A9\u8270\u5978\u7F04\u8327\u68C0\u67EC\u78B1\u7877\u62E3\u6361\u7B80\u4FED\u526A\u51CF\u8350\u69DB\u9274\u8DF5\u8D31\u89C1\u952E\u7BAD\u4EF6"],
      ["bd40", "\u7D37", 54, "\u7D6F", 7],
      ["bd80", "\u7D78", 32, "\u5065\u8230\u5251\u996F\u6E10\u6E85\u6DA7\u5EFA\u50F5\u59DC\u5C06\u6D46\u6C5F\u7586\u848B\u6868\u5956\u8BB2\u5320\u9171\u964D\u8549\u6912\u7901\u7126\u80F6\u4EA4\u90CA\u6D47\u9A84\u5A07\u56BC\u6405\u94F0\u77EB\u4FA5\u811A\u72E1\u89D2\u997A\u7F34\u7EDE\u527F\u6559\u9175\u8F7F\u8F83\u53EB\u7A96\u63ED\u63A5\u7686\u79F8\u8857\u9636\u622A\u52AB\u8282\u6854\u6770\u6377\u776B\u7AED\u6D01\u7ED3\u89E3\u59D0\u6212\u85C9\u82A5\u754C\u501F\u4ECB\u75A5\u8BEB\u5C4A\u5DFE\u7B4B\u65A4\u91D1\u4ECA\u6D25\u895F\u7D27\u9526\u4EC5\u8C28\u8FDB\u9773\u664B\u7981\u8FD1\u70EC\u6D78"],
      ["be40", "\u7D99", 12, "\u7DA7", 6, "\u7DAF", 42],
      ["be80", "\u7DDA", 32, "\u5C3D\u52B2\u8346\u5162\u830E\u775B\u6676\u9CB8\u4EAC\u60CA\u7CBE\u7CB3\u7ECF\u4E95\u8B66\u666F\u9888\u9759\u5883\u656C\u955C\u5F84\u75C9\u9756\u7ADF\u7ADE\u51C0\u70AF\u7A98\u63EA\u7A76\u7EA0\u7396\u97ED\u4E45\u7078\u4E5D\u9152\u53A9\u6551\u65E7\u81FC\u8205\u548E\u5C31\u759A\u97A0\u62D8\u72D9\u75BD\u5C45\u9A79\u83CA\u5C40\u5480\u77E9\u4E3E\u6CAE\u805A\u62D2\u636E\u5DE8\u5177\u8DDD\u8E1E\u952F\u4FF1\u53E5\u60E7\u70AC\u5267\u6350\u9E43\u5A1F\u5026\u7737\u5377\u7EE2\u6485\u652B\u6289\u6398\u5014\u7235\u89C9\u51B3\u8BC0\u7EDD\u5747\u83CC\u94A7\u519B\u541B\u5CFB"],
      ["bf40", "\u7DFB", 62],
      ["bf80", "\u7E3A\u7E3C", 4, "\u7E42", 4, "\u7E48", 21, "\u4FCA\u7AE3\u6D5A\u90E1\u9A8F\u5580\u5496\u5361\u54AF\u5F00\u63E9\u6977\u51EF\u6168\u520A\u582A\u52D8\u574E\u780D\u770B\u5EB7\u6177\u7CE0\u625B\u6297\u4EA2\u7095\u8003\u62F7\u70E4\u9760\u5777\u82DB\u67EF\u68F5\u78D5\u9897\u79D1\u58F3\u54B3\u53EF\u6E34\u514B\u523B\u5BA2\u8BFE\u80AF\u5543\u57A6\u6073\u5751\u542D\u7A7A\u6050\u5B54\u63A7\u62A0\u53E3\u6263\u5BC7\u67AF\u54ED\u7A9F\u82E6\u9177\u5E93\u88E4\u5938\u57AE\u630E\u8DE8\u80EF\u5757\u7B77\u4FA9\u5FEB\u5BBD\u6B3E\u5321\u7B50\u72C2\u6846\u77FF\u7736\u65F7\u51B5\u4E8F\u76D4\u5CBF\u7AA5\u8475\u594E\u9B41\u5080"],
      ["c040", "\u7E5E", 35, "\u7E83", 23, "\u7E9C\u7E9D\u7E9E"],
      ["c080", "\u7EAE\u7EB4\u7EBB\u7EBC\u7ED6\u7EE4\u7EEC\u7EF9\u7F0A\u7F10\u7F1E\u7F37\u7F39\u7F3B", 6, "\u7F43\u7F46", 9, "\u7F52\u7F53\u9988\u6127\u6E83\u5764\u6606\u6346\u56F0\u62EC\u6269\u5ED3\u9614\u5783\u62C9\u5587\u8721\u814A\u8FA3\u5566\u83B1\u6765\u8D56\u84DD\u5A6A\u680F\u62E6\u7BEE\u9611\u5170\u6F9C\u8C30\u63FD\u89C8\u61D2\u7F06\u70C2\u6EE5\u7405\u6994\u72FC\u5ECA\u90CE\u6717\u6D6A\u635E\u52B3\u7262\u8001\u4F6C\u59E5\u916A\u70D9\u6D9D\u52D2\u4E50\u96F7\u956D\u857E\u78CA\u7D2F\u5121\u5792\u64C2\u808B\u7C7B\u6CEA\u68F1\u695E\u51B7\u5398\u68A8\u7281\u9ECE\u7BF1\u72F8\u79BB\u6F13\u7406\u674E\u91CC\u9CA4\u793C\u8389\u8354\u540F\u6817\u4E3D\u5389\u52B1\u783E\u5386\u5229\u5088\u4F8B\u4FD0"],
      ["c140", "\u7F56\u7F59\u7F5B\u7F5C\u7F5D\u7F5E\u7F60\u7F63", 4, "\u7F6B\u7F6C\u7F6D\u7F6F\u7F70\u7F73\u7F75\u7F76\u7F77\u7F78\u7F7A\u7F7B\u7F7C\u7F7D\u7F7F\u7F80\u7F82", 7, "\u7F8B\u7F8D\u7F8F", 4, "\u7F95", 4, "\u7F9B\u7F9C\u7FA0\u7FA2\u7FA3\u7FA5\u7FA6\u7FA8", 6, "\u7FB1"],
      ["c180", "\u7FB3", 4, "\u7FBA\u7FBB\u7FBE\u7FC0\u7FC2\u7FC3\u7FC4\u7FC6\u7FC7\u7FC8\u7FC9\u7FCB\u7FCD\u7FCF", 4, "\u7FD6\u7FD7\u7FD9", 5, "\u7FE2\u7FE3\u75E2\u7ACB\u7C92\u6CA5\u96B6\u529B\u7483\u54E9\u4FE9\u8054\u83B2\u8FDE\u9570\u5EC9\u601C\u6D9F\u5E18\u655B\u8138\u94FE\u604B\u70BC\u7EC3\u7CAE\u51C9\u6881\u7CB1\u826F\u4E24\u8F86\u91CF\u667E\u4EAE\u8C05\u64A9\u804A\u50DA\u7597\u71CE\u5BE5\u8FBD\u6F66\u4E86\u6482\u9563\u5ED6\u6599\u5217\u88C2\u70C8\u52A3\u730E\u7433\u6797\u78F7\u9716\u4E34\u90BB\u9CDE\u6DCB\u51DB\u8D41\u541D\u62CE\u73B2\u83F1\u96F6\u9F84\u94C3\u4F36\u7F9A\u51CC\u7075\u9675\u5CAD\u9886\u53E6\u4EE4\u6E9C\u7409\u69B4\u786B\u998F\u7559\u5218\u7624\u6D41\u67F3\u516D\u9F99\u804B\u5499\u7B3C\u7ABF"],
      ["c240", "\u7FE4\u7FE7\u7FE8\u7FEA\u7FEB\u7FEC\u7FED\u7FEF\u7FF2\u7FF4", 6, "\u7FFD\u7FFE\u7FFF\u8002\u8007\u8008\u8009\u800A\u800E\u800F\u8011\u8013\u801A\u801B\u801D\u801E\u801F\u8021\u8023\u8024\u802B", 5, "\u8032\u8034\u8039\u803A\u803C\u803E\u8040\u8041\u8044\u8045\u8047\u8048\u8049\u804E\u804F\u8050\u8051\u8053\u8055\u8056\u8057"],
      ["c280", "\u8059\u805B", 13, "\u806B", 5, "\u8072", 11, "\u9686\u5784\u62E2\u9647\u697C\u5A04\u6402\u7BD3\u6F0F\u964B\u82A6\u5362\u9885\u5E90\u7089\u63B3\u5364\u864F\u9C81\u9E93\u788C\u9732\u8DEF\u8D42\u9E7F\u6F5E\u7984\u5F55\u9646\u622E\u9A74\u5415\u94DD\u4FA3\u65C5\u5C65\u5C61\u7F15\u8651\u6C2F\u5F8B\u7387\u6EE4\u7EFF\u5CE6\u631B\u5B6A\u6EE6\u5375\u4E71\u63A0\u7565\u62A1\u8F6E\u4F26\u4ED1\u6CA6\u7EB6\u8BBA\u841D\u87BA\u7F57\u903B\u9523\u7BA9\u9AA1\u88F8\u843D\u6D1B\u9A86\u7EDC\u5988\u9EBB\u739B\u7801\u8682\u9A6C\u9A82\u561B\u5417\u57CB\u4E70\u9EA6\u5356\u8FC8\u8109\u7792\u9992\u86EE\u6EE1\u8513\u66FC\u6162\u6F2B"],
      ["c340", "\u807E\u8081\u8082\u8085\u8088\u808A\u808D", 5, "\u8094\u8095\u8097\u8099\u809E\u80A3\u80A6\u80A7\u80A8\u80AC\u80B0\u80B3\u80B5\u80B6\u80B8\u80B9\u80BB\u80C5\u80C7", 4, "\u80CF", 6, "\u80D8\u80DF\u80E0\u80E2\u80E3\u80E6\u80EE\u80F5\u80F7\u80F9\u80FB\u80FE\u80FF\u8100\u8101\u8103\u8104\u8105\u8107\u8108\u810B"],
      ["c380", "\u810C\u8115\u8117\u8119\u811B\u811C\u811D\u811F", 12, "\u812D\u812E\u8130\u8133\u8134\u8135\u8137\u8139", 4, "\u813F\u8C29\u8292\u832B\u76F2\u6C13\u5FD9\u83BD\u732B\u8305\u951A\u6BDB\u77DB\u94C6\u536F\u8302\u5192\u5E3D\u8C8C\u8D38\u4E48\u73AB\u679A\u6885\u9176\u9709\u7164\u6CA1\u7709\u5A92\u9541\u6BCF\u7F8E\u6627\u5BD0\u59B9\u5A9A\u95E8\u95F7\u4EEC\u840C\u8499\u6AAC\u76DF\u9530\u731B\u68A6\u5B5F\u772F\u919A\u9761\u7CDC\u8FF7\u8C1C\u5F25\u7C73\u79D8\u89C5\u6CCC\u871C\u5BC6\u5E42\u68C9\u7720\u7EF5\u5195\u514D\u52C9\u5A29\u7F05\u9762\u82D7\u63CF\u7784\u85D0\u79D2\u6E3A\u5E99\u5999\u8511\u706D\u6C11\u62BF\u76BF\u654F\u60AF\u95FD\u660E\u879F\u9E23\u94ED\u540D\u547D\u8C2C\u6478"],
      ["c440", "\u8140", 5, "\u8147\u8149\u814D\u814E\u814F\u8152\u8156\u8157\u8158\u815B", 4, "\u8161\u8162\u8163\u8164\u8166\u8168\u816A\u816B\u816C\u816F\u8172\u8173\u8175\u8176\u8177\u8178\u8181\u8183", 4, "\u8189\u818B\u818C\u818D\u818E\u8190\u8192", 5, "\u8199\u819A\u819E", 4, "\u81A4\u81A5"],
      ["c480", "\u81A7\u81A9\u81AB", 7, "\u81B4", 5, "\u81BC\u81BD\u81BE\u81BF\u81C4\u81C5\u81C7\u81C8\u81C9\u81CB\u81CD", 6, "\u6479\u8611\u6A21\u819C\u78E8\u6469\u9B54\u62B9\u672B\u83AB\u58A8\u9ED8\u6CAB\u6F20\u5BDE\u964C\u8C0B\u725F\u67D0\u62C7\u7261\u4EA9\u59C6\u6BCD\u5893\u66AE\u5E55\u52DF\u6155\u6728\u76EE\u7766\u7267\u7A46\u62FF\u54EA\u5450\u94A0\u90A3\u5A1C\u7EB3\u6C16\u4E43\u5976\u8010\u5948\u5357\u7537\u96BE\u56CA\u6320\u8111\u607C\u95F9\u6DD6\u5462\u9981\u5185\u5AE9\u80FD\u59AE\u9713\u502A\u6CE5\u5C3C\u62DF\u4F60\u533F\u817B\u9006\u6EBA\u852B\u62C8\u5E74\u78BE\u64B5\u637B\u5FF5\u5A18\u917F\u9E1F\u5C3F\u634F\u8042\u5B7D\u556E\u954A\u954D\u6D85\u60A8\u67E0\u72DE\u51DD\u5B81"],
      ["c540", "\u81D4", 14, "\u81E4\u81E5\u81E6\u81E8\u81E9\u81EB\u81EE", 4, "\u81F5", 5, "\u81FD\u81FF\u8203\u8207", 4, "\u820E\u820F\u8211\u8213\u8215", 5, "\u821D\u8220\u8224\u8225\u8226\u8227\u8229\u822E\u8232\u823A\u823C\u823D\u823F"],
      ["c580", "\u8240\u8241\u8242\u8243\u8245\u8246\u8248\u824A\u824C\u824D\u824E\u8250", 7, "\u8259\u825B\u825C\u825D\u825E\u8260", 7, "\u8269\u62E7\u6CDE\u725B\u626D\u94AE\u7EBD\u8113\u6D53\u519C\u5F04\u5974\u52AA\u6012\u5973\u6696\u8650\u759F\u632A\u61E6\u7CEF\u8BFA\u54E6\u6B27\u9E25\u6BB4\u85D5\u5455\u5076\u6CA4\u556A\u8DB4\u722C\u5E15\u6015\u7436\u62CD\u6392\u724C\u5F98\u6E43\u6D3E\u6500\u6F58\u76D8\u78D0\u76FC\u7554\u5224\u53DB\u4E53\u5E9E\u65C1\u802A\u80D6\u629B\u5486\u5228\u70AE\u888D\u8DD1\u6CE1\u5478\u80DA\u57F9\u88F4\u8D54\u966A\u914D\u4F69\u6C9B\u55B7\u76C6\u7830\u62A8\u70F9\u6F8E\u5F6D\u84EC\u68DA\u787C\u7BF7\u81A8\u670B\u9E4F\u6367\u78B0\u576F\u7812\u9739\u6279\u62AB\u5288\u7435\u6BD7"],
      ["c640", "\u826A\u826B\u826C\u826D\u8271\u8275\u8276\u8277\u8278\u827B\u827C\u8280\u8281\u8283\u8285\u8286\u8287\u8289\u828C\u8290\u8293\u8294\u8295\u8296\u829A\u829B\u829E\u82A0\u82A2\u82A3\u82A7\u82B2\u82B5\u82B6\u82BA\u82BB\u82BC\u82BF\u82C0\u82C2\u82C3\u82C5\u82C6\u82C9\u82D0\u82D6\u82D9\u82DA\u82DD\u82E2\u82E7\u82E8\u82E9\u82EA\u82EC\u82ED\u82EE\u82F0\u82F2\u82F3\u82F5\u82F6\u82F8"],
      ["c680", "\u82FA\u82FC", 4, "\u830A\u830B\u830D\u8310\u8312\u8313\u8316\u8318\u8319\u831D", 9, "\u8329\u832A\u832E\u8330\u8332\u8337\u833B\u833D\u5564\u813E\u75B2\u76AE\u5339\u75DE\u50FB\u5C41\u8B6C\u7BC7\u504F\u7247\u9A97\u98D8\u6F02\u74E2\u7968\u6487\u77A5\u62FC\u9891\u8D2B\u54C1\u8058\u4E52\u576A\u82F9\u840D\u5E73\u51ED\u74F6\u8BC4\u5C4F\u5761\u6CFC\u9887\u5A46\u7834\u9B44\u8FEB\u7C95\u5256\u6251\u94FA\u4EC6\u8386\u8461\u83E9\u84B2\u57D4\u6734\u5703\u666E\u6D66\u8C31\u66DD\u7011\u671F\u6B3A\u6816\u621A\u59BB\u4E03\u51C4\u6F06\u67D2\u6C8F\u5176\u68CB\u5947\u6B67\u7566\u5D0E\u8110\u9F50\u65D7\u7948\u7941\u9A91\u8D77\u5C82\u4E5E\u4F01\u542F\u5951\u780C\u5668\u6C14\u8FC4\u5F03\u6C7D\u6CE3\u8BAB\u6390"],
      ["c740", "\u833E\u833F\u8341\u8342\u8344\u8345\u8348\u834A", 4, "\u8353\u8355", 4, "\u835D\u8362\u8370", 6, "\u8379\u837A\u837E", 6, "\u8387\u8388\u838A\u838B\u838C\u838D\u838F\u8390\u8391\u8394\u8395\u8396\u8397\u8399\u839A\u839D\u839F\u83A1", 6, "\u83AC\u83AD\u83AE"],
      ["c780", "\u83AF\u83B5\u83BB\u83BE\u83BF\u83C2\u83C3\u83C4\u83C6\u83C8\u83C9\u83CB\u83CD\u83CE\u83D0\u83D1\u83D2\u83D3\u83D5\u83D7\u83D9\u83DA\u83DB\u83DE\u83E2\u83E3\u83E4\u83E6\u83E7\u83E8\u83EB\u83EC\u83ED\u6070\u6D3D\u7275\u6266\u948E\u94C5\u5343\u8FC1\u7B7E\u4EDF\u8C26\u4E7E\u9ED4\u94B1\u94B3\u524D\u6F5C\u9063\u6D45\u8C34\u5811\u5D4C\u6B20\u6B49\u67AA\u545B\u8154\u7F8C\u5899\u8537\u5F3A\u62A2\u6A47\u9539\u6572\u6084\u6865\u77A7\u4E54\u4FA8\u5DE7\u9798\u64AC\u7FD8\u5CED\u4FCF\u7A8D\u5207\u8304\u4E14\u602F\u7A83\u94A6\u4FB5\u4EB2\u79E6\u7434\u52E4\u82B9\u64D2\u79BD\u5BDD\u6C81\u9752\u8F7B\u6C22\u503E\u537F\u6E05\u64CE\u6674\u6C30\u60C5\u9877\u8BF7\u5E86\u743C\u7A77\u79CB\u4E18\u90B1\u7403\u6C42\u56DA\u914B\u6CC5\u8D8B\u533A\u86C6\u66F2\u8EAF\u5C48\u9A71\u6E20"],
      ["c840", "\u83EE\u83EF\u83F3", 4, "\u83FA\u83FB\u83FC\u83FE\u83FF\u8400\u8402\u8405\u8407\u8408\u8409\u840A\u8410\u8412", 5, "\u8419\u841A\u841B\u841E", 5, "\u8429", 7, "\u8432", 5, "\u8439\u843A\u843B\u843E", 7, "\u8447\u8448\u8449"],
      ["c880", "\u844A", 6, "\u8452", 4, "\u8458\u845D\u845E\u845F\u8460\u8462\u8464", 4, "\u846A\u846E\u846F\u8470\u8472\u8474\u8477\u8479\u847B\u847C\u53D6\u5A36\u9F8B\u8DA3\u53BB\u5708\u98A7\u6743\u919B\u6CC9\u5168\u75CA\u62F3\u72AC\u5238\u529D\u7F3A\u7094\u7638\u5374\u9E4A\u69B7\u786E\u96C0\u88D9\u7FA4\u7136\u71C3\u5189\u67D3\u74E4\u58E4\u6518\u56B7\u8BA9\u9976\u6270\u7ED5\u60F9\u70ED\u58EC\u4EC1\u4EBA\u5FCD\u97E7\u4EFB\u8BA4\u5203\u598A\u7EAB\u6254\u4ECD\u65E5\u620E\u8338\u84C9\u8363\u878D\u7194\u6EB6\u5BB9\u7ED2\u5197\u63C9\u67D4\u8089\u8339\u8815\u5112\u5B7A\u5982\u8FB1\u4E73\u6C5D\u5165\u8925\u8F6F\u962E\u854A\u745E\u9510\u95F0\u6DA6\u82E5\u5F31\u6492\u6D12\u8428\u816E\u9CC3\u585E\u8D5B\u4E09\u53C1"],
      ["c940", "\u847D", 4, "\u8483\u8484\u8485\u8486\u848A\u848D\u848F", 7, "\u8498\u849A\u849B\u849D\u849E\u849F\u84A0\u84A2", 12, "\u84B0\u84B1\u84B3\u84B5\u84B6\u84B7\u84BB\u84BC\u84BE\u84C0\u84C2\u84C3\u84C5\u84C6\u84C7\u84C8\u84CB\u84CC\u84CE\u84CF\u84D2\u84D4\u84D5\u84D7"],
      ["c980", "\u84D8", 4, "\u84DE\u84E1\u84E2\u84E4\u84E7", 4, "\u84ED\u84EE\u84EF\u84F1", 10, "\u84FD\u84FE\u8500\u8501\u8502\u4F1E\u6563\u6851\u55D3\u4E27\u6414\u9A9A\u626B\u5AC2\u745F\u8272\u6DA9\u68EE\u50E7\u838E\u7802\u6740\u5239\u6C99\u7EB1\u50BB\u5565\u715E\u7B5B\u6652\u73CA\u82EB\u6749\u5C71\u5220\u717D\u886B\u95EA\u9655\u64C5\u8D61\u81B3\u5584\u6C55\u6247\u7F2E\u5892\u4F24\u5546\u8D4F\u664C\u4E0A\u5C1A\u88F3\u68A2\u634E\u7A0D\u70E7\u828D\u52FA\u97F6\u5C11\u54E8\u90B5\u7ECD\u5962\u8D4A\u86C7\u820C\u820D\u8D66\u6444\u5C04\u6151\u6D89\u793E\u8BBE\u7837\u7533\u547B\u4F38\u8EAB\u6DF1\u5A20\u7EC5\u795E\u6C88\u5BA1\u5A76\u751A\u80BE\u614E\u6E17\u58F0\u751F\u7525\u7272\u5347\u7EF3"],
      ["ca40", "\u8503", 8, "\u850D\u850E\u850F\u8510\u8512\u8514\u8515\u8516\u8518\u8519\u851B\u851C\u851D\u851E\u8520\u8522", 8, "\u852D", 9, "\u853E", 4, "\u8544\u8545\u8546\u8547\u854B", 10],
      ["ca80", "\u8557\u8558\u855A\u855B\u855C\u855D\u855F", 4, "\u8565\u8566\u8567\u8569", 8, "\u8573\u8575\u8576\u8577\u8578\u857C\u857D\u857F\u8580\u8581\u7701\u76DB\u5269\u80DC\u5723\u5E08\u5931\u72EE\u65BD\u6E7F\u8BD7\u5C38\u8671\u5341\u77F3\u62FE\u65F6\u4EC0\u98DF\u8680\u5B9E\u8BC6\u53F2\u77E2\u4F7F\u5C4E\u9A76\u59CB\u5F0F\u793A\u58EB\u4E16\u67FF\u4E8B\u62ED\u8A93\u901D\u52BF\u662F\u55DC\u566C\u9002\u4ED5\u4F8D\u91CA\u9970\u6C0F\u5E02\u6043\u5BA4\u89C6\u8BD5\u6536\u624B\u9996\u5B88\u5BFF\u6388\u552E\u53D7\u7626\u517D\u852C\u67A2\u68B3\u6B8A\u6292\u8F93\u53D4\u8212\u6DD1\u758F\u4E66\u8D4E\u5B70\u719F\u85AF\u6691\u66D9\u7F72\u8700\u9ECD\u9F20\u5C5E\u672F\u8FF0\u6811\u675F\u620D\u7AD6\u5885\u5EB6\u6570\u6F31"],
      ["cb40", "\u8582\u8583\u8586\u8588", 6, "\u8590", 10, "\u859D", 6, "\u85A5\u85A6\u85A7\u85A9\u85AB\u85AC\u85AD\u85B1", 5, "\u85B8\u85BA", 6, "\u85C2", 6, "\u85CA", 4, "\u85D1\u85D2"],
      ["cb80", "\u85D4\u85D6", 5, "\u85DD", 6, "\u85E5\u85E6\u85E7\u85E8\u85EA", 14, "\u6055\u5237\u800D\u6454\u8870\u7529\u5E05\u6813\u62F4\u971C\u53CC\u723D\u8C01\u6C34\u7761\u7A0E\u542E\u77AC\u987A\u821C\u8BF4\u7855\u6714\u70C1\u65AF\u6495\u5636\u601D\u79C1\u53F8\u4E1D\u6B7B\u8086\u5BFA\u55E3\u56DB\u4F3A\u4F3C\u9972\u5DF3\u677E\u8038\u6002\u9882\u9001\u5B8B\u8BBC\u8BF5\u641C\u8258\u64DE\u55FD\u82CF\u9165\u4FD7\u7D20\u901F\u7C9F\u50F3\u5851\u6EAF\u5BBF\u8BC9\u8083\u9178\u849C\u7B97\u867D\u968B\u968F\u7EE5\u9AD3\u788E\u5C81\u7A57\u9042\u96A7\u795F\u5B59\u635F\u7B0B\u84D1\u68AD\u5506\u7F29\u7410\u7D22\u9501\u6240\u584C\u4ED6\u5B83\u5979\u5854"],
      ["cc40", "\u85F9\u85FA\u85FC\u85FD\u85FE\u8600", 4, "\u8606", 10, "\u8612\u8613\u8614\u8615\u8617", 15, "\u8628\u862A", 13, "\u8639\u863A\u863B\u863D\u863E\u863F\u8640"],
      ["cc80", "\u8641", 11, "\u8652\u8653\u8655", 4, "\u865B\u865C\u865D\u865F\u8660\u8661\u8663", 7, "\u736D\u631E\u8E4B\u8E0F\u80CE\u82D4\u62AC\u53F0\u6CF0\u915E\u592A\u6001\u6C70\u574D\u644A\u8D2A\u762B\u6EE9\u575B\u6A80\u75F0\u6F6D\u8C2D\u8C08\u5766\u6BEF\u8892\u78B3\u63A2\u53F9\u70AD\u6C64\u5858\u642A\u5802\u68E0\u819B\u5510\u7CD6\u5018\u8EBA\u6DCC\u8D9F\u70EB\u638F\u6D9B\u6ED4\u7EE6\u8404\u6843\u9003\u6DD8\u9676\u8BA8\u5957\u7279\u85E4\u817E\u75BC\u8A8A\u68AF\u5254\u8E22\u9511\u63D0\u9898\u8E44\u557C\u4F53\u66FF\u568F\u60D5\u6D95\u5243\u5C49\u5929\u6DFB\u586B\u7530\u751C\u606C\u8214\u8146\u6311\u6761\u8FE2\u773A\u8DF3\u8D34\u94C1\u5E16\u5385\u542C\u70C3"],
      ["cd40", "\u866D\u866F\u8670\u8672", 6, "\u8683", 6, "\u868E", 4, "\u8694\u8696", 5, "\u869E", 4, "\u86A5\u86A6\u86AB\u86AD\u86AE\u86B2\u86B3\u86B7\u86B8\u86B9\u86BB", 4, "\u86C1\u86C2\u86C3\u86C5\u86C8\u86CC\u86CD\u86D2\u86D3\u86D5\u86D6\u86D7\u86DA\u86DC"],
      ["cd80", "\u86DD\u86E0\u86E1\u86E2\u86E3\u86E5\u86E6\u86E7\u86E8\u86EA\u86EB\u86EC\u86EF\u86F5\u86F6\u86F7\u86FA\u86FB\u86FC\u86FD\u86FF\u8701\u8704\u8705\u8706\u870B\u870C\u870E\u870F\u8710\u8711\u8714\u8716\u6C40\u5EF7\u505C\u4EAD\u5EAD\u633A\u8247\u901A\u6850\u916E\u77B3\u540C\u94DC\u5F64\u7AE5\u6876\u6345\u7B52\u7EDF\u75DB\u5077\u6295\u5934\u900F\u51F8\u79C3\u7A81\u56FE\u5F92\u9014\u6D82\u5C60\u571F\u5410\u5154\u6E4D\u56E2\u63A8\u9893\u817F\u8715\u892A\u9000\u541E\u5C6F\u81C0\u62D6\u6258\u8131\u9E35\u9640\u9A6E\u9A7C\u692D\u59A5\u62D3\u553E\u6316\u54C7\u86D9\u6D3C\u5A03\u74E6\u889C\u6B6A\u5916\u8C4C\u5F2F\u6E7E\u73A9\u987D\u4E38\u70F7\u5B8C\u7897\u633D\u665A\u7696\u60CB\u5B9B\u5A49\u4E07\u8155\u6C6A\u738B\u4EA1\u6789\u7F51\u5F80\u65FA\u671B\u5FD8\u5984\u5A01"],
      ["ce40", "\u8719\u871B\u871D\u871F\u8720\u8724\u8726\u8727\u8728\u872A\u872B\u872C\u872D\u872F\u8730\u8732\u8733\u8735\u8736\u8738\u8739\u873A\u873C\u873D\u8740", 6, "\u874A\u874B\u874D\u874F\u8750\u8751\u8752\u8754\u8755\u8756\u8758\u875A", 5, "\u8761\u8762\u8766", 7, "\u876F\u8771\u8772\u8773\u8775"],
      ["ce80", "\u8777\u8778\u8779\u877A\u877F\u8780\u8781\u8784\u8786\u8787\u8789\u878A\u878C\u878E", 4, "\u8794\u8795\u8796\u8798", 6, "\u87A0", 4, "\u5DCD\u5FAE\u5371\u97E6\u8FDD\u6845\u56F4\u552F\u60DF\u4E3A\u6F4D\u7EF4\u82C7\u840E\u59D4\u4F1F\u4F2A\u5C3E\u7EAC\u672A\u851A\u5473\u754F\u80C3\u5582\u9B4F\u4F4D\u6E2D\u8C13\u5C09\u6170\u536B\u761F\u6E29\u868A\u6587\u95FB\u7EB9\u543B\u7A33\u7D0A\u95EE\u55E1\u7FC1\u74EE\u631D\u8717\u6DA1\u7A9D\u6211\u65A1\u5367\u63E1\u6C83\u5DEB\u545C\u94A8\u4E4C\u6C61\u8BEC\u5C4B\u65E0\u829C\u68A7\u543E\u5434\u6BCB\u6B66\u4E94\u6342\u5348\u821E\u4F0D\u4FAE\u575E\u620A\u96FE\u6664\u7269\u52FF\u52A1\u609F\u8BEF\u6614\u7199\u6790\u897F\u7852\u77FD\u6670\u563B\u5438\u9521\u727A"],
      ["cf40", "\u87A5\u87A6\u87A7\u87A9\u87AA\u87AE\u87B0\u87B1\u87B2\u87B4\u87B6\u87B7\u87B8\u87B9\u87BB\u87BC\u87BE\u87BF\u87C1", 4, "\u87C7\u87C8\u87C9\u87CC", 4, "\u87D4", 6, "\u87DC\u87DD\u87DE\u87DF\u87E1\u87E2\u87E3\u87E4\u87E6\u87E7\u87E8\u87E9\u87EB\u87EC\u87ED\u87EF", 9],
      ["cf80", "\u87FA\u87FB\u87FC\u87FD\u87FF\u8800\u8801\u8802\u8804", 5, "\u880B", 7, "\u8814\u8817\u8818\u8819\u881A\u881C", 4, "\u8823\u7A00\u606F\u5E0C\u6089\u819D\u5915\u60DC\u7184\u70EF\u6EAA\u6C50\u7280\u6A84\u88AD\u5E2D\u4E60\u5AB3\u559C\u94E3\u6D17\u7CFB\u9699\u620F\u7EC6\u778E\u867E\u5323\u971E\u8F96\u6687\u5CE1\u4FA0\u72ED\u4E0B\u53A6\u590F\u5413\u6380\u9528\u5148\u4ED9\u9C9C\u7EA4\u54B8\u8D24\u8854\u8237\u95F2\u6D8E\u5F26\u5ACC\u663E\u9669\u73B0\u732E\u53BF\u817A\u9985\u7FA1\u5BAA\u9677\u9650\u7EBF\u76F8\u53A2\u9576\u9999\u7BB1\u8944\u6E58\u4E61\u7FD4\u7965\u8BE6\u60F3\u54CD\u4EAB\u9879\u5DF7\u6A61\u50CF\u5411\u8C61\u8427\u785D\u9704\u524A\u54EE\u56A3\u9500\u6D88\u5BB5\u6DC6\u6653"],
      ["d040", "\u8824", 13, "\u8833", 5, "\u883A\u883B\u883D\u883E\u883F\u8841\u8842\u8843\u8846", 5, "\u884E", 5, "\u8855\u8856\u8858\u885A", 6, "\u8866\u8867\u886A\u886D\u886F\u8871\u8873\u8874\u8875\u8876\u8878\u8879\u887A"],
      ["d080", "\u887B\u887C\u8880\u8883\u8886\u8887\u8889\u888A\u888C\u888E\u888F\u8890\u8891\u8893\u8894\u8895\u8897", 4, "\u889D", 4, "\u88A3\u88A5", 5, "\u5C0F\u5B5D\u6821\u8096\u5578\u7B11\u6548\u6954\u4E9B\u6B47\u874E\u978B\u534F\u631F\u643A\u90AA\u659C\u80C1\u8C10\u5199\u68B0\u5378\u87F9\u61C8\u6CC4\u6CFB\u8C22\u5C51\u85AA\u82AF\u950C\u6B23\u8F9B\u65B0\u5FFB\u5FC3\u4FE1\u8845\u661F\u8165\u7329\u60FA\u5174\u5211\u578B\u5F62\u90A2\u884C\u9192\u5E78\u674F\u6027\u59D3\u5144\u51F6\u80F8\u5308\u6C79\u96C4\u718A\u4F11\u4FEE\u7F9E\u673D\u55C5\u9508\u79C0\u8896\u7EE3\u589F\u620C\u9700\u865A\u5618\u987B\u5F90\u8BB8\u84C4\u9157\u53D9\u65ED\u5E8F\u755C\u6064\u7D6E\u5A7F\u7EEA\u7EED\u8F69\u55A7\u5BA3\u60AC\u65CB\u7384"],
      ["d140", "\u88AC\u88AE\u88AF\u88B0\u88B2", 4, "\u88B8\u88B9\u88BA\u88BB\u88BD\u88BE\u88BF\u88C0\u88C3\u88C4\u88C7\u88C8\u88CA\u88CB\u88CC\u88CD\u88CF\u88D0\u88D1\u88D3\u88D6\u88D7\u88DA", 4, "\u88E0\u88E1\u88E6\u88E7\u88E9", 6, "\u88F2\u88F5\u88F6\u88F7\u88FA\u88FB\u88FD\u88FF\u8900\u8901\u8903", 5],
      ["d180", "\u8909\u890B", 4, "\u8911\u8914", 4, "\u891C", 4, "\u8922\u8923\u8924\u8926\u8927\u8928\u8929\u892C\u892D\u892E\u892F\u8931\u8932\u8933\u8935\u8937\u9009\u7663\u7729\u7EDA\u9774\u859B\u5B66\u7A74\u96EA\u8840\u52CB\u718F\u5FAA\u65EC\u8BE2\u5BFB\u9A6F\u5DE1\u6B89\u6C5B\u8BAD\u8BAF\u900A\u8FC5\u538B\u62BC\u9E26\u9E2D\u5440\u4E2B\u82BD\u7259\u869C\u5D16\u8859\u6DAF\u96C5\u54D1\u4E9A\u8BB6\u7109\u54BD\u9609\u70DF\u6DF9\u76D0\u4E25\u7814\u8712\u5CA9\u5EF6\u8A00\u989C\u960E\u708E\u6CBF\u5944\u63A9\u773C\u884D\u6F14\u8273\u5830\u71D5\u538C\u781A\u96C1\u5501\u5F66\u7130\u5BB4\u8C1A\u9A8C\u6B83\u592E\u9E2F\u79E7\u6768\u626C\u4F6F\u75A1\u7F8A\u6D0B\u9633\u6C27\u4EF0\u75D2\u517B\u6837\u6F3E\u9080\u8170\u5996\u7476"],
      ["d240", "\u8938", 8, "\u8942\u8943\u8945", 24, "\u8960", 5, "\u8967", 19, "\u897C"],
      ["d280", "\u897D\u897E\u8980\u8982\u8984\u8985\u8987", 26, "\u6447\u5C27\u9065\u7A91\u8C23\u59DA\u54AC\u8200\u836F\u8981\u8000\u6930\u564E\u8036\u7237\u91CE\u51B6\u4E5F\u9875\u6396\u4E1A\u53F6\u66F3\u814B\u591C\u6DB2\u4E00\u58F9\u533B\u63D6\u94F1\u4F9D\u4F0A\u8863\u9890\u5937\u9057\u79FB\u4EEA\u80F0\u7591\u6C82\u5B9C\u59E8\u5F5D\u6905\u8681\u501A\u5DF2\u4E59\u77E3\u4EE5\u827A\u6291\u6613\u9091\u5C79\u4EBF\u5F79\u81C6\u9038\u8084\u75AB\u4EA6\u88D4\u610F\u6BC5\u5FC6\u4E49\u76CA\u6EA2\u8BE3\u8BAE\u8C0A\u8BD1\u5F02\u7FFC\u7FCC\u7ECE\u8335\u836B\u56E0\u6BB7\u97F3\u9634\u59FB\u541F\u94F6\u6DEB\u5BC5\u996E\u5C39\u5F15\u9690"],
      ["d340", "\u89A2", 30, "\u89C3\u89CD\u89D3\u89D4\u89D5\u89D7\u89D8\u89D9\u89DB\u89DD\u89DF\u89E0\u89E1\u89E2\u89E4\u89E7\u89E8\u89E9\u89EA\u89EC\u89ED\u89EE\u89F0\u89F1\u89F2\u89F4", 6],
      ["d380", "\u89FB", 4, "\u8A01", 5, "\u8A08", 21, "\u5370\u82F1\u6A31\u5A74\u9E70\u5E94\u7F28\u83B9\u8424\u8425\u8367\u8747\u8FCE\u8D62\u76C8\u5F71\u9896\u786C\u6620\u54DF\u62E5\u4F63\u81C3\u75C8\u5EB8\u96CD\u8E0A\u86F9\u548F\u6CF3\u6D8C\u6C38\u607F\u52C7\u7528\u5E7D\u4F18\u60A0\u5FE7\u5C24\u7531\u90AE\u94C0\u72B9\u6CB9\u6E38\u9149\u6709\u53CB\u53F3\u4F51\u91C9\u8BF1\u53C8\u5E7C\u8FC2\u6DE4\u4E8E\u76C2\u6986\u865E\u611A\u8206\u4F59\u4FDE\u903E\u9C7C\u6109\u6E1D\u6E14\u9685\u4E88\u5A31\u96E8\u4E0E\u5C7F\u79B9\u5B87\u8BED\u7FBD\u7389\u57DF\u828B\u90C1\u5401\u9047\u55BB\u5CEA\u5FA1\u6108\u6B32\u72F1\u80B2\u8A89"],
      ["d440", "\u8A1E", 31, "\u8A3F", 8, "\u8A49", 21],
      ["d480", "\u8A5F", 25, "\u8A7A", 6, "\u6D74\u5BD3\u88D5\u9884\u8C6B\u9A6D\u9E33\u6E0A\u51A4\u5143\u57A3\u8881\u539F\u63F4\u8F95\u56ED\u5458\u5706\u733F\u6E90\u7F18\u8FDC\u82D1\u613F\u6028\u9662\u66F0\u7EA6\u8D8A\u8DC3\u94A5\u5CB3\u7CA4\u6708\u60A6\u9605\u8018\u4E91\u90E7\u5300\u9668\u5141\u8FD0\u8574\u915D\u6655\u97F5\u5B55\u531D\u7838\u6742\u683D\u54C9\u707E\u5BB0\u8F7D\u518D\u5728\u54B1\u6512\u6682\u8D5E\u8D43\u810F\u846C\u906D\u7CDF\u51FF\u85FB\u67A3\u65E9\u6FA1\u86A4\u8E81\u566A\u9020\u7682\u7076\u71E5\u8D23\u62E9\u5219\u6CFD\u8D3C\u600E\u589E\u618E\u66FE\u8D60\u624E\u55B3\u6E23\u672D\u8F67"],
      ["d540", "\u8A81", 7, "\u8A8B", 7, "\u8A94", 46],
      ["d580", "\u8AC3", 32, "\u94E1\u95F8\u7728\u6805\u69A8\u548B\u4E4D\u70B8\u8BC8\u6458\u658B\u5B85\u7A84\u503A\u5BE8\u77BB\u6BE1\u8A79\u7C98\u6CBE\u76CF\u65A9\u8F97\u5D2D\u5C55\u8638\u6808\u5360\u6218\u7AD9\u6E5B\u7EFD\u6A1F\u7AE0\u5F70\u6F33\u5F20\u638C\u6DA8\u6756\u4E08\u5E10\u8D26\u4ED7\u80C0\u7634\u969C\u62DB\u662D\u627E\u6CBC\u8D75\u7167\u7F69\u5146\u8087\u53EC\u906E\u6298\u54F2\u86F0\u8F99\u8005\u9517\u8517\u8FD9\u6D59\u73CD\u659F\u771F\u7504\u7827\u81FB\u8D1E\u9488\u4FA6\u6795\u75B9\u8BCA\u9707\u632F\u9547\u9635\u84B8\u6323\u7741\u5F81\u72F0\u4E89\u6014\u6574\u62EF\u6B63\u653F"],
      ["d640", "\u8AE4", 34, "\u8B08", 27],
      ["d680", "\u8B24\u8B25\u8B27", 30, "\u5E27\u75C7\u90D1\u8BC1\u829D\u679D\u652F\u5431\u8718\u77E5\u80A2\u8102\u6C41\u4E4B\u7EC7\u804C\u76F4\u690D\u6B96\u6267\u503C\u4F84\u5740\u6307\u6B62\u8DBE\u53EA\u65E8\u7EB8\u5FD7\u631A\u63B7\u81F3\u81F4\u7F6E\u5E1C\u5CD9\u5236\u667A\u79E9\u7A1A\u8D28\u7099\u75D4\u6EDE\u6CBB\u7A92\u4E2D\u76C5\u5FE0\u949F\u8877\u7EC8\u79CD\u80BF\u91CD\u4EF2\u4F17\u821F\u5468\u5DDE\u6D32\u8BCC\u7CA5\u8F74\u8098\u5E1A\u5492\u76B1\u5B99\u663C\u9AA4\u73E0\u682A\u86DB\u6731\u732A\u8BF8\u8BDB\u9010\u7AF9\u70DB\u716E\u62C4\u77A9\u5631\u4E3B\u8457\u67F1\u52A9\u86C0\u8D2E\u94F8\u7B51"],
      ["d740", "\u8B46", 31, "\u8B67", 4, "\u8B6D", 25],
      ["d780", "\u8B87", 24, "\u8BAC\u8BB1\u8BBB\u8BC7\u8BD0\u8BEA\u8C09\u8C1E\u4F4F\u6CE8\u795D\u9A7B\u6293\u722A\u62FD\u4E13\u7816\u8F6C\u64B0\u8D5A\u7BC6\u6869\u5E84\u88C5\u5986\u649E\u58EE\u72B6\u690E\u9525\u8FFD\u8D58\u5760\u7F00\u8C06\u51C6\u6349\u62D9\u5353\u684C\u7422\u8301\u914C\u5544\u7740\u707C\u6D4A\u5179\u54A8\u8D44\u59FF\u6ECB\u6DC4\u5B5C\u7D2B\u4ED4\u7C7D\u6ED3\u5B50\u81EA\u6E0D\u5B57\u9B03\u68D5\u8E2A\u5B97\u7EFC\u603B\u7EB5\u90B9\u8D70\u594F\u63CD\u79DF\u8DB3\u5352\u65CF\u7956\u8BC5\u963B\u7EC4\u94BB\u7E82\u5634\u9189\u6700\u7F6A\u5C0A\u9075\u6628\u5DE6\u4F50\u67DE\u505A\u4F5C\u5750\u5EA7"],
      ["d840", "\u8C38", 8, "\u8C42\u8C43\u8C44\u8C45\u8C48\u8C4A\u8C4B\u8C4D", 7, "\u8C56\u8C57\u8C58\u8C59\u8C5B", 5, "\u8C63", 6, "\u8C6C", 6, "\u8C74\u8C75\u8C76\u8C77\u8C7B", 6, "\u8C83\u8C84\u8C86\u8C87"],
      ["d880", "\u8C88\u8C8B\u8C8D", 6, "\u8C95\u8C96\u8C97\u8C99", 20, "\u4E8D\u4E0C\u5140\u4E10\u5EFF\u5345\u4E15\u4E98\u4E1E\u9B32\u5B6C\u5669\u4E28\u79BA\u4E3F\u5315\u4E47\u592D\u723B\u536E\u6C10\u56DF\u80E4\u9997\u6BD3\u777E\u9F17\u4E36\u4E9F\u9F10\u4E5C\u4E69\u4E93\u8288\u5B5B\u556C\u560F\u4EC4\u538D\u539D\u53A3\u53A5\u53AE\u9765\u8D5D\u531A\u53F5\u5326\u532E\u533E\u8D5C\u5366\u5363\u5202\u5208\u520E\u522D\u5233\u523F\u5240\u524C\u525E\u5261\u525C\u84AF\u527D\u5282\u5281\u5290\u5293\u5182\u7F54\u4EBB\u4EC3\u4EC9\u4EC2\u4EE8\u4EE1\u4EEB\u4EDE\u4F1B\u4EF3\u4F22\u4F64\u4EF5\u4F25\u4F27\u4F09\u4F2B\u4F5E\u4F67\u6538\u4F5A\u4F5D"],
      ["d940", "\u8CAE", 62],
      ["d980", "\u8CED", 32, "\u4F5F\u4F57\u4F32\u4F3D\u4F76\u4F74\u4F91\u4F89\u4F83\u4F8F\u4F7E\u4F7B\u4FAA\u4F7C\u4FAC\u4F94\u4FE6\u4FE8\u4FEA\u4FC5\u4FDA\u4FE3\u4FDC\u4FD1\u4FDF\u4FF8\u5029\u504C\u4FF3\u502C\u500F\u502E\u502D\u4FFE\u501C\u500C\u5025\u5028\u507E\u5043\u5055\u5048\u504E\u506C\u507B\u50A5\u50A7\u50A9\u50BA\u50D6\u5106\u50ED\u50EC\u50E6\u50EE\u5107\u510B\u4EDD\u6C3D\u4F58\u4F65\u4FCE\u9FA0\u6C46\u7C74\u516E\u5DFD\u9EC9\u9998\u5181\u5914\u52F9\u530D\u8A07\u5310\u51EB\u5919\u5155\u4EA0\u5156\u4EB3\u886E\u88A4\u4EB5\u8114\u88D2\u7980\u5B34\u8803\u7FB8\u51AB\u51B1\u51BD\u51BC"],
      ["da40", "\u8D0E", 14, "\u8D20\u8D51\u8D52\u8D57\u8D5F\u8D65\u8D68\u8D69\u8D6A\u8D6C\u8D6E\u8D6F\u8D71\u8D72\u8D78", 8, "\u8D82\u8D83\u8D86\u8D87\u8D88\u8D89\u8D8C", 4, "\u8D92\u8D93\u8D95", 9, "\u8DA0\u8DA1"],
      ["da80", "\u8DA2\u8DA4", 12, "\u8DB2\u8DB6\u8DB7\u8DB9\u8DBB\u8DBD\u8DC0\u8DC1\u8DC2\u8DC5\u8DC7\u8DC8\u8DC9\u8DCA\u8DCD\u8DD0\u8DD2\u8DD3\u8DD4\u51C7\u5196\u51A2\u51A5\u8BA0\u8BA6\u8BA7\u8BAA\u8BB4\u8BB5\u8BB7\u8BC2\u8BC3\u8BCB\u8BCF\u8BCE\u8BD2\u8BD3\u8BD4\u8BD6\u8BD8\u8BD9\u8BDC\u8BDF\u8BE0\u8BE4\u8BE8\u8BE9\u8BEE\u8BF0\u8BF3\u8BF6\u8BF9\u8BFC\u8BFF\u8C00\u8C02\u8C04\u8C07\u8C0C\u8C0F\u8C11\u8C12\u8C14\u8C15\u8C16\u8C19\u8C1B\u8C18\u8C1D\u8C1F\u8C20\u8C21\u8C25\u8C27\u8C2A\u8C2B\u8C2E\u8C2F\u8C32\u8C33\u8C35\u8C36\u5369\u537A\u961D\u9622\u9621\u9631\u962A\u963D\u963C\u9642\u9649\u9654\u965F\u9667\u966C\u9672\u9674\u9688\u968D\u9697\u96B0\u9097\u909B\u909D\u9099\u90AC\u90A1\u90B4\u90B3\u90B6\u90BA"],
      ["db40", "\u8DD5\u8DD8\u8DD9\u8DDC\u8DE0\u8DE1\u8DE2\u8DE5\u8DE6\u8DE7\u8DE9\u8DED\u8DEE\u8DF0\u8DF1\u8DF2\u8DF4\u8DF6\u8DFC\u8DFE", 6, "\u8E06\u8E07\u8E08\u8E0B\u8E0D\u8E0E\u8E10\u8E11\u8E12\u8E13\u8E15", 7, "\u8E20\u8E21\u8E24", 4, "\u8E2B\u8E2D\u8E30\u8E32\u8E33\u8E34\u8E36\u8E37\u8E38\u8E3B\u8E3C\u8E3E"],
      ["db80", "\u8E3F\u8E43\u8E45\u8E46\u8E4C", 4, "\u8E53", 5, "\u8E5A", 11, "\u8E67\u8E68\u8E6A\u8E6B\u8E6E\u8E71\u90B8\u90B0\u90CF\u90C5\u90BE\u90D0\u90C4\u90C7\u90D3\u90E6\u90E2\u90DC\u90D7\u90DB\u90EB\u90EF\u90FE\u9104\u9122\u911E\u9123\u9131\u912F\u9139\u9143\u9146\u520D\u5942\u52A2\u52AC\u52AD\u52BE\u54FF\u52D0\u52D6\u52F0\u53DF\u71EE\u77CD\u5EF4\u51F5\u51FC\u9B2F\u53B6\u5F01\u755A\u5DEF\u574C\u57A9\u57A1\u587E\u58BC\u58C5\u58D1\u5729\u572C\u572A\u5733\u5739\u572E\u572F\u575C\u573B\u5742\u5769\u5785\u576B\u5786\u577C\u577B\u5768\u576D\u5776\u5773\u57AD\u57A4\u578C\u57B2\u57CF\u57A7\u57B4\u5793\u57A0\u57D5\u57D8\u57DA\u57D9\u57D2\u57B8\u57F4\u57EF\u57F8\u57E4\u57DD"],
      ["dc40", "\u8E73\u8E75\u8E77", 4, "\u8E7D\u8E7E\u8E80\u8E82\u8E83\u8E84\u8E86\u8E88", 6, "\u8E91\u8E92\u8E93\u8E95", 6, "\u8E9D\u8E9F", 11, "\u8EAD\u8EAE\u8EB0\u8EB1\u8EB3", 6, "\u8EBB", 7],
      ["dc80", "\u8EC3", 10, "\u8ECF", 21, "\u580B\u580D\u57FD\u57ED\u5800\u581E\u5819\u5844\u5820\u5865\u586C\u5881\u5889\u589A\u5880\u99A8\u9F19\u61FF\u8279\u827D\u827F\u828F\u828A\u82A8\u8284\u828E\u8291\u8297\u8299\u82AB\u82B8\u82BE\u82B0\u82C8\u82CA\u82E3\u8298\u82B7\u82AE\u82CB\u82CC\u82C1\u82A9\u82B4\u82A1\u82AA\u829F\u82C4\u82CE\u82A4\u82E1\u8309\u82F7\u82E4\u830F\u8307\u82DC\u82F4\u82D2\u82D8\u830C\u82FB\u82D3\u8311\u831A\u8306\u8314\u8315\u82E0\u82D5\u831C\u8351\u835B\u835C\u8308\u8392\u833C\u8334\u8331\u839B\u835E\u832F\u834F\u8347\u8343\u835F\u8340\u8317\u8360\u832D\u833A\u8333\u8366\u8365"],
      ["dd40", "\u8EE5", 62],
      ["dd80", "\u8F24", 32, "\u8368\u831B\u8369\u836C\u836A\u836D\u836E\u83B0\u8378\u83B3\u83B4\u83A0\u83AA\u8393\u839C\u8385\u837C\u83B6\u83A9\u837D\u83B8\u837B\u8398\u839E\u83A8\u83BA\u83BC\u83C1\u8401\u83E5\u83D8\u5807\u8418\u840B\u83DD\u83FD\u83D6\u841C\u8438\u8411\u8406\u83D4\u83DF\u840F\u8403\u83F8\u83F9\u83EA\u83C5\u83C0\u8426\u83F0\u83E1\u845C\u8451\u845A\u8459\u8473\u8487\u8488\u847A\u8489\u8478\u843C\u8446\u8469\u8476\u848C\u848E\u8431\u846D\u84C1\u84CD\u84D0\u84E6\u84BD\u84D3\u84CA\u84BF\u84BA\u84E0\u84A1\u84B9\u84B4\u8497\u84E5\u84E3\u850C\u750D\u8538\u84F0\u8539\u851F\u853A"],
      ["de40", "\u8F45", 32, "\u8F6A\u8F80\u8F8C\u8F92\u8F9D\u8FA0\u8FA1\u8FA2\u8FA4\u8FA5\u8FA6\u8FA7\u8FAA\u8FAC\u8FAD\u8FAE\u8FAF\u8FB2\u8FB3\u8FB4\u8FB5\u8FB7\u8FB8\u8FBA\u8FBB\u8FBC\u8FBF\u8FC0\u8FC3\u8FC6"],
      ["de80", "\u8FC9", 4, "\u8FCF\u8FD2\u8FD6\u8FD7\u8FDA\u8FE0\u8FE1\u8FE3\u8FE7\u8FEC\u8FEF\u8FF1\u8FF2\u8FF4\u8FF5\u8FF6\u8FFA\u8FFB\u8FFC\u8FFE\u8FFF\u9007\u9008\u900C\u900E\u9013\u9015\u9018\u8556\u853B\u84FF\u84FC\u8559\u8548\u8568\u8564\u855E\u857A\u77A2\u8543\u8572\u857B\u85A4\u85A8\u8587\u858F\u8579\u85AE\u859C\u8585\u85B9\u85B7\u85B0\u85D3\u85C1\u85DC\u85FF\u8627\u8605\u8629\u8616\u863C\u5EFE\u5F08\u593C\u5941\u8037\u5955\u595A\u5958\u530F\u5C22\u5C25\u5C2C\u5C34\u624C\u626A\u629F\u62BB\u62CA\u62DA\u62D7\u62EE\u6322\u62F6\u6339\u634B\u6343\u63AD\u63F6\u6371\u637A\u638E\u63B4\u636D\u63AC\u638A\u6369\u63AE\u63BC\u63F2\u63F8\u63E0\u63FF\u63C4\u63DE\u63CE\u6452\u63C6\u63BE\u6445\u6441\u640B\u641B\u6420\u640C\u6426\u6421\u645E\u6484\u646D\u6496"],
      ["df40", "\u9019\u901C\u9023\u9024\u9025\u9027", 5, "\u9030", 4, "\u9037\u9039\u903A\u903D\u903F\u9040\u9043\u9045\u9046\u9048", 4, "\u904E\u9054\u9055\u9056\u9059\u905A\u905C", 5, "\u9064\u9066\u9067\u9069\u906A\u906B\u906C\u906F", 4, "\u9076", 6, "\u907E\u9081"],
      ["df80", "\u9084\u9085\u9086\u9087\u9089\u908A\u908C", 4, "\u9092\u9094\u9096\u9098\u909A\u909C\u909E\u909F\u90A0\u90A4\u90A5\u90A7\u90A8\u90A9\u90AB\u90AD\u90B2\u90B7\u90BC\u90BD\u90BF\u90C0\u647A\u64B7\u64B8\u6499\u64BA\u64C0\u64D0\u64D7\u64E4\u64E2\u6509\u6525\u652E\u5F0B\u5FD2\u7519\u5F11\u535F\u53F1\u53FD\u53E9\u53E8\u53FB\u5412\u5416\u5406\u544B\u5452\u5453\u5454\u5456\u5443\u5421\u5457\u5459\u5423\u5432\u5482\u5494\u5477\u5471\u5464\u549A\u549B\u5484\u5476\u5466\u549D\u54D0\u54AD\u54C2\u54B4\u54D2\u54A7\u54A6\u54D3\u54D4\u5472\u54A3\u54D5\u54BB\u54BF\u54CC\u54D9\u54DA\u54DC\u54A9\u54AA\u54A4\u54DD\u54CF\u54DE\u551B\u54E7\u5520\u54FD\u5514\u54F3\u5522\u5523\u550F\u5511\u5527\u552A\u5567\u558F\u55B5\u5549\u556D\u5541\u5555\u553F\u5550\u553C"],
      ["e040", "\u90C2\u90C3\u90C6\u90C8\u90C9\u90CB\u90CC\u90CD\u90D2\u90D4\u90D5\u90D6\u90D8\u90D9\u90DA\u90DE\u90DF\u90E0\u90E3\u90E4\u90E5\u90E9\u90EA\u90EC\u90EE\u90F0\u90F1\u90F2\u90F3\u90F5\u90F6\u90F7\u90F9\u90FA\u90FB\u90FC\u90FF\u9100\u9101\u9103\u9105", 19, "\u911A\u911B\u911C"],
      ["e080", "\u911D\u911F\u9120\u9121\u9124", 10, "\u9130\u9132", 6, "\u913A", 8, "\u9144\u5537\u5556\u5575\u5576\u5577\u5533\u5530\u555C\u558B\u55D2\u5583\u55B1\u55B9\u5588\u5581\u559F\u557E\u55D6\u5591\u557B\u55DF\u55BD\u55BE\u5594\u5599\u55EA\u55F7\u55C9\u561F\u55D1\u55EB\u55EC\u55D4\u55E6\u55DD\u55C4\u55EF\u55E5\u55F2\u55F3\u55CC\u55CD\u55E8\u55F5\u55E4\u8F94\u561E\u5608\u560C\u5601\u5624\u5623\u55FE\u5600\u5627\u562D\u5658\u5639\u5657\u562C\u564D\u5662\u5659\u565C\u564C\u5654\u5686\u5664\u5671\u566B\u567B\u567C\u5685\u5693\u56AF\u56D4\u56D7\u56DD\u56E1\u56F5\u56EB\u56F9\u56FF\u5704\u570A\u5709\u571C\u5E0F\u5E19\u5E14\u5E11\u5E31\u5E3B\u5E3C"],
      ["e140", "\u9145\u9147\u9148\u9151\u9153\u9154\u9155\u9156\u9158\u9159\u915B\u915C\u915F\u9160\u9166\u9167\u9168\u916B\u916D\u9173\u917A\u917B\u917C\u9180", 4, "\u9186\u9188\u918A\u918E\u918F\u9193", 6, "\u919C", 5, "\u91A4", 5, "\u91AB\u91AC\u91B0\u91B1\u91B2\u91B3\u91B6\u91B7\u91B8\u91B9\u91BB"],
      ["e180", "\u91BC", 10, "\u91C8\u91CB\u91D0\u91D2", 9, "\u91DD", 8, "\u5E37\u5E44\u5E54\u5E5B\u5E5E\u5E61\u5C8C\u5C7A\u5C8D\u5C90\u5C96\u5C88\u5C98\u5C99\u5C91\u5C9A\u5C9C\u5CB5\u5CA2\u5CBD\u5CAC\u5CAB\u5CB1\u5CA3\u5CC1\u5CB7\u5CC4\u5CD2\u5CE4\u5CCB\u5CE5\u5D02\u5D03\u5D27\u5D26\u5D2E\u5D24\u5D1E\u5D06\u5D1B\u5D58\u5D3E\u5D34\u5D3D\u5D6C\u5D5B\u5D6F\u5D5D\u5D6B\u5D4B\u5D4A\u5D69\u5D74\u5D82\u5D99\u5D9D\u8C73\u5DB7\u5DC5\u5F73\u5F77\u5F82\u5F87\u5F89\u5F8C\u5F95\u5F99\u5F9C\u5FA8\u5FAD\u5FB5\u5FBC\u8862\u5F61\u72AD\u72B0\u72B4\u72B7\u72B8\u72C3\u72C1\u72CE\u72CD\u72D2\u72E8\u72EF\u72E9\u72F2\u72F4\u72F7\u7301\u72F3\u7303\u72FA"],
      ["e240", "\u91E6", 62],
      ["e280", "\u9225", 32, "\u72FB\u7317\u7313\u7321\u730A\u731E\u731D\u7315\u7322\u7339\u7325\u732C\u7338\u7331\u7350\u734D\u7357\u7360\u736C\u736F\u737E\u821B\u5925\u98E7\u5924\u5902\u9963\u9967", 5, "\u9974\u9977\u997D\u9980\u9984\u9987\u998A\u998D\u9990\u9991\u9993\u9994\u9995\u5E80\u5E91\u5E8B\u5E96\u5EA5\u5EA0\u5EB9\u5EB5\u5EBE\u5EB3\u8D53\u5ED2\u5ED1\u5EDB\u5EE8\u5EEA\u81BA\u5FC4\u5FC9\u5FD6\u5FCF\u6003\u5FEE\u6004\u5FE1\u5FE4\u5FFE\u6005\u6006\u5FEA\u5FED\u5FF8\u6019\u6035\u6026\u601B\u600F\u600D\u6029\u602B\u600A\u603F\u6021\u6078\u6079\u607B\u607A\u6042"],
      ["e340", "\u9246", 45, "\u9275", 16],
      ["e380", "\u9286", 7, "\u928F", 24, "\u606A\u607D\u6096\u609A\u60AD\u609D\u6083\u6092\u608C\u609B\u60EC\u60BB\u60B1\u60DD\u60D8\u60C6\u60DA\u60B4\u6120\u6126\u6115\u6123\u60F4\u6100\u610E\u612B\u614A\u6175\u61AC\u6194\u61A7\u61B7\u61D4\u61F5\u5FDD\u96B3\u95E9\u95EB\u95F1\u95F3\u95F5\u95F6\u95FC\u95FE\u9603\u9604\u9606\u9608\u960A\u960B\u960C\u960D\u960F\u9612\u9615\u9616\u9617\u9619\u961A\u4E2C\u723F\u6215\u6C35\u6C54\u6C5C\u6C4A\u6CA3\u6C85\u6C90\u6C94\u6C8C\u6C68\u6C69\u6C74\u6C76\u6C86\u6CA9\u6CD0\u6CD4\u6CAD\u6CF7\u6CF8\u6CF1\u6CD7\u6CB2\u6CE0\u6CD6\u6CFA\u6CEB\u6CEE\u6CB1\u6CD3\u6CEF\u6CFE"],
      ["e440", "\u92A8", 5, "\u92AF", 24, "\u92C9", 31],
      ["e480", "\u92E9", 32, "\u6D39\u6D27\u6D0C\u6D43\u6D48\u6D07\u6D04\u6D19\u6D0E\u6D2B\u6D4D\u6D2E\u6D35\u6D1A\u6D4F\u6D52\u6D54\u6D33\u6D91\u6D6F\u6D9E\u6DA0\u6D5E\u6D93\u6D94\u6D5C\u6D60\u6D7C\u6D63\u6E1A\u6DC7\u6DC5\u6DDE\u6E0E\u6DBF\u6DE0\u6E11\u6DE6\u6DDD\u6DD9\u6E16\u6DAB\u6E0C\u6DAE\u6E2B\u6E6E\u6E4E\u6E6B\u6EB2\u6E5F\u6E86\u6E53\u6E54\u6E32\u6E25\u6E44\u6EDF\u6EB1\u6E98\u6EE0\u6F2D\u6EE2\u6EA5\u6EA7\u6EBD\u6EBB\u6EB7\u6ED7\u6EB4\u6ECF\u6E8F\u6EC2\u6E9F\u6F62\u6F46\u6F47\u6F24\u6F15\u6EF9\u6F2F\u6F36\u6F4B\u6F74\u6F2A\u6F09\u6F29\u6F89\u6F8D\u6F8C\u6F78\u6F72\u6F7C\u6F7A\u6FD1"],
      ["e540", "\u930A", 51, "\u933F", 10],
      ["e580", "\u934A", 31, "\u936B\u6FC9\u6FA7\u6FB9\u6FB6\u6FC2\u6FE1\u6FEE\u6FDE\u6FE0\u6FEF\u701A\u7023\u701B\u7039\u7035\u704F\u705E\u5B80\u5B84\u5B95\u5B93\u5BA5\u5BB8\u752F\u9A9E\u6434\u5BE4\u5BEE\u8930\u5BF0\u8E47\u8B07\u8FB6\u8FD3\u8FD5\u8FE5\u8FEE\u8FE4\u8FE9\u8FE6\u8FF3\u8FE8\u9005\u9004\u900B\u9026\u9011\u900D\u9016\u9021\u9035\u9036\u902D\u902F\u9044\u9051\u9052\u9050\u9068\u9058\u9062\u905B\u66B9\u9074\u907D\u9082\u9088\u9083\u908B\u5F50\u5F57\u5F56\u5F58\u5C3B\u54AB\u5C50\u5C59\u5B71\u5C63\u5C66\u7FBC\u5F2A\u5F29\u5F2D\u8274\u5F3C\u9B3B\u5C6E\u5981\u5983\u598D\u59A9\u59AA\u59A3"],
      ["e640", "\u936C", 34, "\u9390", 27],
      ["e680", "\u93AC", 29, "\u93CB\u93CC\u93CD\u5997\u59CA\u59AB\u599E\u59A4\u59D2\u59B2\u59AF\u59D7\u59BE\u5A05\u5A06\u59DD\u5A08\u59E3\u59D8\u59F9\u5A0C\u5A09\u5A32\u5A34\u5A11\u5A23\u5A13\u5A40\u5A67\u5A4A\u5A55\u5A3C\u5A62\u5A75\u80EC\u5AAA\u5A9B\u5A77\u5A7A\u5ABE\u5AEB\u5AB2\u5AD2\u5AD4\u5AB8\u5AE0\u5AE3\u5AF1\u5AD6\u5AE6\u5AD8\u5ADC\u5B09\u5B17\u5B16\u5B32\u5B37\u5B40\u5C15\u5C1C\u5B5A\u5B65\u5B73\u5B51\u5B53\u5B62\u9A75\u9A77\u9A78\u9A7A\u9A7F\u9A7D\u9A80\u9A81\u9A85\u9A88\u9A8A\u9A90\u9A92\u9A93\u9A96\u9A98\u9A9B\u9A9C\u9A9D\u9A9F\u9AA0\u9AA2\u9AA3\u9AA5\u9AA7\u7E9F\u7EA1\u7EA3\u7EA5\u7EA8\u7EA9"],
      ["e740", "\u93CE", 7, "\u93D7", 54],
      ["e780", "\u940E", 32, "\u7EAD\u7EB0\u7EBE\u7EC0\u7EC1\u7EC2\u7EC9\u7ECB\u7ECC\u7ED0\u7ED4\u7ED7\u7EDB\u7EE0\u7EE1\u7EE8\u7EEB\u7EEE\u7EEF\u7EF1\u7EF2\u7F0D\u7EF6\u7EFA\u7EFB\u7EFE\u7F01\u7F02\u7F03\u7F07\u7F08\u7F0B\u7F0C\u7F0F\u7F11\u7F12\u7F17\u7F19\u7F1C\u7F1B\u7F1F\u7F21", 6, "\u7F2A\u7F2B\u7F2C\u7F2D\u7F2F", 4, "\u7F35\u5E7A\u757F\u5DDB\u753E\u9095\u738E\u7391\u73AE\u73A2\u739F\u73CF\u73C2\u73D1\u73B7\u73B3\u73C0\u73C9\u73C8\u73E5\u73D9\u987C\u740A\u73E9\u73E7\u73DE\u73BA\u73F2\u740F\u742A\u745B\u7426\u7425\u7428\u7430\u742E\u742C"],
      ["e840", "\u942F", 14, "\u943F", 43, "\u946C\u946D\u946E\u946F"],
      ["e880", "\u9470", 20, "\u9491\u9496\u9498\u94C7\u94CF\u94D3\u94D4\u94DA\u94E6\u94FB\u951C\u9520\u741B\u741A\u7441\u745C\u7457\u7455\u7459\u7477\u746D\u747E\u749C\u748E\u7480\u7481\u7487\u748B\u749E\u74A8\u74A9\u7490\u74A7\u74D2\u74BA\u97EA\u97EB\u97EC\u674C\u6753\u675E\u6748\u6769\u67A5\u6787\u676A\u6773\u6798\u67A7\u6775\u67A8\u679E\u67AD\u678B\u6777\u677C\u67F0\u6809\u67D8\u680A\u67E9\u67B0\u680C\u67D9\u67B5\u67DA\u67B3\u67DD\u6800\u67C3\u67B8\u67E2\u680E\u67C1\u67FD\u6832\u6833\u6860\u6861\u684E\u6862\u6844\u6864\u6883\u681D\u6855\u6866\u6841\u6867\u6840\u683E\u684A\u6849\u6829\u68B5\u688F\u6874\u6877\u6893\u686B\u68C2\u696E\u68FC\u691F\u6920\u68F9"],
      ["e940", "\u9527\u9533\u953D\u9543\u9548\u954B\u9555\u955A\u9560\u956E\u9574\u9575\u9577", 7, "\u9580", 42],
      ["e980", "\u95AB", 32, "\u6924\u68F0\u690B\u6901\u6957\u68E3\u6910\u6971\u6939\u6960\u6942\u695D\u6984\u696B\u6980\u6998\u6978\u6934\u69CC\u6987\u6988\u69CE\u6989\u6966\u6963\u6979\u699B\u69A7\u69BB\u69AB\u69AD\u69D4\u69B1\u69C1\u69CA\u69DF\u6995\u69E0\u698D\u69FF\u6A2F\u69ED\u6A17\u6A18\u6A65\u69F2\u6A44\u6A3E\u6AA0\u6A50\u6A5B\u6A35\u6A8E\u6A79\u6A3D\u6A28\u6A58\u6A7C\u6A91\u6A90\u6AA9\u6A97\u6AAB\u7337\u7352\u6B81\u6B82\u6B87\u6B84\u6B92\u6B93\u6B8D\u6B9A\u6B9B\u6BA1\u6BAA\u8F6B\u8F6D\u8F71\u8F72\u8F73\u8F75\u8F76\u8F78\u8F77\u8F79\u8F7A\u8F7C\u8F7E\u8F81\u8F82\u8F84\u8F87\u8F8B"],
      ["ea40", "\u95CC", 27, "\u95EC\u95FF\u9607\u9613\u9618\u961B\u961E\u9620\u9623", 6, "\u962B\u962C\u962D\u962F\u9630\u9637\u9638\u9639\u963A\u963E\u9641\u9643\u964A\u964E\u964F\u9651\u9652\u9653\u9656\u9657"],
      ["ea80", "\u9658\u9659\u965A\u965C\u965D\u965E\u9660\u9663\u9665\u9666\u966B\u966D", 4, "\u9673\u9678", 12, "\u9687\u9689\u968A\u8F8D\u8F8E\u8F8F\u8F98\u8F9A\u8ECE\u620B\u6217\u621B\u621F\u6222\u6221\u6225\u6224\u622C\u81E7\u74EF\u74F4\u74FF\u750F\u7511\u7513\u6534\u65EE\u65EF\u65F0\u660A\u6619\u6772\u6603\u6615\u6600\u7085\u66F7\u661D\u6634\u6631\u6636\u6635\u8006\u665F\u6654\u6641\u664F\u6656\u6661\u6657\u6677\u6684\u668C\u66A7\u669D\u66BE\u66DB\u66DC\u66E6\u66E9\u8D32\u8D33\u8D36\u8D3B\u8D3D\u8D40\u8D45\u8D46\u8D48\u8D49\u8D47\u8D4D\u8D55\u8D59\u89C7\u89CA\u89CB\u89CC\u89CE\u89CF\u89D0\u89D1\u726E\u729F\u725D\u7266\u726F\u727E\u727F\u7284\u728B\u728D\u728F\u7292\u6308\u6332\u63B0"],
      ["eb40", "\u968C\u968E\u9691\u9692\u9693\u9695\u9696\u969A\u969B\u969D", 9, "\u96A8", 7, "\u96B1\u96B2\u96B4\u96B5\u96B7\u96B8\u96BA\u96BB\u96BF\u96C2\u96C3\u96C8\u96CA\u96CB\u96D0\u96D1\u96D3\u96D4\u96D6", 9, "\u96E1", 6, "\u96EB"],
      ["eb80", "\u96EC\u96ED\u96EE\u96F0\u96F1\u96F2\u96F4\u96F5\u96F8\u96FA\u96FB\u96FC\u96FD\u96FF\u9702\u9703\u9705\u970A\u970B\u970C\u9710\u9711\u9712\u9714\u9715\u9717", 4, "\u971D\u971F\u9720\u643F\u64D8\u8004\u6BEA\u6BF3\u6BFD\u6BF5\u6BF9\u6C05\u6C07\u6C06\u6C0D\u6C15\u6C18\u6C19\u6C1A\u6C21\u6C29\u6C24\u6C2A\u6C32\u6535\u6555\u656B\u724D\u7252\u7256\u7230\u8662\u5216\u809F\u809C\u8093\u80BC\u670A\u80BD\u80B1\u80AB\u80AD\u80B4\u80B7\u80E7\u80E8\u80E9\u80EA\u80DB\u80C2\u80C4\u80D9\u80CD\u80D7\u6710\u80DD\u80EB\u80F1\u80F4\u80ED\u810D\u810E\u80F2\u80FC\u6715\u8112\u8C5A\u8136\u811E\u812C\u8118\u8132\u8148\u814C\u8153\u8174\u8159\u815A\u8171\u8160\u8169\u817C\u817D\u816D\u8167\u584D\u5AB5\u8188\u8182\u8191\u6ED5\u81A3\u81AA\u81CC\u6726\u81CA\u81BB"],
      ["ec40", "\u9721", 8, "\u972B\u972C\u972E\u972F\u9731\u9733", 4, "\u973A\u973B\u973C\u973D\u973F", 18, "\u9754\u9755\u9757\u9758\u975A\u975C\u975D\u975F\u9763\u9764\u9766\u9767\u9768\u976A", 7],
      ["ec80", "\u9772\u9775\u9777", 4, "\u977D", 7, "\u9786", 4, "\u978C\u978E\u978F\u9790\u9793\u9795\u9796\u9797\u9799", 4, "\u81C1\u81A6\u6B24\u6B37\u6B39\u6B43\u6B46\u6B59\u98D1\u98D2\u98D3\u98D5\u98D9\u98DA\u6BB3\u5F40\u6BC2\u89F3\u6590\u9F51\u6593\u65BC\u65C6\u65C4\u65C3\u65CC\u65CE\u65D2\u65D6\u7080\u709C\u7096\u709D\u70BB\u70C0\u70B7\u70AB\u70B1\u70E8\u70CA\u7110\u7113\u7116\u712F\u7131\u7173\u715C\u7168\u7145\u7172\u714A\u7178\u717A\u7198\u71B3\u71B5\u71A8\u71A0\u71E0\u71D4\u71E7\u71F9\u721D\u7228\u706C\u7118\u7166\u71B9\u623E\u623D\u6243\u6248\u6249\u793B\u7940\u7946\u7949\u795B\u795C\u7953\u795A\u7962\u7957\u7960\u796F\u7967\u797A\u7985\u798A\u799A\u79A7\u79B3\u5FD1\u5FD0"],
      ["ed40", "\u979E\u979F\u97A1\u97A2\u97A4", 6, "\u97AC\u97AE\u97B0\u97B1\u97B3\u97B5", 46],
      ["ed80", "\u97E4\u97E5\u97E8\u97EE", 4, "\u97F4\u97F7", 23, "\u603C\u605D\u605A\u6067\u6041\u6059\u6063\u60AB\u6106\u610D\u615D\u61A9\u619D\u61CB\u61D1\u6206\u8080\u807F\u6C93\u6CF6\u6DFC\u77F6\u77F8\u7800\u7809\u7817\u7818\u7811\u65AB\u782D\u781C\u781D\u7839\u783A\u783B\u781F\u783C\u7825\u782C\u7823\u7829\u784E\u786D\u7856\u7857\u7826\u7850\u7847\u784C\u786A\u789B\u7893\u789A\u7887\u789C\u78A1\u78A3\u78B2\u78B9\u78A5\u78D4\u78D9\u78C9\u78EC\u78F2\u7905\u78F4\u7913\u7924\u791E\u7934\u9F9B\u9EF9\u9EFB\u9EFC\u76F1\u7704\u770D\u76F9\u7707\u7708\u771A\u7722\u7719\u772D\u7726\u7735\u7738\u7750\u7751\u7747\u7743\u775A\u7768"],
      ["ee40", "\u980F", 62],
      ["ee80", "\u984E", 32, "\u7762\u7765\u777F\u778D\u777D\u7780\u778C\u7791\u779F\u77A0\u77B0\u77B5\u77BD\u753A\u7540\u754E\u754B\u7548\u755B\u7572\u7579\u7583\u7F58\u7F61\u7F5F\u8A48\u7F68\u7F74\u7F71\u7F79\u7F81\u7F7E\u76CD\u76E5\u8832\u9485\u9486\u9487\u948B\u948A\u948C\u948D\u948F\u9490\u9494\u9497\u9495\u949A\u949B\u949C\u94A3\u94A4\u94AB\u94AA\u94AD\u94AC\u94AF\u94B0\u94B2\u94B4\u94B6", 4, "\u94BC\u94BD\u94BF\u94C4\u94C8", 6, "\u94D0\u94D1\u94D2\u94D5\u94D6\u94D7\u94D9\u94D8\u94DB\u94DE\u94DF\u94E0\u94E2\u94E4\u94E5\u94E7\u94E8\u94EA"],
      ["ef40", "\u986F", 5, "\u988B\u988E\u9892\u9895\u9899\u98A3\u98A8", 37, "\u98CF\u98D0\u98D4\u98D6\u98D7\u98DB\u98DC\u98DD\u98E0", 4],
      ["ef80", "\u98E5\u98E6\u98E9", 30, "\u94E9\u94EB\u94EE\u94EF\u94F3\u94F4\u94F5\u94F7\u94F9\u94FC\u94FD\u94FF\u9503\u9502\u9506\u9507\u9509\u950A\u950D\u950E\u950F\u9512", 4, "\u9518\u951B\u951D\u951E\u951F\u9522\u952A\u952B\u9529\u952C\u9531\u9532\u9534\u9536\u9537\u9538\u953C\u953E\u953F\u9542\u9535\u9544\u9545\u9546\u9549\u954C\u954E\u954F\u9552\u9553\u9554\u9556\u9557\u9558\u9559\u955B\u955E\u955F\u955D\u9561\u9562\u9564", 8, "\u956F\u9571\u9572\u9573\u953A\u77E7\u77EC\u96C9\u79D5\u79ED\u79E3\u79EB\u7A06\u5D47\u7A03\u7A02\u7A1E\u7A14"],
      ["f040", "\u9908", 4, "\u990E\u990F\u9911", 28, "\u992F", 26],
      ["f080", "\u994A", 9, "\u9956", 12, "\u9964\u9966\u9973\u9978\u9979\u997B\u997E\u9982\u9983\u9989\u7A39\u7A37\u7A51\u9ECF\u99A5\u7A70\u7688\u768E\u7693\u7699\u76A4\u74DE\u74E0\u752C\u9E20\u9E22\u9E28", 4, "\u9E32\u9E31\u9E36\u9E38\u9E37\u9E39\u9E3A\u9E3E\u9E41\u9E42\u9E44\u9E46\u9E47\u9E48\u9E49\u9E4B\u9E4C\u9E4E\u9E51\u9E55\u9E57\u9E5A\u9E5B\u9E5C\u9E5E\u9E63\u9E66", 6, "\u9E71\u9E6D\u9E73\u7592\u7594\u7596\u75A0\u759D\u75AC\u75A3\u75B3\u75B4\u75B8\u75C4\u75B1\u75B0\u75C3\u75C2\u75D6\u75CD\u75E3\u75E8\u75E6\u75E4\u75EB\u75E7\u7603\u75F1\u75FC\u75FF\u7610\u7600\u7605\u760C\u7617\u760A\u7625\u7618\u7615\u7619"],
      ["f140", "\u998C\u998E\u999A", 10, "\u99A6\u99A7\u99A9", 47],
      ["f180", "\u99D9", 32, "\u761B\u763C\u7622\u7620\u7640\u762D\u7630\u763F\u7635\u7643\u763E\u7633\u764D\u765E\u7654\u765C\u7656\u766B\u766F\u7FCA\u7AE6\u7A78\u7A79\u7A80\u7A86\u7A88\u7A95\u7AA6\u7AA0\u7AAC\u7AA8\u7AAD\u7AB3\u8864\u8869\u8872\u887D\u887F\u8882\u88A2\u88C6\u88B7\u88BC\u88C9\u88E2\u88CE\u88E3\u88E5\u88F1\u891A\u88FC\u88E8\u88FE\u88F0\u8921\u8919\u8913\u891B\u890A\u8934\u892B\u8936\u8941\u8966\u897B\u758B\u80E5\u76B2\u76B4\u77DC\u8012\u8014\u8016\u801C\u8020\u8022\u8025\u8026\u8027\u8029\u8028\u8031\u800B\u8035\u8043\u8046\u804D\u8052\u8069\u8071\u8983\u9878\u9880\u9883"],
      ["f240", "\u99FA", 62],
      ["f280", "\u9A39", 32, "\u9889\u988C\u988D\u988F\u9894\u989A\u989B\u989E\u989F\u98A1\u98A2\u98A5\u98A6\u864D\u8654\u866C\u866E\u867F\u867A\u867C\u867B\u86A8\u868D\u868B\u86AC\u869D\u86A7\u86A3\u86AA\u8693\u86A9\u86B6\u86C4\u86B5\u86CE\u86B0\u86BA\u86B1\u86AF\u86C9\u86CF\u86B4\u86E9\u86F1\u86F2\u86ED\u86F3\u86D0\u8713\u86DE\u86F4\u86DF\u86D8\u86D1\u8703\u8707\u86F8\u8708\u870A\u870D\u8709\u8723\u873B\u871E\u8725\u872E\u871A\u873E\u8748\u8734\u8731\u8729\u8737\u873F\u8782\u8722\u877D\u877E\u877B\u8760\u8770\u874C\u876E\u878B\u8753\u8763\u877C\u8764\u8759\u8765\u8793\u87AF\u87A8\u87D2"],
      ["f340", "\u9A5A", 17, "\u9A72\u9A83\u9A89\u9A8D\u9A8E\u9A94\u9A95\u9A99\u9AA6\u9AA9", 6, "\u9AB2\u9AB3\u9AB4\u9AB5\u9AB9\u9ABB\u9ABD\u9ABE\u9ABF\u9AC3\u9AC4\u9AC6", 4, "\u9ACD\u9ACE\u9ACF\u9AD0\u9AD2\u9AD4\u9AD5\u9AD6\u9AD7\u9AD9\u9ADA\u9ADB\u9ADC"],
      ["f380", "\u9ADD\u9ADE\u9AE0\u9AE2\u9AE3\u9AE4\u9AE5\u9AE7\u9AE8\u9AE9\u9AEA\u9AEC\u9AEE\u9AF0", 8, "\u9AFA\u9AFC", 6, "\u9B04\u9B05\u9B06\u87C6\u8788\u8785\u87AD\u8797\u8783\u87AB\u87E5\u87AC\u87B5\u87B3\u87CB\u87D3\u87BD\u87D1\u87C0\u87CA\u87DB\u87EA\u87E0\u87EE\u8816\u8813\u87FE\u880A\u881B\u8821\u8839\u883C\u7F36\u7F42\u7F44\u7F45\u8210\u7AFA\u7AFD\u7B08\u7B03\u7B04\u7B15\u7B0A\u7B2B\u7B0F\u7B47\u7B38\u7B2A\u7B19\u7B2E\u7B31\u7B20\u7B25\u7B24\u7B33\u7B3E\u7B1E\u7B58\u7B5A\u7B45\u7B75\u7B4C\u7B5D\u7B60\u7B6E\u7B7B\u7B62\u7B72\u7B71\u7B90\u7BA6\u7BA7\u7BB8\u7BAC\u7B9D\u7BA8\u7B85\u7BAA\u7B9C\u7BA2\u7BAB\u7BB4\u7BD1\u7BC1\u7BCC\u7BDD\u7BDA\u7BE5\u7BE6\u7BEA\u7C0C\u7BFE\u7BFC\u7C0F\u7C16\u7C0B"],
      ["f440", "\u9B07\u9B09", 5, "\u9B10\u9B11\u9B12\u9B14", 10, "\u9B20\u9B21\u9B22\u9B24", 10, "\u9B30\u9B31\u9B33", 7, "\u9B3D\u9B3E\u9B3F\u9B40\u9B46\u9B4A\u9B4B\u9B4C\u9B4E\u9B50\u9B52\u9B53\u9B55", 5],
      ["f480", "\u9B5B", 32, "\u7C1F\u7C2A\u7C26\u7C38\u7C41\u7C40\u81FE\u8201\u8202\u8204\u81EC\u8844\u8221\u8222\u8223\u822D\u822F\u8228\u822B\u8238\u823B\u8233\u8234\u823E\u8244\u8249\u824B\u824F\u825A\u825F\u8268\u887E\u8885\u8888\u88D8\u88DF\u895E\u7F9D\u7F9F\u7FA7\u7FAF\u7FB0\u7FB2\u7C7C\u6549\u7C91\u7C9D\u7C9C\u7C9E\u7CA2\u7CB2\u7CBC\u7CBD\u7CC1\u7CC7\u7CCC\u7CCD\u7CC8\u7CC5\u7CD7\u7CE8\u826E\u66A8\u7FBF\u7FCE\u7FD5\u7FE5\u7FE1\u7FE6\u7FE9\u7FEE\u7FF3\u7CF8\u7D77\u7DA6\u7DAE\u7E47\u7E9B\u9EB8\u9EB4\u8D73\u8D84\u8D94\u8D91\u8DB1\u8D67\u8D6D\u8C47\u8C49\u914A\u9150\u914E\u914F\u9164"],
      ["f540", "\u9B7C", 62],
      ["f580", "\u9BBB", 32, "\u9162\u9161\u9170\u9169\u916F\u917D\u917E\u9172\u9174\u9179\u918C\u9185\u9190\u918D\u9191\u91A2\u91A3\u91AA\u91AD\u91AE\u91AF\u91B5\u91B4\u91BA\u8C55\u9E7E\u8DB8\u8DEB\u8E05\u8E59\u8E69\u8DB5\u8DBF\u8DBC\u8DBA\u8DC4\u8DD6\u8DD7\u8DDA\u8DDE\u8DCE\u8DCF\u8DDB\u8DC6\u8DEC\u8DF7\u8DF8\u8DE3\u8DF9\u8DFB\u8DE4\u8E09\u8DFD\u8E14\u8E1D\u8E1F\u8E2C\u8E2E\u8E23\u8E2F\u8E3A\u8E40\u8E39\u8E35\u8E3D\u8E31\u8E49\u8E41\u8E42\u8E51\u8E52\u8E4A\u8E70\u8E76\u8E7C\u8E6F\u8E74\u8E85\u8E8F\u8E94\u8E90\u8E9C\u8E9E\u8C78\u8C82\u8C8A\u8C85\u8C98\u8C94\u659B\u89D6\u89DE\u89DA\u89DC"],
      ["f640", "\u9BDC", 62],
      ["f680", "\u9C1B", 32, "\u89E5\u89EB\u89EF\u8A3E\u8B26\u9753\u96E9\u96F3\u96EF\u9706\u9701\u9708\u970F\u970E\u972A\u972D\u9730\u973E\u9F80\u9F83\u9F85", 5, "\u9F8C\u9EFE\u9F0B\u9F0D\u96B9\u96BC\u96BD\u96CE\u96D2\u77BF\u96E0\u928E\u92AE\u92C8\u933E\u936A\u93CA\u938F\u943E\u946B\u9C7F\u9C82\u9C85\u9C86\u9C87\u9C88\u7A23\u9C8B\u9C8E\u9C90\u9C91\u9C92\u9C94\u9C95\u9C9A\u9C9B\u9C9E", 5, "\u9CA5", 4, "\u9CAB\u9CAD\u9CAE\u9CB0", 7, "\u9CBA\u9CBB\u9CBC\u9CBD\u9CC4\u9CC5\u9CC6\u9CC7\u9CCA\u9CCB"],
      ["f740", "\u9C3C", 62],
      ["f780", "\u9C7B\u9C7D\u9C7E\u9C80\u9C83\u9C84\u9C89\u9C8A\u9C8C\u9C8F\u9C93\u9C96\u9C97\u9C98\u9C99\u9C9D\u9CAA\u9CAC\u9CAF\u9CB9\u9CBE", 4, "\u9CC8\u9CC9\u9CD1\u9CD2\u9CDA\u9CDB\u9CE0\u9CE1\u9CCC", 4, "\u9CD3\u9CD4\u9CD5\u9CD7\u9CD8\u9CD9\u9CDC\u9CDD\u9CDF\u9CE2\u977C\u9785\u9791\u9792\u9794\u97AF\u97AB\u97A3\u97B2\u97B4\u9AB1\u9AB0\u9AB7\u9E58\u9AB6\u9ABA\u9ABC\u9AC1\u9AC0\u9AC5\u9AC2\u9ACB\u9ACC\u9AD1\u9B45\u9B43\u9B47\u9B49\u9B48\u9B4D\u9B51\u98E8\u990D\u992E\u9955\u9954\u9ADF\u9AE1\u9AE6\u9AEF\u9AEB\u9AFB\u9AED\u9AF9\u9B08\u9B0F\u9B13\u9B1F\u9B23\u9EBD\u9EBE\u7E3B\u9E82\u9E87\u9E88\u9E8B\u9E92\u93D6\u9E9D\u9E9F\u9EDB\u9EDC\u9EDD\u9EE0\u9EDF\u9EE2\u9EE9\u9EE7\u9EE5\u9EEA\u9EEF\u9F22\u9F2C\u9F2F\u9F39\u9F37\u9F3D\u9F3E\u9F44"],
      ["f840", "\u9CE3", 62],
      ["f880", "\u9D22", 32],
      ["f940", "\u9D43", 62],
      ["f980", "\u9D82", 32],
      ["fa40", "\u9DA3", 62],
      ["fa80", "\u9DE2", 32],
      ["fb40", "\u9E03", 27, "\u9E24\u9E27\u9E2E\u9E30\u9E34\u9E3B\u9E3C\u9E40\u9E4D\u9E50\u9E52\u9E53\u9E54\u9E56\u9E59\u9E5D\u9E5F\u9E60\u9E61\u9E62\u9E65\u9E6E\u9E6F\u9E72\u9E74", 9, "\u9E80"],
      ["fb80", "\u9E81\u9E83\u9E84\u9E85\u9E86\u9E89\u9E8A\u9E8C", 5, "\u9E94", 8, "\u9E9E\u9EA0", 5, "\u9EA7\u9EA8\u9EA9\u9EAA"],
      ["fc40", "\u9EAB", 8, "\u9EB5\u9EB6\u9EB7\u9EB9\u9EBA\u9EBC\u9EBF", 4, "\u9EC5\u9EC6\u9EC7\u9EC8\u9ECA\u9ECB\u9ECC\u9ED0\u9ED2\u9ED3\u9ED5\u9ED6\u9ED7\u9ED9\u9EDA\u9EDE\u9EE1\u9EE3\u9EE4\u9EE6\u9EE8\u9EEB\u9EEC\u9EED\u9EEE\u9EF0", 8, "\u9EFA\u9EFD\u9EFF", 6],
      ["fc80", "\u9F06", 4, "\u9F0C\u9F0F\u9F11\u9F12\u9F14\u9F15\u9F16\u9F18\u9F1A", 5, "\u9F21\u9F23", 8, "\u9F2D\u9F2E\u9F30\u9F31"],
      ["fd40", "\u9F32", 4, "\u9F38\u9F3A\u9F3C\u9F3F", 4, "\u9F45", 10, "\u9F52", 38],
      ["fd80", "\u9F79", 5, "\u9F81\u9F82\u9F8D", 11, "\u9F9C\u9F9D\u9F9E\u9FA1", 4, "\uF92C\uF979\uF995\uF9E7\uF9F1"],
      ["fe40", "\uFA0C\uFA0D\uFA0E\uFA0F\uFA11\uFA13\uFA14\uFA18\uFA1F\uFA20\uFA21\uFA23\uFA24\uFA27\uFA28\uFA29"]
    ];
  }
});

// node_modules/iconv-lite/encodings/tables/gbk-added.json
var require_gbk_added = __commonJS({
  "node_modules/iconv-lite/encodings/tables/gbk-added.json"(exports2, module2) {
    module2.exports = [
      ["a140", "\uE4C6", 62],
      ["a180", "\uE505", 32],
      ["a240", "\uE526", 62],
      ["a280", "\uE565", 32],
      ["a2ab", "\uE766", 5],
      ["a2e3", "\u20AC\uE76D"],
      ["a2ef", "\uE76E\uE76F"],
      ["a2fd", "\uE770\uE771"],
      ["a340", "\uE586", 62],
      ["a380", "\uE5C5", 31, "\u3000"],
      ["a440", "\uE5E6", 62],
      ["a480", "\uE625", 32],
      ["a4f4", "\uE772", 10],
      ["a540", "\uE646", 62],
      ["a580", "\uE685", 32],
      ["a5f7", "\uE77D", 7],
      ["a640", "\uE6A6", 62],
      ["a680", "\uE6E5", 32],
      ["a6b9", "\uE785", 7],
      ["a6d9", "\uE78D", 6],
      ["a6ec", "\uE794\uE795"],
      ["a6f3", "\uE796"],
      ["a6f6", "\uE797", 8],
      ["a740", "\uE706", 62],
      ["a780", "\uE745", 32],
      ["a7c2", "\uE7A0", 14],
      ["a7f2", "\uE7AF", 12],
      ["a896", "\uE7BC", 10],
      ["a8bc", "\u1E3F"],
      ["a8bf", "\u01F9"],
      ["a8c1", "\uE7C9\uE7CA\uE7CB\uE7CC"],
      ["a8ea", "\uE7CD", 20],
      ["a958", "\uE7E2"],
      ["a95b", "\uE7E3"],
      ["a95d", "\uE7E4\uE7E5\uE7E6"],
      ["a989", "\u303E\u2FF0", 11],
      ["a997", "\uE7F4", 12],
      ["a9f0", "\uE801", 14],
      ["aaa1", "\uE000", 93],
      ["aba1", "\uE05E", 93],
      ["aca1", "\uE0BC", 93],
      ["ada1", "\uE11A", 93],
      ["aea1", "\uE178", 93],
      ["afa1", "\uE1D6", 93],
      ["d7fa", "\uE810", 4],
      ["f8a1", "\uE234", 93],
      ["f9a1", "\uE292", 93],
      ["faa1", "\uE2F0", 93],
      ["fba1", "\uE34E", 93],
      ["fca1", "\uE3AC", 93],
      ["fda1", "\uE40A", 93],
      ["fe50", "\u2E81\uE816\uE817\uE818\u2E84\u3473\u3447\u2E88\u2E8B\uE81E\u359E\u361A\u360E\u2E8C\u2E97\u396E\u3918\uE826\u39CF\u39DF\u3A73\u39D0\uE82B\uE82C\u3B4E\u3C6E\u3CE0\u2EA7\uE831\uE832\u2EAA\u4056\u415F\u2EAE\u4337\u2EB3\u2EB6\u2EB7\uE83B\u43B1\u43AC\u2EBB\u43DD\u44D6\u4661\u464C\uE843"],
      ["fe80", "\u4723\u4729\u477C\u478D\u2ECA\u4947\u497A\u497D\u4982\u4983\u4985\u4986\u499F\u499B\u49B7\u49B6\uE854\uE855\u4CA3\u4C9F\u4CA0\u4CA1\u4C77\u4CA2\u4D13", 6, "\u4DAE\uE864\uE468", 93],
      ["8135f437", "\uE7C7"]
    ];
  }
});

// node_modules/iconv-lite/encodings/tables/gb18030-ranges.json
var require_gb18030_ranges = __commonJS({
  "node_modules/iconv-lite/encodings/tables/gb18030-ranges.json"(exports2, module2) {
    module2.exports = { uChars: [128, 165, 169, 178, 184, 216, 226, 235, 238, 244, 248, 251, 253, 258, 276, 284, 300, 325, 329, 334, 364, 463, 465, 467, 469, 471, 473, 475, 477, 506, 594, 610, 712, 716, 730, 930, 938, 962, 970, 1026, 1104, 1106, 8209, 8215, 8218, 8222, 8231, 8241, 8244, 8246, 8252, 8365, 8452, 8454, 8458, 8471, 8482, 8556, 8570, 8596, 8602, 8713, 8720, 8722, 8726, 8731, 8737, 8740, 8742, 8748, 8751, 8760, 8766, 8777, 8781, 8787, 8802, 8808, 8816, 8854, 8858, 8870, 8896, 8979, 9322, 9372, 9548, 9588, 9616, 9622, 9634, 9652, 9662, 9672, 9676, 9680, 9702, 9735, 9738, 9793, 9795, 11906, 11909, 11913, 11917, 11928, 11944, 11947, 11951, 11956, 11960, 11964, 11979, 12284, 12292, 12312, 12319, 12330, 12351, 12436, 12447, 12535, 12543, 12586, 12842, 12850, 12964, 13200, 13215, 13218, 13253, 13263, 13267, 13270, 13384, 13428, 13727, 13839, 13851, 14617, 14703, 14801, 14816, 14964, 15183, 15471, 15585, 16471, 16736, 17208, 17325, 17330, 17374, 17623, 17997, 18018, 18212, 18218, 18301, 18318, 18760, 18811, 18814, 18820, 18823, 18844, 18848, 18872, 19576, 19620, 19738, 19887, 40870, 59244, 59336, 59367, 59413, 59417, 59423, 59431, 59437, 59443, 59452, 59460, 59478, 59493, 63789, 63866, 63894, 63976, 63986, 64016, 64018, 64021, 64025, 64034, 64037, 64042, 65074, 65093, 65107, 65112, 65127, 65132, 65375, 65510, 65536], gbChars: [0, 36, 38, 45, 50, 81, 89, 95, 96, 100, 103, 104, 105, 109, 126, 133, 148, 172, 175, 179, 208, 306, 307, 308, 309, 310, 311, 312, 313, 341, 428, 443, 544, 545, 558, 741, 742, 749, 750, 805, 819, 820, 7922, 7924, 7925, 7927, 7934, 7943, 7944, 7945, 7950, 8062, 8148, 8149, 8152, 8164, 8174, 8236, 8240, 8262, 8264, 8374, 8380, 8381, 8384, 8388, 8390, 8392, 8393, 8394, 8396, 8401, 8406, 8416, 8419, 8424, 8437, 8439, 8445, 8482, 8485, 8496, 8521, 8603, 8936, 8946, 9046, 9050, 9063, 9066, 9076, 9092, 9100, 9108, 9111, 9113, 9131, 9162, 9164, 9218, 9219, 11329, 11331, 11334, 11336, 11346, 11361, 11363, 11366, 11370, 11372, 11375, 11389, 11682, 11686, 11687, 11692, 11694, 11714, 11716, 11723, 11725, 11730, 11736, 11982, 11989, 12102, 12336, 12348, 12350, 12384, 12393, 12395, 12397, 12510, 12553, 12851, 12962, 12973, 13738, 13823, 13919, 13933, 14080, 14298, 14585, 14698, 15583, 15847, 16318, 16434, 16438, 16481, 16729, 17102, 17122, 17315, 17320, 17402, 17418, 17859, 17909, 17911, 17915, 17916, 17936, 17939, 17961, 18664, 18703, 18814, 18962, 19043, 33469, 33470, 33471, 33484, 33485, 33490, 33497, 33501, 33505, 33513, 33520, 33536, 33550, 37845, 37921, 37948, 38029, 38038, 38064, 38065, 38066, 38069, 38075, 38076, 38078, 39108, 39109, 39113, 39114, 39115, 39116, 39265, 39394, 189e3] };
  }
});

// node_modules/iconv-lite/encodings/tables/cp949.json
var require_cp949 = __commonJS({
  "node_modules/iconv-lite/encodings/tables/cp949.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127],
      ["8141", "\uAC02\uAC03\uAC05\uAC06\uAC0B", 4, "\uAC18\uAC1E\uAC1F\uAC21\uAC22\uAC23\uAC25", 6, "\uAC2E\uAC32\uAC33\uAC34"],
      ["8161", "\uAC35\uAC36\uAC37\uAC3A\uAC3B\uAC3D\uAC3E\uAC3F\uAC41", 9, "\uAC4C\uAC4E", 5, "\uAC55"],
      ["8181", "\uAC56\uAC57\uAC59\uAC5A\uAC5B\uAC5D", 18, "\uAC72\uAC73\uAC75\uAC76\uAC79\uAC7B", 4, "\uAC82\uAC87\uAC88\uAC8D\uAC8E\uAC8F\uAC91\uAC92\uAC93\uAC95", 6, "\uAC9E\uACA2", 5, "\uACAB\uACAD\uACAE\uACB1", 6, "\uACBA\uACBE\uACBF\uACC0\uACC2\uACC3\uACC5\uACC6\uACC7\uACC9\uACCA\uACCB\uACCD", 7, "\uACD6\uACD8", 7, "\uACE2\uACE3\uACE5\uACE6\uACE9\uACEB\uACED\uACEE\uACF2\uACF4\uACF7", 4, "\uACFE\uACFF\uAD01\uAD02\uAD03\uAD05\uAD07", 4, "\uAD0E\uAD10\uAD12\uAD13"],
      ["8241", "\uAD14\uAD15\uAD16\uAD17\uAD19\uAD1A\uAD1B\uAD1D\uAD1E\uAD1F\uAD21", 7, "\uAD2A\uAD2B\uAD2E", 5],
      ["8261", "\uAD36\uAD37\uAD39\uAD3A\uAD3B\uAD3D", 6, "\uAD46\uAD48\uAD4A", 5, "\uAD51\uAD52\uAD53\uAD55\uAD56\uAD57"],
      ["8281", "\uAD59", 7, "\uAD62\uAD64", 7, "\uAD6E\uAD6F\uAD71\uAD72\uAD77\uAD78\uAD79\uAD7A\uAD7E\uAD80\uAD83", 4, "\uAD8A\uAD8B\uAD8D\uAD8E\uAD8F\uAD91", 10, "\uAD9E", 5, "\uADA5", 17, "\uADB8", 7, "\uADC2\uADC3\uADC5\uADC6\uADC7\uADC9", 6, "\uADD2\uADD4", 7, "\uADDD\uADDE\uADDF\uADE1\uADE2\uADE3\uADE5", 18],
      ["8341", "\uADFA\uADFB\uADFD\uADFE\uAE02", 5, "\uAE0A\uAE0C\uAE0E", 5, "\uAE15", 7],
      ["8361", "\uAE1D", 18, "\uAE32\uAE33\uAE35\uAE36\uAE39\uAE3B\uAE3C"],
      ["8381", "\uAE3D\uAE3E\uAE3F\uAE42\uAE44\uAE47\uAE48\uAE49\uAE4B\uAE4F\uAE51\uAE52\uAE53\uAE55\uAE57", 4, "\uAE5E\uAE62\uAE63\uAE64\uAE66\uAE67\uAE6A\uAE6B\uAE6D\uAE6E\uAE6F\uAE71", 6, "\uAE7A\uAE7E", 5, "\uAE86", 5, "\uAE8D", 46, "\uAEBF\uAEC1\uAEC2\uAEC3\uAEC5", 6, "\uAECE\uAED2", 5, "\uAEDA\uAEDB\uAEDD", 8],
      ["8441", "\uAEE6\uAEE7\uAEE9\uAEEA\uAEEC\uAEEE", 5, "\uAEF5\uAEF6\uAEF7\uAEF9\uAEFA\uAEFB\uAEFD", 8],
      ["8461", "\uAF06\uAF09\uAF0A\uAF0B\uAF0C\uAF0E\uAF0F\uAF11", 18],
      ["8481", "\uAF24", 7, "\uAF2E\uAF2F\uAF31\uAF33\uAF35", 6, "\uAF3E\uAF40\uAF44\uAF45\uAF46\uAF47\uAF4A", 5, "\uAF51", 10, "\uAF5E", 5, "\uAF66", 18, "\uAF7A", 5, "\uAF81\uAF82\uAF83\uAF85\uAF86\uAF87\uAF89", 6, "\uAF92\uAF93\uAF94\uAF96", 5, "\uAF9D", 26, "\uAFBA\uAFBB\uAFBD\uAFBE"],
      ["8541", "\uAFBF\uAFC1", 5, "\uAFCA\uAFCC\uAFCF", 4, "\uAFD5", 6, "\uAFDD", 4],
      ["8561", "\uAFE2", 5, "\uAFEA", 5, "\uAFF2\uAFF3\uAFF5\uAFF6\uAFF7\uAFF9", 6, "\uB002\uB003"],
      ["8581", "\uB005", 6, "\uB00D\uB00E\uB00F\uB011\uB012\uB013\uB015", 6, "\uB01E", 9, "\uB029", 26, "\uB046\uB047\uB049\uB04B\uB04D\uB04F\uB050\uB051\uB052\uB056\uB058\uB05A\uB05B\uB05C\uB05E", 29, "\uB07E\uB07F\uB081\uB082\uB083\uB085", 6, "\uB08E\uB090\uB092", 5, "\uB09B\uB09D\uB09E\uB0A3\uB0A4"],
      ["8641", "\uB0A5\uB0A6\uB0A7\uB0AA\uB0B0\uB0B2\uB0B6\uB0B7\uB0B9\uB0BA\uB0BB\uB0BD", 6, "\uB0C6\uB0CA", 5, "\uB0D2"],
      ["8661", "\uB0D3\uB0D5\uB0D6\uB0D7\uB0D9", 6, "\uB0E1\uB0E2\uB0E3\uB0E4\uB0E6", 10],
      ["8681", "\uB0F1", 22, "\uB10A\uB10D\uB10E\uB10F\uB111\uB114\uB115\uB116\uB117\uB11A\uB11E", 4, "\uB126\uB127\uB129\uB12A\uB12B\uB12D", 6, "\uB136\uB13A", 5, "\uB142\uB143\uB145\uB146\uB147\uB149", 6, "\uB152\uB153\uB156\uB157\uB159\uB15A\uB15B\uB15D\uB15E\uB15F\uB161", 22, "\uB17A\uB17B\uB17D\uB17E\uB17F\uB181\uB183", 4, "\uB18A\uB18C\uB18E\uB18F\uB190\uB191\uB195\uB196\uB197\uB199\uB19A\uB19B\uB19D"],
      ["8741", "\uB19E", 9, "\uB1A9", 15],
      ["8761", "\uB1B9", 18, "\uB1CD\uB1CE\uB1CF\uB1D1\uB1D2\uB1D3\uB1D5"],
      ["8781", "\uB1D6", 5, "\uB1DE\uB1E0", 7, "\uB1EA\uB1EB\uB1ED\uB1EE\uB1EF\uB1F1", 7, "\uB1FA\uB1FC\uB1FE", 5, "\uB206\uB207\uB209\uB20A\uB20D", 6, "\uB216\uB218\uB21A", 5, "\uB221", 18, "\uB235", 6, "\uB23D", 26, "\uB259\uB25A\uB25B\uB25D\uB25E\uB25F\uB261", 6, "\uB26A", 4],
      ["8841", "\uB26F", 4, "\uB276", 5, "\uB27D", 6, "\uB286\uB287\uB288\uB28A", 4],
      ["8861", "\uB28F\uB292\uB293\uB295\uB296\uB297\uB29B", 4, "\uB2A2\uB2A4\uB2A7\uB2A8\uB2A9\uB2AB\uB2AD\uB2AE\uB2AF\uB2B1\uB2B2\uB2B3\uB2B5\uB2B6\uB2B7"],
      ["8881", "\uB2B8", 15, "\uB2CA\uB2CB\uB2CD\uB2CE\uB2CF\uB2D1\uB2D3", 4, "\uB2DA\uB2DC\uB2DE\uB2DF\uB2E0\uB2E1\uB2E3\uB2E7\uB2E9\uB2EA\uB2F0\uB2F1\uB2F2\uB2F6\uB2FC\uB2FD\uB2FE\uB302\uB303\uB305\uB306\uB307\uB309", 6, "\uB312\uB316", 5, "\uB31D", 54, "\uB357\uB359\uB35A\uB35D\uB360\uB361\uB362\uB363"],
      ["8941", "\uB366\uB368\uB36A\uB36C\uB36D\uB36F\uB372\uB373\uB375\uB376\uB377\uB379", 6, "\uB382\uB386", 5, "\uB38D"],
      ["8961", "\uB38E\uB38F\uB391\uB392\uB393\uB395", 10, "\uB3A2", 5, "\uB3A9\uB3AA\uB3AB\uB3AD"],
      ["8981", "\uB3AE", 21, "\uB3C6\uB3C7\uB3C9\uB3CA\uB3CD\uB3CF\uB3D1\uB3D2\uB3D3\uB3D6\uB3D8\uB3DA\uB3DC\uB3DE\uB3DF\uB3E1\uB3E2\uB3E3\uB3E5\uB3E6\uB3E7\uB3E9", 18, "\uB3FD", 18, "\uB411", 6, "\uB419\uB41A\uB41B\uB41D\uB41E\uB41F\uB421", 6, "\uB42A\uB42C", 7, "\uB435", 15],
      ["8a41", "\uB445", 10, "\uB452\uB453\uB455\uB456\uB457\uB459", 6, "\uB462\uB464\uB466"],
      ["8a61", "\uB467", 4, "\uB46D", 18, "\uB481\uB482"],
      ["8a81", "\uB483", 4, "\uB489", 19, "\uB49E", 5, "\uB4A5\uB4A6\uB4A7\uB4A9\uB4AA\uB4AB\uB4AD", 7, "\uB4B6\uB4B8\uB4BA", 5, "\uB4C1\uB4C2\uB4C3\uB4C5\uB4C6\uB4C7\uB4C9", 6, "\uB4D1\uB4D2\uB4D3\uB4D4\uB4D6", 5, "\uB4DE\uB4DF\uB4E1\uB4E2\uB4E5\uB4E7", 4, "\uB4EE\uB4F0\uB4F2", 5, "\uB4F9", 26, "\uB516\uB517\uB519\uB51A\uB51D"],
      ["8b41", "\uB51E", 5, "\uB526\uB52B", 4, "\uB532\uB533\uB535\uB536\uB537\uB539", 6, "\uB542\uB546"],
      ["8b61", "\uB547\uB548\uB549\uB54A\uB54E\uB54F\uB551\uB552\uB553\uB555", 6, "\uB55E\uB562", 8],
      ["8b81", "\uB56B", 52, "\uB5A2\uB5A3\uB5A5\uB5A6\uB5A7\uB5A9\uB5AC\uB5AD\uB5AE\uB5AF\uB5B2\uB5B6", 4, "\uB5BE\uB5BF\uB5C1\uB5C2\uB5C3\uB5C5", 6, "\uB5CE\uB5D2", 5, "\uB5D9", 18, "\uB5ED", 18],
      ["8c41", "\uB600", 15, "\uB612\uB613\uB615\uB616\uB617\uB619", 4],
      ["8c61", "\uB61E", 6, "\uB626", 5, "\uB62D", 6, "\uB635", 5],
      ["8c81", "\uB63B", 12, "\uB649", 26, "\uB665\uB666\uB667\uB669", 50, "\uB69E\uB69F\uB6A1\uB6A2\uB6A3\uB6A5", 5, "\uB6AD\uB6AE\uB6AF\uB6B0\uB6B2", 16],
      ["8d41", "\uB6C3", 16, "\uB6D5", 8],
      ["8d61", "\uB6DE", 17, "\uB6F1\uB6F2\uB6F3\uB6F5\uB6F6\uB6F7\uB6F9\uB6FA"],
      ["8d81", "\uB6FB", 4, "\uB702\uB703\uB704\uB706", 33, "\uB72A\uB72B\uB72D\uB72E\uB731", 6, "\uB73A\uB73C", 7, "\uB745\uB746\uB747\uB749\uB74A\uB74B\uB74D", 6, "\uB756", 9, "\uB761\uB762\uB763\uB765\uB766\uB767\uB769", 6, "\uB772\uB774\uB776", 5, "\uB77E\uB77F\uB781\uB782\uB783\uB785", 6, "\uB78E\uB793\uB794\uB795\uB79A\uB79B\uB79D\uB79E"],
      ["8e41", "\uB79F\uB7A1", 6, "\uB7AA\uB7AE", 5, "\uB7B6\uB7B7\uB7B9", 8],
      ["8e61", "\uB7C2", 4, "\uB7C8\uB7CA", 19],
      ["8e81", "\uB7DE", 13, "\uB7EE\uB7EF\uB7F1\uB7F2\uB7F3\uB7F5", 6, "\uB7FE\uB802", 4, "\uB80A\uB80B\uB80D\uB80E\uB80F\uB811", 6, "\uB81A\uB81C\uB81E", 5, "\uB826\uB827\uB829\uB82A\uB82B\uB82D", 6, "\uB836\uB83A", 5, "\uB841\uB842\uB843\uB845", 11, "\uB852\uB854", 7, "\uB85E\uB85F\uB861\uB862\uB863\uB865", 6, "\uB86E\uB870\uB872", 5, "\uB879\uB87A\uB87B\uB87D", 7],
      ["8f41", "\uB885", 7, "\uB88E", 17],
      ["8f61", "\uB8A0", 7, "\uB8A9", 6, "\uB8B1\uB8B2\uB8B3\uB8B5\uB8B6\uB8B7\uB8B9", 4],
      ["8f81", "\uB8BE\uB8BF\uB8C2\uB8C4\uB8C6", 5, "\uB8CD\uB8CE\uB8CF\uB8D1\uB8D2\uB8D3\uB8D5", 7, "\uB8DE\uB8E0\uB8E2", 5, "\uB8EA\uB8EB\uB8ED\uB8EE\uB8EF\uB8F1", 6, "\uB8FA\uB8FC\uB8FE", 5, "\uB905", 18, "\uB919", 6, "\uB921", 26, "\uB93E\uB93F\uB941\uB942\uB943\uB945", 6, "\uB94D\uB94E\uB950\uB952", 5],
      ["9041", "\uB95A\uB95B\uB95D\uB95E\uB95F\uB961", 6, "\uB96A\uB96C\uB96E", 5, "\uB976\uB977\uB979\uB97A\uB97B\uB97D"],
      ["9061", "\uB97E", 5, "\uB986\uB988\uB98B\uB98C\uB98F", 15],
      ["9081", "\uB99F", 12, "\uB9AE\uB9AF\uB9B1\uB9B2\uB9B3\uB9B5", 6, "\uB9BE\uB9C0\uB9C2", 5, "\uB9CA\uB9CB\uB9CD\uB9D3", 4, "\uB9DA\uB9DC\uB9DF\uB9E0\uB9E2\uB9E6\uB9E7\uB9E9\uB9EA\uB9EB\uB9ED", 6, "\uB9F6\uB9FB", 4, "\uBA02", 5, "\uBA09", 11, "\uBA16", 33, "\uBA3A\uBA3B\uBA3D\uBA3E\uBA3F\uBA41\uBA43\uBA44\uBA45\uBA46"],
      ["9141", "\uBA47\uBA4A\uBA4C\uBA4F\uBA50\uBA51\uBA52\uBA56\uBA57\uBA59\uBA5A\uBA5B\uBA5D", 6, "\uBA66\uBA6A", 5],
      ["9161", "\uBA72\uBA73\uBA75\uBA76\uBA77\uBA79", 9, "\uBA86\uBA88\uBA89\uBA8A\uBA8B\uBA8D", 5],
      ["9181", "\uBA93", 20, "\uBAAA\uBAAD\uBAAE\uBAAF\uBAB1\uBAB3", 4, "\uBABA\uBABC\uBABE", 5, "\uBAC5\uBAC6\uBAC7\uBAC9", 14, "\uBADA", 33, "\uBAFD\uBAFE\uBAFF\uBB01\uBB02\uBB03\uBB05", 7, "\uBB0E\uBB10\uBB12", 5, "\uBB19\uBB1A\uBB1B\uBB1D\uBB1E\uBB1F\uBB21", 6],
      ["9241", "\uBB28\uBB2A\uBB2C", 7, "\uBB37\uBB39\uBB3A\uBB3F", 4, "\uBB46\uBB48\uBB4A\uBB4B\uBB4C\uBB4E\uBB51\uBB52"],
      ["9261", "\uBB53\uBB55\uBB56\uBB57\uBB59", 7, "\uBB62\uBB64", 7, "\uBB6D", 4],
      ["9281", "\uBB72", 21, "\uBB89\uBB8A\uBB8B\uBB8D\uBB8E\uBB8F\uBB91", 18, "\uBBA5\uBBA6\uBBA7\uBBA9\uBBAA\uBBAB\uBBAD", 6, "\uBBB5\uBBB6\uBBB8", 7, "\uBBC1\uBBC2\uBBC3\uBBC5\uBBC6\uBBC7\uBBC9", 6, "\uBBD1\uBBD2\uBBD4", 35, "\uBBFA\uBBFB\uBBFD\uBBFE\uBC01"],
      ["9341", "\uBC03", 4, "\uBC0A\uBC0E\uBC10\uBC12\uBC13\uBC19\uBC1A\uBC20\uBC21\uBC22\uBC23\uBC26\uBC28\uBC2A\uBC2B\uBC2C\uBC2E\uBC2F\uBC32\uBC33\uBC35"],
      ["9361", "\uBC36\uBC37\uBC39", 6, "\uBC42\uBC46\uBC47\uBC48\uBC4A\uBC4B\uBC4E\uBC4F\uBC51", 8],
      ["9381", "\uBC5A\uBC5B\uBC5C\uBC5E", 37, "\uBC86\uBC87\uBC89\uBC8A\uBC8D\uBC8F", 4, "\uBC96\uBC98\uBC9B", 4, "\uBCA2\uBCA3\uBCA5\uBCA6\uBCA9", 6, "\uBCB2\uBCB6", 5, "\uBCBE\uBCBF\uBCC1\uBCC2\uBCC3\uBCC5", 7, "\uBCCE\uBCD2\uBCD3\uBCD4\uBCD6\uBCD7\uBCD9\uBCDA\uBCDB\uBCDD", 22, "\uBCF7\uBCF9\uBCFA\uBCFB\uBCFD"],
      ["9441", "\uBCFE", 5, "\uBD06\uBD08\uBD0A", 5, "\uBD11\uBD12\uBD13\uBD15", 8],
      ["9461", "\uBD1E", 5, "\uBD25", 6, "\uBD2D", 12],
      ["9481", "\uBD3A", 5, "\uBD41", 6, "\uBD4A\uBD4B\uBD4D\uBD4E\uBD4F\uBD51", 6, "\uBD5A", 9, "\uBD65\uBD66\uBD67\uBD69", 22, "\uBD82\uBD83\uBD85\uBD86\uBD8B", 4, "\uBD92\uBD94\uBD96\uBD97\uBD98\uBD9B\uBD9D", 6, "\uBDA5", 10, "\uBDB1", 6, "\uBDB9", 24],
      ["9541", "\uBDD2\uBDD3\uBDD6\uBDD7\uBDD9\uBDDA\uBDDB\uBDDD", 11, "\uBDEA", 5, "\uBDF1"],
      ["9561", "\uBDF2\uBDF3\uBDF5\uBDF6\uBDF7\uBDF9", 6, "\uBE01\uBE02\uBE04\uBE06", 5, "\uBE0E\uBE0F\uBE11\uBE12\uBE13"],
      ["9581", "\uBE15", 6, "\uBE1E\uBE20", 35, "\uBE46\uBE47\uBE49\uBE4A\uBE4B\uBE4D\uBE4F", 4, "\uBE56\uBE58\uBE5C\uBE5D\uBE5E\uBE5F\uBE62\uBE63\uBE65\uBE66\uBE67\uBE69\uBE6B", 4, "\uBE72\uBE76", 4, "\uBE7E\uBE7F\uBE81\uBE82\uBE83\uBE85", 6, "\uBE8E\uBE92", 5, "\uBE9A", 13, "\uBEA9", 14],
      ["9641", "\uBEB8", 23, "\uBED2\uBED3"],
      ["9661", "\uBED5\uBED6\uBED9", 6, "\uBEE1\uBEE2\uBEE6", 5, "\uBEED", 8],
      ["9681", "\uBEF6", 10, "\uBF02", 5, "\uBF0A", 13, "\uBF1A\uBF1E", 33, "\uBF42\uBF43\uBF45\uBF46\uBF47\uBF49", 6, "\uBF52\uBF53\uBF54\uBF56", 44],
      ["9741", "\uBF83", 16, "\uBF95", 8],
      ["9761", "\uBF9E", 17, "\uBFB1", 7],
      ["9781", "\uBFB9", 11, "\uBFC6", 5, "\uBFCE\uBFCF\uBFD1\uBFD2\uBFD3\uBFD5", 6, "\uBFDD\uBFDE\uBFE0\uBFE2", 89, "\uC03D\uC03E\uC03F"],
      ["9841", "\uC040", 16, "\uC052", 5, "\uC059\uC05A\uC05B"],
      ["9861", "\uC05D\uC05E\uC05F\uC061", 6, "\uC06A", 15],
      ["9881", "\uC07A", 21, "\uC092\uC093\uC095\uC096\uC097\uC099", 6, "\uC0A2\uC0A4\uC0A6", 5, "\uC0AE\uC0B1\uC0B2\uC0B7", 4, "\uC0BE\uC0C2\uC0C3\uC0C4\uC0C6\uC0C7\uC0CA\uC0CB\uC0CD\uC0CE\uC0CF\uC0D1", 6, "\uC0DA\uC0DE", 5, "\uC0E6\uC0E7\uC0E9\uC0EA\uC0EB\uC0ED", 6, "\uC0F6\uC0F8\uC0FA", 5, "\uC101\uC102\uC103\uC105\uC106\uC107\uC109", 6, "\uC111\uC112\uC113\uC114\uC116", 5, "\uC121\uC122\uC125\uC128\uC129\uC12A\uC12B\uC12E"],
      ["9941", "\uC132\uC133\uC134\uC135\uC137\uC13A\uC13B\uC13D\uC13E\uC13F\uC141", 6, "\uC14A\uC14E", 5, "\uC156\uC157"],
      ["9961", "\uC159\uC15A\uC15B\uC15D", 6, "\uC166\uC16A", 5, "\uC171\uC172\uC173\uC175\uC176\uC177\uC179\uC17A\uC17B"],
      ["9981", "\uC17C", 8, "\uC186", 5, "\uC18F\uC191\uC192\uC193\uC195\uC197", 4, "\uC19E\uC1A0\uC1A2\uC1A3\uC1A4\uC1A6\uC1A7\uC1AA\uC1AB\uC1AD\uC1AE\uC1AF\uC1B1", 11, "\uC1BE", 5, "\uC1C5\uC1C6\uC1C7\uC1C9\uC1CA\uC1CB\uC1CD", 6, "\uC1D5\uC1D6\uC1D9", 6, "\uC1E1\uC1E2\uC1E3\uC1E5\uC1E6\uC1E7\uC1E9", 6, "\uC1F2\uC1F4", 7, "\uC1FE\uC1FF\uC201\uC202\uC203\uC205", 6, "\uC20E\uC210\uC212", 5, "\uC21A\uC21B\uC21D\uC21E\uC221\uC222\uC223"],
      ["9a41", "\uC224\uC225\uC226\uC227\uC22A\uC22C\uC22E\uC230\uC233\uC235", 16],
      ["9a61", "\uC246\uC247\uC249", 6, "\uC252\uC253\uC255\uC256\uC257\uC259", 6, "\uC261\uC262\uC263\uC264\uC266"],
      ["9a81", "\uC267", 4, "\uC26E\uC26F\uC271\uC272\uC273\uC275", 6, "\uC27E\uC280\uC282", 5, "\uC28A", 5, "\uC291", 6, "\uC299\uC29A\uC29C\uC29E", 5, "\uC2A6\uC2A7\uC2A9\uC2AA\uC2AB\uC2AE", 5, "\uC2B6\uC2B8\uC2BA", 33, "\uC2DE\uC2DF\uC2E1\uC2E2\uC2E5", 5, "\uC2EE\uC2F0\uC2F2\uC2F3\uC2F4\uC2F5\uC2F7\uC2FA\uC2FD\uC2FE\uC2FF\uC301", 6, "\uC30A\uC30B\uC30E\uC30F"],
      ["9b41", "\uC310\uC311\uC312\uC316\uC317\uC319\uC31A\uC31B\uC31D", 6, "\uC326\uC327\uC32A", 8],
      ["9b61", "\uC333", 17, "\uC346", 7],
      ["9b81", "\uC34E", 25, "\uC36A\uC36B\uC36D\uC36E\uC36F\uC371\uC373", 4, "\uC37A\uC37B\uC37E", 5, "\uC385\uC386\uC387\uC389\uC38A\uC38B\uC38D", 50, "\uC3C1", 22, "\uC3DA"],
      ["9c41", "\uC3DB\uC3DD\uC3DE\uC3E1\uC3E3", 4, "\uC3EA\uC3EB\uC3EC\uC3EE", 5, "\uC3F6\uC3F7\uC3F9", 5],
      ["9c61", "\uC3FF", 8, "\uC409", 6, "\uC411", 9],
      ["9c81", "\uC41B", 8, "\uC425", 6, "\uC42D\uC42E\uC42F\uC431\uC432\uC433\uC435", 6, "\uC43E", 9, "\uC449", 26, "\uC466\uC467\uC469\uC46A\uC46B\uC46D", 6, "\uC476\uC477\uC478\uC47A", 5, "\uC481", 18, "\uC495", 6, "\uC49D", 12],
      ["9d41", "\uC4AA", 13, "\uC4B9\uC4BA\uC4BB\uC4BD", 8],
      ["9d61", "\uC4C6", 25],
      ["9d81", "\uC4E0", 8, "\uC4EA", 5, "\uC4F2\uC4F3\uC4F5\uC4F6\uC4F7\uC4F9\uC4FB\uC4FC\uC4FD\uC4FE\uC502", 9, "\uC50D\uC50E\uC50F\uC511\uC512\uC513\uC515", 6, "\uC51D", 10, "\uC52A\uC52B\uC52D\uC52E\uC52F\uC531", 6, "\uC53A\uC53C\uC53E", 5, "\uC546\uC547\uC54B\uC54F\uC550\uC551\uC552\uC556\uC55A\uC55B\uC55C\uC55F\uC562\uC563\uC565\uC566\uC567\uC569", 6, "\uC572\uC576", 5, "\uC57E\uC57F\uC581\uC582\uC583\uC585\uC586\uC588\uC589\uC58A\uC58B\uC58E\uC590\uC592\uC593\uC594"],
      ["9e41", "\uC596\uC599\uC59A\uC59B\uC59D\uC59E\uC59F\uC5A1", 7, "\uC5AA", 9, "\uC5B6"],
      ["9e61", "\uC5B7\uC5BA\uC5BF", 4, "\uC5CB\uC5CD\uC5CF\uC5D2\uC5D3\uC5D5\uC5D6\uC5D7\uC5D9", 6, "\uC5E2\uC5E4\uC5E6\uC5E7"],
      ["9e81", "\uC5E8\uC5E9\uC5EA\uC5EB\uC5EF\uC5F1\uC5F2\uC5F3\uC5F5\uC5F8\uC5F9\uC5FA\uC5FB\uC602\uC603\uC604\uC609\uC60A\uC60B\uC60D\uC60E\uC60F\uC611", 6, "\uC61A\uC61D", 6, "\uC626\uC627\uC629\uC62A\uC62B\uC62F\uC631\uC632\uC636\uC638\uC63A\uC63C\uC63D\uC63E\uC63F\uC642\uC643\uC645\uC646\uC647\uC649", 6, "\uC652\uC656", 5, "\uC65E\uC65F\uC661", 10, "\uC66D\uC66E\uC670\uC672", 5, "\uC67A\uC67B\uC67D\uC67E\uC67F\uC681", 6, "\uC68A\uC68C\uC68E", 5, "\uC696\uC697\uC699\uC69A\uC69B\uC69D", 6, "\uC6A6"],
      ["9f41", "\uC6A8\uC6AA", 5, "\uC6B2\uC6B3\uC6B5\uC6B6\uC6B7\uC6BB", 4, "\uC6C2\uC6C4\uC6C6", 5, "\uC6CE"],
      ["9f61", "\uC6CF\uC6D1\uC6D2\uC6D3\uC6D5", 6, "\uC6DE\uC6DF\uC6E2", 5, "\uC6EA\uC6EB\uC6ED\uC6EE\uC6EF\uC6F1\uC6F2"],
      ["9f81", "\uC6F3", 4, "\uC6FA\uC6FB\uC6FC\uC6FE", 5, "\uC706\uC707\uC709\uC70A\uC70B\uC70D", 6, "\uC716\uC718\uC71A", 5, "\uC722\uC723\uC725\uC726\uC727\uC729", 6, "\uC732\uC734\uC736\uC738\uC739\uC73A\uC73B\uC73E\uC73F\uC741\uC742\uC743\uC745", 4, "\uC74B\uC74E\uC750\uC759\uC75A\uC75B\uC75D\uC75E\uC75F\uC761", 6, "\uC769\uC76A\uC76C", 7, "\uC776\uC777\uC779\uC77A\uC77B\uC77F\uC780\uC781\uC782\uC786\uC78B\uC78C\uC78D\uC78F\uC792\uC793\uC795\uC799\uC79B", 4, "\uC7A2\uC7A7", 4, "\uC7AE\uC7AF\uC7B1\uC7B2\uC7B3\uC7B5\uC7B6\uC7B7"],
      ["a041", "\uC7B8\uC7B9\uC7BA\uC7BB\uC7BE\uC7C2", 5, "\uC7CA\uC7CB\uC7CD\uC7CF\uC7D1", 6, "\uC7D9\uC7DA\uC7DB\uC7DC"],
      ["a061", "\uC7DE", 5, "\uC7E5\uC7E6\uC7E7\uC7E9\uC7EA\uC7EB\uC7ED", 13],
      ["a081", "\uC7FB", 4, "\uC802\uC803\uC805\uC806\uC807\uC809\uC80B", 4, "\uC812\uC814\uC817", 4, "\uC81E\uC81F\uC821\uC822\uC823\uC825", 6, "\uC82E\uC830\uC832", 5, "\uC839\uC83A\uC83B\uC83D\uC83E\uC83F\uC841", 6, "\uC84A\uC84B\uC84E", 5, "\uC855", 26, "\uC872\uC873\uC875\uC876\uC877\uC879\uC87B", 4, "\uC882\uC884\uC888\uC889\uC88A\uC88E", 5, "\uC895", 7, "\uC89E\uC8A0\uC8A2\uC8A3\uC8A4"],
      ["a141", "\uC8A5\uC8A6\uC8A7\uC8A9", 18, "\uC8BE\uC8BF\uC8C0\uC8C1"],
      ["a161", "\uC8C2\uC8C3\uC8C5\uC8C6\uC8C7\uC8C9\uC8CA\uC8CB\uC8CD", 6, "\uC8D6\uC8D8\uC8DA", 5, "\uC8E2\uC8E3\uC8E5"],
      ["a181", "\uC8E6", 14, "\uC8F6", 5, "\uC8FE\uC8FF\uC901\uC902\uC903\uC907", 4, "\uC90E\u3000\u3001\u3002\xB7\u2025\u2026\xA8\u3003\xAD\u2015\u2225\uFF3C\u223C\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 9, "\xB1\xD7\xF7\u2260\u2264\u2265\u221E\u2234\xB0\u2032\u2033\u2103\u212B\uFFE0\uFFE1\uFFE5\u2642\u2640\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\xA7\u203B\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u2192\u2190\u2191\u2193\u2194\u3013\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229\u2227\u2228\uFFE2"],
      ["a241", "\uC910\uC912", 5, "\uC919", 18],
      ["a261", "\uC92D", 6, "\uC935", 18],
      ["a281", "\uC948", 7, "\uC952\uC953\uC955\uC956\uC957\uC959", 6, "\uC962\uC964", 7, "\uC96D\uC96E\uC96F\u21D2\u21D4\u2200\u2203\xB4\uFF5E\u02C7\u02D8\u02DD\u02DA\u02D9\xB8\u02DB\xA1\xBF\u02D0\u222E\u2211\u220F\xA4\u2109\u2030\u25C1\u25C0\u25B7\u25B6\u2664\u2660\u2661\u2665\u2667\u2663\u2299\u25C8\u25A3\u25D0\u25D1\u2592\u25A4\u25A5\u25A8\u25A7\u25A6\u25A9\u2668\u260F\u260E\u261C\u261E\xB6\u2020\u2021\u2195\u2197\u2199\u2196\u2198\u266D\u2669\u266A\u266C\u327F\u321C\u2116\u33C7\u2122\u33C2\u33D8\u2121\u20AC\xAE"],
      ["a341", "\uC971\uC972\uC973\uC975", 6, "\uC97D", 10, "\uC98A\uC98B\uC98D\uC98E\uC98F"],
      ["a361", "\uC991", 6, "\uC99A\uC99C\uC99E", 16],
      ["a381", "\uC9AF", 16, "\uC9C2\uC9C3\uC9C5\uC9C6\uC9C9\uC9CB", 4, "\uC9D2\uC9D4\uC9D7\uC9D8\uC9DB\uFF01", 58, "\uFFE6\uFF3D", 32, "\uFFE3"],
      ["a441", "\uC9DE\uC9DF\uC9E1\uC9E3\uC9E5\uC9E6\uC9E8\uC9E9\uC9EA\uC9EB\uC9EE\uC9F2", 5, "\uC9FA\uC9FB\uC9FD\uC9FE\uC9FF\uCA01\uCA02\uCA03\uCA04"],
      ["a461", "\uCA05\uCA06\uCA07\uCA0A\uCA0E", 5, "\uCA15\uCA16\uCA17\uCA19", 12],
      ["a481", "\uCA26\uCA27\uCA28\uCA2A", 28, "\u3131", 93],
      ["a541", "\uCA47", 4, "\uCA4E\uCA4F\uCA51\uCA52\uCA53\uCA55", 6, "\uCA5E\uCA62", 5, "\uCA69\uCA6A"],
      ["a561", "\uCA6B", 17, "\uCA7E", 5, "\uCA85\uCA86"],
      ["a581", "\uCA87", 16, "\uCA99", 14, "\u2170", 9],
      ["a5b0", "\u2160", 9],
      ["a5c1", "\u0391", 16, "\u03A3", 6],
      ["a5e1", "\u03B1", 16, "\u03C3", 6],
      ["a641", "\uCAA8", 19, "\uCABE\uCABF\uCAC1\uCAC2\uCAC3\uCAC5"],
      ["a661", "\uCAC6", 5, "\uCACE\uCAD0\uCAD2\uCAD4\uCAD5\uCAD6\uCAD7\uCADA", 5, "\uCAE1", 6],
      ["a681", "\uCAE8\uCAE9\uCAEA\uCAEB\uCAED", 6, "\uCAF5", 18, "\uCB09\uCB0A\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542\u2512\u2511\u251A\u2519\u2516\u2515\u250E\u250D\u251E\u251F\u2521\u2522\u2526\u2527\u2529\u252A\u252D\u252E\u2531\u2532\u2535\u2536\u2539\u253A\u253D\u253E\u2540\u2541\u2543", 7],
      ["a741", "\uCB0B", 4, "\uCB11\uCB12\uCB13\uCB15\uCB16\uCB17\uCB19", 6, "\uCB22", 7],
      ["a761", "\uCB2A", 22, "\uCB42\uCB43\uCB44"],
      ["a781", "\uCB45\uCB46\uCB47\uCB4A\uCB4B\uCB4D\uCB4E\uCB4F\uCB51", 6, "\uCB5A\uCB5B\uCB5C\uCB5E", 5, "\uCB65", 7, "\u3395\u3396\u3397\u2113\u3398\u33C4\u33A3\u33A4\u33A5\u33A6\u3399", 9, "\u33CA\u338D\u338E\u338F\u33CF\u3388\u3389\u33C8\u33A7\u33A8\u33B0", 9, "\u3380", 4, "\u33BA", 5, "\u3390", 4, "\u2126\u33C0\u33C1\u338A\u338B\u338C\u33D6\u33C5\u33AD\u33AE\u33AF\u33DB\u33A9\u33AA\u33AB\u33AC\u33DD\u33D0\u33D3\u33C3\u33C9\u33DC\u33C6"],
      ["a841", "\uCB6D", 10, "\uCB7A", 14],
      ["a861", "\uCB89", 18, "\uCB9D", 6],
      ["a881", "\uCBA4", 19, "\uCBB9", 11, "\xC6\xD0\xAA\u0126"],
      ["a8a6", "\u0132"],
      ["a8a8", "\u013F\u0141\xD8\u0152\xBA\xDE\u0166\u014A"],
      ["a8b1", "\u3260", 27, "\u24D0", 25, "\u2460", 14, "\xBD\u2153\u2154\xBC\xBE\u215B\u215C\u215D\u215E"],
      ["a941", "\uCBC5", 14, "\uCBD5", 10],
      ["a961", "\uCBE0\uCBE1\uCBE2\uCBE3\uCBE5\uCBE6\uCBE8\uCBEA", 18],
      ["a981", "\uCBFD", 14, "\uCC0E\uCC0F\uCC11\uCC12\uCC13\uCC15", 6, "\uCC1E\uCC1F\uCC20\uCC23\uCC24\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0140\u0142\xF8\u0153\xDF\xFE\u0167\u014B\u0149\u3200", 27, "\u249C", 25, "\u2474", 14, "\xB9\xB2\xB3\u2074\u207F\u2081\u2082\u2083\u2084"],
      ["aa41", "\uCC25\uCC26\uCC2A\uCC2B\uCC2D\uCC2F\uCC31", 6, "\uCC3A\uCC3F", 4, "\uCC46\uCC47\uCC49\uCC4A\uCC4B\uCC4D\uCC4E"],
      ["aa61", "\uCC4F", 4, "\uCC56\uCC5A", 5, "\uCC61\uCC62\uCC63\uCC65\uCC67\uCC69", 6, "\uCC71\uCC72"],
      ["aa81", "\uCC73\uCC74\uCC76", 29, "\u3041", 82],
      ["ab41", "\uCC94\uCC95\uCC96\uCC97\uCC9A\uCC9B\uCC9D\uCC9E\uCC9F\uCCA1", 6, "\uCCAA\uCCAE", 5, "\uCCB6\uCCB7\uCCB9"],
      ["ab61", "\uCCBA\uCCBB\uCCBD", 6, "\uCCC6\uCCC8\uCCCA", 5, "\uCCD1\uCCD2\uCCD3\uCCD5", 5],
      ["ab81", "\uCCDB", 8, "\uCCE5", 6, "\uCCED\uCCEE\uCCEF\uCCF1", 12, "\u30A1", 85],
      ["ac41", "\uCCFE\uCCFF\uCD00\uCD02", 5, "\uCD0A\uCD0B\uCD0D\uCD0E\uCD0F\uCD11", 6, "\uCD1A\uCD1C\uCD1E\uCD1F\uCD20"],
      ["ac61", "\uCD21\uCD22\uCD23\uCD25\uCD26\uCD27\uCD29\uCD2A\uCD2B\uCD2D", 11, "\uCD3A", 4],
      ["ac81", "\uCD3F", 28, "\uCD5D\uCD5E\uCD5F\u0410", 5, "\u0401\u0416", 25],
      ["acd1", "\u0430", 5, "\u0451\u0436", 25],
      ["ad41", "\uCD61\uCD62\uCD63\uCD65", 6, "\uCD6E\uCD70\uCD72", 5, "\uCD79", 7],
      ["ad61", "\uCD81", 6, "\uCD89", 10, "\uCD96\uCD97\uCD99\uCD9A\uCD9B\uCD9D\uCD9E\uCD9F"],
      ["ad81", "\uCDA0\uCDA1\uCDA2\uCDA3\uCDA6\uCDA8\uCDAA", 5, "\uCDB1", 18, "\uCDC5"],
      ["ae41", "\uCDC6", 5, "\uCDCD\uCDCE\uCDCF\uCDD1", 16],
      ["ae61", "\uCDE2", 5, "\uCDE9\uCDEA\uCDEB\uCDED\uCDEE\uCDEF\uCDF1", 6, "\uCDFA\uCDFC\uCDFE", 4],
      ["ae81", "\uCE03\uCE05\uCE06\uCE07\uCE09\uCE0A\uCE0B\uCE0D", 6, "\uCE15\uCE16\uCE17\uCE18\uCE1A", 5, "\uCE22\uCE23\uCE25\uCE26\uCE27\uCE29\uCE2A\uCE2B"],
      ["af41", "\uCE2C\uCE2D\uCE2E\uCE2F\uCE32\uCE34\uCE36", 19],
      ["af61", "\uCE4A", 13, "\uCE5A\uCE5B\uCE5D\uCE5E\uCE62", 5, "\uCE6A\uCE6C"],
      ["af81", "\uCE6E", 5, "\uCE76\uCE77\uCE79\uCE7A\uCE7B\uCE7D", 6, "\uCE86\uCE88\uCE8A", 5, "\uCE92\uCE93\uCE95\uCE96\uCE97\uCE99"],
      ["b041", "\uCE9A", 5, "\uCEA2\uCEA6", 5, "\uCEAE", 12],
      ["b061", "\uCEBB", 5, "\uCEC2", 19],
      ["b081", "\uCED6", 13, "\uCEE6\uCEE7\uCEE9\uCEEA\uCEED", 6, "\uCEF6\uCEFA", 5, "\uAC00\uAC01\uAC04\uAC07\uAC08\uAC09\uAC0A\uAC10", 7, "\uAC19", 4, "\uAC20\uAC24\uAC2C\uAC2D\uAC2F\uAC30\uAC31\uAC38\uAC39\uAC3C\uAC40\uAC4B\uAC4D\uAC54\uAC58\uAC5C\uAC70\uAC71\uAC74\uAC77\uAC78\uAC7A\uAC80\uAC81\uAC83\uAC84\uAC85\uAC86\uAC89\uAC8A\uAC8B\uAC8C\uAC90\uAC94\uAC9C\uAC9D\uAC9F\uACA0\uACA1\uACA8\uACA9\uACAA\uACAC\uACAF\uACB0\uACB8\uACB9\uACBB\uACBC\uACBD\uACC1\uACC4\uACC8\uACCC\uACD5\uACD7\uACE0\uACE1\uACE4\uACE7\uACE8\uACEA\uACEC\uACEF\uACF0\uACF1\uACF3\uACF5\uACF6\uACFC\uACFD\uAD00\uAD04\uAD06"],
      ["b141", "\uCF02\uCF03\uCF05\uCF06\uCF07\uCF09", 6, "\uCF12\uCF14\uCF16", 5, "\uCF1D\uCF1E\uCF1F\uCF21\uCF22\uCF23"],
      ["b161", "\uCF25", 6, "\uCF2E\uCF32", 5, "\uCF39", 11],
      ["b181", "\uCF45", 14, "\uCF56\uCF57\uCF59\uCF5A\uCF5B\uCF5D", 6, "\uCF66\uCF68\uCF6A\uCF6B\uCF6C\uAD0C\uAD0D\uAD0F\uAD11\uAD18\uAD1C\uAD20\uAD29\uAD2C\uAD2D\uAD34\uAD35\uAD38\uAD3C\uAD44\uAD45\uAD47\uAD49\uAD50\uAD54\uAD58\uAD61\uAD63\uAD6C\uAD6D\uAD70\uAD73\uAD74\uAD75\uAD76\uAD7B\uAD7C\uAD7D\uAD7F\uAD81\uAD82\uAD88\uAD89\uAD8C\uAD90\uAD9C\uAD9D\uADA4\uADB7\uADC0\uADC1\uADC4\uADC8\uADD0\uADD1\uADD3\uADDC\uADE0\uADE4\uADF8\uADF9\uADFC\uADFF\uAE00\uAE01\uAE08\uAE09\uAE0B\uAE0D\uAE14\uAE30\uAE31\uAE34\uAE37\uAE38\uAE3A\uAE40\uAE41\uAE43\uAE45\uAE46\uAE4A\uAE4C\uAE4D\uAE4E\uAE50\uAE54\uAE56\uAE5C\uAE5D\uAE5F\uAE60\uAE61\uAE65\uAE68\uAE69\uAE6C\uAE70\uAE78"],
      ["b241", "\uCF6D\uCF6E\uCF6F\uCF72\uCF73\uCF75\uCF76\uCF77\uCF79", 6, "\uCF81\uCF82\uCF83\uCF84\uCF86", 5, "\uCF8D"],
      ["b261", "\uCF8E", 18, "\uCFA2", 5, "\uCFA9"],
      ["b281", "\uCFAA", 5, "\uCFB1", 18, "\uCFC5", 6, "\uAE79\uAE7B\uAE7C\uAE7D\uAE84\uAE85\uAE8C\uAEBC\uAEBD\uAEBE\uAEC0\uAEC4\uAECC\uAECD\uAECF\uAED0\uAED1\uAED8\uAED9\uAEDC\uAEE8\uAEEB\uAEED\uAEF4\uAEF8\uAEFC\uAF07\uAF08\uAF0D\uAF10\uAF2C\uAF2D\uAF30\uAF32\uAF34\uAF3C\uAF3D\uAF3F\uAF41\uAF42\uAF43\uAF48\uAF49\uAF50\uAF5C\uAF5D\uAF64\uAF65\uAF79\uAF80\uAF84\uAF88\uAF90\uAF91\uAF95\uAF9C\uAFB8\uAFB9\uAFBC\uAFC0\uAFC7\uAFC8\uAFC9\uAFCB\uAFCD\uAFCE\uAFD4\uAFDC\uAFE8\uAFE9\uAFF0\uAFF1\uAFF4\uAFF8\uB000\uB001\uB004\uB00C\uB010\uB014\uB01C\uB01D\uB028\uB044\uB045\uB048\uB04A\uB04C\uB04E\uB053\uB054\uB055\uB057\uB059"],
      ["b341", "\uCFCC", 19, "\uCFE2\uCFE3\uCFE5\uCFE6\uCFE7\uCFE9"],
      ["b361", "\uCFEA", 5, "\uCFF2\uCFF4\uCFF6", 5, "\uCFFD\uCFFE\uCFFF\uD001\uD002\uD003\uD005", 5],
      ["b381", "\uD00B", 5, "\uD012", 5, "\uD019", 19, "\uB05D\uB07C\uB07D\uB080\uB084\uB08C\uB08D\uB08F\uB091\uB098\uB099\uB09A\uB09C\uB09F\uB0A0\uB0A1\uB0A2\uB0A8\uB0A9\uB0AB", 4, "\uB0B1\uB0B3\uB0B4\uB0B5\uB0B8\uB0BC\uB0C4\uB0C5\uB0C7\uB0C8\uB0C9\uB0D0\uB0D1\uB0D4\uB0D8\uB0E0\uB0E5\uB108\uB109\uB10B\uB10C\uB110\uB112\uB113\uB118\uB119\uB11B\uB11C\uB11D\uB123\uB124\uB125\uB128\uB12C\uB134\uB135\uB137\uB138\uB139\uB140\uB141\uB144\uB148\uB150\uB151\uB154\uB155\uB158\uB15C\uB160\uB178\uB179\uB17C\uB180\uB182\uB188\uB189\uB18B\uB18D\uB192\uB193\uB194\uB198\uB19C\uB1A8\uB1CC\uB1D0\uB1D4\uB1DC\uB1DD"],
      ["b441", "\uD02E", 5, "\uD036\uD037\uD039\uD03A\uD03B\uD03D", 6, "\uD046\uD048\uD04A", 5],
      ["b461", "\uD051\uD052\uD053\uD055\uD056\uD057\uD059", 6, "\uD061", 10, "\uD06E\uD06F"],
      ["b481", "\uD071\uD072\uD073\uD075", 6, "\uD07E\uD07F\uD080\uD082", 18, "\uB1DF\uB1E8\uB1E9\uB1EC\uB1F0\uB1F9\uB1FB\uB1FD\uB204\uB205\uB208\uB20B\uB20C\uB214\uB215\uB217\uB219\uB220\uB234\uB23C\uB258\uB25C\uB260\uB268\uB269\uB274\uB275\uB27C\uB284\uB285\uB289\uB290\uB291\uB294\uB298\uB299\uB29A\uB2A0\uB2A1\uB2A3\uB2A5\uB2A6\uB2AA\uB2AC\uB2B0\uB2B4\uB2C8\uB2C9\uB2CC\uB2D0\uB2D2\uB2D8\uB2D9\uB2DB\uB2DD\uB2E2\uB2E4\uB2E5\uB2E6\uB2E8\uB2EB", 4, "\uB2F3\uB2F4\uB2F5\uB2F7", 4, "\uB2FF\uB300\uB301\uB304\uB308\uB310\uB311\uB313\uB314\uB315\uB31C\uB354\uB355\uB356\uB358\uB35B\uB35C\uB35E\uB35F\uB364\uB365"],
      ["b541", "\uD095", 14, "\uD0A6\uD0A7\uD0A9\uD0AA\uD0AB\uD0AD", 5],
      ["b561", "\uD0B3\uD0B6\uD0B8\uD0BA", 5, "\uD0C2\uD0C3\uD0C5\uD0C6\uD0C7\uD0CA", 5, "\uD0D2\uD0D6", 4],
      ["b581", "\uD0DB\uD0DE\uD0DF\uD0E1\uD0E2\uD0E3\uD0E5", 6, "\uD0EE\uD0F2", 5, "\uD0F9", 11, "\uB367\uB369\uB36B\uB36E\uB370\uB371\uB374\uB378\uB380\uB381\uB383\uB384\uB385\uB38C\uB390\uB394\uB3A0\uB3A1\uB3A8\uB3AC\uB3C4\uB3C5\uB3C8\uB3CB\uB3CC\uB3CE\uB3D0\uB3D4\uB3D5\uB3D7\uB3D9\uB3DB\uB3DD\uB3E0\uB3E4\uB3E8\uB3FC\uB410\uB418\uB41C\uB420\uB428\uB429\uB42B\uB434\uB450\uB451\uB454\uB458\uB460\uB461\uB463\uB465\uB46C\uB480\uB488\uB49D\uB4A4\uB4A8\uB4AC\uB4B5\uB4B7\uB4B9\uB4C0\uB4C4\uB4C8\uB4D0\uB4D5\uB4DC\uB4DD\uB4E0\uB4E3\uB4E4\uB4E6\uB4EC\uB4ED\uB4EF\uB4F1\uB4F8\uB514\uB515\uB518\uB51B\uB51C\uB524\uB525\uB527\uB528\uB529\uB52A\uB530\uB531\uB534\uB538"],
      ["b641", "\uD105", 7, "\uD10E", 17],
      ["b661", "\uD120", 15, "\uD132\uD133\uD135\uD136\uD137\uD139\uD13B\uD13C\uD13D\uD13E"],
      ["b681", "\uD13F\uD142\uD146", 5, "\uD14E\uD14F\uD151\uD152\uD153\uD155", 6, "\uD15E\uD160\uD162", 5, "\uD169\uD16A\uD16B\uD16D\uB540\uB541\uB543\uB544\uB545\uB54B\uB54C\uB54D\uB550\uB554\uB55C\uB55D\uB55F\uB560\uB561\uB5A0\uB5A1\uB5A4\uB5A8\uB5AA\uB5AB\uB5B0\uB5B1\uB5B3\uB5B4\uB5B5\uB5BB\uB5BC\uB5BD\uB5C0\uB5C4\uB5CC\uB5CD\uB5CF\uB5D0\uB5D1\uB5D8\uB5EC\uB610\uB611\uB614\uB618\uB625\uB62C\uB634\uB648\uB664\uB668\uB69C\uB69D\uB6A0\uB6A4\uB6AB\uB6AC\uB6B1\uB6D4\uB6F0\uB6F4\uB6F8\uB700\uB701\uB705\uB728\uB729\uB72C\uB72F\uB730\uB738\uB739\uB73B\uB744\uB748\uB74C\uB754\uB755\uB760\uB764\uB768\uB770\uB771\uB773\uB775\uB77C\uB77D\uB780\uB784\uB78C\uB78D\uB78F\uB790\uB791\uB792\uB796\uB797"],
      ["b741", "\uD16E", 13, "\uD17D", 6, "\uD185\uD186\uD187\uD189\uD18A"],
      ["b761", "\uD18B", 20, "\uD1A2\uD1A3\uD1A5\uD1A6\uD1A7"],
      ["b781", "\uD1A9", 6, "\uD1B2\uD1B4\uD1B6\uD1B7\uD1B8\uD1B9\uD1BB\uD1BD\uD1BE\uD1BF\uD1C1", 14, "\uB798\uB799\uB79C\uB7A0\uB7A8\uB7A9\uB7AB\uB7AC\uB7AD\uB7B4\uB7B5\uB7B8\uB7C7\uB7C9\uB7EC\uB7ED\uB7F0\uB7F4\uB7FC\uB7FD\uB7FF\uB800\uB801\uB807\uB808\uB809\uB80C\uB810\uB818\uB819\uB81B\uB81D\uB824\uB825\uB828\uB82C\uB834\uB835\uB837\uB838\uB839\uB840\uB844\uB851\uB853\uB85C\uB85D\uB860\uB864\uB86C\uB86D\uB86F\uB871\uB878\uB87C\uB88D\uB8A8\uB8B0\uB8B4\uB8B8\uB8C0\uB8C1\uB8C3\uB8C5\uB8CC\uB8D0\uB8D4\uB8DD\uB8DF\uB8E1\uB8E8\uB8E9\uB8EC\uB8F0\uB8F8\uB8F9\uB8FB\uB8FD\uB904\uB918\uB920\uB93C\uB93D\uB940\uB944\uB94C\uB94F\uB951\uB958\uB959\uB95C\uB960\uB968\uB969"],
      ["b841", "\uD1D0", 7, "\uD1D9", 17],
      ["b861", "\uD1EB", 8, "\uD1F5\uD1F6\uD1F7\uD1F9", 13],
      ["b881", "\uD208\uD20A", 5, "\uD211", 24, "\uB96B\uB96D\uB974\uB975\uB978\uB97C\uB984\uB985\uB987\uB989\uB98A\uB98D\uB98E\uB9AC\uB9AD\uB9B0\uB9B4\uB9BC\uB9BD\uB9BF\uB9C1\uB9C8\uB9C9\uB9CC\uB9CE", 4, "\uB9D8\uB9D9\uB9DB\uB9DD\uB9DE\uB9E1\uB9E3\uB9E4\uB9E5\uB9E8\uB9EC\uB9F4\uB9F5\uB9F7\uB9F8\uB9F9\uB9FA\uBA00\uBA01\uBA08\uBA15\uBA38\uBA39\uBA3C\uBA40\uBA42\uBA48\uBA49\uBA4B\uBA4D\uBA4E\uBA53\uBA54\uBA55\uBA58\uBA5C\uBA64\uBA65\uBA67\uBA68\uBA69\uBA70\uBA71\uBA74\uBA78\uBA83\uBA84\uBA85\uBA87\uBA8C\uBAA8\uBAA9\uBAAB\uBAAC\uBAB0\uBAB2\uBAB8\uBAB9\uBABB\uBABD\uBAC4\uBAC8\uBAD8\uBAD9\uBAFC"],
      ["b941", "\uD22A\uD22B\uD22E\uD22F\uD231\uD232\uD233\uD235", 6, "\uD23E\uD240\uD242", 5, "\uD249\uD24A\uD24B\uD24C"],
      ["b961", "\uD24D", 14, "\uD25D", 6, "\uD265\uD266\uD267\uD268"],
      ["b981", "\uD269", 22, "\uD282\uD283\uD285\uD286\uD287\uD289\uD28A\uD28B\uD28C\uBB00\uBB04\uBB0D\uBB0F\uBB11\uBB18\uBB1C\uBB20\uBB29\uBB2B\uBB34\uBB35\uBB36\uBB38\uBB3B\uBB3C\uBB3D\uBB3E\uBB44\uBB45\uBB47\uBB49\uBB4D\uBB4F\uBB50\uBB54\uBB58\uBB61\uBB63\uBB6C\uBB88\uBB8C\uBB90\uBBA4\uBBA8\uBBAC\uBBB4\uBBB7\uBBC0\uBBC4\uBBC8\uBBD0\uBBD3\uBBF8\uBBF9\uBBFC\uBBFF\uBC00\uBC02\uBC08\uBC09\uBC0B\uBC0C\uBC0D\uBC0F\uBC11\uBC14", 4, "\uBC1B", 4, "\uBC24\uBC25\uBC27\uBC29\uBC2D\uBC30\uBC31\uBC34\uBC38\uBC40\uBC41\uBC43\uBC44\uBC45\uBC49\uBC4C\uBC4D\uBC50\uBC5D\uBC84\uBC85\uBC88\uBC8B\uBC8C\uBC8E\uBC94\uBC95\uBC97"],
      ["ba41", "\uD28D\uD28E\uD28F\uD292\uD293\uD294\uD296", 5, "\uD29D\uD29E\uD29F\uD2A1\uD2A2\uD2A3\uD2A5", 6, "\uD2AD"],
      ["ba61", "\uD2AE\uD2AF\uD2B0\uD2B2", 5, "\uD2BA\uD2BB\uD2BD\uD2BE\uD2C1\uD2C3", 4, "\uD2CA\uD2CC", 5],
      ["ba81", "\uD2D2\uD2D3\uD2D5\uD2D6\uD2D7\uD2D9\uD2DA\uD2DB\uD2DD", 6, "\uD2E6", 9, "\uD2F2\uD2F3\uD2F5\uD2F6\uD2F7\uD2F9\uD2FA\uBC99\uBC9A\uBCA0\uBCA1\uBCA4\uBCA7\uBCA8\uBCB0\uBCB1\uBCB3\uBCB4\uBCB5\uBCBC\uBCBD\uBCC0\uBCC4\uBCCD\uBCCF\uBCD0\uBCD1\uBCD5\uBCD8\uBCDC\uBCF4\uBCF5\uBCF6\uBCF8\uBCFC\uBD04\uBD05\uBD07\uBD09\uBD10\uBD14\uBD24\uBD2C\uBD40\uBD48\uBD49\uBD4C\uBD50\uBD58\uBD59\uBD64\uBD68\uBD80\uBD81\uBD84\uBD87\uBD88\uBD89\uBD8A\uBD90\uBD91\uBD93\uBD95\uBD99\uBD9A\uBD9C\uBDA4\uBDB0\uBDB8\uBDD4\uBDD5\uBDD8\uBDDC\uBDE9\uBDF0\uBDF4\uBDF8\uBE00\uBE03\uBE05\uBE0C\uBE0D\uBE10\uBE14\uBE1C\uBE1D\uBE1F\uBE44\uBE45\uBE48\uBE4C\uBE4E\uBE54\uBE55\uBE57\uBE59\uBE5A\uBE5B\uBE60\uBE61\uBE64"],
      ["bb41", "\uD2FB", 4, "\uD302\uD304\uD306", 5, "\uD30F\uD311\uD312\uD313\uD315\uD317", 4, "\uD31E\uD322\uD323"],
      ["bb61", "\uD324\uD326\uD327\uD32A\uD32B\uD32D\uD32E\uD32F\uD331", 6, "\uD33A\uD33E", 5, "\uD346\uD347\uD348\uD349"],
      ["bb81", "\uD34A", 31, "\uBE68\uBE6A\uBE70\uBE71\uBE73\uBE74\uBE75\uBE7B\uBE7C\uBE7D\uBE80\uBE84\uBE8C\uBE8D\uBE8F\uBE90\uBE91\uBE98\uBE99\uBEA8\uBED0\uBED1\uBED4\uBED7\uBED8\uBEE0\uBEE3\uBEE4\uBEE5\uBEEC\uBF01\uBF08\uBF09\uBF18\uBF19\uBF1B\uBF1C\uBF1D\uBF40\uBF41\uBF44\uBF48\uBF50\uBF51\uBF55\uBF94\uBFB0\uBFC5\uBFCC\uBFCD\uBFD0\uBFD4\uBFDC\uBFDF\uBFE1\uC03C\uC051\uC058\uC05C\uC060\uC068\uC069\uC090\uC091\uC094\uC098\uC0A0\uC0A1\uC0A3\uC0A5\uC0AC\uC0AD\uC0AF\uC0B0\uC0B3\uC0B4\uC0B5\uC0B6\uC0BC\uC0BD\uC0BF\uC0C0\uC0C1\uC0C5\uC0C8\uC0C9\uC0CC\uC0D0\uC0D8\uC0D9\uC0DB\uC0DC\uC0DD\uC0E4"],
      ["bc41", "\uD36A", 17, "\uD37E\uD37F\uD381\uD382\uD383\uD385\uD386\uD387"],
      ["bc61", "\uD388\uD389\uD38A\uD38B\uD38E\uD392", 5, "\uD39A\uD39B\uD39D\uD39E\uD39F\uD3A1", 6, "\uD3AA\uD3AC\uD3AE"],
      ["bc81", "\uD3AF", 4, "\uD3B5\uD3B6\uD3B7\uD3B9\uD3BA\uD3BB\uD3BD", 6, "\uD3C6\uD3C7\uD3CA", 5, "\uD3D1", 5, "\uC0E5\uC0E8\uC0EC\uC0F4\uC0F5\uC0F7\uC0F9\uC100\uC104\uC108\uC110\uC115\uC11C", 4, "\uC123\uC124\uC126\uC127\uC12C\uC12D\uC12F\uC130\uC131\uC136\uC138\uC139\uC13C\uC140\uC148\uC149\uC14B\uC14C\uC14D\uC154\uC155\uC158\uC15C\uC164\uC165\uC167\uC168\uC169\uC170\uC174\uC178\uC185\uC18C\uC18D\uC18E\uC190\uC194\uC196\uC19C\uC19D\uC19F\uC1A1\uC1A5\uC1A8\uC1A9\uC1AC\uC1B0\uC1BD\uC1C4\uC1C8\uC1CC\uC1D4\uC1D7\uC1D8\uC1E0\uC1E4\uC1E8\uC1F0\uC1F1\uC1F3\uC1FC\uC1FD\uC200\uC204\uC20C\uC20D\uC20F\uC211\uC218\uC219\uC21C\uC21F\uC220\uC228\uC229\uC22B\uC22D"],
      ["bd41", "\uD3D7\uD3D9", 7, "\uD3E2\uD3E4", 7, "\uD3EE\uD3EF\uD3F1\uD3F2\uD3F3\uD3F5\uD3F6\uD3F7"],
      ["bd61", "\uD3F8\uD3F9\uD3FA\uD3FB\uD3FE\uD400\uD402", 5, "\uD409", 13],
      ["bd81", "\uD417", 5, "\uD41E", 25, "\uC22F\uC231\uC232\uC234\uC248\uC250\uC251\uC254\uC258\uC260\uC265\uC26C\uC26D\uC270\uC274\uC27C\uC27D\uC27F\uC281\uC288\uC289\uC290\uC298\uC29B\uC29D\uC2A4\uC2A5\uC2A8\uC2AC\uC2AD\uC2B4\uC2B5\uC2B7\uC2B9\uC2DC\uC2DD\uC2E0\uC2E3\uC2E4\uC2EB\uC2EC\uC2ED\uC2EF\uC2F1\uC2F6\uC2F8\uC2F9\uC2FB\uC2FC\uC300\uC308\uC309\uC30C\uC30D\uC313\uC314\uC315\uC318\uC31C\uC324\uC325\uC328\uC329\uC345\uC368\uC369\uC36C\uC370\uC372\uC378\uC379\uC37C\uC37D\uC384\uC388\uC38C\uC3C0\uC3D8\uC3D9\uC3DC\uC3DF\uC3E0\uC3E2\uC3E8\uC3E9\uC3ED\uC3F4\uC3F5\uC3F8\uC408\uC410\uC424\uC42C\uC430"],
      ["be41", "\uD438", 7, "\uD441\uD442\uD443\uD445", 14],
      ["be61", "\uD454", 7, "\uD45D\uD45E\uD45F\uD461\uD462\uD463\uD465", 7, "\uD46E\uD470\uD471\uD472"],
      ["be81", "\uD473", 4, "\uD47A\uD47B\uD47D\uD47E\uD481\uD483", 4, "\uD48A\uD48C\uD48E", 5, "\uD495", 8, "\uC434\uC43C\uC43D\uC448\uC464\uC465\uC468\uC46C\uC474\uC475\uC479\uC480\uC494\uC49C\uC4B8\uC4BC\uC4E9\uC4F0\uC4F1\uC4F4\uC4F8\uC4FA\uC4FF\uC500\uC501\uC50C\uC510\uC514\uC51C\uC528\uC529\uC52C\uC530\uC538\uC539\uC53B\uC53D\uC544\uC545\uC548\uC549\uC54A\uC54C\uC54D\uC54E\uC553\uC554\uC555\uC557\uC558\uC559\uC55D\uC55E\uC560\uC561\uC564\uC568\uC570\uC571\uC573\uC574\uC575\uC57C\uC57D\uC580\uC584\uC587\uC58C\uC58D\uC58F\uC591\uC595\uC597\uC598\uC59C\uC5A0\uC5A9\uC5B4\uC5B5\uC5B8\uC5B9\uC5BB\uC5BC\uC5BD\uC5BE\uC5C4", 6, "\uC5CC\uC5CE"],
      ["bf41", "\uD49E", 10, "\uD4AA", 14],
      ["bf61", "\uD4B9", 18, "\uD4CD\uD4CE\uD4CF\uD4D1\uD4D2\uD4D3\uD4D5"],
      ["bf81", "\uD4D6", 5, "\uD4DD\uD4DE\uD4E0", 7, "\uD4E9\uD4EA\uD4EB\uD4ED\uD4EE\uD4EF\uD4F1", 6, "\uD4F9\uD4FA\uD4FC\uC5D0\uC5D1\uC5D4\uC5D8\uC5E0\uC5E1\uC5E3\uC5E5\uC5EC\uC5ED\uC5EE\uC5F0\uC5F4\uC5F6\uC5F7\uC5FC", 5, "\uC605\uC606\uC607\uC608\uC60C\uC610\uC618\uC619\uC61B\uC61C\uC624\uC625\uC628\uC62C\uC62D\uC62E\uC630\uC633\uC634\uC635\uC637\uC639\uC63B\uC640\uC641\uC644\uC648\uC650\uC651\uC653\uC654\uC655\uC65C\uC65D\uC660\uC66C\uC66F\uC671\uC678\uC679\uC67C\uC680\uC688\uC689\uC68B\uC68D\uC694\uC695\uC698\uC69C\uC6A4\uC6A5\uC6A7\uC6A9\uC6B0\uC6B1\uC6B4\uC6B8\uC6B9\uC6BA\uC6C0\uC6C1\uC6C3\uC6C5\uC6CC\uC6CD\uC6D0\uC6D4\uC6DC\uC6DD\uC6E0\uC6E1\uC6E8"],
      ["c041", "\uD4FE", 5, "\uD505\uD506\uD507\uD509\uD50A\uD50B\uD50D", 6, "\uD516\uD518", 5],
      ["c061", "\uD51E", 25],
      ["c081", "\uD538\uD539\uD53A\uD53B\uD53E\uD53F\uD541\uD542\uD543\uD545", 6, "\uD54E\uD550\uD552", 5, "\uD55A\uD55B\uD55D\uD55E\uD55F\uD561\uD562\uD563\uC6E9\uC6EC\uC6F0\uC6F8\uC6F9\uC6FD\uC704\uC705\uC708\uC70C\uC714\uC715\uC717\uC719\uC720\uC721\uC724\uC728\uC730\uC731\uC733\uC735\uC737\uC73C\uC73D\uC740\uC744\uC74A\uC74C\uC74D\uC74F\uC751", 7, "\uC75C\uC760\uC768\uC76B\uC774\uC775\uC778\uC77C\uC77D\uC77E\uC783\uC784\uC785\uC787\uC788\uC789\uC78A\uC78E\uC790\uC791\uC794\uC796\uC797\uC798\uC79A\uC7A0\uC7A1\uC7A3\uC7A4\uC7A5\uC7A6\uC7AC\uC7AD\uC7B0\uC7B4\uC7BC\uC7BD\uC7BF\uC7C0\uC7C1\uC7C8\uC7C9\uC7CC\uC7CE\uC7D0\uC7D8\uC7DD\uC7E4\uC7E8\uC7EC\uC800\uC801\uC804\uC808\uC80A"],
      ["c141", "\uD564\uD566\uD567\uD56A\uD56C\uD56E", 5, "\uD576\uD577\uD579\uD57A\uD57B\uD57D", 6, "\uD586\uD58A\uD58B"],
      ["c161", "\uD58C\uD58D\uD58E\uD58F\uD591", 19, "\uD5A6\uD5A7"],
      ["c181", "\uD5A8", 31, "\uC810\uC811\uC813\uC815\uC816\uC81C\uC81D\uC820\uC824\uC82C\uC82D\uC82F\uC831\uC838\uC83C\uC840\uC848\uC849\uC84C\uC84D\uC854\uC870\uC871\uC874\uC878\uC87A\uC880\uC881\uC883\uC885\uC886\uC887\uC88B\uC88C\uC88D\uC894\uC89D\uC89F\uC8A1\uC8A8\uC8BC\uC8BD\uC8C4\uC8C8\uC8CC\uC8D4\uC8D5\uC8D7\uC8D9\uC8E0\uC8E1\uC8E4\uC8F5\uC8FC\uC8FD\uC900\uC904\uC905\uC906\uC90C\uC90D\uC90F\uC911\uC918\uC92C\uC934\uC950\uC951\uC954\uC958\uC960\uC961\uC963\uC96C\uC970\uC974\uC97C\uC988\uC989\uC98C\uC990\uC998\uC999\uC99B\uC99D\uC9C0\uC9C1\uC9C4\uC9C7\uC9C8\uC9CA\uC9D0\uC9D1\uC9D3"],
      ["c241", "\uD5CA\uD5CB\uD5CD\uD5CE\uD5CF\uD5D1\uD5D3", 4, "\uD5DA\uD5DC\uD5DE", 5, "\uD5E6\uD5E7\uD5E9\uD5EA\uD5EB\uD5ED\uD5EE"],
      ["c261", "\uD5EF", 4, "\uD5F6\uD5F8\uD5FA", 5, "\uD602\uD603\uD605\uD606\uD607\uD609", 6, "\uD612"],
      ["c281", "\uD616", 5, "\uD61D\uD61E\uD61F\uD621\uD622\uD623\uD625", 7, "\uD62E", 9, "\uD63A\uD63B\uC9D5\uC9D6\uC9D9\uC9DA\uC9DC\uC9DD\uC9E0\uC9E2\uC9E4\uC9E7\uC9EC\uC9ED\uC9EF\uC9F0\uC9F1\uC9F8\uC9F9\uC9FC\uCA00\uCA08\uCA09\uCA0B\uCA0C\uCA0D\uCA14\uCA18\uCA29\uCA4C\uCA4D\uCA50\uCA54\uCA5C\uCA5D\uCA5F\uCA60\uCA61\uCA68\uCA7D\uCA84\uCA98\uCABC\uCABD\uCAC0\uCAC4\uCACC\uCACD\uCACF\uCAD1\uCAD3\uCAD8\uCAD9\uCAE0\uCAEC\uCAF4\uCB08\uCB10\uCB14\uCB18\uCB20\uCB21\uCB41\uCB48\uCB49\uCB4C\uCB50\uCB58\uCB59\uCB5D\uCB64\uCB78\uCB79\uCB9C\uCBB8\uCBD4\uCBE4\uCBE7\uCBE9\uCC0C\uCC0D\uCC10\uCC14\uCC1C\uCC1D\uCC21\uCC22\uCC27\uCC28\uCC29\uCC2C\uCC2E\uCC30\uCC38\uCC39\uCC3B"],
      ["c341", "\uD63D\uD63E\uD63F\uD641\uD642\uD643\uD644\uD646\uD647\uD64A\uD64C\uD64E\uD64F\uD650\uD652\uD653\uD656\uD657\uD659\uD65A\uD65B\uD65D", 4],
      ["c361", "\uD662", 4, "\uD668\uD66A", 5, "\uD672\uD673\uD675", 11],
      ["c381", "\uD681\uD682\uD684\uD686", 5, "\uD68E\uD68F\uD691\uD692\uD693\uD695", 7, "\uD69E\uD6A0\uD6A2", 5, "\uD6A9\uD6AA\uCC3C\uCC3D\uCC3E\uCC44\uCC45\uCC48\uCC4C\uCC54\uCC55\uCC57\uCC58\uCC59\uCC60\uCC64\uCC66\uCC68\uCC70\uCC75\uCC98\uCC99\uCC9C\uCCA0\uCCA8\uCCA9\uCCAB\uCCAC\uCCAD\uCCB4\uCCB5\uCCB8\uCCBC\uCCC4\uCCC5\uCCC7\uCCC9\uCCD0\uCCD4\uCCE4\uCCEC\uCCF0\uCD01\uCD08\uCD09\uCD0C\uCD10\uCD18\uCD19\uCD1B\uCD1D\uCD24\uCD28\uCD2C\uCD39\uCD5C\uCD60\uCD64\uCD6C\uCD6D\uCD6F\uCD71\uCD78\uCD88\uCD94\uCD95\uCD98\uCD9C\uCDA4\uCDA5\uCDA7\uCDA9\uCDB0\uCDC4\uCDCC\uCDD0\uCDE8\uCDEC\uCDF0\uCDF8\uCDF9\uCDFB\uCDFD\uCE04\uCE08\uCE0C\uCE14\uCE19\uCE20\uCE21\uCE24\uCE28\uCE30\uCE31\uCE33\uCE35"],
      ["c441", "\uD6AB\uD6AD\uD6AE\uD6AF\uD6B1", 7, "\uD6BA\uD6BC", 7, "\uD6C6\uD6C7\uD6C9\uD6CA\uD6CB"],
      ["c461", "\uD6CD\uD6CE\uD6CF\uD6D0\uD6D2\uD6D3\uD6D5\uD6D6\uD6D8\uD6DA", 5, "\uD6E1\uD6E2\uD6E3\uD6E5\uD6E6\uD6E7\uD6E9", 4],
      ["c481", "\uD6EE\uD6EF\uD6F1\uD6F2\uD6F3\uD6F4\uD6F6", 5, "\uD6FE\uD6FF\uD701\uD702\uD703\uD705", 11, "\uD712\uD713\uD714\uCE58\uCE59\uCE5C\uCE5F\uCE60\uCE61\uCE68\uCE69\uCE6B\uCE6D\uCE74\uCE75\uCE78\uCE7C\uCE84\uCE85\uCE87\uCE89\uCE90\uCE91\uCE94\uCE98\uCEA0\uCEA1\uCEA3\uCEA4\uCEA5\uCEAC\uCEAD\uCEC1\uCEE4\uCEE5\uCEE8\uCEEB\uCEEC\uCEF4\uCEF5\uCEF7\uCEF8\uCEF9\uCF00\uCF01\uCF04\uCF08\uCF10\uCF11\uCF13\uCF15\uCF1C\uCF20\uCF24\uCF2C\uCF2D\uCF2F\uCF30\uCF31\uCF38\uCF54\uCF55\uCF58\uCF5C\uCF64\uCF65\uCF67\uCF69\uCF70\uCF71\uCF74\uCF78\uCF80\uCF85\uCF8C\uCFA1\uCFA8\uCFB0\uCFC4\uCFE0\uCFE1\uCFE4\uCFE8\uCFF0\uCFF1\uCFF3\uCFF5\uCFFC\uD000\uD004\uD011\uD018\uD02D\uD034\uD035\uD038\uD03C"],
      ["c541", "\uD715\uD716\uD717\uD71A\uD71B\uD71D\uD71E\uD71F\uD721", 6, "\uD72A\uD72C\uD72E", 5, "\uD736\uD737\uD739"],
      ["c561", "\uD73A\uD73B\uD73D", 6, "\uD745\uD746\uD748\uD74A", 5, "\uD752\uD753\uD755\uD75A", 4],
      ["c581", "\uD75F\uD762\uD764\uD766\uD767\uD768\uD76A\uD76B\uD76D\uD76E\uD76F\uD771\uD772\uD773\uD775", 6, "\uD77E\uD77F\uD780\uD782", 5, "\uD78A\uD78B\uD044\uD045\uD047\uD049\uD050\uD054\uD058\uD060\uD06C\uD06D\uD070\uD074\uD07C\uD07D\uD081\uD0A4\uD0A5\uD0A8\uD0AC\uD0B4\uD0B5\uD0B7\uD0B9\uD0C0\uD0C1\uD0C4\uD0C8\uD0C9\uD0D0\uD0D1\uD0D3\uD0D4\uD0D5\uD0DC\uD0DD\uD0E0\uD0E4\uD0EC\uD0ED\uD0EF\uD0F0\uD0F1\uD0F8\uD10D\uD130\uD131\uD134\uD138\uD13A\uD140\uD141\uD143\uD144\uD145\uD14C\uD14D\uD150\uD154\uD15C\uD15D\uD15F\uD161\uD168\uD16C\uD17C\uD184\uD188\uD1A0\uD1A1\uD1A4\uD1A8\uD1B0\uD1B1\uD1B3\uD1B5\uD1BA\uD1BC\uD1C0\uD1D8\uD1F4\uD1F8\uD207\uD209\uD210\uD22C\uD22D\uD230\uD234\uD23C\uD23D\uD23F\uD241\uD248\uD25C"],
      ["c641", "\uD78D\uD78E\uD78F\uD791", 6, "\uD79A\uD79C\uD79E", 5],
      ["c6a1", "\uD264\uD280\uD281\uD284\uD288\uD290\uD291\uD295\uD29C\uD2A0\uD2A4\uD2AC\uD2B1\uD2B8\uD2B9\uD2BC\uD2BF\uD2C0\uD2C2\uD2C8\uD2C9\uD2CB\uD2D4\uD2D8\uD2DC\uD2E4\uD2E5\uD2F0\uD2F1\uD2F4\uD2F8\uD300\uD301\uD303\uD305\uD30C\uD30D\uD30E\uD310\uD314\uD316\uD31C\uD31D\uD31F\uD320\uD321\uD325\uD328\uD329\uD32C\uD330\uD338\uD339\uD33B\uD33C\uD33D\uD344\uD345\uD37C\uD37D\uD380\uD384\uD38C\uD38D\uD38F\uD390\uD391\uD398\uD399\uD39C\uD3A0\uD3A8\uD3A9\uD3AB\uD3AD\uD3B4\uD3B8\uD3BC\uD3C4\uD3C5\uD3C8\uD3C9\uD3D0\uD3D8\uD3E1\uD3E3\uD3EC\uD3ED\uD3F0\uD3F4\uD3FC\uD3FD\uD3FF\uD401"],
      ["c7a1", "\uD408\uD41D\uD440\uD444\uD45C\uD460\uD464\uD46D\uD46F\uD478\uD479\uD47C\uD47F\uD480\uD482\uD488\uD489\uD48B\uD48D\uD494\uD4A9\uD4CC\uD4D0\uD4D4\uD4DC\uD4DF\uD4E8\uD4EC\uD4F0\uD4F8\uD4FB\uD4FD\uD504\uD508\uD50C\uD514\uD515\uD517\uD53C\uD53D\uD540\uD544\uD54C\uD54D\uD54F\uD551\uD558\uD559\uD55C\uD560\uD565\uD568\uD569\uD56B\uD56D\uD574\uD575\uD578\uD57C\uD584\uD585\uD587\uD588\uD589\uD590\uD5A5\uD5C8\uD5C9\uD5CC\uD5D0\uD5D2\uD5D8\uD5D9\uD5DB\uD5DD\uD5E4\uD5E5\uD5E8\uD5EC\uD5F4\uD5F5\uD5F7\uD5F9\uD600\uD601\uD604\uD608\uD610\uD611\uD613\uD614\uD615\uD61C\uD620"],
      ["c8a1", "\uD624\uD62D\uD638\uD639\uD63C\uD640\uD645\uD648\uD649\uD64B\uD64D\uD651\uD654\uD655\uD658\uD65C\uD667\uD669\uD670\uD671\uD674\uD683\uD685\uD68C\uD68D\uD690\uD694\uD69D\uD69F\uD6A1\uD6A8\uD6AC\uD6B0\uD6B9\uD6BB\uD6C4\uD6C5\uD6C8\uD6CC\uD6D1\uD6D4\uD6D7\uD6D9\uD6E0\uD6E4\uD6E8\uD6F0\uD6F5\uD6FC\uD6FD\uD700\uD704\uD711\uD718\uD719\uD71C\uD720\uD728\uD729\uD72B\uD72D\uD734\uD735\uD738\uD73C\uD744\uD747\uD749\uD750\uD751\uD754\uD756\uD757\uD758\uD759\uD760\uD761\uD763\uD765\uD769\uD76C\uD770\uD774\uD77C\uD77D\uD781\uD788\uD789\uD78C\uD790\uD798\uD799\uD79B\uD79D"],
      ["caa1", "\u4F3D\u4F73\u5047\u50F9\u52A0\u53EF\u5475\u54E5\u5609\u5AC1\u5BB6\u6687\u67B6\u67B7\u67EF\u6B4C\u73C2\u75C2\u7A3C\u82DB\u8304\u8857\u8888\u8A36\u8CC8\u8DCF\u8EFB\u8FE6\u99D5\u523B\u5374\u5404\u606A\u6164\u6BBC\u73CF\u811A\u89BA\u89D2\u95A3\u4F83\u520A\u58BE\u5978\u59E6\u5E72\u5E79\u61C7\u63C0\u6746\u67EC\u687F\u6F97\u764E\u770B\u78F5\u7A08\u7AFF\u7C21\u809D\u826E\u8271\u8AEB\u9593\u4E6B\u559D\u66F7\u6E34\u78A3\u7AED\u845B\u8910\u874E\u97A8\u52D8\u574E\u582A\u5D4C\u611F\u61BE\u6221\u6562\u67D1\u6A44\u6E1B\u7518\u75B3\u76E3\u77B0\u7D3A\u90AF\u9451\u9452\u9F95"],
      ["cba1", "\u5323\u5CAC\u7532\u80DB\u9240\u9598\u525B\u5808\u59DC\u5CA1\u5D17\u5EB7\u5F3A\u5F4A\u6177\u6C5F\u757A\u7586\u7CE0\u7D73\u7DB1\u7F8C\u8154\u8221\u8591\u8941\u8B1B\u92FC\u964D\u9C47\u4ECB\u4EF7\u500B\u51F1\u584F\u6137\u613E\u6168\u6539\u69EA\u6F11\u75A5\u7686\u76D6\u7B87\u82A5\u84CB\uF900\u93A7\u958B\u5580\u5BA2\u5751\uF901\u7CB3\u7FB9\u91B5\u5028\u53BB\u5C45\u5DE8\u62D2\u636E\u64DA\u64E7\u6E20\u70AC\u795B\u8DDD\u8E1E\uF902\u907D\u9245\u92F8\u4E7E\u4EF6\u5065\u5DFE\u5EFA\u6106\u6957\u8171\u8654\u8E47\u9375\u9A2B\u4E5E\u5091\u6770\u6840\u5109\u528D\u5292\u6AA2"],
      ["cca1", "\u77BC\u9210\u9ED4\u52AB\u602F\u8FF2\u5048\u61A9\u63ED\u64CA\u683C\u6A84\u6FC0\u8188\u89A1\u9694\u5805\u727D\u72AC\u7504\u7D79\u7E6D\u80A9\u898B\u8B74\u9063\u9D51\u6289\u6C7A\u6F54\u7D50\u7F3A\u8A23\u517C\u614A\u7B9D\u8B19\u9257\u938C\u4EAC\u4FD3\u501E\u50BE\u5106\u52C1\u52CD\u537F\u5770\u5883\u5E9A\u5F91\u6176\u61AC\u64CE\u656C\u666F\u66BB\u66F4\u6897\u6D87\u7085\u70F1\u749F\u74A5\u74CA\u75D9\u786C\u78EC\u7ADF\u7AF6\u7D45\u7D93\u8015\u803F\u811B\u8396\u8B66\u8F15\u9015\u93E1\u9803\u9838\u9A5A\u9BE8\u4FC2\u5553\u583A\u5951\u5B63\u5C46\u60B8\u6212\u6842\u68B0"],
      ["cda1", "\u68E8\u6EAA\u754C\u7678\u78CE\u7A3D\u7CFB\u7E6B\u7E7C\u8A08\u8AA1\u8C3F\u968E\u9DC4\u53E4\u53E9\u544A\u5471\u56FA\u59D1\u5B64\u5C3B\u5EAB\u62F7\u6537\u6545\u6572\u66A0\u67AF\u69C1\u6CBD\u75FC\u7690\u777E\u7A3F\u7F94\u8003\u80A1\u818F\u82E6\u82FD\u83F0\u85C1\u8831\u88B4\u8AA5\uF903\u8F9C\u932E\u96C7\u9867\u9AD8\u9F13\u54ED\u659B\u66F2\u688F\u7A40\u8C37\u9D60\u56F0\u5764\u5D11\u6606\u68B1\u68CD\u6EFE\u7428\u889E\u9BE4\u6C68\uF904\u9AA8\u4F9B\u516C\u5171\u529F\u5B54\u5DE5\u6050\u606D\u62F1\u63A7\u653B\u73D9\u7A7A\u86A3\u8CA2\u978F\u4E32\u5BE1\u6208\u679C\u74DC"],
      ["cea1", "\u79D1\u83D3\u8A87\u8AB2\u8DE8\u904E\u934B\u9846\u5ED3\u69E8\u85FF\u90ED\uF905\u51A0\u5B98\u5BEC\u6163\u68FA\u6B3E\u704C\u742F\u74D8\u7BA1\u7F50\u83C5\u89C0\u8CAB\u95DC\u9928\u522E\u605D\u62EC\u9002\u4F8A\u5149\u5321\u58D9\u5EE3\u66E0\u6D38\u709A\u72C2\u73D6\u7B50\u80F1\u945B\u5366\u639B\u7F6B\u4E56\u5080\u584A\u58DE\u602A\u6127\u62D0\u69D0\u9B41\u5B8F\u7D18\u80B1\u8F5F\u4EA4\u50D1\u54AC\u55AC\u5B0C\u5DA0\u5DE7\u652A\u654E\u6821\u6A4B\u72E1\u768E\u77EF\u7D5E\u7FF9\u81A0\u854E\u86DF\u8F03\u8F4E\u90CA\u9903\u9A55\u9BAB\u4E18\u4E45\u4E5D\u4EC7\u4FF1\u5177\u52FE"],
      ["cfa1", "\u5340\u53E3\u53E5\u548E\u5614\u5775\u57A2\u5BC7\u5D87\u5ED0\u61FC\u62D8\u6551\u67B8\u67E9\u69CB\u6B50\u6BC6\u6BEC\u6C42\u6E9D\u7078\u72D7\u7396\u7403\u77BF\u77E9\u7A76\u7D7F\u8009\u81FC\u8205\u820A\u82DF\u8862\u8B33\u8CFC\u8EC0\u9011\u90B1\u9264\u92B6\u99D2\u9A45\u9CE9\u9DD7\u9F9C\u570B\u5C40\u83CA\u97A0\u97AB\u9EB4\u541B\u7A98\u7FA4\u88D9\u8ECD\u90E1\u5800\u5C48\u6398\u7A9F\u5BAE\u5F13\u7A79\u7AAE\u828E\u8EAC\u5026\u5238\u52F8\u5377\u5708\u62F3\u6372\u6B0A\u6DC3\u7737\u53A5\u7357\u8568\u8E76\u95D5\u673A\u6AC3\u6F70\u8A6D\u8ECC\u994B\uF906\u6677\u6B78\u8CB4"],
      ["d0a1", "\u9B3C\uF907\u53EB\u572D\u594E\u63C6\u69FB\u73EA\u7845\u7ABA\u7AC5\u7CFE\u8475\u898F\u8D73\u9035\u95A8\u52FB\u5747\u7547\u7B60\u83CC\u921E\uF908\u6A58\u514B\u524B\u5287\u621F\u68D8\u6975\u9699\u50C5\u52A4\u52E4\u61C3\u65A4\u6839\u69FF\u747E\u7B4B\u82B9\u83EB\u89B2\u8B39\u8FD1\u9949\uF909\u4ECA\u5997\u64D2\u6611\u6A8E\u7434\u7981\u79BD\u82A9\u887E\u887F\u895F\uF90A\u9326\u4F0B\u53CA\u6025\u6271\u6C72\u7D1A\u7D66\u4E98\u5162\u77DC\u80AF\u4F01\u4F0E\u5176\u5180\u55DC\u5668\u573B\u57FA\u57FC\u5914\u5947\u5993\u5BC4\u5C90\u5D0E\u5DF1\u5E7E\u5FCC\u6280\u65D7\u65E3"],
      ["d1a1", "\u671E\u671F\u675E\u68CB\u68C4\u6A5F\u6B3A\u6C23\u6C7D\u6C82\u6DC7\u7398\u7426\u742A\u7482\u74A3\u7578\u757F\u7881\u78EF\u7941\u7947\u7948\u797A\u7B95\u7D00\u7DBA\u7F88\u8006\u802D\u808C\u8A18\u8B4F\u8C48\u8D77\u9321\u9324\u98E2\u9951\u9A0E\u9A0F\u9A65\u9E92\u7DCA\u4F76\u5409\u62EE\u6854\u91D1\u55AB\u513A\uF90B\uF90C\u5A1C\u61E6\uF90D\u62CF\u62FF\uF90E", 5, "\u90A3\uF914", 4, "\u8AFE\uF919\uF91A\uF91B\uF91C\u6696\uF91D\u7156\uF91E\uF91F\u96E3\uF920\u634F\u637A\u5357\uF921\u678F\u6960\u6E73\uF922\u7537\uF923\uF924\uF925"],
      ["d2a1", "\u7D0D\uF926\uF927\u8872\u56CA\u5A18\uF928", 4, "\u4E43\uF92D\u5167\u5948\u67F0\u8010\uF92E\u5973\u5E74\u649A\u79CA\u5FF5\u606C\u62C8\u637B\u5BE7\u5BD7\u52AA\uF92F\u5974\u5F29\u6012\uF930\uF931\uF932\u7459\uF933", 5, "\u99D1\uF939", 10, "\u6FC3\uF944\uF945\u81BF\u8FB2\u60F1\uF946\uF947\u8166\uF948\uF949\u5C3F\uF94A", 7, "\u5AE9\u8A25\u677B\u7D10\uF952", 5, "\u80FD\uF958\uF959\u5C3C\u6CE5\u533F\u6EBA\u591A\u8336"],
      ["d3a1", "\u4E39\u4EB6\u4F46\u55AE\u5718\u58C7\u5F56\u65B7\u65E6\u6A80\u6BB5\u6E4D\u77ED\u7AEF\u7C1E\u7DDE\u86CB\u8892\u9132\u935B\u64BB\u6FBE\u737A\u75B8\u9054\u5556\u574D\u61BA\u64D4\u66C7\u6DE1\u6E5B\u6F6D\u6FB9\u75F0\u8043\u81BD\u8541\u8983\u8AC7\u8B5A\u931F\u6C93\u7553\u7B54\u8E0F\u905D\u5510\u5802\u5858\u5E62\u6207\u649E\u68E0\u7576\u7CD6\u87B3\u9EE8\u4EE3\u5788\u576E\u5927\u5C0D\u5CB1\u5E36\u5F85\u6234\u64E1\u73B3\u81FA\u888B\u8CB8\u968A\u9EDB\u5B85\u5FB7\u60B3\u5012\u5200\u5230\u5716\u5835\u5857\u5C0E\u5C60\u5CF6\u5D8B\u5EA6\u5F92\u60BC\u6311\u6389\u6417\u6843"],
      ["d4a1", "\u68F9\u6AC2\u6DD8\u6E21\u6ED4\u6FE4\u71FE\u76DC\u7779\u79B1\u7A3B\u8404\u89A9\u8CED\u8DF3\u8E48\u9003\u9014\u9053\u90FD\u934D\u9676\u97DC\u6BD2\u7006\u7258\u72A2\u7368\u7763\u79BF\u7BE4\u7E9B\u8B80\u58A9\u60C7\u6566\u65FD\u66BE\u6C8C\u711E\u71C9\u8C5A\u9813\u4E6D\u7A81\u4EDD\u51AC\u51CD\u52D5\u540C\u61A7\u6771\u6850\u68DF\u6D1E\u6F7C\u75BC\u77B3\u7AE5\u80F4\u8463\u9285\u515C\u6597\u675C\u6793\u75D8\u7AC7\u8373\uF95A\u8C46\u9017\u982D\u5C6F\u81C0\u829A\u9041\u906F\u920D\u5F97\u5D9D\u6A59\u71C8\u767B\u7B49\u85E4\u8B04\u9127\u9A30\u5587\u61F6\uF95B\u7669\u7F85"],
      ["d5a1", "\u863F\u87BA\u88F8\u908F\uF95C\u6D1B\u70D9\u73DE\u7D61\u843D\uF95D\u916A\u99F1\uF95E\u4E82\u5375\u6B04\u6B12\u703E\u721B\u862D\u9E1E\u524C\u8FA3\u5D50\u64E5\u652C\u6B16\u6FEB\u7C43\u7E9C\u85CD\u8964\u89BD\u62C9\u81D8\u881F\u5ECA\u6717\u6D6A\u72FC\u7405\u746F\u8782\u90DE\u4F86\u5D0D\u5FA0\u840A\u51B7\u63A0\u7565\u4EAE\u5006\u5169\u51C9\u6881\u6A11\u7CAE\u7CB1\u7CE7\u826F\u8AD2\u8F1B\u91CF\u4FB6\u5137\u52F5\u5442\u5EEC\u616E\u623E\u65C5\u6ADA\u6FFE\u792A\u85DC\u8823\u95AD\u9A62\u9A6A\u9E97\u9ECE\u529B\u66C6\u6B77\u701D\u792B\u8F62\u9742\u6190\u6200\u6523\u6F23"],
      ["d6a1", "\u7149\u7489\u7DF4\u806F\u84EE\u8F26\u9023\u934A\u51BD\u5217\u52A3\u6D0C\u70C8\u88C2\u5EC9\u6582\u6BAE\u6FC2\u7C3E\u7375\u4EE4\u4F36\u56F9\uF95F\u5CBA\u5DBA\u601C\u73B2\u7B2D\u7F9A\u7FCE\u8046\u901E\u9234\u96F6\u9748\u9818\u9F61\u4F8B\u6FA7\u79AE\u91B4\u96B7\u52DE\uF960\u6488\u64C4\u6AD3\u6F5E\u7018\u7210\u76E7\u8001\u8606\u865C\u8DEF\u8F05\u9732\u9B6F\u9DFA\u9E75\u788C\u797F\u7DA0\u83C9\u9304\u9E7F\u9E93\u8AD6\u58DF\u5F04\u6727\u7027\u74CF\u7C60\u807E\u5121\u7028\u7262\u78CA\u8CC2\u8CDA\u8CF4\u96F7\u4E86\u50DA\u5BEE\u5ED6\u6599\u71CE\u7642\u77AD\u804A\u84FC"],
      ["d7a1", "\u907C\u9B27\u9F8D\u58D8\u5A41\u5C62\u6A13\u6DDA\u6F0F\u763B\u7D2F\u7E37\u851E\u8938\u93E4\u964B\u5289\u65D2\u67F3\u69B4\u6D41\u6E9C\u700F\u7409\u7460\u7559\u7624\u786B\u8B2C\u985E\u516D\u622E\u9678\u4F96\u502B\u5D19\u6DEA\u7DB8\u8F2A\u5F8B\u6144\u6817\uF961\u9686\u52D2\u808B\u51DC\u51CC\u695E\u7A1C\u7DBE\u83F1\u9675\u4FDA\u5229\u5398\u540F\u550E\u5C65\u60A7\u674E\u68A8\u6D6C\u7281\u72F8\u7406\u7483\uF962\u75E2\u7C6C\u7F79\u7FB8\u8389\u88CF\u88E1\u91CC\u91D0\u96E2\u9BC9\u541D\u6F7E\u71D0\u7498\u85FA\u8EAA\u96A3\u9C57\u9E9F\u6797\u6DCB\u7433\u81E8\u9716\u782C"],
      ["d8a1", "\u7ACB\u7B20\u7C92\u6469\u746A\u75F2\u78BC\u78E8\u99AC\u9B54\u9EBB\u5BDE\u5E55\u6F20\u819C\u83AB\u9088\u4E07\u534D\u5A29\u5DD2\u5F4E\u6162\u633D\u6669\u66FC\u6EFF\u6F2B\u7063\u779E\u842C\u8513\u883B\u8F13\u9945\u9C3B\u551C\u62B9\u672B\u6CAB\u8309\u896A\u977A\u4EA1\u5984\u5FD8\u5FD9\u671B\u7DB2\u7F54\u8292\u832B\u83BD\u8F1E\u9099\u57CB\u59B9\u5A92\u5BD0\u6627\u679A\u6885\u6BCF\u7164\u7F75\u8CB7\u8CE3\u9081\u9B45\u8108\u8C8A\u964C\u9A40\u9EA5\u5B5F\u6C13\u731B\u76F2\u76DF\u840C\u51AA\u8993\u514D\u5195\u52C9\u68C9\u6C94\u7704\u7720\u7DBF\u7DEC\u9762\u9EB5\u6EC5"],
      ["d9a1", "\u8511\u51A5\u540D\u547D\u660E\u669D\u6927\u6E9F\u76BF\u7791\u8317\u84C2\u879F\u9169\u9298\u9CF4\u8882\u4FAE\u5192\u52DF\u59C6\u5E3D\u6155\u6478\u6479\u66AE\u67D0\u6A21\u6BCD\u6BDB\u725F\u7261\u7441\u7738\u77DB\u8017\u82BC\u8305\u8B00\u8B28\u8C8C\u6728\u6C90\u7267\u76EE\u7766\u7A46\u9DA9\u6B7F\u6C92\u5922\u6726\u8499\u536F\u5893\u5999\u5EDF\u63CF\u6634\u6773\u6E3A\u732B\u7AD7\u82D7\u9328\u52D9\u5DEB\u61AE\u61CB\u620A\u62C7\u64AB\u65E0\u6959\u6B66\u6BCB\u7121\u73F7\u755D\u7E46\u821E\u8302\u856A\u8AA3\u8CBF\u9727\u9D61\u58A8\u9ED8\u5011\u520E\u543B\u554F\u6587"],
      ["daa1", "\u6C76\u7D0A\u7D0B\u805E\u868A\u9580\u96EF\u52FF\u6C95\u7269\u5473\u5A9A\u5C3E\u5D4B\u5F4C\u5FAE\u672A\u68B6\u6963\u6E3C\u6E44\u7709\u7C73\u7F8E\u8587\u8B0E\u8FF7\u9761\u9EF4\u5CB7\u60B6\u610D\u61AB\u654F\u65FB\u65FC\u6C11\u6CEF\u739F\u73C9\u7DE1\u9594\u5BC6\u871C\u8B10\u525D\u535A\u62CD\u640F\u64B2\u6734\u6A38\u6CCA\u73C0\u749E\u7B94\u7C95\u7E1B\u818A\u8236\u8584\u8FEB\u96F9\u99C1\u4F34\u534A\u53CD\u53DB\u62CC\u642C\u6500\u6591\u69C3\u6CEE\u6F58\u73ED\u7554\u7622\u76E4\u76FC\u78D0\u78FB\u792C\u7D46\u822C\u87E0\u8FD4\u9812\u98EF\u52C3\u62D4\u64A5\u6E24\u6F51"],
      ["dba1", "\u767C\u8DCB\u91B1\u9262\u9AEE\u9B43\u5023\u508D\u574A\u59A8\u5C28\u5E47\u5F77\u623F\u653E\u65B9\u65C1\u6609\u678B\u699C\u6EC2\u78C5\u7D21\u80AA\u8180\u822B\u82B3\u84A1\u868C\u8A2A\u8B17\u90A6\u9632\u9F90\u500D\u4FF3\uF963\u57F9\u5F98\u62DC\u6392\u676F\u6E43\u7119\u76C3\u80CC\u80DA\u88F4\u88F5\u8919\u8CE0\u8F29\u914D\u966A\u4F2F\u4F70\u5E1B\u67CF\u6822\u767D\u767E\u9B44\u5E61\u6A0A\u7169\u71D4\u756A\uF964\u7E41\u8543\u85E9\u98DC\u4F10\u7B4F\u7F70\u95A5\u51E1\u5E06\u68B5\u6C3E\u6C4E\u6CDB\u72AF\u7BC4\u8303\u6CD5\u743A\u50FB\u5288\u58C1\u64D8\u6A97\u74A7\u7656"],
      ["dca1", "\u78A7\u8617\u95E2\u9739\uF965\u535E\u5F01\u8B8A\u8FA8\u8FAF\u908A\u5225\u77A5\u9C49\u9F08\u4E19\u5002\u5175\u5C5B\u5E77\u661E\u663A\u67C4\u68C5\u70B3\u7501\u75C5\u79C9\u7ADD\u8F27\u9920\u9A08\u4FDD\u5821\u5831\u5BF6\u666E\u6B65\u6D11\u6E7A\u6F7D\u73E4\u752B\u83E9\u88DC\u8913\u8B5C\u8F14\u4F0F\u50D5\u5310\u535C\u5B93\u5FA9\u670D\u798F\u8179\u832F\u8514\u8907\u8986\u8F39\u8F3B\u99A5\u9C12\u672C\u4E76\u4FF8\u5949\u5C01\u5CEF\u5CF0\u6367\u68D2\u70FD\u71A2\u742B\u7E2B\u84EC\u8702\u9022\u92D2\u9CF3\u4E0D\u4ED8\u4FEF\u5085\u5256\u526F\u5426\u5490\u57E0\u592B\u5A66"],
      ["dda1", "\u5B5A\u5B75\u5BCC\u5E9C\uF966\u6276\u6577\u65A7\u6D6E\u6EA5\u7236\u7B26\u7C3F\u7F36\u8150\u8151\u819A\u8240\u8299\u83A9\u8A03\u8CA0\u8CE6\u8CFB\u8D74\u8DBA\u90E8\u91DC\u961C\u9644\u99D9\u9CE7\u5317\u5206\u5429\u5674\u58B3\u5954\u596E\u5FFF\u61A4\u626E\u6610\u6C7E\u711A\u76C6\u7C89\u7CDE\u7D1B\u82AC\u8CC1\u96F0\uF967\u4F5B\u5F17\u5F7F\u62C2\u5D29\u670B\u68DA\u787C\u7E43\u9D6C\u4E15\u5099\u5315\u532A\u5351\u5983\u5A62\u5E87\u60B2\u618A\u6249\u6279\u6590\u6787\u69A7\u6BD4\u6BD6\u6BD7\u6BD8\u6CB8\uF968\u7435\u75FA\u7812\u7891\u79D5\u79D8\u7C83\u7DCB\u7FE1\u80A5"],
      ["dea1", "\u813E\u81C2\u83F2\u871A\u88E8\u8AB9\u8B6C\u8CBB\u9119\u975E\u98DB\u9F3B\u56AC\u5B2A\u5F6C\u658C\u6AB3\u6BAF\u6D5C\u6FF1\u7015\u725D\u73AD\u8CA7\u8CD3\u983B\u6191\u6C37\u8058\u9A01\u4E4D\u4E8B\u4E9B\u4ED5\u4F3A\u4F3C\u4F7F\u4FDF\u50FF\u53F2\u53F8\u5506\u55E3\u56DB\u58EB\u5962\u5A11\u5BEB\u5BFA\u5C04\u5DF3\u5E2B\u5F99\u601D\u6368\u659C\u65AF\u67F6\u67FB\u68AD\u6B7B\u6C99\u6CD7\u6E23\u7009\u7345\u7802\u793E\u7940\u7960\u79C1\u7BE9\u7D17\u7D72\u8086\u820D\u838E\u84D1\u86C7\u88DF\u8A50\u8A5E\u8B1D\u8CDC\u8D66\u8FAD\u90AA\u98FC\u99DF\u9E9D\u524A\uF969\u6714\uF96A"],
      ["dfa1", "\u5098\u522A\u5C71\u6563\u6C55\u73CA\u7523\u759D\u7B97\u849C\u9178\u9730\u4E77\u6492\u6BBA\u715E\u85A9\u4E09\uF96B\u6749\u68EE\u6E17\u829F\u8518\u886B\u63F7\u6F81\u9212\u98AF\u4E0A\u50B7\u50CF\u511F\u5546\u55AA\u5617\u5B40\u5C19\u5CE0\u5E38\u5E8A\u5EA0\u5EC2\u60F3\u6851\u6A61\u6E58\u723D\u7240\u72C0\u76F8\u7965\u7BB1\u7FD4\u88F3\u89F4\u8A73\u8C61\u8CDE\u971C\u585E\u74BD\u8CFD\u55C7\uF96C\u7A61\u7D22\u8272\u7272\u751F\u7525\uF96D\u7B19\u5885\u58FB\u5DBC\u5E8F\u5EB6\u5F90\u6055\u6292\u637F\u654D\u6691\u66D9\u66F8\u6816\u68F2\u7280\u745E\u7B6E\u7D6E\u7DD6\u7F72"],
      ["e0a1", "\u80E5\u8212\u85AF\u897F\u8A93\u901D\u92E4\u9ECD\u9F20\u5915\u596D\u5E2D\u60DC\u6614\u6673\u6790\u6C50\u6DC5\u6F5F\u77F3\u78A9\u84C6\u91CB\u932B\u4ED9\u50CA\u5148\u5584\u5B0B\u5BA3\u6247\u657E\u65CB\u6E32\u717D\u7401\u7444\u7487\u74BF\u766C\u79AA\u7DDA\u7E55\u7FA8\u817A\u81B3\u8239\u861A\u87EC\u8A75\u8DE3\u9078\u9291\u9425\u994D\u9BAE\u5368\u5C51\u6954\u6CC4\u6D29\u6E2B\u820C\u859B\u893B\u8A2D\u8AAA\u96EA\u9F67\u5261\u66B9\u6BB2\u7E96\u87FE\u8D0D\u9583\u965D\u651D\u6D89\u71EE\uF96E\u57CE\u59D3\u5BAC\u6027\u60FA\u6210\u661F\u665F\u7329\u73F9\u76DB\u7701\u7B6C"],
      ["e1a1", "\u8056\u8072\u8165\u8AA0\u9192\u4E16\u52E2\u6B72\u6D17\u7A05\u7B39\u7D30\uF96F\u8CB0\u53EC\u562F\u5851\u5BB5\u5C0F\u5C11\u5DE2\u6240\u6383\u6414\u662D\u68B3\u6CBC\u6D88\u6EAF\u701F\u70A4\u71D2\u7526\u758F\u758E\u7619\u7B11\u7BE0\u7C2B\u7D20\u7D39\u852C\u856D\u8607\u8A34\u900D\u9061\u90B5\u92B7\u97F6\u9A37\u4FD7\u5C6C\u675F\u6D91\u7C9F\u7E8C\u8B16\u8D16\u901F\u5B6B\u5DFD\u640D\u84C0\u905C\u98E1\u7387\u5B8B\u609A\u677E\u6DDE\u8A1F\u8AA6\u9001\u980C\u5237\uF970\u7051\u788E\u9396\u8870\u91D7\u4FEE\u53D7\u55FD\u56DA\u5782\u58FD\u5AC2\u5B88\u5CAB\u5CC0\u5E25\u6101"],
      ["e2a1", "\u620D\u624B\u6388\u641C\u6536\u6578\u6A39\u6B8A\u6C34\u6D19\u6F31\u71E7\u72E9\u7378\u7407\u74B2\u7626\u7761\u79C0\u7A57\u7AEA\u7CB9\u7D8F\u7DAC\u7E61\u7F9E\u8129\u8331\u8490\u84DA\u85EA\u8896\u8AB0\u8B90\u8F38\u9042\u9083\u916C\u9296\u92B9\u968B\u96A7\u96A8\u96D6\u9700\u9808\u9996\u9AD3\u9B1A\u53D4\u587E\u5919\u5B70\u5BBF\u6DD1\u6F5A\u719F\u7421\u74B9\u8085\u83FD\u5DE1\u5F87\u5FAA\u6042\u65EC\u6812\u696F\u6A53\u6B89\u6D35\u6DF3\u73E3\u76FE\u77AC\u7B4D\u7D14\u8123\u821C\u8340\u84F4\u8563\u8A62\u8AC4\u9187\u931E\u9806\u99B4\u620C\u8853\u8FF0\u9265\u5D07\u5D27"],
      ["e3a1", "\u5D69\u745F\u819D\u8768\u6FD5\u62FE\u7FD2\u8936\u8972\u4E1E\u4E58\u50E7\u52DD\u5347\u627F\u6607\u7E69\u8805\u965E\u4F8D\u5319\u5636\u59CB\u5AA4\u5C38\u5C4E\u5C4D\u5E02\u5F11\u6043\u65BD\u662F\u6642\u67BE\u67F4\u731C\u77E2\u793A\u7FC5\u8494\u84CD\u8996\u8A66\u8A69\u8AE1\u8C55\u8C7A\u57F4\u5BD4\u5F0F\u606F\u62ED\u690D\u6B96\u6E5C\u7184\u7BD2\u8755\u8B58\u8EFE\u98DF\u98FE\u4F38\u4F81\u4FE1\u547B\u5A20\u5BB8\u613C\u65B0\u6668\u71FC\u7533\u795E\u7D33\u814E\u81E3\u8398\u85AA\u85CE\u8703\u8A0A\u8EAB\u8F9B\uF971\u8FC5\u5931\u5BA4\u5BE6\u6089\u5BE9\u5C0B\u5FC3\u6C81"],
      ["e4a1", "\uF972\u6DF1\u700B\u751A\u82AF\u8AF6\u4EC0\u5341\uF973\u96D9\u6C0F\u4E9E\u4FC4\u5152\u555E\u5A25\u5CE8\u6211\u7259\u82BD\u83AA\u86FE\u8859\u8A1D\u963F\u96C5\u9913\u9D09\u9D5D\u580A\u5CB3\u5DBD\u5E44\u60E1\u6115\u63E1\u6A02\u6E25\u9102\u9354\u984E\u9C10\u9F77\u5B89\u5CB8\u6309\u664F\u6848\u773C\u96C1\u978D\u9854\u9B9F\u65A1\u8B01\u8ECB\u95BC\u5535\u5CA9\u5DD6\u5EB5\u6697\u764C\u83F4\u95C7\u58D3\u62BC\u72CE\u9D28\u4EF0\u592E\u600F\u663B\u6B83\u79E7\u9D26\u5393\u54C0\u57C3\u5D16\u611B\u66D6\u6DAF\u788D\u827E\u9698\u9744\u5384\u627C\u6396\u6DB2\u7E0A\u814B\u984D"],
      ["e5a1", "\u6AFB\u7F4C\u9DAF\u9E1A\u4E5F\u503B\u51B6\u591C\u60F9\u63F6\u6930\u723A\u8036\uF974\u91CE\u5F31\uF975\uF976\u7D04\u82E5\u846F\u84BB\u85E5\u8E8D\uF977\u4F6F\uF978\uF979\u58E4\u5B43\u6059\u63DA\u6518\u656D\u6698\uF97A\u694A\u6A23\u6D0B\u7001\u716C\u75D2\u760D\u79B3\u7A70\uF97B\u7F8A\uF97C\u8944\uF97D\u8B93\u91C0\u967D\uF97E\u990A\u5704\u5FA1\u65BC\u6F01\u7600\u79A6\u8A9E\u99AD\u9B5A\u9F6C\u5104\u61B6\u6291\u6A8D\u81C6\u5043\u5830\u5F66\u7109\u8A00\u8AFA\u5B7C\u8616\u4FFA\u513C\u56B4\u5944\u63A9\u6DF9\u5DAA\u696D\u5186\u4E88\u4F59\uF97F\uF980\uF981\u5982\uF982"],
      ["e6a1", "\uF983\u6B5F\u6C5D\uF984\u74B5\u7916\uF985\u8207\u8245\u8339\u8F3F\u8F5D\uF986\u9918\uF987\uF988\uF989\u4EA6\uF98A\u57DF\u5F79\u6613\uF98B\uF98C\u75AB\u7E79\u8B6F\uF98D\u9006\u9A5B\u56A5\u5827\u59F8\u5A1F\u5BB4\uF98E\u5EF6\uF98F\uF990\u6350\u633B\uF991\u693D\u6C87\u6CBF\u6D8E\u6D93\u6DF5\u6F14\uF992\u70DF\u7136\u7159\uF993\u71C3\u71D5\uF994\u784F\u786F\uF995\u7B75\u7DE3\uF996\u7E2F\uF997\u884D\u8EDF\uF998\uF999\uF99A\u925B\uF99B\u9CF6\uF99C\uF99D\uF99E\u6085\u6D85\uF99F\u71B1\uF9A0\uF9A1\u95B1\u53AD\uF9A2\uF9A3\uF9A4\u67D3\uF9A5\u708E\u7130\u7430\u8276\u82D2"],
      ["e7a1", "\uF9A6\u95BB\u9AE5\u9E7D\u66C4\uF9A7\u71C1\u8449\uF9A8\uF9A9\u584B\uF9AA\uF9AB\u5DB8\u5F71\uF9AC\u6620\u668E\u6979\u69AE\u6C38\u6CF3\u6E36\u6F41\u6FDA\u701B\u702F\u7150\u71DF\u7370\uF9AD\u745B\uF9AE\u74D4\u76C8\u7A4E\u7E93\uF9AF\uF9B0\u82F1\u8A60\u8FCE\uF9B1\u9348\uF9B2\u9719\uF9B3\uF9B4\u4E42\u502A\uF9B5\u5208\u53E1\u66F3\u6C6D\u6FCA\u730A\u777F\u7A62\u82AE\u85DD\u8602\uF9B6\u88D4\u8A63\u8B7D\u8C6B\uF9B7\u92B3\uF9B8\u9713\u9810\u4E94\u4F0D\u4FC9\u50B2\u5348\u543E\u5433\u55DA\u5862\u58BA\u5967\u5A1B\u5BE4\u609F\uF9B9\u61CA\u6556\u65FF\u6664\u68A7\u6C5A\u6FB3"],
      ["e8a1", "\u70CF\u71AC\u7352\u7B7D\u8708\u8AA4\u9C32\u9F07\u5C4B\u6C83\u7344\u7389\u923A\u6EAB\u7465\u761F\u7A69\u7E15\u860A\u5140\u58C5\u64C1\u74EE\u7515\u7670\u7FC1\u9095\u96CD\u9954\u6E26\u74E6\u7AA9\u7AAA\u81E5\u86D9\u8778\u8A1B\u5A49\u5B8C\u5B9B\u68A1\u6900\u6D63\u73A9\u7413\u742C\u7897\u7DE9\u7FEB\u8118\u8155\u839E\u8C4C\u962E\u9811\u66F0\u5F80\u65FA\u6789\u6C6A\u738B\u502D\u5A03\u6B6A\u77EE\u5916\u5D6C\u5DCD\u7325\u754F\uF9BA\uF9BB\u50E5\u51F9\u582F\u592D\u5996\u59DA\u5BE5\uF9BC\uF9BD\u5DA2\u62D7\u6416\u6493\u64FE\uF9BE\u66DC\uF9BF\u6A48\uF9C0\u71FF\u7464\uF9C1"],
      ["e9a1", "\u7A88\u7AAF\u7E47\u7E5E\u8000\u8170\uF9C2\u87EF\u8981\u8B20\u9059\uF9C3\u9080\u9952\u617E\u6B32\u6D74\u7E1F\u8925\u8FB1\u4FD1\u50AD\u5197\u52C7\u57C7\u5889\u5BB9\u5EB8\u6142\u6995\u6D8C\u6E67\u6EB6\u7194\u7462\u7528\u752C\u8073\u8338\u84C9\u8E0A\u9394\u93DE\uF9C4\u4E8E\u4F51\u5076\u512A\u53C8\u53CB\u53F3\u5B87\u5BD3\u5C24\u611A\u6182\u65F4\u725B\u7397\u7440\u76C2\u7950\u7991\u79B9\u7D06\u7FBD\u828B\u85D5\u865E\u8FC2\u9047\u90F5\u91EA\u9685\u96E8\u96E9\u52D6\u5F67\u65ED\u6631\u682F\u715C\u7A36\u90C1\u980A\u4E91\uF9C5\u6A52\u6B9E\u6F90\u7189\u8018\u82B8\u8553"],
      ["eaa1", "\u904B\u9695\u96F2\u97FB\u851A\u9B31\u4E90\u718A\u96C4\u5143\u539F\u54E1\u5713\u5712\u57A3\u5A9B\u5AC4\u5BC3\u6028\u613F\u63F4\u6C85\u6D39\u6E72\u6E90\u7230\u733F\u7457\u82D1\u8881\u8F45\u9060\uF9C6\u9662\u9858\u9D1B\u6708\u8D8A\u925E\u4F4D\u5049\u50DE\u5371\u570D\u59D4\u5A01\u5C09\u6170\u6690\u6E2D\u7232\u744B\u7DEF\u80C3\u840E\u8466\u853F\u875F\u885B\u8918\u8B02\u9055\u97CB\u9B4F\u4E73\u4F91\u5112\u516A\uF9C7\u552F\u55A9\u5B7A\u5BA5\u5E7C\u5E7D\u5EBE\u60A0\u60DF\u6108\u6109\u63C4\u6538\u6709\uF9C8\u67D4\u67DA\uF9C9\u6961\u6962\u6CB9\u6D27\uF9CA\u6E38\uF9CB"],
      ["eba1", "\u6FE1\u7336\u7337\uF9CC\u745C\u7531\uF9CD\u7652\uF9CE\uF9CF\u7DAD\u81FE\u8438\u88D5\u8A98\u8ADB\u8AED\u8E30\u8E42\u904A\u903E\u907A\u9149\u91C9\u936E\uF9D0\uF9D1\u5809\uF9D2\u6BD3\u8089\u80B2\uF9D3\uF9D4\u5141\u596B\u5C39\uF9D5\uF9D6\u6F64\u73A7\u80E4\u8D07\uF9D7\u9217\u958F\uF9D8\uF9D9\uF9DA\uF9DB\u807F\u620E\u701C\u7D68\u878D\uF9DC\u57A0\u6069\u6147\u6BB7\u8ABE\u9280\u96B1\u4E59\u541F\u6DEB\u852D\u9670\u97F3\u98EE\u63D6\u6CE3\u9091\u51DD\u61C9\u81BA\u9DF9\u4F9D\u501A\u5100\u5B9C\u610F\u61FF\u64EC\u6905\u6BC5\u7591\u77E3\u7FA9\u8264\u858F\u87FB\u8863\u8ABC"],
      ["eca1", "\u8B70\u91AB\u4E8C\u4EE5\u4F0A\uF9DD\uF9DE\u5937\u59E8\uF9DF\u5DF2\u5F1B\u5F5B\u6021\uF9E0\uF9E1\uF9E2\uF9E3\u723E\u73E5\uF9E4\u7570\u75CD\uF9E5\u79FB\uF9E6\u800C\u8033\u8084\u82E1\u8351\uF9E7\uF9E8\u8CBD\u8CB3\u9087\uF9E9\uF9EA\u98F4\u990C\uF9EB\uF9EC\u7037\u76CA\u7FCA\u7FCC\u7FFC\u8B1A\u4EBA\u4EC1\u5203\u5370\uF9ED\u54BD\u56E0\u59FB\u5BC5\u5F15\u5FCD\u6E6E\uF9EE\uF9EF\u7D6A\u8335\uF9F0\u8693\u8A8D\uF9F1\u976D\u9777\uF9F2\uF9F3\u4E00\u4F5A\u4F7E\u58F9\u65E5\u6EA2\u9038\u93B0\u99B9\u4EFB\u58EC\u598A\u59D9\u6041\uF9F4\uF9F5\u7A14\uF9F6\u834F\u8CC3\u5165\u5344"],
      ["eda1", "\uF9F7\uF9F8\uF9F9\u4ECD\u5269\u5B55\u82BF\u4ED4\u523A\u54A8\u59C9\u59FF\u5B50\u5B57\u5B5C\u6063\u6148\u6ECB\u7099\u716E\u7386\u74F7\u75B5\u78C1\u7D2B\u8005\u81EA\u8328\u8517\u85C9\u8AEE\u8CC7\u96CC\u4F5C\u52FA\u56BC\u65AB\u6628\u707C\u70B8\u7235\u7DBD\u828D\u914C\u96C0\u9D72\u5B71\u68E7\u6B98\u6F7A\u76DE\u5C91\u66AB\u6F5B\u7BB4\u7C2A\u8836\u96DC\u4E08\u4ED7\u5320\u5834\u58BB\u58EF\u596C\u5C07\u5E33\u5E84\u5F35\u638C\u66B2\u6756\u6A1F\u6AA3\u6B0C\u6F3F\u7246\uF9FA\u7350\u748B\u7AE0\u7CA7\u8178\u81DF\u81E7\u838A\u846C\u8523\u8594\u85CF\u88DD\u8D13\u91AC\u9577"],
      ["eea1", "\u969C\u518D\u54C9\u5728\u5BB0\u624D\u6750\u683D\u6893\u6E3D\u6ED3\u707D\u7E21\u88C1\u8CA1\u8F09\u9F4B\u9F4E\u722D\u7B8F\u8ACD\u931A\u4F47\u4F4E\u5132\u5480\u59D0\u5E95\u62B5\u6775\u696E\u6A17\u6CAE\u6E1A\u72D9\u732A\u75BD\u7BB8\u7D35\u82E7\u83F9\u8457\u85F7\u8A5B\u8CAF\u8E87\u9019\u90B8\u96CE\u9F5F\u52E3\u540A\u5AE1\u5BC2\u6458\u6575\u6EF4\u72C4\uF9FB\u7684\u7A4D\u7B1B\u7C4D\u7E3E\u7FDF\u837B\u8B2B\u8CCA\u8D64\u8DE1\u8E5F\u8FEA\u8FF9\u9069\u93D1\u4F43\u4F7A\u50B3\u5168\u5178\u524D\u526A\u5861\u587C\u5960\u5C08\u5C55\u5EDB\u609B\u6230\u6813\u6BBF\u6C08\u6FB1"],
      ["efa1", "\u714E\u7420\u7530\u7538\u7551\u7672\u7B4C\u7B8B\u7BAD\u7BC6\u7E8F\u8A6E\u8F3E\u8F49\u923F\u9293\u9322\u942B\u96FB\u985A\u986B\u991E\u5207\u622A\u6298\u6D59\u7664\u7ACA\u7BC0\u7D76\u5360\u5CBE\u5E97\u6F38\u70B9\u7C98\u9711\u9B8E\u9EDE\u63A5\u647A\u8776\u4E01\u4E95\u4EAD\u505C\u5075\u5448\u59C3\u5B9A\u5E40\u5EAD\u5EF7\u5F81\u60C5\u633A\u653F\u6574\u65CC\u6676\u6678\u67FE\u6968\u6A89\u6B63\u6C40\u6DC0\u6DE8\u6E1F\u6E5E\u701E\u70A1\u738E\u73FD\u753A\u775B\u7887\u798E\u7A0B\u7A7D\u7CBE\u7D8E\u8247\u8A02\u8AEA\u8C9E\u912D\u914A\u91D8\u9266\u92CC\u9320\u9706\u9756"],
      ["f0a1", "\u975C\u9802\u9F0E\u5236\u5291\u557C\u5824\u5E1D\u5F1F\u608C\u63D0\u68AF\u6FDF\u796D\u7B2C\u81CD\u85BA\u88FD\u8AF8\u8E44\u918D\u9664\u969B\u973D\u984C\u9F4A\u4FCE\u5146\u51CB\u52A9\u5632\u5F14\u5F6B\u63AA\u64CD\u65E9\u6641\u66FA\u66F9\u671D\u689D\u68D7\u69FD\u6F15\u6F6E\u7167\u71E5\u722A\u74AA\u773A\u7956\u795A\u79DF\u7A20\u7A95\u7C97\u7CDF\u7D44\u7E70\u8087\u85FB\u86A4\u8A54\u8ABF\u8D99\u8E81\u9020\u906D\u91E3\u963B\u96D5\u9CE5\u65CF\u7C07\u8DB3\u93C3\u5B58\u5C0A\u5352\u62D9\u731D\u5027\u5B97\u5F9E\u60B0\u616B\u68D5\u6DD9\u742E\u7A2E\u7D42\u7D9C\u7E31\u816B"],
      ["f1a1", "\u8E2A\u8E35\u937E\u9418\u4F50\u5750\u5DE6\u5EA7\u632B\u7F6A\u4E3B\u4F4F\u4F8F\u505A\u59DD\u80C4\u546A\u5468\u55FE\u594F\u5B99\u5DDE\u5EDA\u665D\u6731\u67F1\u682A\u6CE8\u6D32\u6E4A\u6F8D\u70B7\u73E0\u7587\u7C4C\u7D02\u7D2C\u7DA2\u821F\u86DB\u8A3B\u8A85\u8D70\u8E8A\u8F33\u9031\u914E\u9152\u9444\u99D0\u7AF9\u7CA5\u4FCA\u5101\u51C6\u57C8\u5BEF\u5CFB\u6659\u6A3D\u6D5A\u6E96\u6FEC\u710C\u756F\u7AE3\u8822\u9021\u9075\u96CB\u99FF\u8301\u4E2D\u4EF2\u8846\u91CD\u537D\u6ADB\u696B\u6C41\u847A\u589E\u618E\u66FE\u62EF\u70DD\u7511\u75C7\u7E52\u84B8\u8B49\u8D08\u4E4B\u53EA"],
      ["f2a1", "\u54AB\u5730\u5740\u5FD7\u6301\u6307\u646F\u652F\u65E8\u667A\u679D\u67B3\u6B62\u6C60\u6C9A\u6F2C\u77E5\u7825\u7949\u7957\u7D19\u80A2\u8102\u81F3\u829D\u82B7\u8718\u8A8C\uF9FC\u8D04\u8DBE\u9072\u76F4\u7A19\u7A37\u7E54\u8077\u5507\u55D4\u5875\u632F\u6422\u6649\u664B\u686D\u699B\u6B84\u6D25\u6EB1\u73CD\u7468\u74A1\u755B\u75B9\u76E1\u771E\u778B\u79E6\u7E09\u7E1D\u81FB\u852F\u8897\u8A3A\u8CD1\u8EEB\u8FB0\u9032\u93AD\u9663\u9673\u9707\u4F84\u53F1\u59EA\u5AC9\u5E19\u684E\u74C6\u75BE\u79E9\u7A92\u81A3\u86ED\u8CEA\u8DCC\u8FED\u659F\u6715\uF9FD\u57F7\u6F57\u7DDD\u8F2F"],
      ["f3a1", "\u93F6\u96C6\u5FB5\u61F2\u6F84\u4E14\u4F98\u501F\u53C9\u55DF\u5D6F\u5DEE\u6B21\u6B64\u78CB\u7B9A\uF9FE\u8E49\u8ECA\u906E\u6349\u643E\u7740\u7A84\u932F\u947F\u9F6A\u64B0\u6FAF\u71E6\u74A8\u74DA\u7AC4\u7C12\u7E82\u7CB2\u7E98\u8B9A\u8D0A\u947D\u9910\u994C\u5239\u5BDF\u64E6\u672D\u7D2E\u50ED\u53C3\u5879\u6158\u6159\u61FA\u65AC\u7AD9\u8B92\u8B96\u5009\u5021\u5275\u5531\u5A3C\u5EE0\u5F70\u6134\u655E\u660C\u6636\u66A2\u69CD\u6EC4\u6F32\u7316\u7621\u7A93\u8139\u8259\u83D6\u84BC\u50B5\u57F0\u5BC0\u5BE8\u5F69\u63A1\u7826\u7DB5\u83DC\u8521\u91C7\u91F5\u518A\u67F5\u7B56"],
      ["f4a1", "\u8CAC\u51C4\u59BB\u60BD\u8655\u501C\uF9FF\u5254\u5C3A\u617D\u621A\u62D3\u64F2\u65A5\u6ECC\u7620\u810A\u8E60\u965F\u96BB\u4EDF\u5343\u5598\u5929\u5DDD\u64C5\u6CC9\u6DFA\u7394\u7A7F\u821B\u85A6\u8CE4\u8E10\u9077\u91E7\u95E1\u9621\u97C6\u51F8\u54F2\u5586\u5FB9\u64A4\u6F88\u7DB4\u8F1F\u8F4D\u9435\u50C9\u5C16\u6CBE\u6DFB\u751B\u77BB\u7C3D\u7C64\u8A79\u8AC2\u581E\u59BE\u5E16\u6377\u7252\u758A\u776B\u8ADC\u8CBC\u8F12\u5EF3\u6674\u6DF8\u807D\u83C1\u8ACB\u9751\u9BD6\uFA00\u5243\u66FF\u6D95\u6EEF\u7DE0\u8AE6\u902E\u905E\u9AD4\u521D\u527F\u54E8\u6194\u6284\u62DB\u68A2"],
      ["f5a1", "\u6912\u695A\u6A35\u7092\u7126\u785D\u7901\u790E\u79D2\u7A0D\u8096\u8278\u82D5\u8349\u8549\u8C82\u8D85\u9162\u918B\u91AE\u4FC3\u56D1\u71ED\u77D7\u8700\u89F8\u5BF8\u5FD6\u6751\u90A8\u53E2\u585A\u5BF5\u60A4\u6181\u6460\u7E3D\u8070\u8525\u9283\u64AE\u50AC\u5D14\u6700\u589C\u62BD\u63A8\u690E\u6978\u6A1E\u6E6B\u76BA\u79CB\u82BB\u8429\u8ACF\u8DA8\u8FFD\u9112\u914B\u919C\u9310\u9318\u939A\u96DB\u9A36\u9C0D\u4E11\u755C\u795D\u7AFA\u7B51\u7BC9\u7E2E\u84C4\u8E59\u8E74\u8EF8\u9010\u6625\u693F\u7443\u51FA\u672E\u9EDC\u5145\u5FE0\u6C96\u87F2\u885D\u8877\u60B4\u81B5\u8403"],
      ["f6a1", "\u8D05\u53D6\u5439\u5634\u5A36\u5C31\u708A\u7FE0\u805A\u8106\u81ED\u8DA3\u9189\u9A5F\u9DF2\u5074\u4EC4\u53A0\u60FB\u6E2C\u5C64\u4F88\u5024\u55E4\u5CD9\u5E5F\u6065\u6894\u6CBB\u6DC4\u71BE\u75D4\u75F4\u7661\u7A1A\u7A49\u7DC7\u7DFB\u7F6E\u81F4\u86A9\u8F1C\u96C9\u99B3\u9F52\u5247\u52C5\u98ED\u89AA\u4E03\u67D2\u6F06\u4FB5\u5BE2\u6795\u6C88\u6D78\u741B\u7827\u91DD\u937C\u87C4\u79E4\u7A31\u5FEB\u4ED6\u54A4\u553E\u58AE\u59A5\u60F0\u6253\u62D6\u6736\u6955\u8235\u9640\u99B1\u99DD\u502C\u5353\u5544\u577C\uFA01\u6258\uFA02\u64E2\u666B\u67DD\u6FC1\u6FEF\u7422\u7438\u8A17"],
      ["f7a1", "\u9438\u5451\u5606\u5766\u5F48\u619A\u6B4E\u7058\u70AD\u7DBB\u8A95\u596A\u812B\u63A2\u7708\u803D\u8CAA\u5854\u642D\u69BB\u5B95\u5E11\u6E6F\uFA03\u8569\u514C\u53F0\u592A\u6020\u614B\u6B86\u6C70\u6CF0\u7B1E\u80CE\u82D4\u8DC6\u90B0\u98B1\uFA04\u64C7\u6FA4\u6491\u6504\u514E\u5410\u571F\u8A0E\u615F\u6876\uFA05\u75DB\u7B52\u7D71\u901A\u5806\u69CC\u817F\u892A\u9000\u9839\u5078\u5957\u59AC\u6295\u900F\u9B2A\u615D\u7279\u95D6\u5761\u5A46\u5DF4\u628A\u64AD\u64FA\u6777\u6CE2\u6D3E\u722C\u7436\u7834\u7F77\u82AD\u8DDB\u9817\u5224\u5742\u677F\u7248\u74E3\u8CA9\u8FA6\u9211"],
      ["f8a1", "\u962A\u516B\u53ED\u634C\u4F69\u5504\u6096\u6557\u6C9B\u6D7F\u724C\u72FD\u7A17\u8987\u8C9D\u5F6D\u6F8E\u70F9\u81A8\u610E\u4FBF\u504F\u6241\u7247\u7BC7\u7DE8\u7FE9\u904D\u97AD\u9A19\u8CB6\u576A\u5E73\u67B0\u840D\u8A55\u5420\u5B16\u5E63\u5EE2\u5F0A\u6583\u80BA\u853D\u9589\u965B\u4F48\u5305\u530D\u530F\u5486\u54FA\u5703\u5E03\u6016\u629B\u62B1\u6355\uFA06\u6CE1\u6D66\u75B1\u7832\u80DE\u812F\u82DE\u8461\u84B2\u888D\u8912\u900B\u92EA\u98FD\u9B91\u5E45\u66B4\u66DD\u7011\u7206\uFA07\u4FF5\u527D\u5F6A\u6153\u6753\u6A19\u6F02\u74E2\u7968\u8868\u8C79\u98C7\u98C4\u9A43"],
      ["f9a1", "\u54C1\u7A1F\u6953\u8AF7\u8C4A\u98A8\u99AE\u5F7C\u62AB\u75B2\u76AE\u88AB\u907F\u9642\u5339\u5F3C\u5FC5\u6CCC\u73CC\u7562\u758B\u7B46\u82FE\u999D\u4E4F\u903C\u4E0B\u4F55\u53A6\u590F\u5EC8\u6630\u6CB3\u7455\u8377\u8766\u8CC0\u9050\u971E\u9C15\u58D1\u5B78\u8650\u8B14\u9DB4\u5BD2\u6068\u608D\u65F1\u6C57\u6F22\u6FA3\u701A\u7F55\u7FF0\u9591\u9592\u9650\u97D3\u5272\u8F44\u51FD\u542B\u54B8\u5563\u558A\u6ABB\u6DB5\u7DD8\u8266\u929C\u9677\u9E79\u5408\u54C8\u76D2\u86E4\u95A4\u95D4\u965C\u4EA2\u4F09\u59EE\u5AE6\u5DF7\u6052\u6297\u676D\u6841\u6C86\u6E2F\u7F38\u809B\u822A"],
      ["faa1", "\uFA08\uFA09\u9805\u4EA5\u5055\u54B3\u5793\u595A\u5B69\u5BB3\u61C8\u6977\u6D77\u7023\u87F9\u89E3\u8A72\u8AE7\u9082\u99ED\u9AB8\u52BE\u6838\u5016\u5E78\u674F\u8347\u884C\u4EAB\u5411\u56AE\u73E6\u9115\u97FF\u9909\u9957\u9999\u5653\u589F\u865B\u8A31\u61B2\u6AF6\u737B\u8ED2\u6B47\u96AA\u9A57\u5955\u7200\u8D6B\u9769\u4FD4\u5CF4\u5F26\u61F8\u665B\u6CEB\u70AB\u7384\u73B9\u73FE\u7729\u774D\u7D43\u7D62\u7E23\u8237\u8852\uFA0A\u8CE2\u9249\u986F\u5B51\u7A74\u8840\u9801\u5ACC\u4FE0\u5354\u593E\u5CFD\u633E\u6D79\u72F9\u8105\u8107\u83A2\u92CF\u9830\u4EA8\u5144\u5211\u578B"],
      ["fba1", "\u5F62\u6CC2\u6ECE\u7005\u7050\u70AF\u7192\u73E9\u7469\u834A\u87A2\u8861\u9008\u90A2\u93A3\u99A8\u516E\u5F57\u60E0\u6167\u66B3\u8559\u8E4A\u91AF\u978B\u4E4E\u4E92\u547C\u58D5\u58FA\u597D\u5CB5\u5F27\u6236\u6248\u660A\u6667\u6BEB\u6D69\u6DCF\u6E56\u6EF8\u6F94\u6FE0\u6FE9\u705D\u72D0\u7425\u745A\u74E0\u7693\u795C\u7CCA\u7E1E\u80E1\u82A6\u846B\u84BF\u864E\u865F\u8774\u8B77\u8C6A\u93AC\u9800\u9865\u60D1\u6216\u9177\u5A5A\u660F\u6DF7\u6E3E\u743F\u9B42\u5FFD\u60DA\u7B0F\u54C4\u5F18\u6C5E\u6CD3\u6D2A\u70D8\u7D05\u8679\u8A0C\u9D3B\u5316\u548C\u5B05\u6A3A\u706B\u7575"],
      ["fca1", "\u798D\u79BE\u82B1\u83EF\u8A71\u8B41\u8CA8\u9774\uFA0B\u64F4\u652B\u78BA\u78BB\u7A6B\u4E38\u559A\u5950\u5BA6\u5E7B\u60A3\u63DB\u6B61\u6665\u6853\u6E19\u7165\u74B0\u7D08\u9084\u9A69\u9C25\u6D3B\u6ED1\u733E\u8C41\u95CA\u51F0\u5E4C\u5FA8\u604D\u60F6\u6130\u614C\u6643\u6644\u69A5\u6CC1\u6E5F\u6EC9\u6F62\u714C\u749C\u7687\u7BC1\u7C27\u8352\u8757\u9051\u968D\u9EC3\u532F\u56DE\u5EFB\u5F8A\u6062\u6094\u61F7\u6666\u6703\u6A9C\u6DEE\u6FAE\u7070\u736A\u7E6A\u81BE\u8334\u86D4\u8AA8\u8CC4\u5283\u7372\u5B96\u6A6B\u9404\u54EE\u5686\u5B5D\u6548\u6585\u66C9\u689F\u6D8D\u6DC6"],
      ["fda1", "\u723B\u80B4\u9175\u9A4D\u4FAF\u5019\u539A\u540E\u543C\u5589\u55C5\u5E3F\u5F8C\u673D\u7166\u73DD\u9005\u52DB\u52F3\u5864\u58CE\u7104\u718F\u71FB\u85B0\u8A13\u6688\u85A8\u55A7\u6684\u714A\u8431\u5349\u5599\u6BC1\u5F59\u5FBD\u63EE\u6689\u7147\u8AF1\u8F1D\u9EBE\u4F11\u643A\u70CB\u7566\u8667\u6064\u8B4E\u9DF8\u5147\u51F6\u5308\u6D36\u80F8\u9ED1\u6615\u6B23\u7098\u75D5\u5403\u5C79\u7D07\u8A16\u6B20\u6B3D\u6B46\u5438\u6070\u6D3D\u7FD5\u8208\u50D6\u51DE\u559C\u566B\u56CD\u59EC\u5B09\u5E0C\u6199\u6198\u6231\u665E\u66E6\u7199\u71B9\u71BA\u72A7\u79A7\u7A00\u7FB2\u8A70"]
    ];
  }
});

// node_modules/iconv-lite/encodings/tables/cp950.json
var require_cp950 = __commonJS({
  "node_modules/iconv-lite/encodings/tables/cp950.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127],
      ["a140", "\u3000\uFF0C\u3001\u3002\uFF0E\u2027\uFF1B\uFF1A\uFF1F\uFF01\uFE30\u2026\u2025\uFE50\uFE51\uFE52\xB7\uFE54\uFE55\uFE56\uFE57\uFF5C\u2013\uFE31\u2014\uFE33\u2574\uFE34\uFE4F\uFF08\uFF09\uFE35\uFE36\uFF5B\uFF5D\uFE37\uFE38\u3014\u3015\uFE39\uFE3A\u3010\u3011\uFE3B\uFE3C\u300A\u300B\uFE3D\uFE3E\u3008\u3009\uFE3F\uFE40\u300C\u300D\uFE41\uFE42\u300E\u300F\uFE43\uFE44\uFE59\uFE5A"],
      ["a1a1", "\uFE5B\uFE5C\uFE5D\uFE5E\u2018\u2019\u201C\u201D\u301D\u301E\u2035\u2032\uFF03\uFF06\uFF0A\u203B\xA7\u3003\u25CB\u25CF\u25B3\u25B2\u25CE\u2606\u2605\u25C7\u25C6\u25A1\u25A0\u25BD\u25BC\u32A3\u2105\xAF\uFFE3\uFF3F\u02CD\uFE49\uFE4A\uFE4D\uFE4E\uFE4B\uFE4C\uFE5F\uFE60\uFE61\uFF0B\uFF0D\xD7\xF7\xB1\u221A\uFF1C\uFF1E\uFF1D\u2266\u2267\u2260\u221E\u2252\u2261\uFE62", 4, "\uFF5E\u2229\u222A\u22A5\u2220\u221F\u22BF\u33D2\u33D1\u222B\u222E\u2235\u2234\u2640\u2642\u2295\u2299\u2191\u2193\u2190\u2192\u2196\u2197\u2199\u2198\u2225\u2223\uFF0F"],
      ["a240", "\uFF3C\u2215\uFE68\uFF04\uFFE5\u3012\uFFE0\uFFE1\uFF05\uFF20\u2103\u2109\uFE69\uFE6A\uFE6B\u33D5\u339C\u339D\u339E\u33CE\u33A1\u338E\u338F\u33C4\xB0\u5159\u515B\u515E\u515D\u5161\u5163\u55E7\u74E9\u7CCE\u2581", 7, "\u258F\u258E\u258D\u258C\u258B\u258A\u2589\u253C\u2534\u252C\u2524\u251C\u2594\u2500\u2502\u2595\u250C\u2510\u2514\u2518\u256D"],
      ["a2a1", "\u256E\u2570\u256F\u2550\u255E\u256A\u2561\u25E2\u25E3\u25E5\u25E4\u2571\u2572\u2573\uFF10", 9, "\u2160", 9, "\u3021", 8, "\u5341\u5344\u5345\uFF21", 25, "\uFF41", 21],
      ["a340", "\uFF57\uFF58\uFF59\uFF5A\u0391", 16, "\u03A3", 6, "\u03B1", 16, "\u03C3", 6, "\u3105", 10],
      ["a3a1", "\u3110", 25, "\u02D9\u02C9\u02CA\u02C7\u02CB"],
      ["a3e1", "\u20AC"],
      ["a440", "\u4E00\u4E59\u4E01\u4E03\u4E43\u4E5D\u4E86\u4E8C\u4EBA\u513F\u5165\u516B\u51E0\u5200\u5201\u529B\u5315\u5341\u535C\u53C8\u4E09\u4E0B\u4E08\u4E0A\u4E2B\u4E38\u51E1\u4E45\u4E48\u4E5F\u4E5E\u4E8E\u4EA1\u5140\u5203\u52FA\u5343\u53C9\u53E3\u571F\u58EB\u5915\u5927\u5973\u5B50\u5B51\u5B53\u5BF8\u5C0F\u5C22\u5C38\u5C71\u5DDD\u5DE5\u5DF1\u5DF2\u5DF3\u5DFE\u5E72\u5EFE\u5F0B\u5F13\u624D"],
      ["a4a1", "\u4E11\u4E10\u4E0D\u4E2D\u4E30\u4E39\u4E4B\u5C39\u4E88\u4E91\u4E95\u4E92\u4E94\u4EA2\u4EC1\u4EC0\u4EC3\u4EC6\u4EC7\u4ECD\u4ECA\u4ECB\u4EC4\u5143\u5141\u5167\u516D\u516E\u516C\u5197\u51F6\u5206\u5207\u5208\u52FB\u52FE\u52FF\u5316\u5339\u5348\u5347\u5345\u535E\u5384\u53CB\u53CA\u53CD\u58EC\u5929\u592B\u592A\u592D\u5B54\u5C11\u5C24\u5C3A\u5C6F\u5DF4\u5E7B\u5EFF\u5F14\u5F15\u5FC3\u6208\u6236\u624B\u624E\u652F\u6587\u6597\u65A4\u65B9\u65E5\u66F0\u6708\u6728\u6B20\u6B62\u6B79\u6BCB\u6BD4\u6BDB\u6C0F\u6C34\u706B\u722A\u7236\u723B\u7247\u7259\u725B\u72AC\u738B\u4E19"],
      ["a540", "\u4E16\u4E15\u4E14\u4E18\u4E3B\u4E4D\u4E4F\u4E4E\u4EE5\u4ED8\u4ED4\u4ED5\u4ED6\u4ED7\u4EE3\u4EE4\u4ED9\u4EDE\u5145\u5144\u5189\u518A\u51AC\u51F9\u51FA\u51F8\u520A\u52A0\u529F\u5305\u5306\u5317\u531D\u4EDF\u534A\u5349\u5361\u5360\u536F\u536E\u53BB\u53EF\u53E4\u53F3\u53EC\u53EE\u53E9\u53E8\u53FC\u53F8\u53F5\u53EB\u53E6\u53EA\u53F2\u53F1\u53F0\u53E5\u53ED\u53FB\u56DB\u56DA\u5916"],
      ["a5a1", "\u592E\u5931\u5974\u5976\u5B55\u5B83\u5C3C\u5DE8\u5DE7\u5DE6\u5E02\u5E03\u5E73\u5E7C\u5F01\u5F18\u5F17\u5FC5\u620A\u6253\u6254\u6252\u6251\u65A5\u65E6\u672E\u672C\u672A\u672B\u672D\u6B63\u6BCD\u6C11\u6C10\u6C38\u6C41\u6C40\u6C3E\u72AF\u7384\u7389\u74DC\u74E6\u7518\u751F\u7528\u7529\u7530\u7531\u7532\u7533\u758B\u767D\u76AE\u76BF\u76EE\u77DB\u77E2\u77F3\u793A\u79BE\u7A74\u7ACB\u4E1E\u4E1F\u4E52\u4E53\u4E69\u4E99\u4EA4\u4EA6\u4EA5\u4EFF\u4F09\u4F19\u4F0A\u4F15\u4F0D\u4F10\u4F11\u4F0F\u4EF2\u4EF6\u4EFB\u4EF0\u4EF3\u4EFD\u4F01\u4F0B\u5149\u5147\u5146\u5148\u5168"],
      ["a640", "\u5171\u518D\u51B0\u5217\u5211\u5212\u520E\u5216\u52A3\u5308\u5321\u5320\u5370\u5371\u5409\u540F\u540C\u540A\u5410\u5401\u540B\u5404\u5411\u540D\u5408\u5403\u540E\u5406\u5412\u56E0\u56DE\u56DD\u5733\u5730\u5728\u572D\u572C\u572F\u5729\u5919\u591A\u5937\u5938\u5984\u5978\u5983\u597D\u5979\u5982\u5981\u5B57\u5B58\u5B87\u5B88\u5B85\u5B89\u5BFA\u5C16\u5C79\u5DDE\u5E06\u5E76\u5E74"],
      ["a6a1", "\u5F0F\u5F1B\u5FD9\u5FD6\u620E\u620C\u620D\u6210\u6263\u625B\u6258\u6536\u65E9\u65E8\u65EC\u65ED\u66F2\u66F3\u6709\u673D\u6734\u6731\u6735\u6B21\u6B64\u6B7B\u6C16\u6C5D\u6C57\u6C59\u6C5F\u6C60\u6C50\u6C55\u6C61\u6C5B\u6C4D\u6C4E\u7070\u725F\u725D\u767E\u7AF9\u7C73\u7CF8\u7F36\u7F8A\u7FBD\u8001\u8003\u800C\u8012\u8033\u807F\u8089\u808B\u808C\u81E3\u81EA\u81F3\u81FC\u820C\u821B\u821F\u826E\u8272\u827E\u866B\u8840\u884C\u8863\u897F\u9621\u4E32\u4EA8\u4F4D\u4F4F\u4F47\u4F57\u4F5E\u4F34\u4F5B\u4F55\u4F30\u4F50\u4F51\u4F3D\u4F3A\u4F38\u4F43\u4F54\u4F3C\u4F46\u4F63"],
      ["a740", "\u4F5C\u4F60\u4F2F\u4F4E\u4F36\u4F59\u4F5D\u4F48\u4F5A\u514C\u514B\u514D\u5175\u51B6\u51B7\u5225\u5224\u5229\u522A\u5228\u52AB\u52A9\u52AA\u52AC\u5323\u5373\u5375\u541D\u542D\u541E\u543E\u5426\u544E\u5427\u5446\u5443\u5433\u5448\u5442\u541B\u5429\u544A\u5439\u543B\u5438\u542E\u5435\u5436\u5420\u543C\u5440\u5431\u542B\u541F\u542C\u56EA\u56F0\u56E4\u56EB\u574A\u5751\u5740\u574D"],
      ["a7a1", "\u5747\u574E\u573E\u5750\u574F\u573B\u58EF\u593E\u599D\u5992\u59A8\u599E\u59A3\u5999\u5996\u598D\u59A4\u5993\u598A\u59A5\u5B5D\u5B5C\u5B5A\u5B5B\u5B8C\u5B8B\u5B8F\u5C2C\u5C40\u5C41\u5C3F\u5C3E\u5C90\u5C91\u5C94\u5C8C\u5DEB\u5E0C\u5E8F\u5E87\u5E8A\u5EF7\u5F04\u5F1F\u5F64\u5F62\u5F77\u5F79\u5FD8\u5FCC\u5FD7\u5FCD\u5FF1\u5FEB\u5FF8\u5FEA\u6212\u6211\u6284\u6297\u6296\u6280\u6276\u6289\u626D\u628A\u627C\u627E\u6279\u6273\u6292\u626F\u6298\u626E\u6295\u6293\u6291\u6286\u6539\u653B\u6538\u65F1\u66F4\u675F\u674E\u674F\u6750\u6751\u675C\u6756\u675E\u6749\u6746\u6760"],
      ["a840", "\u6753\u6757\u6B65\u6BCF\u6C42\u6C5E\u6C99\u6C81\u6C88\u6C89\u6C85\u6C9B\u6C6A\u6C7A\u6C90\u6C70\u6C8C\u6C68\u6C96\u6C92\u6C7D\u6C83\u6C72\u6C7E\u6C74\u6C86\u6C76\u6C8D\u6C94\u6C98\u6C82\u7076\u707C\u707D\u7078\u7262\u7261\u7260\u72C4\u72C2\u7396\u752C\u752B\u7537\u7538\u7682\u76EF\u77E3\u79C1\u79C0\u79BF\u7A76\u7CFB\u7F55\u8096\u8093\u809D\u8098\u809B\u809A\u80B2\u826F\u8292"],
      ["a8a1", "\u828B\u828D\u898B\u89D2\u8A00\u8C37\u8C46\u8C55\u8C9D\u8D64\u8D70\u8DB3\u8EAB\u8ECA\u8F9B\u8FB0\u8FC2\u8FC6\u8FC5\u8FC4\u5DE1\u9091\u90A2\u90AA\u90A6\u90A3\u9149\u91C6\u91CC\u9632\u962E\u9631\u962A\u962C\u4E26\u4E56\u4E73\u4E8B\u4E9B\u4E9E\u4EAB\u4EAC\u4F6F\u4F9D\u4F8D\u4F73\u4F7F\u4F6C\u4F9B\u4F8B\u4F86\u4F83\u4F70\u4F75\u4F88\u4F69\u4F7B\u4F96\u4F7E\u4F8F\u4F91\u4F7A\u5154\u5152\u5155\u5169\u5177\u5176\u5178\u51BD\u51FD\u523B\u5238\u5237\u523A\u5230\u522E\u5236\u5241\u52BE\u52BB\u5352\u5354\u5353\u5351\u5366\u5377\u5378\u5379\u53D6\u53D4\u53D7\u5473\u5475"],
      ["a940", "\u5496\u5478\u5495\u5480\u547B\u5477\u5484\u5492\u5486\u547C\u5490\u5471\u5476\u548C\u549A\u5462\u5468\u548B\u547D\u548E\u56FA\u5783\u5777\u576A\u5769\u5761\u5766\u5764\u577C\u591C\u5949\u5947\u5948\u5944\u5954\u59BE\u59BB\u59D4\u59B9\u59AE\u59D1\u59C6\u59D0\u59CD\u59CB\u59D3\u59CA\u59AF\u59B3\u59D2\u59C5\u5B5F\u5B64\u5B63\u5B97\u5B9A\u5B98\u5B9C\u5B99\u5B9B\u5C1A\u5C48\u5C45"],
      ["a9a1", "\u5C46\u5CB7\u5CA1\u5CB8\u5CA9\u5CAB\u5CB1\u5CB3\u5E18\u5E1A\u5E16\u5E15\u5E1B\u5E11\u5E78\u5E9A\u5E97\u5E9C\u5E95\u5E96\u5EF6\u5F26\u5F27\u5F29\u5F80\u5F81\u5F7F\u5F7C\u5FDD\u5FE0\u5FFD\u5FF5\u5FFF\u600F\u6014\u602F\u6035\u6016\u602A\u6015\u6021\u6027\u6029\u602B\u601B\u6216\u6215\u623F\u623E\u6240\u627F\u62C9\u62CC\u62C4\u62BF\u62C2\u62B9\u62D2\u62DB\u62AB\u62D3\u62D4\u62CB\u62C8\u62A8\u62BD\u62BC\u62D0\u62D9\u62C7\u62CD\u62B5\u62DA\u62B1\u62D8\u62D6\u62D7\u62C6\u62AC\u62CE\u653E\u65A7\u65BC\u65FA\u6614\u6613\u660C\u6606\u6602\u660E\u6600\u660F\u6615\u660A"],
      ["aa40", "\u6607\u670D\u670B\u676D\u678B\u6795\u6771\u679C\u6773\u6777\u6787\u679D\u6797\u676F\u6770\u677F\u6789\u677E\u6790\u6775\u679A\u6793\u677C\u676A\u6772\u6B23\u6B66\u6B67\u6B7F\u6C13\u6C1B\u6CE3\u6CE8\u6CF3\u6CB1\u6CCC\u6CE5\u6CB3\u6CBD\u6CBE\u6CBC\u6CE2\u6CAB\u6CD5\u6CD3\u6CB8\u6CC4\u6CB9\u6CC1\u6CAE\u6CD7\u6CC5\u6CF1\u6CBF\u6CBB\u6CE1\u6CDB\u6CCA\u6CAC\u6CEF\u6CDC\u6CD6\u6CE0"],
      ["aaa1", "\u7095\u708E\u7092\u708A\u7099\u722C\u722D\u7238\u7248\u7267\u7269\u72C0\u72CE\u72D9\u72D7\u72D0\u73A9\u73A8\u739F\u73AB\u73A5\u753D\u759D\u7599\u759A\u7684\u76C2\u76F2\u76F4\u77E5\u77FD\u793E\u7940\u7941\u79C9\u79C8\u7A7A\u7A79\u7AFA\u7CFE\u7F54\u7F8C\u7F8B\u8005\u80BA\u80A5\u80A2\u80B1\u80A1\u80AB\u80A9\u80B4\u80AA\u80AF\u81E5\u81FE\u820D\u82B3\u829D\u8299\u82AD\u82BD\u829F\u82B9\u82B1\u82AC\u82A5\u82AF\u82B8\u82A3\u82B0\u82BE\u82B7\u864E\u8671\u521D\u8868\u8ECB\u8FCE\u8FD4\u8FD1\u90B5\u90B8\u90B1\u90B6\u91C7\u91D1\u9577\u9580\u961C\u9640\u963F\u963B\u9644"],
      ["ab40", "\u9642\u96B9\u96E8\u9752\u975E\u4E9F\u4EAD\u4EAE\u4FE1\u4FB5\u4FAF\u4FBF\u4FE0\u4FD1\u4FCF\u4FDD\u4FC3\u4FB6\u4FD8\u4FDF\u4FCA\u4FD7\u4FAE\u4FD0\u4FC4\u4FC2\u4FDA\u4FCE\u4FDE\u4FB7\u5157\u5192\u5191\u51A0\u524E\u5243\u524A\u524D\u524C\u524B\u5247\u52C7\u52C9\u52C3\u52C1\u530D\u5357\u537B\u539A\u53DB\u54AC\u54C0\u54A8\u54CE\u54C9\u54B8\u54A6\u54B3\u54C7\u54C2\u54BD\u54AA\u54C1"],
      ["aba1", "\u54C4\u54C8\u54AF\u54AB\u54B1\u54BB\u54A9\u54A7\u54BF\u56FF\u5782\u578B\u57A0\u57A3\u57A2\u57CE\u57AE\u5793\u5955\u5951\u594F\u594E\u5950\u59DC\u59D8\u59FF\u59E3\u59E8\u5A03\u59E5\u59EA\u59DA\u59E6\u5A01\u59FB\u5B69\u5BA3\u5BA6\u5BA4\u5BA2\u5BA5\u5C01\u5C4E\u5C4F\u5C4D\u5C4B\u5CD9\u5CD2\u5DF7\u5E1D\u5E25\u5E1F\u5E7D\u5EA0\u5EA6\u5EFA\u5F08\u5F2D\u5F65\u5F88\u5F85\u5F8A\u5F8B\u5F87\u5F8C\u5F89\u6012\u601D\u6020\u6025\u600E\u6028\u604D\u6070\u6068\u6062\u6046\u6043\u606C\u606B\u606A\u6064\u6241\u62DC\u6316\u6309\u62FC\u62ED\u6301\u62EE\u62FD\u6307\u62F1\u62F7"],
      ["ac40", "\u62EF\u62EC\u62FE\u62F4\u6311\u6302\u653F\u6545\u65AB\u65BD\u65E2\u6625\u662D\u6620\u6627\u662F\u661F\u6628\u6631\u6624\u66F7\u67FF\u67D3\u67F1\u67D4\u67D0\u67EC\u67B6\u67AF\u67F5\u67E9\u67EF\u67C4\u67D1\u67B4\u67DA\u67E5\u67B8\u67CF\u67DE\u67F3\u67B0\u67D9\u67E2\u67DD\u67D2\u6B6A\u6B83\u6B86\u6BB5\u6BD2\u6BD7\u6C1F\u6CC9\u6D0B\u6D32\u6D2A\u6D41\u6D25\u6D0C\u6D31\u6D1E\u6D17"],
      ["aca1", "\u6D3B\u6D3D\u6D3E\u6D36\u6D1B\u6CF5\u6D39\u6D27\u6D38\u6D29\u6D2E\u6D35\u6D0E\u6D2B\u70AB\u70BA\u70B3\u70AC\u70AF\u70AD\u70B8\u70AE\u70A4\u7230\u7272\u726F\u7274\u72E9\u72E0\u72E1\u73B7\u73CA\u73BB\u73B2\u73CD\u73C0\u73B3\u751A\u752D\u754F\u754C\u754E\u754B\u75AB\u75A4\u75A5\u75A2\u75A3\u7678\u7686\u7687\u7688\u76C8\u76C6\u76C3\u76C5\u7701\u76F9\u76F8\u7709\u770B\u76FE\u76FC\u7707\u77DC\u7802\u7814\u780C\u780D\u7946\u7949\u7948\u7947\u79B9\u79BA\u79D1\u79D2\u79CB\u7A7F\u7A81\u7AFF\u7AFD\u7C7D\u7D02\u7D05\u7D00\u7D09\u7D07\u7D04\u7D06\u7F38\u7F8E\u7FBF\u8004"],
      ["ad40", "\u8010\u800D\u8011\u8036\u80D6\u80E5\u80DA\u80C3\u80C4\u80CC\u80E1\u80DB\u80CE\u80DE\u80E4\u80DD\u81F4\u8222\u82E7\u8303\u8305\u82E3\u82DB\u82E6\u8304\u82E5\u8302\u8309\u82D2\u82D7\u82F1\u8301\u82DC\u82D4\u82D1\u82DE\u82D3\u82DF\u82EF\u8306\u8650\u8679\u867B\u867A\u884D\u886B\u8981\u89D4\u8A08\u8A02\u8A03\u8C9E\u8CA0\u8D74\u8D73\u8DB4\u8ECD\u8ECC\u8FF0\u8FE6\u8FE2\u8FEA\u8FE5"],
      ["ada1", "\u8FED\u8FEB\u8FE4\u8FE8\u90CA\u90CE\u90C1\u90C3\u914B\u914A\u91CD\u9582\u9650\u964B\u964C\u964D\u9762\u9769\u97CB\u97ED\u97F3\u9801\u98A8\u98DB\u98DF\u9996\u9999\u4E58\u4EB3\u500C\u500D\u5023\u4FEF\u5026\u5025\u4FF8\u5029\u5016\u5006\u503C\u501F\u501A\u5012\u5011\u4FFA\u5000\u5014\u5028\u4FF1\u5021\u500B\u5019\u5018\u4FF3\u4FEE\u502D\u502A\u4FFE\u502B\u5009\u517C\u51A4\u51A5\u51A2\u51CD\u51CC\u51C6\u51CB\u5256\u525C\u5254\u525B\u525D\u532A\u537F\u539F\u539D\u53DF\u54E8\u5510\u5501\u5537\u54FC\u54E5\u54F2\u5506\u54FA\u5514\u54E9\u54ED\u54E1\u5509\u54EE\u54EA"],
      ["ae40", "\u54E6\u5527\u5507\u54FD\u550F\u5703\u5704\u57C2\u57D4\u57CB\u57C3\u5809\u590F\u5957\u5958\u595A\u5A11\u5A18\u5A1C\u5A1F\u5A1B\u5A13\u59EC\u5A20\u5A23\u5A29\u5A25\u5A0C\u5A09\u5B6B\u5C58\u5BB0\u5BB3\u5BB6\u5BB4\u5BAE\u5BB5\u5BB9\u5BB8\u5C04\u5C51\u5C55\u5C50\u5CED\u5CFD\u5CFB\u5CEA\u5CE8\u5CF0\u5CF6\u5D01\u5CF4\u5DEE\u5E2D\u5E2B\u5EAB\u5EAD\u5EA7\u5F31\u5F92\u5F91\u5F90\u6059"],
      ["aea1", "\u6063\u6065\u6050\u6055\u606D\u6069\u606F\u6084\u609F\u609A\u608D\u6094\u608C\u6085\u6096\u6247\u62F3\u6308\u62FF\u634E\u633E\u632F\u6355\u6342\u6346\u634F\u6349\u633A\u6350\u633D\u632A\u632B\u6328\u634D\u634C\u6548\u6549\u6599\u65C1\u65C5\u6642\u6649\u664F\u6643\u6652\u664C\u6645\u6641\u66F8\u6714\u6715\u6717\u6821\u6838\u6848\u6846\u6853\u6839\u6842\u6854\u6829\u68B3\u6817\u684C\u6851\u683D\u67F4\u6850\u6840\u683C\u6843\u682A\u6845\u6813\u6818\u6841\u6B8A\u6B89\u6BB7\u6C23\u6C27\u6C28\u6C26\u6C24\u6CF0\u6D6A\u6D95\u6D88\u6D87\u6D66\u6D78\u6D77\u6D59\u6D93"],
      ["af40", "\u6D6C\u6D89\u6D6E\u6D5A\u6D74\u6D69\u6D8C\u6D8A\u6D79\u6D85\u6D65\u6D94\u70CA\u70D8\u70E4\u70D9\u70C8\u70CF\u7239\u7279\u72FC\u72F9\u72FD\u72F8\u72F7\u7386\u73ED\u7409\u73EE\u73E0\u73EA\u73DE\u7554\u755D\u755C\u755A\u7559\u75BE\u75C5\u75C7\u75B2\u75B3\u75BD\u75BC\u75B9\u75C2\u75B8\u768B\u76B0\u76CA\u76CD\u76CE\u7729\u771F\u7720\u7728\u77E9\u7830\u7827\u7838\u781D\u7834\u7837"],
      ["afa1", "\u7825\u782D\u7820\u781F\u7832\u7955\u7950\u7960\u795F\u7956\u795E\u795D\u7957\u795A\u79E4\u79E3\u79E7\u79DF\u79E6\u79E9\u79D8\u7A84\u7A88\u7AD9\u7B06\u7B11\u7C89\u7D21\u7D17\u7D0B\u7D0A\u7D20\u7D22\u7D14\u7D10\u7D15\u7D1A\u7D1C\u7D0D\u7D19\u7D1B\u7F3A\u7F5F\u7F94\u7FC5\u7FC1\u8006\u8018\u8015\u8019\u8017\u803D\u803F\u80F1\u8102\u80F0\u8105\u80ED\u80F4\u8106\u80F8\u80F3\u8108\u80FD\u810A\u80FC\u80EF\u81ED\u81EC\u8200\u8210\u822A\u822B\u8228\u822C\u82BB\u832B\u8352\u8354\u834A\u8338\u8350\u8349\u8335\u8334\u834F\u8332\u8339\u8336\u8317\u8340\u8331\u8328\u8343"],
      ["b040", "\u8654\u868A\u86AA\u8693\u86A4\u86A9\u868C\u86A3\u869C\u8870\u8877\u8881\u8882\u887D\u8879\u8A18\u8A10\u8A0E\u8A0C\u8A15\u8A0A\u8A17\u8A13\u8A16\u8A0F\u8A11\u8C48\u8C7A\u8C79\u8CA1\u8CA2\u8D77\u8EAC\u8ED2\u8ED4\u8ECF\u8FB1\u9001\u9006\u8FF7\u9000\u8FFA\u8FF4\u9003\u8FFD\u9005\u8FF8\u9095\u90E1\u90DD\u90E2\u9152\u914D\u914C\u91D8\u91DD\u91D7\u91DC\u91D9\u9583\u9662\u9663\u9661"],
      ["b0a1", "\u965B\u965D\u9664\u9658\u965E\u96BB\u98E2\u99AC\u9AA8\u9AD8\u9B25\u9B32\u9B3C\u4E7E\u507A\u507D\u505C\u5047\u5043\u504C\u505A\u5049\u5065\u5076\u504E\u5055\u5075\u5074\u5077\u504F\u500F\u506F\u506D\u515C\u5195\u51F0\u526A\u526F\u52D2\u52D9\u52D8\u52D5\u5310\u530F\u5319\u533F\u5340\u533E\u53C3\u66FC\u5546\u556A\u5566\u5544\u555E\u5561\u5543\u554A\u5531\u5556\u554F\u5555\u552F\u5564\u5538\u552E\u555C\u552C\u5563\u5533\u5541\u5557\u5708\u570B\u5709\u57DF\u5805\u580A\u5806\u57E0\u57E4\u57FA\u5802\u5835\u57F7\u57F9\u5920\u5962\u5A36\u5A41\u5A49\u5A66\u5A6A\u5A40"],
      ["b140", "\u5A3C\u5A62\u5A5A\u5A46\u5A4A\u5B70\u5BC7\u5BC5\u5BC4\u5BC2\u5BBF\u5BC6\u5C09\u5C08\u5C07\u5C60\u5C5C\u5C5D\u5D07\u5D06\u5D0E\u5D1B\u5D16\u5D22\u5D11\u5D29\u5D14\u5D19\u5D24\u5D27\u5D17\u5DE2\u5E38\u5E36\u5E33\u5E37\u5EB7\u5EB8\u5EB6\u5EB5\u5EBE\u5F35\u5F37\u5F57\u5F6C\u5F69\u5F6B\u5F97\u5F99\u5F9E\u5F98\u5FA1\u5FA0\u5F9C\u607F\u60A3\u6089\u60A0\u60A8\u60CB\u60B4\u60E6\u60BD"],
      ["b1a1", "\u60C5\u60BB\u60B5\u60DC\u60BC\u60D8\u60D5\u60C6\u60DF\u60B8\u60DA\u60C7\u621A\u621B\u6248\u63A0\u63A7\u6372\u6396\u63A2\u63A5\u6377\u6367\u6398\u63AA\u6371\u63A9\u6389\u6383\u639B\u636B\u63A8\u6384\u6388\u6399\u63A1\u63AC\u6392\u638F\u6380\u637B\u6369\u6368\u637A\u655D\u6556\u6551\u6559\u6557\u555F\u654F\u6558\u6555\u6554\u659C\u659B\u65AC\u65CF\u65CB\u65CC\u65CE\u665D\u665A\u6664\u6668\u6666\u665E\u66F9\u52D7\u671B\u6881\u68AF\u68A2\u6893\u68B5\u687F\u6876\u68B1\u68A7\u6897\u68B0\u6883\u68C4\u68AD\u6886\u6885\u6894\u689D\u68A8\u689F\u68A1\u6882\u6B32\u6BBA"],
      ["b240", "\u6BEB\u6BEC\u6C2B\u6D8E\u6DBC\u6DF3\u6DD9\u6DB2\u6DE1\u6DCC\u6DE4\u6DFB\u6DFA\u6E05\u6DC7\u6DCB\u6DAF\u6DD1\u6DAE\u6DDE\u6DF9\u6DB8\u6DF7\u6DF5\u6DC5\u6DD2\u6E1A\u6DB5\u6DDA\u6DEB\u6DD8\u6DEA\u6DF1\u6DEE\u6DE8\u6DC6\u6DC4\u6DAA\u6DEC\u6DBF\u6DE6\u70F9\u7109\u710A\u70FD\u70EF\u723D\u727D\u7281\u731C\u731B\u7316\u7313\u7319\u7387\u7405\u740A\u7403\u7406\u73FE\u740D\u74E0\u74F6"],
      ["b2a1", "\u74F7\u751C\u7522\u7565\u7566\u7562\u7570\u758F\u75D4\u75D5\u75B5\u75CA\u75CD\u768E\u76D4\u76D2\u76DB\u7737\u773E\u773C\u7736\u7738\u773A\u786B\u7843\u784E\u7965\u7968\u796D\u79FB\u7A92\u7A95\u7B20\u7B28\u7B1B\u7B2C\u7B26\u7B19\u7B1E\u7B2E\u7C92\u7C97\u7C95\u7D46\u7D43\u7D71\u7D2E\u7D39\u7D3C\u7D40\u7D30\u7D33\u7D44\u7D2F\u7D42\u7D32\u7D31\u7F3D\u7F9E\u7F9A\u7FCC\u7FCE\u7FD2\u801C\u804A\u8046\u812F\u8116\u8123\u812B\u8129\u8130\u8124\u8202\u8235\u8237\u8236\u8239\u838E\u839E\u8398\u8378\u83A2\u8396\u83BD\u83AB\u8392\u838A\u8393\u8389\u83A0\u8377\u837B\u837C"],
      ["b340", "\u8386\u83A7\u8655\u5F6A\u86C7\u86C0\u86B6\u86C4\u86B5\u86C6\u86CB\u86B1\u86AF\u86C9\u8853\u889E\u8888\u88AB\u8892\u8896\u888D\u888B\u8993\u898F\u8A2A\u8A1D\u8A23\u8A25\u8A31\u8A2D\u8A1F\u8A1B\u8A22\u8C49\u8C5A\u8CA9\u8CAC\u8CAB\u8CA8\u8CAA\u8CA7\u8D67\u8D66\u8DBE\u8DBA\u8EDB\u8EDF\u9019\u900D\u901A\u9017\u9023\u901F\u901D\u9010\u9015\u901E\u9020\u900F\u9022\u9016\u901B\u9014"],
      ["b3a1", "\u90E8\u90ED\u90FD\u9157\u91CE\u91F5\u91E6\u91E3\u91E7\u91ED\u91E9\u9589\u966A\u9675\u9673\u9678\u9670\u9674\u9676\u9677\u966C\u96C0\u96EA\u96E9\u7AE0\u7ADF\u9802\u9803\u9B5A\u9CE5\u9E75\u9E7F\u9EA5\u9EBB\u50A2\u508D\u5085\u5099\u5091\u5080\u5096\u5098\u509A\u6700\u51F1\u5272\u5274\u5275\u5269\u52DE\u52DD\u52DB\u535A\u53A5\u557B\u5580\u55A7\u557C\u558A\u559D\u5598\u5582\u559C\u55AA\u5594\u5587\u558B\u5583\u55B3\u55AE\u559F\u553E\u55B2\u559A\u55BB\u55AC\u55B1\u557E\u5589\u55AB\u5599\u570D\u582F\u582A\u5834\u5824\u5830\u5831\u5821\u581D\u5820\u58F9\u58FA\u5960"],
      ["b440", "\u5A77\u5A9A\u5A7F\u5A92\u5A9B\u5AA7\u5B73\u5B71\u5BD2\u5BCC\u5BD3\u5BD0\u5C0A\u5C0B\u5C31\u5D4C\u5D50\u5D34\u5D47\u5DFD\u5E45\u5E3D\u5E40\u5E43\u5E7E\u5ECA\u5EC1\u5EC2\u5EC4\u5F3C\u5F6D\u5FA9\u5FAA\u5FA8\u60D1\u60E1\u60B2\u60B6\u60E0\u611C\u6123\u60FA\u6115\u60F0\u60FB\u60F4\u6168\u60F1\u610E\u60F6\u6109\u6100\u6112\u621F\u6249\u63A3\u638C\u63CF\u63C0\u63E9\u63C9\u63C6\u63CD"],
      ["b4a1", "\u63D2\u63E3\u63D0\u63E1\u63D6\u63ED\u63EE\u6376\u63F4\u63EA\u63DB\u6452\u63DA\u63F9\u655E\u6566\u6562\u6563\u6591\u6590\u65AF\u666E\u6670\u6674\u6676\u666F\u6691\u667A\u667E\u6677\u66FE\u66FF\u671F\u671D\u68FA\u68D5\u68E0\u68D8\u68D7\u6905\u68DF\u68F5\u68EE\u68E7\u68F9\u68D2\u68F2\u68E3\u68CB\u68CD\u690D\u6912\u690E\u68C9\u68DA\u696E\u68FB\u6B3E\u6B3A\u6B3D\u6B98\u6B96\u6BBC\u6BEF\u6C2E\u6C2F\u6C2C\u6E2F\u6E38\u6E54\u6E21\u6E32\u6E67\u6E4A\u6E20\u6E25\u6E23\u6E1B\u6E5B\u6E58\u6E24\u6E56\u6E6E\u6E2D\u6E26\u6E6F\u6E34\u6E4D\u6E3A\u6E2C\u6E43\u6E1D\u6E3E\u6ECB"],
      ["b540", "\u6E89\u6E19\u6E4E\u6E63\u6E44\u6E72\u6E69\u6E5F\u7119\u711A\u7126\u7130\u7121\u7136\u716E\u711C\u724C\u7284\u7280\u7336\u7325\u7334\u7329\u743A\u742A\u7433\u7422\u7425\u7435\u7436\u7434\u742F\u741B\u7426\u7428\u7525\u7526\u756B\u756A\u75E2\u75DB\u75E3\u75D9\u75D8\u75DE\u75E0\u767B\u767C\u7696\u7693\u76B4\u76DC\u774F\u77ED\u785D\u786C\u786F\u7A0D\u7A08\u7A0B\u7A05\u7A00\u7A98"],
      ["b5a1", "\u7A97\u7A96\u7AE5\u7AE3\u7B49\u7B56\u7B46\u7B50\u7B52\u7B54\u7B4D\u7B4B\u7B4F\u7B51\u7C9F\u7CA5\u7D5E\u7D50\u7D68\u7D55\u7D2B\u7D6E\u7D72\u7D61\u7D66\u7D62\u7D70\u7D73\u5584\u7FD4\u7FD5\u800B\u8052\u8085\u8155\u8154\u814B\u8151\u814E\u8139\u8146\u813E\u814C\u8153\u8174\u8212\u821C\u83E9\u8403\u83F8\u840D\u83E0\u83C5\u840B\u83C1\u83EF\u83F1\u83F4\u8457\u840A\u83F0\u840C\u83CC\u83FD\u83F2\u83CA\u8438\u840E\u8404\u83DC\u8407\u83D4\u83DF\u865B\u86DF\u86D9\u86ED\u86D4\u86DB\u86E4\u86D0\u86DE\u8857\u88C1\u88C2\u88B1\u8983\u8996\u8A3B\u8A60\u8A55\u8A5E\u8A3C\u8A41"],
      ["b640", "\u8A54\u8A5B\u8A50\u8A46\u8A34\u8A3A\u8A36\u8A56\u8C61\u8C82\u8CAF\u8CBC\u8CB3\u8CBD\u8CC1\u8CBB\u8CC0\u8CB4\u8CB7\u8CB6\u8CBF\u8CB8\u8D8A\u8D85\u8D81\u8DCE\u8DDD\u8DCB\u8DDA\u8DD1\u8DCC\u8DDB\u8DC6\u8EFB\u8EF8\u8EFC\u8F9C\u902E\u9035\u9031\u9038\u9032\u9036\u9102\u90F5\u9109\u90FE\u9163\u9165\u91CF\u9214\u9215\u9223\u9209\u921E\u920D\u9210\u9207\u9211\u9594\u958F\u958B\u9591"],
      ["b6a1", "\u9593\u9592\u958E\u968A\u968E\u968B\u967D\u9685\u9686\u968D\u9672\u9684\u96C1\u96C5\u96C4\u96C6\u96C7\u96EF\u96F2\u97CC\u9805\u9806\u9808\u98E7\u98EA\u98EF\u98E9\u98F2\u98ED\u99AE\u99AD\u9EC3\u9ECD\u9ED1\u4E82\u50AD\u50B5\u50B2\u50B3\u50C5\u50BE\u50AC\u50B7\u50BB\u50AF\u50C7\u527F\u5277\u527D\u52DF\u52E6\u52E4\u52E2\u52E3\u532F\u55DF\u55E8\u55D3\u55E6\u55CE\u55DC\u55C7\u55D1\u55E3\u55E4\u55EF\u55DA\u55E1\u55C5\u55C6\u55E5\u55C9\u5712\u5713\u585E\u5851\u5858\u5857\u585A\u5854\u586B\u584C\u586D\u584A\u5862\u5852\u584B\u5967\u5AC1\u5AC9\u5ACC\u5ABE\u5ABD\u5ABC"],
      ["b740", "\u5AB3\u5AC2\u5AB2\u5D69\u5D6F\u5E4C\u5E79\u5EC9\u5EC8\u5F12\u5F59\u5FAC\u5FAE\u611A\u610F\u6148\u611F\u60F3\u611B\u60F9\u6101\u6108\u614E\u614C\u6144\u614D\u613E\u6134\u6127\u610D\u6106\u6137\u6221\u6222\u6413\u643E\u641E\u642A\u642D\u643D\u642C\u640F\u641C\u6414\u640D\u6436\u6416\u6417\u6406\u656C\u659F\u65B0\u6697\u6689\u6687\u6688\u6696\u6684\u6698\u668D\u6703\u6994\u696D"],
      ["b7a1", "\u695A\u6977\u6960\u6954\u6975\u6930\u6982\u694A\u6968\u696B\u695E\u6953\u6979\u6986\u695D\u6963\u695B\u6B47\u6B72\u6BC0\u6BBF\u6BD3\u6BFD\u6EA2\u6EAF\u6ED3\u6EB6\u6EC2\u6E90\u6E9D\u6EC7\u6EC5\u6EA5\u6E98\u6EBC\u6EBA\u6EAB\u6ED1\u6E96\u6E9C\u6EC4\u6ED4\u6EAA\u6EA7\u6EB4\u714E\u7159\u7169\u7164\u7149\u7167\u715C\u716C\u7166\u714C\u7165\u715E\u7146\u7168\u7156\u723A\u7252\u7337\u7345\u733F\u733E\u746F\u745A\u7455\u745F\u745E\u7441\u743F\u7459\u745B\u745C\u7576\u7578\u7600\u75F0\u7601\u75F2\u75F1\u75FA\u75FF\u75F4\u75F3\u76DE\u76DF\u775B\u776B\u7766\u775E\u7763"],
      ["b840", "\u7779\u776A\u776C\u775C\u7765\u7768\u7762\u77EE\u788E\u78B0\u7897\u7898\u788C\u7889\u787C\u7891\u7893\u787F\u797A\u797F\u7981\u842C\u79BD\u7A1C\u7A1A\u7A20\u7A14\u7A1F\u7A1E\u7A9F\u7AA0\u7B77\u7BC0\u7B60\u7B6E\u7B67\u7CB1\u7CB3\u7CB5\u7D93\u7D79\u7D91\u7D81\u7D8F\u7D5B\u7F6E\u7F69\u7F6A\u7F72\u7FA9\u7FA8\u7FA4\u8056\u8058\u8086\u8084\u8171\u8170\u8178\u8165\u816E\u8173\u816B"],
      ["b8a1", "\u8179\u817A\u8166\u8205\u8247\u8482\u8477\u843D\u8431\u8475\u8466\u846B\u8449\u846C\u845B\u843C\u8435\u8461\u8463\u8469\u846D\u8446\u865E\u865C\u865F\u86F9\u8713\u8708\u8707\u8700\u86FE\u86FB\u8702\u8703\u8706\u870A\u8859\u88DF\u88D4\u88D9\u88DC\u88D8\u88DD\u88E1\u88CA\u88D5\u88D2\u899C\u89E3\u8A6B\u8A72\u8A73\u8A66\u8A69\u8A70\u8A87\u8A7C\u8A63\u8AA0\u8A71\u8A85\u8A6D\u8A62\u8A6E\u8A6C\u8A79\u8A7B\u8A3E\u8A68\u8C62\u8C8A\u8C89\u8CCA\u8CC7\u8CC8\u8CC4\u8CB2\u8CC3\u8CC2\u8CC5\u8DE1\u8DDF\u8DE8\u8DEF\u8DF3\u8DFA\u8DEA\u8DE4\u8DE6\u8EB2\u8F03\u8F09\u8EFE\u8F0A"],
      ["b940", "\u8F9F\u8FB2\u904B\u904A\u9053\u9042\u9054\u903C\u9055\u9050\u9047\u904F\u904E\u904D\u9051\u903E\u9041\u9112\u9117\u916C\u916A\u9169\u91C9\u9237\u9257\u9238\u923D\u9240\u923E\u925B\u924B\u9264\u9251\u9234\u9249\u924D\u9245\u9239\u923F\u925A\u9598\u9698\u9694\u9695\u96CD\u96CB\u96C9\u96CA\u96F7\u96FB\u96F9\u96F6\u9756\u9774\u9776\u9810\u9811\u9813\u980A\u9812\u980C\u98FC\u98F4"],
      ["b9a1", "\u98FD\u98FE\u99B3\u99B1\u99B4\u9AE1\u9CE9\u9E82\u9F0E\u9F13\u9F20\u50E7\u50EE\u50E5\u50D6\u50ED\u50DA\u50D5\u50CF\u50D1\u50F1\u50CE\u50E9\u5162\u51F3\u5283\u5282\u5331\u53AD\u55FE\u5600\u561B\u5617\u55FD\u5614\u5606\u5609\u560D\u560E\u55F7\u5616\u561F\u5608\u5610\u55F6\u5718\u5716\u5875\u587E\u5883\u5893\u588A\u5879\u5885\u587D\u58FD\u5925\u5922\u5924\u596A\u5969\u5AE1\u5AE6\u5AE9\u5AD7\u5AD6\u5AD8\u5AE3\u5B75\u5BDE\u5BE7\u5BE1\u5BE5\u5BE6\u5BE8\u5BE2\u5BE4\u5BDF\u5C0D\u5C62\u5D84\u5D87\u5E5B\u5E63\u5E55\u5E57\u5E54\u5ED3\u5ED6\u5F0A\u5F46\u5F70\u5FB9\u6147"],
      ["ba40", "\u613F\u614B\u6177\u6162\u6163\u615F\u615A\u6158\u6175\u622A\u6487\u6458\u6454\u64A4\u6478\u645F\u647A\u6451\u6467\u6434\u646D\u647B\u6572\u65A1\u65D7\u65D6\u66A2\u66A8\u669D\u699C\u69A8\u6995\u69C1\u69AE\u69D3\u69CB\u699B\u69B7\u69BB\u69AB\u69B4\u69D0\u69CD\u69AD\u69CC\u69A6\u69C3\u69A3\u6B49\u6B4C\u6C33\u6F33\u6F14\u6EFE\u6F13\u6EF4\u6F29\u6F3E\u6F20\u6F2C\u6F0F\u6F02\u6F22"],
      ["baa1", "\u6EFF\u6EEF\u6F06\u6F31\u6F38\u6F32\u6F23\u6F15\u6F2B\u6F2F\u6F88\u6F2A\u6EEC\u6F01\u6EF2\u6ECC\u6EF7\u7194\u7199\u717D\u718A\u7184\u7192\u723E\u7292\u7296\u7344\u7350\u7464\u7463\u746A\u7470\u746D\u7504\u7591\u7627\u760D\u760B\u7609\u7613\u76E1\u76E3\u7784\u777D\u777F\u7761\u78C1\u789F\u78A7\u78B3\u78A9\u78A3\u798E\u798F\u798D\u7A2E\u7A31\u7AAA\u7AA9\u7AED\u7AEF\u7BA1\u7B95\u7B8B\u7B75\u7B97\u7B9D\u7B94\u7B8F\u7BB8\u7B87\u7B84\u7CB9\u7CBD\u7CBE\u7DBB\u7DB0\u7D9C\u7DBD\u7DBE\u7DA0\u7DCA\u7DB4\u7DB2\u7DB1\u7DBA\u7DA2\u7DBF\u7DB5\u7DB8\u7DAD\u7DD2\u7DC7\u7DAC"],
      ["bb40", "\u7F70\u7FE0\u7FE1\u7FDF\u805E\u805A\u8087\u8150\u8180\u818F\u8188\u818A\u817F\u8182\u81E7\u81FA\u8207\u8214\u821E\u824B\u84C9\u84BF\u84C6\u84C4\u8499\u849E\u84B2\u849C\u84CB\u84B8\u84C0\u84D3\u8490\u84BC\u84D1\u84CA\u873F\u871C\u873B\u8722\u8725\u8734\u8718\u8755\u8737\u8729\u88F3\u8902\u88F4\u88F9\u88F8\u88FD\u88E8\u891A\u88EF\u8AA6\u8A8C\u8A9E\u8AA3\u8A8D\u8AA1\u8A93\u8AA4"],
      ["bba1", "\u8AAA\u8AA5\u8AA8\u8A98\u8A91\u8A9A\u8AA7\u8C6A\u8C8D\u8C8C\u8CD3\u8CD1\u8CD2\u8D6B\u8D99\u8D95\u8DFC\u8F14\u8F12\u8F15\u8F13\u8FA3\u9060\u9058\u905C\u9063\u9059\u905E\u9062\u905D\u905B\u9119\u9118\u911E\u9175\u9178\u9177\u9174\u9278\u9280\u9285\u9298\u9296\u927B\u9293\u929C\u92A8\u927C\u9291\u95A1\u95A8\u95A9\u95A3\u95A5\u95A4\u9699\u969C\u969B\u96CC\u96D2\u9700\u977C\u9785\u97F6\u9817\u9818\u98AF\u98B1\u9903\u9905\u990C\u9909\u99C1\u9AAF\u9AB0\u9AE6\u9B41\u9B42\u9CF4\u9CF6\u9CF3\u9EBC\u9F3B\u9F4A\u5104\u5100\u50FB\u50F5\u50F9\u5102\u5108\u5109\u5105\u51DC"],
      ["bc40", "\u5287\u5288\u5289\u528D\u528A\u52F0\u53B2\u562E\u563B\u5639\u5632\u563F\u5634\u5629\u5653\u564E\u5657\u5674\u5636\u562F\u5630\u5880\u589F\u589E\u58B3\u589C\u58AE\u58A9\u58A6\u596D\u5B09\u5AFB\u5B0B\u5AF5\u5B0C\u5B08\u5BEE\u5BEC\u5BE9\u5BEB\u5C64\u5C65\u5D9D\u5D94\u5E62\u5E5F\u5E61\u5EE2\u5EDA\u5EDF\u5EDD\u5EE3\u5EE0\u5F48\u5F71\u5FB7\u5FB5\u6176\u6167\u616E\u615D\u6155\u6182"],
      ["bca1", "\u617C\u6170\u616B\u617E\u61A7\u6190\u61AB\u618E\u61AC\u619A\u61A4\u6194\u61AE\u622E\u6469\u646F\u6479\u649E\u64B2\u6488\u6490\u64B0\u64A5\u6493\u6495\u64A9\u6492\u64AE\u64AD\u64AB\u649A\u64AC\u6499\u64A2\u64B3\u6575\u6577\u6578\u66AE\u66AB\u66B4\u66B1\u6A23\u6A1F\u69E8\u6A01\u6A1E\u6A19\u69FD\u6A21\u6A13\u6A0A\u69F3\u6A02\u6A05\u69ED\u6A11\u6B50\u6B4E\u6BA4\u6BC5\u6BC6\u6F3F\u6F7C\u6F84\u6F51\u6F66\u6F54\u6F86\u6F6D\u6F5B\u6F78\u6F6E\u6F8E\u6F7A\u6F70\u6F64\u6F97\u6F58\u6ED5\u6F6F\u6F60\u6F5F\u719F\u71AC\u71B1\u71A8\u7256\u729B\u734E\u7357\u7469\u748B\u7483"],
      ["bd40", "\u747E\u7480\u757F\u7620\u7629\u761F\u7624\u7626\u7621\u7622\u769A\u76BA\u76E4\u778E\u7787\u778C\u7791\u778B\u78CB\u78C5\u78BA\u78CA\u78BE\u78D5\u78BC\u78D0\u7A3F\u7A3C\u7A40\u7A3D\u7A37\u7A3B\u7AAF\u7AAE\u7BAD\u7BB1\u7BC4\u7BB4\u7BC6\u7BC7\u7BC1\u7BA0\u7BCC\u7CCA\u7DE0\u7DF4\u7DEF\u7DFB\u7DD8\u7DEC\u7DDD\u7DE8\u7DE3\u7DDA\u7DDE\u7DE9\u7D9E\u7DD9\u7DF2\u7DF9\u7F75\u7F77\u7FAF"],
      ["bda1", "\u7FE9\u8026\u819B\u819C\u819D\u81A0\u819A\u8198\u8517\u853D\u851A\u84EE\u852C\u852D\u8513\u8511\u8523\u8521\u8514\u84EC\u8525\u84FF\u8506\u8782\u8774\u8776\u8760\u8766\u8778\u8768\u8759\u8757\u874C\u8753\u885B\u885D\u8910\u8907\u8912\u8913\u8915\u890A\u8ABC\u8AD2\u8AC7\u8AC4\u8A95\u8ACB\u8AF8\u8AB2\u8AC9\u8AC2\u8ABF\u8AB0\u8AD6\u8ACD\u8AB6\u8AB9\u8ADB\u8C4C\u8C4E\u8C6C\u8CE0\u8CDE\u8CE6\u8CE4\u8CEC\u8CED\u8CE2\u8CE3\u8CDC\u8CEA\u8CE1\u8D6D\u8D9F\u8DA3\u8E2B\u8E10\u8E1D\u8E22\u8E0F\u8E29\u8E1F\u8E21\u8E1E\u8EBA\u8F1D\u8F1B\u8F1F\u8F29\u8F26\u8F2A\u8F1C\u8F1E"],
      ["be40", "\u8F25\u9069\u906E\u9068\u906D\u9077\u9130\u912D\u9127\u9131\u9187\u9189\u918B\u9183\u92C5\u92BB\u92B7\u92EA\u92AC\u92E4\u92C1\u92B3\u92BC\u92D2\u92C7\u92F0\u92B2\u95AD\u95B1\u9704\u9706\u9707\u9709\u9760\u978D\u978B\u978F\u9821\u982B\u981C\u98B3\u990A\u9913\u9912\u9918\u99DD\u99D0\u99DF\u99DB\u99D1\u99D5\u99D2\u99D9\u9AB7\u9AEE\u9AEF\u9B27\u9B45\u9B44\u9B77\u9B6F\u9D06\u9D09"],
      ["bea1", "\u9D03\u9EA9\u9EBE\u9ECE\u58A8\u9F52\u5112\u5118\u5114\u5110\u5115\u5180\u51AA\u51DD\u5291\u5293\u52F3\u5659\u566B\u5679\u5669\u5664\u5678\u566A\u5668\u5665\u5671\u566F\u566C\u5662\u5676\u58C1\u58BE\u58C7\u58C5\u596E\u5B1D\u5B34\u5B78\u5BF0\u5C0E\u5F4A\u61B2\u6191\u61A9\u618A\u61CD\u61B6\u61BE\u61CA\u61C8\u6230\u64C5\u64C1\u64CB\u64BB\u64BC\u64DA\u64C4\u64C7\u64C2\u64CD\u64BF\u64D2\u64D4\u64BE\u6574\u66C6\u66C9\u66B9\u66C4\u66C7\u66B8\u6A3D\u6A38\u6A3A\u6A59\u6A6B\u6A58\u6A39\u6A44\u6A62\u6A61\u6A4B\u6A47\u6A35\u6A5F\u6A48\u6B59\u6B77\u6C05\u6FC2\u6FB1\u6FA1"],
      ["bf40", "\u6FC3\u6FA4\u6FC1\u6FA7\u6FB3\u6FC0\u6FB9\u6FB6\u6FA6\u6FA0\u6FB4\u71BE\u71C9\u71D0\u71D2\u71C8\u71D5\u71B9\u71CE\u71D9\u71DC\u71C3\u71C4\u7368\u749C\u74A3\u7498\u749F\u749E\u74E2\u750C\u750D\u7634\u7638\u763A\u76E7\u76E5\u77A0\u779E\u779F\u77A5\u78E8\u78DA\u78EC\u78E7\u79A6\u7A4D\u7A4E\u7A46\u7A4C\u7A4B\u7ABA\u7BD9\u7C11\u7BC9\u7BE4\u7BDB\u7BE1\u7BE9\u7BE6\u7CD5\u7CD6\u7E0A"],
      ["bfa1", "\u7E11\u7E08\u7E1B\u7E23\u7E1E\u7E1D\u7E09\u7E10\u7F79\u7FB2\u7FF0\u7FF1\u7FEE\u8028\u81B3\u81A9\u81A8\u81FB\u8208\u8258\u8259\u854A\u8559\u8548\u8568\u8569\u8543\u8549\u856D\u856A\u855E\u8783\u879F\u879E\u87A2\u878D\u8861\u892A\u8932\u8925\u892B\u8921\u89AA\u89A6\u8AE6\u8AFA\u8AEB\u8AF1\u8B00\u8ADC\u8AE7\u8AEE\u8AFE\u8B01\u8B02\u8AF7\u8AED\u8AF3\u8AF6\u8AFC\u8C6B\u8C6D\u8C93\u8CF4\u8E44\u8E31\u8E34\u8E42\u8E39\u8E35\u8F3B\u8F2F\u8F38\u8F33\u8FA8\u8FA6\u9075\u9074\u9078\u9072\u907C\u907A\u9134\u9192\u9320\u9336\u92F8\u9333\u932F\u9322\u92FC\u932B\u9304\u931A"],
      ["c040", "\u9310\u9326\u9321\u9315\u932E\u9319\u95BB\u96A7\u96A8\u96AA\u96D5\u970E\u9711\u9716\u970D\u9713\u970F\u975B\u975C\u9766\u9798\u9830\u9838\u983B\u9837\u982D\u9839\u9824\u9910\u9928\u991E\u991B\u9921\u991A\u99ED\u99E2\u99F1\u9AB8\u9ABC\u9AFB\u9AED\u9B28\u9B91\u9D15\u9D23\u9D26\u9D28\u9D12\u9D1B\u9ED8\u9ED4\u9F8D\u9F9C\u512A\u511F\u5121\u5132\u52F5\u568E\u5680\u5690\u5685\u5687"],
      ["c0a1", "\u568F\u58D5\u58D3\u58D1\u58CE\u5B30\u5B2A\u5B24\u5B7A\u5C37\u5C68\u5DBC\u5DBA\u5DBD\u5DB8\u5E6B\u5F4C\u5FBD\u61C9\u61C2\u61C7\u61E6\u61CB\u6232\u6234\u64CE\u64CA\u64D8\u64E0\u64F0\u64E6\u64EC\u64F1\u64E2\u64ED\u6582\u6583\u66D9\u66D6\u6A80\u6A94\u6A84\u6AA2\u6A9C\u6ADB\u6AA3\u6A7E\u6A97\u6A90\u6AA0\u6B5C\u6BAE\u6BDA\u6C08\u6FD8\u6FF1\u6FDF\u6FE0\u6FDB\u6FE4\u6FEB\u6FEF\u6F80\u6FEC\u6FE1\u6FE9\u6FD5\u6FEE\u6FF0\u71E7\u71DF\u71EE\u71E6\u71E5\u71ED\u71EC\u71F4\u71E0\u7235\u7246\u7370\u7372\u74A9\u74B0\u74A6\u74A8\u7646\u7642\u764C\u76EA\u77B3\u77AA\u77B0\u77AC"],
      ["c140", "\u77A7\u77AD\u77EF\u78F7\u78FA\u78F4\u78EF\u7901\u79A7\u79AA\u7A57\u7ABF\u7C07\u7C0D\u7BFE\u7BF7\u7C0C\u7BE0\u7CE0\u7CDC\u7CDE\u7CE2\u7CDF\u7CD9\u7CDD\u7E2E\u7E3E\u7E46\u7E37\u7E32\u7E43\u7E2B\u7E3D\u7E31\u7E45\u7E41\u7E34\u7E39\u7E48\u7E35\u7E3F\u7E2F\u7F44\u7FF3\u7FFC\u8071\u8072\u8070\u806F\u8073\u81C6\u81C3\u81BA\u81C2\u81C0\u81BF\u81BD\u81C9\u81BE\u81E8\u8209\u8271\u85AA"],
      ["c1a1", "\u8584\u857E\u859C\u8591\u8594\u85AF\u859B\u8587\u85A8\u858A\u8667\u87C0\u87D1\u87B3\u87D2\u87C6\u87AB\u87BB\u87BA\u87C8\u87CB\u893B\u8936\u8944\u8938\u893D\u89AC\u8B0E\u8B17\u8B19\u8B1B\u8B0A\u8B20\u8B1D\u8B04\u8B10\u8C41\u8C3F\u8C73\u8CFA\u8CFD\u8CFC\u8CF8\u8CFB\u8DA8\u8E49\u8E4B\u8E48\u8E4A\u8F44\u8F3E\u8F42\u8F45\u8F3F\u907F\u907D\u9084\u9081\u9082\u9080\u9139\u91A3\u919E\u919C\u934D\u9382\u9328\u9375\u934A\u9365\u934B\u9318\u937E\u936C\u935B\u9370\u935A\u9354\u95CA\u95CB\u95CC\u95C8\u95C6\u96B1\u96B8\u96D6\u971C\u971E\u97A0\u97D3\u9846\u98B6\u9935\u9A01"],
      ["c240", "\u99FF\u9BAE\u9BAB\u9BAA\u9BAD\u9D3B\u9D3F\u9E8B\u9ECF\u9EDE\u9EDC\u9EDD\u9EDB\u9F3E\u9F4B\u53E2\u5695\u56AE\u58D9\u58D8\u5B38\u5F5D\u61E3\u6233\u64F4\u64F2\u64FE\u6506\u64FA\u64FB\u64F7\u65B7\u66DC\u6726\u6AB3\u6AAC\u6AC3\u6ABB\u6AB8\u6AC2\u6AAE\u6AAF\u6B5F\u6B78\u6BAF\u7009\u700B\u6FFE\u7006\u6FFA\u7011\u700F\u71FB\u71FC\u71FE\u71F8\u7377\u7375\u74A7\u74BF\u7515\u7656\u7658"],
      ["c2a1", "\u7652\u77BD\u77BF\u77BB\u77BC\u790E\u79AE\u7A61\u7A62\u7A60\u7AC4\u7AC5\u7C2B\u7C27\u7C2A\u7C1E\u7C23\u7C21\u7CE7\u7E54\u7E55\u7E5E\u7E5A\u7E61\u7E52\u7E59\u7F48\u7FF9\u7FFB\u8077\u8076\u81CD\u81CF\u820A\u85CF\u85A9\u85CD\u85D0\u85C9\u85B0\u85BA\u85B9\u85A6\u87EF\u87EC\u87F2\u87E0\u8986\u89B2\u89F4\u8B28\u8B39\u8B2C\u8B2B\u8C50\u8D05\u8E59\u8E63\u8E66\u8E64\u8E5F\u8E55\u8EC0\u8F49\u8F4D\u9087\u9083\u9088\u91AB\u91AC\u91D0\u9394\u938A\u9396\u93A2\u93B3\u93AE\u93AC\u93B0\u9398\u939A\u9397\u95D4\u95D6\u95D0\u95D5\u96E2\u96DC\u96D9\u96DB\u96DE\u9724\u97A3\u97A6"],
      ["c340", "\u97AD\u97F9\u984D\u984F\u984C\u984E\u9853\u98BA\u993E\u993F\u993D\u992E\u99A5\u9A0E\u9AC1\u9B03\u9B06\u9B4F\u9B4E\u9B4D\u9BCA\u9BC9\u9BFD\u9BC8\u9BC0\u9D51\u9D5D\u9D60\u9EE0\u9F15\u9F2C\u5133\u56A5\u58DE\u58DF\u58E2\u5BF5\u9F90\u5EEC\u61F2\u61F7\u61F6\u61F5\u6500\u650F\u66E0\u66DD\u6AE5\u6ADD\u6ADA\u6AD3\u701B\u701F\u7028\u701A\u701D\u7015\u7018\u7206\u720D\u7258\u72A2\u7378"],
      ["c3a1", "\u737A\u74BD\u74CA\u74E3\u7587\u7586\u765F\u7661\u77C7\u7919\u79B1\u7A6B\u7A69\u7C3E\u7C3F\u7C38\u7C3D\u7C37\u7C40\u7E6B\u7E6D\u7E79\u7E69\u7E6A\u7F85\u7E73\u7FB6\u7FB9\u7FB8\u81D8\u85E9\u85DD\u85EA\u85D5\u85E4\u85E5\u85F7\u87FB\u8805\u880D\u87F9\u87FE\u8960\u895F\u8956\u895E\u8B41\u8B5C\u8B58\u8B49\u8B5A\u8B4E\u8B4F\u8B46\u8B59\u8D08\u8D0A\u8E7C\u8E72\u8E87\u8E76\u8E6C\u8E7A\u8E74\u8F54\u8F4E\u8FAD\u908A\u908B\u91B1\u91AE\u93E1\u93D1\u93DF\u93C3\u93C8\u93DC\u93DD\u93D6\u93E2\u93CD\u93D8\u93E4\u93D7\u93E8\u95DC\u96B4\u96E3\u972A\u9727\u9761\u97DC\u97FB\u985E"],
      ["c440", "\u9858\u985B\u98BC\u9945\u9949\u9A16\u9A19\u9B0D\u9BE8\u9BE7\u9BD6\u9BDB\u9D89\u9D61\u9D72\u9D6A\u9D6C\u9E92\u9E97\u9E93\u9EB4\u52F8\u56A8\u56B7\u56B6\u56B4\u56BC\u58E4\u5B40\u5B43\u5B7D\u5BF6\u5DC9\u61F8\u61FA\u6518\u6514\u6519\u66E6\u6727\u6AEC\u703E\u7030\u7032\u7210\u737B\u74CF\u7662\u7665\u7926\u792A\u792C\u792B\u7AC7\u7AF6\u7C4C\u7C43\u7C4D\u7CEF\u7CF0\u8FAE\u7E7D\u7E7C"],
      ["c4a1", "\u7E82\u7F4C\u8000\u81DA\u8266\u85FB\u85F9\u8611\u85FA\u8606\u860B\u8607\u860A\u8814\u8815\u8964\u89BA\u89F8\u8B70\u8B6C\u8B66\u8B6F\u8B5F\u8B6B\u8D0F\u8D0D\u8E89\u8E81\u8E85\u8E82\u91B4\u91CB\u9418\u9403\u93FD\u95E1\u9730\u98C4\u9952\u9951\u99A8\u9A2B\u9A30\u9A37\u9A35\u9C13\u9C0D\u9E79\u9EB5\u9EE8\u9F2F\u9F5F\u9F63\u9F61\u5137\u5138\u56C1\u56C0\u56C2\u5914\u5C6C\u5DCD\u61FC\u61FE\u651D\u651C\u6595\u66E9\u6AFB\u6B04\u6AFA\u6BB2\u704C\u721B\u72A7\u74D6\u74D4\u7669\u77D3\u7C50\u7E8F\u7E8C\u7FBC\u8617\u862D\u861A\u8823\u8822\u8821\u881F\u896A\u896C\u89BD\u8B74"],
      ["c540", "\u8B77\u8B7D\u8D13\u8E8A\u8E8D\u8E8B\u8F5F\u8FAF\u91BA\u942E\u9433\u9435\u943A\u9438\u9432\u942B\u95E2\u9738\u9739\u9732\u97FF\u9867\u9865\u9957\u9A45\u9A43\u9A40\u9A3E\u9ACF\u9B54\u9B51\u9C2D\u9C25\u9DAF\u9DB4\u9DC2\u9DB8\u9E9D\u9EEF\u9F19\u9F5C\u9F66\u9F67\u513C\u513B\u56C8\u56CA\u56C9\u5B7F\u5DD4\u5DD2\u5F4E\u61FF\u6524\u6B0A\u6B61\u7051\u7058\u7380\u74E4\u758A\u766E\u766C"],
      ["c5a1", "\u79B3\u7C60\u7C5F\u807E\u807D\u81DF\u8972\u896F\u89FC\u8B80\u8D16\u8D17\u8E91\u8E93\u8F61\u9148\u9444\u9451\u9452\u973D\u973E\u97C3\u97C1\u986B\u9955\u9A55\u9A4D\u9AD2\u9B1A\u9C49\u9C31\u9C3E\u9C3B\u9DD3\u9DD7\u9F34\u9F6C\u9F6A\u9F94\u56CC\u5DD6\u6200\u6523\u652B\u652A\u66EC\u6B10\u74DA\u7ACA\u7C64\u7C63\u7C65\u7E93\u7E96\u7E94\u81E2\u8638\u863F\u8831\u8B8A\u9090\u908F\u9463\u9460\u9464\u9768\u986F\u995C\u9A5A\u9A5B\u9A57\u9AD3\u9AD4\u9AD1\u9C54\u9C57\u9C56\u9DE5\u9E9F\u9EF4\u56D1\u58E9\u652C\u705E\u7671\u7672\u77D7\u7F50\u7F88\u8836\u8839\u8862\u8B93\u8B92"],
      ["c640", "\u8B96\u8277\u8D1B\u91C0\u946A\u9742\u9748\u9744\u97C6\u9870\u9A5F\u9B22\u9B58\u9C5F\u9DF9\u9DFA\u9E7C\u9E7D\u9F07\u9F77\u9F72\u5EF3\u6B16\u7063\u7C6C\u7C6E\u883B\u89C0\u8EA1\u91C1\u9472\u9470\u9871\u995E\u9AD6\u9B23\u9ECC\u7064\u77DA\u8B9A\u9477\u97C9\u9A62\u9A65\u7E9C\u8B9C\u8EAA\u91C5\u947D\u947E\u947C\u9C77\u9C78\u9EF7\u8C54\u947F\u9E1A\u7228\u9A6A\u9B31\u9E1B\u9E1E\u7C72"],
      ["c940", "\u4E42\u4E5C\u51F5\u531A\u5382\u4E07\u4E0C\u4E47\u4E8D\u56D7\uFA0C\u5C6E\u5F73\u4E0F\u5187\u4E0E\u4E2E\u4E93\u4EC2\u4EC9\u4EC8\u5198\u52FC\u536C\u53B9\u5720\u5903\u592C\u5C10\u5DFF\u65E1\u6BB3\u6BCC\u6C14\u723F\u4E31\u4E3C\u4EE8\u4EDC\u4EE9\u4EE1\u4EDD\u4EDA\u520C\u531C\u534C\u5722\u5723\u5917\u592F\u5B81\u5B84\u5C12\u5C3B\u5C74\u5C73\u5E04\u5E80\u5E82\u5FC9\u6209\u6250\u6C15"],
      ["c9a1", "\u6C36\u6C43\u6C3F\u6C3B\u72AE\u72B0\u738A\u79B8\u808A\u961E\u4F0E\u4F18\u4F2C\u4EF5\u4F14\u4EF1\u4F00\u4EF7\u4F08\u4F1D\u4F02\u4F05\u4F22\u4F13\u4F04\u4EF4\u4F12\u51B1\u5213\u5209\u5210\u52A6\u5322\u531F\u534D\u538A\u5407\u56E1\u56DF\u572E\u572A\u5734\u593C\u5980\u597C\u5985\u597B\u597E\u5977\u597F\u5B56\u5C15\u5C25\u5C7C\u5C7A\u5C7B\u5C7E\u5DDF\u5E75\u5E84\u5F02\u5F1A\u5F74\u5FD5\u5FD4\u5FCF\u625C\u625E\u6264\u6261\u6266\u6262\u6259\u6260\u625A\u6265\u65EF\u65EE\u673E\u6739\u6738\u673B\u673A\u673F\u673C\u6733\u6C18\u6C46\u6C52\u6C5C\u6C4F\u6C4A\u6C54\u6C4B"],
      ["ca40", "\u6C4C\u7071\u725E\u72B4\u72B5\u738E\u752A\u767F\u7A75\u7F51\u8278\u827C\u8280\u827D\u827F\u864D\u897E\u9099\u9097\u9098\u909B\u9094\u9622\u9624\u9620\u9623\u4F56\u4F3B\u4F62\u4F49\u4F53\u4F64\u4F3E\u4F67\u4F52\u4F5F\u4F41\u4F58\u4F2D\u4F33\u4F3F\u4F61\u518F\u51B9\u521C\u521E\u5221\u52AD\u52AE\u5309\u5363\u5372\u538E\u538F\u5430\u5437\u542A\u5454\u5445\u5419\u541C\u5425\u5418"],
      ["caa1", "\u543D\u544F\u5441\u5428\u5424\u5447\u56EE\u56E7\u56E5\u5741\u5745\u574C\u5749\u574B\u5752\u5906\u5940\u59A6\u5998\u59A0\u5997\u598E\u59A2\u5990\u598F\u59A7\u59A1\u5B8E\u5B92\u5C28\u5C2A\u5C8D\u5C8F\u5C88\u5C8B\u5C89\u5C92\u5C8A\u5C86\u5C93\u5C95\u5DE0\u5E0A\u5E0E\u5E8B\u5E89\u5E8C\u5E88\u5E8D\u5F05\u5F1D\u5F78\u5F76\u5FD2\u5FD1\u5FD0\u5FED\u5FE8\u5FEE\u5FF3\u5FE1\u5FE4\u5FE3\u5FFA\u5FEF\u5FF7\u5FFB\u6000\u5FF4\u623A\u6283\u628C\u628E\u628F\u6294\u6287\u6271\u627B\u627A\u6270\u6281\u6288\u6277\u627D\u6272\u6274\u6537\u65F0\u65F4\u65F3\u65F2\u65F5\u6745\u6747"],
      ["cb40", "\u6759\u6755\u674C\u6748\u675D\u674D\u675A\u674B\u6BD0\u6C19\u6C1A\u6C78\u6C67\u6C6B\u6C84\u6C8B\u6C8F\u6C71\u6C6F\u6C69\u6C9A\u6C6D\u6C87\u6C95\u6C9C\u6C66\u6C73\u6C65\u6C7B\u6C8E\u7074\u707A\u7263\u72BF\u72BD\u72C3\u72C6\u72C1\u72BA\u72C5\u7395\u7397\u7393\u7394\u7392\u753A\u7539\u7594\u7595\u7681\u793D\u8034\u8095\u8099\u8090\u8092\u809C\u8290\u828F\u8285\u828E\u8291\u8293"],
      ["cba1", "\u828A\u8283\u8284\u8C78\u8FC9\u8FBF\u909F\u90A1\u90A5\u909E\u90A7\u90A0\u9630\u9628\u962F\u962D\u4E33\u4F98\u4F7C\u4F85\u4F7D\u4F80\u4F87\u4F76\u4F74\u4F89\u4F84\u4F77\u4F4C\u4F97\u4F6A\u4F9A\u4F79\u4F81\u4F78\u4F90\u4F9C\u4F94\u4F9E\u4F92\u4F82\u4F95\u4F6B\u4F6E\u519E\u51BC\u51BE\u5235\u5232\u5233\u5246\u5231\u52BC\u530A\u530B\u533C\u5392\u5394\u5487\u547F\u5481\u5491\u5482\u5488\u546B\u547A\u547E\u5465\u546C\u5474\u5466\u548D\u546F\u5461\u5460\u5498\u5463\u5467\u5464\u56F7\u56F9\u576F\u5772\u576D\u576B\u5771\u5770\u5776\u5780\u5775\u577B\u5773\u5774\u5762"],
      ["cc40", "\u5768\u577D\u590C\u5945\u59B5\u59BA\u59CF\u59CE\u59B2\u59CC\u59C1\u59B6\u59BC\u59C3\u59D6\u59B1\u59BD\u59C0\u59C8\u59B4\u59C7\u5B62\u5B65\u5B93\u5B95\u5C44\u5C47\u5CAE\u5CA4\u5CA0\u5CB5\u5CAF\u5CA8\u5CAC\u5C9F\u5CA3\u5CAD\u5CA2\u5CAA\u5CA7\u5C9D\u5CA5\u5CB6\u5CB0\u5CA6\u5E17\u5E14\u5E19\u5F28\u5F22\u5F23\u5F24\u5F54\u5F82\u5F7E\u5F7D\u5FDE\u5FE5\u602D\u6026\u6019\u6032\u600B"],
      ["cca1", "\u6034\u600A\u6017\u6033\u601A\u601E\u602C\u6022\u600D\u6010\u602E\u6013\u6011\u600C\u6009\u601C\u6214\u623D\u62AD\u62B4\u62D1\u62BE\u62AA\u62B6\u62CA\u62AE\u62B3\u62AF\u62BB\u62A9\u62B0\u62B8\u653D\u65A8\u65BB\u6609\u65FC\u6604\u6612\u6608\u65FB\u6603\u660B\u660D\u6605\u65FD\u6611\u6610\u66F6\u670A\u6785\u676C\u678E\u6792\u6776\u677B\u6798\u6786\u6784\u6774\u678D\u678C\u677A\u679F\u6791\u6799\u6783\u677D\u6781\u6778\u6779\u6794\u6B25\u6B80\u6B7E\u6BDE\u6C1D\u6C93\u6CEC\u6CEB\u6CEE\u6CD9\u6CB6\u6CD4\u6CAD\u6CE7\u6CB7\u6CD0\u6CC2\u6CBA\u6CC3\u6CC6\u6CED\u6CF2"],
      ["cd40", "\u6CD2\u6CDD\u6CB4\u6C8A\u6C9D\u6C80\u6CDE\u6CC0\u6D30\u6CCD\u6CC7\u6CB0\u6CF9\u6CCF\u6CE9\u6CD1\u7094\u7098\u7085\u7093\u7086\u7084\u7091\u7096\u7082\u709A\u7083\u726A\u72D6\u72CB\u72D8\u72C9\u72DC\u72D2\u72D4\u72DA\u72CC\u72D1\u73A4\u73A1\u73AD\u73A6\u73A2\u73A0\u73AC\u739D\u74DD\u74E8\u753F\u7540\u753E\u758C\u7598\u76AF\u76F3\u76F1\u76F0\u76F5\u77F8\u77FC\u77F9\u77FB\u77FA"],
      ["cda1", "\u77F7\u7942\u793F\u79C5\u7A78\u7A7B\u7AFB\u7C75\u7CFD\u8035\u808F\u80AE\u80A3\u80B8\u80B5\u80AD\u8220\u82A0\u82C0\u82AB\u829A\u8298\u829B\u82B5\u82A7\u82AE\u82BC\u829E\u82BA\u82B4\u82A8\u82A1\u82A9\u82C2\u82A4\u82C3\u82B6\u82A2\u8670\u866F\u866D\u866E\u8C56\u8FD2\u8FCB\u8FD3\u8FCD\u8FD6\u8FD5\u8FD7\u90B2\u90B4\u90AF\u90B3\u90B0\u9639\u963D\u963C\u963A\u9643\u4FCD\u4FC5\u4FD3\u4FB2\u4FC9\u4FCB\u4FC1\u4FD4\u4FDC\u4FD9\u4FBB\u4FB3\u4FDB\u4FC7\u4FD6\u4FBA\u4FC0\u4FB9\u4FEC\u5244\u5249\u52C0\u52C2\u533D\u537C\u5397\u5396\u5399\u5398\u54BA\u54A1\u54AD\u54A5\u54CF"],
      ["ce40", "\u54C3\u830D\u54B7\u54AE\u54D6\u54B6\u54C5\u54C6\u54A0\u5470\u54BC\u54A2\u54BE\u5472\u54DE\u54B0\u57B5\u579E\u579F\u57A4\u578C\u5797\u579D\u579B\u5794\u5798\u578F\u5799\u57A5\u579A\u5795\u58F4\u590D\u5953\u59E1\u59DE\u59EE\u5A00\u59F1\u59DD\u59FA\u59FD\u59FC\u59F6\u59E4\u59F2\u59F7\u59DB\u59E9\u59F3\u59F5\u59E0\u59FE\u59F4\u59ED\u5BA8\u5C4C\u5CD0\u5CD8\u5CCC\u5CD7\u5CCB\u5CDB"],
      ["cea1", "\u5CDE\u5CDA\u5CC9\u5CC7\u5CCA\u5CD6\u5CD3\u5CD4\u5CCF\u5CC8\u5CC6\u5CCE\u5CDF\u5CF8\u5DF9\u5E21\u5E22\u5E23\u5E20\u5E24\u5EB0\u5EA4\u5EA2\u5E9B\u5EA3\u5EA5\u5F07\u5F2E\u5F56\u5F86\u6037\u6039\u6054\u6072\u605E\u6045\u6053\u6047\u6049\u605B\u604C\u6040\u6042\u605F\u6024\u6044\u6058\u6066\u606E\u6242\u6243\u62CF\u630D\u630B\u62F5\u630E\u6303\u62EB\u62F9\u630F\u630C\u62F8\u62F6\u6300\u6313\u6314\u62FA\u6315\u62FB\u62F0\u6541\u6543\u65AA\u65BF\u6636\u6621\u6632\u6635\u661C\u6626\u6622\u6633\u662B\u663A\u661D\u6634\u6639\u662E\u670F\u6710\u67C1\u67F2\u67C8\u67BA"],
      ["cf40", "\u67DC\u67BB\u67F8\u67D8\u67C0\u67B7\u67C5\u67EB\u67E4\u67DF\u67B5\u67CD\u67B3\u67F7\u67F6\u67EE\u67E3\u67C2\u67B9\u67CE\u67E7\u67F0\u67B2\u67FC\u67C6\u67ED\u67CC\u67AE\u67E6\u67DB\u67FA\u67C9\u67CA\u67C3\u67EA\u67CB\u6B28\u6B82\u6B84\u6BB6\u6BD6\u6BD8\u6BE0\u6C20\u6C21\u6D28\u6D34\u6D2D\u6D1F\u6D3C\u6D3F\u6D12\u6D0A\u6CDA\u6D33\u6D04\u6D19\u6D3A\u6D1A\u6D11\u6D00\u6D1D\u6D42"],
      ["cfa1", "\u6D01\u6D18\u6D37\u6D03\u6D0F\u6D40\u6D07\u6D20\u6D2C\u6D08\u6D22\u6D09\u6D10\u70B7\u709F\u70BE\u70B1\u70B0\u70A1\u70B4\u70B5\u70A9\u7241\u7249\u724A\u726C\u7270\u7273\u726E\u72CA\u72E4\u72E8\u72EB\u72DF\u72EA\u72E6\u72E3\u7385\u73CC\u73C2\u73C8\u73C5\u73B9\u73B6\u73B5\u73B4\u73EB\u73BF\u73C7\u73BE\u73C3\u73C6\u73B8\u73CB\u74EC\u74EE\u752E\u7547\u7548\u75A7\u75AA\u7679\u76C4\u7708\u7703\u7704\u7705\u770A\u76F7\u76FB\u76FA\u77E7\u77E8\u7806\u7811\u7812\u7805\u7810\u780F\u780E\u7809\u7803\u7813\u794A\u794C\u794B\u7945\u7944\u79D5\u79CD\u79CF\u79D6\u79CE\u7A80"],
      ["d040", "\u7A7E\u7AD1\u7B00\u7B01\u7C7A\u7C78\u7C79\u7C7F\u7C80\u7C81\u7D03\u7D08\u7D01\u7F58\u7F91\u7F8D\u7FBE\u8007\u800E\u800F\u8014\u8037\u80D8\u80C7\u80E0\u80D1\u80C8\u80C2\u80D0\u80C5\u80E3\u80D9\u80DC\u80CA\u80D5\u80C9\u80CF\u80D7\u80E6\u80CD\u81FF\u8221\u8294\u82D9\u82FE\u82F9\u8307\u82E8\u8300\u82D5\u833A\u82EB\u82D6\u82F4\u82EC\u82E1\u82F2\u82F5\u830C\u82FB\u82F6\u82F0\u82EA"],
      ["d0a1", "\u82E4\u82E0\u82FA\u82F3\u82ED\u8677\u8674\u867C\u8673\u8841\u884E\u8867\u886A\u8869\u89D3\u8A04\u8A07\u8D72\u8FE3\u8FE1\u8FEE\u8FE0\u90F1\u90BD\u90BF\u90D5\u90C5\u90BE\u90C7\u90CB\u90C8\u91D4\u91D3\u9654\u964F\u9651\u9653\u964A\u964E\u501E\u5005\u5007\u5013\u5022\u5030\u501B\u4FF5\u4FF4\u5033\u5037\u502C\u4FF6\u4FF7\u5017\u501C\u5020\u5027\u5035\u502F\u5031\u500E\u515A\u5194\u5193\u51CA\u51C4\u51C5\u51C8\u51CE\u5261\u525A\u5252\u525E\u525F\u5255\u5262\u52CD\u530E\u539E\u5526\u54E2\u5517\u5512\u54E7\u54F3\u54E4\u551A\u54FF\u5504\u5508\u54EB\u5511\u5505\u54F1"],
      ["d140", "\u550A\u54FB\u54F7\u54F8\u54E0\u550E\u5503\u550B\u5701\u5702\u57CC\u5832\u57D5\u57D2\u57BA\u57C6\u57BD\u57BC\u57B8\u57B6\u57BF\u57C7\u57D0\u57B9\u57C1\u590E\u594A\u5A19\u5A16\u5A2D\u5A2E\u5A15\u5A0F\u5A17\u5A0A\u5A1E\u5A33\u5B6C\u5BA7\u5BAD\u5BAC\u5C03\u5C56\u5C54\u5CEC\u5CFF\u5CEE\u5CF1\u5CF7\u5D00\u5CF9\u5E29\u5E28\u5EA8\u5EAE\u5EAA\u5EAC\u5F33\u5F30\u5F67\u605D\u605A\u6067"],
      ["d1a1", "\u6041\u60A2\u6088\u6080\u6092\u6081\u609D\u6083\u6095\u609B\u6097\u6087\u609C\u608E\u6219\u6246\u62F2\u6310\u6356\u632C\u6344\u6345\u6336\u6343\u63E4\u6339\u634B\u634A\u633C\u6329\u6341\u6334\u6358\u6354\u6359\u632D\u6347\u6333\u635A\u6351\u6338\u6357\u6340\u6348\u654A\u6546\u65C6\u65C3\u65C4\u65C2\u664A\u665F\u6647\u6651\u6712\u6713\u681F\u681A\u6849\u6832\u6833\u683B\u684B\u684F\u6816\u6831\u681C\u6835\u682B\u682D\u682F\u684E\u6844\u6834\u681D\u6812\u6814\u6826\u6828\u682E\u684D\u683A\u6825\u6820\u6B2C\u6B2F\u6B2D\u6B31\u6B34\u6B6D\u8082\u6B88\u6BE6\u6BE4"],
      ["d240", "\u6BE8\u6BE3\u6BE2\u6BE7\u6C25\u6D7A\u6D63\u6D64\u6D76\u6D0D\u6D61\u6D92\u6D58\u6D62\u6D6D\u6D6F\u6D91\u6D8D\u6DEF\u6D7F\u6D86\u6D5E\u6D67\u6D60\u6D97\u6D70\u6D7C\u6D5F\u6D82\u6D98\u6D2F\u6D68\u6D8B\u6D7E\u6D80\u6D84\u6D16\u6D83\u6D7B\u6D7D\u6D75\u6D90\u70DC\u70D3\u70D1\u70DD\u70CB\u7F39\u70E2\u70D7\u70D2\u70DE\u70E0\u70D4\u70CD\u70C5\u70C6\u70C7\u70DA\u70CE\u70E1\u7242\u7278"],
      ["d2a1", "\u7277\u7276\u7300\u72FA\u72F4\u72FE\u72F6\u72F3\u72FB\u7301\u73D3\u73D9\u73E5\u73D6\u73BC\u73E7\u73E3\u73E9\u73DC\u73D2\u73DB\u73D4\u73DD\u73DA\u73D7\u73D8\u73E8\u74DE\u74DF\u74F4\u74F5\u7521\u755B\u755F\u75B0\u75C1\u75BB\u75C4\u75C0\u75BF\u75B6\u75BA\u768A\u76C9\u771D\u771B\u7710\u7713\u7712\u7723\u7711\u7715\u7719\u771A\u7722\u7727\u7823\u782C\u7822\u7835\u782F\u7828\u782E\u782B\u7821\u7829\u7833\u782A\u7831\u7954\u795B\u794F\u795C\u7953\u7952\u7951\u79EB\u79EC\u79E0\u79EE\u79ED\u79EA\u79DC\u79DE\u79DD\u7A86\u7A89\u7A85\u7A8B\u7A8C\u7A8A\u7A87\u7AD8\u7B10"],
      ["d340", "\u7B04\u7B13\u7B05\u7B0F\u7B08\u7B0A\u7B0E\u7B09\u7B12\u7C84\u7C91\u7C8A\u7C8C\u7C88\u7C8D\u7C85\u7D1E\u7D1D\u7D11\u7D0E\u7D18\u7D16\u7D13\u7D1F\u7D12\u7D0F\u7D0C\u7F5C\u7F61\u7F5E\u7F60\u7F5D\u7F5B\u7F96\u7F92\u7FC3\u7FC2\u7FC0\u8016\u803E\u8039\u80FA\u80F2\u80F9\u80F5\u8101\u80FB\u8100\u8201\u822F\u8225\u8333\u832D\u8344\u8319\u8351\u8325\u8356\u833F\u8341\u8326\u831C\u8322"],
      ["d3a1", "\u8342\u834E\u831B\u832A\u8308\u833C\u834D\u8316\u8324\u8320\u8337\u832F\u8329\u8347\u8345\u834C\u8353\u831E\u832C\u834B\u8327\u8348\u8653\u8652\u86A2\u86A8\u8696\u868D\u8691\u869E\u8687\u8697\u8686\u868B\u869A\u8685\u86A5\u8699\u86A1\u86A7\u8695\u8698\u868E\u869D\u8690\u8694\u8843\u8844\u886D\u8875\u8876\u8872\u8880\u8871\u887F\u886F\u8883\u887E\u8874\u887C\u8A12\u8C47\u8C57\u8C7B\u8CA4\u8CA3\u8D76\u8D78\u8DB5\u8DB7\u8DB6\u8ED1\u8ED3\u8FFE\u8FF5\u9002\u8FFF\u8FFB\u9004\u8FFC\u8FF6\u90D6\u90E0\u90D9\u90DA\u90E3\u90DF\u90E5\u90D8\u90DB\u90D7\u90DC\u90E4\u9150"],
      ["d440", "\u914E\u914F\u91D5\u91E2\u91DA\u965C\u965F\u96BC\u98E3\u9ADF\u9B2F\u4E7F\u5070\u506A\u5061\u505E\u5060\u5053\u504B\u505D\u5072\u5048\u504D\u5041\u505B\u504A\u5062\u5015\u5045\u505F\u5069\u506B\u5063\u5064\u5046\u5040\u506E\u5073\u5057\u5051\u51D0\u526B\u526D\u526C\u526E\u52D6\u52D3\u532D\u539C\u5575\u5576\u553C\u554D\u5550\u5534\u552A\u5551\u5562\u5536\u5535\u5530\u5552\u5545"],
      ["d4a1", "\u550C\u5532\u5565\u554E\u5539\u5548\u552D\u553B\u5540\u554B\u570A\u5707\u57FB\u5814\u57E2\u57F6\u57DC\u57F4\u5800\u57ED\u57FD\u5808\u57F8\u580B\u57F3\u57CF\u5807\u57EE\u57E3\u57F2\u57E5\u57EC\u57E1\u580E\u57FC\u5810\u57E7\u5801\u580C\u57F1\u57E9\u57F0\u580D\u5804\u595C\u5A60\u5A58\u5A55\u5A67\u5A5E\u5A38\u5A35\u5A6D\u5A50\u5A5F\u5A65\u5A6C\u5A53\u5A64\u5A57\u5A43\u5A5D\u5A52\u5A44\u5A5B\u5A48\u5A8E\u5A3E\u5A4D\u5A39\u5A4C\u5A70\u5A69\u5A47\u5A51\u5A56\u5A42\u5A5C\u5B72\u5B6E\u5BC1\u5BC0\u5C59\u5D1E\u5D0B\u5D1D\u5D1A\u5D20\u5D0C\u5D28\u5D0D\u5D26\u5D25\u5D0F"],
      ["d540", "\u5D30\u5D12\u5D23\u5D1F\u5D2E\u5E3E\u5E34\u5EB1\u5EB4\u5EB9\u5EB2\u5EB3\u5F36\u5F38\u5F9B\u5F96\u5F9F\u608A\u6090\u6086\u60BE\u60B0\u60BA\u60D3\u60D4\u60CF\u60E4\u60D9\u60DD\u60C8\u60B1\u60DB\u60B7\u60CA\u60BF\u60C3\u60CD\u60C0\u6332\u6365\u638A\u6382\u637D\u63BD\u639E\u63AD\u639D\u6397\u63AB\u638E\u636F\u6387\u6390\u636E\u63AF\u6375\u639C\u636D\u63AE\u637C\u63A4\u633B\u639F"],
      ["d5a1", "\u6378\u6385\u6381\u6391\u638D\u6370\u6553\u65CD\u6665\u6661\u665B\u6659\u665C\u6662\u6718\u6879\u6887\u6890\u689C\u686D\u686E\u68AE\u68AB\u6956\u686F\u68A3\u68AC\u68A9\u6875\u6874\u68B2\u688F\u6877\u6892\u687C\u686B\u6872\u68AA\u6880\u6871\u687E\u689B\u6896\u688B\u68A0\u6889\u68A4\u6878\u687B\u6891\u688C\u688A\u687D\u6B36\u6B33\u6B37\u6B38\u6B91\u6B8F\u6B8D\u6B8E\u6B8C\u6C2A\u6DC0\u6DAB\u6DB4\u6DB3\u6E74\u6DAC\u6DE9\u6DE2\u6DB7\u6DF6\u6DD4\u6E00\u6DC8\u6DE0\u6DDF\u6DD6\u6DBE\u6DE5\u6DDC\u6DDD\u6DDB\u6DF4\u6DCA\u6DBD\u6DED\u6DF0\u6DBA\u6DD5\u6DC2\u6DCF\u6DC9"],
      ["d640", "\u6DD0\u6DF2\u6DD3\u6DFD\u6DD7\u6DCD\u6DE3\u6DBB\u70FA\u710D\u70F7\u7117\u70F4\u710C\u70F0\u7104\u70F3\u7110\u70FC\u70FF\u7106\u7113\u7100\u70F8\u70F6\u710B\u7102\u710E\u727E\u727B\u727C\u727F\u731D\u7317\u7307\u7311\u7318\u730A\u7308\u72FF\u730F\u731E\u7388\u73F6\u73F8\u73F5\u7404\u7401\u73FD\u7407\u7400\u73FA\u73FC\u73FF\u740C\u740B\u73F4\u7408\u7564\u7563\u75CE\u75D2\u75CF"],
      ["d6a1", "\u75CB\u75CC\u75D1\u75D0\u768F\u7689\u76D3\u7739\u772F\u772D\u7731\u7732\u7734\u7733\u773D\u7725\u773B\u7735\u7848\u7852\u7849\u784D\u784A\u784C\u7826\u7845\u7850\u7964\u7967\u7969\u796A\u7963\u796B\u7961\u79BB\u79FA\u79F8\u79F6\u79F7\u7A8F\u7A94\u7A90\u7B35\u7B47\u7B34\u7B25\u7B30\u7B22\u7B24\u7B33\u7B18\u7B2A\u7B1D\u7B31\u7B2B\u7B2D\u7B2F\u7B32\u7B38\u7B1A\u7B23\u7C94\u7C98\u7C96\u7CA3\u7D35\u7D3D\u7D38\u7D36\u7D3A\u7D45\u7D2C\u7D29\u7D41\u7D47\u7D3E\u7D3F\u7D4A\u7D3B\u7D28\u7F63\u7F95\u7F9C\u7F9D\u7F9B\u7FCA\u7FCB\u7FCD\u7FD0\u7FD1\u7FC7\u7FCF\u7FC9\u801F"],
      ["d740", "\u801E\u801B\u8047\u8043\u8048\u8118\u8125\u8119\u811B\u812D\u811F\u812C\u811E\u8121\u8115\u8127\u811D\u8122\u8211\u8238\u8233\u823A\u8234\u8232\u8274\u8390\u83A3\u83A8\u838D\u837A\u8373\u83A4\u8374\u838F\u8381\u8395\u8399\u8375\u8394\u83A9\u837D\u8383\u838C\u839D\u839B\u83AA\u838B\u837E\u83A5\u83AF\u8388\u8397\u83B0\u837F\u83A6\u8387\u83AE\u8376\u839A\u8659\u8656\u86BF\u86B7"],
      ["d7a1", "\u86C2\u86C1\u86C5\u86BA\u86B0\u86C8\u86B9\u86B3\u86B8\u86CC\u86B4\u86BB\u86BC\u86C3\u86BD\u86BE\u8852\u8889\u8895\u88A8\u88A2\u88AA\u889A\u8891\u88A1\u889F\u8898\u88A7\u8899\u889B\u8897\u88A4\u88AC\u888C\u8893\u888E\u8982\u89D6\u89D9\u89D5\u8A30\u8A27\u8A2C\u8A1E\u8C39\u8C3B\u8C5C\u8C5D\u8C7D\u8CA5\u8D7D\u8D7B\u8D79\u8DBC\u8DC2\u8DB9\u8DBF\u8DC1\u8ED8\u8EDE\u8EDD\u8EDC\u8ED7\u8EE0\u8EE1\u9024\u900B\u9011\u901C\u900C\u9021\u90EF\u90EA\u90F0\u90F4\u90F2\u90F3\u90D4\u90EB\u90EC\u90E9\u9156\u9158\u915A\u9153\u9155\u91EC\u91F4\u91F1\u91F3\u91F8\u91E4\u91F9\u91EA"],
      ["d840", "\u91EB\u91F7\u91E8\u91EE\u957A\u9586\u9588\u967C\u966D\u966B\u9671\u966F\u96BF\u976A\u9804\u98E5\u9997\u509B\u5095\u5094\u509E\u508B\u50A3\u5083\u508C\u508E\u509D\u5068\u509C\u5092\u5082\u5087\u515F\u51D4\u5312\u5311\u53A4\u53A7\u5591\u55A8\u55A5\u55AD\u5577\u5645\u55A2\u5593\u5588\u558F\u55B5\u5581\u55A3\u5592\u55A4\u557D\u558C\u55A6\u557F\u5595\u55A1\u558E\u570C\u5829\u5837"],
      ["d8a1", "\u5819\u581E\u5827\u5823\u5828\u57F5\u5848\u5825\u581C\u581B\u5833\u583F\u5836\u582E\u5839\u5838\u582D\u582C\u583B\u5961\u5AAF\u5A94\u5A9F\u5A7A\u5AA2\u5A9E\u5A78\u5AA6\u5A7C\u5AA5\u5AAC\u5A95\u5AAE\u5A37\u5A84\u5A8A\u5A97\u5A83\u5A8B\u5AA9\u5A7B\u5A7D\u5A8C\u5A9C\u5A8F\u5A93\u5A9D\u5BEA\u5BCD\u5BCB\u5BD4\u5BD1\u5BCA\u5BCE\u5C0C\u5C30\u5D37\u5D43\u5D6B\u5D41\u5D4B\u5D3F\u5D35\u5D51\u5D4E\u5D55\u5D33\u5D3A\u5D52\u5D3D\u5D31\u5D59\u5D42\u5D39\u5D49\u5D38\u5D3C\u5D32\u5D36\u5D40\u5D45\u5E44\u5E41\u5F58\u5FA6\u5FA5\u5FAB\u60C9\u60B9\u60CC\u60E2\u60CE\u60C4\u6114"],
      ["d940", "\u60F2\u610A\u6116\u6105\u60F5\u6113\u60F8\u60FC\u60FE\u60C1\u6103\u6118\u611D\u6110\u60FF\u6104\u610B\u624A\u6394\u63B1\u63B0\u63CE\u63E5\u63E8\u63EF\u63C3\u649D\u63F3\u63CA\u63E0\u63F6\u63D5\u63F2\u63F5\u6461\u63DF\u63BE\u63DD\u63DC\u63C4\u63D8\u63D3\u63C2\u63C7\u63CC\u63CB\u63C8\u63F0\u63D7\u63D9\u6532\u6567\u656A\u6564\u655C\u6568\u6565\u658C\u659D\u659E\u65AE\u65D0\u65D2"],
      ["d9a1", "\u667C\u666C\u667B\u6680\u6671\u6679\u666A\u6672\u6701\u690C\u68D3\u6904\u68DC\u692A\u68EC\u68EA\u68F1\u690F\u68D6\u68F7\u68EB\u68E4\u68F6\u6913\u6910\u68F3\u68E1\u6907\u68CC\u6908\u6970\u68B4\u6911\u68EF\u68C6\u6914\u68F8\u68D0\u68FD\u68FC\u68E8\u690B\u690A\u6917\u68CE\u68C8\u68DD\u68DE\u68E6\u68F4\u68D1\u6906\u68D4\u68E9\u6915\u6925\u68C7\u6B39\u6B3B\u6B3F\u6B3C\u6B94\u6B97\u6B99\u6B95\u6BBD\u6BF0\u6BF2\u6BF3\u6C30\u6DFC\u6E46\u6E47\u6E1F\u6E49\u6E88\u6E3C\u6E3D\u6E45\u6E62\u6E2B\u6E3F\u6E41\u6E5D\u6E73\u6E1C\u6E33\u6E4B\u6E40\u6E51\u6E3B\u6E03\u6E2E\u6E5E"],
      ["da40", "\u6E68\u6E5C\u6E61\u6E31\u6E28\u6E60\u6E71\u6E6B\u6E39\u6E22\u6E30\u6E53\u6E65\u6E27\u6E78\u6E64\u6E77\u6E55\u6E79\u6E52\u6E66\u6E35\u6E36\u6E5A\u7120\u711E\u712F\u70FB\u712E\u7131\u7123\u7125\u7122\u7132\u711F\u7128\u713A\u711B\u724B\u725A\u7288\u7289\u7286\u7285\u728B\u7312\u730B\u7330\u7322\u7331\u7333\u7327\u7332\u732D\u7326\u7323\u7335\u730C\u742E\u742C\u7430\u742B\u7416"],
      ["daa1", "\u741A\u7421\u742D\u7431\u7424\u7423\u741D\u7429\u7420\u7432\u74FB\u752F\u756F\u756C\u75E7\u75DA\u75E1\u75E6\u75DD\u75DF\u75E4\u75D7\u7695\u7692\u76DA\u7746\u7747\u7744\u774D\u7745\u774A\u774E\u774B\u774C\u77DE\u77EC\u7860\u7864\u7865\u785C\u786D\u7871\u786A\u786E\u7870\u7869\u7868\u785E\u7862\u7974\u7973\u7972\u7970\u7A02\u7A0A\u7A03\u7A0C\u7A04\u7A99\u7AE6\u7AE4\u7B4A\u7B3B\u7B44\u7B48\u7B4C\u7B4E\u7B40\u7B58\u7B45\u7CA2\u7C9E\u7CA8\u7CA1\u7D58\u7D6F\u7D63\u7D53\u7D56\u7D67\u7D6A\u7D4F\u7D6D\u7D5C\u7D6B\u7D52\u7D54\u7D69\u7D51\u7D5F\u7D4E\u7F3E\u7F3F\u7F65"],
      ["db40", "\u7F66\u7FA2\u7FA0\u7FA1\u7FD7\u8051\u804F\u8050\u80FE\u80D4\u8143\u814A\u8152\u814F\u8147\u813D\u814D\u813A\u81E6\u81EE\u81F7\u81F8\u81F9\u8204\u823C\u823D\u823F\u8275\u833B\u83CF\u83F9\u8423\u83C0\u83E8\u8412\u83E7\u83E4\u83FC\u83F6\u8410\u83C6\u83C8\u83EB\u83E3\u83BF\u8401\u83DD\u83E5\u83D8\u83FF\u83E1\u83CB\u83CE\u83D6\u83F5\u83C9\u8409\u840F\u83DE\u8411\u8406\u83C2\u83F3"],
      ["dba1", "\u83D5\u83FA\u83C7\u83D1\u83EA\u8413\u83C3\u83EC\u83EE\u83C4\u83FB\u83D7\u83E2\u841B\u83DB\u83FE\u86D8\u86E2\u86E6\u86D3\u86E3\u86DA\u86EA\u86DD\u86EB\u86DC\u86EC\u86E9\u86D7\u86E8\u86D1\u8848\u8856\u8855\u88BA\u88D7\u88B9\u88B8\u88C0\u88BE\u88B6\u88BC\u88B7\u88BD\u88B2\u8901\u88C9\u8995\u8998\u8997\u89DD\u89DA\u89DB\u8A4E\u8A4D\u8A39\u8A59\u8A40\u8A57\u8A58\u8A44\u8A45\u8A52\u8A48\u8A51\u8A4A\u8A4C\u8A4F\u8C5F\u8C81\u8C80\u8CBA\u8CBE\u8CB0\u8CB9\u8CB5\u8D84\u8D80\u8D89\u8DD8\u8DD3\u8DCD\u8DC7\u8DD6\u8DDC\u8DCF\u8DD5\u8DD9\u8DC8\u8DD7\u8DC5\u8EEF\u8EF7\u8EFA"],
      ["dc40", "\u8EF9\u8EE6\u8EEE\u8EE5\u8EF5\u8EE7\u8EE8\u8EF6\u8EEB\u8EF1\u8EEC\u8EF4\u8EE9\u902D\u9034\u902F\u9106\u912C\u9104\u90FF\u90FC\u9108\u90F9\u90FB\u9101\u9100\u9107\u9105\u9103\u9161\u9164\u915F\u9162\u9160\u9201\u920A\u9225\u9203\u921A\u9226\u920F\u920C\u9200\u9212\u91FF\u91FD\u9206\u9204\u9227\u9202\u921C\u9224\u9219\u9217\u9205\u9216\u957B\u958D\u958C\u9590\u9687\u967E\u9688"],
      ["dca1", "\u9689\u9683\u9680\u96C2\u96C8\u96C3\u96F1\u96F0\u976C\u9770\u976E\u9807\u98A9\u98EB\u9CE6\u9EF9\u4E83\u4E84\u4EB6\u50BD\u50BF\u50C6\u50AE\u50C4\u50CA\u50B4\u50C8\u50C2\u50B0\u50C1\u50BA\u50B1\u50CB\u50C9\u50B6\u50B8\u51D7\u527A\u5278\u527B\u527C\u55C3\u55DB\u55CC\u55D0\u55CB\u55CA\u55DD\u55C0\u55D4\u55C4\u55E9\u55BF\u55D2\u558D\u55CF\u55D5\u55E2\u55D6\u55C8\u55F2\u55CD\u55D9\u55C2\u5714\u5853\u5868\u5864\u584F\u584D\u5849\u586F\u5855\u584E\u585D\u5859\u5865\u585B\u583D\u5863\u5871\u58FC\u5AC7\u5AC4\u5ACB\u5ABA\u5AB8\u5AB1\u5AB5\u5AB0\u5ABF\u5AC8\u5ABB\u5AC6"],
      ["dd40", "\u5AB7\u5AC0\u5ACA\u5AB4\u5AB6\u5ACD\u5AB9\u5A90\u5BD6\u5BD8\u5BD9\u5C1F\u5C33\u5D71\u5D63\u5D4A\u5D65\u5D72\u5D6C\u5D5E\u5D68\u5D67\u5D62\u5DF0\u5E4F\u5E4E\u5E4A\u5E4D\u5E4B\u5EC5\u5ECC\u5EC6\u5ECB\u5EC7\u5F40\u5FAF\u5FAD\u60F7\u6149\u614A\u612B\u6145\u6136\u6132\u612E\u6146\u612F\u614F\u6129\u6140\u6220\u9168\u6223\u6225\u6224\u63C5\u63F1\u63EB\u6410\u6412\u6409\u6420\u6424"],
      ["dda1", "\u6433\u6443\u641F\u6415\u6418\u6439\u6437\u6422\u6423\u640C\u6426\u6430\u6428\u6441\u6435\u642F\u640A\u641A\u6440\u6425\u6427\u640B\u63E7\u641B\u642E\u6421\u640E\u656F\u6592\u65D3\u6686\u668C\u6695\u6690\u668B\u668A\u6699\u6694\u6678\u6720\u6966\u695F\u6938\u694E\u6962\u6971\u693F\u6945\u696A\u6939\u6942\u6957\u6959\u697A\u6948\u6949\u6935\u696C\u6933\u693D\u6965\u68F0\u6978\u6934\u6969\u6940\u696F\u6944\u6976\u6958\u6941\u6974\u694C\u693B\u694B\u6937\u695C\u694F\u6951\u6932\u6952\u692F\u697B\u693C\u6B46\u6B45\u6B43\u6B42\u6B48\u6B41\u6B9B\uFA0D\u6BFB\u6BFC"],
      ["de40", "\u6BF9\u6BF7\u6BF8\u6E9B\u6ED6\u6EC8\u6E8F\u6EC0\u6E9F\u6E93\u6E94\u6EA0\u6EB1\u6EB9\u6EC6\u6ED2\u6EBD\u6EC1\u6E9E\u6EC9\u6EB7\u6EB0\u6ECD\u6EA6\u6ECF\u6EB2\u6EBE\u6EC3\u6EDC\u6ED8\u6E99\u6E92\u6E8E\u6E8D\u6EA4\u6EA1\u6EBF\u6EB3\u6ED0\u6ECA\u6E97\u6EAE\u6EA3\u7147\u7154\u7152\u7163\u7160\u7141\u715D\u7162\u7172\u7178\u716A\u7161\u7142\u7158\u7143\u714B\u7170\u715F\u7150\u7153"],
      ["dea1", "\u7144\u714D\u715A\u724F\u728D\u728C\u7291\u7290\u728E\u733C\u7342\u733B\u733A\u7340\u734A\u7349\u7444\u744A\u744B\u7452\u7451\u7457\u7440\u744F\u7450\u744E\u7442\u7446\u744D\u7454\u74E1\u74FF\u74FE\u74FD\u751D\u7579\u7577\u6983\u75EF\u760F\u7603\u75F7\u75FE\u75FC\u75F9\u75F8\u7610\u75FB\u75F6\u75ED\u75F5\u75FD\u7699\u76B5\u76DD\u7755\u775F\u7760\u7752\u7756\u775A\u7769\u7767\u7754\u7759\u776D\u77E0\u7887\u789A\u7894\u788F\u7884\u7895\u7885\u7886\u78A1\u7883\u7879\u7899\u7880\u7896\u787B\u797C\u7982\u797D\u7979\u7A11\u7A18\u7A19\u7A12\u7A17\u7A15\u7A22\u7A13"],
      ["df40", "\u7A1B\u7A10\u7AA3\u7AA2\u7A9E\u7AEB\u7B66\u7B64\u7B6D\u7B74\u7B69\u7B72\u7B65\u7B73\u7B71\u7B70\u7B61\u7B78\u7B76\u7B63\u7CB2\u7CB4\u7CAF\u7D88\u7D86\u7D80\u7D8D\u7D7F\u7D85\u7D7A\u7D8E\u7D7B\u7D83\u7D7C\u7D8C\u7D94\u7D84\u7D7D\u7D92\u7F6D\u7F6B\u7F67\u7F68\u7F6C\u7FA6\u7FA5\u7FA7\u7FDB\u7FDC\u8021\u8164\u8160\u8177\u815C\u8169\u815B\u8162\u8172\u6721\u815E\u8176\u8167\u816F"],
      ["dfa1", "\u8144\u8161\u821D\u8249\u8244\u8240\u8242\u8245\u84F1\u843F\u8456\u8476\u8479\u848F\u848D\u8465\u8451\u8440\u8486\u8467\u8430\u844D\u847D\u845A\u8459\u8474\u8473\u845D\u8507\u845E\u8437\u843A\u8434\u847A\u8443\u8478\u8432\u8445\u8429\u83D9\u844B\u842F\u8442\u842D\u845F\u8470\u8439\u844E\u844C\u8452\u846F\u84C5\u848E\u843B\u8447\u8436\u8433\u8468\u847E\u8444\u842B\u8460\u8454\u846E\u8450\u870B\u8704\u86F7\u870C\u86FA\u86D6\u86F5\u874D\u86F8\u870E\u8709\u8701\u86F6\u870D\u8705\u88D6\u88CB\u88CD\u88CE\u88DE\u88DB\u88DA\u88CC\u88D0\u8985\u899B\u89DF\u89E5\u89E4"],
      ["e040", "\u89E1\u89E0\u89E2\u89DC\u89E6\u8A76\u8A86\u8A7F\u8A61\u8A3F\u8A77\u8A82\u8A84\u8A75\u8A83\u8A81\u8A74\u8A7A\u8C3C\u8C4B\u8C4A\u8C65\u8C64\u8C66\u8C86\u8C84\u8C85\u8CCC\u8D68\u8D69\u8D91\u8D8C\u8D8E\u8D8F\u8D8D\u8D93\u8D94\u8D90\u8D92\u8DF0\u8DE0\u8DEC\u8DF1\u8DEE\u8DD0\u8DE9\u8DE3\u8DE2\u8DE7\u8DF2\u8DEB\u8DF4\u8F06\u8EFF\u8F01\u8F00\u8F05\u8F07\u8F08\u8F02\u8F0B\u9052\u903F"],
      ["e0a1", "\u9044\u9049\u903D\u9110\u910D\u910F\u9111\u9116\u9114\u910B\u910E\u916E\u916F\u9248\u9252\u9230\u923A\u9266\u9233\u9265\u925E\u9283\u922E\u924A\u9246\u926D\u926C\u924F\u9260\u9267\u926F\u9236\u9261\u9270\u9231\u9254\u9263\u9250\u9272\u924E\u9253\u924C\u9256\u9232\u959F\u959C\u959E\u959B\u9692\u9693\u9691\u9697\u96CE\u96FA\u96FD\u96F8\u96F5\u9773\u9777\u9778\u9772\u980F\u980D\u980E\u98AC\u98F6\u98F9\u99AF\u99B2\u99B0\u99B5\u9AAD\u9AAB\u9B5B\u9CEA\u9CED\u9CE7\u9E80\u9EFD\u50E6\u50D4\u50D7\u50E8\u50F3\u50DB\u50EA\u50DD\u50E4\u50D3\u50EC\u50F0\u50EF\u50E3\u50E0"],
      ["e140", "\u51D8\u5280\u5281\u52E9\u52EB\u5330\u53AC\u5627\u5615\u560C\u5612\u55FC\u560F\u561C\u5601\u5613\u5602\u55FA\u561D\u5604\u55FF\u55F9\u5889\u587C\u5890\u5898\u5886\u5881\u587F\u5874\u588B\u587A\u5887\u5891\u588E\u5876\u5882\u5888\u587B\u5894\u588F\u58FE\u596B\u5ADC\u5AEE\u5AE5\u5AD5\u5AEA\u5ADA\u5AED\u5AEB\u5AF3\u5AE2\u5AE0\u5ADB\u5AEC\u5ADE\u5ADD\u5AD9\u5AE8\u5ADF\u5B77\u5BE0"],
      ["e1a1", "\u5BE3\u5C63\u5D82\u5D80\u5D7D\u5D86\u5D7A\u5D81\u5D77\u5D8A\u5D89\u5D88\u5D7E\u5D7C\u5D8D\u5D79\u5D7F\u5E58\u5E59\u5E53\u5ED8\u5ED1\u5ED7\u5ECE\u5EDC\u5ED5\u5ED9\u5ED2\u5ED4\u5F44\u5F43\u5F6F\u5FB6\u612C\u6128\u6141\u615E\u6171\u6173\u6152\u6153\u6172\u616C\u6180\u6174\u6154\u617A\u615B\u6165\u613B\u616A\u6161\u6156\u6229\u6227\u622B\u642B\u644D\u645B\u645D\u6474\u6476\u6472\u6473\u647D\u6475\u6466\u64A6\u644E\u6482\u645E\u645C\u644B\u6453\u6460\u6450\u647F\u643F\u646C\u646B\u6459\u6465\u6477\u6573\u65A0\u66A1\u66A0\u669F\u6705\u6704\u6722\u69B1\u69B6\u69C9"],
      ["e240", "\u69A0\u69CE\u6996\u69B0\u69AC\u69BC\u6991\u6999\u698E\u69A7\u698D\u69A9\u69BE\u69AF\u69BF\u69C4\u69BD\u69A4\u69D4\u69B9\u69CA\u699A\u69CF\u69B3\u6993\u69AA\u69A1\u699E\u69D9\u6997\u6990\u69C2\u69B5\u69A5\u69C6\u6B4A\u6B4D\u6B4B\u6B9E\u6B9F\u6BA0\u6BC3\u6BC4\u6BFE\u6ECE\u6EF5\u6EF1\u6F03\u6F25\u6EF8\u6F37\u6EFB\u6F2E\u6F09\u6F4E\u6F19\u6F1A\u6F27\u6F18\u6F3B\u6F12\u6EED\u6F0A"],
      ["e2a1", "\u6F36\u6F73\u6EF9\u6EEE\u6F2D\u6F40\u6F30\u6F3C\u6F35\u6EEB\u6F07\u6F0E\u6F43\u6F05\u6EFD\u6EF6\u6F39\u6F1C\u6EFC\u6F3A\u6F1F\u6F0D\u6F1E\u6F08\u6F21\u7187\u7190\u7189\u7180\u7185\u7182\u718F\u717B\u7186\u7181\u7197\u7244\u7253\u7297\u7295\u7293\u7343\u734D\u7351\u734C\u7462\u7473\u7471\u7475\u7472\u7467\u746E\u7500\u7502\u7503\u757D\u7590\u7616\u7608\u760C\u7615\u7611\u760A\u7614\u76B8\u7781\u777C\u7785\u7782\u776E\u7780\u776F\u777E\u7783\u78B2\u78AA\u78B4\u78AD\u78A8\u787E\u78AB\u789E\u78A5\u78A0\u78AC\u78A2\u78A4\u7998\u798A\u798B\u7996\u7995\u7994\u7993"],
      ["e340", "\u7997\u7988\u7992\u7990\u7A2B\u7A4A\u7A30\u7A2F\u7A28\u7A26\u7AA8\u7AAB\u7AAC\u7AEE\u7B88\u7B9C\u7B8A\u7B91\u7B90\u7B96\u7B8D\u7B8C\u7B9B\u7B8E\u7B85\u7B98\u5284\u7B99\u7BA4\u7B82\u7CBB\u7CBF\u7CBC\u7CBA\u7DA7\u7DB7\u7DC2\u7DA3\u7DAA\u7DC1\u7DC0\u7DC5\u7D9D\u7DCE\u7DC4\u7DC6\u7DCB\u7DCC\u7DAF\u7DB9\u7D96\u7DBC\u7D9F\u7DA6\u7DAE\u7DA9\u7DA1\u7DC9\u7F73\u7FE2\u7FE3\u7FE5\u7FDE"],
      ["e3a1", "\u8024\u805D\u805C\u8189\u8186\u8183\u8187\u818D\u818C\u818B\u8215\u8497\u84A4\u84A1\u849F\u84BA\u84CE\u84C2\u84AC\u84AE\u84AB\u84B9\u84B4\u84C1\u84CD\u84AA\u849A\u84B1\u84D0\u849D\u84A7\u84BB\u84A2\u8494\u84C7\u84CC\u849B\u84A9\u84AF\u84A8\u84D6\u8498\u84B6\u84CF\u84A0\u84D7\u84D4\u84D2\u84DB\u84B0\u8491\u8661\u8733\u8723\u8728\u876B\u8740\u872E\u871E\u8721\u8719\u871B\u8743\u872C\u8741\u873E\u8746\u8720\u8732\u872A\u872D\u873C\u8712\u873A\u8731\u8735\u8742\u8726\u8727\u8738\u8724\u871A\u8730\u8711\u88F7\u88E7\u88F1\u88F2\u88FA\u88FE\u88EE\u88FC\u88F6\u88FB"],
      ["e440", "\u88F0\u88EC\u88EB\u899D\u89A1\u899F\u899E\u89E9\u89EB\u89E8\u8AAB\u8A99\u8A8B\u8A92\u8A8F\u8A96\u8C3D\u8C68\u8C69\u8CD5\u8CCF\u8CD7\u8D96\u8E09\u8E02\u8DFF\u8E0D\u8DFD\u8E0A\u8E03\u8E07\u8E06\u8E05\u8DFE\u8E00\u8E04\u8F10\u8F11\u8F0E\u8F0D\u9123\u911C\u9120\u9122\u911F\u911D\u911A\u9124\u9121\u911B\u917A\u9172\u9179\u9173\u92A5\u92A4\u9276\u929B\u927A\u92A0\u9294\u92AA\u928D"],
      ["e4a1", "\u92A6\u929A\u92AB\u9279\u9297\u927F\u92A3\u92EE\u928E\u9282\u9295\u92A2\u927D\u9288\u92A1\u928A\u9286\u928C\u9299\u92A7\u927E\u9287\u92A9\u929D\u928B\u922D\u969E\u96A1\u96FF\u9758\u977D\u977A\u977E\u9783\u9780\u9782\u977B\u9784\u9781\u977F\u97CE\u97CD\u9816\u98AD\u98AE\u9902\u9900\u9907\u999D\u999C\u99C3\u99B9\u99BB\u99BA\u99C2\u99BD\u99C7\u9AB1\u9AE3\u9AE7\u9B3E\u9B3F\u9B60\u9B61\u9B5F\u9CF1\u9CF2\u9CF5\u9EA7\u50FF\u5103\u5130\u50F8\u5106\u5107\u50F6\u50FE\u510B\u510C\u50FD\u510A\u528B\u528C\u52F1\u52EF\u5648\u5642\u564C\u5635\u5641\u564A\u5649\u5646\u5658"],
      ["e540", "\u565A\u5640\u5633\u563D\u562C\u563E\u5638\u562A\u563A\u571A\u58AB\u589D\u58B1\u58A0\u58A3\u58AF\u58AC\u58A5\u58A1\u58FF\u5AFF\u5AF4\u5AFD\u5AF7\u5AF6\u5B03\u5AF8\u5B02\u5AF9\u5B01\u5B07\u5B05\u5B0F\u5C67\u5D99\u5D97\u5D9F\u5D92\u5DA2\u5D93\u5D95\u5DA0\u5D9C\u5DA1\u5D9A\u5D9E\u5E69\u5E5D\u5E60\u5E5C\u7DF3\u5EDB\u5EDE\u5EE1\u5F49\u5FB2\u618B\u6183\u6179\u61B1\u61B0\u61A2\u6189"],
      ["e5a1", "\u619B\u6193\u61AF\u61AD\u619F\u6192\u61AA\u61A1\u618D\u6166\u61B3\u622D\u646E\u6470\u6496\u64A0\u6485\u6497\u649C\u648F\u648B\u648A\u648C\u64A3\u649F\u6468\u64B1\u6498\u6576\u657A\u6579\u657B\u65B2\u65B3\u66B5\u66B0\u66A9\u66B2\u66B7\u66AA\u66AF\u6A00\u6A06\u6A17\u69E5\u69F8\u6A15\u69F1\u69E4\u6A20\u69FF\u69EC\u69E2\u6A1B\u6A1D\u69FE\u6A27\u69F2\u69EE\u6A14\u69F7\u69E7\u6A40\u6A08\u69E6\u69FB\u6A0D\u69FC\u69EB\u6A09\u6A04\u6A18\u6A25\u6A0F\u69F6\u6A26\u6A07\u69F4\u6A16\u6B51\u6BA5\u6BA3\u6BA2\u6BA6\u6C01\u6C00\u6BFF\u6C02\u6F41\u6F26\u6F7E\u6F87\u6FC6\u6F92"],
      ["e640", "\u6F8D\u6F89\u6F8C\u6F62\u6F4F\u6F85\u6F5A\u6F96\u6F76\u6F6C\u6F82\u6F55\u6F72\u6F52\u6F50\u6F57\u6F94\u6F93\u6F5D\u6F00\u6F61\u6F6B\u6F7D\u6F67\u6F90\u6F53\u6F8B\u6F69\u6F7F\u6F95\u6F63\u6F77\u6F6A\u6F7B\u71B2\u71AF\u719B\u71B0\u71A0\u719A\u71A9\u71B5\u719D\u71A5\u719E\u71A4\u71A1\u71AA\u719C\u71A7\u71B3\u7298\u729A\u7358\u7352\u735E\u735F\u7360\u735D\u735B\u7361\u735A\u7359"],
      ["e6a1", "\u7362\u7487\u7489\u748A\u7486\u7481\u747D\u7485\u7488\u747C\u7479\u7508\u7507\u757E\u7625\u761E\u7619\u761D\u761C\u7623\u761A\u7628\u761B\u769C\u769D\u769E\u769B\u778D\u778F\u7789\u7788\u78CD\u78BB\u78CF\u78CC\u78D1\u78CE\u78D4\u78C8\u78C3\u78C4\u78C9\u799A\u79A1\u79A0\u799C\u79A2\u799B\u6B76\u7A39\u7AB2\u7AB4\u7AB3\u7BB7\u7BCB\u7BBE\u7BAC\u7BCE\u7BAF\u7BB9\u7BCA\u7BB5\u7CC5\u7CC8\u7CCC\u7CCB\u7DF7\u7DDB\u7DEA\u7DE7\u7DD7\u7DE1\u7E03\u7DFA\u7DE6\u7DF6\u7DF1\u7DF0\u7DEE\u7DDF\u7F76\u7FAC\u7FB0\u7FAD\u7FED\u7FEB\u7FEA\u7FEC\u7FE6\u7FE8\u8064\u8067\u81A3\u819F"],
      ["e740", "\u819E\u8195\u81A2\u8199\u8197\u8216\u824F\u8253\u8252\u8250\u824E\u8251\u8524\u853B\u850F\u8500\u8529\u850E\u8509\u850D\u851F\u850A\u8527\u851C\u84FB\u852B\u84FA\u8508\u850C\u84F4\u852A\u84F2\u8515\u84F7\u84EB\u84F3\u84FC\u8512\u84EA\u84E9\u8516\u84FE\u8528\u851D\u852E\u8502\u84FD\u851E\u84F6\u8531\u8526\u84E7\u84E8\u84F0\u84EF\u84F9\u8518\u8520\u8530\u850B\u8519\u852F\u8662"],
      ["e7a1", "\u8756\u8763\u8764\u8777\u87E1\u8773\u8758\u8754\u875B\u8752\u8761\u875A\u8751\u875E\u876D\u876A\u8750\u874E\u875F\u875D\u876F\u876C\u877A\u876E\u875C\u8765\u874F\u877B\u8775\u8762\u8767\u8769\u885A\u8905\u890C\u8914\u890B\u8917\u8918\u8919\u8906\u8916\u8911\u890E\u8909\u89A2\u89A4\u89A3\u89ED\u89F0\u89EC\u8ACF\u8AC6\u8AB8\u8AD3\u8AD1\u8AD4\u8AD5\u8ABB\u8AD7\u8ABE\u8AC0\u8AC5\u8AD8\u8AC3\u8ABA\u8ABD\u8AD9\u8C3E\u8C4D\u8C8F\u8CE5\u8CDF\u8CD9\u8CE8\u8CDA\u8CDD\u8CE7\u8DA0\u8D9C\u8DA1\u8D9B\u8E20\u8E23\u8E25\u8E24\u8E2E\u8E15\u8E1B\u8E16\u8E11\u8E19\u8E26\u8E27"],
      ["e840", "\u8E14\u8E12\u8E18\u8E13\u8E1C\u8E17\u8E1A\u8F2C\u8F24\u8F18\u8F1A\u8F20\u8F23\u8F16\u8F17\u9073\u9070\u906F\u9067\u906B\u912F\u912B\u9129\u912A\u9132\u9126\u912E\u9185\u9186\u918A\u9181\u9182\u9184\u9180\u92D0\u92C3\u92C4\u92C0\u92D9\u92B6\u92CF\u92F1\u92DF\u92D8\u92E9\u92D7\u92DD\u92CC\u92EF\u92C2\u92E8\u92CA\u92C8\u92CE\u92E6\u92CD\u92D5\u92C9\u92E0\u92DE\u92E7\u92D1\u92D3"],
      ["e8a1", "\u92B5\u92E1\u92C6\u92B4\u957C\u95AC\u95AB\u95AE\u95B0\u96A4\u96A2\u96D3\u9705\u9708\u9702\u975A\u978A\u978E\u9788\u97D0\u97CF\u981E\u981D\u9826\u9829\u9828\u9820\u981B\u9827\u98B2\u9908\u98FA\u9911\u9914\u9916\u9917\u9915\u99DC\u99CD\u99CF\u99D3\u99D4\u99CE\u99C9\u99D6\u99D8\u99CB\u99D7\u99CC\u9AB3\u9AEC\u9AEB\u9AF3\u9AF2\u9AF1\u9B46\u9B43\u9B67\u9B74\u9B71\u9B66\u9B76\u9B75\u9B70\u9B68\u9B64\u9B6C\u9CFC\u9CFA\u9CFD\u9CFF\u9CF7\u9D07\u9D00\u9CF9\u9CFB\u9D08\u9D05\u9D04\u9E83\u9ED3\u9F0F\u9F10\u511C\u5113\u5117\u511A\u5111\u51DE\u5334\u53E1\u5670\u5660\u566E"],
      ["e940", "\u5673\u5666\u5663\u566D\u5672\u565E\u5677\u571C\u571B\u58C8\u58BD\u58C9\u58BF\u58BA\u58C2\u58BC\u58C6\u5B17\u5B19\u5B1B\u5B21\u5B14\u5B13\u5B10\u5B16\u5B28\u5B1A\u5B20\u5B1E\u5BEF\u5DAC\u5DB1\u5DA9\u5DA7\u5DB5\u5DB0\u5DAE\u5DAA\u5DA8\u5DB2\u5DAD\u5DAF\u5DB4\u5E67\u5E68\u5E66\u5E6F\u5EE9\u5EE7\u5EE6\u5EE8\u5EE5\u5F4B\u5FBC\u619D\u61A8\u6196\u61C5\u61B4\u61C6\u61C1\u61CC\u61BA"],
      ["e9a1", "\u61BF\u61B8\u618C\u64D7\u64D6\u64D0\u64CF\u64C9\u64BD\u6489\u64C3\u64DB\u64F3\u64D9\u6533\u657F\u657C\u65A2\u66C8\u66BE\u66C0\u66CA\u66CB\u66CF\u66BD\u66BB\u66BA\u66CC\u6723\u6A34\u6A66\u6A49\u6A67\u6A32\u6A68\u6A3E\u6A5D\u6A6D\u6A76\u6A5B\u6A51\u6A28\u6A5A\u6A3B\u6A3F\u6A41\u6A6A\u6A64\u6A50\u6A4F\u6A54\u6A6F\u6A69\u6A60\u6A3C\u6A5E\u6A56\u6A55\u6A4D\u6A4E\u6A46\u6B55\u6B54\u6B56\u6BA7\u6BAA\u6BAB\u6BC8\u6BC7\u6C04\u6C03\u6C06\u6FAD\u6FCB\u6FA3\u6FC7\u6FBC\u6FCE\u6FC8\u6F5E\u6FC4\u6FBD\u6F9E\u6FCA\u6FA8\u7004\u6FA5\u6FAE\u6FBA\u6FAC\u6FAA\u6FCF\u6FBF\u6FB8"],
      ["ea40", "\u6FA2\u6FC9\u6FAB\u6FCD\u6FAF\u6FB2\u6FB0\u71C5\u71C2\u71BF\u71B8\u71D6\u71C0\u71C1\u71CB\u71D4\u71CA\u71C7\u71CF\u71BD\u71D8\u71BC\u71C6\u71DA\u71DB\u729D\u729E\u7369\u7366\u7367\u736C\u7365\u736B\u736A\u747F\u749A\u74A0\u7494\u7492\u7495\u74A1\u750B\u7580\u762F\u762D\u7631\u763D\u7633\u763C\u7635\u7632\u7630\u76BB\u76E6\u779A\u779D\u77A1\u779C\u779B\u77A2\u77A3\u7795\u7799"],
      ["eaa1", "\u7797\u78DD\u78E9\u78E5\u78EA\u78DE\u78E3\u78DB\u78E1\u78E2\u78ED\u78DF\u78E0\u79A4\u7A44\u7A48\u7A47\u7AB6\u7AB8\u7AB5\u7AB1\u7AB7\u7BDE\u7BE3\u7BE7\u7BDD\u7BD5\u7BE5\u7BDA\u7BE8\u7BF9\u7BD4\u7BEA\u7BE2\u7BDC\u7BEB\u7BD8\u7BDF\u7CD2\u7CD4\u7CD7\u7CD0\u7CD1\u7E12\u7E21\u7E17\u7E0C\u7E1F\u7E20\u7E13\u7E0E\u7E1C\u7E15\u7E1A\u7E22\u7E0B\u7E0F\u7E16\u7E0D\u7E14\u7E25\u7E24\u7F43\u7F7B\u7F7C\u7F7A\u7FB1\u7FEF\u802A\u8029\u806C\u81B1\u81A6\u81AE\u81B9\u81B5\u81AB\u81B0\u81AC\u81B4\u81B2\u81B7\u81A7\u81F2\u8255\u8256\u8257\u8556\u8545\u856B\u854D\u8553\u8561\u8558"],
      ["eb40", "\u8540\u8546\u8564\u8541\u8562\u8544\u8551\u8547\u8563\u853E\u855B\u8571\u854E\u856E\u8575\u8555\u8567\u8560\u858C\u8566\u855D\u8554\u8565\u856C\u8663\u8665\u8664\u879B\u878F\u8797\u8793\u8792\u8788\u8781\u8796\u8798\u8779\u8787\u87A3\u8785\u8790\u8791\u879D\u8784\u8794\u879C\u879A\u8789\u891E\u8926\u8930\u892D\u892E\u8927\u8931\u8922\u8929\u8923\u892F\u892C\u891F\u89F1\u8AE0"],
      ["eba1", "\u8AE2\u8AF2\u8AF4\u8AF5\u8ADD\u8B14\u8AE4\u8ADF\u8AF0\u8AC8\u8ADE\u8AE1\u8AE8\u8AFF\u8AEF\u8AFB\u8C91\u8C92\u8C90\u8CF5\u8CEE\u8CF1\u8CF0\u8CF3\u8D6C\u8D6E\u8DA5\u8DA7\u8E33\u8E3E\u8E38\u8E40\u8E45\u8E36\u8E3C\u8E3D\u8E41\u8E30\u8E3F\u8EBD\u8F36\u8F2E\u8F35\u8F32\u8F39\u8F37\u8F34\u9076\u9079\u907B\u9086\u90FA\u9133\u9135\u9136\u9193\u9190\u9191\u918D\u918F\u9327\u931E\u9308\u931F\u9306\u930F\u937A\u9338\u933C\u931B\u9323\u9312\u9301\u9346\u932D\u930E\u930D\u92CB\u931D\u92FA\u9325\u9313\u92F9\u92F7\u9334\u9302\u9324\u92FF\u9329\u9339\u9335\u932A\u9314\u930C"],
      ["ec40", "\u930B\u92FE\u9309\u9300\u92FB\u9316\u95BC\u95CD\u95BE\u95B9\u95BA\u95B6\u95BF\u95B5\u95BD\u96A9\u96D4\u970B\u9712\u9710\u9799\u9797\u9794\u97F0\u97F8\u9835\u982F\u9832\u9924\u991F\u9927\u9929\u999E\u99EE\u99EC\u99E5\u99E4\u99F0\u99E3\u99EA\u99E9\u99E7\u9AB9\u9ABF\u9AB4\u9ABB\u9AF6\u9AFA\u9AF9\u9AF7\u9B33\u9B80\u9B85\u9B87\u9B7C\u9B7E\u9B7B\u9B82\u9B93\u9B92\u9B90\u9B7A\u9B95"],
      ["eca1", "\u9B7D\u9B88\u9D25\u9D17\u9D20\u9D1E\u9D14\u9D29\u9D1D\u9D18\u9D22\u9D10\u9D19\u9D1F\u9E88\u9E86\u9E87\u9EAE\u9EAD\u9ED5\u9ED6\u9EFA\u9F12\u9F3D\u5126\u5125\u5122\u5124\u5120\u5129\u52F4\u5693\u568C\u568D\u5686\u5684\u5683\u567E\u5682\u567F\u5681\u58D6\u58D4\u58CF\u58D2\u5B2D\u5B25\u5B32\u5B23\u5B2C\u5B27\u5B26\u5B2F\u5B2E\u5B7B\u5BF1\u5BF2\u5DB7\u5E6C\u5E6A\u5FBE\u5FBB\u61C3\u61B5\u61BC\u61E7\u61E0\u61E5\u61E4\u61E8\u61DE\u64EF\u64E9\u64E3\u64EB\u64E4\u64E8\u6581\u6580\u65B6\u65DA\u66D2\u6A8D\u6A96\u6A81\u6AA5\u6A89\u6A9F\u6A9B\u6AA1\u6A9E\u6A87\u6A93\u6A8E"],
      ["ed40", "\u6A95\u6A83\u6AA8\u6AA4\u6A91\u6A7F\u6AA6\u6A9A\u6A85\u6A8C\u6A92\u6B5B\u6BAD\u6C09\u6FCC\u6FA9\u6FF4\u6FD4\u6FE3\u6FDC\u6FED\u6FE7\u6FE6\u6FDE\u6FF2\u6FDD\u6FE2\u6FE8\u71E1\u71F1\u71E8\u71F2\u71E4\u71F0\u71E2\u7373\u736E\u736F\u7497\u74B2\u74AB\u7490\u74AA\u74AD\u74B1\u74A5\u74AF\u7510\u7511\u7512\u750F\u7584\u7643\u7648\u7649\u7647\u76A4\u76E9\u77B5\u77AB\u77B2\u77B7\u77B6"],
      ["eda1", "\u77B4\u77B1\u77A8\u77F0\u78F3\u78FD\u7902\u78FB\u78FC\u78F2\u7905\u78F9\u78FE\u7904\u79AB\u79A8\u7A5C\u7A5B\u7A56\u7A58\u7A54\u7A5A\u7ABE\u7AC0\u7AC1\u7C05\u7C0F\u7BF2\u7C00\u7BFF\u7BFB\u7C0E\u7BF4\u7C0B\u7BF3\u7C02\u7C09\u7C03\u7C01\u7BF8\u7BFD\u7C06\u7BF0\u7BF1\u7C10\u7C0A\u7CE8\u7E2D\u7E3C\u7E42\u7E33\u9848\u7E38\u7E2A\u7E49\u7E40\u7E47\u7E29\u7E4C\u7E30\u7E3B\u7E36\u7E44\u7E3A\u7F45\u7F7F\u7F7E\u7F7D\u7FF4\u7FF2\u802C\u81BB\u81C4\u81CC\u81CA\u81C5\u81C7\u81BC\u81E9\u825B\u825A\u825C\u8583\u8580\u858F\u85A7\u8595\u85A0\u858B\u85A3\u857B\u85A4\u859A\u859E"],
      ["ee40", "\u8577\u857C\u8589\u85A1\u857A\u8578\u8557\u858E\u8596\u8586\u858D\u8599\u859D\u8581\u85A2\u8582\u8588\u8585\u8579\u8576\u8598\u8590\u859F\u8668\u87BE\u87AA\u87AD\u87C5\u87B0\u87AC\u87B9\u87B5\u87BC\u87AE\u87C9\u87C3\u87C2\u87CC\u87B7\u87AF\u87C4\u87CA\u87B4\u87B6\u87BF\u87B8\u87BD\u87DE\u87B2\u8935\u8933\u893C\u893E\u8941\u8952\u8937\u8942\u89AD\u89AF\u89AE\u89F2\u89F3\u8B1E"],
      ["eea1", "\u8B18\u8B16\u8B11\u8B05\u8B0B\u8B22\u8B0F\u8B12\u8B15\u8B07\u8B0D\u8B08\u8B06\u8B1C\u8B13\u8B1A\u8C4F\u8C70\u8C72\u8C71\u8C6F\u8C95\u8C94\u8CF9\u8D6F\u8E4E\u8E4D\u8E53\u8E50\u8E4C\u8E47\u8F43\u8F40\u9085\u907E\u9138\u919A\u91A2\u919B\u9199\u919F\u91A1\u919D\u91A0\u93A1\u9383\u93AF\u9364\u9356\u9347\u937C\u9358\u935C\u9376\u9349\u9350\u9351\u9360\u936D\u938F\u934C\u936A\u9379\u9357\u9355\u9352\u934F\u9371\u9377\u937B\u9361\u935E\u9363\u9367\u9380\u934E\u9359\u95C7\u95C0\u95C9\u95C3\u95C5\u95B7\u96AE\u96B0\u96AC\u9720\u971F\u9718\u971D\u9719\u979A\u97A1\u979C"],
      ["ef40", "\u979E\u979D\u97D5\u97D4\u97F1\u9841\u9844\u984A\u9849\u9845\u9843\u9925\u992B\u992C\u992A\u9933\u9932\u992F\u992D\u9931\u9930\u9998\u99A3\u99A1\u9A02\u99FA\u99F4\u99F7\u99F9\u99F8\u99F6\u99FB\u99FD\u99FE\u99FC\u9A03\u9ABE\u9AFE\u9AFD\u9B01\u9AFC\u9B48\u9B9A\u9BA8\u9B9E\u9B9B\u9BA6\u9BA1\u9BA5\u9BA4\u9B86\u9BA2\u9BA0\u9BAF\u9D33\u9D41\u9D67\u9D36\u9D2E\u9D2F\u9D31\u9D38\u9D30"],
      ["efa1", "\u9D45\u9D42\u9D43\u9D3E\u9D37\u9D40\u9D3D\u7FF5\u9D2D\u9E8A\u9E89\u9E8D\u9EB0\u9EC8\u9EDA\u9EFB\u9EFF\u9F24\u9F23\u9F22\u9F54\u9FA0\u5131\u512D\u512E\u5698\u569C\u5697\u569A\u569D\u5699\u5970\u5B3C\u5C69\u5C6A\u5DC0\u5E6D\u5E6E\u61D8\u61DF\u61ED\u61EE\u61F1\u61EA\u61F0\u61EB\u61D6\u61E9\u64FF\u6504\u64FD\u64F8\u6501\u6503\u64FC\u6594\u65DB\u66DA\u66DB\u66D8\u6AC5\u6AB9\u6ABD\u6AE1\u6AC6\u6ABA\u6AB6\u6AB7\u6AC7\u6AB4\u6AAD\u6B5E\u6BC9\u6C0B\u7007\u700C\u700D\u7001\u7005\u7014\u700E\u6FFF\u7000\u6FFB\u7026\u6FFC\u6FF7\u700A\u7201\u71FF\u71F9\u7203\u71FD\u7376"],
      ["f040", "\u74B8\u74C0\u74B5\u74C1\u74BE\u74B6\u74BB\u74C2\u7514\u7513\u765C\u7664\u7659\u7650\u7653\u7657\u765A\u76A6\u76BD\u76EC\u77C2\u77BA\u78FF\u790C\u7913\u7914\u7909\u7910\u7912\u7911\u79AD\u79AC\u7A5F\u7C1C\u7C29\u7C19\u7C20\u7C1F\u7C2D\u7C1D\u7C26\u7C28\u7C22\u7C25\u7C30\u7E5C\u7E50\u7E56\u7E63\u7E58\u7E62\u7E5F\u7E51\u7E60\u7E57\u7E53\u7FB5\u7FB3\u7FF7\u7FF8\u8075\u81D1\u81D2"],
      ["f0a1", "\u81D0\u825F\u825E\u85B4\u85C6\u85C0\u85C3\u85C2\u85B3\u85B5\u85BD\u85C7\u85C4\u85BF\u85CB\u85CE\u85C8\u85C5\u85B1\u85B6\u85D2\u8624\u85B8\u85B7\u85BE\u8669\u87E7\u87E6\u87E2\u87DB\u87EB\u87EA\u87E5\u87DF\u87F3\u87E4\u87D4\u87DC\u87D3\u87ED\u87D8\u87E3\u87A4\u87D7\u87D9\u8801\u87F4\u87E8\u87DD\u8953\u894B\u894F\u894C\u8946\u8950\u8951\u8949\u8B2A\u8B27\u8B23\u8B33\u8B30\u8B35\u8B47\u8B2F\u8B3C\u8B3E\u8B31\u8B25\u8B37\u8B26\u8B36\u8B2E\u8B24\u8B3B\u8B3D\u8B3A\u8C42\u8C75\u8C99\u8C98\u8C97\u8CFE\u8D04\u8D02\u8D00\u8E5C\u8E62\u8E60\u8E57\u8E56\u8E5E\u8E65\u8E67"],
      ["f140", "\u8E5B\u8E5A\u8E61\u8E5D\u8E69\u8E54\u8F46\u8F47\u8F48\u8F4B\u9128\u913A\u913B\u913E\u91A8\u91A5\u91A7\u91AF\u91AA\u93B5\u938C\u9392\u93B7\u939B\u939D\u9389\u93A7\u938E\u93AA\u939E\u93A6\u9395\u9388\u9399\u939F\u938D\u93B1\u9391\u93B2\u93A4\u93A8\u93B4\u93A3\u93A5\u95D2\u95D3\u95D1\u96B3\u96D7\u96DA\u5DC2\u96DF\u96D8\u96DD\u9723\u9722\u9725\u97AC\u97AE\u97A8\u97AB\u97A4\u97AA"],
      ["f1a1", "\u97A2\u97A5\u97D7\u97D9\u97D6\u97D8\u97FA\u9850\u9851\u9852\u98B8\u9941\u993C\u993A\u9A0F\u9A0B\u9A09\u9A0D\u9A04\u9A11\u9A0A\u9A05\u9A07\u9A06\u9AC0\u9ADC\u9B08\u9B04\u9B05\u9B29\u9B35\u9B4A\u9B4C\u9B4B\u9BC7\u9BC6\u9BC3\u9BBF\u9BC1\u9BB5\u9BB8\u9BD3\u9BB6\u9BC4\u9BB9\u9BBD\u9D5C\u9D53\u9D4F\u9D4A\u9D5B\u9D4B\u9D59\u9D56\u9D4C\u9D57\u9D52\u9D54\u9D5F\u9D58\u9D5A\u9E8E\u9E8C\u9EDF\u9F01\u9F00\u9F16\u9F25\u9F2B\u9F2A\u9F29\u9F28\u9F4C\u9F55\u5134\u5135\u5296\u52F7\u53B4\u56AB\u56AD\u56A6\u56A7\u56AA\u56AC\u58DA\u58DD\u58DB\u5912\u5B3D\u5B3E\u5B3F\u5DC3\u5E70"],
      ["f240", "\u5FBF\u61FB\u6507\u6510\u650D\u6509\u650C\u650E\u6584\u65DE\u65DD\u66DE\u6AE7\u6AE0\u6ACC\u6AD1\u6AD9\u6ACB\u6ADF\u6ADC\u6AD0\u6AEB\u6ACF\u6ACD\u6ADE\u6B60\u6BB0\u6C0C\u7019\u7027\u7020\u7016\u702B\u7021\u7022\u7023\u7029\u7017\u7024\u701C\u702A\u720C\u720A\u7207\u7202\u7205\u72A5\u72A6\u72A4\u72A3\u72A1\u74CB\u74C5\u74B7\u74C3\u7516\u7660\u77C9\u77CA\u77C4\u77F1\u791D\u791B"],
      ["f2a1", "\u7921\u791C\u7917\u791E\u79B0\u7A67\u7A68\u7C33\u7C3C\u7C39\u7C2C\u7C3B\u7CEC\u7CEA\u7E76\u7E75\u7E78\u7E70\u7E77\u7E6F\u7E7A\u7E72\u7E74\u7E68\u7F4B\u7F4A\u7F83\u7F86\u7FB7\u7FFD\u7FFE\u8078\u81D7\u81D5\u8264\u8261\u8263\u85EB\u85F1\u85ED\u85D9\u85E1\u85E8\u85DA\u85D7\u85EC\u85F2\u85F8\u85D8\u85DF\u85E3\u85DC\u85D1\u85F0\u85E6\u85EF\u85DE\u85E2\u8800\u87FA\u8803\u87F6\u87F7\u8809\u880C\u880B\u8806\u87FC\u8808\u87FF\u880A\u8802\u8962\u895A\u895B\u8957\u8961\u895C\u8958\u895D\u8959\u8988\u89B7\u89B6\u89F6\u8B50\u8B48\u8B4A\u8B40\u8B53\u8B56\u8B54\u8B4B\u8B55"],
      ["f340", "\u8B51\u8B42\u8B52\u8B57\u8C43\u8C77\u8C76\u8C9A\u8D06\u8D07\u8D09\u8DAC\u8DAA\u8DAD\u8DAB\u8E6D\u8E78\u8E73\u8E6A\u8E6F\u8E7B\u8EC2\u8F52\u8F51\u8F4F\u8F50\u8F53\u8FB4\u9140\u913F\u91B0\u91AD\u93DE\u93C7\u93CF\u93C2\u93DA\u93D0\u93F9\u93EC\u93CC\u93D9\u93A9\u93E6\u93CA\u93D4\u93EE\u93E3\u93D5\u93C4\u93CE\u93C0\u93D2\u93E7\u957D\u95DA\u95DB\u96E1\u9729\u972B\u972C\u9728\u9726"],
      ["f3a1", "\u97B3\u97B7\u97B6\u97DD\u97DE\u97DF\u985C\u9859\u985D\u9857\u98BF\u98BD\u98BB\u98BE\u9948\u9947\u9943\u99A6\u99A7\u9A1A\u9A15\u9A25\u9A1D\u9A24\u9A1B\u9A22\u9A20\u9A27\u9A23\u9A1E\u9A1C\u9A14\u9AC2\u9B0B\u9B0A\u9B0E\u9B0C\u9B37\u9BEA\u9BEB\u9BE0\u9BDE\u9BE4\u9BE6\u9BE2\u9BF0\u9BD4\u9BD7\u9BEC\u9BDC\u9BD9\u9BE5\u9BD5\u9BE1\u9BDA\u9D77\u9D81\u9D8A\u9D84\u9D88\u9D71\u9D80\u9D78\u9D86\u9D8B\u9D8C\u9D7D\u9D6B\u9D74\u9D75\u9D70\u9D69\u9D85\u9D73\u9D7B\u9D82\u9D6F\u9D79\u9D7F\u9D87\u9D68\u9E94\u9E91\u9EC0\u9EFC\u9F2D\u9F40\u9F41\u9F4D\u9F56\u9F57\u9F58\u5337\u56B2"],
      ["f440", "\u56B5\u56B3\u58E3\u5B45\u5DC6\u5DC7\u5EEE\u5EEF\u5FC0\u5FC1\u61F9\u6517\u6516\u6515\u6513\u65DF\u66E8\u66E3\u66E4\u6AF3\u6AF0\u6AEA\u6AE8\u6AF9\u6AF1\u6AEE\u6AEF\u703C\u7035\u702F\u7037\u7034\u7031\u7042\u7038\u703F\u703A\u7039\u7040\u703B\u7033\u7041\u7213\u7214\u72A8\u737D\u737C\u74BA\u76AB\u76AA\u76BE\u76ED\u77CC\u77CE\u77CF\u77CD\u77F2\u7925\u7923\u7927\u7928\u7924\u7929"],
      ["f4a1", "\u79B2\u7A6E\u7A6C\u7A6D\u7AF7\u7C49\u7C48\u7C4A\u7C47\u7C45\u7CEE\u7E7B\u7E7E\u7E81\u7E80\u7FBA\u7FFF\u8079\u81DB\u81D9\u820B\u8268\u8269\u8622\u85FF\u8601\u85FE\u861B\u8600\u85F6\u8604\u8609\u8605\u860C\u85FD\u8819\u8810\u8811\u8817\u8813\u8816\u8963\u8966\u89B9\u89F7\u8B60\u8B6A\u8B5D\u8B68\u8B63\u8B65\u8B67\u8B6D\u8DAE\u8E86\u8E88\u8E84\u8F59\u8F56\u8F57\u8F55\u8F58\u8F5A\u908D\u9143\u9141\u91B7\u91B5\u91B2\u91B3\u940B\u9413\u93FB\u9420\u940F\u9414\u93FE\u9415\u9410\u9428\u9419\u940D\u93F5\u9400\u93F7\u9407\u940E\u9416\u9412\u93FA\u9409\u93F8\u940A\u93FF"],
      ["f540", "\u93FC\u940C\u93F6\u9411\u9406\u95DE\u95E0\u95DF\u972E\u972F\u97B9\u97BB\u97FD\u97FE\u9860\u9862\u9863\u985F\u98C1\u98C2\u9950\u994E\u9959\u994C\u994B\u9953\u9A32\u9A34\u9A31\u9A2C\u9A2A\u9A36\u9A29\u9A2E\u9A38\u9A2D\u9AC7\u9ACA\u9AC6\u9B10\u9B12\u9B11\u9C0B\u9C08\u9BF7\u9C05\u9C12\u9BF8\u9C40\u9C07\u9C0E\u9C06\u9C17\u9C14\u9C09\u9D9F\u9D99\u9DA4\u9D9D\u9D92\u9D98\u9D90\u9D9B"],
      ["f5a1", "\u9DA0\u9D94\u9D9C\u9DAA\u9D97\u9DA1\u9D9A\u9DA2\u9DA8\u9D9E\u9DA3\u9DBF\u9DA9\u9D96\u9DA6\u9DA7\u9E99\u9E9B\u9E9A\u9EE5\u9EE4\u9EE7\u9EE6\u9F30\u9F2E\u9F5B\u9F60\u9F5E\u9F5D\u9F59\u9F91\u513A\u5139\u5298\u5297\u56C3\u56BD\u56BE\u5B48\u5B47\u5DCB\u5DCF\u5EF1\u61FD\u651B\u6B02\u6AFC\u6B03\u6AF8\u6B00\u7043\u7044\u704A\u7048\u7049\u7045\u7046\u721D\u721A\u7219\u737E\u7517\u766A\u77D0\u792D\u7931\u792F\u7C54\u7C53\u7CF2\u7E8A\u7E87\u7E88\u7E8B\u7E86\u7E8D\u7F4D\u7FBB\u8030\u81DD\u8618\u862A\u8626\u861F\u8623\u861C\u8619\u8627\u862E\u8621\u8620\u8629\u861E\u8625"],
      ["f640", "\u8829\u881D\u881B\u8820\u8824\u881C\u882B\u884A\u896D\u8969\u896E\u896B\u89FA\u8B79\u8B78\u8B45\u8B7A\u8B7B\u8D10\u8D14\u8DAF\u8E8E\u8E8C\u8F5E\u8F5B\u8F5D\u9146\u9144\u9145\u91B9\u943F\u943B\u9436\u9429\u943D\u943C\u9430\u9439\u942A\u9437\u942C\u9440\u9431\u95E5\u95E4\u95E3\u9735\u973A\u97BF\u97E1\u9864\u98C9\u98C6\u98C0\u9958\u9956\u9A39\u9A3D\u9A46\u9A44\u9A42\u9A41\u9A3A"],
      ["f6a1", "\u9A3F\u9ACD\u9B15\u9B17\u9B18\u9B16\u9B3A\u9B52\u9C2B\u9C1D\u9C1C\u9C2C\u9C23\u9C28\u9C29\u9C24\u9C21\u9DB7\u9DB6\u9DBC\u9DC1\u9DC7\u9DCA\u9DCF\u9DBE\u9DC5\u9DC3\u9DBB\u9DB5\u9DCE\u9DB9\u9DBA\u9DAC\u9DC8\u9DB1\u9DAD\u9DCC\u9DB3\u9DCD\u9DB2\u9E7A\u9E9C\u9EEB\u9EEE\u9EED\u9F1B\u9F18\u9F1A\u9F31\u9F4E\u9F65\u9F64\u9F92\u4EB9\u56C6\u56C5\u56CB\u5971\u5B4B\u5B4C\u5DD5\u5DD1\u5EF2\u6521\u6520\u6526\u6522\u6B0B\u6B08\u6B09\u6C0D\u7055\u7056\u7057\u7052\u721E\u721F\u72A9\u737F\u74D8\u74D5\u74D9\u74D7\u766D\u76AD\u7935\u79B4\u7A70\u7A71\u7C57\u7C5C\u7C59\u7C5B\u7C5A"],
      ["f740", "\u7CF4\u7CF1\u7E91\u7F4F\u7F87\u81DE\u826B\u8634\u8635\u8633\u862C\u8632\u8636\u882C\u8828\u8826\u882A\u8825\u8971\u89BF\u89BE\u89FB\u8B7E\u8B84\u8B82\u8B86\u8B85\u8B7F\u8D15\u8E95\u8E94\u8E9A\u8E92\u8E90\u8E96\u8E97\u8F60\u8F62\u9147\u944C\u9450\u944A\u944B\u944F\u9447\u9445\u9448\u9449\u9446\u973F\u97E3\u986A\u9869\u98CB\u9954\u995B\u9A4E\u9A53\u9A54\u9A4C\u9A4F\u9A48\u9A4A"],
      ["f7a1", "\u9A49\u9A52\u9A50\u9AD0\u9B19\u9B2B\u9B3B\u9B56\u9B55\u9C46\u9C48\u9C3F\u9C44\u9C39\u9C33\u9C41\u9C3C\u9C37\u9C34\u9C32\u9C3D\u9C36\u9DDB\u9DD2\u9DDE\u9DDA\u9DCB\u9DD0\u9DDC\u9DD1\u9DDF\u9DE9\u9DD9\u9DD8\u9DD6\u9DF5\u9DD5\u9DDD\u9EB6\u9EF0\u9F35\u9F33\u9F32\u9F42\u9F6B\u9F95\u9FA2\u513D\u5299\u58E8\u58E7\u5972\u5B4D\u5DD8\u882F\u5F4F\u6201\u6203\u6204\u6529\u6525\u6596\u66EB\u6B11\u6B12\u6B0F\u6BCA\u705B\u705A\u7222\u7382\u7381\u7383\u7670\u77D4\u7C67\u7C66\u7E95\u826C\u863A\u8640\u8639\u863C\u8631\u863B\u863E\u8830\u8832\u882E\u8833\u8976\u8974\u8973\u89FE"],
      ["f840", "\u8B8C\u8B8E\u8B8B\u8B88\u8C45\u8D19\u8E98\u8F64\u8F63\u91BC\u9462\u9455\u945D\u9457\u945E\u97C4\u97C5\u9800\u9A56\u9A59\u9B1E\u9B1F\u9B20\u9C52\u9C58\u9C50\u9C4A\u9C4D\u9C4B\u9C55\u9C59\u9C4C\u9C4E\u9DFB\u9DF7\u9DEF\u9DE3\u9DEB\u9DF8\u9DE4\u9DF6\u9DE1\u9DEE\u9DE6\u9DF2\u9DF0\u9DE2\u9DEC\u9DF4\u9DF3\u9DE8\u9DED\u9EC2\u9ED0\u9EF2\u9EF3\u9F06\u9F1C\u9F38\u9F37\u9F36\u9F43\u9F4F"],
      ["f8a1", "\u9F71\u9F70\u9F6E\u9F6F\u56D3\u56CD\u5B4E\u5C6D\u652D\u66ED\u66EE\u6B13\u705F\u7061\u705D\u7060\u7223\u74DB\u74E5\u77D5\u7938\u79B7\u79B6\u7C6A\u7E97\u7F89\u826D\u8643\u8838\u8837\u8835\u884B\u8B94\u8B95\u8E9E\u8E9F\u8EA0\u8E9D\u91BE\u91BD\u91C2\u946B\u9468\u9469\u96E5\u9746\u9743\u9747\u97C7\u97E5\u9A5E\u9AD5\u9B59\u9C63\u9C67\u9C66\u9C62\u9C5E\u9C60\u9E02\u9DFE\u9E07\u9E03\u9E06\u9E05\u9E00\u9E01\u9E09\u9DFF\u9DFD\u9E04\u9EA0\u9F1E\u9F46\u9F74\u9F75\u9F76\u56D4\u652E\u65B8\u6B18\u6B19\u6B17\u6B1A\u7062\u7226\u72AA\u77D8\u77D9\u7939\u7C69\u7C6B\u7CF6\u7E9A"],
      ["f940", "\u7E98\u7E9B\u7E99\u81E0\u81E1\u8646\u8647\u8648\u8979\u897A\u897C\u897B\u89FF\u8B98\u8B99\u8EA5\u8EA4\u8EA3\u946E\u946D\u946F\u9471\u9473\u9749\u9872\u995F\u9C68\u9C6E\u9C6D\u9E0B\u9E0D\u9E10\u9E0F\u9E12\u9E11\u9EA1\u9EF5\u9F09\u9F47\u9F78\u9F7B\u9F7A\u9F79\u571E\u7066\u7C6F\u883C\u8DB2\u8EA6\u91C3\u9474\u9478\u9476\u9475\u9A60\u9C74\u9C73\u9C71\u9C75\u9E14\u9E13\u9EF6\u9F0A"],
      ["f9a1", "\u9FA4\u7068\u7065\u7CF7\u866A\u883E\u883D\u883F\u8B9E\u8C9C\u8EA9\u8EC9\u974B\u9873\u9874\u98CC\u9961\u99AB\u9A64\u9A66\u9A67\u9B24\u9E15\u9E17\u9F48\u6207\u6B1E\u7227\u864C\u8EA8\u9482\u9480\u9481\u9A69\u9A68\u9B2E\u9E19\u7229\u864B\u8B9F\u9483\u9C79\u9EB7\u7675\u9A6B\u9C7A\u9E1D\u7069\u706A\u9EA4\u9F7E\u9F49\u9F98\u7881\u92B9\u88CF\u58BB\u6052\u7CA7\u5AFA\u2554\u2566\u2557\u2560\u256C\u2563\u255A\u2569\u255D\u2552\u2564\u2555\u255E\u256A\u2561\u2558\u2567\u255B\u2553\u2565\u2556\u255F\u256B\u2562\u2559\u2568\u255C\u2551\u2550\u256D\u256E\u2570\u256F\u2593"]
    ];
  }
});

// node_modules/iconv-lite/encodings/tables/big5-added.json
var require_big5_added = __commonJS({
  "node_modules/iconv-lite/encodings/tables/big5-added.json"(exports2, module2) {
    module2.exports = [
      ["8740", "\u43F0\u4C32\u4603\u45A6\u4578\u{27267}\u4D77\u45B3\u{27CB1}\u4CE2\u{27CC5}\u3B95\u4736\u4744\u4C47\u4C40\u{242BF}\u{23617}\u{27352}\u{26E8B}\u{270D2}\u4C57\u{2A351}\u474F\u45DA\u4C85\u{27C6C}\u4D07\u4AA4\u46A1\u{26B23}\u7225\u{25A54}\u{21A63}\u{23E06}\u{23F61}\u664D\u56FB"],
      ["8767", "\u7D95\u591D\u{28BB9}\u3DF4\u9734\u{27BEF}\u5BDB\u{21D5E}\u5AA4\u3625\u{29EB0}\u5AD1\u5BB7\u5CFC\u676E\u8593\u{29945}\u7461\u749D\u3875\u{21D53}\u{2369E}\u{26021}\u3EEC"],
      ["87a1", "\u{258DE}\u3AF5\u7AFC\u9F97\u{24161}\u{2890D}\u{231EA}\u{20A8A}\u{2325E}\u430A\u8484\u9F96\u942F\u4930\u8613\u5896\u974A\u9218\u79D0\u7A32\u6660\u6A29\u889D\u744C\u7BC5\u6782\u7A2C\u524F\u9046\u34E6\u73C4\u{25DB9}\u74C6\u9FC7\u57B3\u492F\u544C\u4131\u{2368E}\u5818\u7A72\u{27B65}\u8B8F\u46AE\u{26E88}\u4181\u{25D99}\u7BAE\u{224BC}\u9FC8\u{224C1}\u{224C9}\u{224CC}\u9FC9\u8504\u{235BB}\u40B4\u9FCA\u44E1\u{2ADFF}\u62C1\u706E\u9FCB"],
      ["8840", "\u31C0", 4, "\u{2010C}\u31C5\u{200D1}\u{200CD}\u31C6\u31C7\u{200CB}\u{21FE8}\u31C8\u{200CA}\u31C9\u31CA\u31CB\u31CC\u{2010E}\u31CD\u31CE\u0100\xC1\u01CD\xC0\u0112\xC9\u011A\xC8\u014C\xD3\u01D1\xD2\u0FFF\xCA\u0304\u1EBE\u0FFF\xCA\u030C\u1EC0\xCA\u0101\xE1\u01CE\xE0\u0251\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA"],
      ["88a1", "\u01DC\xFC\u0FFF\xEA\u0304\u1EBF\u0FFF\xEA\u030C\u1EC1\xEA\u0261\u23DA\u23DB"],
      ["8940", "\u{2A3A9}\u{21145}"],
      ["8943", "\u650A"],
      ["8946", "\u4E3D\u6EDD\u9D4E\u91DF"],
      ["894c", "\u{27735}\u6491\u4F1A\u4F28\u4FA8\u5156\u5174\u519C\u51E4\u52A1\u52A8\u533B\u534E\u53D1\u53D8\u56E2\u58F0\u5904\u5907\u5932\u5934\u5B66\u5B9E\u5B9F\u5C9A\u5E86\u603B\u6589\u67FE\u6804\u6865\u6D4E\u70BC\u7535\u7EA4\u7EAC\u7EBA\u7EC7\u7ECF\u7EDF\u7F06\u7F37\u827A\u82CF\u836F\u89C6\u8BBE\u8BE2\u8F66\u8F67\u8F6E"],
      ["89a1", "\u7411\u7CFC\u7DCD\u6946\u7AC9\u5227"],
      ["89ab", "\u918C\u78B8\u915E\u80BC"],
      ["89b0", "\u8D0B\u80F6\u{209E7}"],
      ["89b5", "\u809F\u9EC7\u4CCD\u9DC9\u9E0C\u4C3E\u{29DF6}\u{2700E}\u9E0A\u{2A133}\u35C1"],
      ["89c1", "\u6E9A\u823E\u7519"],
      ["89c5", "\u4911\u9A6C\u9A8F\u9F99\u7987\u{2846C}\u{21DCA}\u{205D0}\u{22AE6}\u4E24\u4E81\u4E80\u4E87\u4EBF\u4EEB\u4F37\u344C\u4FBD\u3E48\u5003\u5088\u347D\u3493\u34A5\u5186\u5905\u51DB\u51FC\u5205\u4E89\u5279\u5290\u5327\u35C7\u53A9\u3551\u53B0\u3553\u53C2\u5423\u356D\u3572\u3681\u5493\u54A3\u54B4\u54B9\u54D0\u54EF\u5518\u5523\u5528\u3598\u553F\u35A5\u35BF\u55D7\u35C5"],
      ["8a40", "\u{27D84}\u5525"],
      ["8a43", "\u{20C42}\u{20D15}\u{2512B}\u5590\u{22CC6}\u39EC\u{20341}\u8E46\u{24DB8}\u{294E5}\u4053\u{280BE}\u777A\u{22C38}\u3A34\u47D5\u{2815D}\u{269F2}\u{24DEA}\u64DD\u{20D7C}\u{20FB4}\u{20CD5}\u{210F4}\u648D\u8E7E\u{20E96}\u{20C0B}\u{20F64}\u{22CA9}\u{28256}\u{244D3}"],
      ["8a64", "\u{20D46}\u{29A4D}\u{280E9}\u47F4\u{24EA7}\u{22CC2}\u9AB2\u3A67\u{295F4}\u3FED\u3506\u{252C7}\u{297D4}\u{278C8}\u{22D44}\u9D6E\u9815"],
      ["8a76", "\u43D9\u{260A5}\u64B4\u54E3\u{22D4C}\u{22BCA}\u{21077}\u39FB\u{2106F}"],
      ["8aa1", "\u{266DA}\u{26716}\u{279A0}\u64EA\u{25052}\u{20C43}\u8E68\u{221A1}\u{28B4C}\u{20731}"],
      ["8aac", "\u480B\u{201A9}\u3FFA\u5873\u{22D8D}"],
      ["8ab2", "\u{245C8}\u{204FC}\u{26097}\u{20F4C}\u{20D96}\u5579\u40BB\u43BA"],
      ["8abb", "\u4AB4\u{22A66}\u{2109D}\u81AA\u98F5\u{20D9C}\u6379\u39FE\u{22775}\u8DC0\u56A1\u647C\u3E43"],
      ["8ac9", "\u{2A601}\u{20E09}\u{22ACF}\u{22CC9}"],
      ["8ace", "\u{210C8}\u{239C2}\u3992\u3A06\u{2829B}\u3578\u{25E49}\u{220C7}\u5652\u{20F31}\u{22CB2}\u{29720}\u34BC\u6C3D\u{24E3B}"],
      ["8adf", "\u{27574}\u{22E8B}\u{22208}\u{2A65B}\u{28CCD}\u{20E7A}\u{20C34}\u{2681C}\u7F93\u{210CF}\u{22803}\u{22939}\u35FB\u{251E3}\u{20E8C}\u{20F8D}\u{20EAA}\u3F93\u{20F30}\u{20D47}\u{2114F}\u{20E4C}"],
      ["8af6", "\u{20EAB}\u{20BA9}\u{20D48}\u{210C0}\u{2113D}\u3FF9\u{22696}\u6432\u{20FAD}"],
      ["8b40", "\u{233F4}\u{27639}\u{22BCE}\u{20D7E}\u{20D7F}\u{22C51}\u{22C55}\u3A18\u{20E98}\u{210C7}\u{20F2E}\u{2A632}\u{26B50}\u{28CD2}\u{28D99}\u{28CCA}\u95AA\u54CC\u82C4\u55B9"],
      ["8b55", "\u{29EC3}\u9C26\u9AB6\u{2775E}\u{22DEE}\u7140\u816D\u80EC\u5C1C\u{26572}\u8134\u3797\u535F\u{280BD}\u91B6\u{20EFA}\u{20E0F}\u{20E77}\u{20EFB}\u35DD\u{24DEB}\u3609\u{20CD6}\u56AF\u{227B5}\u{210C9}\u{20E10}\u{20E78}\u{21078}\u{21148}\u{28207}\u{21455}\u{20E79}\u{24E50}\u{22DA4}\u5A54\u{2101D}\u{2101E}\u{210F5}\u{210F6}\u579C\u{20E11}"],
      ["8ba1", "\u{27694}\u{282CD}\u{20FB5}\u{20E7B}\u{2517E}\u3703\u{20FB6}\u{21180}\u{252D8}\u{2A2BD}\u{249DA}\u{2183A}\u{24177}\u{2827C}\u5899\u5268\u361A\u{2573D}\u7BB2\u5B68\u4800\u4B2C\u9F27\u49E7\u9C1F\u9B8D\u{25B74}\u{2313D}\u55FB\u35F2\u5689\u4E28\u5902\u{21BC1}\u{2F878}\u9751\u{20086}\u4E5B\u4EBB\u353E\u5C23\u5F51\u5FC4\u38FA\u624C\u6535\u6B7A\u6C35\u6C3A\u706C\u722B\u4E2C\u72AD\u{248E9}\u7F52\u793B\u7CF9\u7F53\u{2626A}\u34C1"],
      ["8bde", "\u{2634B}\u8002\u8080\u{26612}\u{26951}\u535D\u8864\u89C1\u{278B2}\u8BA0\u8D1D\u9485\u9578\u957F\u95E8\u{28E0F}\u97E6\u9875\u98CE\u98DE\u9963\u{29810}\u9C7C\u9E1F\u9EC4\u6B6F\uF907\u4E37\u{20087}\u961D\u6237\u94A2"],
      ["8c40", "\u503B\u6DFE\u{29C73}\u9FA6\u3DC9\u888F\u{2414E}\u7077\u5CF5\u4B20\u{251CD}\u3559\u{25D30}\u6122\u{28A32}\u8FA7\u91F6\u7191\u6719\u73BA\u{23281}\u{2A107}\u3C8B\u{21980}\u4B10\u78E4\u7402\u51AE\u{2870F}\u4009\u6A63\u{2A2BA}\u4223\u860F\u{20A6F}\u7A2A\u{29947}\u{28AEA}\u9755\u704D\u5324\u{2207E}\u93F4\u76D9\u{289E3}\u9FA7\u77DD\u4EA3\u4FF0\u50BC\u4E2F\u4F17\u9FA8\u5434\u7D8B\u5892\u58D0\u{21DB6}\u5E92\u5E99\u5FC2\u{22712}\u658B"],
      ["8ca1", "\u{233F9}\u6919\u6A43\u{23C63}\u6CFF"],
      ["8ca7", "\u7200\u{24505}\u738C\u3EDB\u{24A13}\u5B15\u74B9\u8B83\u{25CA4}\u{25695}\u7A93\u7BEC\u7CC3\u7E6C\u82F8\u8597\u9FA9\u8890\u9FAA\u8EB9\u9FAB\u8FCF\u855F\u99E0\u9221\u9FAC\u{28DB9}\u{2143F}\u4071\u42A2\u5A1A"],
      ["8cc9", "\u9868\u676B\u4276\u573D"],
      ["8cce", "\u85D6\u{2497B}\u82BF\u{2710D}\u4C81\u{26D74}\u5D7B\u{26B15}\u{26FBE}\u9FAD\u9FAE\u5B96\u9FAF\u66E7\u7E5B\u6E57\u79CA\u3D88\u44C3\u{23256}\u{22796}\u439A\u4536"],
      ["8ce6", "\u5CD5\u{23B1A}\u8AF9\u5C78\u3D12\u{23551}\u5D78\u9FB2\u7157\u4558\u{240EC}\u{21E23}\u4C77\u3978\u344A\u{201A4}\u{26C41}\u8ACC\u4FB4\u{20239}\u59BF\u816C\u9856\u{298FA}\u5F3B"],
      ["8d40", "\u{20B9F}"],
      ["8d42", "\u{221C1}\u{2896D}\u4102\u46BB\u{29079}\u3F07\u9FB3\u{2A1B5}\u40F8\u37D6\u46F7\u{26C46}\u417C\u{286B2}\u{273FF}\u456D\u38D4\u{2549A}\u4561\u451B\u4D89\u4C7B\u4D76\u45EA\u3FC8\u{24B0F}\u3661\u44DE\u44BD\u41ED\u5D3E\u5D48\u5D56\u3DFC\u380F\u5DA4\u5DB9\u3820\u3838\u5E42\u5EBD\u5F25\u5F83\u3908\u3914\u393F\u394D\u60D7\u613D\u5CE5\u3989\u61B7\u61B9\u61CF\u39B8\u622C\u6290\u62E5\u6318\u39F8\u56B1"],
      ["8da1", "\u3A03\u63E2\u63FB\u6407\u645A\u3A4B\u64C0\u5D15\u5621\u9F9F\u3A97\u6586\u3ABD\u65FF\u6653\u3AF2\u6692\u3B22\u6716\u3B42\u67A4\u6800\u3B58\u684A\u6884\u3B72\u3B71\u3B7B\u6909\u6943\u725C\u6964\u699F\u6985\u3BBC\u69D6\u3BDD\u6A65\u6A74\u6A71\u6A82\u3BEC\u6A99\u3BF2\u6AAB\u6AB5\u6AD4\u6AF6\u6B81\u6BC1\u6BEA\u6C75\u6CAA\u3CCB\u6D02\u6D06\u6D26\u6D81\u3CEF\u6DA4\u6DB1\u6E15\u6E18\u6E29\u6E86\u{289C0}\u6EBB\u6EE2\u6EDA\u9F7F\u6EE8\u6EE9\u6F24\u6F34\u3D46\u{23F41}\u6F81\u6FBE\u3D6A\u3D75\u71B7\u5C99\u3D8A\u702C\u3D91\u7050\u7054\u706F\u707F\u7089\u{20325}\u43C1\u35F1\u{20ED8}"],
      ["8e40", "\u{23ED7}\u57BE\u{26ED3}\u713E\u{257E0}\u364E\u69A2\u{28BE9}\u5B74\u7A49\u{258E1}\u{294D9}\u7A65\u7A7D\u{259AC}\u7ABB\u7AB0\u7AC2\u7AC3\u71D1\u{2648D}\u41CA\u7ADA\u7ADD\u7AEA\u41EF\u54B2\u{25C01}\u7B0B\u7B55\u7B29\u{2530E}\u{25CFE}\u7BA2\u7B6F\u839C\u{25BB4}\u{26C7F}\u7BD0\u8421\u7B92\u7BB8\u{25D20}\u3DAD\u{25C65}\u8492\u7BFA\u7C06\u7C35\u{25CC1}\u7C44\u7C83\u{24882}\u7CA6\u667D\u{24578}\u7CC9\u7CC7\u7CE6\u7C74\u7CF3\u7CF5\u7CCE"],
      ["8ea1", "\u7E67\u451D\u{26E44}\u7D5D\u{26ED6}\u748D\u7D89\u7DAB\u7135\u7DB3\u7DD2\u{24057}\u{26029}\u7DE4\u3D13\u7DF5\u{217F9}\u7DE5\u{2836D}\u7E1D\u{26121}\u{2615A}\u7E6E\u7E92\u432B\u946C\u7E27\u7F40\u7F41\u7F47\u7936\u{262D0}\u99E1\u7F97\u{26351}\u7FA3\u{21661}\u{20068}\u455C\u{23766}\u4503\u{2833A}\u7FFA\u{26489}\u8005\u8008\u801D\u8028\u802F\u{2A087}\u{26CC3}\u803B\u803C\u8061\u{22714}\u4989\u{26626}\u{23DE3}\u{266E8}\u6725\u80A7\u{28A48}\u8107\u811A\u58B0\u{226F6}\u6C7F\u{26498}\u{24FB8}\u64E7\u{2148A}\u8218\u{2185E}\u6A53\u{24A65}\u{24A95}\u447A\u8229\u{20B0D}\u{26A52}\u{23D7E}\u4FF9\u{214FD}\u84E2\u8362\u{26B0A}\u{249A7}\u{23530}\u{21773}\u{23DF8}\u82AA\u691B\u{2F994}\u41DB"],
      ["8f40", "\u854B\u82D0\u831A\u{20E16}\u{217B4}\u36C1\u{2317D}\u{2355A}\u827B\u82E2\u8318\u{23E8B}\u{26DA3}\u{26B05}\u{26B97}\u{235CE}\u3DBF\u831D\u55EC\u8385\u450B\u{26DA5}\u83AC\u83C1\u83D3\u347E\u{26ED4}\u6A57\u855A\u3496\u{26E42}\u{22EEF}\u8458\u{25BE4}\u8471\u3DD3\u44E4\u6AA7\u844A\u{23CB5}\u7958\u84A8\u{26B96}\u{26E77}\u{26E43}\u84DE\u840F\u8391\u44A0\u8493\u84E4\u{25C91}\u4240\u{25CC0}\u4543\u8534\u5AF2\u{26E99}\u4527\u8573\u4516\u67BF\u8616"],
      ["8fa1", "\u{28625}\u{2863B}\u85C1\u{27088}\u8602\u{21582}\u{270CD}\u{2F9B2}\u456A\u8628\u3648\u{218A2}\u53F7\u{2739A}\u867E\u8771\u{2A0F8}\u87EE\u{22C27}\u87B1\u87DA\u880F\u5661\u866C\u6856\u460F\u8845\u8846\u{275E0}\u{23DB9}\u{275E4}\u885E\u889C\u465B\u88B4\u88B5\u63C1\u88C5\u7777\u{2770F}\u8987\u898A\u89A6\u89A9\u89A7\u89BC\u{28A25}\u89E7\u{27924}\u{27ABD}\u8A9C\u7793\u91FE\u8A90\u{27A59}\u7AE9\u{27B3A}\u{23F8F}\u4713\u{27B38}\u717C\u8B0C\u8B1F\u{25430}\u{25565}\u8B3F\u8B4C\u8B4D\u8AA9\u{24A7A}\u8B90\u8B9B\u8AAF\u{216DF}\u4615\u884F\u8C9B\u{27D54}\u{27D8F}\u{2F9D4}\u3725\u{27D53}\u8CD6\u{27D98}\u{27DBD}\u8D12\u8D03\u{21910}\u8CDB\u705C\u8D11\u{24CC9}\u3ED0\u8D77"],
      ["9040", "\u8DA9\u{28002}\u{21014}\u{2498A}\u3B7C\u{281BC}\u{2710C}\u7AE7\u8EAD\u8EB6\u8EC3\u92D4\u8F19\u8F2D\u{28365}\u{28412}\u8FA5\u9303\u{2A29F}\u{20A50}\u8FB3\u492A\u{289DE}\u{2853D}\u{23DBB}\u5EF8\u{23262}\u8FF9\u{2A014}\u{286BC}\u{28501}\u{22325}\u3980\u{26ED7}\u9037\u{2853C}\u{27ABE}\u9061\u{2856C}\u{2860B}\u90A8\u{28713}\u90C4\u{286E6}\u90AE\u90FD\u9167\u3AF0\u91A9\u91C4\u7CAC\u{28933}\u{21E89}\u920E\u6C9F\u9241\u9262\u{255B9}\u92B9\u{28AC6}\u{23C9B}\u{28B0C}\u{255DB}"],
      ["90a1", "\u{20D31}\u932C\u936B\u{28AE1}\u{28BEB}\u708F\u5AC3\u{28AE2}\u{28AE5}\u4965\u9244\u{28BEC}\u{28C39}\u{28BFF}\u9373\u945B\u8EBC\u9585\u95A6\u9426\u95A0\u6FF6\u42B9\u{2267A}\u{286D8}\u{2127C}\u{23E2E}\u49DF\u6C1C\u967B\u9696\u416C\u96A3\u{26ED5}\u61DA\u96B6\u78F5\u{28AE0}\u96BD\u53CC\u49A1\u{26CB8}\u{20274}\u{26410}\u{290AF}\u{290E5}\u{24AD1}\u{21915}\u{2330A}\u9731\u8642\u9736\u4A0F\u453D\u4585\u{24AE9}\u7075\u5B41\u971B\u975C\u{291D5}\u9757\u5B4A\u{291EB}\u975F\u9425\u50D0\u{230B7}\u{230BC}\u9789\u979F\u97B1\u97BE\u97C0\u97D2\u97E0\u{2546C}\u97EE\u741C\u{29433}\u97FF\u97F5\u{2941D}\u{2797A}\u4AD1\u9834\u9833\u984B\u9866\u3B0E\u{27175}\u3D51\u{20630}\u{2415C}"],
      ["9140", "\u{25706}\u98CA\u98B7\u98C8\u98C7\u4AFF\u{26D27}\u{216D3}\u55B0\u98E1\u98E6\u98EC\u9378\u9939\u{24A29}\u4B72\u{29857}\u{29905}\u99F5\u9A0C\u9A3B\u9A10\u9A58\u{25725}\u36C4\u{290B1}\u{29BD5}\u9AE0\u9AE2\u{29B05}\u9AF4\u4C0E\u9B14\u9B2D\u{28600}\u5034\u9B34\u{269A8}\u38C3\u{2307D}\u9B50\u9B40\u{29D3E}\u5A45\u{21863}\u9B8E\u{2424B}\u9C02\u9BFF\u9C0C\u{29E68}\u9DD4\u{29FB7}\u{2A192}\u{2A1AB}\u{2A0E1}\u{2A123}\u{2A1DF}\u9D7E\u9D83\u{2A134}\u9E0E\u6888"],
      ["91a1", "\u9DC4\u{2215B}\u{2A193}\u{2A220}\u{2193B}\u{2A233}\u9D39\u{2A0B9}\u{2A2B4}\u9E90\u9E95\u9E9E\u9EA2\u4D34\u9EAA\u9EAF\u{24364}\u9EC1\u3B60\u39E5\u3D1D\u4F32\u37BE\u{28C2B}\u9F02\u9F08\u4B96\u9424\u{26DA2}\u9F17\u9F16\u9F39\u569F\u568A\u9F45\u99B8\u{2908B}\u97F2\u847F\u9F62\u9F69\u7ADC\u9F8E\u7216\u4BBE\u{24975}\u{249BB}\u7177\u{249F8}\u{24348}\u{24A51}\u739E\u{28BDA}\u{218FA}\u799F\u{2897E}\u{28E36}\u9369\u93F3\u{28A44}\u92EC\u9381\u93CB\u{2896C}\u{244B9}\u7217\u3EEB\u7772\u7A43\u70D0\u{24473}\u{243F8}\u717E\u{217EF}\u70A3\u{218BE}\u{23599}\u3EC7\u{21885}\u{2542F}\u{217F8}\u3722\u{216FB}\u{21839}\u36E1\u{21774}\u{218D1}\u{25F4B}\u3723\u{216C0}\u575B\u{24A25}\u{213FE}\u{212A8}"],
      ["9240", "\u{213C6}\u{214B6}\u8503\u{236A6}\u8503\u8455\u{24994}\u{27165}\u{23E31}\u{2555C}\u{23EFB}\u{27052}\u44F4\u{236EE}\u{2999D}\u{26F26}\u67F9\u3733\u3C15\u3DE7\u586C\u{21922}\u6810\u4057\u{2373F}\u{240E1}\u{2408B}\u{2410F}\u{26C21}\u54CB\u569E\u{266B1}\u5692\u{20FDF}\u{20BA8}\u{20E0D}\u93C6\u{28B13}\u939C\u4EF8\u512B\u3819\u{24436}\u4EBC\u{20465}\u{2037F}\u4F4B\u4F8A\u{25651}\u5A68\u{201AB}\u{203CB}\u3999\u{2030A}\u{20414}\u3435\u4F29\u{202C0}\u{28EB3}\u{20275}\u8ADA\u{2020C}\u4E98"],
      ["92a1", "\u50CD\u510D\u4FA2\u4F03\u{24A0E}\u{23E8A}\u4F42\u502E\u506C\u5081\u4FCC\u4FE5\u5058\u50FC\u5159\u515B\u515D\u515E\u6E76\u{23595}\u{23E39}\u{23EBF}\u6D72\u{21884}\u{23E89}\u51A8\u51C3\u{205E0}\u44DD\u{204A3}\u{20492}\u{20491}\u8D7A\u{28A9C}\u{2070E}\u5259\u52A4\u{20873}\u52E1\u936E\u467A\u718C\u{2438C}\u{20C20}\u{249AC}\u{210E4}\u69D1\u{20E1D}\u7479\u3EDE\u7499\u7414\u7456\u7398\u4B8E\u{24ABC}\u{2408D}\u53D0\u3584\u720F\u{240C9}\u55B4\u{20345}\u54CD\u{20BC6}\u571D\u925D\u96F4\u9366\u57DD\u578D\u577F\u363E\u58CB\u5A99\u{28A46}\u{216FA}\u{2176F}\u{21710}\u5A2C\u59B8\u928F\u5A7E\u5ACF\u5A12\u{25946}\u{219F3}\u{21861}\u{24295}\u36F5\u6D05\u7443\u5A21\u{25E83}"],
      ["9340", "\u5A81\u{28BD7}\u{20413}\u93E0\u748C\u{21303}\u7105\u4972\u9408\u{289FB}\u93BD\u37A0\u5C1E\u5C9E\u5E5E\u5E48\u{21996}\u{2197C}\u{23AEE}\u5ECD\u5B4F\u{21903}\u{21904}\u3701\u{218A0}\u36DD\u{216FE}\u36D3\u812A\u{28A47}\u{21DBA}\u{23472}\u{289A8}\u5F0C\u5F0E\u{21927}\u{217AB}\u5A6B\u{2173B}\u5B44\u8614\u{275FD}\u8860\u607E\u{22860}\u{2262B}\u5FDB\u3EB8\u{225AF}\u{225BE}\u{29088}\u{26F73}\u61C0\u{2003E}\u{20046}\u{2261B}\u6199\u6198\u6075\u{22C9B}\u{22D07}\u{246D4}\u{2914D}"],
      ["93a1", "\u6471\u{24665}\u{22B6A}\u3A29\u{22B22}\u{23450}\u{298EA}\u{22E78}\u6337\u{2A45B}\u64B6\u6331\u63D1\u{249E3}\u{22D67}\u62A4\u{22CA1}\u643B\u656B\u6972\u3BF4\u{2308E}\u{232AD}\u{24989}\u{232AB}\u550D\u{232E0}\u{218D9}\u{2943F}\u66CE\u{23289}\u{231B3}\u3AE0\u4190\u{25584}\u{28B22}\u{2558F}\u{216FC}\u{2555B}\u{25425}\u78EE\u{23103}\u{2182A}\u{23234}\u3464\u{2320F}\u{23182}\u{242C9}\u668E\u{26D24}\u666B\u4B93\u6630\u{27870}\u{21DEB}\u6663\u{232D2}\u{232E1}\u661E\u{25872}\u38D1\u{2383A}\u{237BC}\u3B99\u{237A2}\u{233FE}\u74D0\u3B96\u678F\u{2462A}\u68B6\u681E\u3BC4\u6ABE\u3863\u{237D5}\u{24487}\u6A33\u6A52\u6AC9\u6B05\u{21912}\u6511\u6898\u6A4C\u3BD7\u6A7A\u6B57\u{23FC0}\u{23C9A}\u93A0\u92F2\u{28BEA}\u{28ACB}"],
      ["9440", "\u9289\u{2801E}\u{289DC}\u9467\u6DA5\u6F0B\u{249EC}\u6D67\u{23F7F}\u3D8F\u6E04\u{2403C}\u5A3D\u6E0A\u5847\u6D24\u7842\u713B\u{2431A}\u{24276}\u70F1\u7250\u7287\u7294\u{2478F}\u{24725}\u5179\u{24AA4}\u{205EB}\u747A\u{23EF8}\u{2365F}\u{24A4A}\u{24917}\u{25FE1}\u3F06\u3EB1\u{24ADF}\u{28C23}\u{23F35}\u60A7\u3EF3\u74CC\u743C\u9387\u7437\u449F\u{26DEA}\u4551\u7583\u3F63\u{24CD9}\u{24D06}\u3F58\u7555\u7673\u{2A5C6}\u3B19\u7468\u{28ACC}\u{249AB}\u{2498E}\u3AFB"],
      ["94a1", "\u3DCD\u{24A4E}\u3EFF\u{249C5}\u{248F3}\u91FA\u5732\u9342\u{28AE3}\u{21864}\u50DF\u{25221}\u{251E7}\u7778\u{23232}\u770E\u770F\u777B\u{24697}\u{23781}\u3A5E\u{248F0}\u7438\u749B\u3EBF\u{24ABA}\u{24AC7}\u40C8\u{24A96}\u{261AE}\u9307\u{25581}\u781E\u788D\u7888\u78D2\u73D0\u7959\u{27741}\u{256E3}\u410E\u799B\u8496\u79A5\u6A2D\u{23EFA}\u7A3A\u79F4\u416E\u{216E6}\u4132\u9235\u79F1\u{20D4C}\u{2498C}\u{20299}\u{23DBA}\u{2176E}\u3597\u556B\u3570\u36AA\u{201D4}\u{20C0D}\u7AE2\u5A59\u{226F5}\u{25AAF}\u{25A9C}\u5A0D\u{2025B}\u78F0\u5A2A\u{25BC6}\u7AFE\u41F9\u7C5D\u7C6D\u4211\u{25BB3}\u{25EBC}\u{25EA6}\u7CCD\u{249F9}\u{217B0}\u7C8E\u7C7C\u7CAE\u6AB2\u7DDC\u7E07\u7DD3\u7F4E\u{26261}"],
      ["9540", "\u{2615C}\u{27B48}\u7D97\u{25E82}\u426A\u{26B75}\u{20916}\u67D6\u{2004E}\u{235CF}\u57C4\u{26412}\u{263F8}\u{24962}\u7FDD\u7B27\u{2082C}\u{25AE9}\u{25D43}\u7B0C\u{25E0E}\u99E6\u8645\u9A63\u6A1C\u{2343F}\u39E2\u{249F7}\u{265AD}\u9A1F\u{265A0}\u8480\u{27127}\u{26CD1}\u44EA\u8137\u4402\u80C6\u8109\u8142\u{267B4}\u98C3\u{26A42}\u8262\u8265\u{26A51}\u8453\u{26DA7}\u8610\u{2721B}\u5A86\u417F\u{21840}\u5B2B\u{218A1}\u5AE4\u{218D8}\u86A0\u{2F9BC}\u{23D8F}\u882D\u{27422}\u5A02"],
      ["95a1", "\u886E\u4F45\u8887\u88BF\u88E6\u8965\u894D\u{25683}\u8954\u{27785}\u{27784}\u{28BF5}\u{28BD9}\u{28B9C}\u{289F9}\u3EAD\u84A3\u46F5\u46CF\u37F2\u8A3D\u8A1C\u{29448}\u5F4D\u922B\u{24284}\u65D4\u7129\u70C4\u{21845}\u9D6D\u8C9F\u8CE9\u{27DDC}\u599A\u77C3\u59F0\u436E\u36D4\u8E2A\u8EA7\u{24C09}\u8F30\u8F4A\u42F4\u6C58\u6FBB\u{22321}\u489B\u6F79\u6E8B\u{217DA}\u9BE9\u36B5\u{2492F}\u90BB\u9097\u5571\u4906\u91BB\u9404\u{28A4B}\u4062\u{28AFC}\u9427\u{28C1D}\u{28C3B}\u84E5\u8A2B\u9599\u95A7\u9597\u9596\u{28D34}\u7445\u3EC2\u{248FF}\u{24A42}\u{243EA}\u3EE7\u{23225}\u968F\u{28EE7}\u{28E66}\u{28E65}\u3ECC\u{249ED}\u{24A78}\u{23FEE}\u7412\u746B\u3EFC\u9741\u{290B0}"],
      ["9640", "\u6847\u4A1D\u{29093}\u{257DF}\u975D\u9368\u{28989}\u{28C26}\u{28B2F}\u{263BE}\u92BA\u5B11\u8B69\u493C\u73F9\u{2421B}\u979B\u9771\u9938\u{20F26}\u5DC1\u{28BC5}\u{24AB2}\u981F\u{294DA}\u92F6\u{295D7}\u91E5\u44C0\u{28B50}\u{24A67}\u{28B64}\u98DC\u{28A45}\u3F00\u922A\u4925\u8414\u993B\u994D\u{27B06}\u3DFD\u999B\u4B6F\u99AA\u9A5C\u{28B65}\u{258C8}\u6A8F\u9A21\u5AFE\u9A2F\u{298F1}\u4B90\u{29948}\u99BC\u4BBD\u4B97\u937D\u5872\u{21302}\u5822\u{249B8}"],
      ["96a1", "\u{214E8}\u7844\u{2271F}\u{23DB8}\u68C5\u3D7D\u9458\u3927\u6150\u{22781}\u{2296B}\u6107\u9C4F\u9C53\u9C7B\u9C35\u9C10\u9B7F\u9BCF\u{29E2D}\u9B9F\u{2A1F5}\u{2A0FE}\u9D21\u4CAE\u{24104}\u9E18\u4CB0\u9D0C\u{2A1B4}\u{2A0ED}\u{2A0F3}\u{2992F}\u9DA5\u84BD\u{26E12}\u{26FDF}\u{26B82}\u85FC\u4533\u{26DA4}\u{26E84}\u{26DF0}\u8420\u85EE\u{26E00}\u{237D7}\u{26064}\u79E2\u{2359C}\u{23640}\u492D\u{249DE}\u3D62\u93DB\u92BE\u9348\u{202BF}\u78B9\u9277\u944D\u4FE4\u3440\u9064\u{2555D}\u783D\u7854\u78B6\u784B\u{21757}\u{231C9}\u{24941}\u369A\u4F72\u6FDA\u6FD9\u701E\u701E\u5414\u{241B5}\u57BB\u58F3\u578A\u9D16\u57D7\u7134\u34AF\u{241AC}\u71EB\u{26C40}\u{24F97}\u5B28\u{217B5}\u{28A49}"],
      ["9740", "\u610C\u5ACE\u5A0B\u42BC\u{24488}\u372C\u4B7B\u{289FC}\u93BB\u93B8\u{218D6}\u{20F1D}\u8472\u{26CC0}\u{21413}\u{242FA}\u{22C26}\u{243C1}\u5994\u{23DB7}\u{26741}\u7DA8\u{2615B}\u{260A4}\u{249B9}\u{2498B}\u{289FA}\u92E5\u73E2\u3EE9\u74B4\u{28B63}\u{2189F}\u3EE1\u{24AB3}\u6AD8\u73F3\u73FB\u3ED6\u{24A3E}\u{24A94}\u{217D9}\u{24A66}\u{203A7}\u{21424}\u{249E5}\u7448\u{24916}\u70A5\u{24976}\u9284\u73E6\u935F\u{204FE}\u9331\u{28ACE}\u{28A16}\u9386\u{28BE7}\u{255D5}\u4935\u{28A82}\u716B"],
      ["97a1", "\u{24943}\u{20CFF}\u56A4\u{2061A}\u{20BEB}\u{20CB8}\u5502\u79C4\u{217FA}\u7DFE\u{216C2}\u{24A50}\u{21852}\u452E\u9401\u370A\u{28AC0}\u{249AD}\u59B0\u{218BF}\u{21883}\u{27484}\u5AA1\u36E2\u{23D5B}\u36B0\u925F\u5A79\u{28A81}\u{21862}\u9374\u3CCD\u{20AB4}\u4A96\u398A\u50F4\u3D69\u3D4C\u{2139C}\u7175\u42FB\u{28218}\u6E0F\u{290E4}\u44EB\u6D57\u{27E4F}\u7067\u6CAF\u3CD6\u{23FED}\u{23E2D}\u6E02\u6F0C\u3D6F\u{203F5}\u7551\u36BC\u34C8\u4680\u3EDA\u4871\u59C4\u926E\u493E\u8F41\u{28C1C}\u{26BC0}\u5812\u57C8\u36D6\u{21452}\u70FE\u{24362}\u{24A71}\u{22FE3}\u{212B0}\u{223BD}\u68B9\u6967\u{21398}\u{234E5}\u{27BF4}\u{236DF}\u{28A83}\u{237D6}\u{233FA}\u{24C9F}\u6A1A\u{236AD}\u{26CB7}\u843E\u44DF\u44CE"],
      ["9840", "\u{26D26}\u{26D51}\u{26C82}\u{26FDE}\u6F17\u{27109}\u833D\u{2173A}\u83ED\u{26C80}\u{27053}\u{217DB}\u5989\u5A82\u{217B3}\u5A61\u5A71\u{21905}\u{241FC}\u372D\u59EF\u{2173C}\u36C7\u718E\u9390\u669A\u{242A5}\u5A6E\u5A2B\u{24293}\u6A2B\u{23EF9}\u{27736}\u{2445B}\u{242CA}\u711D\u{24259}\u{289E1}\u4FB0\u{26D28}\u5CC2\u{244CE}\u{27E4D}\u{243BD}\u6A0C\u{24256}\u{21304}\u70A6\u7133\u{243E9}\u3DA5\u6CDF\u{2F825}\u{24A4F}\u7E65\u59EB\u5D2F\u3DF3\u5F5C\u{24A5D}\u{217DF}\u7DA4\u8426"],
      ["98a1", "\u5485\u{23AFA}\u{23300}\u{20214}\u577E\u{208D5}\u{20619}\u3FE5\u{21F9E}\u{2A2B6}\u7003\u{2915B}\u5D70\u738F\u7CD3\u{28A59}\u{29420}\u4FC8\u7FE7\u72CD\u7310\u{27AF4}\u7338\u7339\u{256F6}\u7341\u7348\u3EA9\u{27B18}\u906C\u71F5\u{248F2}\u73E1\u81F6\u3ECA\u770C\u3ED1\u6CA2\u56FD\u7419\u741E\u741F\u3EE2\u3EF0\u3EF4\u3EFA\u74D3\u3F0E\u3F53\u7542\u756D\u7572\u758D\u3F7C\u75C8\u75DC\u3FC0\u764D\u3FD7\u7674\u3FDC\u767A\u{24F5C}\u7188\u5623\u8980\u5869\u401D\u7743\u4039\u6761\u4045\u35DB\u7798\u406A\u406F\u5C5E\u77BE\u77CB\u58F2\u7818\u70B9\u781C\u40A8\u7839\u7847\u7851\u7866\u8448\u{25535}\u7933\u6803\u7932\u4103"],
      ["9940", "\u4109\u7991\u7999\u8FBB\u7A06\u8FBC\u4167\u7A91\u41B2\u7ABC\u8279\u41C4\u7ACF\u7ADB\u41CF\u4E21\u7B62\u7B6C\u7B7B\u7C12\u7C1B\u4260\u427A\u7C7B\u7C9C\u428C\u7CB8\u4294\u7CED\u8F93\u70C0\u{20CCF}\u7DCF\u7DD4\u7DD0\u7DFD\u7FAE\u7FB4\u729F\u4397\u8020\u8025\u7B39\u802E\u8031\u8054\u3DCC\u57B4\u70A0\u80B7\u80E9\u43ED\u810C\u732A\u810E\u8112\u7560\u8114\u4401\u3B39\u8156\u8159\u815A"],
      ["99a1", "\u4413\u583A\u817C\u8184\u4425\u8193\u442D\u81A5\u57EF\u81C1\u81E4\u8254\u448F\u82A6\u8276\u82CA\u82D8\u82FF\u44B0\u8357\u9669\u698A\u8405\u70F5\u8464\u60E3\u8488\u4504\u84BE\u84E1\u84F8\u8510\u8538\u8552\u453B\u856F\u8570\u85E0\u4577\u8672\u8692\u86B2\u86EF\u9645\u878B\u4606\u4617\u88AE\u88FF\u8924\u8947\u8991\u{27967}\u8A29\u8A38\u8A94\u8AB4\u8C51\u8CD4\u8CF2\u8D1C\u4798\u585F\u8DC3\u47ED\u4EEE\u8E3A\u55D8\u5754\u8E71\u55F5\u8EB0\u4837\u8ECE\u8EE2\u8EE4\u8EED\u8EF2\u8FB7\u8FC1\u8FCA\u8FCC\u9033\u99C4\u48AD\u98E0\u9213\u491E\u9228\u9258\u926B\u92B1\u92AE\u92BF"],
      ["9a40", "\u92E3\u92EB\u92F3\u92F4\u92FD\u9343\u9384\u93AD\u4945\u4951\u9EBF\u9417\u5301\u941D\u942D\u943E\u496A\u9454\u9479\u952D\u95A2\u49A7\u95F4\u9633\u49E5\u67A0\u4A24\u9740\u4A35\u97B2\u97C2\u5654\u4AE4\u60E8\u98B9\u4B19\u98F1\u5844\u990E\u9919\u51B4\u991C\u9937\u9942\u995D\u9962\u4B70\u99C5\u4B9D\u9A3C\u9B0F\u7A83\u9B69\u9B81\u9BDD\u9BF1\u9BF4\u4C6D\u9C20\u376F\u{21BC2}\u9D49\u9C3A"],
      ["9aa1", "\u9EFE\u5650\u9D93\u9DBD\u9DC0\u9DFC\u94F6\u8FB6\u9E7B\u9EAC\u9EB1\u9EBD\u9EC6\u94DC\u9EE2\u9EF1\u9EF8\u7AC8\u9F44\u{20094}\u{202B7}\u{203A0}\u691A\u94C3\u59AC\u{204D7}\u5840\u94C1\u37B9\u{205D5}\u{20615}\u{20676}\u{216BA}\u5757\u7173\u{20AC2}\u{20ACD}\u{20BBF}\u546A\u{2F83B}\u{20BCB}\u549E\u{20BFB}\u{20C3B}\u{20C53}\u{20C65}\u{20C7C}\u60E7\u{20C8D}\u567A\u{20CB5}\u{20CDD}\u{20CED}\u{20D6F}\u{20DB2}\u{20DC8}\u6955\u9C2F\u87A5\u{20E04}\u{20E0E}\u{20ED7}\u{20F90}\u{20F2D}\u{20E73}\u5C20\u{20FBC}\u5E0B\u{2105C}\u{2104F}\u{21076}\u671E\u{2107B}\u{21088}\u{21096}\u3647\u{210BF}\u{210D3}\u{2112F}\u{2113B}\u5364\u84AD\u{212E3}\u{21375}\u{21336}\u8B81\u{21577}\u{21619}\u{217C3}\u{217C7}\u4E78\u70BB\u{2182D}\u{2196A}"],
      ["9b40", "\u{21A2D}\u{21A45}\u{21C2A}\u{21C70}\u{21CAC}\u{21EC8}\u62C3\u{21ED5}\u{21F15}\u7198\u6855\u{22045}\u69E9\u36C8\u{2227C}\u{223D7}\u{223FA}\u{2272A}\u{22871}\u{2294F}\u82FD\u{22967}\u{22993}\u{22AD5}\u89A5\u{22AE8}\u8FA0\u{22B0E}\u97B8\u{22B3F}\u9847\u9ABD\u{22C4C}"],
      ["9b62", "\u{22C88}\u{22CB7}\u{25BE8}\u{22D08}\u{22D12}\u{22DB7}\u{22D95}\u{22E42}\u{22F74}\u{22FCC}\u{23033}\u{23066}\u{2331F}\u{233DE}\u5FB1\u6648\u66BF\u{27A79}\u{23567}\u{235F3}\u7201\u{249BA}\u77D7\u{2361A}\u{23716}\u7E87\u{20346}\u58B5\u670E"],
      ["9ba1", "\u6918\u{23AA7}\u{27657}\u{25FE2}\u{23E11}\u{23EB9}\u{275FE}\u{2209A}\u48D0\u4AB8\u{24119}\u{28A9A}\u{242EE}\u{2430D}\u{2403B}\u{24334}\u{24396}\u{24A45}\u{205CA}\u51D2\u{20611}\u599F\u{21EA8}\u3BBE\u{23CFF}\u{24404}\u{244D6}\u5788\u{24674}\u399B\u{2472F}\u{285E8}\u{299C9}\u3762\u{221C3}\u8B5E\u{28B4E}\u99D6\u{24812}\u{248FB}\u{24A15}\u7209\u{24AC0}\u{20C78}\u5965\u{24EA5}\u{24F86}\u{20779}\u8EDA\u{2502C}\u528F\u573F\u7171\u{25299}\u{25419}\u{23F4A}\u{24AA7}\u55BC\u{25446}\u{2546E}\u{26B52}\u91D4\u3473\u{2553F}\u{27632}\u{2555E}\u4718\u{25562}\u{25566}\u{257C7}\u{2493F}\u{2585D}\u5066\u34FB\u{233CC}\u60DE\u{25903}\u477C\u{28948}\u{25AAE}\u{25B89}\u{25C06}\u{21D90}\u57A1\u7151\u6FB6\u{26102}\u{27C12}\u9056\u{261B2}\u{24F9A}\u8B62\u{26402}\u{2644A}"],
      ["9c40", "\u5D5B\u{26BF7}\u8F36\u{26484}\u{2191C}\u8AEA\u{249F6}\u{26488}\u{23FEF}\u{26512}\u4BC0\u{265BF}\u{266B5}\u{2271B}\u9465\u{257E1}\u6195\u5A27\u{2F8CD}\u4FBB\u56B9\u{24521}\u{266FC}\u4E6A\u{24934}\u9656\u6D8F\u{26CBD}\u3618\u8977\u{26799}\u{2686E}\u{26411}\u{2685E}\u71DF\u{268C7}\u7B42\u{290C0}\u{20A11}\u{26926}\u9104\u{26939}\u7A45\u9DF0\u{269FA}\u9A26\u{26A2D}\u365F\u{26469}\u{20021}\u7983\u{26A34}\u{26B5B}\u5D2C\u{23519}\u83CF\u{26B9D}\u46D0\u{26CA4}\u753B\u8865\u{26DAE}\u58B6"],
      ["9ca1", "\u371C\u{2258D}\u{2704B}\u{271CD}\u3C54\u{27280}\u{27285}\u9281\u{2217A}\u{2728B}\u9330\u{272E6}\u{249D0}\u6C39\u949F\u{27450}\u{20EF8}\u8827\u88F5\u{22926}\u{28473}\u{217B1}\u6EB8\u{24A2A}\u{21820}\u39A4\u36B9\u5C10\u79E3\u453F\u66B6\u{29CAD}\u{298A4}\u8943\u{277CC}\u{27858}\u56D6\u40DF\u{2160A}\u39A1\u{2372F}\u{280E8}\u{213C5}\u71AD\u8366\u{279DD}\u{291A8}\u5A67\u4CB7\u{270AF}\u{289AB}\u{279FD}\u{27A0A}\u{27B0B}\u{27D66}\u{2417A}\u7B43\u797E\u{28009}\u6FB5\u{2A2DF}\u6A03\u{28318}\u53A2\u{26E07}\u93BF\u6836\u975D\u{2816F}\u{28023}\u{269B5}\u{213ED}\u{2322F}\u{28048}\u5D85\u{28C30}\u{28083}\u5715\u9823\u{28949}\u5DAB\u{24988}\u65BE\u69D5\u53D2\u{24AA5}\u{23F81}\u3C11\u6736\u{28090}\u{280F4}\u{2812E}\u{21FA1}\u{2814F}"],
      ["9d40", "\u{28189}\u{281AF}\u{2821A}\u{28306}\u{2832F}\u{2838A}\u35CA\u{28468}\u{286AA}\u48FA\u63E6\u{28956}\u7808\u9255\u{289B8}\u43F2\u{289E7}\u43DF\u{289E8}\u{28B46}\u{28BD4}\u59F8\u{28C09}\u8F0B\u{28FC5}\u{290EC}\u7B51\u{29110}\u{2913C}\u3DF7\u{2915E}\u{24ACA}\u8FD0\u728F\u568B\u{294E7}\u{295E9}\u{295B0}\u{295B8}\u{29732}\u{298D1}\u{29949}\u{2996A}\u{299C3}\u{29A28}\u{29B0E}\u{29D5A}\u{29D9B}\u7E9F\u{29EF8}\u{29F23}\u4CA4\u9547\u{2A293}\u71A2\u{2A2FF}\u4D91\u9012\u{2A5CB}\u4D9C\u{20C9C}\u8FBE\u55C1"],
      ["9da1", "\u8FBA\u{224B0}\u8FB9\u{24A93}\u4509\u7E7F\u6F56\u6AB1\u4EEA\u34E4\u{28B2C}\u{2789D}\u373A\u8E80\u{217F5}\u{28024}\u{28B6C}\u{28B99}\u{27A3E}\u{266AF}\u3DEB\u{27655}\u{23CB7}\u{25635}\u{25956}\u4E9A\u{25E81}\u{26258}\u56BF\u{20E6D}\u8E0E\u5B6D\u{23E88}\u{24C9E}\u63DE\u62D0\u{217F6}\u{2187B}\u6530\u562D\u{25C4A}\u541A\u{25311}\u3DC6\u{29D98}\u4C7D\u5622\u561E\u7F49\u{25ED8}\u5975\u{23D40}\u8770\u4E1C\u{20FEA}\u{20D49}\u{236BA}\u8117\u9D5E\u8D18\u763B\u9C45\u764E\u77B9\u9345\u5432\u8148\u82F7\u5625\u8132\u8418\u80BD\u55EA\u7962\u5643\u5416\u{20E9D}\u35CE\u5605\u55F1\u66F1\u{282E2}\u362D\u7534\u55F0\u55BA\u5497\u5572\u{20C41}\u{20C96}\u5ED0\u{25148}\u{20E76}\u{22C62}"],
      ["9e40", "\u{20EA2}\u9EAB\u7D5A\u55DE\u{21075}\u629D\u976D\u5494\u8CCD\u71F6\u9176\u63FC\u63B9\u63FE\u5569\u{22B43}\u9C72\u{22EB3}\u519A\u34DF\u{20DA7}\u51A7\u544D\u551E\u5513\u7666\u8E2D\u{2688A}\u75B1\u80B6\u8804\u8786\u88C7\u81B6\u841C\u{210C1}\u44EC\u7304\u{24706}\u5B90\u830B\u{26893}\u567B\u{226F4}\u{27D2F}\u{241A3}\u{27D73}\u{26ED0}\u{272B6}\u9170\u{211D9}\u9208\u{23CFC}\u{2A6A9}\u{20EAC}\u{20EF9}\u7266\u{21CA2}\u474E\u{24FC2}\u{27FF9}\u{20FEB}\u40FA"],
      ["9ea1", "\u9C5D\u651F\u{22DA0}\u48F3\u{247E0}\u{29D7C}\u{20FEC}\u{20E0A}\u6062\u{275A3}\u{20FED}"],
      ["9ead", "\u{26048}\u{21187}\u71A3\u7E8E\u9D50\u4E1A\u4E04\u3577\u5B0D\u6CB2\u5367\u36AC\u39DC\u537D\u36A5\u{24618}\u589A\u{24B6E}\u822D\u544B\u57AA\u{25A95}\u{20979}"],
      ["9ec5", "\u3A52\u{22465}\u7374\u{29EAC}\u4D09\u9BED\u{23CFE}\u{29F30}\u4C5B\u{24FA9}\u{2959E}\u{29FDE}\u845C\u{23DB6}\u{272B2}\u{267B3}\u{23720}\u632E\u7D25\u{23EF7}\u{23E2C}\u3A2A\u9008\u52CC\u3E74\u367A\u45E9\u{2048E}\u7640\u5AF0\u{20EB6}\u787A\u{27F2E}\u58A7\u40BF\u567C\u9B8B\u5D74\u7654\u{2A434}\u9E85\u4CE1\u75F9\u37FB\u6119\u{230DA}\u{243F2}"],
      ["9ef5", "\u565D\u{212A9}\u57A7\u{24963}\u{29E06}\u5234\u{270AE}\u35AD\u6C4A\u9D7C"],
      ["9f40", "\u7C56\u9B39\u57DE\u{2176C}\u5C53\u64D3\u{294D0}\u{26335}\u{27164}\u86AD\u{20D28}\u{26D22}\u{24AE2}\u{20D71}"],
      ["9f4f", "\u51FE\u{21F0F}\u5D8E\u9703\u{21DD1}\u9E81\u904C\u7B1F\u9B02\u5CD1\u7BA3\u6268\u6335\u9AFF\u7BCF\u9B2A\u7C7E\u9B2E\u7C42\u7C86\u9C15\u7BFC\u9B09\u9F17\u9C1B\u{2493E}\u9F5A\u5573\u5BC3\u4FFD\u9E98\u4FF2\u5260\u3E06\u52D1\u5767\u5056\u59B7\u5E12\u97C8\u9DAB\u8F5C\u5469\u97B4\u9940\u97BA\u532C\u6130"],
      ["9fa1", "\u692C\u53DA\u9C0A\u9D02\u4C3B\u9641\u6980\u50A6\u7546\u{2176D}\u99DA\u5273"],
      ["9fae", "\u9159\u9681\u915C"],
      ["9fb2", "\u9151\u{28E97}\u637F\u{26D23}\u6ACA\u5611\u918E\u757A\u6285\u{203FC}\u734F\u7C70\u{25C21}\u{23CFD}"],
      ["9fc1", "\u{24919}\u76D6\u9B9D\u4E2A\u{20CD4}\u83BE\u8842"],
      ["9fc9", "\u5C4A\u69C0\u50ED\u577A\u521F\u5DF5\u4ECE\u6C31\u{201F2}\u4F39\u549C\u54DA\u529A\u8D82\u35FE\u5F0C\u35F3"],
      ["9fdb", "\u6B52\u917C\u9FA5\u9B97\u982E\u98B4\u9ABA\u9EA8\u9E84\u717A\u7B14"],
      ["9fe7", "\u6BFA\u8818\u7F78"],
      ["9feb", "\u5620\u{2A64A}\u8E77\u9F53"],
      ["9ff0", "\u8DD4\u8E4F\u9E1C\u8E01\u6282\u{2837D}\u8E28\u8E75\u7AD3\u{24A77}\u7A3E\u78D8\u6CEA\u8A67\u7607"],
      ["a040", "\u{28A5A}\u9F26\u6CCE\u87D6\u75C3\u{2A2B2}\u7853\u{2F840}\u8D0C\u72E2\u7371\u8B2D\u7302\u74F1\u8CEB\u{24ABB}\u862F\u5FBA\u88A0\u44B7"],
      ["a055", "\u{2183B}\u{26E05}"],
      ["a058", "\u8A7E\u{2251B}"],
      ["a05b", "\u60FD\u7667\u9AD7\u9D44\u936E\u9B8F\u87F5"],
      ["a063", "\u880F\u8CF7\u732C\u9721\u9BB0\u35D6\u72B2\u4C07\u7C51\u994A\u{26159}\u6159\u4C04\u9E96\u617D"],
      ["a073", "\u575F\u616F\u62A6\u6239\u62CE\u3A5C\u61E2\u53AA\u{233F5}\u6364\u6802\u35D2"],
      ["a0a1", "\u5D57\u{28BC2}\u8FDA\u{28E39}"],
      ["a0a6", "\u50D9\u{21D46}\u7906\u5332\u9638\u{20F3B}\u4065"],
      ["a0ae", "\u77FE"],
      ["a0b0", "\u7CC2\u{25F1A}\u7CDA\u7A2D\u8066\u8063\u7D4D\u7505\u74F2\u8994\u821A\u670C\u8062\u{27486}\u805B\u74F0\u8103\u7724\u8989\u{267CC}\u7553\u{26ED1}\u87A9\u87CE\u81C8\u878C\u8A49\u8CAD\u8B43\u772B\u74F8\u84DA\u3635\u69B2\u8DA6"],
      ["a0d4", "\u89A9\u7468\u6DB9\u87C1\u{24011}\u74E7\u3DDB\u7176\u60A4\u619C\u3CD1\u7162\u6077"],
      ["a0e2", "\u7F71\u{28B2D}\u7250\u60E9\u4B7E\u5220\u3C18\u{23CC7}\u{25ED7}\u{27656}\u{25531}\u{21944}\u{212FE}\u{29903}\u{26DDC}\u{270AD}\u5CC1\u{261AD}\u{28A0F}\u{23677}\u{200EE}\u{26846}\u{24F0E}\u4562\u5B1F\u{2634C}\u9F50\u9EA6\u{2626B}"],
      ["a3c0", "\u2400", 31, "\u2421"],
      ["c6a1", "\u2460", 9, "\u2474", 9, "\u2170", 9, "\u4E36\u4E3F\u4E85\u4EA0\u5182\u5196\u51AB\u52F9\u5338\u5369\u53B6\u590A\u5B80\u5DDB\u2F33\u5E7F\u5EF4\u5F50\u5F61\u6534\u65E0\u7592\u7676\u8FB5\u96B6\xA8\u02C6\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\uFF3B\uFF3D\u273D\u3041", 23],
      ["c740", "\u3059", 58, "\u30A1\u30A2\u30A3\u30A4"],
      ["c7a1", "\u30A5", 81, "\u0410", 5, "\u0401\u0416", 4],
      ["c840", "\u041B", 26, "\u0451\u0436", 25, "\u21E7\u21B8\u21B9\u31CF\u{200CC}\u4E5A\u{2008A}\u5202\u4491"],
      ["c8a1", "\u9FB0\u5188\u9FB1\u{27607}"],
      ["c8cd", "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u309B\u309C\u2E80\u2E84\u2E86\u2E87\u2E88\u2E8A\u2E8C\u2E8D\u2E95\u2E9C\u2E9D\u2EA5\u2EA7\u2EAA\u2EAC\u2EAE\u2EB6\u2EBC\u2EBE\u2EC6\u2ECA\u2ECC\u2ECD\u2ECF\u2ED6\u2ED7\u2EDE\u2EE3"],
      ["c8f5", "\u0283\u0250\u025B\u0254\u0275\u0153\xF8\u014B\u028A\u026A"],
      ["f9fe", "\uFFED"],
      ["fa40", "\u{20547}\u92DB\u{205DF}\u{23FC5}\u854C\u42B5\u73EF\u51B5\u3649\u{24942}\u{289E4}\u9344\u{219DB}\u82EE\u{23CC8}\u783C\u6744\u62DF\u{24933}\u{289AA}\u{202A0}\u{26BB3}\u{21305}\u4FAB\u{224ED}\u5008\u{26D29}\u{27A84}\u{23600}\u{24AB1}\u{22513}\u5029\u{2037E}\u5FA4\u{20380}\u{20347}\u6EDB\u{2041F}\u507D\u5101\u347A\u510E\u986C\u3743\u8416\u{249A4}\u{20487}\u5160\u{233B4}\u516A\u{20BFF}\u{220FC}\u{202E5}\u{22530}\u{2058E}\u{23233}\u{21983}\u5B82\u877D\u{205B3}\u{23C99}\u51B2\u51B8"],
      ["faa1", "\u9D34\u51C9\u51CF\u51D1\u3CDC\u51D3\u{24AA6}\u51B3\u51E2\u5342\u51ED\u83CD\u693E\u{2372D}\u5F7B\u520B\u5226\u523C\u52B5\u5257\u5294\u52B9\u52C5\u7C15\u8542\u52E0\u860D\u{26B13}\u5305\u{28ADE}\u5549\u6ED9\u{23F80}\u{20954}\u{23FEC}\u5333\u5344\u{20BE2}\u6CCB\u{21726}\u681B\u73D5\u604A\u3EAA\u38CC\u{216E8}\u71DD\u44A2\u536D\u5374\u{286AB}\u537E\u537F\u{21596}\u{21613}\u77E6\u5393\u{28A9B}\u53A0\u53AB\u53AE\u73A7\u{25772}\u3F59\u739C\u53C1\u53C5\u6C49\u4E49\u57FE\u53D9\u3AAB\u{20B8F}\u53E0\u{23FEB}\u{22DA3}\u53F6\u{20C77}\u5413\u7079\u552B\u6657\u6D5B\u546D\u{26B53}\u{20D74}\u555D\u548F\u54A4\u47A6\u{2170D}\u{20EDD}\u3DB4\u{20D4D}"],
      ["fb40", "\u{289BC}\u{22698}\u5547\u4CED\u542F\u7417\u5586\u55A9\u5605\u{218D7}\u{2403A}\u4552\u{24435}\u66B3\u{210B4}\u5637\u66CD\u{2328A}\u66A4\u66AD\u564D\u564F\u78F1\u56F1\u9787\u53FE\u5700\u56EF\u56ED\u{28B66}\u3623\u{2124F}\u5746\u{241A5}\u6C6E\u708B\u5742\u36B1\u{26C7E}\u57E6\u{21416}\u5803\u{21454}\u{24363}\u5826\u{24BF5}\u585C\u58AA\u3561\u58E0\u58DC\u{2123C}\u58FB\u5BFF\u5743\u{2A150}\u{24278}\u93D3\u35A1\u591F\u68A6\u36C3\u6E59"],
      ["fba1", "\u{2163E}\u5A24\u5553\u{21692}\u8505\u59C9\u{20D4E}\u{26C81}\u{26D2A}\u{217DC}\u59D9\u{217FB}\u{217B2}\u{26DA6}\u6D71\u{21828}\u{216D5}\u59F9\u{26E45}\u5AAB\u5A63\u36E6\u{249A9}\u5A77\u3708\u5A96\u7465\u5AD3\u{26FA1}\u{22554}\u3D85\u{21911}\u3732\u{216B8}\u5E83\u52D0\u5B76\u6588\u5B7C\u{27A0E}\u4004\u485D\u{20204}\u5BD5\u6160\u{21A34}\u{259CC}\u{205A5}\u5BF3\u5B9D\u4D10\u5C05\u{21B44}\u5C13\u73CE\u5C14\u{21CA5}\u{26B28}\u5C49\u48DD\u5C85\u5CE9\u5CEF\u5D8B\u{21DF9}\u{21E37}\u5D10\u5D18\u5D46\u{21EA4}\u5CBA\u5DD7\u82FC\u382D\u{24901}\u{22049}\u{22173}\u8287\u3836\u3BC2\u5E2E\u6A8A\u5E75\u5E7A\u{244BC}\u{20CD3}\u53A6\u4EB7\u5ED0\u53A8\u{21771}\u5E09\u5EF4\u{28482}"],
      ["fc40", "\u5EF9\u5EFB\u38A0\u5EFC\u683E\u941B\u5F0D\u{201C1}\u{2F894}\u3ADE\u48AE\u{2133A}\u5F3A\u{26888}\u{223D0}\u5F58\u{22471}\u5F63\u97BD\u{26E6E}\u5F72\u9340\u{28A36}\u5FA7\u5DB6\u3D5F\u{25250}\u{21F6A}\u{270F8}\u{22668}\u91D6\u{2029E}\u{28A29}\u6031\u6685\u{21877}\u3963\u3DC7\u3639\u5790\u{227B4}\u7971\u3E40\u609E\u60A4\u60B3\u{24982}\u{2498F}\u{27A53}\u74A4\u50E1\u5AA0\u6164\u8424\u6142\u{2F8A6}\u{26ED2}\u6181\u51F4\u{20656}\u6187\u5BAA\u{23FB7}"],
      ["fca1", "\u{2285F}\u61D3\u{28B9D}\u{2995D}\u61D0\u3932\u{22980}\u{228C1}\u6023\u615C\u651E\u638B\u{20118}\u62C5\u{21770}\u62D5\u{22E0D}\u636C\u{249DF}\u3A17\u6438\u63F8\u{2138E}\u{217FC}\u6490\u6F8A\u{22E36}\u9814\u{2408C}\u{2571D}\u64E1\u64E5\u947B\u3A66\u643A\u3A57\u654D\u6F16\u{24A28}\u{24A23}\u6585\u656D\u655F\u{2307E}\u65B5\u{24940}\u4B37\u65D1\u40D8\u{21829}\u65E0\u65E3\u5FDF\u{23400}\u6618\u{231F7}\u{231F8}\u6644\u{231A4}\u{231A5}\u664B\u{20E75}\u6667\u{251E6}\u6673\u6674\u{21E3D}\u{23231}\u{285F4}\u{231C8}\u{25313}\u77C5\u{228F7}\u99A4\u6702\u{2439C}\u{24A21}\u3B2B\u69FA\u{237C2}\u675E\u6767\u6762\u{241CD}\u{290ED}\u67D7\u44E9\u6822\u6E50\u923C\u6801\u{233E6}\u{26DA0}\u685D"],
      ["fd40", "\u{2346F}\u69E1\u6A0B\u{28ADF}\u6973\u68C3\u{235CD}\u6901\u6900\u3D32\u3A01\u{2363C}\u3B80\u67AC\u6961\u{28A4A}\u42FC\u6936\u6998\u3BA1\u{203C9}\u8363\u5090\u69F9\u{23659}\u{2212A}\u6A45\u{23703}\u6A9D\u3BF3\u67B1\u6AC8\u{2919C}\u3C0D\u6B1D\u{20923}\u60DE\u6B35\u6B74\u{227CD}\u6EB5\u{23ADB}\u{203B5}\u{21958}\u3740\u5421\u{23B5A}\u6BE1\u{23EFC}\u6BDC\u6C37\u{2248B}\u{248F1}\u{26B51}\u6C5A\u8226\u6C79\u{23DBC}\u44C5\u{23DBD}\u{241A4}\u{2490C}\u{24900}"],
      ["fda1", "\u{23CC9}\u36E5\u3CEB\u{20D32}\u9B83\u{231F9}\u{22491}\u7F8F\u6837\u{26D25}\u{26DA1}\u{26DEB}\u6D96\u6D5C\u6E7C\u6F04\u{2497F}\u{24085}\u{26E72}\u8533\u{26F74}\u51C7\u6C9C\u6E1D\u842E\u{28B21}\u6E2F\u{23E2F}\u7453\u{23F82}\u79CC\u6E4F\u5A91\u{2304B}\u6FF8\u370D\u6F9D\u{23E30}\u6EFA\u{21497}\u{2403D}\u4555\u93F0\u6F44\u6F5C\u3D4E\u6F74\u{29170}\u3D3B\u6F9F\u{24144}\u6FD3\u{24091}\u{24155}\u{24039}\u{23FF0}\u{23FB4}\u{2413F}\u51DF\u{24156}\u{24157}\u{24140}\u{261DD}\u704B\u707E\u70A7\u7081\u70CC\u70D5\u70D6\u70DF\u4104\u3DE8\u71B4\u7196\u{24277}\u712B\u7145\u5A88\u714A\u716E\u5C9C\u{24365}\u714F\u9362\u{242C1}\u712C\u{2445A}\u{24A27}\u{24A22}\u71BA\u{28BE8}\u70BD\u720E"],
      ["fe40", "\u9442\u7215\u5911\u9443\u7224\u9341\u{25605}\u722E\u7240\u{24974}\u68BD\u7255\u7257\u3E55\u{23044}\u680D\u6F3D\u7282\u732A\u732B\u{24823}\u{2882B}\u48ED\u{28804}\u7328\u732E\u73CF\u73AA\u{20C3A}\u{26A2E}\u73C9\u7449\u{241E2}\u{216E7}\u{24A24}\u6623\u36C5\u{249B7}\u{2498D}\u{249FB}\u73F7\u7415\u6903\u{24A26}\u7439\u{205C3}\u3ED7\u745C\u{228AD}\u7460\u{28EB2}\u7447\u73E4\u7476\u83B9\u746C\u3730\u7474\u93F1\u6A2C\u7482\u4953\u{24A8C}"],
      ["fea1", "\u{2415F}\u{24A79}\u{28B8F}\u5B46\u{28C03}\u{2189E}\u74C8\u{21988}\u750E\u74E9\u751E\u{28ED9}\u{21A4B}\u5BD7\u{28EAC}\u9385\u754D\u754A\u7567\u756E\u{24F82}\u3F04\u{24D13}\u758E\u745D\u759E\u75B4\u7602\u762C\u7651\u764F\u766F\u7676\u{263F5}\u7690\u81EF\u37F8\u{26911}\u{2690E}\u76A1\u76A5\u76B7\u76CC\u{26F9F}\u8462\u{2509D}\u{2517D}\u{21E1C}\u771E\u7726\u7740\u64AF\u{25220}\u7758\u{232AC}\u77AF\u{28964}\u{28968}\u{216C1}\u77F4\u7809\u{21376}\u{24A12}\u68CA\u78AF\u78C7\u78D3\u96A5\u792E\u{255E0}\u78D7\u7934\u78B1\u{2760C}\u8FB8\u8884\u{28B2B}\u{26083}\u{2261C}\u7986\u8900\u6902\u7980\u{25857}\u799D\u{27B39}\u793C\u79A9\u6E2A\u{27126}\u3EA8\u79C6\u{2910D}\u79D4"]
    ];
  }
});

// node_modules/iconv-lite/encodings/dbcs-data.js
var require_dbcs_data = __commonJS({
  "node_modules/iconv-lite/encodings/dbcs-data.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      // == Japanese/ShiftJIS ====================================================
      // All japanese encodings are based on JIS X set of standards:
      // JIS X 0201 - Single-byte encoding of ASCII + ¥ + Kana chars at 0xA1-0xDF.
      // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes.
      //              Has several variations in 1978, 1983, 1990 and 1997.
      // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead.
      // JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233.
      //              2 planes, first is superset of 0208, second - revised 0212.
      //              Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx)
      // Byte encodings are:
      //  * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte
      //               encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC.
      //               Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI.
      //  * EUC-JP:    Up to 3 bytes per character. Used mostly on *nixes.
      //               0x00-0x7F       - lower part of 0201
      //               0x8E, 0xA1-0xDF - upper part of 0201
      //               (0xA1-0xFE)x2   - 0208 plane (94x94).
      //               0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94).
      //  * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon.
      //               Used as-is in ISO2022 family.
      //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII,
      //                0201-1976 Roman, 0208-1978, 0208-1983.
      //  * ISO2022-JP-1: Adds esc seq for 0212-1990.
      //  * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7.
      //  * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2.
      //  * ISO2022-JP-2004: Adds 0213-2004 Plane 1.
      //
      // After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes.
      //
      // Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html
      shiftjis: {
        type: "_dbcs",
        table: function() {
          return require_shiftjis();
        },
        encodeAdd: { "\xA5": 92, "\u203E": 126 },
        encodeSkipVals: [{ from: 60736, to: 63808 }]
      },
      csshiftjis: "shiftjis",
      mskanji: "shiftjis",
      sjis: "shiftjis",
      windows31j: "shiftjis",
      ms31j: "shiftjis",
      xsjis: "shiftjis",
      windows932: "shiftjis",
      ms932: "shiftjis",
      932: "shiftjis",
      cp932: "shiftjis",
      eucjp: {
        type: "_dbcs",
        table: function() {
          return require_eucjp();
        },
        encodeAdd: { "\xA5": 92, "\u203E": 126 }
      },
      // TODO: KDDI extension to Shift_JIS
      // TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes.
      // TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars.
      // == Chinese/GBK ==========================================================
      // http://en.wikipedia.org/wiki/GBK
      // We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder
      // Oldest GB2312 (1981, ~7600 chars) is a subset of CP936
      gb2312: "cp936",
      gb231280: "cp936",
      gb23121980: "cp936",
      csgb2312: "cp936",
      csiso58gb231280: "cp936",
      euccn: "cp936",
      // Microsoft's CP936 is a subset and approximation of GBK.
      windows936: "cp936",
      ms936: "cp936",
      936: "cp936",
      cp936: {
        type: "_dbcs",
        table: function() {
          return require_cp936();
        }
      },
      // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other.
      gbk: {
        type: "_dbcs",
        table: function() {
          return require_cp936().concat(require_gbk_added());
        }
      },
      xgbk: "gbk",
      isoir58: "gbk",
      // GB18030 is an algorithmic extension of GBK.
      // Main source: https://www.w3.org/TR/encoding/#gbk-encoder
      // http://icu-project.org/docs/papers/gb18030.html
      // http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml
      // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0
      gb18030: {
        type: "_dbcs",
        table: function() {
          return require_cp936().concat(require_gbk_added());
        },
        gb18030: function() {
          return require_gb18030_ranges();
        },
        encodeSkipVals: [128],
        encodeAdd: { "\u20AC": 41699 }
      },
      chinese: "gb18030",
      // == Korean ===============================================================
      // EUC-KR, KS_C_5601 and KS X 1001 are exactly the same.
      windows949: "cp949",
      ms949: "cp949",
      949: "cp949",
      cp949: {
        type: "_dbcs",
        table: function() {
          return require_cp949();
        }
      },
      cseuckr: "cp949",
      csksc56011987: "cp949",
      euckr: "cp949",
      isoir149: "cp949",
      korean: "cp949",
      ksc56011987: "cp949",
      ksc56011989: "cp949",
      ksc5601: "cp949",
      // == Big5/Taiwan/Hong Kong ================================================
      // There are lots of tables for Big5 and cp950. Please see the following links for history:
      // http://moztw.org/docs/big5/  http://www.haible.de/bruno/charsets/conversion-tables/Big5.html
      // Variations, in roughly number of defined chars:
      //  * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT
      //  * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/
      //  * Big5-2003 (Taiwan standard) almost superset of cp950.
      //  * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers.
      //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard.
      //    many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years.
      //    Plus, it has 4 combining sequences.
      //    Seems that Mozilla refused to support it for 10 yrs. https://bugzilla.mozilla.org/show_bug.cgi?id=162431 https://bugzilla.mozilla.org/show_bug.cgi?id=310299
      //    because big5-hkscs is the only encoding to include astral characters in non-algorithmic way.
      //    Implementations are not consistent within browsers; sometimes labeled as just big5.
      //    MS Internet Explorer switches from big5 to big5-hkscs when a patch applied.
      //    Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31
      //    In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s.
      //    Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt
      //                   http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt
      //
      // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder
      // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong.
      windows950: "cp950",
      ms950: "cp950",
      950: "cp950",
      cp950: {
        type: "_dbcs",
        table: function() {
          return require_cp950();
        }
      },
      // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus.
      big5: "big5hkscs",
      big5hkscs: {
        type: "_dbcs",
        table: function() {
          return require_cp950().concat(require_big5_added());
        },
        encodeSkipVals: [
          // Although Encoding Standard says we should avoid encoding to HKSCS area (See Step 1 of
          // https://encoding.spec.whatwg.org/#index-big5-pointer), we still do it to increase compatibility with ICU.
          // But if a single unicode point can be encoded both as HKSCS and regular Big5, we prefer the latter.
          36457,
          36463,
          36478,
          36523,
          36532,
          36557,
          36560,
          36695,
          36713,
          36718,
          36811,
          36862,
          36973,
          36986,
          37060,
          37084,
          37105,
          37311,
          37551,
          37552,
          37553,
          37554,
          37585,
          37959,
          38090,
          38361,
          38652,
          39285,
          39798,
          39800,
          39803,
          39878,
          39902,
          39916,
          39926,
          40002,
          40019,
          40034,
          40040,
          40043,
          40055,
          40124,
          40125,
          40144,
          40279,
          40282,
          40388,
          40431,
          40443,
          40617,
          40687,
          40701,
          40800,
          40907,
          41079,
          41180,
          41183,
          36812,
          37576,
          38468,
          38637,
          // Step 2 of https://encoding.spec.whatwg.org/#index-big5-pointer: Use last pointer for U+2550, U+255E, U+2561, U+256A, U+5341, or U+5345
          41636,
          41637,
          41639,
          41638,
          41676,
          41678
        ]
      },
      cnbig5: "big5hkscs",
      csbig5: "big5hkscs",
      xxbig5: "big5hkscs"
    };
  }
});

// node_modules/iconv-lite/encodings/index.js
var require_encodings = __commonJS({
  "node_modules/iconv-lite/encodings/index.js"(exports2, module2) {
    "use strict";
    var mergeModules = require_merge_exports();
    var modules = [
      require_internal(),
      require_utf32(),
      require_utf16(),
      require_utf7(),
      require_sbcs_codec(),
      require_sbcs_data(),
      require_sbcs_data_generated(),
      require_dbcs_codec(),
      require_dbcs_data()
    ];
    for (i = 0; i < modules.length; i++) {
      module2 = modules[i];
      mergeModules(exports2, module2);
    }
    var module2;
    var i;
  }
});

// node_modules/iconv-lite/lib/streams.js
var require_streams = __commonJS({
  "node_modules/iconv-lite/lib/streams.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    module2.exports = function(streamModule) {
      var Transform = streamModule.Transform;
      function IconvLiteEncoderStream(conv, options) {
        this.conv = conv;
        options = options || {};
        options.decodeStrings = false;
        Transform.call(this, options);
      }
      IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, {
        constructor: { value: IconvLiteEncoderStream }
      });
      IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) {
        if (typeof chunk !== "string") {
          return done(new Error("Iconv encoding stream needs strings as its input."));
        }
        try {
          var res = this.conv.write(chunk);
          if (res && res.length) this.push(res);
          done();
        } catch (e) {
          done(e);
        }
      };
      IconvLiteEncoderStream.prototype._flush = function(done) {
        try {
          var res = this.conv.end();
          if (res && res.length) this.push(res);
          done();
        } catch (e) {
          done(e);
        }
      };
      IconvLiteEncoderStream.prototype.collect = function(cb) {
        var chunks = [];
        this.on("error", cb);
        this.on("data", function(chunk) {
          chunks.push(chunk);
        });
        this.on("end", function() {
          cb(null, Buffer3.concat(chunks));
        });
        return this;
      };
      function IconvLiteDecoderStream(conv, options) {
        this.conv = conv;
        options = options || {};
        options.encoding = this.encoding = "utf8";
        Transform.call(this, options);
      }
      IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, {
        constructor: { value: IconvLiteDecoderStream }
      });
      IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {
        if (!Buffer3.isBuffer(chunk) && !(chunk instanceof Uint8Array)) {
          return done(new Error("Iconv decoding stream needs buffers as its input."));
        }
        try {
          var res = this.conv.write(chunk);
          if (res && res.length) this.push(res, this.encoding);
          done();
        } catch (e) {
          done(e);
        }
      };
      IconvLiteDecoderStream.prototype._flush = function(done) {
        try {
          var res = this.conv.end();
          if (res && res.length) this.push(res, this.encoding);
          done();
        } catch (e) {
          done(e);
        }
      };
      IconvLiteDecoderStream.prototype.collect = function(cb) {
        var res = "";
        this.on("error", cb);
        this.on("data", function(chunk) {
          res += chunk;
        });
        this.on("end", function() {
          cb(null, res);
        });
        return this;
      };
      return {
        IconvLiteEncoderStream,
        IconvLiteDecoderStream
      };
    };
  }
});

// node_modules/iconv-lite/lib/index.js
var require_lib = __commonJS({
  "node_modules/iconv-lite/lib/index.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    var bomHandling = require_bom_handling();
    var mergeModules = require_merge_exports();
    module2.exports.encodings = null;
    module2.exports.defaultCharUnicode = "\uFFFD";
    module2.exports.defaultCharSingleByte = "?";
    module2.exports.encode = function encode6(str, encoding, options) {
      str = "" + (str || "");
      var encoder = module2.exports.getEncoder(encoding, options);
      var res = encoder.write(str);
      var trail = encoder.end();
      return trail && trail.length > 0 ? Buffer3.concat([res, trail]) : res;
    };
    module2.exports.decode = function decode4(buf, encoding, options) {
      if (typeof buf === "string") {
        if (!module2.exports.skipDecodeWarning) {
          console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
          module2.exports.skipDecodeWarning = true;
        }
        buf = Buffer3.from("" + (buf || ""), "binary");
      }
      var decoder = module2.exports.getDecoder(encoding, options);
      var res = decoder.write(buf);
      var trail = decoder.end();
      return trail ? res + trail : res;
    };
    module2.exports.encodingExists = function encodingExists(enc) {
      try {
        module2.exports.getCodec(enc);
        return true;
      } catch (e) {
        return false;
      }
    };
    module2.exports.toEncoding = module2.exports.encode;
    module2.exports.fromEncoding = module2.exports.decode;
    module2.exports._codecDataCache = { __proto__: null };
    module2.exports.getCodec = function getCodec(encoding) {
      if (!module2.exports.encodings) {
        var raw = require_encodings();
        module2.exports.encodings = { __proto__: null };
        mergeModules(module2.exports.encodings, raw);
      }
      var enc = module2.exports._canonicalizeEncoding(encoding);
      var codecOptions = {};
      while (true) {
        var codec3 = module2.exports._codecDataCache[enc];
        if (codec3) {
          return codec3;
        }
        var codecDef = module2.exports.encodings[enc];
        switch (typeof codecDef) {
          case "string":
            enc = codecDef;
            break;
          case "object":
            for (var key in codecDef) {
              codecOptions[key] = codecDef[key];
            }
            if (!codecOptions.encodingName) {
              codecOptions.encodingName = enc;
            }
            enc = codecDef.type;
            break;
          case "function":
            if (!codecOptions.encodingName) {
              codecOptions.encodingName = enc;
            }
            codec3 = new codecDef(codecOptions, module2.exports);
            module2.exports._codecDataCache[codecOptions.encodingName] = codec3;
            return codec3;
          default:
            throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
        }
      }
    };
    module2.exports._canonicalizeEncoding = function(encoding) {
      return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
    };
    module2.exports.getEncoder = function getEncoder(encoding, options) {
      var codec3 = module2.exports.getCodec(encoding);
      var encoder = new codec3.encoder(options, codec3);
      if (codec3.bomAware && options && options.addBOM) {
        encoder = new bomHandling.PrependBOM(encoder, options);
      }
      return encoder;
    };
    module2.exports.getDecoder = function getDecoder(encoding, options) {
      var codec3 = module2.exports.getCodec(encoding);
      var decoder = new codec3.decoder(options, codec3);
      if (codec3.bomAware && !(options && options.stripBOM === false)) {
        decoder = new bomHandling.StripBOM(decoder, options);
      }
      return decoder;
    };
    module2.exports.enableStreamingAPI = function enableStreamingAPI(streamModule2) {
      if (module2.exports.supportsStreams) {
        return;
      }
      var streams = require_streams()(streamModule2);
      module2.exports.IconvLiteEncoderStream = streams.IconvLiteEncoderStream;
      module2.exports.IconvLiteDecoderStream = streams.IconvLiteDecoderStream;
      module2.exports.encodeStream = function encodeStream(encoding, options) {
        return new module2.exports.IconvLiteEncoderStream(module2.exports.getEncoder(encoding, options), options);
      };
      module2.exports.decodeStream = function decodeStream(encoding, options) {
        return new module2.exports.IconvLiteDecoderStream(module2.exports.getDecoder(encoding, options), options);
      };
      module2.exports.supportsStreams = true;
    };
    var streamModule;
    try {
      streamModule = require("stream");
    } catch (e) {
    }
    if (streamModule && streamModule.Transform) {
      module2.exports.enableStreamingAPI(streamModule);
    } else {
      module2.exports.encodeStream = module2.exports.decodeStream = function() {
        throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.");
      };
    }
    if (false) {
      console.error("iconv-lite warning: js files use non-utf8 encoding. See https://github.com/ashtuchkin/iconv-lite/wiki/Javascript-source-file-encodings for more info.");
    }
  }
});

// node_modules/unpipe/index.js
var require_unpipe = __commonJS({
  "node_modules/unpipe/index.js"(exports2, module2) {
    "use strict";
    module2.exports = unpipe;
    function hasPipeDataListeners(stream4) {
      var listeners = stream4.listeners("data");
      for (var i = 0; i < listeners.length; i++) {
        if (listeners[i].name === "ondata") {
          return true;
        }
      }
      return false;
    }
    function unpipe(stream4) {
      if (!stream4) {
        throw new TypeError("argument stream is required");
      }
      if (typeof stream4.unpipe === "function") {
        stream4.unpipe();
        return;
      }
      if (!hasPipeDataListeners(stream4)) {
        return;
      }
      var listener;
      var listeners = stream4.listeners("close");
      for (var i = 0; i < listeners.length; i++) {
        listener = listeners[i];
        if (listener.name !== "cleanup" && listener.name !== "onclose") {
          continue;
        }
        listener.call(stream4);
      }
    }
  }
});

// node_modules/raw-body/index.js
var require_raw_body = __commonJS({
  "node_modules/raw-body/index.js"(exports2, module2) {
    "use strict";
    var asyncHooks = tryRequireAsyncHooks();
    var bytes = require_bytes();
    var createError = require_http_errors();
    var iconv = require_lib();
    var unpipe = require_unpipe();
    module2.exports = getRawBody;
    var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /;
    function getDecoder(encoding) {
      if (!encoding) return null;
      try {
        return iconv.getDecoder(encoding);
      } catch (e) {
        if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e.message)) throw e;
        throw createError(415, "specified encoding unsupported", {
          encoding,
          type: "encoding.unsupported"
        });
      }
    }
    function getRawBody(stream4, options, callback) {
      var done = callback;
      var opts = options || {};
      if (stream4 === void 0) {
        throw new TypeError("argument stream is required");
      } else if (typeof stream4 !== "object" || stream4 === null || typeof stream4.on !== "function") {
        throw new TypeError("argument stream must be a stream");
      }
      if (options === true || typeof options === "string") {
        opts = {
          encoding: options
        };
      }
      if (typeof options === "function") {
        done = options;
        opts = {};
      }
      if (done !== void 0 && typeof done !== "function") {
        throw new TypeError("argument callback must be a function");
      }
      if (!done && !global.Promise) {
        throw new TypeError("argument callback is required");
      }
      var encoding = opts.encoding !== true ? opts.encoding : "utf-8";
      var limit = bytes.parse(opts.limit);
      var length = opts.length != null && !isNaN(opts.length) ? parseInt(opts.length, 10) : null;
      if (done) {
        return readStream2(stream4, encoding, length, limit, wrap(done));
      }
      return new Promise(function executor(resolve3, reject) {
        readStream2(stream4, encoding, length, limit, function onRead(err, buf) {
          if (err) return reject(err);
          resolve3(buf);
        });
      });
    }
    function halt(stream4) {
      unpipe(stream4);
      if (typeof stream4.pause === "function") {
        stream4.pause();
      }
    }
    function readStream2(stream4, encoding, length, limit, callback) {
      var complete = false;
      var sync = true;
      if (limit !== null && length !== null && length > limit) {
        return done(createError(413, "request entity too large", {
          expected: length,
          length,
          limit,
          type: "entity.too.large"
        }));
      }
      var state = stream4._readableState;
      if (stream4._decoder || state && (state.encoding || state.decoder)) {
        return done(createError(500, "stream encoding should not be set", {
          type: "stream.encoding.set"
        }));
      }
      if (typeof stream4.readable !== "undefined" && !stream4.readable) {
        return done(createError(500, "stream is not readable", {
          type: "stream.not.readable"
        }));
      }
      var received = 0;
      var decoder;
      try {
        decoder = getDecoder(encoding);
      } catch (err) {
        return done(err);
      }
      var buffer = decoder ? "" : [];
      stream4.on("aborted", onAborted);
      stream4.on("close", cleanup);
      stream4.on("data", onData);
      stream4.on("end", onEnd);
      stream4.on("error", onEnd);
      sync = false;
      function done() {
        var args = new Array(arguments.length);
        for (var i = 0; i < args.length; i++) {
          args[i] = arguments[i];
        }
        complete = true;
        if (sync) {
          process.nextTick(invokeCallback);
        } else {
          invokeCallback();
        }
        function invokeCallback() {
          cleanup();
          if (args[0]) {
            halt(stream4);
          }
          callback.apply(null, args);
        }
      }
      function onAborted() {
        if (complete) return;
        done(createError(400, "request aborted", {
          code: "ECONNABORTED",
          expected: length,
          length,
          received,
          type: "request.aborted"
        }));
      }
      function onData(chunk) {
        if (complete) return;
        received += chunk.length;
        if (limit !== null && received > limit) {
          done(createError(413, "request entity too large", {
            limit,
            received,
            type: "entity.too.large"
          }));
        } else if (decoder) {
          buffer += decoder.write(chunk);
        } else {
          buffer.push(chunk);
        }
      }
      function onEnd(err) {
        if (complete) return;
        if (err) return done(err);
        if (length !== null && received !== length) {
          done(createError(400, "request size did not match content length", {
            expected: length,
            length,
            received,
            type: "request.size.invalid"
          }));
        } else {
          var string5 = decoder ? buffer + (decoder.end() || "") : Buffer.concat(buffer);
          done(null, string5);
        }
      }
      function cleanup() {
        buffer = null;
        stream4.removeListener("aborted", onAborted);
        stream4.removeListener("data", onData);
        stream4.removeListener("end", onEnd);
        stream4.removeListener("error", onEnd);
        stream4.removeListener("close", cleanup);
      }
    }
    function tryRequireAsyncHooks() {
      try {
        return require("async_hooks");
      } catch (e) {
        return {};
      }
    }
    function wrap(fn) {
      var res;
      if (asyncHooks.AsyncResource) {
        res = new asyncHooks.AsyncResource(fn.name || "bound-anonymous-fn");
      }
      if (!res || !res.runInAsyncScope) {
        return fn;
      }
      return res.runInAsyncScope.bind(res, fn, null);
    }
  }
});

// node_modules/ee-first/index.js
var require_ee_first = __commonJS({
  "node_modules/ee-first/index.js"(exports2, module2) {
    "use strict";
    module2.exports = first;
    function first(stuff, done) {
      if (!Array.isArray(stuff))
        throw new TypeError("arg must be an array of [ee, events...] arrays");
      var cleanups = [];
      for (var i = 0; i < stuff.length; i++) {
        var arr = stuff[i];
        if (!Array.isArray(arr) || arr.length < 2)
          throw new TypeError("each array member must be [ee, events...]");
        var ee = arr[0];
        for (var j = 1; j < arr.length; j++) {
          var event = arr[j];
          var fn = listener(event, callback);
          ee.on(event, fn);
          cleanups.push({
            ee,
            event,
            fn
          });
        }
      }
      function callback() {
        cleanup();
        done.apply(null, arguments);
      }
      function cleanup() {
        var x;
        for (var i2 = 0; i2 < cleanups.length; i2++) {
          x = cleanups[i2];
          x.ee.removeListener(x.event, x.fn);
        }
      }
      function thunk(fn2) {
        done = fn2;
      }
      thunk.cancel = cleanup;
      return thunk;
    }
    function listener(event, done) {
      return function onevent(arg1) {
        var args = new Array(arguments.length);
        var ee = this;
        var err = event === "error" ? arg1 : null;
        for (var i = 0; i < args.length; i++) {
          args[i] = arguments[i];
        }
        done(err, ee, event, args);
      };
    }
  }
});

// node_modules/on-finished/index.js
var require_on_finished = __commonJS({
  "node_modules/on-finished/index.js"(exports2, module2) {
    "use strict";
    module2.exports = onFinished;
    module2.exports.isFinished = isFinished;
    var asyncHooks = tryRequireAsyncHooks();
    var first = require_ee_first();
    var defer = typeof setImmediate === "function" ? setImmediate : function(fn) {
      process.nextTick(fn.bind.apply(fn, arguments));
    };
    function onFinished(msg, listener) {
      if (isFinished(msg) !== false) {
        defer(listener, null, msg);
        return msg;
      }
      attachListener(msg, wrap(listener));
      return msg;
    }
    function isFinished(msg) {
      var socket = msg.socket;
      if (typeof msg.finished === "boolean") {
        return Boolean(msg.finished || socket && !socket.writable);
      }
      if (typeof msg.complete === "boolean") {
        return Boolean(msg.upgrade || !socket || !socket.readable || msg.complete && !msg.readable);
      }
      return void 0;
    }
    function attachFinishedListener(msg, callback) {
      var eeMsg;
      var eeSocket;
      var finished = false;
      function onFinish(error73) {
        eeMsg.cancel();
        eeSocket.cancel();
        finished = true;
        callback(error73);
      }
      eeMsg = eeSocket = first([[msg, "end", "finish"]], onFinish);
      function onSocket(socket) {
        msg.removeListener("socket", onSocket);
        if (finished) return;
        if (eeMsg !== eeSocket) return;
        eeSocket = first([[socket, "error", "close"]], onFinish);
      }
      if (msg.socket) {
        onSocket(msg.socket);
        return;
      }
      msg.on("socket", onSocket);
      if (msg.socket === void 0) {
        patchAssignSocket(msg, onSocket);
      }
    }
    function attachListener(msg, listener) {
      var attached = msg.__onFinished;
      if (!attached || !attached.queue) {
        attached = msg.__onFinished = createListener(msg);
        attachFinishedListener(msg, attached);
      }
      attached.queue.push(listener);
    }
    function createListener(msg) {
      function listener(err) {
        if (msg.__onFinished === listener) msg.__onFinished = null;
        if (!listener.queue) return;
        var queue = listener.queue;
        listener.queue = null;
        for (var i = 0; i < queue.length; i++) {
          queue[i](err, msg);
        }
      }
      listener.queue = [];
      return listener;
    }
    function patchAssignSocket(res, callback) {
      var assignSocket = res.assignSocket;
      if (typeof assignSocket !== "function") return;
      res.assignSocket = function _assignSocket(socket) {
        assignSocket.call(this, socket);
        callback(socket);
      };
    }
    function tryRequireAsyncHooks() {
      try {
        return require("async_hooks");
      } catch (e) {
        return {};
      }
    }
    function wrap(fn) {
      var res;
      if (asyncHooks.AsyncResource) {
        res = new asyncHooks.AsyncResource(fn.name || "bound-anonymous-fn");
      }
      if (!res || !res.runInAsyncScope) {
        return fn;
      }
      return res.runInAsyncScope.bind(res, fn, null);
    }
  }
});

// node_modules/content-type/index.js
var require_content_type = __commonJS({
  "node_modules/content-type/index.js"(exports2) {
    "use strict";
    var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
    var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/;
    var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
    var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
    var QUOTE_REGEXP = /([\\"])/g;
    var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
    exports2.format = format;
    exports2.parse = parse4;
    function format(obj) {
      if (!obj || typeof obj !== "object") {
        throw new TypeError("argument obj is required");
      }
      var parameters = obj.parameters;
      var type = obj.type;
      if (!type || !TYPE_REGEXP.test(type)) {
        throw new TypeError("invalid type");
      }
      var string5 = type;
      if (parameters && typeof parameters === "object") {
        var param;
        var params = Object.keys(parameters).sort();
        for (var i = 0; i < params.length; i++) {
          param = params[i];
          if (!TOKEN_REGEXP.test(param)) {
            throw new TypeError("invalid parameter name");
          }
          string5 += "; " + param + "=" + qstring(parameters[param]);
        }
      }
      return string5;
    }
    function parse4(string5) {
      if (!string5) {
        throw new TypeError("argument string is required");
      }
      var header = typeof string5 === "object" ? getcontenttype(string5) : string5;
      if (typeof header !== "string") {
        throw new TypeError("argument string is required to be a string");
      }
      var index = header.indexOf(";");
      var type = index !== -1 ? header.slice(0, index).trim() : header.trim();
      if (!TYPE_REGEXP.test(type)) {
        throw new TypeError("invalid media type");
      }
      var obj = new ContentType(type.toLowerCase());
      if (index !== -1) {
        var key;
        var match;
        var value;
        PARAM_REGEXP.lastIndex = index;
        while (match = PARAM_REGEXP.exec(header)) {
          if (match.index !== index) {
            throw new TypeError("invalid parameter format");
          }
          index += match[0].length;
          key = match[1].toLowerCase();
          value = match[2];
          if (value.charCodeAt(0) === 34) {
            value = value.slice(1, -1);
            if (value.indexOf("\\") !== -1) {
              value = value.replace(QESC_REGEXP, "$1");
            }
          }
          obj.parameters[key] = value;
        }
        if (index !== header.length) {
          throw new TypeError("invalid parameter format");
        }
      }
      return obj;
    }
    function getcontenttype(obj) {
      var header;
      if (typeof obj.getHeader === "function") {
        header = obj.getHeader("content-type");
      } else if (typeof obj.headers === "object") {
        header = obj.headers && obj.headers["content-type"];
      }
      if (typeof header !== "string") {
        throw new TypeError("content-type header is missing from object");
      }
      return header;
    }
    function qstring(val) {
      var str = String(val);
      if (TOKEN_REGEXP.test(str)) {
        return str;
      }
      if (str.length > 0 && !TEXT_REGEXP.test(str)) {
        throw new TypeError("invalid parameter value");
      }
      return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
    }
    function ContentType(type) {
      this.parameters = /* @__PURE__ */ Object.create(null);
      this.type = type;
    }
  }
});

// node_modules/mime-db/db.json
var require_db = __commonJS({
  "node_modules/mime-db/db.json"(exports2, module2) {
    module2.exports = {
      "application/1d-interleaved-parityfec": {
        source: "iana"
      },
      "application/3gpdash-qoe-report+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/3gpp-ims+xml": {
        source: "iana",
        compressible: true
      },
      "application/3gpphal+json": {
        source: "iana",
        compressible: true
      },
      "application/3gpphalforms+json": {
        source: "iana",
        compressible: true
      },
      "application/a2l": {
        source: "iana"
      },
      "application/ace+cbor": {
        source: "iana"
      },
      "application/ace+json": {
        source: "iana",
        compressible: true
      },
      "application/ace-groupcomm+cbor": {
        source: "iana"
      },
      "application/ace-trl+cbor": {
        source: "iana"
      },
      "application/activemessage": {
        source: "iana"
      },
      "application/activity+json": {
        source: "iana",
        compressible: true
      },
      "application/aif+cbor": {
        source: "iana"
      },
      "application/aif+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-cdni+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-cdnifilter+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-costmap+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-costmapfilter+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-directory+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointcost+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointcostparams+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointprop+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointpropparams+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-error+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-networkmap+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-networkmapfilter+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-propmap+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-propmapparams+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-tips+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-tipsparams+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-updatestreamcontrol+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-updatestreamparams+json": {
        source: "iana",
        compressible: true
      },
      "application/aml": {
        source: "iana"
      },
      "application/andrew-inset": {
        source: "iana",
        extensions: ["ez"]
      },
      "application/appinstaller": {
        compressible: false,
        extensions: ["appinstaller"]
      },
      "application/applefile": {
        source: "iana"
      },
      "application/applixware": {
        source: "apache",
        extensions: ["aw"]
      },
      "application/appx": {
        compressible: false,
        extensions: ["appx"]
      },
      "application/appxbundle": {
        compressible: false,
        extensions: ["appxbundle"]
      },
      "application/at+jwt": {
        source: "iana"
      },
      "application/atf": {
        source: "iana"
      },
      "application/atfx": {
        source: "iana"
      },
      "application/atom+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atom"]
      },
      "application/atomcat+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atomcat"]
      },
      "application/atomdeleted+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atomdeleted"]
      },
      "application/atomicmail": {
        source: "iana"
      },
      "application/atomsvc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atomsvc"]
      },
      "application/atsc-dwd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dwd"]
      },
      "application/atsc-dynamic-event-message": {
        source: "iana"
      },
      "application/atsc-held+xml": {
        source: "iana",
        compressible: true,
        extensions: ["held"]
      },
      "application/atsc-rdt+json": {
        source: "iana",
        compressible: true
      },
      "application/atsc-rsat+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rsat"]
      },
      "application/atxml": {
        source: "iana"
      },
      "application/auth-policy+xml": {
        source: "iana",
        compressible: true
      },
      "application/automationml-aml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["aml"]
      },
      "application/automationml-amlx+zip": {
        source: "iana",
        compressible: false,
        extensions: ["amlx"]
      },
      "application/bacnet-xdd+zip": {
        source: "iana",
        compressible: false
      },
      "application/batch-smtp": {
        source: "iana"
      },
      "application/bdoc": {
        compressible: false,
        extensions: ["bdoc"]
      },
      "application/beep+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/bufr": {
        source: "iana"
      },
      "application/c2pa": {
        source: "iana"
      },
      "application/calendar+json": {
        source: "iana",
        compressible: true
      },
      "application/calendar+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xcs"]
      },
      "application/call-completion": {
        source: "iana"
      },
      "application/cals-1840": {
        source: "iana"
      },
      "application/captive+json": {
        source: "iana",
        compressible: true
      },
      "application/cbor": {
        source: "iana"
      },
      "application/cbor-seq": {
        source: "iana"
      },
      "application/cccex": {
        source: "iana"
      },
      "application/ccmp+xml": {
        source: "iana",
        compressible: true
      },
      "application/ccxml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ccxml"]
      },
      "application/cda+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/cdfx+xml": {
        source: "iana",
        compressible: true,
        extensions: ["cdfx"]
      },
      "application/cdmi-capability": {
        source: "iana",
        extensions: ["cdmia"]
      },
      "application/cdmi-container": {
        source: "iana",
        extensions: ["cdmic"]
      },
      "application/cdmi-domain": {
        source: "iana",
        extensions: ["cdmid"]
      },
      "application/cdmi-object": {
        source: "iana",
        extensions: ["cdmio"]
      },
      "application/cdmi-queue": {
        source: "iana",
        extensions: ["cdmiq"]
      },
      "application/cdni": {
        source: "iana"
      },
      "application/ce+cbor": {
        source: "iana"
      },
      "application/cea": {
        source: "iana"
      },
      "application/cea-2018+xml": {
        source: "iana",
        compressible: true
      },
      "application/cellml+xml": {
        source: "iana",
        compressible: true
      },
      "application/cfw": {
        source: "iana"
      },
      "application/cid-edhoc+cbor-seq": {
        source: "iana"
      },
      "application/city+json": {
        source: "iana",
        compressible: true
      },
      "application/city+json-seq": {
        source: "iana"
      },
      "application/clr": {
        source: "iana"
      },
      "application/clue+xml": {
        source: "iana",
        compressible: true
      },
      "application/clue_info+xml": {
        source: "iana",
        compressible: true
      },
      "application/cms": {
        source: "iana"
      },
      "application/cnrp+xml": {
        source: "iana",
        compressible: true
      },
      "application/coap-eap": {
        source: "iana"
      },
      "application/coap-group+json": {
        source: "iana",
        compressible: true
      },
      "application/coap-payload": {
        source: "iana"
      },
      "application/commonground": {
        source: "iana"
      },
      "application/concise-problem-details+cbor": {
        source: "iana"
      },
      "application/conference-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/cose": {
        source: "iana"
      },
      "application/cose-key": {
        source: "iana"
      },
      "application/cose-key-set": {
        source: "iana"
      },
      "application/cose-x509": {
        source: "iana"
      },
      "application/cpl+xml": {
        source: "iana",
        compressible: true,
        extensions: ["cpl"]
      },
      "application/csrattrs": {
        source: "iana"
      },
      "application/csta+xml": {
        source: "iana",
        compressible: true
      },
      "application/cstadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/csvm+json": {
        source: "iana",
        compressible: true
      },
      "application/cu-seeme": {
        source: "apache",
        extensions: ["cu"]
      },
      "application/cwl": {
        source: "iana",
        extensions: ["cwl"]
      },
      "application/cwl+json": {
        source: "iana",
        compressible: true
      },
      "application/cwl+yaml": {
        source: "iana"
      },
      "application/cwt": {
        source: "iana"
      },
      "application/cybercash": {
        source: "iana"
      },
      "application/dart": {
        compressible: true
      },
      "application/dash+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpd"]
      },
      "application/dash-patch+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpp"]
      },
      "application/dashdelta": {
        source: "iana"
      },
      "application/davmount+xml": {
        source: "iana",
        compressible: true,
        extensions: ["davmount"]
      },
      "application/dca-rft": {
        source: "iana"
      },
      "application/dcd": {
        source: "iana"
      },
      "application/dec-dx": {
        source: "iana"
      },
      "application/dialog-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/dicom": {
        source: "iana",
        extensions: ["dcm"]
      },
      "application/dicom+json": {
        source: "iana",
        compressible: true
      },
      "application/dicom+xml": {
        source: "iana",
        compressible: true
      },
      "application/dii": {
        source: "iana"
      },
      "application/dit": {
        source: "iana"
      },
      "application/dns": {
        source: "iana"
      },
      "application/dns+json": {
        source: "iana",
        compressible: true
      },
      "application/dns-message": {
        source: "iana"
      },
      "application/docbook+xml": {
        source: "apache",
        compressible: true,
        extensions: ["dbk"]
      },
      "application/dots+cbor": {
        source: "iana"
      },
      "application/dpop+jwt": {
        source: "iana"
      },
      "application/dskpp+xml": {
        source: "iana",
        compressible: true
      },
      "application/dssc+der": {
        source: "iana",
        extensions: ["dssc"]
      },
      "application/dssc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdssc"]
      },
      "application/dvcs": {
        source: "iana"
      },
      "application/eat+cwt": {
        source: "iana"
      },
      "application/eat+jwt": {
        source: "iana"
      },
      "application/eat-bun+cbor": {
        source: "iana"
      },
      "application/eat-bun+json": {
        source: "iana",
        compressible: true
      },
      "application/eat-ucs+cbor": {
        source: "iana"
      },
      "application/eat-ucs+json": {
        source: "iana",
        compressible: true
      },
      "application/ecmascript": {
        source: "apache",
        compressible: true,
        extensions: ["ecma"]
      },
      "application/edhoc+cbor-seq": {
        source: "iana"
      },
      "application/edi-consent": {
        source: "iana"
      },
      "application/edi-x12": {
        source: "iana",
        compressible: false
      },
      "application/edifact": {
        source: "iana",
        compressible: false
      },
      "application/efi": {
        source: "iana"
      },
      "application/elm+json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/elm+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.cap+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/emergencycalldata.comment+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.control+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.deviceinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.ecall.msd": {
        source: "iana"
      },
      "application/emergencycalldata.legacyesn+json": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.providerinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.serviceinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.subscriberinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.veds+xml": {
        source: "iana",
        compressible: true
      },
      "application/emma+xml": {
        source: "iana",
        compressible: true,
        extensions: ["emma"]
      },
      "application/emotionml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["emotionml"]
      },
      "application/encaprtp": {
        source: "iana"
      },
      "application/entity-statement+jwt": {
        source: "iana"
      },
      "application/epp+xml": {
        source: "iana",
        compressible: true
      },
      "application/epub+zip": {
        source: "iana",
        compressible: false,
        extensions: ["epub"]
      },
      "application/eshop": {
        source: "iana"
      },
      "application/exi": {
        source: "iana",
        extensions: ["exi"]
      },
      "application/expect-ct-report+json": {
        source: "iana",
        compressible: true
      },
      "application/express": {
        source: "iana",
        extensions: ["exp"]
      },
      "application/fastinfoset": {
        source: "iana"
      },
      "application/fastsoap": {
        source: "iana"
      },
      "application/fdf": {
        source: "iana",
        extensions: ["fdf"]
      },
      "application/fdt+xml": {
        source: "iana",
        compressible: true,
        extensions: ["fdt"]
      },
      "application/fhir+json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/fhir+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/fido.trusted-apps+json": {
        compressible: true
      },
      "application/fits": {
        source: "iana"
      },
      "application/flexfec": {
        source: "iana"
      },
      "application/font-sfnt": {
        source: "iana"
      },
      "application/font-tdpfr": {
        source: "iana",
        extensions: ["pfr"]
      },
      "application/font-woff": {
        source: "iana",
        compressible: false
      },
      "application/framework-attributes+xml": {
        source: "iana",
        compressible: true
      },
      "application/geo+json": {
        source: "iana",
        compressible: true,
        extensions: ["geojson"]
      },
      "application/geo+json-seq": {
        source: "iana"
      },
      "application/geopackage+sqlite3": {
        source: "iana"
      },
      "application/geopose+json": {
        source: "iana",
        compressible: true
      },
      "application/geoxacml+json": {
        source: "iana",
        compressible: true
      },
      "application/geoxacml+xml": {
        source: "iana",
        compressible: true
      },
      "application/gltf-buffer": {
        source: "iana"
      },
      "application/gml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["gml"]
      },
      "application/gnap-binding-jws": {
        source: "iana"
      },
      "application/gnap-binding-jwsd": {
        source: "iana"
      },
      "application/gnap-binding-rotation-jws": {
        source: "iana"
      },
      "application/gnap-binding-rotation-jwsd": {
        source: "iana"
      },
      "application/gpx+xml": {
        source: "apache",
        compressible: true,
        extensions: ["gpx"]
      },
      "application/grib": {
        source: "iana"
      },
      "application/gxf": {
        source: "apache",
        extensions: ["gxf"]
      },
      "application/gzip": {
        source: "iana",
        compressible: false,
        extensions: ["gz"]
      },
      "application/h224": {
        source: "iana"
      },
      "application/held+xml": {
        source: "iana",
        compressible: true
      },
      "application/hjson": {
        extensions: ["hjson"]
      },
      "application/hl7v2+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/http": {
        source: "iana"
      },
      "application/hyperstudio": {
        source: "iana",
        extensions: ["stk"]
      },
      "application/ibe-key-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/ibe-pkg-reply+xml": {
        source: "iana",
        compressible: true
      },
      "application/ibe-pp-data": {
        source: "iana"
      },
      "application/iges": {
        source: "iana"
      },
      "application/im-iscomposing+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/index": {
        source: "iana"
      },
      "application/index.cmd": {
        source: "iana"
      },
      "application/index.obj": {
        source: "iana"
      },
      "application/index.response": {
        source: "iana"
      },
      "application/index.vnd": {
        source: "iana"
      },
      "application/inkml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ink", "inkml"]
      },
      "application/iotp": {
        source: "iana"
      },
      "application/ipfix": {
        source: "iana",
        extensions: ["ipfix"]
      },
      "application/ipp": {
        source: "iana"
      },
      "application/isup": {
        source: "iana"
      },
      "application/its+xml": {
        source: "iana",
        compressible: true,
        extensions: ["its"]
      },
      "application/java-archive": {
        source: "iana",
        compressible: false,
        extensions: ["jar", "war", "ear"]
      },
      "application/java-serialized-object": {
        source: "apache",
        compressible: false,
        extensions: ["ser"]
      },
      "application/java-vm": {
        source: "apache",
        compressible: false,
        extensions: ["class"]
      },
      "application/javascript": {
        source: "apache",
        charset: "UTF-8",
        compressible: true,
        extensions: ["js"]
      },
      "application/jf2feed+json": {
        source: "iana",
        compressible: true
      },
      "application/jose": {
        source: "iana"
      },
      "application/jose+json": {
        source: "iana",
        compressible: true
      },
      "application/jrd+json": {
        source: "iana",
        compressible: true
      },
      "application/jscalendar+json": {
        source: "iana",
        compressible: true
      },
      "application/jscontact+json": {
        source: "iana",
        compressible: true
      },
      "application/json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["json", "map"]
      },
      "application/json-patch+json": {
        source: "iana",
        compressible: true
      },
      "application/json-seq": {
        source: "iana"
      },
      "application/json5": {
        extensions: ["json5"]
      },
      "application/jsonml+json": {
        source: "apache",
        compressible: true,
        extensions: ["jsonml"]
      },
      "application/jsonpath": {
        source: "iana"
      },
      "application/jwk+json": {
        source: "iana",
        compressible: true
      },
      "application/jwk-set+json": {
        source: "iana",
        compressible: true
      },
      "application/jwk-set+jwt": {
        source: "iana"
      },
      "application/jwt": {
        source: "iana"
      },
      "application/kpml-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/kpml-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/ld+json": {
        source: "iana",
        compressible: true,
        extensions: ["jsonld"]
      },
      "application/lgr+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lgr"]
      },
      "application/link-format": {
        source: "iana"
      },
      "application/linkset": {
        source: "iana"
      },
      "application/linkset+json": {
        source: "iana",
        compressible: true
      },
      "application/load-control+xml": {
        source: "iana",
        compressible: true
      },
      "application/logout+jwt": {
        source: "iana"
      },
      "application/lost+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lostxml"]
      },
      "application/lostsync+xml": {
        source: "iana",
        compressible: true
      },
      "application/lpf+zip": {
        source: "iana",
        compressible: false
      },
      "application/lxf": {
        source: "iana"
      },
      "application/mac-binhex40": {
        source: "iana",
        extensions: ["hqx"]
      },
      "application/mac-compactpro": {
        source: "apache",
        extensions: ["cpt"]
      },
      "application/macwriteii": {
        source: "iana"
      },
      "application/mads+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mads"]
      },
      "application/manifest+json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["webmanifest"]
      },
      "application/marc": {
        source: "iana",
        extensions: ["mrc"]
      },
      "application/marcxml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mrcx"]
      },
      "application/mathematica": {
        source: "iana",
        extensions: ["ma", "nb", "mb"]
      },
      "application/mathml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mathml"]
      },
      "application/mathml-content+xml": {
        source: "iana",
        compressible: true
      },
      "application/mathml-presentation+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-associated-procedure-description+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-deregister+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-envelope+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-msk+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-msk-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-protection-description+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-reception-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-register+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-register-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-schedule+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-user-service-description+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbox": {
        source: "iana",
        extensions: ["mbox"]
      },
      "application/media-policy-dataset+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpf"]
      },
      "application/media_control+xml": {
        source: "iana",
        compressible: true
      },
      "application/mediaservercontrol+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mscml"]
      },
      "application/merge-patch+json": {
        source: "iana",
        compressible: true
      },
      "application/metalink+xml": {
        source: "apache",
        compressible: true,
        extensions: ["metalink"]
      },
      "application/metalink4+xml": {
        source: "iana",
        compressible: true,
        extensions: ["meta4"]
      },
      "application/mets+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mets"]
      },
      "application/mf4": {
        source: "iana"
      },
      "application/mikey": {
        source: "iana"
      },
      "application/mipc": {
        source: "iana"
      },
      "application/missing-blocks+cbor-seq": {
        source: "iana"
      },
      "application/mmt-aei+xml": {
        source: "iana",
        compressible: true,
        extensions: ["maei"]
      },
      "application/mmt-usd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["musd"]
      },
      "application/mods+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mods"]
      },
      "application/moss-keys": {
        source: "iana"
      },
      "application/moss-signature": {
        source: "iana"
      },
      "application/mosskey-data": {
        source: "iana"
      },
      "application/mosskey-request": {
        source: "iana"
      },
      "application/mp21": {
        source: "iana",
        extensions: ["m21", "mp21"]
      },
      "application/mp4": {
        source: "iana",
        extensions: ["mp4", "mpg4", "mp4s", "m4p"]
      },
      "application/mpeg4-generic": {
        source: "iana"
      },
      "application/mpeg4-iod": {
        source: "iana"
      },
      "application/mpeg4-iod-xmt": {
        source: "iana"
      },
      "application/mrb-consumer+xml": {
        source: "iana",
        compressible: true
      },
      "application/mrb-publish+xml": {
        source: "iana",
        compressible: true
      },
      "application/msc-ivr+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/msc-mixer+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/msix": {
        compressible: false,
        extensions: ["msix"]
      },
      "application/msixbundle": {
        compressible: false,
        extensions: ["msixbundle"]
      },
      "application/msword": {
        source: "iana",
        compressible: false,
        extensions: ["doc", "dot"]
      },
      "application/mud+json": {
        source: "iana",
        compressible: true
      },
      "application/multipart-core": {
        source: "iana"
      },
      "application/mxf": {
        source: "iana",
        extensions: ["mxf"]
      },
      "application/n-quads": {
        source: "iana",
        extensions: ["nq"]
      },
      "application/n-triples": {
        source: "iana",
        extensions: ["nt"]
      },
      "application/nasdata": {
        source: "iana"
      },
      "application/news-checkgroups": {
        source: "iana",
        charset: "US-ASCII"
      },
      "application/news-groupinfo": {
        source: "iana",
        charset: "US-ASCII"
      },
      "application/news-transmission": {
        source: "iana"
      },
      "application/nlsml+xml": {
        source: "iana",
        compressible: true
      },
      "application/node": {
        source: "iana",
        extensions: ["cjs"]
      },
      "application/nss": {
        source: "iana"
      },
      "application/oauth-authz-req+jwt": {
        source: "iana"
      },
      "application/oblivious-dns-message": {
        source: "iana"
      },
      "application/ocsp-request": {
        source: "iana"
      },
      "application/ocsp-response": {
        source: "iana"
      },
      "application/octet-stream": {
        source: "iana",
        compressible: true,
        extensions: ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"]
      },
      "application/oda": {
        source: "iana",
        extensions: ["oda"]
      },
      "application/odm+xml": {
        source: "iana",
        compressible: true
      },
      "application/odx": {
        source: "iana"
      },
      "application/oebps-package+xml": {
        source: "iana",
        compressible: true,
        extensions: ["opf"]
      },
      "application/ogg": {
        source: "iana",
        compressible: false,
        extensions: ["ogx"]
      },
      "application/ohttp-keys": {
        source: "iana"
      },
      "application/omdoc+xml": {
        source: "apache",
        compressible: true,
        extensions: ["omdoc"]
      },
      "application/onenote": {
        source: "apache",
        extensions: ["onetoc", "onetoc2", "onetmp", "onepkg", "one", "onea"]
      },
      "application/opc-nodeset+xml": {
        source: "iana",
        compressible: true
      },
      "application/oscore": {
        source: "iana"
      },
      "application/oxps": {
        source: "iana",
        extensions: ["oxps"]
      },
      "application/p21": {
        source: "iana"
      },
      "application/p21+zip": {
        source: "iana",
        compressible: false
      },
      "application/p2p-overlay+xml": {
        source: "iana",
        compressible: true,
        extensions: ["relo"]
      },
      "application/parityfec": {
        source: "iana"
      },
      "application/passport": {
        source: "iana"
      },
      "application/patch-ops-error+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xer"]
      },
      "application/pdf": {
        source: "iana",
        compressible: false,
        extensions: ["pdf"]
      },
      "application/pdx": {
        source: "iana"
      },
      "application/pem-certificate-chain": {
        source: "iana"
      },
      "application/pgp-encrypted": {
        source: "iana",
        compressible: false,
        extensions: ["pgp"]
      },
      "application/pgp-keys": {
        source: "iana",
        extensions: ["asc"]
      },
      "application/pgp-signature": {
        source: "iana",
        extensions: ["sig", "asc"]
      },
      "application/pics-rules": {
        source: "apache",
        extensions: ["prf"]
      },
      "application/pidf+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/pidf-diff+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/pkcs10": {
        source: "iana",
        extensions: ["p10"]
      },
      "application/pkcs12": {
        source: "iana"
      },
      "application/pkcs7-mime": {
        source: "iana",
        extensions: ["p7m", "p7c"]
      },
      "application/pkcs7-signature": {
        source: "iana",
        extensions: ["p7s"]
      },
      "application/pkcs8": {
        source: "iana",
        extensions: ["p8"]
      },
      "application/pkcs8-encrypted": {
        source: "iana"
      },
      "application/pkix-attr-cert": {
        source: "iana",
        extensions: ["ac"]
      },
      "application/pkix-cert": {
        source: "iana",
        extensions: ["cer"]
      },
      "application/pkix-crl": {
        source: "iana",
        extensions: ["crl"]
      },
      "application/pkix-pkipath": {
        source: "iana",
        extensions: ["pkipath"]
      },
      "application/pkixcmp": {
        source: "iana",
        extensions: ["pki"]
      },
      "application/pls+xml": {
        source: "iana",
        compressible: true,
        extensions: ["pls"]
      },
      "application/poc-settings+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/postscript": {
        source: "iana",
        compressible: true,
        extensions: ["ai", "eps", "ps"]
      },
      "application/ppsp-tracker+json": {
        source: "iana",
        compressible: true
      },
      "application/private-token-issuer-directory": {
        source: "iana"
      },
      "application/private-token-request": {
        source: "iana"
      },
      "application/private-token-response": {
        source: "iana"
      },
      "application/problem+json": {
        source: "iana",
        compressible: true
      },
      "application/problem+xml": {
        source: "iana",
        compressible: true
      },
      "application/provenance+xml": {
        source: "iana",
        compressible: true,
        extensions: ["provx"]
      },
      "application/provided-claims+jwt": {
        source: "iana"
      },
      "application/prs.alvestrand.titrax-sheet": {
        source: "iana"
      },
      "application/prs.cww": {
        source: "iana",
        extensions: ["cww"]
      },
      "application/prs.cyn": {
        source: "iana",
        charset: "7-BIT"
      },
      "application/prs.hpub+zip": {
        source: "iana",
        compressible: false
      },
      "application/prs.implied-document+xml": {
        source: "iana",
        compressible: true
      },
      "application/prs.implied-executable": {
        source: "iana"
      },
      "application/prs.implied-object+json": {
        source: "iana",
        compressible: true
      },
      "application/prs.implied-object+json-seq": {
        source: "iana"
      },
      "application/prs.implied-object+yaml": {
        source: "iana"
      },
      "application/prs.implied-structure": {
        source: "iana"
      },
      "application/prs.mayfile": {
        source: "iana"
      },
      "application/prs.nprend": {
        source: "iana"
      },
      "application/prs.plucker": {
        source: "iana"
      },
      "application/prs.rdf-xml-crypt": {
        source: "iana"
      },
      "application/prs.vcfbzip2": {
        source: "iana"
      },
      "application/prs.xsf+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xsf"]
      },
      "application/pskc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["pskcxml"]
      },
      "application/pvd+json": {
        source: "iana",
        compressible: true
      },
      "application/qsig": {
        source: "iana"
      },
      "application/raml+yaml": {
        compressible: true,
        extensions: ["raml"]
      },
      "application/raptorfec": {
        source: "iana"
      },
      "application/rdap+json": {
        source: "iana",
        compressible: true
      },
      "application/rdf+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rdf", "owl"]
      },
      "application/reginfo+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rif"]
      },
      "application/relax-ng-compact-syntax": {
        source: "iana",
        extensions: ["rnc"]
      },
      "application/remote-printing": {
        source: "apache"
      },
      "application/reputon+json": {
        source: "iana",
        compressible: true
      },
      "application/resolve-response+jwt": {
        source: "iana"
      },
      "application/resource-lists+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rl"]
      },
      "application/resource-lists-diff+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rld"]
      },
      "application/rfc+xml": {
        source: "iana",
        compressible: true
      },
      "application/riscos": {
        source: "iana"
      },
      "application/rlmi+xml": {
        source: "iana",
        compressible: true
      },
      "application/rls-services+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rs"]
      },
      "application/route-apd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rapd"]
      },
      "application/route-s-tsid+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sls"]
      },
      "application/route-usd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rusd"]
      },
      "application/rpki-checklist": {
        source: "iana"
      },
      "application/rpki-ghostbusters": {
        source: "iana",
        extensions: ["gbr"]
      },
      "application/rpki-manifest": {
        source: "iana",
        extensions: ["mft"]
      },
      "application/rpki-publication": {
        source: "iana"
      },
      "application/rpki-roa": {
        source: "iana",
        extensions: ["roa"]
      },
      "application/rpki-signed-tal": {
        source: "iana"
      },
      "application/rpki-updown": {
        source: "iana"
      },
      "application/rsd+xml": {
        source: "apache",
        compressible: true,
        extensions: ["rsd"]
      },
      "application/rss+xml": {
        source: "apache",
        compressible: true,
        extensions: ["rss"]
      },
      "application/rtf": {
        source: "iana",
        compressible: true,
        extensions: ["rtf"]
      },
      "application/rtploopback": {
        source: "iana"
      },
      "application/rtx": {
        source: "iana"
      },
      "application/samlassertion+xml": {
        source: "iana",
        compressible: true
      },
      "application/samlmetadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/sarif+json": {
        source: "iana",
        compressible: true
      },
      "application/sarif-external-properties+json": {
        source: "iana",
        compressible: true
      },
      "application/sbe": {
        source: "iana"
      },
      "application/sbml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sbml"]
      },
      "application/scaip+xml": {
        source: "iana",
        compressible: true
      },
      "application/scim+json": {
        source: "iana",
        compressible: true
      },
      "application/scvp-cv-request": {
        source: "iana",
        extensions: ["scq"]
      },
      "application/scvp-cv-response": {
        source: "iana",
        extensions: ["scs"]
      },
      "application/scvp-vp-request": {
        source: "iana",
        extensions: ["spq"]
      },
      "application/scvp-vp-response": {
        source: "iana",
        extensions: ["spp"]
      },
      "application/sdp": {
        source: "iana",
        extensions: ["sdp"]
      },
      "application/secevent+jwt": {
        source: "iana"
      },
      "application/senml+cbor": {
        source: "iana"
      },
      "application/senml+json": {
        source: "iana",
        compressible: true
      },
      "application/senml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["senmlx"]
      },
      "application/senml-etch+cbor": {
        source: "iana"
      },
      "application/senml-etch+json": {
        source: "iana",
        compressible: true
      },
      "application/senml-exi": {
        source: "iana"
      },
      "application/sensml+cbor": {
        source: "iana"
      },
      "application/sensml+json": {
        source: "iana",
        compressible: true
      },
      "application/sensml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sensmlx"]
      },
      "application/sensml-exi": {
        source: "iana"
      },
      "application/sep+xml": {
        source: "iana",
        compressible: true
      },
      "application/sep-exi": {
        source: "iana"
      },
      "application/session-info": {
        source: "iana"
      },
      "application/set-payment": {
        source: "iana"
      },
      "application/set-payment-initiation": {
        source: "iana",
        extensions: ["setpay"]
      },
      "application/set-registration": {
        source: "iana"
      },
      "application/set-registration-initiation": {
        source: "iana",
        extensions: ["setreg"]
      },
      "application/sgml": {
        source: "iana"
      },
      "application/sgml-open-catalog": {
        source: "iana"
      },
      "application/shf+xml": {
        source: "iana",
        compressible: true,
        extensions: ["shf"]
      },
      "application/sieve": {
        source: "iana",
        extensions: ["siv", "sieve"]
      },
      "application/simple-filter+xml": {
        source: "iana",
        compressible: true
      },
      "application/simple-message-summary": {
        source: "iana"
      },
      "application/simplesymbolcontainer": {
        source: "iana"
      },
      "application/sipc": {
        source: "iana"
      },
      "application/slate": {
        source: "iana"
      },
      "application/smil": {
        source: "apache"
      },
      "application/smil+xml": {
        source: "iana",
        compressible: true,
        extensions: ["smi", "smil"]
      },
      "application/smpte336m": {
        source: "iana"
      },
      "application/soap+fastinfoset": {
        source: "iana"
      },
      "application/soap+xml": {
        source: "iana",
        compressible: true
      },
      "application/sparql-query": {
        source: "iana",
        extensions: ["rq"]
      },
      "application/sparql-results+xml": {
        source: "iana",
        compressible: true,
        extensions: ["srx"]
      },
      "application/spdx+json": {
        source: "iana",
        compressible: true
      },
      "application/spirits-event+xml": {
        source: "iana",
        compressible: true
      },
      "application/sql": {
        source: "iana",
        extensions: ["sql"]
      },
      "application/srgs": {
        source: "iana",
        extensions: ["gram"]
      },
      "application/srgs+xml": {
        source: "iana",
        compressible: true,
        extensions: ["grxml"]
      },
      "application/sru+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sru"]
      },
      "application/ssdl+xml": {
        source: "apache",
        compressible: true,
        extensions: ["ssdl"]
      },
      "application/sslkeylogfile": {
        source: "iana"
      },
      "application/ssml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ssml"]
      },
      "application/st2110-41": {
        source: "iana"
      },
      "application/stix+json": {
        source: "iana",
        compressible: true
      },
      "application/stratum": {
        source: "iana"
      },
      "application/swid+cbor": {
        source: "iana"
      },
      "application/swid+xml": {
        source: "iana",
        compressible: true,
        extensions: ["swidtag"]
      },
      "application/tamp-apex-update": {
        source: "iana"
      },
      "application/tamp-apex-update-confirm": {
        source: "iana"
      },
      "application/tamp-community-update": {
        source: "iana"
      },
      "application/tamp-community-update-confirm": {
        source: "iana"
      },
      "application/tamp-error": {
        source: "iana"
      },
      "application/tamp-sequence-adjust": {
        source: "iana"
      },
      "application/tamp-sequence-adjust-confirm": {
        source: "iana"
      },
      "application/tamp-status-query": {
        source: "iana"
      },
      "application/tamp-status-response": {
        source: "iana"
      },
      "application/tamp-update": {
        source: "iana"
      },
      "application/tamp-update-confirm": {
        source: "iana"
      },
      "application/tar": {
        compressible: true
      },
      "application/taxii+json": {
        source: "iana",
        compressible: true
      },
      "application/td+json": {
        source: "iana",
        compressible: true
      },
      "application/tei+xml": {
        source: "iana",
        compressible: true,
        extensions: ["tei", "teicorpus"]
      },
      "application/tetra_isi": {
        source: "iana"
      },
      "application/thraud+xml": {
        source: "iana",
        compressible: true,
        extensions: ["tfi"]
      },
      "application/timestamp-query": {
        source: "iana"
      },
      "application/timestamp-reply": {
        source: "iana"
      },
      "application/timestamped-data": {
        source: "iana",
        extensions: ["tsd"]
      },
      "application/tlsrpt+gzip": {
        source: "iana"
      },
      "application/tlsrpt+json": {
        source: "iana",
        compressible: true
      },
      "application/tm+json": {
        source: "iana",
        compressible: true
      },
      "application/tnauthlist": {
        source: "iana"
      },
      "application/toc+cbor": {
        source: "iana"
      },
      "application/token-introspection+jwt": {
        source: "iana"
      },
      "application/toml": {
        source: "iana",
        compressible: true,
        extensions: ["toml"]
      },
      "application/trickle-ice-sdpfrag": {
        source: "iana"
      },
      "application/trig": {
        source: "iana",
        extensions: ["trig"]
      },
      "application/trust-chain+json": {
        source: "iana",
        compressible: true
      },
      "application/trust-mark+jwt": {
        source: "iana"
      },
      "application/trust-mark-delegation+jwt": {
        source: "iana"
      },
      "application/ttml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ttml"]
      },
      "application/tve-trigger": {
        source: "iana"
      },
      "application/tzif": {
        source: "iana"
      },
      "application/tzif-leap": {
        source: "iana"
      },
      "application/ubjson": {
        compressible: false,
        extensions: ["ubj"]
      },
      "application/uccs+cbor": {
        source: "iana"
      },
      "application/ujcs+json": {
        source: "iana",
        compressible: true
      },
      "application/ulpfec": {
        source: "iana"
      },
      "application/urc-grpsheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/urc-ressheet+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rsheet"]
      },
      "application/urc-targetdesc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["td"]
      },
      "application/urc-uisocketdesc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vc": {
        source: "iana"
      },
      "application/vc+cose": {
        source: "iana"
      },
      "application/vc+jwt": {
        source: "iana"
      },
      "application/vcard+json": {
        source: "iana",
        compressible: true
      },
      "application/vcard+xml": {
        source: "iana",
        compressible: true
      },
      "application/vemmi": {
        source: "iana"
      },
      "application/vividence.scriptfile": {
        source: "apache"
      },
      "application/vnd.1000minds.decision-model+xml": {
        source: "iana",
        compressible: true,
        extensions: ["1km"]
      },
      "application/vnd.1ob": {
        source: "iana"
      },
      "application/vnd.3gpp-prose+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp-prose-pc3a+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp-prose-pc3ach+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp-prose-pc3ch+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp-prose-pc8+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp-v2x-local-service-information": {
        source: "iana"
      },
      "application/vnd.3gpp.5gnas": {
        source: "iana"
      },
      "application/vnd.3gpp.5gsa2x": {
        source: "iana"
      },
      "application/vnd.3gpp.5gsa2x-local-service-information": {
        source: "iana"
      },
      "application/vnd.3gpp.5gsv2x": {
        source: "iana"
      },
      "application/vnd.3gpp.5gsv2x-local-service-information": {
        source: "iana"
      },
      "application/vnd.3gpp.access-transfer-events+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.bsf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.crs+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.current-location-discovery+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.gmop+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.gtpc": {
        source: "iana"
      },
      "application/vnd.3gpp.interworking-data": {
        source: "iana"
      },
      "application/vnd.3gpp.lpp": {
        source: "iana"
      },
      "application/vnd.3gpp.mc-signalling-ear": {
        source: "iana"
      },
      "application/vnd.3gpp.mcdata-affiliation-command+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-payload": {
        source: "iana"
      },
      "application/vnd.3gpp.mcdata-regroup+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-service-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-signalling": {
        source: "iana"
      },
      "application/vnd.3gpp.mcdata-ue-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-user-profile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-affiliation-command+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-floor-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-location-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-mbms-usage-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-regroup+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-service-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-signed+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-ue-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-ue-init-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-user-profile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-affiliation-command+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-location-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-regroup+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-service-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-transmission-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-ue-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-user-profile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mid-call+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.ngap": {
        source: "iana"
      },
      "application/vnd.3gpp.pfcp": {
        source: "iana"
      },
      "application/vnd.3gpp.pic-bw-large": {
        source: "iana",
        extensions: ["plb"]
      },
      "application/vnd.3gpp.pic-bw-small": {
        source: "iana",
        extensions: ["psb"]
      },
      "application/vnd.3gpp.pic-bw-var": {
        source: "iana",
        extensions: ["pvb"]
      },
      "application/vnd.3gpp.pinapp-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.s1ap": {
        source: "iana"
      },
      "application/vnd.3gpp.seal-group-doc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.seal-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.seal-location-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.seal-mbms-usage-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.seal-network-qos-management-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.seal-ue-config-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.seal-unicast-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.seal-user-profile-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.sms": {
        source: "iana"
      },
      "application/vnd.3gpp.sms+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.srvcc-ext+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.srvcc-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.state-and-event-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.ussd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.v2x": {
        source: "iana"
      },
      "application/vnd.3gpp.vae-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp2.bcmcsinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp2.sms": {
        source: "iana"
      },
      "application/vnd.3gpp2.tcap": {
        source: "iana",
        extensions: ["tcap"]
      },
      "application/vnd.3lightssoftware.imagescal": {
        source: "iana"
      },
      "application/vnd.3m.post-it-notes": {
        source: "iana",
        extensions: ["pwn"]
      },
      "application/vnd.accpac.simply.aso": {
        source: "iana",
        extensions: ["aso"]
      },
      "application/vnd.accpac.simply.imp": {
        source: "iana",
        extensions: ["imp"]
      },
      "application/vnd.acm.addressxfer+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.acm.chatbot+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.acucobol": {
        source: "iana",
        extensions: ["acu"]
      },
      "application/vnd.acucorp": {
        source: "iana",
        extensions: ["atc", "acutc"]
      },
      "application/vnd.adobe.air-application-installer-package+zip": {
        source: "apache",
        compressible: false,
        extensions: ["air"]
      },
      "application/vnd.adobe.flash.movie": {
        source: "iana"
      },
      "application/vnd.adobe.formscentral.fcdt": {
        source: "iana",
        extensions: ["fcdt"]
      },
      "application/vnd.adobe.fxp": {
        source: "iana",
        extensions: ["fxp", "fxpl"]
      },
      "application/vnd.adobe.partial-upload": {
        source: "iana"
      },
      "application/vnd.adobe.xdp+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdp"]
      },
      "application/vnd.adobe.xfdf": {
        source: "apache",
        extensions: ["xfdf"]
      },
      "application/vnd.aether.imp": {
        source: "iana"
      },
      "application/vnd.afpc.afplinedata": {
        source: "iana"
      },
      "application/vnd.afpc.afplinedata-pagedef": {
        source: "iana"
      },
      "application/vnd.afpc.cmoca-cmresource": {
        source: "iana"
      },
      "application/vnd.afpc.foca-charset": {
        source: "iana"
      },
      "application/vnd.afpc.foca-codedfont": {
        source: "iana"
      },
      "application/vnd.afpc.foca-codepage": {
        source: "iana"
      },
      "application/vnd.afpc.modca": {
        source: "iana"
      },
      "application/vnd.afpc.modca-cmtable": {
        source: "iana"
      },
      "application/vnd.afpc.modca-formdef": {
        source: "iana"
      },
      "application/vnd.afpc.modca-mediummap": {
        source: "iana"
      },
      "application/vnd.afpc.modca-objectcontainer": {
        source: "iana"
      },
      "application/vnd.afpc.modca-overlay": {
        source: "iana"
      },
      "application/vnd.afpc.modca-pagesegment": {
        source: "iana"
      },
      "application/vnd.age": {
        source: "iana",
        extensions: ["age"]
      },
      "application/vnd.ah-barcode": {
        source: "apache"
      },
      "application/vnd.ahead.space": {
        source: "iana",
        extensions: ["ahead"]
      },
      "application/vnd.airzip.filesecure.azf": {
        source: "iana",
        extensions: ["azf"]
      },
      "application/vnd.airzip.filesecure.azs": {
        source: "iana",
        extensions: ["azs"]
      },
      "application/vnd.amadeus+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.amazon.ebook": {
        source: "apache",
        extensions: ["azw"]
      },
      "application/vnd.amazon.mobi8-ebook": {
        source: "iana"
      },
      "application/vnd.americandynamics.acc": {
        source: "iana",
        extensions: ["acc"]
      },
      "application/vnd.amiga.ami": {
        source: "iana",
        extensions: ["ami"]
      },
      "application/vnd.amundsen.maze+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.android.ota": {
        source: "iana"
      },
      "application/vnd.android.package-archive": {
        source: "apache",
        compressible: false,
        extensions: ["apk"]
      },
      "application/vnd.anki": {
        source: "iana"
      },
      "application/vnd.anser-web-certificate-issue-initiation": {
        source: "iana",
        extensions: ["cii"]
      },
      "application/vnd.anser-web-funds-transfer-initiation": {
        source: "apache",
        extensions: ["fti"]
      },
      "application/vnd.antix.game-component": {
        source: "iana",
        extensions: ["atx"]
      },
      "application/vnd.apache.arrow.file": {
        source: "iana"
      },
      "application/vnd.apache.arrow.stream": {
        source: "iana"
      },
      "application/vnd.apache.parquet": {
        source: "iana"
      },
      "application/vnd.apache.thrift.binary": {
        source: "iana"
      },
      "application/vnd.apache.thrift.compact": {
        source: "iana"
      },
      "application/vnd.apache.thrift.json": {
        source: "iana"
      },
      "application/vnd.apexlang": {
        source: "iana"
      },
      "application/vnd.api+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.aplextor.warrp+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.apothekende.reservation+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.apple.installer+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpkg"]
      },
      "application/vnd.apple.keynote": {
        source: "iana",
        extensions: ["key"]
      },
      "application/vnd.apple.mpegurl": {
        source: "iana",
        extensions: ["m3u8"]
      },
      "application/vnd.apple.numbers": {
        source: "iana",
        extensions: ["numbers"]
      },
      "application/vnd.apple.pages": {
        source: "iana",
        extensions: ["pages"]
      },
      "application/vnd.apple.pkpass": {
        compressible: false,
        extensions: ["pkpass"]
      },
      "application/vnd.arastra.swi": {
        source: "apache"
      },
      "application/vnd.aristanetworks.swi": {
        source: "iana",
        extensions: ["swi"]
      },
      "application/vnd.artisan+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.artsquare": {
        source: "iana"
      },
      "application/vnd.astraea-software.iota": {
        source: "iana",
        extensions: ["iota"]
      },
      "application/vnd.audiograph": {
        source: "iana",
        extensions: ["aep"]
      },
      "application/vnd.autodesk.fbx": {
        extensions: ["fbx"]
      },
      "application/vnd.autopackage": {
        source: "iana"
      },
      "application/vnd.avalon+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.avistar+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.balsamiq.bmml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["bmml"]
      },
      "application/vnd.balsamiq.bmpr": {
        source: "iana"
      },
      "application/vnd.banana-accounting": {
        source: "iana"
      },
      "application/vnd.bbf.usp.error": {
        source: "iana"
      },
      "application/vnd.bbf.usp.msg": {
        source: "iana"
      },
      "application/vnd.bbf.usp.msg+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.bekitzur-stech+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.belightsoft.lhzd+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.belightsoft.lhzl+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.bint.med-content": {
        source: "iana"
      },
      "application/vnd.biopax.rdf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.blink-idb-value-wrapper": {
        source: "iana"
      },
      "application/vnd.blueice.multipass": {
        source: "iana",
        extensions: ["mpm"]
      },
      "application/vnd.bluetooth.ep.oob": {
        source: "iana"
      },
      "application/vnd.bluetooth.le.oob": {
        source: "iana"
      },
      "application/vnd.bmi": {
        source: "iana",
        extensions: ["bmi"]
      },
      "application/vnd.bpf": {
        source: "iana"
      },
      "application/vnd.bpf3": {
        source: "iana"
      },
      "application/vnd.businessobjects": {
        source: "iana",
        extensions: ["rep"]
      },
      "application/vnd.byu.uapi+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.bzip3": {
        source: "iana"
      },
      "application/vnd.c3voc.schedule+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cab-jscript": {
        source: "iana"
      },
      "application/vnd.canon-cpdl": {
        source: "iana"
      },
      "application/vnd.canon-lips": {
        source: "iana"
      },
      "application/vnd.capasystems-pg+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cendio.thinlinc.clientconf": {
        source: "iana"
      },
      "application/vnd.century-systems.tcp_stream": {
        source: "iana"
      },
      "application/vnd.chemdraw+xml": {
        source: "iana",
        compressible: true,
        extensions: ["cdxml"]
      },
      "application/vnd.chess-pgn": {
        source: "iana"
      },
      "application/vnd.chipnuts.karaoke-mmd": {
        source: "iana",
        extensions: ["mmd"]
      },
      "application/vnd.ciedi": {
        source: "iana"
      },
      "application/vnd.cinderella": {
        source: "iana",
        extensions: ["cdy"]
      },
      "application/vnd.cirpack.isdn-ext": {
        source: "iana"
      },
      "application/vnd.citationstyles.style+xml": {
        source: "iana",
        compressible: true,
        extensions: ["csl"]
      },
      "application/vnd.claymore": {
        source: "iana",
        extensions: ["cla"]
      },
      "application/vnd.cloanto.rp9": {
        source: "iana",
        extensions: ["rp9"]
      },
      "application/vnd.clonk.c4group": {
        source: "iana",
        extensions: ["c4g", "c4d", "c4f", "c4p", "c4u"]
      },
      "application/vnd.cluetrust.cartomobile-config": {
        source: "iana",
        extensions: ["c11amc"]
      },
      "application/vnd.cluetrust.cartomobile-config-pkg": {
        source: "iana",
        extensions: ["c11amz"]
      },
      "application/vnd.cncf.helm.chart.content.v1.tar+gzip": {
        source: "iana"
      },
      "application/vnd.cncf.helm.chart.provenance.v1.prov": {
        source: "iana"
      },
      "application/vnd.cncf.helm.config.v1+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.coffeescript": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.document": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.document-template": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.presentation": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.presentation-template": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.spreadsheet": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.spreadsheet-template": {
        source: "iana"
      },
      "application/vnd.collection+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.collection.doc+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.collection.next+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.comicbook+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.comicbook-rar": {
        source: "iana"
      },
      "application/vnd.commerce-battelle": {
        source: "iana"
      },
      "application/vnd.commonspace": {
        source: "iana",
        extensions: ["csp"]
      },
      "application/vnd.contact.cmsg": {
        source: "iana",
        extensions: ["cdbcmsg"]
      },
      "application/vnd.coreos.ignition+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cosmocaller": {
        source: "iana",
        extensions: ["cmc"]
      },
      "application/vnd.crick.clicker": {
        source: "iana",
        extensions: ["clkx"]
      },
      "application/vnd.crick.clicker.keyboard": {
        source: "iana",
        extensions: ["clkk"]
      },
      "application/vnd.crick.clicker.palette": {
        source: "iana",
        extensions: ["clkp"]
      },
      "application/vnd.crick.clicker.template": {
        source: "iana",
        extensions: ["clkt"]
      },
      "application/vnd.crick.clicker.wordbank": {
        source: "iana",
        extensions: ["clkw"]
      },
      "application/vnd.criticaltools.wbs+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wbs"]
      },
      "application/vnd.cryptii.pipe+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.crypto-shade-file": {
        source: "iana"
      },
      "application/vnd.cryptomator.encrypted": {
        source: "iana"
      },
      "application/vnd.cryptomator.vault": {
        source: "iana"
      },
      "application/vnd.ctc-posml": {
        source: "iana",
        extensions: ["pml"]
      },
      "application/vnd.ctct.ws+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cups-pdf": {
        source: "iana"
      },
      "application/vnd.cups-postscript": {
        source: "iana"
      },
      "application/vnd.cups-ppd": {
        source: "iana",
        extensions: ["ppd"]
      },
      "application/vnd.cups-raster": {
        source: "iana"
      },
      "application/vnd.cups-raw": {
        source: "iana"
      },
      "application/vnd.curl": {
        source: "iana"
      },
      "application/vnd.curl.car": {
        source: "apache",
        extensions: ["car"]
      },
      "application/vnd.curl.pcurl": {
        source: "apache",
        extensions: ["pcurl"]
      },
      "application/vnd.cyan.dean.root+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cybank": {
        source: "iana"
      },
      "application/vnd.cyclonedx+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cyclonedx+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.d2l.coursepackage1p0+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.d3m-dataset": {
        source: "iana"
      },
      "application/vnd.d3m-problem": {
        source: "iana"
      },
      "application/vnd.dart": {
        source: "iana",
        compressible: true,
        extensions: ["dart"]
      },
      "application/vnd.data-vision.rdz": {
        source: "iana",
        extensions: ["rdz"]
      },
      "application/vnd.datalog": {
        source: "iana"
      },
      "application/vnd.datapackage+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dataresource+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dbf": {
        source: "iana",
        extensions: ["dbf"]
      },
      "application/vnd.dcmp+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dcmp"]
      },
      "application/vnd.debian.binary-package": {
        source: "iana"
      },
      "application/vnd.dece.data": {
        source: "iana",
        extensions: ["uvf", "uvvf", "uvd", "uvvd"]
      },
      "application/vnd.dece.ttml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["uvt", "uvvt"]
      },
      "application/vnd.dece.unspecified": {
        source: "iana",
        extensions: ["uvx", "uvvx"]
      },
      "application/vnd.dece.zip": {
        source: "iana",
        extensions: ["uvz", "uvvz"]
      },
      "application/vnd.denovo.fcselayout-link": {
        source: "iana",
        extensions: ["fe_launch"]
      },
      "application/vnd.desmume.movie": {
        source: "iana"
      },
      "application/vnd.dir-bi.plate-dl-nosuffix": {
        source: "iana"
      },
      "application/vnd.dm.delegation+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dna": {
        source: "iana",
        extensions: ["dna"]
      },
      "application/vnd.document+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dolby.mlp": {
        source: "apache",
        extensions: ["mlp"]
      },
      "application/vnd.dolby.mobile.1": {
        source: "iana"
      },
      "application/vnd.dolby.mobile.2": {
        source: "iana"
      },
      "application/vnd.doremir.scorecloud-binary-document": {
        source: "iana"
      },
      "application/vnd.dpgraph": {
        source: "iana",
        extensions: ["dpg"]
      },
      "application/vnd.dreamfactory": {
        source: "iana",
        extensions: ["dfac"]
      },
      "application/vnd.drive+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ds-keypoint": {
        source: "apache",
        extensions: ["kpxx"]
      },
      "application/vnd.dtg.local": {
        source: "iana"
      },
      "application/vnd.dtg.local.flash": {
        source: "iana"
      },
      "application/vnd.dtg.local.html": {
        source: "iana"
      },
      "application/vnd.dvb.ait": {
        source: "iana",
        extensions: ["ait"]
      },
      "application/vnd.dvb.dvbisl+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.dvbj": {
        source: "iana"
      },
      "application/vnd.dvb.esgcontainer": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcdftnotifaccess": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcesgaccess": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcesgaccess2": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcesgpdd": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcroaming": {
        source: "iana"
      },
      "application/vnd.dvb.iptv.alfec-base": {
        source: "iana"
      },
      "application/vnd.dvb.iptv.alfec-enhancement": {
        source: "iana"
      },
      "application/vnd.dvb.notif-aggregate-root+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-container+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-generic+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-ia-msglist+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-ia-registration-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-ia-registration-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-init+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.pfr": {
        source: "iana"
      },
      "application/vnd.dvb.service": {
        source: "iana",
        extensions: ["svc"]
      },
      "application/vnd.dxr": {
        source: "iana"
      },
      "application/vnd.dynageo": {
        source: "iana",
        extensions: ["geo"]
      },
      "application/vnd.dzr": {
        source: "iana"
      },
      "application/vnd.easykaraoke.cdgdownload": {
        source: "iana"
      },
      "application/vnd.ecdis-update": {
        source: "iana"
      },
      "application/vnd.ecip.rlp": {
        source: "iana"
      },
      "application/vnd.eclipse.ditto+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ecowin.chart": {
        source: "iana",
        extensions: ["mag"]
      },
      "application/vnd.ecowin.filerequest": {
        source: "iana"
      },
      "application/vnd.ecowin.fileupdate": {
        source: "iana"
      },
      "application/vnd.ecowin.series": {
        source: "iana"
      },
      "application/vnd.ecowin.seriesrequest": {
        source: "iana"
      },
      "application/vnd.ecowin.seriesupdate": {
        source: "iana"
      },
      "application/vnd.efi.img": {
        source: "iana"
      },
      "application/vnd.efi.iso": {
        source: "iana"
      },
      "application/vnd.eln+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.emclient.accessrequest+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.enliven": {
        source: "iana",
        extensions: ["nml"]
      },
      "application/vnd.enphase.envoy": {
        source: "iana"
      },
      "application/vnd.eprints.data+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.epson.esf": {
        source: "iana",
        extensions: ["esf"]
      },
      "application/vnd.epson.msf": {
        source: "iana",
        extensions: ["msf"]
      },
      "application/vnd.epson.quickanime": {
        source: "iana",
        extensions: ["qam"]
      },
      "application/vnd.epson.salt": {
        source: "iana",
        extensions: ["slt"]
      },
      "application/vnd.epson.ssf": {
        source: "iana",
        extensions: ["ssf"]
      },
      "application/vnd.ericsson.quickcall": {
        source: "iana"
      },
      "application/vnd.erofs": {
        source: "iana"
      },
      "application/vnd.espass-espass+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.eszigno3+xml": {
        source: "iana",
        compressible: true,
        extensions: ["es3", "et3"]
      },
      "application/vnd.etsi.aoc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.asic-e+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.etsi.asic-s+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.etsi.cug+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvcommand+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvdiscovery+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsad-bc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsad-cod+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsad-npvr+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvservice+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsync+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvueprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.mcid+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.mheg5": {
        source: "iana"
      },
      "application/vnd.etsi.overload-control-policy-dataset+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.pstn+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.sci+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.simservs+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.timestamp-token": {
        source: "iana"
      },
      "application/vnd.etsi.tsl+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.tsl.der": {
        source: "iana"
      },
      "application/vnd.eu.kasparian.car+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.eudora.data": {
        source: "iana"
      },
      "application/vnd.evolv.ecig.profile": {
        source: "iana"
      },
      "application/vnd.evolv.ecig.settings": {
        source: "iana"
      },
      "application/vnd.evolv.ecig.theme": {
        source: "iana"
      },
      "application/vnd.exstream-empower+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.exstream-package": {
        source: "iana"
      },
      "application/vnd.ezpix-album": {
        source: "iana",
        extensions: ["ez2"]
      },
      "application/vnd.ezpix-package": {
        source: "iana",
        extensions: ["ez3"]
      },
      "application/vnd.f-secure.mobile": {
        source: "iana"
      },
      "application/vnd.familysearch.gedcom+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.fastcopy-disk-image": {
        source: "iana"
      },
      "application/vnd.fdf": {
        source: "apache",
        extensions: ["fdf"]
      },
      "application/vnd.fdsn.mseed": {
        source: "iana",
        extensions: ["mseed"]
      },
      "application/vnd.fdsn.seed": {
        source: "iana",
        extensions: ["seed", "dataless"]
      },
      "application/vnd.fdsn.stationxml+xml": {
        source: "iana",
        charset: "XML-BASED",
        compressible: true
      },
      "application/vnd.ffsns": {
        source: "iana"
      },
      "application/vnd.ficlab.flb+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.filmit.zfc": {
        source: "iana"
      },
      "application/vnd.fints": {
        source: "iana"
      },
      "application/vnd.firemonkeys.cloudcell": {
        source: "iana"
      },
      "application/vnd.flographit": {
        source: "iana",
        extensions: ["gph"]
      },
      "application/vnd.fluxtime.clip": {
        source: "iana",
        extensions: ["ftc"]
      },
      "application/vnd.font-fontforge-sfd": {
        source: "iana"
      },
      "application/vnd.framemaker": {
        source: "iana",
        extensions: ["fm", "frame", "maker", "book"]
      },
      "application/vnd.freelog.comic": {
        source: "iana"
      },
      "application/vnd.frogans.fnc": {
        source: "apache",
        extensions: ["fnc"]
      },
      "application/vnd.frogans.ltf": {
        source: "apache",
        extensions: ["ltf"]
      },
      "application/vnd.fsc.weblaunch": {
        source: "iana",
        extensions: ["fsc"]
      },
      "application/vnd.fujifilm.fb.docuworks": {
        source: "iana"
      },
      "application/vnd.fujifilm.fb.docuworks.binder": {
        source: "iana"
      },
      "application/vnd.fujifilm.fb.docuworks.container": {
        source: "iana"
      },
      "application/vnd.fujifilm.fb.jfi+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.fujitsu.oasys": {
        source: "iana",
        extensions: ["oas"]
      },
      "application/vnd.fujitsu.oasys2": {
        source: "iana",
        extensions: ["oa2"]
      },
      "application/vnd.fujitsu.oasys3": {
        source: "iana",
        extensions: ["oa3"]
      },
      "application/vnd.fujitsu.oasysgp": {
        source: "iana",
        extensions: ["fg5"]
      },
      "application/vnd.fujitsu.oasysprs": {
        source: "iana",
        extensions: ["bh2"]
      },
      "application/vnd.fujixerox.art-ex": {
        source: "iana"
      },
      "application/vnd.fujixerox.art4": {
        source: "iana"
      },
      "application/vnd.fujixerox.ddd": {
        source: "iana",
        extensions: ["ddd"]
      },
      "application/vnd.fujixerox.docuworks": {
        source: "iana",
        extensions: ["xdw"]
      },
      "application/vnd.fujixerox.docuworks.binder": {
        source: "iana",
        extensions: ["xbd"]
      },
      "application/vnd.fujixerox.docuworks.container": {
        source: "iana"
      },
      "application/vnd.fujixerox.hbpl": {
        source: "iana"
      },
      "application/vnd.fut-misnet": {
        source: "iana"
      },
      "application/vnd.futoin+cbor": {
        source: "iana"
      },
      "application/vnd.futoin+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.fuzzysheet": {
        source: "iana",
        extensions: ["fzs"]
      },
      "application/vnd.ga4gh.passport+jwt": {
        source: "iana"
      },
      "application/vnd.genomatix.tuxedo": {
        source: "iana",
        extensions: ["txd"]
      },
      "application/vnd.genozip": {
        source: "iana"
      },
      "application/vnd.gentics.grd+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.gentoo.catmetadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.gentoo.ebuild": {
        source: "iana"
      },
      "application/vnd.gentoo.eclass": {
        source: "iana"
      },
      "application/vnd.gentoo.gpkg": {
        source: "iana"
      },
      "application/vnd.gentoo.manifest": {
        source: "iana"
      },
      "application/vnd.gentoo.pkgmetadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.gentoo.xpak": {
        source: "iana"
      },
      "application/vnd.geo+json": {
        source: "apache",
        compressible: true
      },
      "application/vnd.geocube+xml": {
        source: "apache",
        compressible: true
      },
      "application/vnd.geogebra.file": {
        source: "iana",
        extensions: ["ggb"]
      },
      "application/vnd.geogebra.pinboard": {
        source: "iana"
      },
      "application/vnd.geogebra.slides": {
        source: "iana",
        extensions: ["ggs"]
      },
      "application/vnd.geogebra.tool": {
        source: "iana",
        extensions: ["ggt"]
      },
      "application/vnd.geometry-explorer": {
        source: "iana",
        extensions: ["gex", "gre"]
      },
      "application/vnd.geonext": {
        source: "iana",
        extensions: ["gxt"]
      },
      "application/vnd.geoplan": {
        source: "iana",
        extensions: ["g2w"]
      },
      "application/vnd.geospace": {
        source: "iana",
        extensions: ["g3w"]
      },
      "application/vnd.gerber": {
        source: "iana"
      },
      "application/vnd.globalplatform.card-content-mgt": {
        source: "iana"
      },
      "application/vnd.globalplatform.card-content-mgt-response": {
        source: "iana"
      },
      "application/vnd.gmx": {
        source: "iana",
        extensions: ["gmx"]
      },
      "application/vnd.gnu.taler.exchange+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.gnu.taler.merchant+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.google-apps.audio": {},
      "application/vnd.google-apps.document": {
        compressible: false,
        extensions: ["gdoc"]
      },
      "application/vnd.google-apps.drawing": {
        compressible: false,
        extensions: ["gdraw"]
      },
      "application/vnd.google-apps.drive-sdk": {
        compressible: false
      },
      "application/vnd.google-apps.file": {},
      "application/vnd.google-apps.folder": {
        compressible: false
      },
      "application/vnd.google-apps.form": {
        compressible: false,
        extensions: ["gform"]
      },
      "application/vnd.google-apps.fusiontable": {},
      "application/vnd.google-apps.jam": {
        compressible: false,
        extensions: ["gjam"]
      },
      "application/vnd.google-apps.mail-layout": {},
      "application/vnd.google-apps.map": {
        compressible: false,
        extensions: ["gmap"]
      },
      "application/vnd.google-apps.photo": {},
      "application/vnd.google-apps.presentation": {
        compressible: false,
        extensions: ["gslides"]
      },
      "application/vnd.google-apps.script": {
        compressible: false,
        extensions: ["gscript"]
      },
      "application/vnd.google-apps.shortcut": {},
      "application/vnd.google-apps.site": {
        compressible: false,
        extensions: ["gsite"]
      },
      "application/vnd.google-apps.spreadsheet": {
        compressible: false,
        extensions: ["gsheet"]
      },
      "application/vnd.google-apps.unknown": {},
      "application/vnd.google-apps.video": {},
      "application/vnd.google-earth.kml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["kml"]
      },
      "application/vnd.google-earth.kmz": {
        source: "iana",
        compressible: false,
        extensions: ["kmz"]
      },
      "application/vnd.gov.sk.e-form+xml": {
        source: "apache",
        compressible: true
      },
      "application/vnd.gov.sk.e-form+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.gov.sk.xmldatacontainer+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdcf"]
      },
      "application/vnd.gpxsee.map+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.grafeq": {
        source: "iana",
        extensions: ["gqf", "gqs"]
      },
      "application/vnd.gridmp": {
        source: "iana"
      },
      "application/vnd.groove-account": {
        source: "iana",
        extensions: ["gac"]
      },
      "application/vnd.groove-help": {
        source: "iana",
        extensions: ["ghf"]
      },
      "application/vnd.groove-identity-message": {
        source: "iana",
        extensions: ["gim"]
      },
      "application/vnd.groove-injector": {
        source: "iana",
        extensions: ["grv"]
      },
      "application/vnd.groove-tool-message": {
        source: "iana",
        extensions: ["gtm"]
      },
      "application/vnd.groove-tool-template": {
        source: "iana",
        extensions: ["tpl"]
      },
      "application/vnd.groove-vcard": {
        source: "iana",
        extensions: ["vcg"]
      },
      "application/vnd.hal+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hal+xml": {
        source: "iana",
        compressible: true,
        extensions: ["hal"]
      },
      "application/vnd.handheld-entertainment+xml": {
        source: "iana",
        compressible: true,
        extensions: ["zmm"]
      },
      "application/vnd.hbci": {
        source: "iana",
        extensions: ["hbci"]
      },
      "application/vnd.hc+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hcl-bireports": {
        source: "iana"
      },
      "application/vnd.hdt": {
        source: "iana"
      },
      "application/vnd.heroku+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hhe.lesson-player": {
        source: "iana",
        extensions: ["les"]
      },
      "application/vnd.hp-hpgl": {
        source: "iana",
        extensions: ["hpgl"]
      },
      "application/vnd.hp-hpid": {
        source: "iana",
        extensions: ["hpid"]
      },
      "application/vnd.hp-hps": {
        source: "iana",
        extensions: ["hps"]
      },
      "application/vnd.hp-jlyt": {
        source: "iana",
        extensions: ["jlt"]
      },
      "application/vnd.hp-pcl": {
        source: "iana",
        extensions: ["pcl"]
      },
      "application/vnd.hp-pclxl": {
        source: "iana",
        extensions: ["pclxl"]
      },
      "application/vnd.hsl": {
        source: "iana"
      },
      "application/vnd.httphone": {
        source: "iana"
      },
      "application/vnd.hydrostatix.sof-data": {
        source: "iana",
        extensions: ["sfd-hdstx"]
      },
      "application/vnd.hyper+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hyper-item+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hyperdrive+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hzn-3d-crossword": {
        source: "iana"
      },
      "application/vnd.ibm.afplinedata": {
        source: "apache"
      },
      "application/vnd.ibm.electronic-media": {
        source: "iana"
      },
      "application/vnd.ibm.minipay": {
        source: "iana",
        extensions: ["mpy"]
      },
      "application/vnd.ibm.modcap": {
        source: "apache",
        extensions: ["afp", "listafp", "list3820"]
      },
      "application/vnd.ibm.rights-management": {
        source: "iana",
        extensions: ["irm"]
      },
      "application/vnd.ibm.secure-container": {
        source: "iana",
        extensions: ["sc"]
      },
      "application/vnd.iccprofile": {
        source: "iana",
        extensions: ["icc", "icm"]
      },
      "application/vnd.ieee.1905": {
        source: "iana"
      },
      "application/vnd.igloader": {
        source: "iana",
        extensions: ["igl"]
      },
      "application/vnd.imagemeter.folder+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.imagemeter.image+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.immervision-ivp": {
        source: "iana",
        extensions: ["ivp"]
      },
      "application/vnd.immervision-ivu": {
        source: "iana",
        extensions: ["ivu"]
      },
      "application/vnd.ims.imsccv1p1": {
        source: "iana"
      },
      "application/vnd.ims.imsccv1p2": {
        source: "iana"
      },
      "application/vnd.ims.imsccv1p3": {
        source: "iana"
      },
      "application/vnd.ims.lis.v2.result+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolconsumerprofile+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolproxy+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolproxy.id+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolsettings+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolsettings.simple+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.informedcontrol.rms+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.informix-visionary": {
        source: "apache"
      },
      "application/vnd.infotech.project": {
        source: "iana"
      },
      "application/vnd.infotech.project+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.innopath.wamp.notification": {
        source: "iana"
      },
      "application/vnd.insors.igm": {
        source: "iana",
        extensions: ["igm"]
      },
      "application/vnd.intercon.formnet": {
        source: "iana",
        extensions: ["xpw", "xpx"]
      },
      "application/vnd.intergeo": {
        source: "iana",
        extensions: ["i2g"]
      },
      "application/vnd.intertrust.digibox": {
        source: "iana"
      },
      "application/vnd.intertrust.nncp": {
        source: "iana"
      },
      "application/vnd.intu.qbo": {
        source: "iana",
        extensions: ["qbo"]
      },
      "application/vnd.intu.qfx": {
        source: "iana",
        extensions: ["qfx"]
      },
      "application/vnd.ipfs.ipns-record": {
        source: "iana"
      },
      "application/vnd.ipld.car": {
        source: "iana"
      },
      "application/vnd.ipld.dag-cbor": {
        source: "iana"
      },
      "application/vnd.ipld.dag-json": {
        source: "iana"
      },
      "application/vnd.ipld.raw": {
        source: "iana"
      },
      "application/vnd.iptc.g2.catalogitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.conceptitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.knowledgeitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.newsitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.newsmessage+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.packageitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.planningitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ipunplugged.rcprofile": {
        source: "iana",
        extensions: ["rcprofile"]
      },
      "application/vnd.irepository.package+xml": {
        source: "iana",
        compressible: true,
        extensions: ["irp"]
      },
      "application/vnd.is-xpr": {
        source: "iana",
        extensions: ["xpr"]
      },
      "application/vnd.isac.fcs": {
        source: "iana",
        extensions: ["fcs"]
      },
      "application/vnd.iso11783-10+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.jam": {
        source: "iana",
        extensions: ["jam"]
      },
      "application/vnd.japannet-directory-service": {
        source: "iana"
      },
      "application/vnd.japannet-jpnstore-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-payment-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-registration": {
        source: "iana"
      },
      "application/vnd.japannet-registration-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-setstore-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-verification": {
        source: "iana"
      },
      "application/vnd.japannet-verification-wakeup": {
        source: "iana"
      },
      "application/vnd.jcp.javame.midlet-rms": {
        source: "iana",
        extensions: ["rms"]
      },
      "application/vnd.jisp": {
        source: "iana",
        extensions: ["jisp"]
      },
      "application/vnd.joost.joda-archive": {
        source: "iana",
        extensions: ["joda"]
      },
      "application/vnd.jsk.isdn-ngn": {
        source: "iana"
      },
      "application/vnd.kahootz": {
        source: "iana",
        extensions: ["ktz", "ktr"]
      },
      "application/vnd.kde.karbon": {
        source: "iana",
        extensions: ["karbon"]
      },
      "application/vnd.kde.kchart": {
        source: "iana",
        extensions: ["chrt"]
      },
      "application/vnd.kde.kformula": {
        source: "iana",
        extensions: ["kfo"]
      },
      "application/vnd.kde.kivio": {
        source: "iana",
        extensions: ["flw"]
      },
      "application/vnd.kde.kontour": {
        source: "iana",
        extensions: ["kon"]
      },
      "application/vnd.kde.kpresenter": {
        source: "iana",
        extensions: ["kpr", "kpt"]
      },
      "application/vnd.kde.kspread": {
        source: "iana",
        extensions: ["ksp"]
      },
      "application/vnd.kde.kword": {
        source: "iana",
        extensions: ["kwd", "kwt"]
      },
      "application/vnd.kdl": {
        source: "iana"
      },
      "application/vnd.kenameaapp": {
        source: "iana",
        extensions: ["htke"]
      },
      "application/vnd.keyman.kmp+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.keyman.kmx": {
        source: "iana"
      },
      "application/vnd.kidspiration": {
        source: "iana",
        extensions: ["kia"]
      },
      "application/vnd.kinar": {
        source: "iana",
        extensions: ["kne", "knp"]
      },
      "application/vnd.koan": {
        source: "iana",
        extensions: ["skp", "skd", "skt", "skm"]
      },
      "application/vnd.kodak-descriptor": {
        source: "iana",
        extensions: ["sse"]
      },
      "application/vnd.las": {
        source: "iana"
      },
      "application/vnd.las.las+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.las.las+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lasxml"]
      },
      "application/vnd.laszip": {
        source: "iana"
      },
      "application/vnd.ldev.productlicensing": {
        source: "iana"
      },
      "application/vnd.leap+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.liberty-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.llamagraphics.life-balance.desktop": {
        source: "iana",
        extensions: ["lbd"]
      },
      "application/vnd.llamagraphics.life-balance.exchange+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lbe"]
      },
      "application/vnd.logipipe.circuit+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.loom": {
        source: "iana"
      },
      "application/vnd.lotus-1-2-3": {
        source: "iana",
        extensions: ["123"]
      },
      "application/vnd.lotus-approach": {
        source: "iana",
        extensions: ["apr"]
      },
      "application/vnd.lotus-freelance": {
        source: "iana",
        extensions: ["pre"]
      },
      "application/vnd.lotus-notes": {
        source: "iana",
        extensions: ["nsf"]
      },
      "application/vnd.lotus-organizer": {
        source: "iana",
        extensions: ["org"]
      },
      "application/vnd.lotus-screencam": {
        source: "iana",
        extensions: ["scm"]
      },
      "application/vnd.lotus-wordpro": {
        source: "iana",
        extensions: ["lwp"]
      },
      "application/vnd.macports.portpkg": {
        source: "iana",
        extensions: ["portpkg"]
      },
      "application/vnd.mapbox-vector-tile": {
        source: "iana",
        extensions: ["mvt"]
      },
      "application/vnd.marlin.drm.actiontoken+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.marlin.drm.conftoken+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.marlin.drm.license+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.marlin.drm.mdcf": {
        source: "iana"
      },
      "application/vnd.mason+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.maxar.archive.3tz+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.maxmind.maxmind-db": {
        source: "iana"
      },
      "application/vnd.mcd": {
        source: "iana",
        extensions: ["mcd"]
      },
      "application/vnd.mdl": {
        source: "iana"
      },
      "application/vnd.mdl-mbsdf": {
        source: "iana"
      },
      "application/vnd.medcalcdata": {
        source: "iana",
        extensions: ["mc1"]
      },
      "application/vnd.mediastation.cdkey": {
        source: "iana",
        extensions: ["cdkey"]
      },
      "application/vnd.medicalholodeck.recordxr": {
        source: "iana"
      },
      "application/vnd.meridian-slingshot": {
        source: "iana"
      },
      "application/vnd.mermaid": {
        source: "iana"
      },
      "application/vnd.mfer": {
        source: "iana",
        extensions: ["mwf"]
      },
      "application/vnd.mfmp": {
        source: "iana",
        extensions: ["mfm"]
      },
      "application/vnd.micro+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.micrografx.flo": {
        source: "iana",
        extensions: ["flo"]
      },
      "application/vnd.micrografx.igx": {
        source: "iana",
        extensions: ["igx"]
      },
      "application/vnd.microsoft.portable-executable": {
        source: "iana"
      },
      "application/vnd.microsoft.windows.thumbnail-cache": {
        source: "iana"
      },
      "application/vnd.miele+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.mif": {
        source: "iana",
        extensions: ["mif"]
      },
      "application/vnd.minisoft-hp3000-save": {
        source: "iana"
      },
      "application/vnd.mitsubishi.misty-guard.trustweb": {
        source: "iana"
      },
      "application/vnd.mobius.daf": {
        source: "iana",
        extensions: ["daf"]
      },
      "application/vnd.mobius.dis": {
        source: "iana",
        extensions: ["dis"]
      },
      "application/vnd.mobius.mbk": {
        source: "iana",
        extensions: ["mbk"]
      },
      "application/vnd.mobius.mqy": {
        source: "iana",
        extensions: ["mqy"]
      },
      "application/vnd.mobius.msl": {
        source: "iana",
        extensions: ["msl"]
      },
      "application/vnd.mobius.plc": {
        source: "iana",
        extensions: ["plc"]
      },
      "application/vnd.mobius.txf": {
        source: "iana",
        extensions: ["txf"]
      },
      "application/vnd.modl": {
        source: "iana"
      },
      "application/vnd.mophun.application": {
        source: "iana",
        extensions: ["mpn"]
      },
      "application/vnd.mophun.certificate": {
        source: "iana",
        extensions: ["mpc"]
      },
      "application/vnd.motorola.flexsuite": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.adsi": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.fis": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.gotap": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.kmr": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.ttc": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.wem": {
        source: "iana"
      },
      "application/vnd.motorola.iprm": {
        source: "iana"
      },
      "application/vnd.mozilla.xul+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xul"]
      },
      "application/vnd.ms-3mfdocument": {
        source: "iana"
      },
      "application/vnd.ms-artgalry": {
        source: "iana",
        extensions: ["cil"]
      },
      "application/vnd.ms-asf": {
        source: "iana"
      },
      "application/vnd.ms-cab-compressed": {
        source: "iana",
        extensions: ["cab"]
      },
      "application/vnd.ms-color.iccprofile": {
        source: "apache"
      },
      "application/vnd.ms-excel": {
        source: "iana",
        compressible: false,
        extensions: ["xls", "xlm", "xla", "xlc", "xlt", "xlw"]
      },
      "application/vnd.ms-excel.addin.macroenabled.12": {
        source: "iana",
        extensions: ["xlam"]
      },
      "application/vnd.ms-excel.sheet.binary.macroenabled.12": {
        source: "iana",
        extensions: ["xlsb"]
      },
      "application/vnd.ms-excel.sheet.macroenabled.12": {
        source: "iana",
        extensions: ["xlsm"]
      },
      "application/vnd.ms-excel.template.macroenabled.12": {
        source: "iana",
        extensions: ["xltm"]
      },
      "application/vnd.ms-fontobject": {
        source: "iana",
        compressible: true,
        extensions: ["eot"]
      },
      "application/vnd.ms-htmlhelp": {
        source: "iana",
        extensions: ["chm"]
      },
      "application/vnd.ms-ims": {
        source: "iana",
        extensions: ["ims"]
      },
      "application/vnd.ms-lrm": {
        source: "iana",
        extensions: ["lrm"]
      },
      "application/vnd.ms-office.activex+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-officetheme": {
        source: "iana",
        extensions: ["thmx"]
      },
      "application/vnd.ms-opentype": {
        source: "apache",
        compressible: true
      },
      "application/vnd.ms-outlook": {
        compressible: false,
        extensions: ["msg"]
      },
      "application/vnd.ms-package.obfuscated-opentype": {
        source: "apache"
      },
      "application/vnd.ms-pki.seccat": {
        source: "apache",
        extensions: ["cat"]
      },
      "application/vnd.ms-pki.stl": {
        source: "apache",
        extensions: ["stl"]
      },
      "application/vnd.ms-playready.initiator+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-powerpoint": {
        source: "iana",
        compressible: false,
        extensions: ["ppt", "pps", "pot"]
      },
      "application/vnd.ms-powerpoint.addin.macroenabled.12": {
        source: "iana",
        extensions: ["ppam"]
      },
      "application/vnd.ms-powerpoint.presentation.macroenabled.12": {
        source: "iana",
        extensions: ["pptm"]
      },
      "application/vnd.ms-powerpoint.slide.macroenabled.12": {
        source: "iana",
        extensions: ["sldm"]
      },
      "application/vnd.ms-powerpoint.slideshow.macroenabled.12": {
        source: "iana",
        extensions: ["ppsm"]
      },
      "application/vnd.ms-powerpoint.template.macroenabled.12": {
        source: "iana",
        extensions: ["potm"]
      },
      "application/vnd.ms-printdevicecapabilities+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-printing.printticket+xml": {
        source: "apache",
        compressible: true
      },
      "application/vnd.ms-printschematicket+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-project": {
        source: "iana",
        extensions: ["mpp", "mpt"]
      },
      "application/vnd.ms-tnef": {
        source: "iana"
      },
      "application/vnd.ms-visio.viewer": {
        extensions: ["vdx"]
      },
      "application/vnd.ms-windows.devicepairing": {
        source: "iana"
      },
      "application/vnd.ms-windows.nwprinting.oob": {
        source: "iana"
      },
      "application/vnd.ms-windows.printerpairing": {
        source: "iana"
      },
      "application/vnd.ms-windows.wsd.oob": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.lic-chlg-req": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.lic-resp": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.meter-chlg-req": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.meter-resp": {
        source: "iana"
      },
      "application/vnd.ms-word.document.macroenabled.12": {
        source: "iana",
        extensions: ["docm"]
      },
      "application/vnd.ms-word.template.macroenabled.12": {
        source: "iana",
        extensions: ["dotm"]
      },
      "application/vnd.ms-works": {
        source: "iana",
        extensions: ["wps", "wks", "wcm", "wdb"]
      },
      "application/vnd.ms-wpl": {
        source: "iana",
        extensions: ["wpl"]
      },
      "application/vnd.ms-xpsdocument": {
        source: "iana",
        compressible: false,
        extensions: ["xps"]
      },
      "application/vnd.msa-disk-image": {
        source: "iana"
      },
      "application/vnd.mseq": {
        source: "iana",
        extensions: ["mseq"]
      },
      "application/vnd.msgpack": {
        source: "iana"
      },
      "application/vnd.msign": {
        source: "iana"
      },
      "application/vnd.multiad.creator": {
        source: "iana"
      },
      "application/vnd.multiad.creator.cif": {
        source: "iana"
      },
      "application/vnd.music-niff": {
        source: "iana"
      },
      "application/vnd.musician": {
        source: "iana",
        extensions: ["mus"]
      },
      "application/vnd.muvee.style": {
        source: "iana",
        extensions: ["msty"]
      },
      "application/vnd.mynfc": {
        source: "iana",
        extensions: ["taglet"]
      },
      "application/vnd.nacamar.ybrid+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nato.bindingdataobject+cbor": {
        source: "iana"
      },
      "application/vnd.nato.bindingdataobject+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nato.bindingdataobject+xml": {
        source: "iana",
        compressible: true,
        extensions: ["bdo"]
      },
      "application/vnd.nato.openxmlformats-package.iepd+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.ncd.control": {
        source: "iana"
      },
      "application/vnd.ncd.reference": {
        source: "iana"
      },
      "application/vnd.nearst.inv+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nebumind.line": {
        source: "iana"
      },
      "application/vnd.nervana": {
        source: "iana"
      },
      "application/vnd.netfpx": {
        source: "iana"
      },
      "application/vnd.neurolanguage.nlu": {
        source: "iana",
        extensions: ["nlu"]
      },
      "application/vnd.nimn": {
        source: "iana"
      },
      "application/vnd.nintendo.nitro.rom": {
        source: "iana"
      },
      "application/vnd.nintendo.snes.rom": {
        source: "iana"
      },
      "application/vnd.nitf": {
        source: "iana",
        extensions: ["ntf", "nitf"]
      },
      "application/vnd.noblenet-directory": {
        source: "iana",
        extensions: ["nnd"]
      },
      "application/vnd.noblenet-sealer": {
        source: "iana",
        extensions: ["nns"]
      },
      "application/vnd.noblenet-web": {
        source: "iana",
        extensions: ["nnw"]
      },
      "application/vnd.nokia.catalogs": {
        source: "iana"
      },
      "application/vnd.nokia.conml+wbxml": {
        source: "iana"
      },
      "application/vnd.nokia.conml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.iptv.config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.isds-radio-presets": {
        source: "iana"
      },
      "application/vnd.nokia.landmark+wbxml": {
        source: "iana"
      },
      "application/vnd.nokia.landmark+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.landmarkcollection+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.n-gage.ac+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ac"]
      },
      "application/vnd.nokia.n-gage.data": {
        source: "iana",
        extensions: ["ngdat"]
      },
      "application/vnd.nokia.n-gage.symbian.install": {
        source: "apache",
        extensions: ["n-gage"]
      },
      "application/vnd.nokia.ncd": {
        source: "iana"
      },
      "application/vnd.nokia.pcd+wbxml": {
        source: "iana"
      },
      "application/vnd.nokia.pcd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.radio-preset": {
        source: "iana",
        extensions: ["rpst"]
      },
      "application/vnd.nokia.radio-presets": {
        source: "iana",
        extensions: ["rpss"]
      },
      "application/vnd.novadigm.edm": {
        source: "iana",
        extensions: ["edm"]
      },
      "application/vnd.novadigm.edx": {
        source: "iana",
        extensions: ["edx"]
      },
      "application/vnd.novadigm.ext": {
        source: "iana",
        extensions: ["ext"]
      },
      "application/vnd.ntt-local.content-share": {
        source: "iana"
      },
      "application/vnd.ntt-local.file-transfer": {
        source: "iana"
      },
      "application/vnd.ntt-local.ogw_remote-access": {
        source: "iana"
      },
      "application/vnd.ntt-local.sip-ta_remote": {
        source: "iana"
      },
      "application/vnd.ntt-local.sip-ta_tcp_stream": {
        source: "iana"
      },
      "application/vnd.oai.workflows": {
        source: "iana"
      },
      "application/vnd.oai.workflows+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oai.workflows+yaml": {
        source: "iana"
      },
      "application/vnd.oasis.opendocument.base": {
        source: "iana"
      },
      "application/vnd.oasis.opendocument.chart": {
        source: "iana",
        extensions: ["odc"]
      },
      "application/vnd.oasis.opendocument.chart-template": {
        source: "iana",
        extensions: ["otc"]
      },
      "application/vnd.oasis.opendocument.database": {
        source: "apache",
        extensions: ["odb"]
      },
      "application/vnd.oasis.opendocument.formula": {
        source: "iana",
        extensions: ["odf"]
      },
      "application/vnd.oasis.opendocument.formula-template": {
        source: "iana",
        extensions: ["odft"]
      },
      "application/vnd.oasis.opendocument.graphics": {
        source: "iana",
        compressible: false,
        extensions: ["odg"]
      },
      "application/vnd.oasis.opendocument.graphics-template": {
        source: "iana",
        extensions: ["otg"]
      },
      "application/vnd.oasis.opendocument.image": {
        source: "iana",
        extensions: ["odi"]
      },
      "application/vnd.oasis.opendocument.image-template": {
        source: "iana",
        extensions: ["oti"]
      },
      "application/vnd.oasis.opendocument.presentation": {
        source: "iana",
        compressible: false,
        extensions: ["odp"]
      },
      "application/vnd.oasis.opendocument.presentation-template": {
        source: "iana",
        extensions: ["otp"]
      },
      "application/vnd.oasis.opendocument.spreadsheet": {
        source: "iana",
        compressible: false,
        extensions: ["ods"]
      },
      "application/vnd.oasis.opendocument.spreadsheet-template": {
        source: "iana",
        extensions: ["ots"]
      },
      "application/vnd.oasis.opendocument.text": {
        source: "iana",
        compressible: false,
        extensions: ["odt"]
      },
      "application/vnd.oasis.opendocument.text-master": {
        source: "iana",
        extensions: ["odm"]
      },
      "application/vnd.oasis.opendocument.text-master-template": {
        source: "iana"
      },
      "application/vnd.oasis.opendocument.text-template": {
        source: "iana",
        extensions: ["ott"]
      },
      "application/vnd.oasis.opendocument.text-web": {
        source: "iana",
        extensions: ["oth"]
      },
      "application/vnd.obn": {
        source: "iana"
      },
      "application/vnd.ocf+cbor": {
        source: "iana"
      },
      "application/vnd.oci.image.manifest.v1+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oftn.l10n+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.contentaccessdownload+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.contentaccessstreaming+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.cspg-hexbinary": {
        source: "iana"
      },
      "application/vnd.oipf.dae.svg+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.dae.xhtml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.mippvcontrolmessage+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.pae.gem": {
        source: "iana"
      },
      "application/vnd.oipf.spdiscovery+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.spdlist+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.ueprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.userprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.olpc-sugar": {
        source: "iana",
        extensions: ["xo"]
      },
      "application/vnd.oma-scws-config": {
        source: "iana"
      },
      "application/vnd.oma-scws-http-request": {
        source: "iana"
      },
      "application/vnd.oma-scws-http-response": {
        source: "iana"
      },
      "application/vnd.oma.bcast.associated-procedure-parameter+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.drm-trigger+xml": {
        source: "apache",
        compressible: true
      },
      "application/vnd.oma.bcast.imd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.ltkm": {
        source: "iana"
      },
      "application/vnd.oma.bcast.notification+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.provisioningtrigger": {
        source: "iana"
      },
      "application/vnd.oma.bcast.sgboot": {
        source: "iana"
      },
      "application/vnd.oma.bcast.sgdd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.sgdu": {
        source: "iana"
      },
      "application/vnd.oma.bcast.simple-symbol-container": {
        source: "iana"
      },
      "application/vnd.oma.bcast.smartcard-trigger+xml": {
        source: "apache",
        compressible: true
      },
      "application/vnd.oma.bcast.sprov+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.stkm": {
        source: "iana"
      },
      "application/vnd.oma.cab-address-book+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-feature-handler+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-pcc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-subs-invite+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-user-prefs+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.dcd": {
        source: "iana"
      },
      "application/vnd.oma.dcdc": {
        source: "iana"
      },
      "application/vnd.oma.dd2+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dd2"]
      },
      "application/vnd.oma.drm.risd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.group-usage-list+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.lwm2m+cbor": {
        source: "iana"
      },
      "application/vnd.oma.lwm2m+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.lwm2m+tlv": {
        source: "iana"
      },
      "application/vnd.oma.pal+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.detailed-progress-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.final-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.groups+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.invocation-descriptor+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.optimized-progress-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.push": {
        source: "iana"
      },
      "application/vnd.oma.scidm.messages+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.xcap-directory+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.omads-email+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.omads-file+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.omads-folder+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.omaloc-supl-init": {
        source: "iana"
      },
      "application/vnd.onepager": {
        source: "iana"
      },
      "application/vnd.onepagertamp": {
        source: "iana"
      },
      "application/vnd.onepagertamx": {
        source: "iana"
      },
      "application/vnd.onepagertat": {
        source: "iana"
      },
      "application/vnd.onepagertatp": {
        source: "iana"
      },
      "application/vnd.onepagertatx": {
        source: "iana"
      },
      "application/vnd.onvif.metadata": {
        source: "iana"
      },
      "application/vnd.openblox.game+xml": {
        source: "iana",
        compressible: true,
        extensions: ["obgx"]
      },
      "application/vnd.openblox.game-binary": {
        source: "iana"
      },
      "application/vnd.openeye.oeb": {
        source: "iana"
      },
      "application/vnd.openofficeorg.extension": {
        source: "apache",
        extensions: ["oxt"]
      },
      "application/vnd.openstreetmap.data+xml": {
        source: "iana",
        compressible: true,
        extensions: ["osm"]
      },
      "application/vnd.opentimestamps.ots": {
        source: "iana"
      },
      "application/vnd.openvpi.dspx+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.custom-properties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawing+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.extended-properties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.presentation": {
        source: "iana",
        compressible: false,
        extensions: ["pptx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slide": {
        source: "iana",
        extensions: ["sldx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slideshow": {
        source: "iana",
        extensions: ["ppsx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.template": {
        source: "iana",
        extensions: ["potx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": {
        source: "iana",
        compressible: false,
        extensions: ["xlsx"]
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.template": {
        source: "iana",
        extensions: ["xltx"]
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.theme+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.themeoverride+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.vmldrawing": {
        source: "iana"
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document": {
        source: "iana",
        compressible: false,
        extensions: ["docx"]
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.template": {
        source: "iana",
        extensions: ["dotx"]
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-package.core-properties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-package.relationships+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oracle.resource+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.orange.indata": {
        source: "iana"
      },
      "application/vnd.osa.netdeploy": {
        source: "iana"
      },
      "application/vnd.osgeo.mapguide.package": {
        source: "iana",
        extensions: ["mgp"]
      },
      "application/vnd.osgi.bundle": {
        source: "iana"
      },
      "application/vnd.osgi.dp": {
        source: "iana",
        extensions: ["dp"]
      },
      "application/vnd.osgi.subsystem": {
        source: "iana",
        extensions: ["esa"]
      },
      "application/vnd.otps.ct-kip+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oxli.countgraph": {
        source: "iana"
      },
      "application/vnd.pagerduty+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.palm": {
        source: "iana",
        extensions: ["pdb", "pqa", "oprc"]
      },
      "application/vnd.panoply": {
        source: "iana"
      },
      "application/vnd.paos.xml": {
        source: "iana"
      },
      "application/vnd.patentdive": {
        source: "iana"
      },
      "application/vnd.patientecommsdoc": {
        source: "iana"
      },
      "application/vnd.pawaafile": {
        source: "iana",
        extensions: ["paw"]
      },
      "application/vnd.pcos": {
        source: "iana"
      },
      "application/vnd.pg.format": {
        source: "iana",
        extensions: ["str"]
      },
      "application/vnd.pg.osasli": {
        source: "iana",
        extensions: ["ei6"]
      },
      "application/vnd.piaccess.application-licence": {
        source: "iana"
      },
      "application/vnd.picsel": {
        source: "iana",
        extensions: ["efif"]
      },
      "application/vnd.pmi.widget": {
        source: "iana",
        extensions: ["wg"]
      },
      "application/vnd.poc.group-advertisement+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.pocketlearn": {
        source: "iana",
        extensions: ["plf"]
      },
      "application/vnd.powerbuilder6": {
        source: "iana",
        extensions: ["pbd"]
      },
      "application/vnd.powerbuilder6-s": {
        source: "iana"
      },
      "application/vnd.powerbuilder7": {
        source: "iana"
      },
      "application/vnd.powerbuilder7-s": {
        source: "iana"
      },
      "application/vnd.powerbuilder75": {
        source: "iana"
      },
      "application/vnd.powerbuilder75-s": {
        source: "iana"
      },
      "application/vnd.preminet": {
        source: "iana"
      },
      "application/vnd.previewsystems.box": {
        source: "iana",
        extensions: ["box"]
      },
      "application/vnd.procrate.brushset": {
        extensions: ["brushset"]
      },
      "application/vnd.procreate.brush": {
        extensions: ["brush"]
      },
      "application/vnd.procreate.dream": {
        extensions: ["drm"]
      },
      "application/vnd.proteus.magazine": {
        source: "iana",
        extensions: ["mgz"]
      },
      "application/vnd.psfs": {
        source: "iana"
      },
      "application/vnd.pt.mundusmundi": {
        source: "iana"
      },
      "application/vnd.publishare-delta-tree": {
        source: "iana",
        extensions: ["qps"]
      },
      "application/vnd.pvi.ptid1": {
        source: "iana",
        extensions: ["ptid"]
      },
      "application/vnd.pwg-multiplexed": {
        source: "iana"
      },
      "application/vnd.pwg-xhtml-print+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xhtm"]
      },
      "application/vnd.qualcomm.brew-app-res": {
        source: "iana"
      },
      "application/vnd.quarantainenet": {
        source: "iana"
      },
      "application/vnd.quark.quarkxpress": {
        source: "iana",
        extensions: ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"]
      },
      "application/vnd.quobject-quoxdocument": {
        source: "iana"
      },
      "application/vnd.radisys.moml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-conf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-conn+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-dialog+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-stream+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-conf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-base+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-fax-detect+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-group+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-speech+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-transform+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.rainstor.data": {
        source: "iana"
      },
      "application/vnd.rapid": {
        source: "iana"
      },
      "application/vnd.rar": {
        source: "iana",
        extensions: ["rar"]
      },
      "application/vnd.realvnc.bed": {
        source: "iana",
        extensions: ["bed"]
      },
      "application/vnd.recordare.musicxml": {
        source: "iana",
        extensions: ["mxl"]
      },
      "application/vnd.recordare.musicxml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["musicxml"]
      },
      "application/vnd.relpipe": {
        source: "iana"
      },
      "application/vnd.renlearn.rlprint": {
        source: "iana"
      },
      "application/vnd.resilient.logic": {
        source: "iana"
      },
      "application/vnd.restful+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.rig.cryptonote": {
        source: "iana",
        extensions: ["cryptonote"]
      },
      "application/vnd.rim.cod": {
        source: "apache",
        extensions: ["cod"]
      },
      "application/vnd.rn-realmedia": {
        source: "apache",
        extensions: ["rm"]
      },
      "application/vnd.rn-realmedia-vbr": {
        source: "apache",
        extensions: ["rmvb"]
      },
      "application/vnd.route66.link66+xml": {
        source: "iana",
        compressible: true,
        extensions: ["link66"]
      },
      "application/vnd.rs-274x": {
        source: "iana"
      },
      "application/vnd.ruckus.download": {
        source: "iana"
      },
      "application/vnd.s3sms": {
        source: "iana"
      },
      "application/vnd.sailingtracker.track": {
        source: "iana",
        extensions: ["st"]
      },
      "application/vnd.sar": {
        source: "iana"
      },
      "application/vnd.sbm.cid": {
        source: "iana"
      },
      "application/vnd.sbm.mid2": {
        source: "iana"
      },
      "application/vnd.scribus": {
        source: "iana"
      },
      "application/vnd.sealed.3df": {
        source: "iana"
      },
      "application/vnd.sealed.csf": {
        source: "iana"
      },
      "application/vnd.sealed.doc": {
        source: "iana"
      },
      "application/vnd.sealed.eml": {
        source: "iana"
      },
      "application/vnd.sealed.mht": {
        source: "iana"
      },
      "application/vnd.sealed.net": {
        source: "iana"
      },
      "application/vnd.sealed.ppt": {
        source: "iana"
      },
      "application/vnd.sealed.tiff": {
        source: "iana"
      },
      "application/vnd.sealed.xls": {
        source: "iana"
      },
      "application/vnd.sealedmedia.softseal.html": {
        source: "iana"
      },
      "application/vnd.sealedmedia.softseal.pdf": {
        source: "iana"
      },
      "application/vnd.seemail": {
        source: "iana",
        extensions: ["see"]
      },
      "application/vnd.seis+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.sema": {
        source: "iana",
        extensions: ["sema"]
      },
      "application/vnd.semd": {
        source: "iana",
        extensions: ["semd"]
      },
      "application/vnd.semf": {
        source: "iana",
        extensions: ["semf"]
      },
      "application/vnd.shade-save-file": {
        source: "iana"
      },
      "application/vnd.shana.informed.formdata": {
        source: "iana",
        extensions: ["ifm"]
      },
      "application/vnd.shana.informed.formtemplate": {
        source: "iana",
        extensions: ["itp"]
      },
      "application/vnd.shana.informed.interchange": {
        source: "iana",
        extensions: ["iif"]
      },
      "application/vnd.shana.informed.package": {
        source: "iana",
        extensions: ["ipk"]
      },
      "application/vnd.shootproof+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.shopkick+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.shp": {
        source: "iana"
      },
      "application/vnd.shx": {
        source: "iana"
      },
      "application/vnd.sigrok.session": {
        source: "iana"
      },
      "application/vnd.simtech-mindmapper": {
        source: "iana",
        extensions: ["twd", "twds"]
      },
      "application/vnd.siren+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.sketchometry": {
        source: "iana"
      },
      "application/vnd.smaf": {
        source: "iana",
        extensions: ["mmf"]
      },
      "application/vnd.smart.notebook": {
        source: "iana"
      },
      "application/vnd.smart.teacher": {
        source: "iana",
        extensions: ["teacher"]
      },
      "application/vnd.smintio.portals.archive": {
        source: "iana"
      },
      "application/vnd.snesdev-page-table": {
        source: "iana"
      },
      "application/vnd.software602.filler.form+xml": {
        source: "iana",
        compressible: true,
        extensions: ["fo"]
      },
      "application/vnd.software602.filler.form-xml-zip": {
        source: "iana"
      },
      "application/vnd.solent.sdkm+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sdkm", "sdkd"]
      },
      "application/vnd.spotfire.dxp": {
        source: "iana",
        extensions: ["dxp"]
      },
      "application/vnd.spotfire.sfs": {
        source: "iana",
        extensions: ["sfs"]
      },
      "application/vnd.sqlite3": {
        source: "iana"
      },
      "application/vnd.sss-cod": {
        source: "iana"
      },
      "application/vnd.sss-dtf": {
        source: "iana"
      },
      "application/vnd.sss-ntf": {
        source: "iana"
      },
      "application/vnd.stardivision.calc": {
        source: "apache",
        extensions: ["sdc"]
      },
      "application/vnd.stardivision.draw": {
        source: "apache",
        extensions: ["sda"]
      },
      "application/vnd.stardivision.impress": {
        source: "apache",
        extensions: ["sdd"]
      },
      "application/vnd.stardivision.math": {
        source: "apache",
        extensions: ["smf"]
      },
      "application/vnd.stardivision.writer": {
        source: "apache",
        extensions: ["sdw", "vor"]
      },
      "application/vnd.stardivision.writer-global": {
        source: "apache",
        extensions: ["sgl"]
      },
      "application/vnd.stepmania.package": {
        source: "iana",
        extensions: ["smzip"]
      },
      "application/vnd.stepmania.stepchart": {
        source: "iana",
        extensions: ["sm"]
      },
      "application/vnd.street-stream": {
        source: "iana"
      },
      "application/vnd.sun.wadl+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wadl"]
      },
      "application/vnd.sun.xml.calc": {
        source: "apache",
        extensions: ["sxc"]
      },
      "application/vnd.sun.xml.calc.template": {
        source: "apache",
        extensions: ["stc"]
      },
      "application/vnd.sun.xml.draw": {
        source: "apache",
        extensions: ["sxd"]
      },
      "application/vnd.sun.xml.draw.template": {
        source: "apache",
        extensions: ["std"]
      },
      "application/vnd.sun.xml.impress": {
        source: "apache",
        extensions: ["sxi"]
      },
      "application/vnd.sun.xml.impress.template": {
        source: "apache",
        extensions: ["sti"]
      },
      "application/vnd.sun.xml.math": {
        source: "apache",
        extensions: ["sxm"]
      },
      "application/vnd.sun.xml.writer": {
        source: "apache",
        extensions: ["sxw"]
      },
      "application/vnd.sun.xml.writer.global": {
        source: "apache",
        extensions: ["sxg"]
      },
      "application/vnd.sun.xml.writer.template": {
        source: "apache",
        extensions: ["stw"]
      },
      "application/vnd.sus-calendar": {
        source: "iana",
        extensions: ["sus", "susp"]
      },
      "application/vnd.svd": {
        source: "iana",
        extensions: ["svd"]
      },
      "application/vnd.swiftview-ics": {
        source: "iana"
      },
      "application/vnd.sybyl.mol2": {
        source: "iana"
      },
      "application/vnd.sycle+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.syft+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.symbian.install": {
        source: "apache",
        extensions: ["sis", "sisx"]
      },
      "application/vnd.syncml+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["xsm"]
      },
      "application/vnd.syncml.dm+wbxml": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["bdm"]
      },
      "application/vnd.syncml.dm+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["xdm"]
      },
      "application/vnd.syncml.dm.notification": {
        source: "iana"
      },
      "application/vnd.syncml.dmddf+wbxml": {
        source: "iana"
      },
      "application/vnd.syncml.dmddf+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["ddf"]
      },
      "application/vnd.syncml.dmtnds+wbxml": {
        source: "iana"
      },
      "application/vnd.syncml.dmtnds+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.syncml.ds.notification": {
        source: "iana"
      },
      "application/vnd.tableschema+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.tao.intent-module-archive": {
        source: "iana",
        extensions: ["tao"]
      },
      "application/vnd.tcpdump.pcap": {
        source: "iana",
        extensions: ["pcap", "cap", "dmp"]
      },
      "application/vnd.think-cell.ppttc+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.tmd.mediaflex.api+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.tml": {
        source: "iana"
      },
      "application/vnd.tmobile-livetv": {
        source: "iana",
        extensions: ["tmo"]
      },
      "application/vnd.tri.onesource": {
        source: "iana"
      },
      "application/vnd.trid.tpt": {
        source: "iana",
        extensions: ["tpt"]
      },
      "application/vnd.triscape.mxs": {
        source: "iana",
        extensions: ["mxs"]
      },
      "application/vnd.trueapp": {
        source: "iana",
        extensions: ["tra"]
      },
      "application/vnd.truedoc": {
        source: "iana"
      },
      "application/vnd.ubisoft.webplayer": {
        source: "iana"
      },
      "application/vnd.ufdl": {
        source: "iana",
        extensions: ["ufd", "ufdl"]
      },
      "application/vnd.uic.osdm+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.uiq.theme": {
        source: "iana",
        extensions: ["utz"]
      },
      "application/vnd.umajin": {
        source: "iana",
        extensions: ["umj"]
      },
      "application/vnd.unity": {
        source: "iana",
        extensions: ["unityweb"]
      },
      "application/vnd.uoml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["uoml", "uo"]
      },
      "application/vnd.uplanet.alert": {
        source: "iana"
      },
      "application/vnd.uplanet.alert-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.bearer-choice": {
        source: "iana"
      },
      "application/vnd.uplanet.bearer-choice-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.cacheop": {
        source: "iana"
      },
      "application/vnd.uplanet.cacheop-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.channel": {
        source: "iana"
      },
      "application/vnd.uplanet.channel-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.list": {
        source: "iana"
      },
      "application/vnd.uplanet.list-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.listcmd": {
        source: "iana"
      },
      "application/vnd.uplanet.listcmd-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.signal": {
        source: "iana"
      },
      "application/vnd.uri-map": {
        source: "iana"
      },
      "application/vnd.valve.source.material": {
        source: "iana"
      },
      "application/vnd.vcx": {
        source: "iana",
        extensions: ["vcx"]
      },
      "application/vnd.vd-study": {
        source: "iana"
      },
      "application/vnd.vectorworks": {
        source: "iana"
      },
      "application/vnd.vel+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.veraison.tsm-report+cbor": {
        source: "iana"
      },
      "application/vnd.veraison.tsm-report+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.verimatrix.vcas": {
        source: "iana"
      },
      "application/vnd.veritone.aion+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.veryant.thin": {
        source: "iana"
      },
      "application/vnd.ves.encrypted": {
        source: "iana"
      },
      "application/vnd.vidsoft.vidconference": {
        source: "iana"
      },
      "application/vnd.visio": {
        source: "iana",
        extensions: ["vsd", "vst", "vss", "vsw", "vsdx", "vtx"]
      },
      "application/vnd.visionary": {
        source: "iana",
        extensions: ["vis"]
      },
      "application/vnd.vividence.scriptfile": {
        source: "iana"
      },
      "application/vnd.vocalshaper.vsp4": {
        source: "iana"
      },
      "application/vnd.vsf": {
        source: "iana",
        extensions: ["vsf"]
      },
      "application/vnd.wap.sic": {
        source: "iana"
      },
      "application/vnd.wap.slc": {
        source: "iana"
      },
      "application/vnd.wap.wbxml": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["wbxml"]
      },
      "application/vnd.wap.wmlc": {
        source: "iana",
        extensions: ["wmlc"]
      },
      "application/vnd.wap.wmlscriptc": {
        source: "iana",
        extensions: ["wmlsc"]
      },
      "application/vnd.wasmflow.wafl": {
        source: "iana"
      },
      "application/vnd.webturbo": {
        source: "iana",
        extensions: ["wtb"]
      },
      "application/vnd.wfa.dpp": {
        source: "iana"
      },
      "application/vnd.wfa.p2p": {
        source: "iana"
      },
      "application/vnd.wfa.wsc": {
        source: "iana"
      },
      "application/vnd.windows.devicepairing": {
        source: "iana"
      },
      "application/vnd.wmc": {
        source: "iana"
      },
      "application/vnd.wmf.bootstrap": {
        source: "iana"
      },
      "application/vnd.wolfram.mathematica": {
        source: "iana"
      },
      "application/vnd.wolfram.mathematica.package": {
        source: "iana"
      },
      "application/vnd.wolfram.player": {
        source: "iana",
        extensions: ["nbp"]
      },
      "application/vnd.wordlift": {
        source: "iana"
      },
      "application/vnd.wordperfect": {
        source: "iana",
        extensions: ["wpd"]
      },
      "application/vnd.wqd": {
        source: "iana",
        extensions: ["wqd"]
      },
      "application/vnd.wrq-hp3000-labelled": {
        source: "iana"
      },
      "application/vnd.wt.stf": {
        source: "iana",
        extensions: ["stf"]
      },
      "application/vnd.wv.csp+wbxml": {
        source: "iana"
      },
      "application/vnd.wv.csp+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.wv.ssp+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.xacml+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.xara": {
        source: "iana",
        extensions: ["xar"]
      },
      "application/vnd.xarin.cpj": {
        source: "iana"
      },
      "application/vnd.xecrets-encrypted": {
        source: "iana"
      },
      "application/vnd.xfdl": {
        source: "iana",
        extensions: ["xfdl"]
      },
      "application/vnd.xfdl.webform": {
        source: "iana"
      },
      "application/vnd.xmi+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.xmpie.cpkg": {
        source: "iana"
      },
      "application/vnd.xmpie.dpkg": {
        source: "iana"
      },
      "application/vnd.xmpie.plan": {
        source: "iana"
      },
      "application/vnd.xmpie.ppkg": {
        source: "iana"
      },
      "application/vnd.xmpie.xlim": {
        source: "iana"
      },
      "application/vnd.yamaha.hv-dic": {
        source: "iana",
        extensions: ["hvd"]
      },
      "application/vnd.yamaha.hv-script": {
        source: "iana",
        extensions: ["hvs"]
      },
      "application/vnd.yamaha.hv-voice": {
        source: "iana",
        extensions: ["hvp"]
      },
      "application/vnd.yamaha.openscoreformat": {
        source: "iana",
        extensions: ["osf"]
      },
      "application/vnd.yamaha.openscoreformat.osfpvg+xml": {
        source: "iana",
        compressible: true,
        extensions: ["osfpvg"]
      },
      "application/vnd.yamaha.remote-setup": {
        source: "iana"
      },
      "application/vnd.yamaha.smaf-audio": {
        source: "iana",
        extensions: ["saf"]
      },
      "application/vnd.yamaha.smaf-phrase": {
        source: "iana",
        extensions: ["spf"]
      },
      "application/vnd.yamaha.through-ngn": {
        source: "iana"
      },
      "application/vnd.yamaha.tunnel-udpencap": {
        source: "iana"
      },
      "application/vnd.yaoweme": {
        source: "iana"
      },
      "application/vnd.yellowriver-custom-menu": {
        source: "iana",
        extensions: ["cmp"]
      },
      "application/vnd.zul": {
        source: "iana",
        extensions: ["zir", "zirz"]
      },
      "application/vnd.zzazz.deck+xml": {
        source: "iana",
        compressible: true,
        extensions: ["zaz"]
      },
      "application/voicexml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["vxml"]
      },
      "application/voucher-cms+json": {
        source: "iana",
        compressible: true
      },
      "application/voucher-jws+json": {
        source: "iana",
        compressible: true
      },
      "application/vp": {
        source: "iana"
      },
      "application/vp+cose": {
        source: "iana"
      },
      "application/vp+jwt": {
        source: "iana"
      },
      "application/vq-rtcpxr": {
        source: "iana"
      },
      "application/wasm": {
        source: "iana",
        compressible: true,
        extensions: ["wasm"]
      },
      "application/watcherinfo+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wif"]
      },
      "application/webpush-options+json": {
        source: "iana",
        compressible: true
      },
      "application/whoispp-query": {
        source: "iana"
      },
      "application/whoispp-response": {
        source: "iana"
      },
      "application/widget": {
        source: "iana",
        extensions: ["wgt"]
      },
      "application/winhlp": {
        source: "apache",
        extensions: ["hlp"]
      },
      "application/wita": {
        source: "iana"
      },
      "application/wordperfect5.1": {
        source: "iana"
      },
      "application/wsdl+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wsdl"]
      },
      "application/wspolicy+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wspolicy"]
      },
      "application/x-7z-compressed": {
        source: "apache",
        compressible: false,
        extensions: ["7z"]
      },
      "application/x-abiword": {
        source: "apache",
        extensions: ["abw"]
      },
      "application/x-ace-compressed": {
        source: "apache",
        extensions: ["ace"]
      },
      "application/x-amf": {
        source: "apache"
      },
      "application/x-apple-diskimage": {
        source: "apache",
        extensions: ["dmg"]
      },
      "application/x-arj": {
        compressible: false,
        extensions: ["arj"]
      },
      "application/x-authorware-bin": {
        source: "apache",
        extensions: ["aab", "x32", "u32", "vox"]
      },
      "application/x-authorware-map": {
        source: "apache",
        extensions: ["aam"]
      },
      "application/x-authorware-seg": {
        source: "apache",
        extensions: ["aas"]
      },
      "application/x-bcpio": {
        source: "apache",
        extensions: ["bcpio"]
      },
      "application/x-bdoc": {
        compressible: false,
        extensions: ["bdoc"]
      },
      "application/x-bittorrent": {
        source: "apache",
        extensions: ["torrent"]
      },
      "application/x-blender": {
        extensions: ["blend"]
      },
      "application/x-blorb": {
        source: "apache",
        extensions: ["blb", "blorb"]
      },
      "application/x-bzip": {
        source: "apache",
        compressible: false,
        extensions: ["bz"]
      },
      "application/x-bzip2": {
        source: "apache",
        compressible: false,
        extensions: ["bz2", "boz"]
      },
      "application/x-cbr": {
        source: "apache",
        extensions: ["cbr", "cba", "cbt", "cbz", "cb7"]
      },
      "application/x-cdlink": {
        source: "apache",
        extensions: ["vcd"]
      },
      "application/x-cfs-compressed": {
        source: "apache",
        extensions: ["cfs"]
      },
      "application/x-chat": {
        source: "apache",
        extensions: ["chat"]
      },
      "application/x-chess-pgn": {
        source: "apache",
        extensions: ["pgn"]
      },
      "application/x-chrome-extension": {
        extensions: ["crx"]
      },
      "application/x-cocoa": {
        source: "nginx",
        extensions: ["cco"]
      },
      "application/x-compress": {
        source: "apache"
      },
      "application/x-compressed": {
        extensions: ["rar"]
      },
      "application/x-conference": {
        source: "apache",
        extensions: ["nsc"]
      },
      "application/x-cpio": {
        source: "apache",
        extensions: ["cpio"]
      },
      "application/x-csh": {
        source: "apache",
        extensions: ["csh"]
      },
      "application/x-deb": {
        compressible: false
      },
      "application/x-debian-package": {
        source: "apache",
        extensions: ["deb", "udeb"]
      },
      "application/x-dgc-compressed": {
        source: "apache",
        extensions: ["dgc"]
      },
      "application/x-director": {
        source: "apache",
        extensions: ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"]
      },
      "application/x-doom": {
        source: "apache",
        extensions: ["wad"]
      },
      "application/x-dtbncx+xml": {
        source: "apache",
        compressible: true,
        extensions: ["ncx"]
      },
      "application/x-dtbook+xml": {
        source: "apache",
        compressible: true,
        extensions: ["dtb"]
      },
      "application/x-dtbresource+xml": {
        source: "apache",
        compressible: true,
        extensions: ["res"]
      },
      "application/x-dvi": {
        source: "apache",
        compressible: false,
        extensions: ["dvi"]
      },
      "application/x-envoy": {
        source: "apache",
        extensions: ["evy"]
      },
      "application/x-eva": {
        source: "apache",
        extensions: ["eva"]
      },
      "application/x-font-bdf": {
        source: "apache",
        extensions: ["bdf"]
      },
      "application/x-font-dos": {
        source: "apache"
      },
      "application/x-font-framemaker": {
        source: "apache"
      },
      "application/x-font-ghostscript": {
        source: "apache",
        extensions: ["gsf"]
      },
      "application/x-font-libgrx": {
        source: "apache"
      },
      "application/x-font-linux-psf": {
        source: "apache",
        extensions: ["psf"]
      },
      "application/x-font-pcf": {
        source: "apache",
        extensions: ["pcf"]
      },
      "application/x-font-snf": {
        source: "apache",
        extensions: ["snf"]
      },
      "application/x-font-speedo": {
        source: "apache"
      },
      "application/x-font-sunos-news": {
        source: "apache"
      },
      "application/x-font-type1": {
        source: "apache",
        extensions: ["pfa", "pfb", "pfm", "afm"]
      },
      "application/x-font-vfont": {
        source: "apache"
      },
      "application/x-freearc": {
        source: "apache",
        extensions: ["arc"]
      },
      "application/x-futuresplash": {
        source: "apache",
        extensions: ["spl"]
      },
      "application/x-gca-compressed": {
        source: "apache",
        extensions: ["gca"]
      },
      "application/x-glulx": {
        source: "apache",
        extensions: ["ulx"]
      },
      "application/x-gnumeric": {
        source: "apache",
        extensions: ["gnumeric"]
      },
      "application/x-gramps-xml": {
        source: "apache",
        extensions: ["gramps"]
      },
      "application/x-gtar": {
        source: "apache",
        extensions: ["gtar"]
      },
      "application/x-gzip": {
        source: "apache"
      },
      "application/x-hdf": {
        source: "apache",
        extensions: ["hdf"]
      },
      "application/x-httpd-php": {
        compressible: true,
        extensions: ["php"]
      },
      "application/x-install-instructions": {
        source: "apache",
        extensions: ["install"]
      },
      "application/x-ipynb+json": {
        compressible: true,
        extensions: ["ipynb"]
      },
      "application/x-iso9660-image": {
        source: "apache",
        extensions: ["iso"]
      },
      "application/x-iwork-keynote-sffkey": {
        extensions: ["key"]
      },
      "application/x-iwork-numbers-sffnumbers": {
        extensions: ["numbers"]
      },
      "application/x-iwork-pages-sffpages": {
        extensions: ["pages"]
      },
      "application/x-java-archive-diff": {
        source: "nginx",
        extensions: ["jardiff"]
      },
      "application/x-java-jnlp-file": {
        source: "apache",
        compressible: false,
        extensions: ["jnlp"]
      },
      "application/x-javascript": {
        compressible: true
      },
      "application/x-keepass2": {
        extensions: ["kdbx"]
      },
      "application/x-latex": {
        source: "apache",
        compressible: false,
        extensions: ["latex"]
      },
      "application/x-lua-bytecode": {
        extensions: ["luac"]
      },
      "application/x-lzh-compressed": {
        source: "apache",
        extensions: ["lzh", "lha"]
      },
      "application/x-makeself": {
        source: "nginx",
        extensions: ["run"]
      },
      "application/x-mie": {
        source: "apache",
        extensions: ["mie"]
      },
      "application/x-mobipocket-ebook": {
        source: "apache",
        extensions: ["prc", "mobi"]
      },
      "application/x-mpegurl": {
        compressible: false
      },
      "application/x-ms-application": {
        source: "apache",
        extensions: ["application"]
      },
      "application/x-ms-shortcut": {
        source: "apache",
        extensions: ["lnk"]
      },
      "application/x-ms-wmd": {
        source: "apache",
        extensions: ["wmd"]
      },
      "application/x-ms-wmz": {
        source: "apache",
        extensions: ["wmz"]
      },
      "application/x-ms-xbap": {
        source: "apache",
        extensions: ["xbap"]
      },
      "application/x-msaccess": {
        source: "apache",
        extensions: ["mdb"]
      },
      "application/x-msbinder": {
        source: "apache",
        extensions: ["obd"]
      },
      "application/x-mscardfile": {
        source: "apache",
        extensions: ["crd"]
      },
      "application/x-msclip": {
        source: "apache",
        extensions: ["clp"]
      },
      "application/x-msdos-program": {
        extensions: ["exe"]
      },
      "application/x-msdownload": {
        source: "apache",
        extensions: ["exe", "dll", "com", "bat", "msi"]
      },
      "application/x-msmediaview": {
        source: "apache",
        extensions: ["mvb", "m13", "m14"]
      },
      "application/x-msmetafile": {
        source: "apache",
        extensions: ["wmf", "wmz", "emf", "emz"]
      },
      "application/x-msmoney": {
        source: "apache",
        extensions: ["mny"]
      },
      "application/x-mspublisher": {
        source: "apache",
        extensions: ["pub"]
      },
      "application/x-msschedule": {
        source: "apache",
        extensions: ["scd"]
      },
      "application/x-msterminal": {
        source: "apache",
        extensions: ["trm"]
      },
      "application/x-mswrite": {
        source: "apache",
        extensions: ["wri"]
      },
      "application/x-netcdf": {
        source: "apache",
        extensions: ["nc", "cdf"]
      },
      "application/x-ns-proxy-autoconfig": {
        compressible: true,
        extensions: ["pac"]
      },
      "application/x-nzb": {
        source: "apache",
        extensions: ["nzb"]
      },
      "application/x-perl": {
        source: "nginx",
        extensions: ["pl", "pm"]
      },
      "application/x-pilot": {
        source: "nginx",
        extensions: ["prc", "pdb"]
      },
      "application/x-pkcs12": {
        source: "apache",
        compressible: false,
        extensions: ["p12", "pfx"]
      },
      "application/x-pkcs7-certificates": {
        source: "apache",
        extensions: ["p7b", "spc"]
      },
      "application/x-pkcs7-certreqresp": {
        source: "apache",
        extensions: ["p7r"]
      },
      "application/x-pki-message": {
        source: "iana"
      },
      "application/x-rar-compressed": {
        source: "apache",
        compressible: false,
        extensions: ["rar"]
      },
      "application/x-redhat-package-manager": {
        source: "nginx",
        extensions: ["rpm"]
      },
      "application/x-research-info-systems": {
        source: "apache",
        extensions: ["ris"]
      },
      "application/x-sea": {
        source: "nginx",
        extensions: ["sea"]
      },
      "application/x-sh": {
        source: "apache",
        compressible: true,
        extensions: ["sh"]
      },
      "application/x-shar": {
        source: "apache",
        extensions: ["shar"]
      },
      "application/x-shockwave-flash": {
        source: "apache",
        compressible: false,
        extensions: ["swf"]
      },
      "application/x-silverlight-app": {
        source: "apache",
        extensions: ["xap"]
      },
      "application/x-sql": {
        source: "apache",
        extensions: ["sql"]
      },
      "application/x-stuffit": {
        source: "apache",
        compressible: false,
        extensions: ["sit"]
      },
      "application/x-stuffitx": {
        source: "apache",
        extensions: ["sitx"]
      },
      "application/x-subrip": {
        source: "apache",
        extensions: ["srt"]
      },
      "application/x-sv4cpio": {
        source: "apache",
        extensions: ["sv4cpio"]
      },
      "application/x-sv4crc": {
        source: "apache",
        extensions: ["sv4crc"]
      },
      "application/x-t3vm-image": {
        source: "apache",
        extensions: ["t3"]
      },
      "application/x-tads": {
        source: "apache",
        extensions: ["gam"]
      },
      "application/x-tar": {
        source: "apache",
        compressible: true,
        extensions: ["tar"]
      },
      "application/x-tcl": {
        source: "apache",
        extensions: ["tcl", "tk"]
      },
      "application/x-tex": {
        source: "apache",
        extensions: ["tex"]
      },
      "application/x-tex-tfm": {
        source: "apache",
        extensions: ["tfm"]
      },
      "application/x-texinfo": {
        source: "apache",
        extensions: ["texinfo", "texi"]
      },
      "application/x-tgif": {
        source: "apache",
        extensions: ["obj"]
      },
      "application/x-ustar": {
        source: "apache",
        extensions: ["ustar"]
      },
      "application/x-virtualbox-hdd": {
        compressible: true,
        extensions: ["hdd"]
      },
      "application/x-virtualbox-ova": {
        compressible: true,
        extensions: ["ova"]
      },
      "application/x-virtualbox-ovf": {
        compressible: true,
        extensions: ["ovf"]
      },
      "application/x-virtualbox-vbox": {
        compressible: true,
        extensions: ["vbox"]
      },
      "application/x-virtualbox-vbox-extpack": {
        compressible: false,
        extensions: ["vbox-extpack"]
      },
      "application/x-virtualbox-vdi": {
        compressible: true,
        extensions: ["vdi"]
      },
      "application/x-virtualbox-vhd": {
        compressible: true,
        extensions: ["vhd"]
      },
      "application/x-virtualbox-vmdk": {
        compressible: true,
        extensions: ["vmdk"]
      },
      "application/x-wais-source": {
        source: "apache",
        extensions: ["src"]
      },
      "application/x-web-app-manifest+json": {
        compressible: true,
        extensions: ["webapp"]
      },
      "application/x-www-form-urlencoded": {
        source: "iana",
        compressible: true
      },
      "application/x-x509-ca-cert": {
        source: "iana",
        extensions: ["der", "crt", "pem"]
      },
      "application/x-x509-ca-ra-cert": {
        source: "iana"
      },
      "application/x-x509-next-ca-cert": {
        source: "iana"
      },
      "application/x-xfig": {
        source: "apache",
        extensions: ["fig"]
      },
      "application/x-xliff+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xlf"]
      },
      "application/x-xpinstall": {
        source: "apache",
        compressible: false,
        extensions: ["xpi"]
      },
      "application/x-xz": {
        source: "apache",
        extensions: ["xz"]
      },
      "application/x-zip-compressed": {
        extensions: ["zip"]
      },
      "application/x-zmachine": {
        source: "apache",
        extensions: ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"]
      },
      "application/x400-bp": {
        source: "iana"
      },
      "application/xacml+xml": {
        source: "iana",
        compressible: true
      },
      "application/xaml+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xaml"]
      },
      "application/xcap-att+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xav"]
      },
      "application/xcap-caps+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xca"]
      },
      "application/xcap-diff+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdf"]
      },
      "application/xcap-el+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xel"]
      },
      "application/xcap-error+xml": {
        source: "iana",
        compressible: true
      },
      "application/xcap-ns+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xns"]
      },
      "application/xcon-conference-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/xcon-conference-info-diff+xml": {
        source: "iana",
        compressible: true
      },
      "application/xenc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xenc"]
      },
      "application/xfdf": {
        source: "iana",
        extensions: ["xfdf"]
      },
      "application/xhtml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xhtml", "xht"]
      },
      "application/xhtml-voice+xml": {
        source: "apache",
        compressible: true
      },
      "application/xliff+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xlf"]
      },
      "application/xml": {
        source: "iana",
        compressible: true,
        extensions: ["xml", "xsl", "xsd", "rng"]
      },
      "application/xml-dtd": {
        source: "iana",
        compressible: true,
        extensions: ["dtd"]
      },
      "application/xml-external-parsed-entity": {
        source: "iana"
      },
      "application/xml-patch+xml": {
        source: "iana",
        compressible: true
      },
      "application/xmpp+xml": {
        source: "iana",
        compressible: true
      },
      "application/xop+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xop"]
      },
      "application/xproc+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xpl"]
      },
      "application/xslt+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xsl", "xslt"]
      },
      "application/xspf+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xspf"]
      },
      "application/xv+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mxml", "xhvml", "xvml", "xvm"]
      },
      "application/yaml": {
        source: "iana"
      },
      "application/yang": {
        source: "iana",
        extensions: ["yang"]
      },
      "application/yang-data+cbor": {
        source: "iana"
      },
      "application/yang-data+json": {
        source: "iana",
        compressible: true
      },
      "application/yang-data+xml": {
        source: "iana",
        compressible: true
      },
      "application/yang-patch+json": {
        source: "iana",
        compressible: true
      },
      "application/yang-patch+xml": {
        source: "iana",
        compressible: true
      },
      "application/yang-sid+json": {
        source: "iana",
        compressible: true
      },
      "application/yin+xml": {
        source: "iana",
        compressible: true,
        extensions: ["yin"]
      },
      "application/zip": {
        source: "iana",
        compressible: false,
        extensions: ["zip"]
      },
      "application/zip+dotlottie": {
        extensions: ["lottie"]
      },
      "application/zlib": {
        source: "iana"
      },
      "application/zstd": {
        source: "iana"
      },
      "audio/1d-interleaved-parityfec": {
        source: "iana"
      },
      "audio/32kadpcm": {
        source: "iana"
      },
      "audio/3gpp": {
        source: "iana",
        compressible: false,
        extensions: ["3gpp"]
      },
      "audio/3gpp2": {
        source: "iana"
      },
      "audio/aac": {
        source: "iana",
        extensions: ["adts", "aac"]
      },
      "audio/ac3": {
        source: "iana"
      },
      "audio/adpcm": {
        source: "apache",
        extensions: ["adp"]
      },
      "audio/amr": {
        source: "iana",
        extensions: ["amr"]
      },
      "audio/amr-wb": {
        source: "iana"
      },
      "audio/amr-wb+": {
        source: "iana"
      },
      "audio/aptx": {
        source: "iana"
      },
      "audio/asc": {
        source: "iana"
      },
      "audio/atrac-advanced-lossless": {
        source: "iana"
      },
      "audio/atrac-x": {
        source: "iana"
      },
      "audio/atrac3": {
        source: "iana"
      },
      "audio/basic": {
        source: "iana",
        compressible: false,
        extensions: ["au", "snd"]
      },
      "audio/bv16": {
        source: "iana"
      },
      "audio/bv32": {
        source: "iana"
      },
      "audio/clearmode": {
        source: "iana"
      },
      "audio/cn": {
        source: "iana"
      },
      "audio/dat12": {
        source: "iana"
      },
      "audio/dls": {
        source: "iana"
      },
      "audio/dsr-es201108": {
        source: "iana"
      },
      "audio/dsr-es202050": {
        source: "iana"
      },
      "audio/dsr-es202211": {
        source: "iana"
      },
      "audio/dsr-es202212": {
        source: "iana"
      },
      "audio/dv": {
        source: "iana"
      },
      "audio/dvi4": {
        source: "iana"
      },
      "audio/eac3": {
        source: "iana"
      },
      "audio/encaprtp": {
        source: "iana"
      },
      "audio/evrc": {
        source: "iana"
      },
      "audio/evrc-qcp": {
        source: "iana"
      },
      "audio/evrc0": {
        source: "iana"
      },
      "audio/evrc1": {
        source: "iana"
      },
      "audio/evrcb": {
        source: "iana"
      },
      "audio/evrcb0": {
        source: "iana"
      },
      "audio/evrcb1": {
        source: "iana"
      },
      "audio/evrcnw": {
        source: "iana"
      },
      "audio/evrcnw0": {
        source: "iana"
      },
      "audio/evrcnw1": {
        source: "iana"
      },
      "audio/evrcwb": {
        source: "iana"
      },
      "audio/evrcwb0": {
        source: "iana"
      },
      "audio/evrcwb1": {
        source: "iana"
      },
      "audio/evs": {
        source: "iana"
      },
      "audio/flac": {
        source: "iana"
      },
      "audio/flexfec": {
        source: "iana"
      },
      "audio/fwdred": {
        source: "iana"
      },
      "audio/g711-0": {
        source: "iana"
      },
      "audio/g719": {
        source: "iana"
      },
      "audio/g722": {
        source: "iana"
      },
      "audio/g7221": {
        source: "iana"
      },
      "audio/g723": {
        source: "iana"
      },
      "audio/g726-16": {
        source: "iana"
      },
      "audio/g726-24": {
        source: "iana"
      },
      "audio/g726-32": {
        source: "iana"
      },
      "audio/g726-40": {
        source: "iana"
      },
      "audio/g728": {
        source: "iana"
      },
      "audio/g729": {
        source: "iana"
      },
      "audio/g7291": {
        source: "iana"
      },
      "audio/g729d": {
        source: "iana"
      },
      "audio/g729e": {
        source: "iana"
      },
      "audio/gsm": {
        source: "iana"
      },
      "audio/gsm-efr": {
        source: "iana"
      },
      "audio/gsm-hr-08": {
        source: "iana"
      },
      "audio/ilbc": {
        source: "iana"
      },
      "audio/ip-mr_v2.5": {
        source: "iana"
      },
      "audio/isac": {
        source: "apache"
      },
      "audio/l16": {
        source: "iana"
      },
      "audio/l20": {
        source: "iana"
      },
      "audio/l24": {
        source: "iana",
        compressible: false
      },
      "audio/l8": {
        source: "iana"
      },
      "audio/lpc": {
        source: "iana"
      },
      "audio/matroska": {
        source: "iana"
      },
      "audio/melp": {
        source: "iana"
      },
      "audio/melp1200": {
        source: "iana"
      },
      "audio/melp2400": {
        source: "iana"
      },
      "audio/melp600": {
        source: "iana"
      },
      "audio/mhas": {
        source: "iana"
      },
      "audio/midi": {
        source: "apache",
        extensions: ["mid", "midi", "kar", "rmi"]
      },
      "audio/midi-clip": {
        source: "iana"
      },
      "audio/mobile-xmf": {
        source: "iana",
        extensions: ["mxmf"]
      },
      "audio/mp3": {
        compressible: false,
        extensions: ["mp3"]
      },
      "audio/mp4": {
        source: "iana",
        compressible: false,
        extensions: ["m4a", "mp4a", "m4b"]
      },
      "audio/mp4a-latm": {
        source: "iana"
      },
      "audio/mpa": {
        source: "iana"
      },
      "audio/mpa-robust": {
        source: "iana"
      },
      "audio/mpeg": {
        source: "iana",
        compressible: false,
        extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"]
      },
      "audio/mpeg4-generic": {
        source: "iana"
      },
      "audio/musepack": {
        source: "apache"
      },
      "audio/ogg": {
        source: "iana",
        compressible: false,
        extensions: ["oga", "ogg", "spx", "opus"]
      },
      "audio/opus": {
        source: "iana"
      },
      "audio/parityfec": {
        source: "iana"
      },
      "audio/pcma": {
        source: "iana"
      },
      "audio/pcma-wb": {
        source: "iana"
      },
      "audio/pcmu": {
        source: "iana"
      },
      "audio/pcmu-wb": {
        source: "iana"
      },
      "audio/prs.sid": {
        source: "iana"
      },
      "audio/qcelp": {
        source: "iana"
      },
      "audio/raptorfec": {
        source: "iana"
      },
      "audio/red": {
        source: "iana"
      },
      "audio/rtp-enc-aescm128": {
        source: "iana"
      },
      "audio/rtp-midi": {
        source: "iana"
      },
      "audio/rtploopback": {
        source: "iana"
      },
      "audio/rtx": {
        source: "iana"
      },
      "audio/s3m": {
        source: "apache",
        extensions: ["s3m"]
      },
      "audio/scip": {
        source: "iana"
      },
      "audio/silk": {
        source: "apache",
        extensions: ["sil"]
      },
      "audio/smv": {
        source: "iana"
      },
      "audio/smv-qcp": {
        source: "iana"
      },
      "audio/smv0": {
        source: "iana"
      },
      "audio/sofa": {
        source: "iana"
      },
      "audio/sp-midi": {
        source: "iana"
      },
      "audio/speex": {
        source: "iana"
      },
      "audio/t140c": {
        source: "iana"
      },
      "audio/t38": {
        source: "iana"
      },
      "audio/telephone-event": {
        source: "iana"
      },
      "audio/tetra_acelp": {
        source: "iana"
      },
      "audio/tetra_acelp_bb": {
        source: "iana"
      },
      "audio/tone": {
        source: "iana"
      },
      "audio/tsvcis": {
        source: "iana"
      },
      "audio/uemclip": {
        source: "iana"
      },
      "audio/ulpfec": {
        source: "iana"
      },
      "audio/usac": {
        source: "iana"
      },
      "audio/vdvi": {
        source: "iana"
      },
      "audio/vmr-wb": {
        source: "iana"
      },
      "audio/vnd.3gpp.iufp": {
        source: "iana"
      },
      "audio/vnd.4sb": {
        source: "iana"
      },
      "audio/vnd.audiokoz": {
        source: "iana"
      },
      "audio/vnd.celp": {
        source: "iana"
      },
      "audio/vnd.cisco.nse": {
        source: "iana"
      },
      "audio/vnd.cmles.radio-events": {
        source: "iana"
      },
      "audio/vnd.cns.anp1": {
        source: "iana"
      },
      "audio/vnd.cns.inf1": {
        source: "iana"
      },
      "audio/vnd.dece.audio": {
        source: "iana",
        extensions: ["uva", "uvva"]
      },
      "audio/vnd.digital-winds": {
        source: "iana",
        extensions: ["eol"]
      },
      "audio/vnd.dlna.adts": {
        source: "iana"
      },
      "audio/vnd.dolby.heaac.1": {
        source: "iana"
      },
      "audio/vnd.dolby.heaac.2": {
        source: "iana"
      },
      "audio/vnd.dolby.mlp": {
        source: "iana"
      },
      "audio/vnd.dolby.mps": {
        source: "iana"
      },
      "audio/vnd.dolby.pl2": {
        source: "iana"
      },
      "audio/vnd.dolby.pl2x": {
        source: "iana"
      },
      "audio/vnd.dolby.pl2z": {
        source: "iana"
      },
      "audio/vnd.dolby.pulse.1": {
        source: "iana"
      },
      "audio/vnd.dra": {
        source: "iana",
        extensions: ["dra"]
      },
      "audio/vnd.dts": {
        source: "iana",
        extensions: ["dts"]
      },
      "audio/vnd.dts.hd": {
        source: "iana",
        extensions: ["dtshd"]
      },
      "audio/vnd.dts.uhd": {
        source: "iana"
      },
      "audio/vnd.dvb.file": {
        source: "iana"
      },
      "audio/vnd.everad.plj": {
        source: "iana"
      },
      "audio/vnd.hns.audio": {
        source: "iana"
      },
      "audio/vnd.lucent.voice": {
        source: "iana",
        extensions: ["lvp"]
      },
      "audio/vnd.ms-playready.media.pya": {
        source: "iana",
        extensions: ["pya"]
      },
      "audio/vnd.nokia.mobile-xmf": {
        source: "iana"
      },
      "audio/vnd.nortel.vbk": {
        source: "iana"
      },
      "audio/vnd.nuera.ecelp4800": {
        source: "iana",
        extensions: ["ecelp4800"]
      },
      "audio/vnd.nuera.ecelp7470": {
        source: "iana",
        extensions: ["ecelp7470"]
      },
      "audio/vnd.nuera.ecelp9600": {
        source: "iana",
        extensions: ["ecelp9600"]
      },
      "audio/vnd.octel.sbc": {
        source: "iana"
      },
      "audio/vnd.presonus.multitrack": {
        source: "iana"
      },
      "audio/vnd.qcelp": {
        source: "apache"
      },
      "audio/vnd.rhetorex.32kadpcm": {
        source: "iana"
      },
      "audio/vnd.rip": {
        source: "iana",
        extensions: ["rip"]
      },
      "audio/vnd.rn-realaudio": {
        compressible: false
      },
      "audio/vnd.sealedmedia.softseal.mpeg": {
        source: "iana"
      },
      "audio/vnd.vmx.cvsd": {
        source: "iana"
      },
      "audio/vnd.wave": {
        compressible: false
      },
      "audio/vorbis": {
        source: "iana",
        compressible: false
      },
      "audio/vorbis-config": {
        source: "iana"
      },
      "audio/wav": {
        compressible: false,
        extensions: ["wav"]
      },
      "audio/wave": {
        compressible: false,
        extensions: ["wav"]
      },
      "audio/webm": {
        source: "apache",
        compressible: false,
        extensions: ["weba"]
      },
      "audio/x-aac": {
        source: "apache",
        compressible: false,
        extensions: ["aac"]
      },
      "audio/x-aiff": {
        source: "apache",
        extensions: ["aif", "aiff", "aifc"]
      },
      "audio/x-caf": {
        source: "apache",
        compressible: false,
        extensions: ["caf"]
      },
      "audio/x-flac": {
        source: "apache",
        extensions: ["flac"]
      },
      "audio/x-m4a": {
        source: "nginx",
        extensions: ["m4a"]
      },
      "audio/x-matroska": {
        source: "apache",
        extensions: ["mka"]
      },
      "audio/x-mpegurl": {
        source: "apache",
        extensions: ["m3u"]
      },
      "audio/x-ms-wax": {
        source: "apache",
        extensions: ["wax"]
      },
      "audio/x-ms-wma": {
        source: "apache",
        extensions: ["wma"]
      },
      "audio/x-pn-realaudio": {
        source: "apache",
        extensions: ["ram", "ra"]
      },
      "audio/x-pn-realaudio-plugin": {
        source: "apache",
        extensions: ["rmp"]
      },
      "audio/x-realaudio": {
        source: "nginx",
        extensions: ["ra"]
      },
      "audio/x-tta": {
        source: "apache"
      },
      "audio/x-wav": {
        source: "apache",
        extensions: ["wav"]
      },
      "audio/xm": {
        source: "apache",
        extensions: ["xm"]
      },
      "chemical/x-cdx": {
        source: "apache",
        extensions: ["cdx"]
      },
      "chemical/x-cif": {
        source: "apache",
        extensions: ["cif"]
      },
      "chemical/x-cmdf": {
        source: "apache",
        extensions: ["cmdf"]
      },
      "chemical/x-cml": {
        source: "apache",
        extensions: ["cml"]
      },
      "chemical/x-csml": {
        source: "apache",
        extensions: ["csml"]
      },
      "chemical/x-pdb": {
        source: "apache"
      },
      "chemical/x-xyz": {
        source: "apache",
        extensions: ["xyz"]
      },
      "font/collection": {
        source: "iana",
        extensions: ["ttc"]
      },
      "font/otf": {
        source: "iana",
        compressible: true,
        extensions: ["otf"]
      },
      "font/sfnt": {
        source: "iana"
      },
      "font/ttf": {
        source: "iana",
        compressible: true,
        extensions: ["ttf"]
      },
      "font/woff": {
        source: "iana",
        extensions: ["woff"]
      },
      "font/woff2": {
        source: "iana",
        extensions: ["woff2"]
      },
      "image/aces": {
        source: "iana",
        extensions: ["exr"]
      },
      "image/apng": {
        source: "iana",
        compressible: false,
        extensions: ["apng"]
      },
      "image/avci": {
        source: "iana",
        extensions: ["avci"]
      },
      "image/avcs": {
        source: "iana",
        extensions: ["avcs"]
      },
      "image/avif": {
        source: "iana",
        compressible: false,
        extensions: ["avif"]
      },
      "image/bmp": {
        source: "iana",
        compressible: true,
        extensions: ["bmp", "dib"]
      },
      "image/cgm": {
        source: "iana",
        extensions: ["cgm"]
      },
      "image/dicom-rle": {
        source: "iana",
        extensions: ["drle"]
      },
      "image/dpx": {
        source: "iana",
        extensions: ["dpx"]
      },
      "image/emf": {
        source: "iana",
        extensions: ["emf"]
      },
      "image/fits": {
        source: "iana",
        extensions: ["fits"]
      },
      "image/g3fax": {
        source: "iana",
        extensions: ["g3"]
      },
      "image/gif": {
        source: "iana",
        compressible: false,
        extensions: ["gif"]
      },
      "image/heic": {
        source: "iana",
        extensions: ["heic"]
      },
      "image/heic-sequence": {
        source: "iana",
        extensions: ["heics"]
      },
      "image/heif": {
        source: "iana",
        extensions: ["heif"]
      },
      "image/heif-sequence": {
        source: "iana",
        extensions: ["heifs"]
      },
      "image/hej2k": {
        source: "iana",
        extensions: ["hej2"]
      },
      "image/ief": {
        source: "iana",
        extensions: ["ief"]
      },
      "image/j2c": {
        source: "iana"
      },
      "image/jaii": {
        source: "iana",
        extensions: ["jaii"]
      },
      "image/jais": {
        source: "iana",
        extensions: ["jais"]
      },
      "image/jls": {
        source: "iana",
        extensions: ["jls"]
      },
      "image/jp2": {
        source: "iana",
        compressible: false,
        extensions: ["jp2", "jpg2"]
      },
      "image/jpeg": {
        source: "iana",
        compressible: false,
        extensions: ["jpg", "jpeg", "jpe"]
      },
      "image/jph": {
        source: "iana",
        extensions: ["jph"]
      },
      "image/jphc": {
        source: "iana",
        extensions: ["jhc"]
      },
      "image/jpm": {
        source: "iana",
        compressible: false,
        extensions: ["jpm", "jpgm"]
      },
      "image/jpx": {
        source: "iana",
        compressible: false,
        extensions: ["jpx", "jpf"]
      },
      "image/jxl": {
        source: "iana",
        extensions: ["jxl"]
      },
      "image/jxr": {
        source: "iana",
        extensions: ["jxr"]
      },
      "image/jxra": {
        source: "iana",
        extensions: ["jxra"]
      },
      "image/jxrs": {
        source: "iana",
        extensions: ["jxrs"]
      },
      "image/jxs": {
        source: "iana",
        extensions: ["jxs"]
      },
      "image/jxsc": {
        source: "iana",
        extensions: ["jxsc"]
      },
      "image/jxsi": {
        source: "iana",
        extensions: ["jxsi"]
      },
      "image/jxss": {
        source: "iana",
        extensions: ["jxss"]
      },
      "image/ktx": {
        source: "iana",
        extensions: ["ktx"]
      },
      "image/ktx2": {
        source: "iana",
        extensions: ["ktx2"]
      },
      "image/naplps": {
        source: "iana"
      },
      "image/pjpeg": {
        compressible: false,
        extensions: ["jfif"]
      },
      "image/png": {
        source: "iana",
        compressible: false,
        extensions: ["png"]
      },
      "image/prs.btif": {
        source: "iana",
        extensions: ["btif", "btf"]
      },
      "image/prs.pti": {
        source: "iana",
        extensions: ["pti"]
      },
      "image/pwg-raster": {
        source: "iana"
      },
      "image/sgi": {
        source: "apache",
        extensions: ["sgi"]
      },
      "image/svg+xml": {
        source: "iana",
        compressible: true,
        extensions: ["svg", "svgz"]
      },
      "image/t38": {
        source: "iana",
        extensions: ["t38"]
      },
      "image/tiff": {
        source: "iana",
        compressible: false,
        extensions: ["tif", "tiff"]
      },
      "image/tiff-fx": {
        source: "iana",
        extensions: ["tfx"]
      },
      "image/vnd.adobe.photoshop": {
        source: "iana",
        compressible: true,
        extensions: ["psd"]
      },
      "image/vnd.airzip.accelerator.azv": {
        source: "iana",
        extensions: ["azv"]
      },
      "image/vnd.clip": {
        source: "iana"
      },
      "image/vnd.cns.inf2": {
        source: "iana"
      },
      "image/vnd.dece.graphic": {
        source: "iana",
        extensions: ["uvi", "uvvi", "uvg", "uvvg"]
      },
      "image/vnd.djvu": {
        source: "iana",
        extensions: ["djvu", "djv"]
      },
      "image/vnd.dvb.subtitle": {
        source: "iana",
        extensions: ["sub"]
      },
      "image/vnd.dwg": {
        source: "iana",
        extensions: ["dwg"]
      },
      "image/vnd.dxf": {
        source: "iana",
        extensions: ["dxf"]
      },
      "image/vnd.fastbidsheet": {
        source: "iana",
        extensions: ["fbs"]
      },
      "image/vnd.fpx": {
        source: "iana",
        extensions: ["fpx"]
      },
      "image/vnd.fst": {
        source: "iana",
        extensions: ["fst"]
      },
      "image/vnd.fujixerox.edmics-mmr": {
        source: "iana",
        extensions: ["mmr"]
      },
      "image/vnd.fujixerox.edmics-rlc": {
        source: "iana",
        extensions: ["rlc"]
      },
      "image/vnd.globalgraphics.pgb": {
        source: "iana"
      },
      "image/vnd.microsoft.icon": {
        source: "iana",
        compressible: true,
        extensions: ["ico"]
      },
      "image/vnd.mix": {
        source: "iana"
      },
      "image/vnd.mozilla.apng": {
        source: "iana"
      },
      "image/vnd.ms-dds": {
        compressible: true,
        extensions: ["dds"]
      },
      "image/vnd.ms-modi": {
        source: "iana",
        extensions: ["mdi"]
      },
      "image/vnd.ms-photo": {
        source: "apache",
        extensions: ["wdp"]
      },
      "image/vnd.net-fpx": {
        source: "iana",
        extensions: ["npx"]
      },
      "image/vnd.pco.b16": {
        source: "iana",
        extensions: ["b16"]
      },
      "image/vnd.radiance": {
        source: "iana"
      },
      "image/vnd.sealed.png": {
        source: "iana"
      },
      "image/vnd.sealedmedia.softseal.gif": {
        source: "iana"
      },
      "image/vnd.sealedmedia.softseal.jpg": {
        source: "iana"
      },
      "image/vnd.svf": {
        source: "iana"
      },
      "image/vnd.tencent.tap": {
        source: "iana",
        extensions: ["tap"]
      },
      "image/vnd.valve.source.texture": {
        source: "iana",
        extensions: ["vtf"]
      },
      "image/vnd.wap.wbmp": {
        source: "iana",
        extensions: ["wbmp"]
      },
      "image/vnd.xiff": {
        source: "iana",
        extensions: ["xif"]
      },
      "image/vnd.zbrush.pcx": {
        source: "iana",
        extensions: ["pcx"]
      },
      "image/webp": {
        source: "iana",
        extensions: ["webp"]
      },
      "image/wmf": {
        source: "iana",
        extensions: ["wmf"]
      },
      "image/x-3ds": {
        source: "apache",
        extensions: ["3ds"]
      },
      "image/x-adobe-dng": {
        extensions: ["dng"]
      },
      "image/x-cmu-raster": {
        source: "apache",
        extensions: ["ras"]
      },
      "image/x-cmx": {
        source: "apache",
        extensions: ["cmx"]
      },
      "image/x-emf": {
        source: "iana"
      },
      "image/x-freehand": {
        source: "apache",
        extensions: ["fh", "fhc", "fh4", "fh5", "fh7"]
      },
      "image/x-icon": {
        source: "apache",
        compressible: true,
        extensions: ["ico"]
      },
      "image/x-jng": {
        source: "nginx",
        extensions: ["jng"]
      },
      "image/x-mrsid-image": {
        source: "apache",
        extensions: ["sid"]
      },
      "image/x-ms-bmp": {
        source: "nginx",
        compressible: true,
        extensions: ["bmp"]
      },
      "image/x-pcx": {
        source: "apache",
        extensions: ["pcx"]
      },
      "image/x-pict": {
        source: "apache",
        extensions: ["pic", "pct"]
      },
      "image/x-portable-anymap": {
        source: "apache",
        extensions: ["pnm"]
      },
      "image/x-portable-bitmap": {
        source: "apache",
        extensions: ["pbm"]
      },
      "image/x-portable-graymap": {
        source: "apache",
        extensions: ["pgm"]
      },
      "image/x-portable-pixmap": {
        source: "apache",
        extensions: ["ppm"]
      },
      "image/x-rgb": {
        source: "apache",
        extensions: ["rgb"]
      },
      "image/x-tga": {
        source: "apache",
        extensions: ["tga"]
      },
      "image/x-wmf": {
        source: "iana"
      },
      "image/x-xbitmap": {
        source: "apache",
        extensions: ["xbm"]
      },
      "image/x-xcf": {
        compressible: false
      },
      "image/x-xpixmap": {
        source: "apache",
        extensions: ["xpm"]
      },
      "image/x-xwindowdump": {
        source: "apache",
        extensions: ["xwd"]
      },
      "message/bhttp": {
        source: "iana"
      },
      "message/cpim": {
        source: "iana"
      },
      "message/delivery-status": {
        source: "iana"
      },
      "message/disposition-notification": {
        source: "iana",
        extensions: [
          "disposition-notification"
        ]
      },
      "message/external-body": {
        source: "iana"
      },
      "message/feedback-report": {
        source: "iana"
      },
      "message/global": {
        source: "iana",
        extensions: ["u8msg"]
      },
      "message/global-delivery-status": {
        source: "iana",
        extensions: ["u8dsn"]
      },
      "message/global-disposition-notification": {
        source: "iana",
        extensions: ["u8mdn"]
      },
      "message/global-headers": {
        source: "iana",
        extensions: ["u8hdr"]
      },
      "message/http": {
        source: "iana",
        compressible: false
      },
      "message/imdn+xml": {
        source: "iana",
        compressible: true
      },
      "message/mls": {
        source: "iana"
      },
      "message/news": {
        source: "apache"
      },
      "message/ohttp-req": {
        source: "iana"
      },
      "message/ohttp-res": {
        source: "iana"
      },
      "message/partial": {
        source: "iana",
        compressible: false
      },
      "message/rfc822": {
        source: "iana",
        compressible: true,
        extensions: ["eml", "mime", "mht", "mhtml"]
      },
      "message/s-http": {
        source: "apache"
      },
      "message/sip": {
        source: "iana"
      },
      "message/sipfrag": {
        source: "iana"
      },
      "message/tracking-status": {
        source: "iana"
      },
      "message/vnd.si.simp": {
        source: "apache"
      },
      "message/vnd.wfa.wsc": {
        source: "iana",
        extensions: ["wsc"]
      },
      "model/3mf": {
        source: "iana",
        extensions: ["3mf"]
      },
      "model/e57": {
        source: "iana"
      },
      "model/gltf+json": {
        source: "iana",
        compressible: true,
        extensions: ["gltf"]
      },
      "model/gltf-binary": {
        source: "iana",
        compressible: true,
        extensions: ["glb"]
      },
      "model/iges": {
        source: "iana",
        compressible: false,
        extensions: ["igs", "iges"]
      },
      "model/jt": {
        source: "iana",
        extensions: ["jt"]
      },
      "model/mesh": {
        source: "iana",
        compressible: false,
        extensions: ["msh", "mesh", "silo"]
      },
      "model/mtl": {
        source: "iana",
        extensions: ["mtl"]
      },
      "model/obj": {
        source: "iana",
        extensions: ["obj"]
      },
      "model/prc": {
        source: "iana",
        extensions: ["prc"]
      },
      "model/step": {
        source: "iana",
        extensions: ["step", "stp", "stpnc", "p21", "210"]
      },
      "model/step+xml": {
        source: "iana",
        compressible: true,
        extensions: ["stpx"]
      },
      "model/step+zip": {
        source: "iana",
        compressible: false,
        extensions: ["stpz"]
      },
      "model/step-xml+zip": {
        source: "iana",
        compressible: false,
        extensions: ["stpxz"]
      },
      "model/stl": {
        source: "iana",
        extensions: ["stl"]
      },
      "model/u3d": {
        source: "iana",
        extensions: ["u3d"]
      },
      "model/vnd.bary": {
        source: "iana",
        extensions: ["bary"]
      },
      "model/vnd.cld": {
        source: "iana",
        extensions: ["cld"]
      },
      "model/vnd.collada+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dae"]
      },
      "model/vnd.dwf": {
        source: "iana",
        extensions: ["dwf"]
      },
      "model/vnd.flatland.3dml": {
        source: "iana"
      },
      "model/vnd.gdl": {
        source: "iana",
        extensions: ["gdl"]
      },
      "model/vnd.gs-gdl": {
        source: "apache"
      },
      "model/vnd.gs.gdl": {
        source: "iana"
      },
      "model/vnd.gtw": {
        source: "iana",
        extensions: ["gtw"]
      },
      "model/vnd.moml+xml": {
        source: "iana",
        compressible: true
      },
      "model/vnd.mts": {
        source: "iana",
        extensions: ["mts"]
      },
      "model/vnd.opengex": {
        source: "iana",
        extensions: ["ogex"]
      },
      "model/vnd.parasolid.transmit.binary": {
        source: "iana",
        extensions: ["x_b"]
      },
      "model/vnd.parasolid.transmit.text": {
        source: "iana",
        extensions: ["x_t"]
      },
      "model/vnd.pytha.pyox": {
        source: "iana",
        extensions: ["pyo", "pyox"]
      },
      "model/vnd.rosette.annotated-data-model": {
        source: "iana"
      },
      "model/vnd.sap.vds": {
        source: "iana",
        extensions: ["vds"]
      },
      "model/vnd.usda": {
        source: "iana",
        extensions: ["usda"]
      },
      "model/vnd.usdz+zip": {
        source: "iana",
        compressible: false,
        extensions: ["usdz"]
      },
      "model/vnd.valve.source.compiled-map": {
        source: "iana",
        extensions: ["bsp"]
      },
      "model/vnd.vtu": {
        source: "iana",
        extensions: ["vtu"]
      },
      "model/vrml": {
        source: "iana",
        compressible: false,
        extensions: ["wrl", "vrml"]
      },
      "model/x3d+binary": {
        source: "apache",
        compressible: false,
        extensions: ["x3db", "x3dbz"]
      },
      "model/x3d+fastinfoset": {
        source: "iana",
        extensions: ["x3db"]
      },
      "model/x3d+vrml": {
        source: "apache",
        compressible: false,
        extensions: ["x3dv", "x3dvz"]
      },
      "model/x3d+xml": {
        source: "iana",
        compressible: true,
        extensions: ["x3d", "x3dz"]
      },
      "model/x3d-vrml": {
        source: "iana",
        extensions: ["x3dv"]
      },
      "multipart/alternative": {
        source: "iana",
        compressible: false
      },
      "multipart/appledouble": {
        source: "iana"
      },
      "multipart/byteranges": {
        source: "iana"
      },
      "multipart/digest": {
        source: "iana"
      },
      "multipart/encrypted": {
        source: "iana",
        compressible: false
      },
      "multipart/form-data": {
        source: "iana",
        compressible: false
      },
      "multipart/header-set": {
        source: "iana"
      },
      "multipart/mixed": {
        source: "iana"
      },
      "multipart/multilingual": {
        source: "iana"
      },
      "multipart/parallel": {
        source: "iana"
      },
      "multipart/related": {
        source: "iana",
        compressible: false
      },
      "multipart/report": {
        source: "iana"
      },
      "multipart/signed": {
        source: "iana",
        compressible: false
      },
      "multipart/vnd.bint.med-plus": {
        source: "iana"
      },
      "multipart/voice-message": {
        source: "iana"
      },
      "multipart/x-mixed-replace": {
        source: "iana"
      },
      "text/1d-interleaved-parityfec": {
        source: "iana"
      },
      "text/cache-manifest": {
        source: "iana",
        compressible: true,
        extensions: ["appcache", "manifest"]
      },
      "text/calendar": {
        source: "iana",
        extensions: ["ics", "ifb"]
      },
      "text/calender": {
        compressible: true
      },
      "text/cmd": {
        compressible: true
      },
      "text/coffeescript": {
        extensions: ["coffee", "litcoffee"]
      },
      "text/cql": {
        source: "iana"
      },
      "text/cql-expression": {
        source: "iana"
      },
      "text/cql-identifier": {
        source: "iana"
      },
      "text/css": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["css"]
      },
      "text/csv": {
        source: "iana",
        compressible: true,
        extensions: ["csv"]
      },
      "text/csv-schema": {
        source: "iana"
      },
      "text/directory": {
        source: "iana"
      },
      "text/dns": {
        source: "iana"
      },
      "text/ecmascript": {
        source: "apache"
      },
      "text/encaprtp": {
        source: "iana"
      },
      "text/enriched": {
        source: "iana"
      },
      "text/fhirpath": {
        source: "iana"
      },
      "text/flexfec": {
        source: "iana"
      },
      "text/fwdred": {
        source: "iana"
      },
      "text/gff3": {
        source: "iana"
      },
      "text/grammar-ref-list": {
        source: "iana"
      },
      "text/hl7v2": {
        source: "iana"
      },
      "text/html": {
        source: "iana",
        compressible: true,
        extensions: ["html", "htm", "shtml"]
      },
      "text/jade": {
        extensions: ["jade"]
      },
      "text/javascript": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["js", "mjs"]
      },
      "text/jcr-cnd": {
        source: "iana"
      },
      "text/jsx": {
        compressible: true,
        extensions: ["jsx"]
      },
      "text/less": {
        compressible: true,
        extensions: ["less"]
      },
      "text/markdown": {
        source: "iana",
        compressible: true,
        extensions: ["md", "markdown"]
      },
      "text/mathml": {
        source: "nginx",
        extensions: ["mml"]
      },
      "text/mdx": {
        compressible: true,
        extensions: ["mdx"]
      },
      "text/mizar": {
        source: "iana"
      },
      "text/n3": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["n3"]
      },
      "text/parameters": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/parityfec": {
        source: "iana"
      },
      "text/plain": {
        source: "iana",
        compressible: true,
        extensions: ["txt", "text", "conf", "def", "list", "log", "in", "ini"]
      },
      "text/provenance-notation": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/prs.fallenstein.rst": {
        source: "iana"
      },
      "text/prs.lines.tag": {
        source: "iana",
        extensions: ["dsc"]
      },
      "text/prs.prop.logic": {
        source: "iana"
      },
      "text/prs.texi": {
        source: "iana"
      },
      "text/raptorfec": {
        source: "iana"
      },
      "text/red": {
        source: "iana"
      },
      "text/rfc822-headers": {
        source: "iana"
      },
      "text/richtext": {
        source: "iana",
        compressible: true,
        extensions: ["rtx"]
      },
      "text/rtf": {
        source: "iana",
        compressible: true,
        extensions: ["rtf"]
      },
      "text/rtp-enc-aescm128": {
        source: "iana"
      },
      "text/rtploopback": {
        source: "iana"
      },
      "text/rtx": {
        source: "iana"
      },
      "text/sgml": {
        source: "iana",
        extensions: ["sgml", "sgm"]
      },
      "text/shaclc": {
        source: "iana"
      },
      "text/shex": {
        source: "iana",
        extensions: ["shex"]
      },
      "text/slim": {
        extensions: ["slim", "slm"]
      },
      "text/spdx": {
        source: "iana",
        extensions: ["spdx"]
      },
      "text/strings": {
        source: "iana"
      },
      "text/stylus": {
        extensions: ["stylus", "styl"]
      },
      "text/t140": {
        source: "iana"
      },
      "text/tab-separated-values": {
        source: "iana",
        compressible: true,
        extensions: ["tsv"]
      },
      "text/troff": {
        source: "iana",
        extensions: ["t", "tr", "roff", "man", "me", "ms"]
      },
      "text/turtle": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["ttl"]
      },
      "text/ulpfec": {
        source: "iana"
      },
      "text/uri-list": {
        source: "iana",
        compressible: true,
        extensions: ["uri", "uris", "urls"]
      },
      "text/vcard": {
        source: "iana",
        compressible: true,
        extensions: ["vcard"]
      },
      "text/vnd.a": {
        source: "iana"
      },
      "text/vnd.abc": {
        source: "iana"
      },
      "text/vnd.ascii-art": {
        source: "iana"
      },
      "text/vnd.curl": {
        source: "iana",
        extensions: ["curl"]
      },
      "text/vnd.curl.dcurl": {
        source: "apache",
        extensions: ["dcurl"]
      },
      "text/vnd.curl.mcurl": {
        source: "apache",
        extensions: ["mcurl"]
      },
      "text/vnd.curl.scurl": {
        source: "apache",
        extensions: ["scurl"]
      },
      "text/vnd.debian.copyright": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/vnd.dmclientscript": {
        source: "iana"
      },
      "text/vnd.dvb.subtitle": {
        source: "iana",
        extensions: ["sub"]
      },
      "text/vnd.esmertec.theme-descriptor": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/vnd.exchangeable": {
        source: "iana"
      },
      "text/vnd.familysearch.gedcom": {
        source: "iana",
        extensions: ["ged"]
      },
      "text/vnd.ficlab.flt": {
        source: "iana"
      },
      "text/vnd.fly": {
        source: "iana",
        extensions: ["fly"]
      },
      "text/vnd.fmi.flexstor": {
        source: "iana",
        extensions: ["flx"]
      },
      "text/vnd.gml": {
        source: "iana"
      },
      "text/vnd.graphviz": {
        source: "iana",
        extensions: ["gv"]
      },
      "text/vnd.hans": {
        source: "iana"
      },
      "text/vnd.hgl": {
        source: "iana"
      },
      "text/vnd.in3d.3dml": {
        source: "iana",
        extensions: ["3dml"]
      },
      "text/vnd.in3d.spot": {
        source: "iana",
        extensions: ["spot"]
      },
      "text/vnd.iptc.newsml": {
        source: "iana"
      },
      "text/vnd.iptc.nitf": {
        source: "iana"
      },
      "text/vnd.latex-z": {
        source: "iana"
      },
      "text/vnd.motorola.reflex": {
        source: "iana"
      },
      "text/vnd.ms-mediapackage": {
        source: "iana"
      },
      "text/vnd.net2phone.commcenter.command": {
        source: "iana"
      },
      "text/vnd.radisys.msml-basic-layout": {
        source: "iana"
      },
      "text/vnd.senx.warpscript": {
        source: "iana"
      },
      "text/vnd.si.uricatalogue": {
        source: "apache"
      },
      "text/vnd.sosi": {
        source: "iana"
      },
      "text/vnd.sun.j2me.app-descriptor": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["jad"]
      },
      "text/vnd.trolltech.linguist": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/vnd.vcf": {
        source: "iana"
      },
      "text/vnd.wap.si": {
        source: "iana"
      },
      "text/vnd.wap.sl": {
        source: "iana"
      },
      "text/vnd.wap.wml": {
        source: "iana",
        extensions: ["wml"]
      },
      "text/vnd.wap.wmlscript": {
        source: "iana",
        extensions: ["wmls"]
      },
      "text/vnd.zoo.kcl": {
        source: "iana"
      },
      "text/vtt": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["vtt"]
      },
      "text/wgsl": {
        source: "iana",
        extensions: ["wgsl"]
      },
      "text/x-asm": {
        source: "apache",
        extensions: ["s", "asm"]
      },
      "text/x-c": {
        source: "apache",
        extensions: ["c", "cc", "cxx", "cpp", "h", "hh", "dic"]
      },
      "text/x-component": {
        source: "nginx",
        extensions: ["htc"]
      },
      "text/x-fortran": {
        source: "apache",
        extensions: ["f", "for", "f77", "f90"]
      },
      "text/x-gwt-rpc": {
        compressible: true
      },
      "text/x-handlebars-template": {
        extensions: ["hbs"]
      },
      "text/x-java-source": {
        source: "apache",
        extensions: ["java"]
      },
      "text/x-jquery-tmpl": {
        compressible: true
      },
      "text/x-lua": {
        extensions: ["lua"]
      },
      "text/x-markdown": {
        compressible: true,
        extensions: ["mkd"]
      },
      "text/x-nfo": {
        source: "apache",
        extensions: ["nfo"]
      },
      "text/x-opml": {
        source: "apache",
        extensions: ["opml"]
      },
      "text/x-org": {
        compressible: true,
        extensions: ["org"]
      },
      "text/x-pascal": {
        source: "apache",
        extensions: ["p", "pas"]
      },
      "text/x-processing": {
        compressible: true,
        extensions: ["pde"]
      },
      "text/x-sass": {
        extensions: ["sass"]
      },
      "text/x-scss": {
        extensions: ["scss"]
      },
      "text/x-setext": {
        source: "apache",
        extensions: ["etx"]
      },
      "text/x-sfv": {
        source: "apache",
        extensions: ["sfv"]
      },
      "text/x-suse-ymp": {
        compressible: true,
        extensions: ["ymp"]
      },
      "text/x-uuencode": {
        source: "apache",
        extensions: ["uu"]
      },
      "text/x-vcalendar": {
        source: "apache",
        extensions: ["vcs"]
      },
      "text/x-vcard": {
        source: "apache",
        extensions: ["vcf"]
      },
      "text/xml": {
        source: "iana",
        compressible: true,
        extensions: ["xml"]
      },
      "text/xml-external-parsed-entity": {
        source: "iana"
      },
      "text/yaml": {
        compressible: true,
        extensions: ["yaml", "yml"]
      },
      "video/1d-interleaved-parityfec": {
        source: "iana"
      },
      "video/3gpp": {
        source: "iana",
        extensions: ["3gp", "3gpp"]
      },
      "video/3gpp-tt": {
        source: "iana"
      },
      "video/3gpp2": {
        source: "iana",
        extensions: ["3g2"]
      },
      "video/av1": {
        source: "iana"
      },
      "video/bmpeg": {
        source: "iana"
      },
      "video/bt656": {
        source: "iana"
      },
      "video/celb": {
        source: "iana"
      },
      "video/dv": {
        source: "iana"
      },
      "video/encaprtp": {
        source: "iana"
      },
      "video/evc": {
        source: "iana"
      },
      "video/ffv1": {
        source: "iana"
      },
      "video/flexfec": {
        source: "iana"
      },
      "video/h261": {
        source: "iana",
        extensions: ["h261"]
      },
      "video/h263": {
        source: "iana",
        extensions: ["h263"]
      },
      "video/h263-1998": {
        source: "iana"
      },
      "video/h263-2000": {
        source: "iana"
      },
      "video/h264": {
        source: "iana",
        extensions: ["h264"]
      },
      "video/h264-rcdo": {
        source: "iana"
      },
      "video/h264-svc": {
        source: "iana"
      },
      "video/h265": {
        source: "iana"
      },
      "video/h266": {
        source: "iana"
      },
      "video/iso.segment": {
        source: "iana",
        extensions: ["m4s"]
      },
      "video/jpeg": {
        source: "iana",
        extensions: ["jpgv"]
      },
      "video/jpeg2000": {
        source: "iana"
      },
      "video/jpm": {
        source: "apache",
        extensions: ["jpm", "jpgm"]
      },
      "video/jxsv": {
        source: "iana"
      },
      "video/lottie+json": {
        source: "iana",
        compressible: true
      },
      "video/matroska": {
        source: "iana"
      },
      "video/matroska-3d": {
        source: "iana"
      },
      "video/mj2": {
        source: "iana",
        extensions: ["mj2", "mjp2"]
      },
      "video/mp1s": {
        source: "iana"
      },
      "video/mp2p": {
        source: "iana"
      },
      "video/mp2t": {
        source: "iana",
        extensions: ["ts", "m2t", "m2ts", "mts"]
      },
      "video/mp4": {
        source: "iana",
        compressible: false,
        extensions: ["mp4", "mp4v", "mpg4"]
      },
      "video/mp4v-es": {
        source: "iana"
      },
      "video/mpeg": {
        source: "iana",
        compressible: false,
        extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"]
      },
      "video/mpeg4-generic": {
        source: "iana"
      },
      "video/mpv": {
        source: "iana"
      },
      "video/nv": {
        source: "iana"
      },
      "video/ogg": {
        source: "iana",
        compressible: false,
        extensions: ["ogv"]
      },
      "video/parityfec": {
        source: "iana"
      },
      "video/pointer": {
        source: "iana"
      },
      "video/quicktime": {
        source: "iana",
        compressible: false,
        extensions: ["qt", "mov"]
      },
      "video/raptorfec": {
        source: "iana"
      },
      "video/raw": {
        source: "iana"
      },
      "video/rtp-enc-aescm128": {
        source: "iana"
      },
      "video/rtploopback": {
        source: "iana"
      },
      "video/rtx": {
        source: "iana"
      },
      "video/scip": {
        source: "iana"
      },
      "video/smpte291": {
        source: "iana"
      },
      "video/smpte292m": {
        source: "iana"
      },
      "video/ulpfec": {
        source: "iana"
      },
      "video/vc1": {
        source: "iana"
      },
      "video/vc2": {
        source: "iana"
      },
      "video/vnd.cctv": {
        source: "iana"
      },
      "video/vnd.dece.hd": {
        source: "iana",
        extensions: ["uvh", "uvvh"]
      },
      "video/vnd.dece.mobile": {
        source: "iana",
        extensions: ["uvm", "uvvm"]
      },
      "video/vnd.dece.mp4": {
        source: "iana"
      },
      "video/vnd.dece.pd": {
        source: "iana",
        extensions: ["uvp", "uvvp"]
      },
      "video/vnd.dece.sd": {
        source: "iana",
        extensions: ["uvs", "uvvs"]
      },
      "video/vnd.dece.video": {
        source: "iana",
        extensions: ["uvv", "uvvv"]
      },
      "video/vnd.directv.mpeg": {
        source: "iana"
      },
      "video/vnd.directv.mpeg-tts": {
        source: "iana"
      },
      "video/vnd.dlna.mpeg-tts": {
        source: "iana"
      },
      "video/vnd.dvb.file": {
        source: "iana",
        extensions: ["dvb"]
      },
      "video/vnd.fvt": {
        source: "iana",
        extensions: ["fvt"]
      },
      "video/vnd.hns.video": {
        source: "iana"
      },
      "video/vnd.iptvforum.1dparityfec-1010": {
        source: "iana"
      },
      "video/vnd.iptvforum.1dparityfec-2005": {
        source: "iana"
      },
      "video/vnd.iptvforum.2dparityfec-1010": {
        source: "iana"
      },
      "video/vnd.iptvforum.2dparityfec-2005": {
        source: "iana"
      },
      "video/vnd.iptvforum.ttsavc": {
        source: "iana"
      },
      "video/vnd.iptvforum.ttsmpeg2": {
        source: "iana"
      },
      "video/vnd.motorola.video": {
        source: "iana"
      },
      "video/vnd.motorola.videop": {
        source: "iana"
      },
      "video/vnd.mpegurl": {
        source: "iana",
        extensions: ["mxu", "m4u"]
      },
      "video/vnd.ms-playready.media.pyv": {
        source: "iana",
        extensions: ["pyv"]
      },
      "video/vnd.nokia.interleaved-multimedia": {
        source: "iana"
      },
      "video/vnd.nokia.mp4vr": {
        source: "iana"
      },
      "video/vnd.nokia.videovoip": {
        source: "iana"
      },
      "video/vnd.objectvideo": {
        source: "iana"
      },
      "video/vnd.planar": {
        source: "iana"
      },
      "video/vnd.radgamettools.bink": {
        source: "iana"
      },
      "video/vnd.radgamettools.smacker": {
        source: "apache"
      },
      "video/vnd.sealed.mpeg1": {
        source: "iana"
      },
      "video/vnd.sealed.mpeg4": {
        source: "iana"
      },
      "video/vnd.sealed.swf": {
        source: "iana"
      },
      "video/vnd.sealedmedia.softseal.mov": {
        source: "iana"
      },
      "video/vnd.uvvu.mp4": {
        source: "iana",
        extensions: ["uvu", "uvvu"]
      },
      "video/vnd.vivo": {
        source: "iana",
        extensions: ["viv"]
      },
      "video/vnd.youtube.yt": {
        source: "iana"
      },
      "video/vp8": {
        source: "iana"
      },
      "video/vp9": {
        source: "iana"
      },
      "video/webm": {
        source: "apache",
        compressible: false,
        extensions: ["webm"]
      },
      "video/x-f4v": {
        source: "apache",
        extensions: ["f4v"]
      },
      "video/x-fli": {
        source: "apache",
        extensions: ["fli"]
      },
      "video/x-flv": {
        source: "apache",
        compressible: false,
        extensions: ["flv"]
      },
      "video/x-m4v": {
        source: "apache",
        extensions: ["m4v"]
      },
      "video/x-matroska": {
        source: "apache",
        compressible: false,
        extensions: ["mkv", "mk3d", "mks"]
      },
      "video/x-mng": {
        source: "apache",
        extensions: ["mng"]
      },
      "video/x-ms-asf": {
        source: "apache",
        extensions: ["asf", "asx"]
      },
      "video/x-ms-vob": {
        source: "apache",
        extensions: ["vob"]
      },
      "video/x-ms-wm": {
        source: "apache",
        extensions: ["wm"]
      },
      "video/x-ms-wmv": {
        source: "apache",
        compressible: false,
        extensions: ["wmv"]
      },
      "video/x-ms-wmx": {
        source: "apache",
        extensions: ["wmx"]
      },
      "video/x-ms-wvx": {
        source: "apache",
        extensions: ["wvx"]
      },
      "video/x-msvideo": {
        source: "apache",
        extensions: ["avi"]
      },
      "video/x-sgi-movie": {
        source: "apache",
        extensions: ["movie"]
      },
      "video/x-smv": {
        source: "apache",
        extensions: ["smv"]
      },
      "x-conference/x-cooltalk": {
        source: "apache",
        extensions: ["ice"]
      },
      "x-shader/x-fragment": {
        compressible: true
      },
      "x-shader/x-vertex": {
        compressible: true
      }
    };
  }
});

// node_modules/mime-db/index.js
var require_mime_db = __commonJS({
  "node_modules/mime-db/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_db();
  }
});

// node_modules/mime-types/mimeScore.js
var require_mimeScore = __commonJS({
  "node_modules/mime-types/mimeScore.js"(exports2, module2) {
    "use strict";
    var FACET_SCORES = {
      "prs.": 100,
      "x-": 200,
      "x.": 300,
      "vnd.": 400,
      default: 900
    };
    var SOURCE_SCORES = {
      nginx: 10,
      apache: 20,
      iana: 40,
      default: 30
      // definitions added by `jshttp/mime-db` project?
    };
    var TYPE_SCORES = {
      // prefer application/xml over text/xml
      // prefer application/rtf over text/rtf
      application: 1,
      // prefer font/woff over application/font-woff
      font: 2,
      // prefer video/mp4 over audio/mp4 over application/mp4
      // See https://www.rfc-editor.org/rfc/rfc4337.html#section-2
      audio: 2,
      video: 3,
      default: 0
    };
    module2.exports = function mimeScore(mimeType, source = "default") {
      if (mimeType === "application/octet-stream") {
        return 0;
      }
      const [type, subtype] = mimeType.split("/");
      const facet = subtype.replace(/(\.|x-).*/, "$1");
      const facetScore = FACET_SCORES[facet] || FACET_SCORES.default;
      const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default;
      const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default;
      const lengthScore = 1 - mimeType.length / 100;
      return facetScore + sourceScore + typeScore + lengthScore;
    };
  }
});

// node_modules/mime-types/index.js
var require_mime_types = __commonJS({
  "node_modules/mime-types/index.js"(exports2) {
    "use strict";
    var db2 = require_mime_db();
    var extname = require("path").extname;
    var mimeScore = require_mimeScore();
    var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
    var TEXT_TYPE_REGEXP = /^text\//i;
    exports2.charset = charset;
    exports2.charsets = { lookup: charset };
    exports2.contentType = contentType;
    exports2.extension = extension;
    exports2.extensions = /* @__PURE__ */ Object.create(null);
    exports2.lookup = lookup;
    exports2.types = /* @__PURE__ */ Object.create(null);
    exports2._extensionConflicts = [];
    populateMaps(exports2.extensions, exports2.types);
    function charset(type) {
      if (!type || typeof type !== "string") {
        return false;
      }
      var match = EXTRACT_TYPE_REGEXP.exec(type);
      var mime = match && db2[match[1].toLowerCase()];
      if (mime && mime.charset) {
        return mime.charset;
      }
      if (match && TEXT_TYPE_REGEXP.test(match[1])) {
        return "UTF-8";
      }
      return false;
    }
    function contentType(str) {
      if (!str || typeof str !== "string") {
        return false;
      }
      var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str;
      if (!mime) {
        return false;
      }
      if (mime.indexOf("charset") === -1) {
        var charset2 = exports2.charset(mime);
        if (charset2) mime += "; charset=" + charset2.toLowerCase();
      }
      return mime;
    }
    function extension(type) {
      if (!type || typeof type !== "string") {
        return false;
      }
      var match = EXTRACT_TYPE_REGEXP.exec(type);
      var exts = match && exports2.extensions[match[1].toLowerCase()];
      if (!exts || !exts.length) {
        return false;
      }
      return exts[0];
    }
    function lookup(path33) {
      if (!path33 || typeof path33 !== "string") {
        return false;
      }
      var extension2 = extname("x." + path33).toLowerCase().slice(1);
      if (!extension2) {
        return false;
      }
      return exports2.types[extension2] || false;
    }
    function populateMaps(extensions, types) {
      Object.keys(db2).forEach(function forEachMimeType(type) {
        var mime = db2[type];
        var exts = mime.extensions;
        if (!exts || !exts.length) {
          return;
        }
        extensions[type] = exts;
        for (var i = 0; i < exts.length; i++) {
          var extension2 = exts[i];
          types[extension2] = _preferredType(extension2, types[extension2], type);
          const legacyType = _preferredTypeLegacy(
            extension2,
            types[extension2],
            type
          );
          if (legacyType !== types[extension2]) {
            exports2._extensionConflicts.push([extension2, legacyType, types[extension2]]);
          }
        }
      });
    }
    function _preferredType(ext, type0, type1) {
      var score0 = type0 ? mimeScore(type0, db2[type0].source) : 0;
      var score1 = type1 ? mimeScore(type1, db2[type1].source) : 0;
      return score0 > score1 ? type0 : type1;
    }
    function _preferredTypeLegacy(ext, type0, type1) {
      var SOURCE_RANK = ["nginx", "apache", void 0, "iana"];
      var score0 = type0 ? SOURCE_RANK.indexOf(db2[type0].source) : 0;
      var score1 = type1 ? SOURCE_RANK.indexOf(db2[type1].source) : 0;
      if (exports2.types[extension] !== "application/octet-stream" && (score0 > score1 || score0 === score1 && exports2.types[extension]?.slice(0, 12) === "application/")) {
        return type0;
      }
      return score0 > score1 ? type0 : type1;
    }
  }
});

// node_modules/media-typer/index.js
var require_media_typer = __commonJS({
  "node_modules/media-typer/index.js"(exports2) {
    "use strict";
    var SUBTYPE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.-]{0,126}$/;
    var TYPE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}$/;
    var TYPE_REGEXP = /^ *([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}) *$/;
    exports2.format = format;
    exports2.parse = parse4;
    exports2.test = test2;
    function format(obj) {
      if (!obj || typeof obj !== "object") {
        throw new TypeError("argument obj is required");
      }
      var subtype = obj.subtype;
      var suffix = obj.suffix;
      var type = obj.type;
      if (!type || !TYPE_NAME_REGEXP.test(type)) {
        throw new TypeError("invalid type");
      }
      if (!subtype || !SUBTYPE_NAME_REGEXP.test(subtype)) {
        throw new TypeError("invalid subtype");
      }
      var string5 = type + "/" + subtype;
      if (suffix) {
        if (!TYPE_NAME_REGEXP.test(suffix)) {
          throw new TypeError("invalid suffix");
        }
        string5 += "+" + suffix;
      }
      return string5;
    }
    function test2(string5) {
      if (!string5) {
        throw new TypeError("argument string is required");
      }
      if (typeof string5 !== "string") {
        throw new TypeError("argument string is required to be a string");
      }
      return TYPE_REGEXP.test(string5.toLowerCase());
    }
    function parse4(string5) {
      if (!string5) {
        throw new TypeError("argument string is required");
      }
      if (typeof string5 !== "string") {
        throw new TypeError("argument string is required to be a string");
      }
      var match = TYPE_REGEXP.exec(string5.toLowerCase());
      if (!match) {
        throw new TypeError("invalid media type");
      }
      var type = match[1];
      var subtype = match[2];
      var suffix;
      var index = subtype.lastIndexOf("+");
      if (index !== -1) {
        suffix = subtype.substr(index + 1);
        subtype = subtype.substr(0, index);
      }
      return new MediaType(type, subtype, suffix);
    }
    function MediaType(type, subtype, suffix) {
      this.type = type;
      this.subtype = subtype;
      this.suffix = suffix;
    }
  }
});

// node_modules/type-is/index.js
var require_type_is = __commonJS({
  "node_modules/type-is/index.js"(exports2, module2) {
    "use strict";
    var contentType = require_content_type();
    var mime = require_mime_types();
    var typer = require_media_typer();
    module2.exports = typeofrequest;
    module2.exports.is = typeis;
    module2.exports.hasBody = hasbody;
    module2.exports.normalize = normalize;
    module2.exports.match = mimeMatch;
    function typeis(value, types_) {
      var i;
      var types = types_;
      var val = tryNormalizeType(value);
      if (!val) {
        return false;
      }
      if (types && !Array.isArray(types)) {
        types = new Array(arguments.length - 1);
        for (i = 0; i < types.length; i++) {
          types[i] = arguments[i + 1];
        }
      }
      if (!types || !types.length) {
        return val;
      }
      var type;
      for (i = 0; i < types.length; i++) {
        if (mimeMatch(normalize(type = types[i]), val)) {
          return type[0] === "+" || type.indexOf("*") !== -1 ? val : type;
        }
      }
      return false;
    }
    function hasbody(req) {
      return req.headers["transfer-encoding"] !== void 0 || !isNaN(req.headers["content-length"]);
    }
    function typeofrequest(req, types_) {
      if (!hasbody(req)) return null;
      var types = arguments.length > 2 ? Array.prototype.slice.call(arguments, 1) : types_;
      var value = req.headers["content-type"];
      return typeis(value, types);
    }
    function normalize(type) {
      if (typeof type !== "string") {
        return false;
      }
      switch (type) {
        case "urlencoded":
          return "application/x-www-form-urlencoded";
        case "multipart":
          return "multipart/*";
      }
      if (type[0] === "+") {
        return "*/*" + type;
      }
      return type.indexOf("/") === -1 ? mime.lookup(type) : type;
    }
    function mimeMatch(expected, actual) {
      if (expected === false) {
        return false;
      }
      var actualParts = actual.split("/");
      var expectedParts = expected.split("/");
      if (actualParts.length !== 2 || expectedParts.length !== 2) {
        return false;
      }
      if (expectedParts[0] !== "*" && expectedParts[0] !== actualParts[0]) {
        return false;
      }
      if (expectedParts[1].slice(0, 2) === "*+") {
        return expectedParts[1].length <= actualParts[1].length + 1 && expectedParts[1].slice(1) === actualParts[1].slice(1 - expectedParts[1].length);
      }
      if (expectedParts[1] !== "*" && expectedParts[1] !== actualParts[1]) {
        return false;
      }
      return true;
    }
    function normalizeType(value) {
      var type = contentType.parse(value).type;
      return typer.test(type) ? type : null;
    }
    function tryNormalizeType(value) {
      try {
        return value ? normalizeType(value) : null;
      } catch (err) {
        return null;
      }
    }
  }
});

// node_modules/body-parser/lib/utils.js
var require_utils = __commonJS({
  "node_modules/body-parser/lib/utils.js"(exports2, module2) {
    "use strict";
    var bytes = require_bytes();
    var contentType = require_content_type();
    var typeis = require_type_is();
    module2.exports = {
      getCharset,
      normalizeOptions,
      passthrough
    };
    function getCharset(req) {
      try {
        return (contentType.parse(req).parameters.charset || "").toLowerCase();
      } catch {
        return void 0;
      }
    }
    function typeChecker(type) {
      return function checkType(req) {
        return Boolean(typeis(req, type));
      };
    }
    function normalizeOptions(options, defaultType) {
      if (!defaultType) {
        throw new TypeError("defaultType must be provided");
      }
      var inflate = options?.inflate !== false;
      var limit = typeof options?.limit !== "number" ? bytes.parse(options?.limit || "100kb") : options?.limit;
      var type = options?.type || defaultType;
      var verify = options?.verify || false;
      var defaultCharset = options?.defaultCharset || "utf-8";
      if (verify !== false && typeof verify !== "function") {
        throw new TypeError("option verify must be function");
      }
      var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
      return {
        inflate,
        limit,
        verify,
        defaultCharset,
        shouldParse
      };
    }
    function passthrough(value) {
      return value;
    }
  }
});

// node_modules/body-parser/lib/read.js
var require_read = __commonJS({
  "node_modules/body-parser/lib/read.js"(exports2, module2) {
    "use strict";
    var createError = require_http_errors();
    var getBody = require_raw_body();
    var iconv = require_lib();
    var onFinished = require_on_finished();
    var zlib2 = require("node:zlib");
    var hasBody = require_type_is().hasBody;
    var { getCharset } = require_utils();
    module2.exports = read;
    function read(req, res, next, parse4, debug, options) {
      if (onFinished.isFinished(req)) {
        debug("body already parsed");
        next();
        return;
      }
      if (!("body" in req)) {
        req.body = void 0;
      }
      if (!hasBody(req)) {
        debug("skip empty body");
        next();
        return;
      }
      debug("content-type %j", req.headers["content-type"]);
      if (!options.shouldParse(req)) {
        debug("skip parsing");
        next();
        return;
      }
      var encoding = null;
      if (options?.skipCharset !== true) {
        encoding = getCharset(req) || options.defaultCharset;
        if (!!options?.isValidCharset && !options.isValidCharset(encoding)) {
          debug("invalid charset");
          next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
            charset: encoding,
            type: "charset.unsupported"
          }));
          return;
        }
      }
      var length;
      var opts = options;
      var stream4;
      var verify = opts.verify;
      try {
        stream4 = contentstream(req, debug, opts.inflate);
        length = stream4.length;
        stream4.length = void 0;
      } catch (err) {
        return next(err);
      }
      opts.length = length;
      opts.encoding = verify ? null : encoding;
      if (opts.encoding === null && encoding !== null && !iconv.encodingExists(encoding)) {
        return next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
          charset: encoding.toLowerCase(),
          type: "charset.unsupported"
        }));
      }
      debug("read body");
      getBody(stream4, opts, function(error73, body) {
        if (error73) {
          var _error;
          if (error73.type === "encoding.unsupported") {
            _error = createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
              charset: encoding.toLowerCase(),
              type: "charset.unsupported"
            });
          } else {
            _error = createError(400, error73);
          }
          if (stream4 !== req) {
            req.unpipe();
            stream4.destroy();
          }
          dump(req, function onfinished() {
            next(createError(400, _error));
          });
          return;
        }
        if (verify) {
          try {
            debug("verify body");
            verify(req, res, body, encoding);
          } catch (err) {
            next(createError(403, err, {
              body,
              type: err.type || "entity.verify.failed"
            }));
            return;
          }
        }
        var str = body;
        try {
          debug("parse body");
          str = typeof body !== "string" && encoding !== null ? iconv.decode(body, encoding) : body;
          req.body = parse4(str, encoding);
        } catch (err) {
          next(createError(400, err, {
            body: str,
            type: err.type || "entity.parse.failed"
          }));
          return;
        }
        next();
      });
    }
    function contentstream(req, debug, inflate) {
      var encoding = (req.headers["content-encoding"] || "identity").toLowerCase();
      var length = req.headers["content-length"];
      debug('content-encoding "%s"', encoding);
      if (inflate === false && encoding !== "identity") {
        throw createError(415, "content encoding unsupported", {
          encoding,
          type: "encoding.unsupported"
        });
      }
      if (encoding === "identity") {
        req.length = length;
        return req;
      }
      var stream4 = createDecompressionStream(encoding, debug);
      req.pipe(stream4);
      return stream4;
    }
    function createDecompressionStream(encoding, debug) {
      switch (encoding) {
        case "deflate":
          debug("inflate body");
          return zlib2.createInflate();
        case "gzip":
          debug("gunzip body");
          return zlib2.createGunzip();
        case "br":
          debug("brotli decompress body");
          return zlib2.createBrotliDecompress();
        default:
          throw createError(415, 'unsupported content encoding "' + encoding + '"', {
            encoding,
            type: "encoding.unsupported"
          });
      }
    }
    function dump(req, callback) {
      if (onFinished.isFinished(req)) {
        callback(null);
      } else {
        onFinished(req, callback);
        req.resume();
      }
    }
  }
});

// node_modules/body-parser/lib/types/json.js
var require_json = __commonJS({
  "node_modules/body-parser/lib/types/json.js"(exports2, module2) {
    "use strict";
    var debug = require_src()("body-parser:json");
    var read = require_read();
    var { normalizeOptions } = require_utils();
    module2.exports = json4;
    var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/;
    var JSON_SYNTAX_CHAR = "#";
    var JSON_SYNTAX_REGEXP = /#+/g;
    function json4(options) {
      const normalizedOptions = normalizeOptions(options, "application/json");
      var reviver = options?.reviver;
      var strict = options?.strict !== false;
      function parse4(body) {
        if (body.length === 0) {
          return {};
        }
        if (strict) {
          var first = firstchar(body);
          if (first !== "{" && first !== "[") {
            debug("strict violation");
            throw createStrictSyntaxError(body, first);
          }
        }
        try {
          debug("parse json");
          return JSON.parse(body, reviver);
        } catch (e) {
          throw normalizeJsonSyntaxError(e, {
            message: e.message,
            stack: e.stack
          });
        }
      }
      const readOptions = {
        ...normalizedOptions,
        // assert charset per RFC 7159 sec 8.1
        isValidCharset: (charset) => charset.slice(0, 4) === "utf-"
      };
      return function jsonParser(req, res, next) {
        read(req, res, next, parse4, debug, readOptions);
      };
    }
    function createStrictSyntaxError(str, char) {
      var index = str.indexOf(char);
      var partial3 = "";
      if (index !== -1) {
        partial3 = str.substring(0, index) + JSON_SYNTAX_CHAR.repeat(str.length - index);
      }
      try {
        JSON.parse(partial3);
        throw new SyntaxError("strict violation");
      } catch (e) {
        return normalizeJsonSyntaxError(e, {
          message: e.message.replace(JSON_SYNTAX_REGEXP, function(placeholder) {
            return str.substring(index, index + placeholder.length);
          }),
          stack: e.stack
        });
      }
    }
    function firstchar(str) {
      var match = FIRST_CHAR_REGEXP.exec(str);
      return match ? match[1] : void 0;
    }
    function normalizeJsonSyntaxError(error73, obj) {
      var keys2 = Object.getOwnPropertyNames(error73);
      for (var i = 0; i < keys2.length; i++) {
        var key = keys2[i];
        if (key !== "stack" && key !== "message") {
          delete error73[key];
        }
      }
      error73.stack = obj.stack.replace(error73.message, obj.message);
      error73.message = obj.message;
      return error73;
    }
  }
});

// node_modules/body-parser/lib/types/raw.js
var require_raw = __commonJS({
  "node_modules/body-parser/lib/types/raw.js"(exports2, module2) {
    "use strict";
    var debug = require_src()("body-parser:raw");
    var read = require_read();
    var { normalizeOptions, passthrough } = require_utils();
    module2.exports = raw;
    function raw(options) {
      const normalizedOptions = normalizeOptions(options, "application/octet-stream");
      const readOptions = {
        ...normalizedOptions,
        // Skip charset validation and parse the body as is
        skipCharset: true
      };
      return function rawParser(req, res, next) {
        read(req, res, next, passthrough, debug, readOptions);
      };
    }
  }
});

// node_modules/body-parser/lib/types/text.js
var require_text = __commonJS({
  "node_modules/body-parser/lib/types/text.js"(exports2, module2) {
    "use strict";
    var debug = require_src()("body-parser:text");
    var read = require_read();
    var { normalizeOptions, passthrough } = require_utils();
    module2.exports = text2;
    function text2(options) {
      const normalizedOptions = normalizeOptions(options, "text/plain");
      return function textParser(req, res, next) {
        read(req, res, next, passthrough, debug, normalizedOptions);
      };
    }
  }
});

// node_modules/es-errors/type.js
var require_type = __commonJS({
  "node_modules/es-errors/type.js"(exports2, module2) {
    "use strict";
    module2.exports = TypeError;
  }
});

// node_modules/object-inspect/util.inspect.js
var require_util_inspect = __commonJS({
  "node_modules/object-inspect/util.inspect.js"(exports2, module2) {
    "use strict";
    module2.exports = require("util").inspect;
  }
});

// node_modules/object-inspect/index.js
var require_object_inspect = __commonJS({
  "node_modules/object-inspect/index.js"(exports2, module2) {
    "use strict";
    var hasMap = typeof Map === "function" && Map.prototype;
    var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
    var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
    var mapForEach = hasMap && Map.prototype.forEach;
    var hasSet = typeof Set === "function" && Set.prototype;
    var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null;
    var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null;
    var setForEach = hasSet && Set.prototype.forEach;
    var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype;
    var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
    var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype;
    var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
    var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype;
    var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
    var booleanValueOf = Boolean.prototype.valueOf;
    var objectToString2 = Object.prototype.toString;
    var functionToString = Function.prototype.toString;
    var $match = String.prototype.match;
    var $slice = String.prototype.slice;
    var $replace = String.prototype.replace;
    var $toUpperCase = String.prototype.toUpperCase;
    var $toLowerCase = String.prototype.toLowerCase;
    var $test = RegExp.prototype.test;
    var $concat = Array.prototype.concat;
    var $join = Array.prototype.join;
    var $arrSlice = Array.prototype.slice;
    var $floor = Math.floor;
    var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
    var gOPS = Object.getOwnPropertySymbols;
    var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null;
    var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object";
    var toStringTag2 = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null;
    var isEnumerable = Object.prototype.propertyIsEnumerable;
    var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
      return O.__proto__;
    } : null);
    function addNumericSeparator(num, str) {
      if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {
        return str;
      }
      var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
      if (typeof num === "number") {
        var int3 = num < 0 ? -$floor(-num) : $floor(num);
        if (int3 !== num) {
          var intStr = String(int3);
          var dec = $slice.call(str, intStr.length + 1);
          return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
        }
      }
      return $replace.call(str, sepRegex, "$&_");
    }
    var utilInspect = require_util_inspect();
    var inspectCustom = utilInspect.custom;
    var inspectSymbol = isSymbol2(inspectCustom) ? inspectCustom : null;
    var quotes = {
      __proto__: null,
      "double": '"',
      single: "'"
    };
    var quoteREs = {
      __proto__: null,
      "double": /(["\\])/g,
      single: /(['\\])/g
    };
    module2.exports = function inspect_(obj, options, depth, seen) {
      var opts = options || {};
      if (has(opts, "quoteStyle") && !has(quotes, opts.quoteStyle)) {
        throw new TypeError('option "quoteStyle" must be "single" or "double"');
      }
      if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {
        throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
      }
      var customInspect = has(opts, "customInspect") ? opts.customInspect : true;
      if (typeof customInspect !== "boolean" && customInspect !== "symbol") {
        throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
      }
      if (has(opts, "indent") && opts.indent !== null && opts.indent !== "	" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {
        throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
      }
      if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") {
        throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
      }
      var numericSeparator = opts.numericSeparator;
      if (typeof obj === "undefined") {
        return "undefined";
      }
      if (obj === null) {
        return "null";
      }
      if (typeof obj === "boolean") {
        return obj ? "true" : "false";
      }
      if (typeof obj === "string") {
        return inspectString(obj, opts);
      }
      if (typeof obj === "number") {
        if (obj === 0) {
          return Infinity / obj > 0 ? "0" : "-0";
        }
        var str = String(obj);
        return numericSeparator ? addNumericSeparator(obj, str) : str;
      }
      if (typeof obj === "bigint") {
        var bigIntStr = String(obj) + "n";
        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
      }
      var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
      if (typeof depth === "undefined") {
        depth = 0;
      }
      if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") {
        return isArray3(obj) ? "[Array]" : "[Object]";
      }
      var indent = getIndent(opts, depth);
      if (typeof seen === "undefined") {
        seen = [];
      } else if (indexOf(seen, obj) >= 0) {
        return "[Circular]";
      }
      function inspect(value, from, noIndent) {
        if (from) {
          seen = $arrSlice.call(seen);
          seen.push(from);
        }
        if (noIndent) {
          var newOpts = {
            depth: opts.depth
          };
          if (has(opts, "quoteStyle")) {
            newOpts.quoteStyle = opts.quoteStyle;
          }
          return inspect_(value, newOpts, depth + 1, seen);
        }
        return inspect_(value, opts, depth + 1, seen);
      }
      if (typeof obj === "function" && !isRegExp2(obj)) {
        var name28 = nameOf(obj);
        var keys2 = arrObjKeys(obj, inspect);
        return "[Function" + (name28 ? ": " + name28 : " (anonymous)") + "]" + (keys2.length > 0 ? " { " + $join.call(keys2, ", ") + " }" : "");
      }
      if (isSymbol2(obj)) {
        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
        return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
      }
      if (isElement(obj)) {
        var s = "<" + $toLowerCase.call(String(obj.nodeName));
        var attrs = obj.attributes || [];
        for (var i = 0; i < attrs.length; i++) {
          s += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts);
        }
        s += ">";
        if (obj.childNodes && obj.childNodes.length) {
          s += "...";
        }
        s += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
        return s;
      }
      if (isArray3(obj)) {
        if (obj.length === 0) {
          return "[]";
        }
        var xs = arrObjKeys(obj, inspect);
        if (indent && !singleLineValues(xs)) {
          return "[" + indentedJoin(xs, indent) + "]";
        }
        return "[ " + $join.call(xs, ", ") + " ]";
      }
      if (isError(obj)) {
        var parts = arrObjKeys(obj, inspect);
        if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) {
          return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect(obj.cause), parts), ", ") + " }";
        }
        if (parts.length === 0) {
          return "[" + String(obj) + "]";
        }
        return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
      }
      if (typeof obj === "object" && customInspect) {
        if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) {
          return utilInspect(obj, { depth: maxDepth - depth });
        } else if (customInspect !== "symbol" && typeof obj.inspect === "function") {
          return obj.inspect();
        }
      }
      if (isMap(obj)) {
        var mapParts = [];
        if (mapForEach) {
          mapForEach.call(obj, function(value, key) {
            mapParts.push(inspect(key, obj, true) + " => " + inspect(value, obj));
          });
        }
        return collectionOf("Map", mapSize.call(obj), mapParts, indent);
      }
      if (isSet(obj)) {
        var setParts = [];
        if (setForEach) {
          setForEach.call(obj, function(value) {
            setParts.push(inspect(value, obj));
          });
        }
        return collectionOf("Set", setSize.call(obj), setParts, indent);
      }
      if (isWeakMap(obj)) {
        return weakCollectionOf("WeakMap");
      }
      if (isWeakSet(obj)) {
        return weakCollectionOf("WeakSet");
      }
      if (isWeakRef(obj)) {
        return weakCollectionOf("WeakRef");
      }
      if (isNumber2(obj)) {
        return markBoxed(inspect(Number(obj)));
      }
      if (isBigInt(obj)) {
        return markBoxed(inspect(bigIntValueOf.call(obj)));
      }
      if (isBoolean2(obj)) {
        return markBoxed(booleanValueOf.call(obj));
      }
      if (isString2(obj)) {
        return markBoxed(inspect(String(obj)));
      }
      if (typeof window !== "undefined" && obj === window) {
        return "{ [object Window] }";
      }
      if (typeof globalThis !== "undefined" && obj === globalThis || typeof global !== "undefined" && obj === global) {
        return "{ [object globalThis] }";
      }
      if (!isDate2(obj) && !isRegExp2(obj)) {
        var ys = arrObjKeys(obj, inspect);
        var isPlainObject4 = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
        var protoTag = obj instanceof Object ? "" : "null prototype";
        var stringTag3 = !isPlainObject4 && toStringTag2 && Object(obj) === obj && toStringTag2 in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
        var constructorTag = isPlainObject4 || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
        var tag = constructorTag + (stringTag3 || protoTag ? "[" + $join.call($concat.call([], stringTag3 || [], protoTag || []), ": ") + "] " : "");
        if (ys.length === 0) {
          return tag + "{}";
        }
        if (indent) {
          return tag + "{" + indentedJoin(ys, indent) + "}";
        }
        return tag + "{ " + $join.call(ys, ", ") + " }";
      }
      return String(obj);
    };
    function wrapQuotes(s, defaultStyle, opts) {
      var style = opts.quoteStyle || defaultStyle;
      var quoteChar = quotes[style];
      return quoteChar + s + quoteChar;
    }
    function quote(s) {
      return $replace.call(String(s), /"/g, "&quot;");
    }
    function canTrustToString(obj) {
      return !toStringTag2 || !(typeof obj === "object" && (toStringTag2 in obj || typeof obj[toStringTag2] !== "undefined"));
    }
    function isArray3(obj) {
      return toStr(obj) === "[object Array]" && canTrustToString(obj);
    }
    function isDate2(obj) {
      return toStr(obj) === "[object Date]" && canTrustToString(obj);
    }
    function isRegExp2(obj) {
      return toStr(obj) === "[object RegExp]" && canTrustToString(obj);
    }
    function isError(obj) {
      return toStr(obj) === "[object Error]" && canTrustToString(obj);
    }
    function isString2(obj) {
      return toStr(obj) === "[object String]" && canTrustToString(obj);
    }
    function isNumber2(obj) {
      return toStr(obj) === "[object Number]" && canTrustToString(obj);
    }
    function isBoolean2(obj) {
      return toStr(obj) === "[object Boolean]" && canTrustToString(obj);
    }
    function isSymbol2(obj) {
      if (hasShammedSymbols) {
        return obj && typeof obj === "object" && obj instanceof Symbol;
      }
      if (typeof obj === "symbol") {
        return true;
      }
      if (!obj || typeof obj !== "object" || !symToString) {
        return false;
      }
      try {
        symToString.call(obj);
        return true;
      } catch (e) {
      }
      return false;
    }
    function isBigInt(obj) {
      if (!obj || typeof obj !== "object" || !bigIntValueOf) {
        return false;
      }
      try {
        bigIntValueOf.call(obj);
        return true;
      } catch (e) {
      }
      return false;
    }
    var hasOwn = Object.prototype.hasOwnProperty || function(key) {
      return key in this;
    };
    function has(obj, key) {
      return hasOwn.call(obj, key);
    }
    function toStr(obj) {
      return objectToString2.call(obj);
    }
    function nameOf(f) {
      if (f.name) {
        return f.name;
      }
      var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
      if (m) {
        return m[1];
      }
      return null;
    }
    function indexOf(xs, x) {
      if (xs.indexOf) {
        return xs.indexOf(x);
      }
      for (var i = 0, l = xs.length; i < l; i++) {
        if (xs[i] === x) {
          return i;
        }
      }
      return -1;
    }
    function isMap(x) {
      if (!mapSize || !x || typeof x !== "object") {
        return false;
      }
      try {
        mapSize.call(x);
        try {
          setSize.call(x);
        } catch (s) {
          return true;
        }
        return x instanceof Map;
      } catch (e) {
      }
      return false;
    }
    function isWeakMap(x) {
      if (!weakMapHas || !x || typeof x !== "object") {
        return false;
      }
      try {
        weakMapHas.call(x, weakMapHas);
        try {
          weakSetHas.call(x, weakSetHas);
        } catch (s) {
          return true;
        }
        return x instanceof WeakMap;
      } catch (e) {
      }
      return false;
    }
    function isWeakRef(x) {
      if (!weakRefDeref || !x || typeof x !== "object") {
        return false;
      }
      try {
        weakRefDeref.call(x);
        return true;
      } catch (e) {
      }
      return false;
    }
    function isSet(x) {
      if (!setSize || !x || typeof x !== "object") {
        return false;
      }
      try {
        setSize.call(x);
        try {
          mapSize.call(x);
        } catch (m) {
          return true;
        }
        return x instanceof Set;
      } catch (e) {
      }
      return false;
    }
    function isWeakSet(x) {
      if (!weakSetHas || !x || typeof x !== "object") {
        return false;
      }
      try {
        weakSetHas.call(x, weakSetHas);
        try {
          weakMapHas.call(x, weakMapHas);
        } catch (s) {
          return true;
        }
        return x instanceof WeakSet;
      } catch (e) {
      }
      return false;
    }
    function isElement(x) {
      if (!x || typeof x !== "object") {
        return false;
      }
      if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) {
        return true;
      }
      return typeof x.nodeName === "string" && typeof x.getAttribute === "function";
    }
    function inspectString(str, opts) {
      if (str.length > opts.maxStringLength) {
        var remaining = str.length - opts.maxStringLength;
        var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
      }
      var quoteRE = quoteREs[opts.quoteStyle || "single"];
      quoteRE.lastIndex = 0;
      var s = $replace.call($replace.call(str, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte);
      return wrapQuotes(s, "single", opts);
    }
    function lowbyte(c) {
      var n = c.charCodeAt(0);
      var x = {
        8: "b",
        9: "t",
        10: "n",
        12: "f",
        13: "r"
      }[n];
      if (x) {
        return "\\" + x;
      }
      return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16));
    }
    function markBoxed(str) {
      return "Object(" + str + ")";
    }
    function weakCollectionOf(type) {
      return type + " { ? }";
    }
    function collectionOf(type, size, entries, indent) {
      var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
      return type + " (" + size + ") {" + joinedEntries + "}";
    }
    function singleLineValues(xs) {
      for (var i = 0; i < xs.length; i++) {
        if (indexOf(xs[i], "\n") >= 0) {
          return false;
        }
      }
      return true;
    }
    function getIndent(opts, depth) {
      var baseIndent;
      if (opts.indent === "	") {
        baseIndent = "	";
      } else if (typeof opts.indent === "number" && opts.indent > 0) {
        baseIndent = $join.call(Array(opts.indent + 1), " ");
      } else {
        return null;
      }
      return {
        base: baseIndent,
        prev: $join.call(Array(depth + 1), baseIndent)
      };
    }
    function indentedJoin(xs, indent) {
      if (xs.length === 0) {
        return "";
      }
      var lineJoiner = "\n" + indent.prev + indent.base;
      return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
    }
    function arrObjKeys(obj, inspect) {
      var isArr = isArray3(obj);
      var xs = [];
      if (isArr) {
        xs.length = obj.length;
        for (var i = 0; i < obj.length; i++) {
          xs[i] = has(obj, i) ? inspect(obj[i], obj) : "";
        }
      }
      var syms = typeof gOPS === "function" ? gOPS(obj) : [];
      var symMap;
      if (hasShammedSymbols) {
        symMap = {};
        for (var k = 0; k < syms.length; k++) {
          symMap["$" + syms[k]] = syms[k];
        }
      }
      for (var key in obj) {
        if (!has(obj, key)) {
          continue;
        }
        if (isArr && String(Number(key)) === key && key < obj.length) {
          continue;
        }
        if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) {
          continue;
        } else if ($test.call(/[^\w$]/, key)) {
          xs.push(inspect(key, obj) + ": " + inspect(obj[key], obj));
        } else {
          xs.push(key + ": " + inspect(obj[key], obj));
        }
      }
      if (typeof gOPS === "function") {
        for (var j = 0; j < syms.length; j++) {
          if (isEnumerable.call(obj, syms[j])) {
            xs.push("[" + inspect(syms[j]) + "]: " + inspect(obj[syms[j]], obj));
          }
        }
      }
      return xs;
    }
  }
});

// node_modules/side-channel-list/index.js
var require_side_channel_list = __commonJS({
  "node_modules/side-channel-list/index.js"(exports2, module2) {
    "use strict";
    var inspect = require_object_inspect();
    var $TypeError = require_type();
    var listGetNode = function(list2, key, isDelete) {
      var prev = list2;
      var curr;
      for (; (curr = prev.next) != null; prev = curr) {
        if (curr.key === key) {
          prev.next = curr.next;
          if (!isDelete) {
            curr.next = /** @type {NonNullable<typeof list.next>} */
            list2.next;
            list2.next = curr;
          }
          return curr;
        }
      }
    };
    var listGet = function(objects, key) {
      if (!objects) {
        return void 0;
      }
      var node = listGetNode(objects, key);
      return node && node.value;
    };
    var listSet = function(objects, key, value) {
      var node = listGetNode(objects, key);
      if (node) {
        node.value = value;
      } else {
        objects.next = /** @type {import('./list.d.ts').ListNode<typeof value, typeof key>} */
        {
          // eslint-disable-line no-param-reassign, no-extra-parens
          key,
          next: objects.next,
          value
        };
      }
    };
    var listHas = function(objects, key) {
      if (!objects) {
        return false;
      }
      return !!listGetNode(objects, key);
    };
    var listDelete = function(objects, key) {
      if (objects) {
        return listGetNode(objects, key, true);
      }
    };
    module2.exports = function getSideChannelList() {
      var $o;
      var channel = {
        assert: function(key) {
          if (!channel.has(key)) {
            throw new $TypeError("Side channel does not contain " + inspect(key));
          }
        },
        "delete": function(key) {
          var root2 = $o && $o.next;
          var deletedNode = listDelete($o, key);
          if (deletedNode && root2 && root2 === deletedNode) {
            $o = void 0;
          }
          return !!deletedNode;
        },
        get: function(key) {
          return listGet($o, key);
        },
        has: function(key) {
          return listHas($o, key);
        },
        set: function(key, value) {
          if (!$o) {
            $o = {
              next: void 0
            };
          }
          listSet(
            /** @type {NonNullable<typeof $o>} */
            $o,
            key,
            value
          );
        }
      };
      return channel;
    };
  }
});

// node_modules/es-object-atoms/index.js
var require_es_object_atoms = __commonJS({
  "node_modules/es-object-atoms/index.js"(exports2, module2) {
    "use strict";
    module2.exports = Object;
  }
});

// node_modules/es-errors/index.js
var require_es_errors = __commonJS({
  "node_modules/es-errors/index.js"(exports2, module2) {
    "use strict";
    module2.exports = Error;
  }
});

// node_modules/es-errors/eval.js
var require_eval = __commonJS({
  "node_modules/es-errors/eval.js"(exports2, module2) {
    "use strict";
    module2.exports = EvalError;
  }
});

// node_modules/es-errors/range.js
var require_range = __commonJS({
  "node_modules/es-errors/range.js"(exports2, module2) {
    "use strict";
    module2.exports = RangeError;
  }
});

// node_modules/es-errors/ref.js
var require_ref = __commonJS({
  "node_modules/es-errors/ref.js"(exports2, module2) {
    "use strict";
    module2.exports = ReferenceError;
  }
});

// node_modules/es-errors/syntax.js
var require_syntax = __commonJS({
  "node_modules/es-errors/syntax.js"(exports2, module2) {
    "use strict";
    module2.exports = SyntaxError;
  }
});

// node_modules/es-errors/uri.js
var require_uri = __commonJS({
  "node_modules/es-errors/uri.js"(exports2, module2) {
    "use strict";
    module2.exports = URIError;
  }
});

// node_modules/math-intrinsics/abs.js
var require_abs = __commonJS({
  "node_modules/math-intrinsics/abs.js"(exports2, module2) {
    "use strict";
    module2.exports = Math.abs;
  }
});

// node_modules/math-intrinsics/floor.js
var require_floor = __commonJS({
  "node_modules/math-intrinsics/floor.js"(exports2, module2) {
    "use strict";
    module2.exports = Math.floor;
  }
});

// node_modules/math-intrinsics/max.js
var require_max = __commonJS({
  "node_modules/math-intrinsics/max.js"(exports2, module2) {
    "use strict";
    module2.exports = Math.max;
  }
});

// node_modules/math-intrinsics/min.js
var require_min = __commonJS({
  "node_modules/math-intrinsics/min.js"(exports2, module2) {
    "use strict";
    module2.exports = Math.min;
  }
});

// node_modules/math-intrinsics/pow.js
var require_pow = __commonJS({
  "node_modules/math-intrinsics/pow.js"(exports2, module2) {
    "use strict";
    module2.exports = Math.pow;
  }
});

// node_modules/math-intrinsics/round.js
var require_round = __commonJS({
  "node_modules/math-intrinsics/round.js"(exports2, module2) {
    "use strict";
    module2.exports = Math.round;
  }
});

// node_modules/math-intrinsics/isNaN.js
var require_isNaN = __commonJS({
  "node_modules/math-intrinsics/isNaN.js"(exports2, module2) {
    "use strict";
    module2.exports = Number.isNaN || function isNaN2(a) {
      return a !== a;
    };
  }
});

// node_modules/math-intrinsics/sign.js
var require_sign = __commonJS({
  "node_modules/math-intrinsics/sign.js"(exports2, module2) {
    "use strict";
    var $isNaN = require_isNaN();
    module2.exports = function sign(number5) {
      if ($isNaN(number5) || number5 === 0) {
        return number5;
      }
      return number5 < 0 ? -1 : 1;
    };
  }
});

// node_modules/gopd/gOPD.js
var require_gOPD = __commonJS({
  "node_modules/gopd/gOPD.js"(exports2, module2) {
    "use strict";
    module2.exports = Object.getOwnPropertyDescriptor;
  }
});

// node_modules/gopd/index.js
var require_gopd = __commonJS({
  "node_modules/gopd/index.js"(exports2, module2) {
    "use strict";
    var $gOPD = require_gOPD();
    if ($gOPD) {
      try {
        $gOPD([], "length");
      } catch (e) {
        $gOPD = null;
      }
    }
    module2.exports = $gOPD;
  }
});

// node_modules/es-define-property/index.js
var require_es_define_property = __commonJS({
  "node_modules/es-define-property/index.js"(exports2, module2) {
    "use strict";
    var $defineProperty = Object.defineProperty || false;
    if ($defineProperty) {
      try {
        $defineProperty({}, "a", { value: 1 });
      } catch (e) {
        $defineProperty = false;
      }
    }
    module2.exports = $defineProperty;
  }
});

// node_modules/has-symbols/shams.js
var require_shams = __commonJS({
  "node_modules/has-symbols/shams.js"(exports2, module2) {
    "use strict";
    module2.exports = function hasSymbols() {
      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
        return false;
      }
      if (typeof Symbol.iterator === "symbol") {
        return true;
      }
      var obj = {};
      var sym = /* @__PURE__ */ Symbol("test");
      var symObj = Object(sym);
      if (typeof sym === "string") {
        return false;
      }
      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
        return false;
      }
      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
        return false;
      }
      var symVal = 42;
      obj[sym] = symVal;
      for (var _ in obj) {
        return false;
      }
      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
        return false;
      }
      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
        return false;
      }
      var syms = Object.getOwnPropertySymbols(obj);
      if (syms.length !== 1 || syms[0] !== sym) {
        return false;
      }
      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
        return false;
      }
      if (typeof Object.getOwnPropertyDescriptor === "function") {
        var descriptor = (
          /** @type {PropertyDescriptor} */
          Object.getOwnPropertyDescriptor(obj, sym)
        );
        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
          return false;
        }
      }
      return true;
    };
  }
});

// node_modules/has-symbols/index.js
var require_has_symbols = __commonJS({
  "node_modules/has-symbols/index.js"(exports2, module2) {
    "use strict";
    var origSymbol = typeof Symbol !== "undefined" && Symbol;
    var hasSymbolSham = require_shams();
    module2.exports = function hasNativeSymbols() {
      if (typeof origSymbol !== "function") {
        return false;
      }
      if (typeof Symbol !== "function") {
        return false;
      }
      if (typeof origSymbol("foo") !== "symbol") {
        return false;
      }
      if (typeof /* @__PURE__ */ Symbol("bar") !== "symbol") {
        return false;
      }
      return hasSymbolSham();
    };
  }
});

// node_modules/get-proto/Reflect.getPrototypeOf.js
var require_Reflect_getPrototypeOf = __commonJS({
  "node_modules/get-proto/Reflect.getPrototypeOf.js"(exports2, module2) {
    "use strict";
    module2.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
  }
});

// node_modules/get-proto/Object.getPrototypeOf.js
var require_Object_getPrototypeOf = __commonJS({
  "node_modules/get-proto/Object.getPrototypeOf.js"(exports2, module2) {
    "use strict";
    var $Object = require_es_object_atoms();
    module2.exports = $Object.getPrototypeOf || null;
  }
});

// node_modules/function-bind/implementation.js
var require_implementation = __commonJS({
  "node_modules/function-bind/implementation.js"(exports2, module2) {
    "use strict";
    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
    var toStr = Object.prototype.toString;
    var max = Math.max;
    var funcType = "[object Function]";
    var concatty = function concatty2(a, b) {
      var arr = [];
      for (var i = 0; i < a.length; i += 1) {
        arr[i] = a[i];
      }
      for (var j = 0; j < b.length; j += 1) {
        arr[j + a.length] = b[j];
      }
      return arr;
    };
    var slicy = function slicy2(arrLike, offset) {
      var arr = [];
      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
        arr[j] = arrLike[i];
      }
      return arr;
    };
    var joiny = function(arr, joiner) {
      var str = "";
      for (var i = 0; i < arr.length; i += 1) {
        str += arr[i];
        if (i + 1 < arr.length) {
          str += joiner;
        }
      }
      return str;
    };
    module2.exports = function bind2(that) {
      var target = this;
      if (typeof target !== "function" || toStr.apply(target) !== funcType) {
        throw new TypeError(ERROR_MESSAGE + target);
      }
      var args = slicy(arguments, 1);
      var bound;
      var binder = function() {
        if (this instanceof bound) {
          var result = target.apply(
            this,
            concatty(args, arguments)
          );
          if (Object(result) === result) {
            return result;
          }
          return this;
        }
        return target.apply(
          that,
          concatty(args, arguments)
        );
      };
      var boundLength = max(0, target.length - args.length);
      var boundArgs = [];
      for (var i = 0; i < boundLength; i++) {
        boundArgs[i] = "$" + i;
      }
      bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
      if (target.prototype) {
        var Empty = function Empty2() {
        };
        Empty.prototype = target.prototype;
        bound.prototype = new Empty();
        Empty.prototype = null;
      }
      return bound;
    };
  }
});

// node_modules/function-bind/index.js
var require_function_bind = __commonJS({
  "node_modules/function-bind/index.js"(exports2, module2) {
    "use strict";
    var implementation = require_implementation();
    module2.exports = Function.prototype.bind || implementation;
  }
});

// node_modules/call-bind-apply-helpers/functionCall.js
var require_functionCall = __commonJS({
  "node_modules/call-bind-apply-helpers/functionCall.js"(exports2, module2) {
    "use strict";
    module2.exports = Function.prototype.call;
  }
});

// node_modules/call-bind-apply-helpers/functionApply.js
var require_functionApply = __commonJS({
  "node_modules/call-bind-apply-helpers/functionApply.js"(exports2, module2) {
    "use strict";
    module2.exports = Function.prototype.apply;
  }
});

// node_modules/call-bind-apply-helpers/reflectApply.js
var require_reflectApply = __commonJS({
  "node_modules/call-bind-apply-helpers/reflectApply.js"(exports2, module2) {
    "use strict";
    module2.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
  }
});

// node_modules/call-bind-apply-helpers/actualApply.js
var require_actualApply = __commonJS({
  "node_modules/call-bind-apply-helpers/actualApply.js"(exports2, module2) {
    "use strict";
    var bind2 = require_function_bind();
    var $apply = require_functionApply();
    var $call = require_functionCall();
    var $reflectApply = require_reflectApply();
    module2.exports = $reflectApply || bind2.call($call, $apply);
  }
});

// node_modules/call-bind-apply-helpers/index.js
var require_call_bind_apply_helpers = __commonJS({
  "node_modules/call-bind-apply-helpers/index.js"(exports2, module2) {
    "use strict";
    var bind2 = require_function_bind();
    var $TypeError = require_type();
    var $call = require_functionCall();
    var $actualApply = require_actualApply();
    module2.exports = function callBindBasic(args) {
      if (args.length < 1 || typeof args[0] !== "function") {
        throw new $TypeError("a function is required");
      }
      return $actualApply(bind2, $call, args);
    };
  }
});

// node_modules/dunder-proto/get.js
var require_get = __commonJS({
  "node_modules/dunder-proto/get.js"(exports2, module2) {
    "use strict";
    var callBind = require_call_bind_apply_helpers();
    var gOPD = require_gopd();
    var hasProtoAccessor;
    try {
      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
      [].__proto__ === Array.prototype;
    } catch (e) {
      if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
        throw e;
      }
    }
    var desc = !!hasProtoAccessor && gOPD && gOPD(
      Object.prototype,
      /** @type {keyof typeof Object.prototype} */
      "__proto__"
    );
    var $Object = Object;
    var $getPrototypeOf = $Object.getPrototypeOf;
    module2.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
      /** @type {import('./get')} */
      function getDunder(value) {
        return $getPrototypeOf(value == null ? value : $Object(value));
      }
    ) : false;
  }
});

// node_modules/get-proto/index.js
var require_get_proto = __commonJS({
  "node_modules/get-proto/index.js"(exports2, module2) {
    "use strict";
    var reflectGetProto = require_Reflect_getPrototypeOf();
    var originalGetProto = require_Object_getPrototypeOf();
    var getDunderProto = require_get();
    module2.exports = reflectGetProto ? function getProto(O) {
      return reflectGetProto(O);
    } : originalGetProto ? function getProto(O) {
      if (!O || typeof O !== "object" && typeof O !== "function") {
        throw new TypeError("getProto: not an object");
      }
      return originalGetProto(O);
    } : getDunderProto ? function getProto(O) {
      return getDunderProto(O);
    } : null;
  }
});

// node_modules/hasown/index.js
var require_hasown = __commonJS({
  "node_modules/hasown/index.js"(exports2, module2) {
    "use strict";
    var call = Function.prototype.call;
    var $hasOwn = Object.prototype.hasOwnProperty;
    var bind2 = require_function_bind();
    module2.exports = bind2.call(call, $hasOwn);
  }
});

// node_modules/get-intrinsic/index.js
var require_get_intrinsic = __commonJS({
  "node_modules/get-intrinsic/index.js"(exports2, module2) {
    "use strict";
    var undefined2;
    var $Object = require_es_object_atoms();
    var $Error = require_es_errors();
    var $EvalError = require_eval();
    var $RangeError = require_range();
    var $ReferenceError = require_ref();
    var $SyntaxError = require_syntax();
    var $TypeError = require_type();
    var $URIError = require_uri();
    var abs = require_abs();
    var floor = require_floor();
    var max = require_max();
    var min = require_min();
    var pow = require_pow();
    var round = require_round();
    var sign = require_sign();
    var $Function = Function;
    var getEvalledConstructor = function(expressionSyntax) {
      try {
        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
      } catch (e) {
      }
    };
    var $gOPD = require_gopd();
    var $defineProperty = require_es_define_property();
    var throwTypeError = function() {
      throw new $TypeError();
    };
    var ThrowTypeError = $gOPD ? (function() {
      try {
        arguments.callee;
        return throwTypeError;
      } catch (calleeThrows) {
        try {
          return $gOPD(arguments, "callee").get;
        } catch (gOPDthrows) {
          return throwTypeError;
        }
      }
    })() : throwTypeError;
    var hasSymbols = require_has_symbols()();
    var getProto = require_get_proto();
    var $ObjectGPO = require_Object_getPrototypeOf();
    var $ReflectGPO = require_Reflect_getPrototypeOf();
    var $apply = require_functionApply();
    var $call = require_functionCall();
    var needsEval = {};
    var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
    var INTRINSICS = {
      __proto__: null,
      "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
      "%Array%": Array,
      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
      "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
      "%AsyncFromSyncIteratorPrototype%": undefined2,
      "%AsyncFunction%": needsEval,
      "%AsyncGenerator%": needsEval,
      "%AsyncGeneratorFunction%": needsEval,
      "%AsyncIteratorPrototype%": needsEval,
      "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
      "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
      "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
      "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
      "%Boolean%": Boolean,
      "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
      "%Date%": Date,
      "%decodeURI%": decodeURI,
      "%decodeURIComponent%": decodeURIComponent,
      "%encodeURI%": encodeURI,
      "%encodeURIComponent%": encodeURIComponent,
      "%Error%": $Error,
      "%eval%": eval,
      // eslint-disable-line no-eval
      "%EvalError%": $EvalError,
      "%Float16Array%": typeof Float16Array === "undefined" ? undefined2 : Float16Array,
      "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
      "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
      "%Function%": $Function,
      "%GeneratorFunction%": needsEval,
      "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
      "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
      "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
      "%isFinite%": isFinite,
      "%isNaN%": isNaN,
      "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,
      "%JSON%": typeof JSON === "object" ? JSON : undefined2,
      "%Map%": typeof Map === "undefined" ? undefined2 : Map,
      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
      "%Math%": Math,
      "%Number%": Number,
      "%Object%": $Object,
      "%Object.getOwnPropertyDescriptor%": $gOPD,
      "%parseFloat%": parseFloat,
      "%parseInt%": parseInt,
      "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
      "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
      "%RangeError%": $RangeError,
      "%ReferenceError%": $ReferenceError,
      "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
      "%RegExp%": RegExp,
      "%Set%": typeof Set === "undefined" ? undefined2 : Set,
      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
      "%String%": String,
      "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
      "%Symbol%": hasSymbols ? Symbol : undefined2,
      "%SyntaxError%": $SyntaxError,
      "%ThrowTypeError%": ThrowTypeError,
      "%TypedArray%": TypedArray,
      "%TypeError%": $TypeError,
      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
      "%URIError%": $URIError,
      "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
      "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
      "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet,
      "%Function.prototype.call%": $call,
      "%Function.prototype.apply%": $apply,
      "%Object.defineProperty%": $defineProperty,
      "%Object.getPrototypeOf%": $ObjectGPO,
      "%Math.abs%": abs,
      "%Math.floor%": floor,
      "%Math.max%": max,
      "%Math.min%": min,
      "%Math.pow%": pow,
      "%Math.round%": round,
      "%Math.sign%": sign,
      "%Reflect.getPrototypeOf%": $ReflectGPO
    };
    if (getProto) {
      try {
        null.error;
      } catch (e) {
        errorProto = getProto(getProto(e));
        INTRINSICS["%Error.prototype%"] = errorProto;
      }
    }
    var errorProto;
    var doEval = function doEval2(name28) {
      var value;
      if (name28 === "%AsyncFunction%") {
        value = getEvalledConstructor("async function () {}");
      } else if (name28 === "%GeneratorFunction%") {
        value = getEvalledConstructor("function* () {}");
      } else if (name28 === "%AsyncGeneratorFunction%") {
        value = getEvalledConstructor("async function* () {}");
      } else if (name28 === "%AsyncGenerator%") {
        var fn = doEval2("%AsyncGeneratorFunction%");
        if (fn) {
          value = fn.prototype;
        }
      } else if (name28 === "%AsyncIteratorPrototype%") {
        var gen = doEval2("%AsyncGenerator%");
        if (gen && getProto) {
          value = getProto(gen.prototype);
        }
      }
      INTRINSICS[name28] = value;
      return value;
    };
    var LEGACY_ALIASES = {
      __proto__: null,
      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
      "%ArrayPrototype%": ["Array", "prototype"],
      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
      "%ArrayProto_values%": ["Array", "prototype", "values"],
      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
      "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
      "%BooleanPrototype%": ["Boolean", "prototype"],
      "%DataViewPrototype%": ["DataView", "prototype"],
      "%DatePrototype%": ["Date", "prototype"],
      "%ErrorPrototype%": ["Error", "prototype"],
      "%EvalErrorPrototype%": ["EvalError", "prototype"],
      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
      "%FunctionPrototype%": ["Function", "prototype"],
      "%Generator%": ["GeneratorFunction", "prototype"],
      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
      "%JSONParse%": ["JSON", "parse"],
      "%JSONStringify%": ["JSON", "stringify"],
      "%MapPrototype%": ["Map", "prototype"],
      "%NumberPrototype%": ["Number", "prototype"],
      "%ObjectPrototype%": ["Object", "prototype"],
      "%ObjProto_toString%": ["Object", "prototype", "toString"],
      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
      "%PromisePrototype%": ["Promise", "prototype"],
      "%PromiseProto_then%": ["Promise", "prototype", "then"],
      "%Promise_all%": ["Promise", "all"],
      "%Promise_reject%": ["Promise", "reject"],
      "%Promise_resolve%": ["Promise", "resolve"],
      "%RangeErrorPrototype%": ["RangeError", "prototype"],
      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
      "%RegExpPrototype%": ["RegExp", "prototype"],
      "%SetPrototype%": ["Set", "prototype"],
      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
      "%StringPrototype%": ["String", "prototype"],
      "%SymbolPrototype%": ["Symbol", "prototype"],
      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
      "%TypeErrorPrototype%": ["TypeError", "prototype"],
      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
      "%URIErrorPrototype%": ["URIError", "prototype"],
      "%WeakMapPrototype%": ["WeakMap", "prototype"],
      "%WeakSetPrototype%": ["WeakSet", "prototype"]
    };
    var bind2 = require_function_bind();
    var hasOwn = require_hasown();
    var $concat = bind2.call($call, Array.prototype.concat);
    var $spliceApply = bind2.call($apply, Array.prototype.splice);
    var $replace = bind2.call($call, String.prototype.replace);
    var $strSlice = bind2.call($call, String.prototype.slice);
    var $exec = bind2.call($call, RegExp.prototype.exec);
    var rePropName2 = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
    var reEscapeChar2 = /\\(\\)?/g;
    var stringToPath2 = function stringToPath3(string5) {
      var first = $strSlice(string5, 0, 1);
      var last = $strSlice(string5, -1);
      if (first === "%" && last !== "%") {
        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
      } else if (last === "%" && first !== "%") {
        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
      }
      var result = [];
      $replace(string5, rePropName2, function(match, number5, quote, subString) {
        result[result.length] = quote ? $replace(subString, reEscapeChar2, "$1") : number5 || match;
      });
      return result;
    };
    var getBaseIntrinsic = function getBaseIntrinsic2(name28, allowMissing) {
      var intrinsicName = name28;
      var alias;
      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
        alias = LEGACY_ALIASES[intrinsicName];
        intrinsicName = "%" + alias[0] + "%";
      }
      if (hasOwn(INTRINSICS, intrinsicName)) {
        var value = INTRINSICS[intrinsicName];
        if (value === needsEval) {
          value = doEval(intrinsicName);
        }
        if (typeof value === "undefined" && !allowMissing) {
          throw new $TypeError("intrinsic " + name28 + " exists, but is not available. Please file an issue!");
        }
        return {
          alias,
          name: intrinsicName,
          value
        };
      }
      throw new $SyntaxError("intrinsic " + name28 + " does not exist!");
    };
    module2.exports = function GetIntrinsic(name28, allowMissing) {
      if (typeof name28 !== "string" || name28.length === 0) {
        throw new $TypeError("intrinsic name must be a non-empty string");
      }
      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
        throw new $TypeError('"allowMissing" argument must be a boolean');
      }
      if ($exec(/^%?[^%]*%?$/, name28) === null) {
        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
      }
      var parts = stringToPath2(name28);
      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
      var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
      var intrinsicRealName = intrinsic.name;
      var value = intrinsic.value;
      var skipFurtherCaching = false;
      var alias = intrinsic.alias;
      if (alias) {
        intrinsicBaseName = alias[0];
        $spliceApply(parts, $concat([0, 1], alias));
      }
      for (var i = 1, isOwn = true; i < parts.length; i += 1) {
        var part = parts[i];
        var first = $strSlice(part, 0, 1);
        var last = $strSlice(part, -1);
        if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
          throw new $SyntaxError("property names with quotes must have matching quotes");
        }
        if (part === "constructor" || !isOwn) {
          skipFurtherCaching = true;
        }
        intrinsicBaseName += "." + part;
        intrinsicRealName = "%" + intrinsicBaseName + "%";
        if (hasOwn(INTRINSICS, intrinsicRealName)) {
          value = INTRINSICS[intrinsicRealName];
        } else if (value != null) {
          if (!(part in value)) {
            if (!allowMissing) {
              throw new $TypeError("base intrinsic for " + name28 + " exists, but the property is not available.");
            }
            return void undefined2;
          }
          if ($gOPD && i + 1 >= parts.length) {
            var desc = $gOPD(value, part);
            isOwn = !!desc;
            if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
              value = desc.get;
            } else {
              value = value[part];
            }
          } else {
            isOwn = hasOwn(value, part);
            value = value[part];
          }
          if (isOwn && !skipFurtherCaching) {
            INTRINSICS[intrinsicRealName] = value;
          }
        }
      }
      return value;
    };
  }
});

// node_modules/call-bound/index.js
var require_call_bound = __commonJS({
  "node_modules/call-bound/index.js"(exports2, module2) {
    "use strict";
    var GetIntrinsic = require_get_intrinsic();
    var callBindBasic = require_call_bind_apply_helpers();
    var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
    module2.exports = function callBoundIntrinsic(name28, allowMissing) {
      var intrinsic = (
        /** @type {(this: unknown, ...args: unknown[]) => unknown} */
        GetIntrinsic(name28, !!allowMissing)
      );
      if (typeof intrinsic === "function" && $indexOf(name28, ".prototype.") > -1) {
        return callBindBasic(
          /** @type {const} */
          [intrinsic]
        );
      }
      return intrinsic;
    };
  }
});

// node_modules/side-channel-map/index.js
var require_side_channel_map = __commonJS({
  "node_modules/side-channel-map/index.js"(exports2, module2) {
    "use strict";
    var GetIntrinsic = require_get_intrinsic();
    var callBound = require_call_bound();
    var inspect = require_object_inspect();
    var $TypeError = require_type();
    var $Map = GetIntrinsic("%Map%", true);
    var $mapGet = callBound("Map.prototype.get", true);
    var $mapSet = callBound("Map.prototype.set", true);
    var $mapHas = callBound("Map.prototype.has", true);
    var $mapDelete = callBound("Map.prototype.delete", true);
    var $mapSize = callBound("Map.prototype.size", true);
    module2.exports = !!$Map && /** @type {Exclude<import('.'), false>} */
    function getSideChannelMap() {
      var $m;
      var channel = {
        assert: function(key) {
          if (!channel.has(key)) {
            throw new $TypeError("Side channel does not contain " + inspect(key));
          }
        },
        "delete": function(key) {
          if ($m) {
            var result = $mapDelete($m, key);
            if ($mapSize($m) === 0) {
              $m = void 0;
            }
            return result;
          }
          return false;
        },
        get: function(key) {
          if ($m) {
            return $mapGet($m, key);
          }
        },
        has: function(key) {
          if ($m) {
            return $mapHas($m, key);
          }
          return false;
        },
        set: function(key, value) {
          if (!$m) {
            $m = new $Map();
          }
          $mapSet($m, key, value);
        }
      };
      return channel;
    };
  }
});

// node_modules/side-channel-weakmap/index.js
var require_side_channel_weakmap = __commonJS({
  "node_modules/side-channel-weakmap/index.js"(exports2, module2) {
    "use strict";
    var GetIntrinsic = require_get_intrinsic();
    var callBound = require_call_bound();
    var inspect = require_object_inspect();
    var getSideChannelMap = require_side_channel_map();
    var $TypeError = require_type();
    var $WeakMap = GetIntrinsic("%WeakMap%", true);
    var $weakMapGet = callBound("WeakMap.prototype.get", true);
    var $weakMapSet = callBound("WeakMap.prototype.set", true);
    var $weakMapHas = callBound("WeakMap.prototype.has", true);
    var $weakMapDelete = callBound("WeakMap.prototype.delete", true);
    module2.exports = $WeakMap ? (
      /** @type {Exclude<import('.'), false>} */
      function getSideChannelWeakMap() {
        var $wm;
        var $m;
        var channel = {
          assert: function(key) {
            if (!channel.has(key)) {
              throw new $TypeError("Side channel does not contain " + inspect(key));
            }
          },
          "delete": function(key) {
            if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
              if ($wm) {
                return $weakMapDelete($wm, key);
              }
            } else if (getSideChannelMap) {
              if ($m) {
                return $m["delete"](key);
              }
            }
            return false;
          },
          get: function(key) {
            if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
              if ($wm) {
                return $weakMapGet($wm, key);
              }
            }
            return $m && $m.get(key);
          },
          has: function(key) {
            if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
              if ($wm) {
                return $weakMapHas($wm, key);
              }
            }
            return !!$m && $m.has(key);
          },
          set: function(key, value) {
            if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
              if (!$wm) {
                $wm = new $WeakMap();
              }
              $weakMapSet($wm, key, value);
            } else if (getSideChannelMap) {
              if (!$m) {
                $m = getSideChannelMap();
              }
              $m.set(key, value);
            }
          }
        };
        return channel;
      }
    ) : getSideChannelMap;
  }
});

// node_modules/side-channel/index.js
var require_side_channel = __commonJS({
  "node_modules/side-channel/index.js"(exports2, module2) {
    "use strict";
    var $TypeError = require_type();
    var inspect = require_object_inspect();
    var getSideChannelList = require_side_channel_list();
    var getSideChannelMap = require_side_channel_map();
    var getSideChannelWeakMap = require_side_channel_weakmap();
    var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList;
    module2.exports = function getSideChannel() {
      var $channelData;
      var channel = {
        assert: function(key) {
          if (!channel.has(key)) {
            throw new $TypeError("Side channel does not contain " + inspect(key));
          }
        },
        "delete": function(key) {
          return !!$channelData && $channelData["delete"](key);
        },
        get: function(key) {
          return $channelData && $channelData.get(key);
        },
        has: function(key) {
          return !!$channelData && $channelData.has(key);
        },
        set: function(key, value) {
          if (!$channelData) {
            $channelData = makeChannel();
          }
          $channelData.set(key, value);
        }
      };
      return channel;
    };
  }
});

// node_modules/qs/lib/formats.js
var require_formats = __commonJS({
  "node_modules/qs/lib/formats.js"(exports2, module2) {
    "use strict";
    var replace = String.prototype.replace;
    var percentTwenties = /%20/g;
    var Format = {
      RFC1738: "RFC1738",
      RFC3986: "RFC3986"
    };
    module2.exports = {
      "default": Format.RFC3986,
      formatters: {
        RFC1738: function(value) {
          return replace.call(value, percentTwenties, "+");
        },
        RFC3986: function(value) {
          return String(value);
        }
      },
      RFC1738: Format.RFC1738,
      RFC3986: Format.RFC3986
    };
  }
});

// node_modules/qs/lib/utils.js
var require_utils2 = __commonJS({
  "node_modules/qs/lib/utils.js"(exports2, module2) {
    "use strict";
    var formats = require_formats();
    var getSideChannel = require_side_channel();
    var has = Object.prototype.hasOwnProperty;
    var isArray3 = Array.isArray;
    var overflowChannel = getSideChannel();
    var markOverflow = function markOverflow2(obj, maxIndex) {
      overflowChannel.set(obj, maxIndex);
      return obj;
    };
    var isOverflow = function isOverflow2(obj) {
      return overflowChannel.has(obj);
    };
    var getMaxIndex = function getMaxIndex2(obj) {
      return overflowChannel.get(obj);
    };
    var setMaxIndex = function setMaxIndex2(obj, maxIndex) {
      overflowChannel.set(obj, maxIndex);
    };
    var hexTable = (function() {
      var array4 = [];
      for (var i = 0; i < 256; ++i) {
        array4[array4.length] = "%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase();
      }
      return array4;
    })();
    var compactQueue = function compactQueue2(queue) {
      while (queue.length > 1) {
        var item = queue.pop();
        var obj = item.obj[item.prop];
        if (isArray3(obj)) {
          var compacted = [];
          for (var j = 0; j < obj.length; ++j) {
            if (typeof obj[j] !== "undefined") {
              compacted[compacted.length] = obj[j];
            }
          }
          item.obj[item.prop] = compacted;
        }
      }
    };
    var arrayToObject2 = function arrayToObject3(source, options) {
      var obj = options && options.plainObjects ? { __proto__: null } : {};
      for (var i = 0; i < source.length; ++i) {
        if (typeof source[i] !== "undefined") {
          obj[i] = source[i];
        }
      }
      return obj;
    };
    var merge4 = function merge5(target, source, options) {
      if (!source) {
        return target;
      }
      if (typeof source !== "object" && typeof source !== "function") {
        if (isArray3(target)) {
          var nextIndex = target.length;
          if (options && typeof options.arrayLimit === "number" && nextIndex > options.arrayLimit) {
            return markOverflow(arrayToObject2(target.concat(source), options), nextIndex);
          }
          target[nextIndex] = source;
        } else if (target && typeof target === "object") {
          if (isOverflow(target)) {
            var newIndex = getMaxIndex(target) + 1;
            target[newIndex] = source;
            setMaxIndex(target, newIndex);
          } else if (options && options.strictMerge) {
            return [target, source];
          } else if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
            target[source] = true;
          }
        } else {
          return [target, source];
        }
        return target;
      }
      if (!target || typeof target !== "object") {
        if (isOverflow(source)) {
          var sourceKeys = Object.keys(source);
          var result = options && options.plainObjects ? { __proto__: null, 0: target } : { 0: target };
          for (var m = 0; m < sourceKeys.length; m++) {
            var oldKey = parseInt(sourceKeys[m], 10);
            result[oldKey + 1] = source[sourceKeys[m]];
          }
          return markOverflow(result, getMaxIndex(source) + 1);
        }
        var combined = [target].concat(source);
        if (options && typeof options.arrayLimit === "number" && combined.length > options.arrayLimit) {
          return markOverflow(arrayToObject2(combined, options), combined.length - 1);
        }
        return combined;
      }
      var mergeTarget = target;
      if (isArray3(target) && !isArray3(source)) {
        mergeTarget = arrayToObject2(target, options);
      }
      if (isArray3(target) && isArray3(source)) {
        source.forEach(function(item, i) {
          if (has.call(target, i)) {
            var targetItem = target[i];
            if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
              target[i] = merge5(targetItem, item, options);
            } else {
              target[target.length] = item;
            }
          } else {
            target[i] = item;
          }
        });
        return target;
      }
      return Object.keys(source).reduce(function(acc, key) {
        var value = source[key];
        if (has.call(acc, key)) {
          acc[key] = merge5(acc[key], value, options);
        } else {
          acc[key] = value;
        }
        if (isOverflow(source) && !isOverflow(acc)) {
          markOverflow(acc, getMaxIndex(source));
        }
        if (isOverflow(acc)) {
          var keyNum = parseInt(key, 10);
          if (String(keyNum) === key && keyNum >= 0 && keyNum > getMaxIndex(acc)) {
            setMaxIndex(acc, keyNum);
          }
        }
        return acc;
      }, mergeTarget);
    };
    var assign = function assignSingleSource(target, source) {
      return Object.keys(source).reduce(function(acc, key) {
        acc[key] = source[key];
        return acc;
      }, target);
    };
    var decode4 = function(str, defaultDecoder, charset) {
      var strWithoutPlus = str.replace(/\+/g, " ");
      if (charset === "iso-8859-1") {
        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
      }
      try {
        return decodeURIComponent(strWithoutPlus);
      } catch (e) {
        return strWithoutPlus;
      }
    };
    var limit = 1024;
    var encode6 = function encode7(str, defaultEncoder, charset, kind, format) {
      if (str.length === 0) {
        return str;
      }
      var string5 = str;
      if (typeof str === "symbol") {
        string5 = Symbol.prototype.toString.call(str);
      } else if (typeof str !== "string") {
        string5 = String(str);
      }
      if (charset === "iso-8859-1") {
        return escape(string5).replace(/%u[0-9a-f]{4}/gi, function($0) {
          return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
        });
      }
      var out = "";
      for (var j = 0; j < string5.length; j += limit) {
        var segment = string5.length >= limit ? string5.slice(j, j + limit) : string5;
        var arr = [];
        for (var i = 0; i < segment.length; ++i) {
          var c = segment.charCodeAt(i);
          if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format === formats.RFC1738 && (c === 40 || c === 41)) {
            arr[arr.length] = segment.charAt(i);
            continue;
          }
          if (c < 128) {
            arr[arr.length] = hexTable[c];
            continue;
          }
          if (c < 2048) {
            arr[arr.length] = hexTable[192 | c >> 6] + hexTable[128 | c & 63];
            continue;
          }
          if (c < 55296 || c >= 57344) {
            arr[arr.length] = hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
            continue;
          }
          i += 1;
          c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023);
          arr[arr.length] = hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
        }
        out += arr.join("");
      }
      return out;
    };
    var compact = function compact2(value) {
      var queue = [{ obj: { o: value }, prop: "o" }];
      var refs = [];
      for (var i = 0; i < queue.length; ++i) {
        var item = queue[i];
        var obj = item.obj[item.prop];
        var keys2 = Object.keys(obj);
        for (var j = 0; j < keys2.length; ++j) {
          var key = keys2[j];
          var val = obj[key];
          if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
            queue[queue.length] = { obj, prop: key };
            refs[refs.length] = val;
          }
        }
      }
      compactQueue(queue);
      return value;
    };
    var isRegExp2 = function isRegExp3(obj) {
      return Object.prototype.toString.call(obj) === "[object RegExp]";
    };
    var isBuffer3 = function isBuffer4(obj) {
      if (!obj || typeof obj !== "object") {
        return false;
      }
      return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
    };
    var combine = function combine2(a, b, arrayLimit, plainObjects) {
      if (isOverflow(a)) {
        var newIndex = getMaxIndex(a) + 1;
        a[newIndex] = b;
        setMaxIndex(a, newIndex);
        return a;
      }
      var result = [].concat(a, b);
      if (result.length > arrayLimit) {
        return markOverflow(arrayToObject2(result, { plainObjects }), result.length - 1);
      }
      return result;
    };
    var maybeMap = function maybeMap2(val, fn) {
      if (isArray3(val)) {
        var mapped = [];
        for (var i = 0; i < val.length; i += 1) {
          mapped[mapped.length] = fn(val[i]);
        }
        return mapped;
      }
      return fn(val);
    };
    module2.exports = {
      arrayToObject: arrayToObject2,
      assign,
      combine,
      compact,
      decode: decode4,
      encode: encode6,
      isBuffer: isBuffer3,
      isOverflow,
      isRegExp: isRegExp2,
      markOverflow,
      maybeMap,
      merge: merge4
    };
  }
});

// node_modules/qs/lib/stringify.js
var require_stringify = __commonJS({
  "node_modules/qs/lib/stringify.js"(exports2, module2) {
    "use strict";
    var getSideChannel = require_side_channel();
    var utils = require_utils2();
    var formats = require_formats();
    var has = Object.prototype.hasOwnProperty;
    var arrayPrefixGenerators = {
      brackets: function brackets(prefix) {
        return prefix + "[]";
      },
      comma: "comma",
      indices: function indices(prefix, key) {
        return prefix + "[" + key + "]";
      },
      repeat: function repeat(prefix) {
        return prefix;
      }
    };
    var isArray3 = Array.isArray;
    var push = Array.prototype.push;
    var pushToArray = function(arr, valueOrArray) {
      push.apply(arr, isArray3(valueOrArray) ? valueOrArray : [valueOrArray]);
    };
    var toISO = Date.prototype.toISOString;
    var defaultFormat = formats["default"];
    var defaults2 = {
      addQueryPrefix: false,
      allowDots: false,
      allowEmptyArrays: false,
      arrayFormat: "indices",
      charset: "utf-8",
      charsetSentinel: false,
      commaRoundTrip: false,
      delimiter: "&",
      encode: true,
      encodeDotInKeys: false,
      encoder: utils.encode,
      encodeValuesOnly: false,
      filter: void 0,
      format: defaultFormat,
      formatter: formats.formatters[defaultFormat],
      // deprecated
      indices: false,
      serializeDate: function serializeDate(date6) {
        return toISO.call(date6);
      },
      skipNulls: false,
      strictNullHandling: false
    };
    var isNonNullishPrimitive = function isNonNullishPrimitive2(v) {
      return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
    };
    var sentinel = {};
    var stringify2 = function stringify3(object4, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter6, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) {
      var obj = object4;
      var tmpSc = sideChannel;
      var step = 0;
      var findFlag = false;
      while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {
        var pos = tmpSc.get(object4);
        step += 1;
        if (typeof pos !== "undefined") {
          if (pos === step) {
            throw new RangeError("Cyclic object value");
          } else {
            findFlag = true;
          }
        }
        if (typeof tmpSc.get(sentinel) === "undefined") {
          step = 0;
        }
      }
      if (typeof filter6 === "function") {
        obj = filter6(prefix, obj);
      } else if (obj instanceof Date) {
        obj = serializeDate(obj);
      } else if (generateArrayPrefix === "comma" && isArray3(obj)) {
        obj = utils.maybeMap(obj, function(value2) {
          if (value2 instanceof Date) {
            return serializeDate(value2);
          }
          return value2;
        });
      }
      if (obj === null) {
        if (strictNullHandling) {
          return encoder && !encodeValuesOnly ? encoder(prefix, defaults2.encoder, charset, "key", format) : prefix;
        }
        obj = "";
      }
      if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
        if (encoder) {
          var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults2.encoder, charset, "key", format);
          return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults2.encoder, charset, "value", format))];
        }
        return [formatter(prefix) + "=" + formatter(String(obj))];
      }
      var values = [];
      if (typeof obj === "undefined") {
        return values;
      }
      var objKeys;
      if (generateArrayPrefix === "comma" && isArray3(obj)) {
        if (encodeValuesOnly && encoder) {
          obj = utils.maybeMap(obj, encoder);
        }
        objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
      } else if (isArray3(filter6)) {
        objKeys = filter6;
      } else {
        var keys2 = Object.keys(obj);
        objKeys = sort ? keys2.sort(sort) : keys2;
      }
      var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix);
      var adjustedPrefix = commaRoundTrip && isArray3(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix;
      if (allowEmptyArrays && isArray3(obj) && obj.length === 0) {
        return adjustedPrefix + "[]";
      }
      for (var j = 0; j < objKeys.length; ++j) {
        var key = objKeys[j];
        var value = typeof key === "object" && key && typeof key.value !== "undefined" ? key.value : obj[key];
        if (skipNulls && value === null) {
          continue;
        }
        var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\./g, "%2E") : String(key);
        var keyPrefix = isArray3(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? "." + encodedKey : "[" + encodedKey + "]");
        sideChannel.set(object4, step);
        var valueSideChannel = getSideChannel();
        valueSideChannel.set(sentinel, sideChannel);
        pushToArray(values, stringify3(
          value,
          keyPrefix,
          generateArrayPrefix,
          commaRoundTrip,
          allowEmptyArrays,
          strictNullHandling,
          skipNulls,
          encodeDotInKeys,
          generateArrayPrefix === "comma" && encodeValuesOnly && isArray3(obj) ? null : encoder,
          filter6,
          sort,
          allowDots,
          serializeDate,
          format,
          formatter,
          encodeValuesOnly,
          charset,
          valueSideChannel
        ));
      }
      return values;
    };
    var normalizeStringifyOptions = function normalizeStringifyOptions2(opts) {
      if (!opts) {
        return defaults2;
      }
      if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
        throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
      }
      if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") {
        throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
      }
      if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") {
        throw new TypeError("Encoder has to be a function.");
      }
      var charset = opts.charset || defaults2.charset;
      if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
        throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
      }
      var format = formats["default"];
      if (typeof opts.format !== "undefined") {
        if (!has.call(formats.formatters, opts.format)) {
          throw new TypeError("Unknown format option provided.");
        }
        format = opts.format;
      }
      var formatter = formats.formatters[format];
      var filter6 = defaults2.filter;
      if (typeof opts.filter === "function" || isArray3(opts.filter)) {
        filter6 = opts.filter;
      }
      var arrayFormat;
      if (opts.arrayFormat in arrayPrefixGenerators) {
        arrayFormat = opts.arrayFormat;
      } else if ("indices" in opts) {
        arrayFormat = opts.indices ? "indices" : "repeat";
      } else {
        arrayFormat = defaults2.arrayFormat;
      }
      if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") {
        throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
      }
      var allowDots = typeof opts.allowDots === "undefined" ? opts.encodeDotInKeys === true ? true : defaults2.allowDots : !!opts.allowDots;
      return {
        addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults2.addQueryPrefix,
        allowDots,
        allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults2.allowEmptyArrays,
        arrayFormat,
        charset,
        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults2.charsetSentinel,
        commaRoundTrip: !!opts.commaRoundTrip,
        delimiter: typeof opts.delimiter === "undefined" ? defaults2.delimiter : opts.delimiter,
        encode: typeof opts.encode === "boolean" ? opts.encode : defaults2.encode,
        encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults2.encodeDotInKeys,
        encoder: typeof opts.encoder === "function" ? opts.encoder : defaults2.encoder,
        encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults2.encodeValuesOnly,
        filter: filter6,
        format,
        formatter,
        serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults2.serializeDate,
        skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults2.skipNulls,
        sort: typeof opts.sort === "function" ? opts.sort : null,
        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults2.strictNullHandling
      };
    };
    module2.exports = function(object4, opts) {
      var obj = object4;
      var options = normalizeStringifyOptions(opts);
      var objKeys;
      var filter6;
      if (typeof options.filter === "function") {
        filter6 = options.filter;
        obj = filter6("", obj);
      } else if (isArray3(options.filter)) {
        filter6 = options.filter;
        objKeys = filter6;
      }
      var keys2 = [];
      if (typeof obj !== "object" || obj === null) {
        return "";
      }
      var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];
      var commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip;
      if (!objKeys) {
        objKeys = Object.keys(obj);
      }
      if (options.sort) {
        objKeys.sort(options.sort);
      }
      var sideChannel = getSideChannel();
      for (var i = 0; i < objKeys.length; ++i) {
        var key = objKeys[i];
        var value = obj[key];
        if (options.skipNulls && value === null) {
          continue;
        }
        pushToArray(keys2, stringify2(
          value,
          key,
          generateArrayPrefix,
          commaRoundTrip,
          options.allowEmptyArrays,
          options.strictNullHandling,
          options.skipNulls,
          options.encodeDotInKeys,
          options.encode ? options.encoder : null,
          options.filter,
          options.sort,
          options.allowDots,
          options.serializeDate,
          options.format,
          options.formatter,
          options.encodeValuesOnly,
          options.charset,
          sideChannel
        ));
      }
      var joined = keys2.join(options.delimiter);
      var prefix = options.addQueryPrefix === true ? "?" : "";
      if (options.charsetSentinel) {
        if (options.charset === "iso-8859-1") {
          prefix += "utf8=%26%2310003%3B&";
        } else {
          prefix += "utf8=%E2%9C%93&";
        }
      }
      return joined.length > 0 ? prefix + joined : "";
    };
  }
});

// node_modules/qs/lib/parse.js
var require_parse = __commonJS({
  "node_modules/qs/lib/parse.js"(exports2, module2) {
    "use strict";
    var utils = require_utils2();
    var has = Object.prototype.hasOwnProperty;
    var isArray3 = Array.isArray;
    var defaults2 = {
      allowDots: false,
      allowEmptyArrays: false,
      allowPrototypes: false,
      allowSparse: false,
      arrayLimit: 20,
      charset: "utf-8",
      charsetSentinel: false,
      comma: false,
      decodeDotInKeys: false,
      decoder: utils.decode,
      delimiter: "&",
      depth: 5,
      duplicates: "combine",
      ignoreQueryPrefix: false,
      interpretNumericEntities: false,
      parameterLimit: 1e3,
      parseArrays: true,
      plainObjects: false,
      strictDepth: false,
      strictMerge: true,
      strictNullHandling: false,
      throwOnLimitExceeded: false
    };
    var interpretNumericEntities = function(str) {
      return str.replace(/&#(\d+);/g, function($0, numberStr) {
        return String.fromCharCode(parseInt(numberStr, 10));
      });
    };
    var parseArrayValue = function(val, options, currentArrayLength) {
      if (val && typeof val === "string" && options.comma && val.indexOf(",") > -1) {
        return val.split(",");
      }
      if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
        throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
      }
      return val;
    };
    var isoSentinel = "utf8=%26%2310003%3B";
    var charsetSentinel = "utf8=%E2%9C%93";
    var parseValues = function parseQueryStringValues(str, options) {
      var obj = { __proto__: null };
      var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
      cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
      var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
      var parts = cleanStr.split(
        options.delimiter,
        options.throwOnLimitExceeded ? limit + 1 : limit
      );
      if (options.throwOnLimitExceeded && parts.length > limit) {
        throw new RangeError("Parameter limit exceeded. Only " + limit + " parameter" + (limit === 1 ? "" : "s") + " allowed.");
      }
      var skipIndex = -1;
      var i;
      var charset = options.charset;
      if (options.charsetSentinel) {
        for (i = 0; i < parts.length; ++i) {
          if (parts[i].indexOf("utf8=") === 0) {
            if (parts[i] === charsetSentinel) {
              charset = "utf-8";
            } else if (parts[i] === isoSentinel) {
              charset = "iso-8859-1";
            }
            skipIndex = i;
            i = parts.length;
          }
        }
      }
      for (i = 0; i < parts.length; ++i) {
        if (i === skipIndex) {
          continue;
        }
        var part = parts[i];
        var bracketEqualsPos = part.indexOf("]=");
        var pos = bracketEqualsPos === -1 ? part.indexOf("=") : bracketEqualsPos + 1;
        var key;
        var val;
        if (pos === -1) {
          key = options.decoder(part, defaults2.decoder, charset, "key");
          val = options.strictNullHandling ? null : "";
        } else {
          key = options.decoder(part.slice(0, pos), defaults2.decoder, charset, "key");
          if (key !== null) {
            val = utils.maybeMap(
              parseArrayValue(
                part.slice(pos + 1),
                options,
                isArray3(obj[key]) ? obj[key].length : 0
              ),
              function(encodedVal) {
                return options.decoder(encodedVal, defaults2.decoder, charset, "value");
              }
            );
          }
        }
        if (val && options.interpretNumericEntities && charset === "iso-8859-1") {
          val = interpretNumericEntities(String(val));
        }
        if (part.indexOf("[]=") > -1) {
          val = isArray3(val) ? [val] : val;
        }
        if (options.comma && isArray3(val) && val.length > options.arrayLimit) {
          if (options.throwOnLimitExceeded) {
            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
          }
          val = utils.combine([], val, options.arrayLimit, options.plainObjects);
        }
        if (key !== null) {
          var existing = has.call(obj, key);
          if (existing && (options.duplicates === "combine" || part.indexOf("[]=") > -1)) {
            obj[key] = utils.combine(
              obj[key],
              val,
              options.arrayLimit,
              options.plainObjects
            );
          } else if (!existing || options.duplicates === "last") {
            obj[key] = val;
          }
        }
      }
      return obj;
    };
    var parseObject = function(chain, val, options, valuesParsed) {
      var currentArrayLength = 0;
      if (chain.length > 0 && chain[chain.length - 1] === "[]") {
        var parentKey = chain.slice(0, -1).join("");
        currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;
      }
      var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);
      for (var i = chain.length - 1; i >= 0; --i) {
        var obj;
        var root2 = chain[i];
        if (root2 === "[]" && options.parseArrays) {
          if (utils.isOverflow(leaf)) {
            obj = leaf;
          } else {
            obj = options.allowEmptyArrays && (leaf === "" || options.strictNullHandling && leaf === null) ? [] : utils.combine(
              [],
              leaf,
              options.arrayLimit,
              options.plainObjects
            );
          }
        } else {
          obj = options.plainObjects ? { __proto__: null } : {};
          var cleanRoot = root2.charAt(0) === "[" && root2.charAt(root2.length - 1) === "]" ? root2.slice(1, -1) : root2;
          var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, ".") : cleanRoot;
          var index = parseInt(decodedRoot, 10);
          var isValidArrayIndex = !isNaN(index) && root2 !== decodedRoot && String(index) === decodedRoot && index >= 0 && options.parseArrays;
          if (!options.parseArrays && decodedRoot === "") {
            obj = { 0: leaf };
          } else if (isValidArrayIndex && index < options.arrayLimit) {
            obj = [];
            obj[index] = leaf;
          } else if (isValidArrayIndex && options.throwOnLimitExceeded) {
            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
          } else if (isValidArrayIndex) {
            obj[index] = leaf;
            utils.markOverflow(obj, index);
          } else if (decodedRoot !== "__proto__") {
            obj[decodedRoot] = leaf;
          }
        }
        leaf = obj;
      }
      return leaf;
    };
    var splitKeyIntoSegments = function splitKeyIntoSegments2(givenKey, options) {
      var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey;
      if (options.depth <= 0) {
        if (!options.plainObjects && has.call(Object.prototype, key)) {
          if (!options.allowPrototypes) {
            return;
          }
        }
        return [key];
      }
      var brackets = /(\[[^[\]]*])/;
      var child = /(\[[^[\]]*])/g;
      var segment = brackets.exec(key);
      var parent = segment ? key.slice(0, segment.index) : key;
      var keys2 = [];
      if (parent) {
        if (!options.plainObjects && has.call(Object.prototype, parent)) {
          if (!options.allowPrototypes) {
            return;
          }
        }
        keys2[keys2.length] = parent;
      }
      var i = 0;
      while ((segment = child.exec(key)) !== null && i < options.depth) {
        i += 1;
        var segmentContent = segment[1].slice(1, -1);
        if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {
          if (!options.allowPrototypes) {
            return;
          }
        }
        keys2[keys2.length] = segment[1];
      }
      if (segment) {
        if (options.strictDepth === true) {
          throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
        }
        keys2[keys2.length] = "[" + key.slice(segment.index) + "]";
      }
      return keys2;
    };
    var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
      if (!givenKey) {
        return;
      }
      var keys2 = splitKeyIntoSegments(givenKey, options);
      if (!keys2) {
        return;
      }
      return parseObject(keys2, val, options, valuesParsed);
    };
    var normalizeParseOptions = function normalizeParseOptions2(opts) {
      if (!opts) {
        return defaults2;
      }
      if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
        throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
      }
      if (typeof opts.decodeDotInKeys !== "undefined" && typeof opts.decodeDotInKeys !== "boolean") {
        throw new TypeError("`decodeDotInKeys` option can only be `true` or `false`, when provided");
      }
      if (opts.decoder !== null && typeof opts.decoder !== "undefined" && typeof opts.decoder !== "function") {
        throw new TypeError("Decoder has to be a function.");
      }
      if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
        throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
      }
      if (typeof opts.throwOnLimitExceeded !== "undefined" && typeof opts.throwOnLimitExceeded !== "boolean") {
        throw new TypeError("`throwOnLimitExceeded` option must be a boolean");
      }
      var charset = typeof opts.charset === "undefined" ? defaults2.charset : opts.charset;
      var duplicates = typeof opts.duplicates === "undefined" ? defaults2.duplicates : opts.duplicates;
      if (duplicates !== "combine" && duplicates !== "first" && duplicates !== "last") {
        throw new TypeError("The duplicates option must be either combine, first, or last");
      }
      var allowDots = typeof opts.allowDots === "undefined" ? opts.decodeDotInKeys === true ? true : defaults2.allowDots : !!opts.allowDots;
      return {
        allowDots,
        allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults2.allowEmptyArrays,
        allowPrototypes: typeof opts.allowPrototypes === "boolean" ? opts.allowPrototypes : defaults2.allowPrototypes,
        allowSparse: typeof opts.allowSparse === "boolean" ? opts.allowSparse : defaults2.allowSparse,
        arrayLimit: typeof opts.arrayLimit === "number" ? opts.arrayLimit : defaults2.arrayLimit,
        charset,
        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults2.charsetSentinel,
        comma: typeof opts.comma === "boolean" ? opts.comma : defaults2.comma,
        decodeDotInKeys: typeof opts.decodeDotInKeys === "boolean" ? opts.decodeDotInKeys : defaults2.decodeDotInKeys,
        decoder: typeof opts.decoder === "function" ? opts.decoder : defaults2.decoder,
        delimiter: typeof opts.delimiter === "string" || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults2.delimiter,
        // eslint-disable-next-line no-implicit-coercion, no-extra-parens
        depth: typeof opts.depth === "number" || opts.depth === false ? +opts.depth : defaults2.depth,
        duplicates,
        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
        interpretNumericEntities: typeof opts.interpretNumericEntities === "boolean" ? opts.interpretNumericEntities : defaults2.interpretNumericEntities,
        parameterLimit: typeof opts.parameterLimit === "number" ? opts.parameterLimit : defaults2.parameterLimit,
        parseArrays: opts.parseArrays !== false,
        plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults2.plainObjects,
        strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults2.strictDepth,
        strictMerge: typeof opts.strictMerge === "boolean" ? !!opts.strictMerge : defaults2.strictMerge,
        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults2.strictNullHandling,
        throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false
      };
    };
    module2.exports = function(str, opts) {
      var options = normalizeParseOptions(opts);
      if (str === "" || str === null || typeof str === "undefined") {
        return options.plainObjects ? { __proto__: null } : {};
      }
      var tempObj = typeof str === "string" ? parseValues(str, options) : str;
      var obj = options.plainObjects ? { __proto__: null } : {};
      var keys2 = Object.keys(tempObj);
      for (var i = 0; i < keys2.length; ++i) {
        var key = keys2[i];
        var newObj = parseKeys(key, tempObj[key], options, typeof str === "string");
        obj = utils.merge(obj, newObj, options);
      }
      if (options.allowSparse === true) {
        return obj;
      }
      return utils.compact(obj);
    };
  }
});

// node_modules/qs/lib/index.js
var require_lib2 = __commonJS({
  "node_modules/qs/lib/index.js"(exports2, module2) {
    "use strict";
    var stringify2 = require_stringify();
    var parse4 = require_parse();
    var formats = require_formats();
    module2.exports = {
      formats,
      parse: parse4,
      stringify: stringify2
    };
  }
});

// node_modules/body-parser/lib/types/urlencoded.js
var require_urlencoded = __commonJS({
  "node_modules/body-parser/lib/types/urlencoded.js"(exports2, module2) {
    "use strict";
    var createError = require_http_errors();
    var debug = require_src()("body-parser:urlencoded");
    var read = require_read();
    var qs = require_lib2();
    var { normalizeOptions } = require_utils();
    module2.exports = urlencoded;
    function urlencoded(options) {
      const normalizedOptions = normalizeOptions(options, "application/x-www-form-urlencoded");
      if (normalizedOptions.defaultCharset !== "utf-8" && normalizedOptions.defaultCharset !== "iso-8859-1") {
        throw new TypeError("option defaultCharset must be either utf-8 or iso-8859-1");
      }
      var queryparse = createQueryParser(options);
      function parse4(body, encoding) {
        return body.length ? queryparse(body, encoding) : {};
      }
      const readOptions = {
        ...normalizedOptions,
        // assert charset
        isValidCharset: (charset) => charset === "utf-8" || charset === "iso-8859-1"
      };
      return function urlencodedParser(req, res, next) {
        read(req, res, next, parse4, debug, readOptions);
      };
    }
    function createQueryParser(options) {
      var extended = Boolean(options?.extended);
      var parameterLimit = options?.parameterLimit !== void 0 ? options?.parameterLimit : 1e3;
      var charsetSentinel = options?.charsetSentinel;
      var interpretNumericEntities = options?.interpretNumericEntities;
      var depth = extended ? options?.depth !== void 0 ? options?.depth : 32 : 0;
      if (isNaN(parameterLimit) || parameterLimit < 1) {
        throw new TypeError("option parameterLimit must be a positive number");
      }
      if (isNaN(depth) || depth < 0) {
        throw new TypeError("option depth must be a zero or a positive number");
      }
      if (isFinite(parameterLimit)) {
        parameterLimit = parameterLimit | 0;
      }
      return function queryparse(body, encoding) {
        var paramCount = parameterCount(body, parameterLimit);
        if (paramCount === void 0) {
          debug("too many parameters");
          throw createError(413, "too many parameters", {
            type: "parameters.too.many"
          });
        }
        var arrayLimit = extended ? Math.max(100, paramCount) : paramCount;
        debug("parse " + (extended ? "extended " : "") + "urlencoding");
        try {
          return qs.parse(body, {
            allowPrototypes: true,
            arrayLimit,
            depth,
            charsetSentinel,
            interpretNumericEntities,
            charset: encoding,
            parameterLimit,
            strictDepth: true
          });
        } catch (err) {
          if (err instanceof RangeError) {
            throw createError(400, "The input exceeded the depth", {
              type: "querystring.parse.rangeError"
            });
          } else {
            throw err;
          }
        }
      };
    }
    function parameterCount(body, limit) {
      let count = 0;
      let index = -1;
      do {
        count++;
        if (count > limit) return void 0;
        index = body.indexOf("&", index + 1);
      } while (index !== -1);
      return count;
    }
  }
});

// node_modules/body-parser/index.js
var require_body_parser = __commonJS({
  "node_modules/body-parser/index.js"(exports2, module2) {
    "use strict";
    exports2 = module2.exports = bodyParser;
    Object.defineProperty(exports2, "json", {
      configurable: true,
      enumerable: true,
      get: () => require_json()
    });
    Object.defineProperty(exports2, "raw", {
      configurable: true,
      enumerable: true,
      get: () => require_raw()
    });
    Object.defineProperty(exports2, "text", {
      configurable: true,
      enumerable: true,
      get: () => require_text()
    });
    Object.defineProperty(exports2, "urlencoded", {
      configurable: true,
      enumerable: true,
      get: () => require_urlencoded()
    });
    function bodyParser() {
      throw new Error("The bodyParser() generic has been split into individual middleware to use instead.");
    }
  }
});

// node_modules/merge-descriptors/index.js
var require_merge_descriptors = __commonJS({
  "node_modules/merge-descriptors/index.js"(exports2, module2) {
    "use strict";
    function mergeDescriptors(destination, source, overwrite = true) {
      if (!destination) {
        throw new TypeError("The `destination` argument is required.");
      }
      if (!source) {
        throw new TypeError("The `source` argument is required.");
      }
      for (const name28 of Object.getOwnPropertyNames(source)) {
        if (!overwrite && Object.hasOwn(destination, name28)) {
          continue;
        }
        const descriptor = Object.getOwnPropertyDescriptor(source, name28);
        Object.defineProperty(destination, name28, descriptor);
      }
      return destination;
    }
    module2.exports = mergeDescriptors;
  }
});

// node_modules/encodeurl/index.js
var require_encodeurl = __commonJS({
  "node_modules/encodeurl/index.js"(exports2, module2) {
    "use strict";
    module2.exports = encodeUrl;
    var ENCODE_CHARS_REGEXP = /(?:[^\x21\x23-\x3B\x3D\x3F-\x5F\x61-\x7A\x7C\x7E]|%(?:[^0-9A-Fa-f]|[0-9A-Fa-f][^0-9A-Fa-f]|$))+/g;
    var UNMATCHED_SURROGATE_PAIR_REGEXP = /(^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/g;
    var UNMATCHED_SURROGATE_PAIR_REPLACE = "$1\uFFFD$2";
    function encodeUrl(url4) {
      return String(url4).replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE).replace(ENCODE_CHARS_REGEXP, encodeURI);
    }
  }
});

// node_modules/escape-html/index.js
var require_escape_html = __commonJS({
  "node_modules/escape-html/index.js"(exports2, module2) {
    "use strict";
    var matchHtmlRegExp = /["'&<>]/;
    module2.exports = escapeHtml;
    function escapeHtml(string5) {
      var str = "" + string5;
      var match = matchHtmlRegExp.exec(str);
      if (!match) {
        return str;
      }
      var escape2;
      var html = "";
      var index = 0;
      var lastIndex = 0;
      for (index = match.index; index < str.length; index++) {
        switch (str.charCodeAt(index)) {
          case 34:
            escape2 = "&quot;";
            break;
          case 38:
            escape2 = "&amp;";
            break;
          case 39:
            escape2 = "&#39;";
            break;
          case 60:
            escape2 = "&lt;";
            break;
          case 62:
            escape2 = "&gt;";
            break;
          default:
            continue;
        }
        if (lastIndex !== index) {
          html += str.substring(lastIndex, index);
        }
        lastIndex = index + 1;
        html += escape2;
      }
      return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
    }
  }
});

// node_modules/parseurl/index.js
var require_parseurl = __commonJS({
  "node_modules/parseurl/index.js"(exports2, module2) {
    "use strict";
    var url4 = require("url");
    var parse4 = url4.parse;
    var Url = url4.Url;
    module2.exports = parseurl;
    module2.exports.original = originalurl;
    function parseurl(req) {
      var url5 = req.url;
      if (url5 === void 0) {
        return void 0;
      }
      var parsed = req._parsedUrl;
      if (fresh(url5, parsed)) {
        return parsed;
      }
      parsed = fastparse(url5);
      parsed._raw = url5;
      return req._parsedUrl = parsed;
    }
    function originalurl(req) {
      var url5 = req.originalUrl;
      if (typeof url5 !== "string") {
        return parseurl(req);
      }
      var parsed = req._parsedOriginalUrl;
      if (fresh(url5, parsed)) {
        return parsed;
      }
      parsed = fastparse(url5);
      parsed._raw = url5;
      return req._parsedOriginalUrl = parsed;
    }
    function fastparse(str) {
      if (typeof str !== "string" || str.charCodeAt(0) !== 47) {
        return parse4(str);
      }
      var pathname = str;
      var query = null;
      var search = null;
      for (var i = 1; i < str.length; i++) {
        switch (str.charCodeAt(i)) {
          case 63:
            if (search === null) {
              pathname = str.substring(0, i);
              query = str.substring(i + 1);
              search = str.substring(i);
            }
            break;
          case 9:
          /* \t */
          case 10:
          /* \n */
          case 12:
          /* \f */
          case 13:
          /* \r */
          case 32:
          /*    */
          case 35:
          /* #  */
          case 160:
          case 65279:
            return parse4(str);
        }
      }
      var url5 = Url !== void 0 ? new Url() : {};
      url5.path = str;
      url5.href = str;
      url5.pathname = pathname;
      if (search !== null) {
        url5.query = query;
        url5.search = search;
      }
      return url5;
    }
    function fresh(url5, parsedUrl) {
      return typeof parsedUrl === "object" && parsedUrl !== null && (Url === void 0 || parsedUrl instanceof Url) && parsedUrl._raw === url5;
    }
  }
});

// node_modules/finalhandler/index.js
var require_finalhandler = __commonJS({
  "node_modules/finalhandler/index.js"(exports2, module2) {
    "use strict";
    var debug = require_src()("finalhandler");
    var encodeUrl = require_encodeurl();
    var escapeHtml = require_escape_html();
    var onFinished = require_on_finished();
    var parseUrl2 = require_parseurl();
    var statuses = require_statuses();
    var isFinished = onFinished.isFinished;
    function createHtmlDocument(message) {
      var body = escapeHtml(message).replaceAll("\n", "<br>").replaceAll("  ", " &nbsp;");
      return '<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="utf-8">\n<title>Error</title>\n</head>\n<body>\n<pre>' + body + "</pre>\n</body>\n</html>\n";
    }
    module2.exports = finalhandler;
    function finalhandler(req, res, options) {
      var opts = options || {};
      var env2 = opts.env || process.env.NODE_ENV || "development";
      var onerror = opts.onerror;
      return function(err) {
        var headers;
        var msg;
        var status;
        if (!err && res.headersSent) {
          debug("cannot 404 after headers sent");
          return;
        }
        if (err) {
          status = getErrorStatusCode(err);
          if (status === void 0) {
            status = getResponseStatusCode(res);
          } else {
            headers = getErrorHeaders(err);
          }
          msg = getErrorMessage6(err, status, env2);
        } else {
          status = 404;
          msg = "Cannot " + req.method + " " + encodeUrl(getResourceName(req));
        }
        debug("default %s", status);
        if (err && onerror) {
          setImmediate(onerror, err, req, res);
        }
        if (res.headersSent) {
          debug("cannot %d after headers sent", status);
          if (req.socket) {
            req.socket.destroy();
          }
          return;
        }
        send(req, res, status, headers, msg);
      };
    }
    function getErrorHeaders(err) {
      if (!err.headers || typeof err.headers !== "object") {
        return void 0;
      }
      return { ...err.headers };
    }
    function getErrorMessage6(err, status, env2) {
      var msg;
      if (env2 !== "production") {
        msg = err.stack;
        if (!msg && typeof err.toString === "function") {
          msg = err.toString();
        }
      }
      return msg || statuses.message[status];
    }
    function getErrorStatusCode(err) {
      if (typeof err.status === "number" && err.status >= 400 && err.status < 600) {
        return err.status;
      }
      if (typeof err.statusCode === "number" && err.statusCode >= 400 && err.statusCode < 600) {
        return err.statusCode;
      }
      return void 0;
    }
    function getResourceName(req) {
      try {
        return parseUrl2.original(req).pathname;
      } catch (e) {
        return "resource";
      }
    }
    function getResponseStatusCode(res) {
      var status = res.statusCode;
      if (typeof status !== "number" || status < 400 || status > 599) {
        status = 500;
      }
      return status;
    }
    function send(req, res, status, headers, message) {
      function write() {
        var body = createHtmlDocument(message);
        res.statusCode = status;
        if (req.httpVersionMajor < 2) {
          res.statusMessage = statuses.message[status];
        }
        res.removeHeader("Content-Encoding");
        res.removeHeader("Content-Language");
        res.removeHeader("Content-Range");
        for (const [key, value] of Object.entries(headers ?? {})) {
          res.setHeader(key, value);
        }
        res.setHeader("Content-Security-Policy", "default-src 'none'");
        res.setHeader("X-Content-Type-Options", "nosniff");
        res.setHeader("Content-Type", "text/html; charset=utf-8");
        res.setHeader("Content-Length", Buffer.byteLength(body, "utf8"));
        if (req.method === "HEAD") {
          res.end();
          return;
        }
        res.end(body, "utf8");
      }
      if (isFinished(req)) {
        write();
        return;
      }
      req.unpipe();
      onFinished(req, write);
      req.resume();
    }
  }
});

// node_modules/express/lib/view.js
var require_view = __commonJS({
  "node_modules/express/lib/view.js"(exports2, module2) {
    "use strict";
    var debug = require_src()("express:view");
    var path33 = require("node:path");
    var fs34 = require("node:fs");
    var dirname2 = path33.dirname;
    var basename = path33.basename;
    var extname = path33.extname;
    var join2 = path33.join;
    var resolve3 = path33.resolve;
    module2.exports = View;
    function View(name28, options) {
      var opts = options || {};
      this.defaultEngine = opts.defaultEngine;
      this.ext = extname(name28);
      this.name = name28;
      this.root = opts.root;
      if (!this.ext && !this.defaultEngine) {
        throw new Error("No default engine was specified and no extension was provided.");
      }
      var fileName = name28;
      if (!this.ext) {
        this.ext = this.defaultEngine[0] !== "." ? "." + this.defaultEngine : this.defaultEngine;
        fileName += this.ext;
      }
      if (!opts.engines[this.ext]) {
        var mod = this.ext.slice(1);
        debug('require "%s"', mod);
        var fn = require(mod).__express;
        if (typeof fn !== "function") {
          throw new Error('Module "' + mod + '" does not provide a view engine.');
        }
        opts.engines[this.ext] = fn;
      }
      this.engine = opts.engines[this.ext];
      this.path = this.lookup(fileName);
    }
    View.prototype.lookup = function lookup(name28) {
      var path34;
      var roots = [].concat(this.root);
      debug('lookup "%s"', name28);
      for (var i = 0; i < roots.length && !path34; i++) {
        var root2 = roots[i];
        var loc = resolve3(root2, name28);
        var dir = dirname2(loc);
        var file3 = basename(loc);
        path34 = this.resolve(dir, file3);
      }
      return path34;
    };
    View.prototype.render = function render(options, callback) {
      var sync = true;
      debug('render "%s"', this.path);
      this.engine(this.path, options, function onRender() {
        if (!sync) {
          return callback.apply(this, arguments);
        }
        var args = new Array(arguments.length);
        var cntx = this;
        for (var i = 0; i < arguments.length; i++) {
          args[i] = arguments[i];
        }
        return process.nextTick(function renderTick() {
          return callback.apply(cntx, args);
        });
      });
      sync = false;
    };
    View.prototype.resolve = function resolve4(dir, file3) {
      var ext = this.ext;
      var path34 = join2(dir, file3);
      var stat = tryStat(path34);
      if (stat && stat.isFile()) {
        return path34;
      }
      path34 = join2(dir, basename(file3, ext), "index" + ext);
      stat = tryStat(path34);
      if (stat && stat.isFile()) {
        return path34;
      }
    };
    function tryStat(path34) {
      debug('stat "%s"', path34);
      try {
        return fs34.statSync(path34);
      } catch (e) {
        return void 0;
      }
    }
  }
});

// node_modules/etag/index.js
var require_etag = __commonJS({
  "node_modules/etag/index.js"(exports2, module2) {
    "use strict";
    module2.exports = etag;
    var crypto7 = require("crypto");
    var Stats = require("fs").Stats;
    var toString4 = Object.prototype.toString;
    function entitytag(entity) {
      if (entity.length === 0) {
        return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
      }
      var hash3 = crypto7.createHash("sha1").update(entity, "utf8").digest("base64").substring(0, 27);
      var len = typeof entity === "string" ? Buffer.byteLength(entity, "utf8") : entity.length;
      return '"' + len.toString(16) + "-" + hash3 + '"';
    }
    function etag(entity, options) {
      if (entity == null) {
        throw new TypeError("argument entity is required");
      }
      var isStats = isstats(entity);
      var weak = options && typeof options.weak === "boolean" ? options.weak : isStats;
      if (!isStats && typeof entity !== "string" && !Buffer.isBuffer(entity)) {
        throw new TypeError("argument entity must be string, Buffer, or fs.Stats");
      }
      var tag = isStats ? stattag(entity) : entitytag(entity);
      return weak ? "W/" + tag : tag;
    }
    function isstats(obj) {
      if (typeof Stats === "function" && obj instanceof Stats) {
        return true;
      }
      return obj && typeof obj === "object" && "ctime" in obj && toString4.call(obj.ctime) === "[object Date]" && "mtime" in obj && toString4.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number";
    }
    function stattag(stat) {
      var mtime = stat.mtime.getTime().toString(16);
      var size = stat.size.toString(16);
      return '"' + size + "-" + mtime + '"';
    }
  }
});

// node_modules/forwarded/index.js
var require_forwarded = __commonJS({
  "node_modules/forwarded/index.js"(exports2, module2) {
    "use strict";
    module2.exports = forwarded;
    function forwarded(req) {
      if (!req) {
        throw new TypeError("argument req is required");
      }
      var proxyAddrs = parse4(req.headers["x-forwarded-for"] || "");
      var socketAddr = getSocketAddr(req);
      var addrs = [socketAddr].concat(proxyAddrs);
      return addrs;
    }
    function getSocketAddr(req) {
      return req.socket ? req.socket.remoteAddress : req.connection.remoteAddress;
    }
    function parse4(header) {
      var end = header.length;
      var list2 = [];
      var start = header.length;
      for (var i = header.length - 1; i >= 0; i--) {
        switch (header.charCodeAt(i)) {
          case 32:
            if (start === end) {
              start = end = i;
            }
            break;
          case 44:
            if (start !== end) {
              list2.push(header.substring(start, end));
            }
            start = end = i;
            break;
          default:
            start = i;
            break;
        }
      }
      if (start !== end) {
        list2.push(header.substring(start, end));
      }
      return list2;
    }
  }
});

// node_modules/ipaddr.js/lib/ipaddr.js
var require_ipaddr = __commonJS({
  "node_modules/ipaddr.js/lib/ipaddr.js"(exports2, module2) {
    "use strict";
    (function() {
      var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root2, zoneIndex;
      ipaddr = {};
      root2 = this;
      if (typeof module2 !== "undefined" && module2 !== null && module2.exports) {
        module2.exports = ipaddr;
      } else {
        root2["ipaddr"] = ipaddr;
      }
      matchCIDR = function(first, second, partSize, cidrBits) {
        var part, shift;
        if (first.length !== second.length) {
          throw new Error("ipaddr: cannot match CIDR for objects with different lengths");
        }
        part = 0;
        while (cidrBits > 0) {
          shift = partSize - cidrBits;
          if (shift < 0) {
            shift = 0;
          }
          if (first[part] >> shift !== second[part] >> shift) {
            return false;
          }
          cidrBits -= partSize;
          part += 1;
        }
        return true;
      };
      ipaddr.subnetMatch = function(address, rangeList, defaultName) {
        var k, len, rangeName, rangeSubnets, subnet;
        if (defaultName == null) {
          defaultName = "unicast";
        }
        for (rangeName in rangeList) {
          rangeSubnets = rangeList[rangeName];
          if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) {
            rangeSubnets = [rangeSubnets];
          }
          for (k = 0, len = rangeSubnets.length; k < len; k++) {
            subnet = rangeSubnets[k];
            if (address.kind() === subnet[0].kind()) {
              if (address.match.apply(address, subnet)) {
                return rangeName;
              }
            }
          }
        }
        return defaultName;
      };
      ipaddr.IPv4 = (function() {
        function IPv4(octets) {
          var k, len, octet;
          if (octets.length !== 4) {
            throw new Error("ipaddr: ipv4 octet count should be 4");
          }
          for (k = 0, len = octets.length; k < len; k++) {
            octet = octets[k];
            if (!(0 <= octet && octet <= 255)) {
              throw new Error("ipaddr: ipv4 octet should fit in 8 bits");
            }
          }
          this.octets = octets;
        }
        IPv4.prototype.kind = function() {
          return "ipv4";
        };
        IPv4.prototype.toString = function() {
          return this.octets.join(".");
        };
        IPv4.prototype.toNormalizedString = function() {
          return this.toString();
        };
        IPv4.prototype.toByteArray = function() {
          return this.octets.slice(0);
        };
        IPv4.prototype.match = function(other, cidrRange) {
          var ref;
          if (cidrRange === void 0) {
            ref = other, other = ref[0], cidrRange = ref[1];
          }
          if (other.kind() !== "ipv4") {
            throw new Error("ipaddr: cannot match ipv4 address with non-ipv4 one");
          }
          return matchCIDR(this.octets, other.octets, 8, cidrRange);
        };
        IPv4.prototype.SpecialRanges = {
          unspecified: [[new IPv4([0, 0, 0, 0]), 8]],
          broadcast: [[new IPv4([255, 255, 255, 255]), 32]],
          multicast: [[new IPv4([224, 0, 0, 0]), 4]],
          linkLocal: [[new IPv4([169, 254, 0, 0]), 16]],
          loopback: [[new IPv4([127, 0, 0, 0]), 8]],
          carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]],
          "private": [[new IPv4([10, 0, 0, 0]), 8], [new IPv4([172, 16, 0, 0]), 12], [new IPv4([192, 168, 0, 0]), 16]],
          reserved: [[new IPv4([192, 0, 0, 0]), 24], [new IPv4([192, 0, 2, 0]), 24], [new IPv4([192, 88, 99, 0]), 24], [new IPv4([198, 51, 100, 0]), 24], [new IPv4([203, 0, 113, 0]), 24], [new IPv4([240, 0, 0, 0]), 4]]
        };
        IPv4.prototype.range = function() {
          return ipaddr.subnetMatch(this, this.SpecialRanges);
        };
        IPv4.prototype.toIPv4MappedAddress = function() {
          return ipaddr.IPv6.parse("::ffff:" + this.toString());
        };
        IPv4.prototype.prefixLengthFromSubnetMask = function() {
          var cidr, i, k, octet, stop, zeros, zerotable;
          zerotable = {
            0: 8,
            128: 7,
            192: 6,
            224: 5,
            240: 4,
            248: 3,
            252: 2,
            254: 1,
            255: 0
          };
          cidr = 0;
          stop = false;
          for (i = k = 3; k >= 0; i = k += -1) {
            octet = this.octets[i];
            if (octet in zerotable) {
              zeros = zerotable[octet];
              if (stop && zeros !== 0) {
                return null;
              }
              if (zeros !== 8) {
                stop = true;
              }
              cidr += zeros;
            } else {
              return null;
            }
          }
          return 32 - cidr;
        };
        return IPv4;
      })();
      ipv4Part = "(0?\\d+|0x[a-f0-9]+)";
      ipv4Regexes = {
        fourOctet: new RegExp("^" + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$", "i"),
        longValue: new RegExp("^" + ipv4Part + "$", "i")
      };
      ipaddr.IPv4.parser = function(string5) {
        var match, parseIntAuto, part, shift, value;
        parseIntAuto = function(string6) {
          if (string6[0] === "0" && string6[1] !== "x") {
            return parseInt(string6, 8);
          } else {
            return parseInt(string6);
          }
        };
        if (match = string5.match(ipv4Regexes.fourOctet)) {
          return (function() {
            var k, len, ref, results;
            ref = match.slice(1, 6);
            results = [];
            for (k = 0, len = ref.length; k < len; k++) {
              part = ref[k];
              results.push(parseIntAuto(part));
            }
            return results;
          })();
        } else if (match = string5.match(ipv4Regexes.longValue)) {
          value = parseIntAuto(match[1]);
          if (value > 4294967295 || value < 0) {
            throw new Error("ipaddr: address outside defined range");
          }
          return (function() {
            var k, results;
            results = [];
            for (shift = k = 0; k <= 24; shift = k += 8) {
              results.push(value >> shift & 255);
            }
            return results;
          })().reverse();
        } else {
          return null;
        }
      };
      ipaddr.IPv6 = (function() {
        function IPv6(parts, zoneId) {
          var i, k, l, len, part, ref;
          if (parts.length === 16) {
            this.parts = [];
            for (i = k = 0; k <= 14; i = k += 2) {
              this.parts.push(parts[i] << 8 | parts[i + 1]);
            }
          } else if (parts.length === 8) {
            this.parts = parts;
          } else {
            throw new Error("ipaddr: ipv6 part count should be 8 or 16");
          }
          ref = this.parts;
          for (l = 0, len = ref.length; l < len; l++) {
            part = ref[l];
            if (!(0 <= part && part <= 65535)) {
              throw new Error("ipaddr: ipv6 part should fit in 16 bits");
            }
          }
          if (zoneId) {
            this.zoneId = zoneId;
          }
        }
        IPv6.prototype.kind = function() {
          return "ipv6";
        };
        IPv6.prototype.toString = function() {
          return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, "::");
        };
        IPv6.prototype.toRFC5952String = function() {
          var bestMatchIndex, bestMatchLength, match, regex, string5;
          regex = /((^|:)(0(:|$)){2,})/g;
          string5 = this.toNormalizedString();
          bestMatchIndex = 0;
          bestMatchLength = -1;
          while (match = regex.exec(string5)) {
            if (match[0].length > bestMatchLength) {
              bestMatchIndex = match.index;
              bestMatchLength = match[0].length;
            }
          }
          if (bestMatchLength < 0) {
            return string5;
          }
          return string5.substring(0, bestMatchIndex) + "::" + string5.substring(bestMatchIndex + bestMatchLength);
        };
        IPv6.prototype.toByteArray = function() {
          var bytes, k, len, part, ref;
          bytes = [];
          ref = this.parts;
          for (k = 0, len = ref.length; k < len; k++) {
            part = ref[k];
            bytes.push(part >> 8);
            bytes.push(part & 255);
          }
          return bytes;
        };
        IPv6.prototype.toNormalizedString = function() {
          var addr, part, suffix;
          addr = (function() {
            var k, len, ref, results;
            ref = this.parts;
            results = [];
            for (k = 0, len = ref.length; k < len; k++) {
              part = ref[k];
              results.push(part.toString(16));
            }
            return results;
          }).call(this).join(":");
          suffix = "";
          if (this.zoneId) {
            suffix = "%" + this.zoneId;
          }
          return addr + suffix;
        };
        IPv6.prototype.toFixedLengthString = function() {
          var addr, part, suffix;
          addr = (function() {
            var k, len, ref, results;
            ref = this.parts;
            results = [];
            for (k = 0, len = ref.length; k < len; k++) {
              part = ref[k];
              results.push(part.toString(16).padStart(4, "0"));
            }
            return results;
          }).call(this).join(":");
          suffix = "";
          if (this.zoneId) {
            suffix = "%" + this.zoneId;
          }
          return addr + suffix;
        };
        IPv6.prototype.match = function(other, cidrRange) {
          var ref;
          if (cidrRange === void 0) {
            ref = other, other = ref[0], cidrRange = ref[1];
          }
          if (other.kind() !== "ipv6") {
            throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one");
          }
          return matchCIDR(this.parts, other.parts, 16, cidrRange);
        };
        IPv6.prototype.SpecialRanges = {
          unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128],
          linkLocal: [new IPv6([65152, 0, 0, 0, 0, 0, 0, 0]), 10],
          multicast: [new IPv6([65280, 0, 0, 0, 0, 0, 0, 0]), 8],
          loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128],
          uniqueLocal: [new IPv6([64512, 0, 0, 0, 0, 0, 0, 0]), 7],
          ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 65535, 0, 0]), 96],
          rfc6145: [new IPv6([0, 0, 0, 0, 65535, 0, 0, 0]), 96],
          rfc6052: [new IPv6([100, 65435, 0, 0, 0, 0, 0, 0]), 96],
          "6to4": [new IPv6([8194, 0, 0, 0, 0, 0, 0, 0]), 16],
          teredo: [new IPv6([8193, 0, 0, 0, 0, 0, 0, 0]), 32],
          reserved: [[new IPv6([8193, 3512, 0, 0, 0, 0, 0, 0]), 32]]
        };
        IPv6.prototype.range = function() {
          return ipaddr.subnetMatch(this, this.SpecialRanges);
        };
        IPv6.prototype.isIPv4MappedAddress = function() {
          return this.range() === "ipv4Mapped";
        };
        IPv6.prototype.toIPv4Address = function() {
          var high, low, ref;
          if (!this.isIPv4MappedAddress()) {
            throw new Error("ipaddr: trying to convert a generic ipv6 address to ipv4");
          }
          ref = this.parts.slice(-2), high = ref[0], low = ref[1];
          return new ipaddr.IPv4([high >> 8, high & 255, low >> 8, low & 255]);
        };
        IPv6.prototype.prefixLengthFromSubnetMask = function() {
          var cidr, i, k, part, stop, zeros, zerotable;
          zerotable = {
            0: 16,
            32768: 15,
            49152: 14,
            57344: 13,
            61440: 12,
            63488: 11,
            64512: 10,
            65024: 9,
            65280: 8,
            65408: 7,
            65472: 6,
            65504: 5,
            65520: 4,
            65528: 3,
            65532: 2,
            65534: 1,
            65535: 0
          };
          cidr = 0;
          stop = false;
          for (i = k = 7; k >= 0; i = k += -1) {
            part = this.parts[i];
            if (part in zerotable) {
              zeros = zerotable[part];
              if (stop && zeros !== 0) {
                return null;
              }
              if (zeros !== 16) {
                stop = true;
              }
              cidr += zeros;
            } else {
              return null;
            }
          }
          return 128 - cidr;
        };
        return IPv6;
      })();
      ipv6Part = "(?:[0-9a-f]+::?)+";
      zoneIndex = "%[0-9a-z]{1,}";
      ipv6Regexes = {
        zoneIndex: new RegExp(zoneIndex, "i"),
        "native": new RegExp("^(::)?(" + ipv6Part + ")?([0-9a-f]+)?(::)?(" + zoneIndex + ")?$", "i"),
        transitional: new RegExp("^((?:" + ipv6Part + ")|(?:::)(?:" + ipv6Part + ")?)" + (ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part) + ("(" + zoneIndex + ")?$"), "i")
      };
      expandIPv6 = function(string5, parts) {
        var colonCount, lastColon, part, replacement, replacementCount, zoneId;
        if (string5.indexOf("::") !== string5.lastIndexOf("::")) {
          return null;
        }
        zoneId = (string5.match(ipv6Regexes["zoneIndex"]) || [])[0];
        if (zoneId) {
          zoneId = zoneId.substring(1);
          string5 = string5.replace(/%.+$/, "");
        }
        colonCount = 0;
        lastColon = -1;
        while ((lastColon = string5.indexOf(":", lastColon + 1)) >= 0) {
          colonCount++;
        }
        if (string5.substr(0, 2) === "::") {
          colonCount--;
        }
        if (string5.substr(-2, 2) === "::") {
          colonCount--;
        }
        if (colonCount > parts) {
          return null;
        }
        replacementCount = parts - colonCount;
        replacement = ":";
        while (replacementCount--) {
          replacement += "0:";
        }
        string5 = string5.replace("::", replacement);
        if (string5[0] === ":") {
          string5 = string5.slice(1);
        }
        if (string5[string5.length - 1] === ":") {
          string5 = string5.slice(0, -1);
        }
        parts = (function() {
          var k, len, ref, results;
          ref = string5.split(":");
          results = [];
          for (k = 0, len = ref.length; k < len; k++) {
            part = ref[k];
            results.push(parseInt(part, 16));
          }
          return results;
        })();
        return {
          parts,
          zoneId
        };
      };
      ipaddr.IPv6.parser = function(string5) {
        var addr, k, len, match, octet, octets, zoneId;
        if (ipv6Regexes["native"].test(string5)) {
          return expandIPv6(string5, 8);
        } else if (match = string5.match(ipv6Regexes["transitional"])) {
          zoneId = match[6] || "";
          addr = expandIPv6(match[1].slice(0, -1) + zoneId, 6);
          if (addr.parts) {
            octets = [parseInt(match[2]), parseInt(match[3]), parseInt(match[4]), parseInt(match[5])];
            for (k = 0, len = octets.length; k < len; k++) {
              octet = octets[k];
              if (!(0 <= octet && octet <= 255)) {
                return null;
              }
            }
            addr.parts.push(octets[0] << 8 | octets[1]);
            addr.parts.push(octets[2] << 8 | octets[3]);
            return {
              parts: addr.parts,
              zoneId: addr.zoneId
            };
          }
        }
        return null;
      };
      ipaddr.IPv4.isIPv4 = ipaddr.IPv6.isIPv6 = function(string5) {
        return this.parser(string5) !== null;
      };
      ipaddr.IPv4.isValid = function(string5) {
        var e;
        try {
          new this(this.parser(string5));
          return true;
        } catch (error1) {
          e = error1;
          return false;
        }
      };
      ipaddr.IPv4.isValidFourPartDecimal = function(string5) {
        if (ipaddr.IPv4.isValid(string5) && string5.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) {
          return true;
        } else {
          return false;
        }
      };
      ipaddr.IPv6.isValid = function(string5) {
        var addr, e;
        if (typeof string5 === "string" && string5.indexOf(":") === -1) {
          return false;
        }
        try {
          addr = this.parser(string5);
          new this(addr.parts, addr.zoneId);
          return true;
        } catch (error1) {
          e = error1;
          return false;
        }
      };
      ipaddr.IPv4.parse = function(string5) {
        var parts;
        parts = this.parser(string5);
        if (parts === null) {
          throw new Error("ipaddr: string is not formatted like ip address");
        }
        return new this(parts);
      };
      ipaddr.IPv6.parse = function(string5) {
        var addr;
        addr = this.parser(string5);
        if (addr.parts === null) {
          throw new Error("ipaddr: string is not formatted like ip address");
        }
        return new this(addr.parts, addr.zoneId);
      };
      ipaddr.IPv4.parseCIDR = function(string5) {
        var maskLength, match, parsed;
        if (match = string5.match(/^(.+)\/(\d+)$/)) {
          maskLength = parseInt(match[2]);
          if (maskLength >= 0 && maskLength <= 32) {
            parsed = [this.parse(match[1]), maskLength];
            Object.defineProperty(parsed, "toString", {
              value: function() {
                return this.join("/");
              }
            });
            return parsed;
          }
        }
        throw new Error("ipaddr: string is not formatted like an IPv4 CIDR range");
      };
      ipaddr.IPv4.subnetMaskFromPrefixLength = function(prefix) {
        var filledOctetCount, j, octets;
        prefix = parseInt(prefix);
        if (prefix < 0 || prefix > 32) {
          throw new Error("ipaddr: invalid IPv4 prefix length");
        }
        octets = [0, 0, 0, 0];
        j = 0;
        filledOctetCount = Math.floor(prefix / 8);
        while (j < filledOctetCount) {
          octets[j] = 255;
          j++;
        }
        if (filledOctetCount < 4) {
          octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8;
        }
        return new this(octets);
      };
      ipaddr.IPv4.broadcastAddressFromCIDR = function(string5) {
        var cidr, error73, i, ipInterfaceOctets, octets, subnetMaskOctets;
        try {
          cidr = this.parseCIDR(string5);
          ipInterfaceOctets = cidr[0].toByteArray();
          subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
          octets = [];
          i = 0;
          while (i < 4) {
            octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255);
            i++;
          }
          return new this(octets);
        } catch (error1) {
          error73 = error1;
          throw new Error("ipaddr: the address does not have IPv4 CIDR format");
        }
      };
      ipaddr.IPv4.networkAddressFromCIDR = function(string5) {
        var cidr, error73, i, ipInterfaceOctets, octets, subnetMaskOctets;
        try {
          cidr = this.parseCIDR(string5);
          ipInterfaceOctets = cidr[0].toByteArray();
          subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
          octets = [];
          i = 0;
          while (i < 4) {
            octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));
            i++;
          }
          return new this(octets);
        } catch (error1) {
          error73 = error1;
          throw new Error("ipaddr: the address does not have IPv4 CIDR format");
        }
      };
      ipaddr.IPv6.parseCIDR = function(string5) {
        var maskLength, match, parsed;
        if (match = string5.match(/^(.+)\/(\d+)$/)) {
          maskLength = parseInt(match[2]);
          if (maskLength >= 0 && maskLength <= 128) {
            parsed = [this.parse(match[1]), maskLength];
            Object.defineProperty(parsed, "toString", {
              value: function() {
                return this.join("/");
              }
            });
            return parsed;
          }
        }
        throw new Error("ipaddr: string is not formatted like an IPv6 CIDR range");
      };
      ipaddr.isValid = function(string5) {
        return ipaddr.IPv6.isValid(string5) || ipaddr.IPv4.isValid(string5);
      };
      ipaddr.parse = function(string5) {
        if (ipaddr.IPv6.isValid(string5)) {
          return ipaddr.IPv6.parse(string5);
        } else if (ipaddr.IPv4.isValid(string5)) {
          return ipaddr.IPv4.parse(string5);
        } else {
          throw new Error("ipaddr: the address has neither IPv6 nor IPv4 format");
        }
      };
      ipaddr.parseCIDR = function(string5) {
        var e;
        try {
          return ipaddr.IPv6.parseCIDR(string5);
        } catch (error1) {
          e = error1;
          try {
            return ipaddr.IPv4.parseCIDR(string5);
          } catch (error110) {
            e = error110;
            throw new Error("ipaddr: the address has neither IPv6 nor IPv4 CIDR format");
          }
        }
      };
      ipaddr.fromByteArray = function(bytes) {
        var length;
        length = bytes.length;
        if (length === 4) {
          return new ipaddr.IPv4(bytes);
        } else if (length === 16) {
          return new ipaddr.IPv6(bytes);
        } else {
          throw new Error("ipaddr: the binary input is neither an IPv6 nor IPv4 address");
        }
      };
      ipaddr.process = function(string5) {
        var addr;
        addr = this.parse(string5);
        if (addr.kind() === "ipv6" && addr.isIPv4MappedAddress()) {
          return addr.toIPv4Address();
        } else {
          return addr;
        }
      };
    }).call(exports2);
  }
});

// node_modules/proxy-addr/index.js
var require_proxy_addr = __commonJS({
  "node_modules/proxy-addr/index.js"(exports2, module2) {
    "use strict";
    module2.exports = proxyaddr;
    module2.exports.all = alladdrs;
    module2.exports.compile = compile;
    var forwarded = require_forwarded();
    var ipaddr = require_ipaddr();
    var DIGIT_REGEXP = /^[0-9]+$/;
    var isip = ipaddr.isValid;
    var parseip = ipaddr.parse;
    var IP_RANGES = {
      linklocal: ["169.254.0.0/16", "fe80::/10"],
      loopback: ["127.0.0.1/8", "::1/128"],
      uniquelocal: ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "fc00::/7"]
    };
    function alladdrs(req, trust) {
      var addrs = forwarded(req);
      if (!trust) {
        return addrs;
      }
      if (typeof trust !== "function") {
        trust = compile(trust);
      }
      for (var i = 0; i < addrs.length - 1; i++) {
        if (trust(addrs[i], i)) continue;
        addrs.length = i + 1;
      }
      return addrs;
    }
    function compile(val) {
      if (!val) {
        throw new TypeError("argument is required");
      }
      var trust;
      if (typeof val === "string") {
        trust = [val];
      } else if (Array.isArray(val)) {
        trust = val.slice();
      } else {
        throw new TypeError("unsupported trust argument");
      }
      for (var i = 0; i < trust.length; i++) {
        val = trust[i];
        if (!Object.prototype.hasOwnProperty.call(IP_RANGES, val)) {
          continue;
        }
        val = IP_RANGES[val];
        trust.splice.apply(trust, [i, 1].concat(val));
        i += val.length - 1;
      }
      return compileTrust(compileRangeSubnets(trust));
    }
    function compileRangeSubnets(arr) {
      var rangeSubnets = new Array(arr.length);
      for (var i = 0; i < arr.length; i++) {
        rangeSubnets[i] = parseipNotation(arr[i]);
      }
      return rangeSubnets;
    }
    function compileTrust(rangeSubnets) {
      var len = rangeSubnets.length;
      return len === 0 ? trustNone : len === 1 ? trustSingle(rangeSubnets[0]) : trustMulti(rangeSubnets);
    }
    function parseipNotation(note) {
      var pos = note.lastIndexOf("/");
      var str = pos !== -1 ? note.substring(0, pos) : note;
      if (!isip(str)) {
        throw new TypeError("invalid IP address: " + str);
      }
      var ip = parseip(str);
      if (pos === -1 && ip.kind() === "ipv6" && ip.isIPv4MappedAddress()) {
        ip = ip.toIPv4Address();
      }
      var max = ip.kind() === "ipv6" ? 128 : 32;
      var range = pos !== -1 ? note.substring(pos + 1, note.length) : null;
      if (range === null) {
        range = max;
      } else if (DIGIT_REGEXP.test(range)) {
        range = parseInt(range, 10);
      } else if (ip.kind() === "ipv4" && isip(range)) {
        range = parseNetmask(range);
      } else {
        range = null;
      }
      if (range <= 0 || range > max) {
        throw new TypeError("invalid range on address: " + note);
      }
      return [ip, range];
    }
    function parseNetmask(netmask) {
      var ip = parseip(netmask);
      var kind = ip.kind();
      return kind === "ipv4" ? ip.prefixLengthFromSubnetMask() : null;
    }
    function proxyaddr(req, trust) {
      if (!req) {
        throw new TypeError("req argument is required");
      }
      if (!trust) {
        throw new TypeError("trust argument is required");
      }
      var addrs = alladdrs(req, trust);
      var addr = addrs[addrs.length - 1];
      return addr;
    }
    function trustNone() {
      return false;
    }
    function trustMulti(subnets) {
      return function trust(addr) {
        if (!isip(addr)) return false;
        var ip = parseip(addr);
        var ipconv;
        var kind = ip.kind();
        for (var i = 0; i < subnets.length; i++) {
          var subnet = subnets[i];
          var subnetip = subnet[0];
          var subnetkind = subnetip.kind();
          var subnetrange = subnet[1];
          var trusted = ip;
          if (kind !== subnetkind) {
            if (subnetkind === "ipv4" && !ip.isIPv4MappedAddress()) {
              continue;
            }
            if (!ipconv) {
              ipconv = subnetkind === "ipv4" ? ip.toIPv4Address() : ip.toIPv4MappedAddress();
            }
            trusted = ipconv;
          }
          if (trusted.match(subnetip, subnetrange)) {
            return true;
          }
        }
        return false;
      };
    }
    function trustSingle(subnet) {
      var subnetip = subnet[0];
      var subnetkind = subnetip.kind();
      var subnetisipv4 = subnetkind === "ipv4";
      var subnetrange = subnet[1];
      return function trust(addr) {
        if (!isip(addr)) return false;
        var ip = parseip(addr);
        var kind = ip.kind();
        if (kind !== subnetkind) {
          if (subnetisipv4 && !ip.isIPv4MappedAddress()) {
            return false;
          }
          ip = subnetisipv4 ? ip.toIPv4Address() : ip.toIPv4MappedAddress();
        }
        return ip.match(subnetip, subnetrange);
      };
    }
  }
});

// node_modules/express/lib/utils.js
var require_utils3 = __commonJS({
  "node_modules/express/lib/utils.js"(exports2) {
    "use strict";
    var { METHODS } = require("node:http");
    var contentType = require_content_type();
    var etag = require_etag();
    var mime = require_mime_types();
    var proxyaddr = require_proxy_addr();
    var qs = require_lib2();
    var querystring = require("node:querystring");
    var { Buffer: Buffer3 } = require("node:buffer");
    exports2.methods = METHODS.map((method) => method.toLowerCase());
    exports2.etag = createETagGenerator({ weak: false });
    exports2.wetag = createETagGenerator({ weak: true });
    exports2.normalizeType = function(type) {
      return ~type.indexOf("/") ? acceptParams(type) : { value: mime.lookup(type) || "application/octet-stream", params: {} };
    };
    exports2.normalizeTypes = function(types) {
      return types.map(exports2.normalizeType);
    };
    function acceptParams(str) {
      var length = str.length;
      var colonIndex = str.indexOf(";");
      var index = colonIndex === -1 ? length : colonIndex;
      var ret = { value: str.slice(0, index).trim(), quality: 1, params: {} };
      while (index < length) {
        var splitIndex = str.indexOf("=", index);
        if (splitIndex === -1) break;
        var colonIndex = str.indexOf(";", index);
        var endIndex = colonIndex === -1 ? length : colonIndex;
        if (splitIndex > endIndex) {
          index = str.lastIndexOf(";", splitIndex - 1) + 1;
          continue;
        }
        var key = str.slice(index, splitIndex).trim();
        var value = str.slice(splitIndex + 1, endIndex).trim();
        if (key === "q") {
          ret.quality = parseFloat(value);
        } else {
          ret.params[key] = value;
        }
        index = endIndex + 1;
      }
      return ret;
    }
    exports2.compileETag = function(val) {
      var fn;
      if (typeof val === "function") {
        return val;
      }
      switch (val) {
        case true:
        case "weak":
          fn = exports2.wetag;
          break;
        case false:
          break;
        case "strong":
          fn = exports2.etag;
          break;
        default:
          throw new TypeError("unknown value for etag function: " + val);
      }
      return fn;
    };
    exports2.compileQueryParser = function compileQueryParser(val) {
      var fn;
      if (typeof val === "function") {
        return val;
      }
      switch (val) {
        case true:
        case "simple":
          fn = querystring.parse;
          break;
        case false:
          break;
        case "extended":
          fn = parseExtendedQueryString;
          break;
        default:
          throw new TypeError("unknown value for query parser function: " + val);
      }
      return fn;
    };
    exports2.compileTrust = function(val) {
      if (typeof val === "function") return val;
      if (val === true) {
        return function() {
          return true;
        };
      }
      if (typeof val === "number") {
        return function(a, i) {
          return i < val;
        };
      }
      if (typeof val === "string") {
        val = val.split(",").map(function(v) {
          return v.trim();
        });
      }
      return proxyaddr.compile(val || []);
    };
    exports2.setCharset = function setCharset(type, charset) {
      if (!type || !charset) {
        return type;
      }
      var parsed = contentType.parse(type);
      parsed.parameters.charset = charset;
      return contentType.format(parsed);
    };
    function createETagGenerator(options) {
      return function generateETag(body, encoding) {
        var buf = !Buffer3.isBuffer(body) ? Buffer3.from(body, encoding) : body;
        return etag(buf, options);
      };
    }
    function parseExtendedQueryString(str) {
      return qs.parse(str, {
        allowPrototypes: true
      });
    }
  }
});

// node_modules/wrappy/wrappy.js
var require_wrappy = __commonJS({
  "node_modules/wrappy/wrappy.js"(exports2, module2) {
    "use strict";
    module2.exports = wrappy;
    function wrappy(fn, cb) {
      if (fn && cb) return wrappy(fn)(cb);
      if (typeof fn !== "function")
        throw new TypeError("need wrapper function");
      Object.keys(fn).forEach(function(k) {
        wrapper[k] = fn[k];
      });
      return wrapper;
      function wrapper() {
        var args = new Array(arguments.length);
        for (var i = 0; i < args.length; i++) {
          args[i] = arguments[i];
        }
        var ret = fn.apply(this, args);
        var cb2 = args[args.length - 1];
        if (typeof ret === "function" && ret !== cb2) {
          Object.keys(cb2).forEach(function(k) {
            ret[k] = cb2[k];
          });
        }
        return ret;
      }
    }
  }
});

// node_modules/once/once.js
var require_once = __commonJS({
  "node_modules/once/once.js"(exports2, module2) {
    "use strict";
    var wrappy = require_wrappy();
    module2.exports = wrappy(once);
    module2.exports.strict = wrappy(onceStrict);
    once.proto = once(function() {
      Object.defineProperty(Function.prototype, "once", {
        value: function() {
          return once(this);
        },
        configurable: true
      });
      Object.defineProperty(Function.prototype, "onceStrict", {
        value: function() {
          return onceStrict(this);
        },
        configurable: true
      });
    });
    function once(fn) {
      var f = function() {
        if (f.called) return f.value;
        f.called = true;
        return f.value = fn.apply(this, arguments);
      };
      f.called = false;
      return f;
    }
    function onceStrict(fn) {
      var f = function() {
        if (f.called)
          throw new Error(f.onceError);
        f.called = true;
        return f.value = fn.apply(this, arguments);
      };
      var name28 = fn.name || "Function wrapped with `once`";
      f.onceError = name28 + " shouldn't be called more than once";
      f.called = false;
      return f;
    }
  }
});

// node_modules/is-promise/index.js
var require_is_promise = __commonJS({
  "node_modules/is-promise/index.js"(exports2, module2) {
    "use strict";
    module2.exports = isPromise;
    module2.exports.default = isPromise;
    function isPromise(obj) {
      return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
    }
  }
});

// node_modules/path-to-regexp/dist/index.js
var require_dist = __commonJS({
  "node_modules/path-to-regexp/dist/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PathError = exports2.TokenData = void 0;
    exports2.parse = parse4;
    exports2.compile = compile;
    exports2.match = match;
    exports2.pathToRegexp = pathToRegexp;
    exports2.stringify = stringify2;
    var DEFAULT_DELIMITER = "/";
    var NOOP_VALUE = (value) => value;
    var ID_START = /^[$_\p{ID_Start}]$/u;
    var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
    var ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
    var SIMPLE_TOKENS = "{}()[]+?!";
    function escapeText(str) {
      return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
    }
    function escape2(str) {
      return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
    }
    var TokenData = class {
      constructor(tokens, originalPath) {
        this.tokens = tokens;
        this.originalPath = originalPath;
      }
    };
    exports2.TokenData = TokenData;
    var PathError = class extends TypeError {
      constructor(message, originalPath) {
        let text2 = message;
        if (originalPath)
          text2 += `: ${originalPath}`;
        text2 += `; visit https://git.new/pathToRegexpError for info`;
        super(text2);
        this.originalPath = originalPath;
      }
    };
    exports2.PathError = PathError;
    function parse4(str, options = {}) {
      const { encodePath = NOOP_VALUE } = options;
      const chars = [...str];
      const tokens = [];
      let index = 0;
      let pos = 0;
      function name28() {
        let value = "";
        if (ID_START.test(chars[index])) {
          do {
            value += chars[index++];
          } while (ID_CONTINUE.test(chars[index]));
        } else if (chars[index] === '"') {
          let quoteStart = index;
          while (index < chars.length) {
            if (chars[++index] === '"') {
              index++;
              quoteStart = 0;
              break;
            }
            if (chars[index] === "\\")
              index++;
            value += chars[index];
          }
          if (quoteStart) {
            throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
          }
        }
        if (!value) {
          throw new PathError(`Missing parameter name at index ${index}`, str);
        }
        return value;
      }
      while (index < chars.length) {
        const value = chars[index++];
        if (SIMPLE_TOKENS.includes(value)) {
          tokens.push({ type: value, index, value });
        } else if (value === "\\") {
          tokens.push({ type: "escape", index, value: chars[index++] });
        } else if (value === ":") {
          tokens.push({ type: "param", index, value: name28() });
        } else if (value === "*") {
          tokens.push({ type: "wildcard", index, value: name28() });
        } else {
          tokens.push({ type: "char", index, value });
        }
      }
      tokens.push({ type: "end", index, value: "" });
      function consumeUntil(endType) {
        const output = [];
        while (true) {
          const token = tokens[pos++];
          if (token.type === endType)
            break;
          if (token.type === "char" || token.type === "escape") {
            let path33 = token.value;
            let cur = tokens[pos];
            while (cur.type === "char" || cur.type === "escape") {
              path33 += cur.value;
              cur = tokens[++pos];
            }
            output.push({
              type: "text",
              value: encodePath(path33)
            });
            continue;
          }
          if (token.type === "param" || token.type === "wildcard") {
            output.push({
              type: token.type,
              name: token.value
            });
            continue;
          }
          if (token.type === "{") {
            output.push({
              type: "group",
              tokens: consumeUntil("}")
            });
            continue;
          }
          throw new PathError(`Unexpected ${token.type} at index ${token.index}, expected ${endType}`, str);
        }
        return output;
      }
      return new TokenData(consumeUntil("end"), str);
    }
    function compile(path33, options = {}) {
      const { encode: encode6 = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
      const data = typeof path33 === "object" ? path33 : parse4(path33, options);
      const fn = tokensToFunction(data.tokens, delimiter, encode6);
      return function path34(params = {}) {
        const [path35, ...missing] = fn(params);
        if (missing.length) {
          throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
        }
        return path35;
      };
    }
    function tokensToFunction(tokens, delimiter, encode6) {
      const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode6));
      return (data) => {
        const result = [""];
        for (const encoder of encoders) {
          const [value, ...extras] = encoder(data);
          result[0] += value;
          result.push(...extras);
        }
        return result;
      };
    }
    function tokenToFunction(token, delimiter, encode6) {
      if (token.type === "text")
        return () => [token.value];
      if (token.type === "group") {
        const fn = tokensToFunction(token.tokens, delimiter, encode6);
        return (data) => {
          const [value, ...missing] = fn(data);
          if (!missing.length)
            return [value];
          return [""];
        };
      }
      const encodeValue = encode6 || NOOP_VALUE;
      if (token.type === "wildcard" && encode6 !== false) {
        return (data) => {
          const value = data[token.name];
          if (value == null)
            return ["", token.name];
          if (!Array.isArray(value) || value.length === 0) {
            throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
          }
          return [
            value.map((value2, index) => {
              if (typeof value2 !== "string") {
                throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
              }
              return encodeValue(value2);
            }).join(delimiter)
          ];
        };
      }
      return (data) => {
        const value = data[token.name];
        if (value == null)
          return ["", token.name];
        if (typeof value !== "string") {
          throw new TypeError(`Expected "${token.name}" to be a string`);
        }
        return [encodeValue(value)];
      };
    }
    function match(path33, options = {}) {
      const { decode: decode4 = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
      const { regexp, keys: keys2 } = pathToRegexp(path33, options);
      const decoders = keys2.map((key) => {
        if (decode4 === false)
          return NOOP_VALUE;
        if (key.type === "param")
          return decode4;
        return (value) => value.split(delimiter).map(decode4);
      });
      return function match2(input) {
        const m = regexp.exec(input);
        if (!m)
          return false;
        const path34 = m[0];
        const params = /* @__PURE__ */ Object.create(null);
        for (let i = 1; i < m.length; i++) {
          if (m[i] === void 0)
            continue;
          const key = keys2[i - 1];
          const decoder = decoders[i - 1];
          params[key.name] = decoder(m[i]);
        }
        return { path: path34, params };
      };
    }
    function pathToRegexp(path33, options = {}) {
      const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
      const keys2 = [];
      const sources = [];
      const paths = [path33];
      let combinations = 0;
      while (paths.length) {
        const path34 = paths.shift();
        if (Array.isArray(path34)) {
          paths.push(...path34);
          continue;
        }
        const data = typeof path34 === "object" ? path34 : parse4(path34, options);
        flatten(data.tokens, 0, [], (tokens) => {
          if (combinations++ >= 256) {
            throw new PathError("Too many path combinations", data.originalPath);
          }
          sources.push(toRegExpSource(tokens, delimiter, keys2, data.originalPath));
        });
      }
      let pattern = `^(?:${sources.join("|")})`;
      if (trailing)
        pattern += "(?:" + escape2(delimiter) + "$)?";
      pattern += end ? "$" : "(?=" + escape2(delimiter) + "|$)";
      return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys: keys2 };
    }
    function flatten(tokens, index, result, callback) {
      while (index < tokens.length) {
        const token = tokens[index++];
        if (token.type === "group") {
          flatten(token.tokens, 0, result.slice(), (seq) => flatten(tokens, index, seq, callback));
          continue;
        }
        result.push(token);
      }
      callback(result);
    }
    function toRegExpSource(tokens, delimiter, keys2, originalPath) {
      let result = "";
      let backtrack = "";
      let wildcardBacktrack = "";
      let prevCaptureType = 0;
      let hasSegmentCapture = 0;
      let index = 0;
      function hasInSegment(index2, type) {
        while (index2 < tokens.length) {
          const token = tokens[index2++];
          if (token.type === type)
            return true;
          if (token.type === "text") {
            if (token.value.includes(delimiter))
              break;
          }
        }
        return false;
      }
      function peekText(index2) {
        let result2 = "";
        while (index2 < tokens.length) {
          const token = tokens[index2++];
          if (token.type !== "text")
            break;
          result2 += token.value;
        }
        return result2;
      }
      while (index < tokens.length) {
        const token = tokens[index++];
        if (token.type === "text") {
          result += escape2(token.value);
          backtrack += token.value;
          if (prevCaptureType === 2)
            wildcardBacktrack += token.value;
          if (token.value.includes(delimiter))
            hasSegmentCapture = 0;
          continue;
        }
        if (token.type === "param" || token.type === "wildcard") {
          if (prevCaptureType && !backtrack) {
            throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
          }
          if (token.type === "param") {
            result += hasSegmentCapture & 2 ? `(${negate(delimiter, backtrack)}+)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+)` : hasSegmentCapture & 1 ? `(${negate(delimiter, backtrack)}+|${escape2(backtrack)})` : `(${negate(delimiter, "")}+)`;
            hasSegmentCapture |= prevCaptureType = 1;
          } else {
            result += hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)` : `([^]+)`;
            wildcardBacktrack = "";
            hasSegmentCapture |= prevCaptureType = 2;
          }
          keys2.push(token);
          backtrack = "";
          continue;
        }
        throw new TypeError(`Unknown token type: ${token.type}`);
      }
      return result;
    }
    function negate(a, b) {
      if (b.length > a.length)
        return negate(b, a);
      if (a === b)
        b = "";
      if (b.length > 1)
        return `(?:(?!${escape2(a)}|${escape2(b)})[^])`;
      if (a.length > 1)
        return `(?:(?!${escape2(a)})[^${escape2(b)}])`;
      return `[^${escape2(a + b)}]`;
    }
    function stringifyTokens(tokens, index) {
      let value = "";
      while (index < tokens.length) {
        const token = tokens[index++];
        if (token.type === "text") {
          value += escapeText(token.value);
          continue;
        }
        if (token.type === "group") {
          value += "{" + stringifyTokens(token.tokens, 0) + "}";
          continue;
        }
        if (token.type === "param") {
          value += ":" + stringifyName(token.name, tokens[index]);
          continue;
        }
        if (token.type === "wildcard") {
          value += "*" + stringifyName(token.name, tokens[index]);
          continue;
        }
        throw new TypeError(`Unknown token type: ${token.type}`);
      }
      return value;
    }
    function stringify2(data) {
      return stringifyTokens(data.tokens, 0);
    }
    function stringifyName(name28, next) {
      if (!ID.test(name28))
        return JSON.stringify(name28);
      if ((next === null || next === void 0 ? void 0 : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
        return JSON.stringify(name28);
      }
      return name28;
    }
  }
});

// node_modules/router/lib/layer.js
var require_layer = __commonJS({
  "node_modules/router/lib/layer.js"(exports2, module2) {
    "use strict";
    var isPromise = require_is_promise();
    var pathRegexp = require_dist();
    var debug = require_src()("router:layer");
    var deprecate = require_depd()("router");
    var TRAILING_SLASH_REGEXP = /\/+$/;
    var MATCHING_GROUP_REGEXP = /\((?:\?<(.*?)>)?(?!\?)/g;
    module2.exports = Layer;
    function Layer(path33, options, fn) {
      if (!(this instanceof Layer)) {
        return new Layer(path33, options, fn);
      }
      debug("new %o", path33);
      const opts = options || {};
      this.handle = fn;
      this.keys = [];
      this.name = fn.name || "<anonymous>";
      this.params = void 0;
      this.path = void 0;
      this.slash = path33 === "/" && opts.end === false;
      function matcher(_path) {
        if (_path instanceof RegExp) {
          const keys2 = [];
          let name28 = 0;
          let m;
          while (m = MATCHING_GROUP_REGEXP.exec(_path.source)) {
            keys2.push({
              name: m[1] || name28++,
              offset: m.index
            });
          }
          return function regexpMatcher(p3) {
            const match = _path.exec(p3);
            if (!match) {
              return false;
            }
            const params = {};
            for (let i = 1; i < match.length; i++) {
              const key = keys2[i - 1];
              const prop = key.name;
              const val = decodeParam(match[i]);
              if (val !== void 0) {
                params[prop] = val;
              }
            }
            return {
              params,
              path: match[0]
            };
          };
        }
        return pathRegexp.match(opts.strict ? _path : loosen(_path), {
          sensitive: opts.sensitive,
          end: opts.end,
          trailing: !opts.strict,
          decode: decodeParam
        });
      }
      this.matchers = Array.isArray(path33) ? path33.map(matcher) : [matcher(path33)];
    }
    Layer.prototype.handleError = function handleError(error73, req, res, next) {
      const fn = this.handle;
      if (fn.length !== 4) {
        return next(error73);
      }
      try {
        const ret = fn(error73, req, res, next);
        if (isPromise(ret)) {
          if (!(ret instanceof Promise)) {
            deprecate("handlers that are Promise-like are deprecated, use a native Promise instead");
          }
          ret.then(null, function(error74) {
            next(error74 || new Error("Rejected promise"));
          });
        }
      } catch (err) {
        next(err);
      }
    };
    Layer.prototype.handleRequest = function handleRequest(req, res, next) {
      const fn = this.handle;
      if (fn.length > 3) {
        return next();
      }
      try {
        const ret = fn(req, res, next);
        if (isPromise(ret)) {
          if (!(ret instanceof Promise)) {
            deprecate("handlers that are Promise-like are deprecated, use a native Promise instead");
          }
          ret.then(null, function(error73) {
            next(error73 || new Error("Rejected promise"));
          });
        }
      } catch (err) {
        next(err);
      }
    };
    Layer.prototype.match = function match(path33) {
      let match2;
      if (path33 != null) {
        if (this.slash) {
          this.params = {};
          this.path = "";
          return true;
        }
        let i = 0;
        while (!match2 && i < this.matchers.length) {
          match2 = this.matchers[i](path33);
          i++;
        }
      }
      if (!match2) {
        this.params = void 0;
        this.path = void 0;
        return false;
      }
      this.params = match2.params;
      this.path = match2.path;
      this.keys = Object.keys(match2.params);
      return true;
    };
    function decodeParam(val) {
      if (typeof val !== "string" || val.length === 0) {
        return val;
      }
      try {
        return decodeURIComponent(val);
      } catch (err) {
        if (err instanceof URIError) {
          err.message = "Failed to decode param '" + val + "'";
          err.status = 400;
        }
        throw err;
      }
    }
    function loosen(path33) {
      if (path33 instanceof RegExp || path33 === "/") {
        return path33;
      }
      return Array.isArray(path33) ? path33.map(function(p3) {
        return loosen(p3);
      }) : String(path33).replace(TRAILING_SLASH_REGEXP, "");
    }
  }
});

// node_modules/router/lib/route.js
var require_route = __commonJS({
  "node_modules/router/lib/route.js"(exports2, module2) {
    "use strict";
    var debug = require_src()("router:route");
    var Layer = require_layer();
    var { METHODS } = require("node:http");
    var slice = Array.prototype.slice;
    var flatten = Array.prototype.flat;
    var methods = METHODS.map((method) => method.toLowerCase());
    module2.exports = Route;
    function Route(path33) {
      debug("new %o", path33);
      this.path = path33;
      this.stack = [];
      this.methods = /* @__PURE__ */ Object.create(null);
    }
    Route.prototype._handlesMethod = function _handlesMethod(method) {
      if (this.methods._all) {
        return true;
      }
      let name28 = typeof method === "string" ? method.toLowerCase() : method;
      if (name28 === "head" && !this.methods.head) {
        name28 = "get";
      }
      return Boolean(this.methods[name28]);
    };
    Route.prototype._methods = function _methods() {
      const methods2 = Object.keys(this.methods);
      if (this.methods.get && !this.methods.head) {
        methods2.push("head");
      }
      for (let i = 0; i < methods2.length; i++) {
        methods2[i] = methods2[i].toUpperCase();
      }
      return methods2;
    };
    Route.prototype.dispatch = function dispatch(req, res, done) {
      let idx = 0;
      const stack = this.stack;
      let sync = 0;
      if (stack.length === 0) {
        return done();
      }
      let method = typeof req.method === "string" ? req.method.toLowerCase() : req.method;
      if (method === "head" && !this.methods.head) {
        method = "get";
      }
      req.route = this;
      next();
      function next(err) {
        if (err && err === "route") {
          return done();
        }
        if (err && err === "router") {
          return done(err);
        }
        if (idx >= stack.length) {
          return done(err);
        }
        if (++sync > 100) {
          return setImmediate(next, err);
        }
        let layer;
        let match;
        while (match !== true && idx < stack.length) {
          layer = stack[idx++];
          match = !layer.method || layer.method === method;
        }
        if (match !== true) {
          return done(err);
        }
        if (err) {
          layer.handleError(err, req, res, next);
        } else {
          layer.handleRequest(req, res, next);
        }
        sync = 0;
      }
    };
    Route.prototype.all = function all3(handler) {
      const callbacks = flatten.call(slice.call(arguments), Infinity);
      if (callbacks.length === 0) {
        throw new TypeError("argument handler is required");
      }
      for (let i = 0; i < callbacks.length; i++) {
        const fn = callbacks[i];
        if (typeof fn !== "function") {
          throw new TypeError("argument handler must be a function");
        }
        const layer = Layer("/", {}, fn);
        layer.method = void 0;
        this.methods._all = true;
        this.stack.push(layer);
      }
      return this;
    };
    methods.forEach(function(method) {
      Route.prototype[method] = function(handler) {
        const callbacks = flatten.call(slice.call(arguments), Infinity);
        if (callbacks.length === 0) {
          throw new TypeError("argument handler is required");
        }
        for (let i = 0; i < callbacks.length; i++) {
          const fn = callbacks[i];
          if (typeof fn !== "function") {
            throw new TypeError("argument handler must be a function");
          }
          debug("%s %s", method, this.path);
          const layer = Layer("/", {}, fn);
          layer.method = method;
          this.methods[method] = true;
          this.stack.push(layer);
        }
        return this;
      };
    });
  }
});

// node_modules/router/index.js
var require_router = __commonJS({
  "node_modules/router/index.js"(exports2, module2) {
    "use strict";
    var isPromise = require_is_promise();
    var Layer = require_layer();
    var { METHODS } = require("node:http");
    var parseUrl2 = require_parseurl();
    var Route = require_route();
    var debug = require_src()("router");
    var deprecate = require_depd()("router");
    var slice = Array.prototype.slice;
    var flatten = Array.prototype.flat;
    var methods = METHODS.map((method) => method.toLowerCase());
    module2.exports = Router;
    module2.exports.Route = Route;
    function Router(options) {
      if (!(this instanceof Router)) {
        return new Router(options);
      }
      const opts = options || {};
      function router173(req, res, next) {
        router173.handle(req, res, next);
      }
      Object.setPrototypeOf(router173, this);
      router173.caseSensitive = opts.caseSensitive;
      router173.mergeParams = opts.mergeParams;
      router173.params = {};
      router173.strict = opts.strict;
      router173.stack = [];
      return router173;
    }
    Router.prototype = function() {
    };
    Router.prototype.param = function param(name28, fn) {
      if (!name28) {
        throw new TypeError("argument name is required");
      }
      if (typeof name28 !== "string") {
        throw new TypeError("argument name must be a string");
      }
      if (!fn) {
        throw new TypeError("argument fn is required");
      }
      if (typeof fn !== "function") {
        throw new TypeError("argument fn must be a function");
      }
      let params = this.params[name28];
      if (!params) {
        params = this.params[name28] = [];
      }
      params.push(fn);
      return this;
    };
    Router.prototype.handle = function handle(req, res, callback) {
      if (!callback) {
        throw new TypeError("argument callback is required");
      }
      debug("dispatching %s %s", req.method, req.url);
      let idx = 0;
      let methods2;
      const protohost = getProtohost(req.url) || "";
      let removed = "";
      const self2 = this;
      let slashAdded = false;
      let sync = 0;
      const paramcalled = {};
      const stack = this.stack;
      const parentParams = req.params;
      const parentUrl = req.baseUrl || "";
      let done = restore(callback, req, "baseUrl", "next", "params");
      req.next = next;
      if (req.method === "OPTIONS") {
        methods2 = [];
        done = wrap(done, generateOptionsResponder(res, methods2));
      }
      req.baseUrl = parentUrl;
      req.originalUrl = req.originalUrl || req.url;
      next();
      function next(err) {
        let layerError = err === "route" ? null : err;
        if (slashAdded) {
          req.url = req.url.slice(1);
          slashAdded = false;
        }
        if (removed.length !== 0) {
          req.baseUrl = parentUrl;
          req.url = protohost + removed + req.url.slice(protohost.length);
          removed = "";
        }
        if (layerError === "router") {
          setImmediate(done, null);
          return;
        }
        if (idx >= stack.length) {
          setImmediate(done, layerError);
          return;
        }
        if (++sync > 100) {
          return setImmediate(next, err);
        }
        const path33 = getPathname(req);
        if (path33 == null) {
          return done(layerError);
        }
        let layer;
        let match;
        let route;
        while (match !== true && idx < stack.length) {
          layer = stack[idx++];
          match = matchLayer(layer, path33);
          route = layer.route;
          if (typeof match !== "boolean") {
            layerError = layerError || match;
          }
          if (match !== true) {
            continue;
          }
          if (!route) {
            continue;
          }
          if (layerError) {
            match = false;
            continue;
          }
          const method = req.method;
          const hasMethod = route._handlesMethod(method);
          if (!hasMethod && method === "OPTIONS" && methods2) {
            methods2.push.apply(methods2, route._methods());
          }
          if (!hasMethod && method !== "HEAD") {
            match = false;
          }
        }
        if (match !== true) {
          return done(layerError);
        }
        if (route) {
          req.route = route;
        }
        req.params = self2.mergeParams ? mergeParams(layer.params, parentParams) : layer.params;
        const layerPath = layer.path;
        processParams(self2.params, layer, paramcalled, req, res, function(err2) {
          if (err2) {
            next(layerError || err2);
          } else if (route) {
            layer.handleRequest(req, res, next);
          } else {
            trimPrefix(layer, layerError, layerPath, path33);
          }
          sync = 0;
        });
      }
      function trimPrefix(layer, layerError, layerPath, path33) {
        if (layerPath.length !== 0) {
          if (layerPath !== path33.substring(0, layerPath.length)) {
            next(layerError);
            return;
          }
          const c = path33[layerPath.length];
          if (c && c !== "/") {
            next(layerError);
            return;
          }
          debug("trim prefix (%s) from url %s", layerPath, req.url);
          removed = layerPath;
          req.url = protohost + req.url.slice(protohost.length + removed.length);
          if (!protohost && req.url[0] !== "/") {
            req.url = "/" + req.url;
            slashAdded = true;
          }
          req.baseUrl = parentUrl + (removed[removed.length - 1] === "/" ? removed.substring(0, removed.length - 1) : removed);
        }
        debug("%s %s : %s", layer.name, layerPath, req.originalUrl);
        if (layerError) {
          layer.handleError(layerError, req, res, next);
        } else {
          layer.handleRequest(req, res, next);
        }
      }
    };
    Router.prototype.use = function use(handler) {
      let offset = 0;
      let path33 = "/";
      if (typeof handler !== "function") {
        let arg = handler;
        while (Array.isArray(arg) && arg.length !== 0) {
          arg = arg[0];
        }
        if (typeof arg !== "function") {
          offset = 1;
          path33 = handler;
        }
      }
      const callbacks = flatten.call(slice.call(arguments, offset), Infinity);
      if (callbacks.length === 0) {
        throw new TypeError("argument handler is required");
      }
      for (let i = 0; i < callbacks.length; i++) {
        const fn = callbacks[i];
        if (typeof fn !== "function") {
          throw new TypeError("argument handler must be a function");
        }
        debug("use %o %s", path33, fn.name || "<anonymous>");
        const layer = new Layer(path33, {
          sensitive: this.caseSensitive,
          strict: false,
          end: false
        }, fn);
        layer.route = void 0;
        this.stack.push(layer);
      }
      return this;
    };
    Router.prototype.route = function route(path33) {
      const route2 = new Route(path33);
      const layer = new Layer(path33, {
        sensitive: this.caseSensitive,
        strict: this.strict,
        end: true
      }, handle);
      function handle(req, res, next) {
        route2.dispatch(req, res, next);
      }
      layer.route = route2;
      this.stack.push(layer);
      return route2;
    };
    methods.concat("all").forEach(function(method) {
      Router.prototype[method] = function(path33) {
        const route = this.route(path33);
        route[method].apply(route, slice.call(arguments, 1));
        return this;
      };
    });
    function generateOptionsResponder(res, methods2) {
      return function onDone(fn, err) {
        if (err || methods2.length === 0) {
          return fn(err);
        }
        trySendOptionsResponse(res, methods2, fn);
      };
    }
    function getPathname(req) {
      try {
        return parseUrl2(req).pathname;
      } catch (err) {
        return void 0;
      }
    }
    function getProtohost(url4) {
      if (typeof url4 !== "string" || url4.length === 0 || url4[0] === "/") {
        return void 0;
      }
      const searchIndex = url4.indexOf("?");
      const pathLength = searchIndex !== -1 ? searchIndex : url4.length;
      const fqdnIndex = url4.substring(0, pathLength).indexOf("://");
      return fqdnIndex !== -1 ? url4.substring(0, url4.indexOf("/", 3 + fqdnIndex)) : void 0;
    }
    function matchLayer(layer, path33) {
      try {
        return layer.match(path33);
      } catch (err) {
        return err;
      }
    }
    function mergeParams(params, parent) {
      if (typeof parent !== "object" || !parent) {
        return params;
      }
      const obj = Object.assign({}, parent);
      if (!(0 in params) || !(0 in parent)) {
        return Object.assign(obj, params);
      }
      let i = 0;
      let o = 0;
      while (i in params) {
        i++;
      }
      while (o in parent) {
        o++;
      }
      for (i--; i >= 0; i--) {
        params[i + o] = params[i];
        if (i < o) {
          delete params[i];
        }
      }
      return Object.assign(obj, params);
    }
    function processParams(params, layer, called, req, res, done) {
      const keys2 = layer.keys;
      if (!keys2 || keys2.length === 0) {
        return done();
      }
      let i = 0;
      let paramIndex = 0;
      let key;
      let paramVal;
      let paramCallbacks;
      let paramCalled;
      function param(err) {
        if (err) {
          return done(err);
        }
        if (i >= keys2.length) {
          return done();
        }
        paramIndex = 0;
        key = keys2[i++];
        paramVal = req.params[key];
        paramCallbacks = params[key];
        paramCalled = called[key];
        if (paramVal === void 0 || !paramCallbacks) {
          return param();
        }
        if (paramCalled && (paramCalled.match === paramVal || paramCalled.error && paramCalled.error !== "route")) {
          req.params[key] = paramCalled.value;
          return param(paramCalled.error);
        }
        called[key] = paramCalled = {
          error: null,
          match: paramVal,
          value: paramVal
        };
        paramCallback();
      }
      function paramCallback(err) {
        const fn = paramCallbacks[paramIndex++];
        paramCalled.value = req.params[key];
        if (err) {
          paramCalled.error = err;
          param(err);
          return;
        }
        if (!fn) return param();
        try {
          const ret = fn(req, res, paramCallback, paramVal, key);
          if (isPromise(ret)) {
            if (!(ret instanceof Promise)) {
              deprecate("parameters that are Promise-like are deprecated, use a native Promise instead");
            }
            ret.then(null, function(error73) {
              paramCallback(error73 || new Error("Rejected promise"));
            });
          }
        } catch (e) {
          paramCallback(e);
        }
      }
      param();
    }
    function restore(fn, obj) {
      const props = new Array(arguments.length - 2);
      const vals = new Array(arguments.length - 2);
      for (let i = 0; i < props.length; i++) {
        props[i] = arguments[i + 2];
        vals[i] = obj[props[i]];
      }
      return function() {
        for (let i = 0; i < props.length; i++) {
          obj[props[i]] = vals[i];
        }
        return fn.apply(this, arguments);
      };
    }
    function sendOptionsResponse(res, methods2) {
      const options = /* @__PURE__ */ Object.create(null);
      for (let i = 0; i < methods2.length; i++) {
        options[methods2[i]] = true;
      }
      const allow = Object.keys(options).sort().join(", ");
      res.setHeader("Allow", allow);
      res.setHeader("Content-Length", Buffer.byteLength(allow));
      res.setHeader("Content-Type", "text/plain");
      res.setHeader("X-Content-Type-Options", "nosniff");
      res.end(allow);
    }
    function trySendOptionsResponse(res, methods2, next) {
      try {
        sendOptionsResponse(res, methods2);
      } catch (err) {
        next(err);
      }
    }
    function wrap(old, fn) {
      return function proxy() {
        const args = new Array(arguments.length + 1);
        args[0] = old;
        for (let i = 0, len = arguments.length; i < len; i++) {
          args[i + 1] = arguments[i];
        }
        fn.apply(this, args);
      };
    }
  }
});

// node_modules/express/lib/application.js
var require_application = __commonJS({
  "node_modules/express/lib/application.js"(exports2, module2) {
    "use strict";
    var finalhandler = require_finalhandler();
    var debug = require_src()("express:application");
    var View = require_view();
    var http4 = require("node:http");
    var methods = require_utils3().methods;
    var compileETag = require_utils3().compileETag;
    var compileQueryParser = require_utils3().compileQueryParser;
    var compileTrust = require_utils3().compileTrust;
    var resolve3 = require("node:path").resolve;
    var once = require_once();
    var Router = require_router();
    var slice = Array.prototype.slice;
    var flatten = Array.prototype.flat;
    var app2 = exports2 = module2.exports = {};
    var trustProxyDefaultSymbol = "@@symbol:trust_proxy_default";
    app2.init = function init() {
      var router173 = null;
      this.cache = /* @__PURE__ */ Object.create(null);
      this.engines = /* @__PURE__ */ Object.create(null);
      this.settings = /* @__PURE__ */ Object.create(null);
      this.defaultConfiguration();
      Object.defineProperty(this, "router", {
        configurable: true,
        enumerable: true,
        get: function getrouter() {
          if (router173 === null) {
            router173 = new Router({
              caseSensitive: this.enabled("case sensitive routing"),
              strict: this.enabled("strict routing")
            });
          }
          return router173;
        }
      });
    };
    app2.defaultConfiguration = function defaultConfiguration() {
      var env2 = process.env.NODE_ENV || "development";
      this.enable("x-powered-by");
      this.set("etag", "weak");
      this.set("env", env2);
      this.set("query parser", "simple");
      this.set("subdomain offset", 2);
      this.set("trust proxy", false);
      Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
        configurable: true,
        value: true
      });
      debug("booting in %s mode", env2);
      this.on("mount", function onmount(parent) {
        if (this.settings[trustProxyDefaultSymbol] === true && typeof parent.settings["trust proxy fn"] === "function") {
          delete this.settings["trust proxy"];
          delete this.settings["trust proxy fn"];
        }
        Object.setPrototypeOf(this.request, parent.request);
        Object.setPrototypeOf(this.response, parent.response);
        Object.setPrototypeOf(this.engines, parent.engines);
        Object.setPrototypeOf(this.settings, parent.settings);
      });
      this.locals = /* @__PURE__ */ Object.create(null);
      this.mountpath = "/";
      this.locals.settings = this.settings;
      this.set("view", View);
      this.set("views", resolve3("views"));
      this.set("jsonp callback name", "callback");
      if (env2 === "production") {
        this.enable("view cache");
      }
    };
    app2.handle = function handle(req, res, callback) {
      var done = callback || finalhandler(req, res, {
        env: this.get("env"),
        onerror: logerror.bind(this)
      });
      if (this.enabled("x-powered-by")) {
        res.setHeader("X-Powered-By", "Express");
      }
      req.res = res;
      res.req = req;
      Object.setPrototypeOf(req, this.request);
      Object.setPrototypeOf(res, this.response);
      if (!res.locals) {
        res.locals = /* @__PURE__ */ Object.create(null);
      }
      this.router.handle(req, res, done);
    };
    app2.use = function use(fn) {
      var offset = 0;
      var path33 = "/";
      if (typeof fn !== "function") {
        var arg = fn;
        while (Array.isArray(arg) && arg.length !== 0) {
          arg = arg[0];
        }
        if (typeof arg !== "function") {
          offset = 1;
          path33 = fn;
        }
      }
      var fns = flatten.call(slice.call(arguments, offset), Infinity);
      if (fns.length === 0) {
        throw new TypeError("app.use() requires a middleware function");
      }
      var router173 = this.router;
      fns.forEach(function(fn2) {
        if (!fn2 || !fn2.handle || !fn2.set) {
          return router173.use(path33, fn2);
        }
        debug(".use app under %s", path33);
        fn2.mountpath = path33;
        fn2.parent = this;
        router173.use(path33, function mounted_app(req, res, next) {
          var orig = req.app;
          fn2.handle(req, res, function(err) {
            Object.setPrototypeOf(req, orig.request);
            Object.setPrototypeOf(res, orig.response);
            next(err);
          });
        });
        fn2.emit("mount", this);
      }, this);
      return this;
    };
    app2.route = function route(path33) {
      return this.router.route(path33);
    };
    app2.engine = function engine(ext, fn) {
      if (typeof fn !== "function") {
        throw new Error("callback function required");
      }
      var extension = ext[0] !== "." ? "." + ext : ext;
      this.engines[extension] = fn;
      return this;
    };
    app2.param = function param(name28, fn) {
      if (Array.isArray(name28)) {
        for (var i = 0; i < name28.length; i++) {
          this.param(name28[i], fn);
        }
        return this;
      }
      this.router.param(name28, fn);
      return this;
    };
    app2.set = function set3(setting, val) {
      if (arguments.length === 1) {
        return this.settings[setting];
      }
      debug('set "%s" to %o', setting, val);
      this.settings[setting] = val;
      switch (setting) {
        case "etag":
          this.set("etag fn", compileETag(val));
          break;
        case "query parser":
          this.set("query parser fn", compileQueryParser(val));
          break;
        case "trust proxy":
          this.set("trust proxy fn", compileTrust(val));
          Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
            configurable: true,
            value: false
          });
          break;
      }
      return this;
    };
    app2.path = function path33() {
      return this.parent ? this.parent.path() + this.mountpath : "";
    };
    app2.enabled = function enabled(setting) {
      return Boolean(this.set(setting));
    };
    app2.disabled = function disabled(setting) {
      return !this.set(setting);
    };
    app2.enable = function enable(setting) {
      return this.set(setting, true);
    };
    app2.disable = function disable(setting) {
      return this.set(setting, false);
    };
    methods.forEach(function(method) {
      app2[method] = function(path33) {
        if (method === "get" && arguments.length === 1) {
          return this.set(path33);
        }
        var route = this.route(path33);
        route[method].apply(route, slice.call(arguments, 1));
        return this;
      };
    });
    app2.all = function all3(path33) {
      var route = this.route(path33);
      var args = slice.call(arguments, 1);
      for (var i = 0; i < methods.length; i++) {
        route[methods[i]].apply(route, args);
      }
      return this;
    };
    app2.render = function render(name28, options, callback) {
      var cache = this.cache;
      var done = callback;
      var engines = this.engines;
      var opts = options;
      var view;
      if (typeof options === "function") {
        done = options;
        opts = {};
      }
      var renderOptions = { ...this.locals, ...opts._locals, ...opts };
      if (renderOptions.cache == null) {
        renderOptions.cache = this.enabled("view cache");
      }
      if (renderOptions.cache) {
        view = cache[name28];
      }
      if (!view) {
        var View2 = this.get("view");
        view = new View2(name28, {
          defaultEngine: this.get("view engine"),
          root: this.get("views"),
          engines
        });
        if (!view.path) {
          var dirs = Array.isArray(view.root) && view.root.length > 1 ? 'directories "' + view.root.slice(0, -1).join('", "') + '" or "' + view.root[view.root.length - 1] + '"' : 'directory "' + view.root + '"';
          var err = new Error('Failed to lookup view "' + name28 + '" in views ' + dirs);
          err.view = view;
          return done(err);
        }
        if (renderOptions.cache) {
          cache[name28] = view;
        }
      }
      tryRender(view, renderOptions, done);
    };
    app2.listen = function listen() {
      var server2 = http4.createServer(this);
      var args = slice.call(arguments);
      if (typeof args[args.length - 1] === "function") {
        var done = args[args.length - 1] = once(args[args.length - 1]);
        server2.once("error", done);
      }
      return server2.listen.apply(server2, args);
    };
    function logerror(err) {
      if (this.get("env") !== "test") console.error(err.stack || err.toString());
    }
    function tryRender(view, options, callback) {
      try {
        view.render(options, callback);
      } catch (err) {
        callback(err);
      }
    }
  }
});

// node_modules/negotiator/lib/charset.js
var require_charset = __commonJS({
  "node_modules/negotiator/lib/charset.js"(exports2, module2) {
    "use strict";
    module2.exports = preferredCharsets;
    module2.exports.preferredCharsets = preferredCharsets;
    var simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
    function parseAcceptCharset(accept) {
      var accepts = accept.split(",");
      for (var i = 0, j = 0; i < accepts.length; i++) {
        var charset = parseCharset(accepts[i].trim(), i);
        if (charset) {
          accepts[j++] = charset;
        }
      }
      accepts.length = j;
      return accepts;
    }
    function parseCharset(str, i) {
      var match = simpleCharsetRegExp.exec(str);
      if (!match) return null;
      var charset = match[1];
      var q = 1;
      if (match[2]) {
        var params = match[2].split(";");
        for (var j = 0; j < params.length; j++) {
          var p3 = params[j].trim().split("=");
          if (p3[0] === "q") {
            q = parseFloat(p3[1]);
            break;
          }
        }
      }
      return {
        charset,
        q,
        i
      };
    }
    function getCharsetPriority(charset, accepted, index) {
      var priority = { o: -1, q: 0, s: 0 };
      for (var i = 0; i < accepted.length; i++) {
        var spec = specify(charset, accepted[i], index);
        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
          priority = spec;
        }
      }
      return priority;
    }
    function specify(charset, spec, index) {
      var s = 0;
      if (spec.charset.toLowerCase() === charset.toLowerCase()) {
        s |= 1;
      } else if (spec.charset !== "*") {
        return null;
      }
      return {
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    function preferredCharsets(accept, provided) {
      var accepts = parseAcceptCharset(accept === void 0 ? "*" : accept || "");
      if (!provided) {
        return accepts.filter(isQuality).sort(compareSpecs).map(getFullCharset);
      }
      var priorities = provided.map(function getPriority(type, index) {
        return getCharsetPriority(type, accepts, index);
      });
      return priorities.filter(isQuality).sort(compareSpecs).map(function getCharset(priority) {
        return provided[priorities.indexOf(priority)];
      });
    }
    function compareSpecs(a, b) {
      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
    }
    function getFullCharset(spec) {
      return spec.charset;
    }
    function isQuality(spec) {
      return spec.q > 0;
    }
  }
});

// node_modules/negotiator/lib/encoding.js
var require_encoding = __commonJS({
  "node_modules/negotiator/lib/encoding.js"(exports2, module2) {
    "use strict";
    module2.exports = preferredEncodings;
    module2.exports.preferredEncodings = preferredEncodings;
    var simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
    function parseAcceptEncoding(accept) {
      var accepts = accept.split(",");
      var hasIdentity = false;
      var minQuality = 1;
      for (var i = 0, j = 0; i < accepts.length; i++) {
        var encoding = parseEncoding(accepts[i].trim(), i);
        if (encoding) {
          accepts[j++] = encoding;
          hasIdentity = hasIdentity || specify("identity", encoding);
          minQuality = Math.min(minQuality, encoding.q || 1);
        }
      }
      if (!hasIdentity) {
        accepts[j++] = {
          encoding: "identity",
          q: minQuality,
          i
        };
      }
      accepts.length = j;
      return accepts;
    }
    function parseEncoding(str, i) {
      var match = simpleEncodingRegExp.exec(str);
      if (!match) return null;
      var encoding = match[1];
      var q = 1;
      if (match[2]) {
        var params = match[2].split(";");
        for (var j = 0; j < params.length; j++) {
          var p3 = params[j].trim().split("=");
          if (p3[0] === "q") {
            q = parseFloat(p3[1]);
            break;
          }
        }
      }
      return {
        encoding,
        q,
        i
      };
    }
    function getEncodingPriority(encoding, accepted, index) {
      var priority = { encoding, o: -1, q: 0, s: 0 };
      for (var i = 0; i < accepted.length; i++) {
        var spec = specify(encoding, accepted[i], index);
        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
          priority = spec;
        }
      }
      return priority;
    }
    function specify(encoding, spec, index) {
      var s = 0;
      if (spec.encoding.toLowerCase() === encoding.toLowerCase()) {
        s |= 1;
      } else if (spec.encoding !== "*") {
        return null;
      }
      return {
        encoding,
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    function preferredEncodings(accept, provided, preferred) {
      var accepts = parseAcceptEncoding(accept || "");
      var comparator = preferred ? function comparator2(a, b) {
        if (a.q !== b.q) {
          return b.q - a.q;
        }
        var aPreferred = preferred.indexOf(a.encoding);
        var bPreferred = preferred.indexOf(b.encoding);
        if (aPreferred === -1 && bPreferred === -1) {
          return b.s - a.s || a.o - b.o || a.i - b.i;
        }
        if (aPreferred !== -1 && bPreferred !== -1) {
          return aPreferred - bPreferred;
        }
        return aPreferred === -1 ? 1 : -1;
      } : compareSpecs;
      if (!provided) {
        return accepts.filter(isQuality).sort(comparator).map(getFullEncoding);
      }
      var priorities = provided.map(function getPriority(type, index) {
        return getEncodingPriority(type, accepts, index);
      });
      return priorities.filter(isQuality).sort(comparator).map(function getEncoding(priority) {
        return provided[priorities.indexOf(priority)];
      });
    }
    function compareSpecs(a, b) {
      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i;
    }
    function getFullEncoding(spec) {
      return spec.encoding;
    }
    function isQuality(spec) {
      return spec.q > 0;
    }
  }
});

// node_modules/negotiator/lib/language.js
var require_language = __commonJS({
  "node_modules/negotiator/lib/language.js"(exports2, module2) {
    "use strict";
    module2.exports = preferredLanguages;
    module2.exports.preferredLanguages = preferredLanguages;
    var simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
    function parseAcceptLanguage(accept) {
      var accepts = accept.split(",");
      for (var i = 0, j = 0; i < accepts.length; i++) {
        var language = parseLanguage(accepts[i].trim(), i);
        if (language) {
          accepts[j++] = language;
        }
      }
      accepts.length = j;
      return accepts;
    }
    function parseLanguage(str, i) {
      var match = simpleLanguageRegExp.exec(str);
      if (!match) return null;
      var prefix = match[1];
      var suffix = match[2];
      var full = prefix;
      if (suffix) full += "-" + suffix;
      var q = 1;
      if (match[3]) {
        var params = match[3].split(";");
        for (var j = 0; j < params.length; j++) {
          var p3 = params[j].split("=");
          if (p3[0] === "q") q = parseFloat(p3[1]);
        }
      }
      return {
        prefix,
        suffix,
        q,
        i,
        full
      };
    }
    function getLanguagePriority(language, accepted, index) {
      var priority = { o: -1, q: 0, s: 0 };
      for (var i = 0; i < accepted.length; i++) {
        var spec = specify(language, accepted[i], index);
        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
          priority = spec;
        }
      }
      return priority;
    }
    function specify(language, spec, index) {
      var p3 = parseLanguage(language);
      if (!p3) return null;
      var s = 0;
      if (spec.full.toLowerCase() === p3.full.toLowerCase()) {
        s |= 4;
      } else if (spec.prefix.toLowerCase() === p3.full.toLowerCase()) {
        s |= 2;
      } else if (spec.full.toLowerCase() === p3.prefix.toLowerCase()) {
        s |= 1;
      } else if (spec.full !== "*") {
        return null;
      }
      return {
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    function preferredLanguages(accept, provided) {
      var accepts = parseAcceptLanguage(accept === void 0 ? "*" : accept || "");
      if (!provided) {
        return accepts.filter(isQuality).sort(compareSpecs).map(getFullLanguage);
      }
      var priorities = provided.map(function getPriority(type, index) {
        return getLanguagePriority(type, accepts, index);
      });
      return priorities.filter(isQuality).sort(compareSpecs).map(function getLanguage(priority) {
        return provided[priorities.indexOf(priority)];
      });
    }
    function compareSpecs(a, b) {
      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
    }
    function getFullLanguage(spec) {
      return spec.full;
    }
    function isQuality(spec) {
      return spec.q > 0;
    }
  }
});

// node_modules/negotiator/lib/mediaType.js
var require_mediaType = __commonJS({
  "node_modules/negotiator/lib/mediaType.js"(exports2, module2) {
    "use strict";
    module2.exports = preferredMediaTypes;
    module2.exports.preferredMediaTypes = preferredMediaTypes;
    var simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
    function parseAccept(accept) {
      var accepts = splitMediaTypes(accept);
      for (var i = 0, j = 0; i < accepts.length; i++) {
        var mediaType = parseMediaType(accepts[i].trim(), i);
        if (mediaType) {
          accepts[j++] = mediaType;
        }
      }
      accepts.length = j;
      return accepts;
    }
    function parseMediaType(str, i) {
      var match = simpleMediaTypeRegExp.exec(str);
      if (!match) return null;
      var params = /* @__PURE__ */ Object.create(null);
      var q = 1;
      var subtype = match[2];
      var type = match[1];
      if (match[3]) {
        var kvps = splitParameters(match[3]).map(splitKeyValuePair);
        for (var j = 0; j < kvps.length; j++) {
          var pair = kvps[j];
          var key = pair[0].toLowerCase();
          var val = pair[1];
          var value = val && val[0] === '"' && val[val.length - 1] === '"' ? val.slice(1, -1) : val;
          if (key === "q") {
            q = parseFloat(value);
            break;
          }
          params[key] = value;
        }
      }
      return {
        type,
        subtype,
        params,
        q,
        i
      };
    }
    function getMediaTypePriority(type, accepted, index) {
      var priority = { o: -1, q: 0, s: 0 };
      for (var i = 0; i < accepted.length; i++) {
        var spec = specify(type, accepted[i], index);
        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
          priority = spec;
        }
      }
      return priority;
    }
    function specify(type, spec, index) {
      var p3 = parseMediaType(type);
      var s = 0;
      if (!p3) {
        return null;
      }
      if (spec.type.toLowerCase() == p3.type.toLowerCase()) {
        s |= 4;
      } else if (spec.type != "*") {
        return null;
      }
      if (spec.subtype.toLowerCase() == p3.subtype.toLowerCase()) {
        s |= 2;
      } else if (spec.subtype != "*") {
        return null;
      }
      var keys2 = Object.keys(spec.params);
      if (keys2.length > 0) {
        if (keys2.every(function(k) {
          return spec.params[k] == "*" || (spec.params[k] || "").toLowerCase() == (p3.params[k] || "").toLowerCase();
        })) {
          s |= 1;
        } else {
          return null;
        }
      }
      return {
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    function preferredMediaTypes(accept, provided) {
      var accepts = parseAccept(accept === void 0 ? "*/*" : accept || "");
      if (!provided) {
        return accepts.filter(isQuality).sort(compareSpecs).map(getFullType);
      }
      var priorities = provided.map(function getPriority(type, index) {
        return getMediaTypePriority(type, accepts, index);
      });
      return priorities.filter(isQuality).sort(compareSpecs).map(function getType(priority) {
        return provided[priorities.indexOf(priority)];
      });
    }
    function compareSpecs(a, b) {
      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
    }
    function getFullType(spec) {
      return spec.type + "/" + spec.subtype;
    }
    function isQuality(spec) {
      return spec.q > 0;
    }
    function quoteCount(string5) {
      var count = 0;
      var index = 0;
      while ((index = string5.indexOf('"', index)) !== -1) {
        count++;
        index++;
      }
      return count;
    }
    function splitKeyValuePair(str) {
      var index = str.indexOf("=");
      var key;
      var val;
      if (index === -1) {
        key = str;
      } else {
        key = str.slice(0, index);
        val = str.slice(index + 1);
      }
      return [key, val];
    }
    function splitMediaTypes(accept) {
      var accepts = accept.split(",");
      for (var i = 1, j = 0; i < accepts.length; i++) {
        if (quoteCount(accepts[j]) % 2 == 0) {
          accepts[++j] = accepts[i];
        } else {
          accepts[j] += "," + accepts[i];
        }
      }
      accepts.length = j + 1;
      return accepts;
    }
    function splitParameters(str) {
      var parameters = str.split(";");
      for (var i = 1, j = 0; i < parameters.length; i++) {
        if (quoteCount(parameters[j]) % 2 == 0) {
          parameters[++j] = parameters[i];
        } else {
          parameters[j] += ";" + parameters[i];
        }
      }
      parameters.length = j + 1;
      for (var i = 0; i < parameters.length; i++) {
        parameters[i] = parameters[i].trim();
      }
      return parameters;
    }
  }
});

// node_modules/negotiator/index.js
var require_negotiator = __commonJS({
  "node_modules/negotiator/index.js"(exports2, module2) {
    "use strict";
    var preferredCharsets = require_charset();
    var preferredEncodings = require_encoding();
    var preferredLanguages = require_language();
    var preferredMediaTypes = require_mediaType();
    module2.exports = Negotiator;
    module2.exports.Negotiator = Negotiator;
    function Negotiator(request) {
      if (!(this instanceof Negotiator)) {
        return new Negotiator(request);
      }
      this.request = request;
    }
    Negotiator.prototype.charset = function charset(available) {
      var set3 = this.charsets(available);
      return set3 && set3[0];
    };
    Negotiator.prototype.charsets = function charsets(available) {
      return preferredCharsets(this.request.headers["accept-charset"], available);
    };
    Negotiator.prototype.encoding = function encoding(available, opts) {
      var set3 = this.encodings(available, opts);
      return set3 && set3[0];
    };
    Negotiator.prototype.encodings = function encodings(available, options) {
      var opts = options || {};
      return preferredEncodings(this.request.headers["accept-encoding"], available, opts.preferred);
    };
    Negotiator.prototype.language = function language(available) {
      var set3 = this.languages(available);
      return set3 && set3[0];
    };
    Negotiator.prototype.languages = function languages(available) {
      return preferredLanguages(this.request.headers["accept-language"], available);
    };
    Negotiator.prototype.mediaType = function mediaType(available) {
      var set3 = this.mediaTypes(available);
      return set3 && set3[0];
    };
    Negotiator.prototype.mediaTypes = function mediaTypes(available) {
      return preferredMediaTypes(this.request.headers.accept, available);
    };
    Negotiator.prototype.preferredCharset = Negotiator.prototype.charset;
    Negotiator.prototype.preferredCharsets = Negotiator.prototype.charsets;
    Negotiator.prototype.preferredEncoding = Negotiator.prototype.encoding;
    Negotiator.prototype.preferredEncodings = Negotiator.prototype.encodings;
    Negotiator.prototype.preferredLanguage = Negotiator.prototype.language;
    Negotiator.prototype.preferredLanguages = Negotiator.prototype.languages;
    Negotiator.prototype.preferredMediaType = Negotiator.prototype.mediaType;
    Negotiator.prototype.preferredMediaTypes = Negotiator.prototype.mediaTypes;
  }
});

// node_modules/express/node_modules/accepts/index.js
var require_accepts = __commonJS({
  "node_modules/express/node_modules/accepts/index.js"(exports2, module2) {
    "use strict";
    var Negotiator = require_negotiator();
    var mime = require_mime_types();
    module2.exports = Accepts;
    function Accepts(req) {
      if (!(this instanceof Accepts)) {
        return new Accepts(req);
      }
      this.headers = req.headers;
      this.negotiator = new Negotiator(req);
    }
    Accepts.prototype.type = Accepts.prototype.types = function(types_) {
      var types = types_;
      if (types && !Array.isArray(types)) {
        types = new Array(arguments.length);
        for (var i = 0; i < types.length; i++) {
          types[i] = arguments[i];
        }
      }
      if (!types || types.length === 0) {
        return this.negotiator.mediaTypes();
      }
      if (!this.headers.accept) {
        return types[0];
      }
      var mimes = types.map(extToMime);
      var accepts = this.negotiator.mediaTypes(mimes.filter(validMime));
      var first = accepts[0];
      return first ? types[mimes.indexOf(first)] : false;
    };
    Accepts.prototype.encoding = Accepts.prototype.encodings = function(encodings_) {
      var encodings = encodings_;
      if (encodings && !Array.isArray(encodings)) {
        encodings = new Array(arguments.length);
        for (var i = 0; i < encodings.length; i++) {
          encodings[i] = arguments[i];
        }
      }
      if (!encodings || encodings.length === 0) {
        return this.negotiator.encodings();
      }
      return this.negotiator.encodings(encodings)[0] || false;
    };
    Accepts.prototype.charset = Accepts.prototype.charsets = function(charsets_) {
      var charsets = charsets_;
      if (charsets && !Array.isArray(charsets)) {
        charsets = new Array(arguments.length);
        for (var i = 0; i < charsets.length; i++) {
          charsets[i] = arguments[i];
        }
      }
      if (!charsets || charsets.length === 0) {
        return this.negotiator.charsets();
      }
      return this.negotiator.charsets(charsets)[0] || false;
    };
    Accepts.prototype.lang = Accepts.prototype.langs = Accepts.prototype.language = Accepts.prototype.languages = function(languages_) {
      var languages = languages_;
      if (languages && !Array.isArray(languages)) {
        languages = new Array(arguments.length);
        for (var i = 0; i < languages.length; i++) {
          languages[i] = arguments[i];
        }
      }
      if (!languages || languages.length === 0) {
        return this.negotiator.languages();
      }
      return this.negotiator.languages(languages)[0] || false;
    };
    function extToMime(type) {
      return type.indexOf("/") === -1 ? mime.lookup(type) : type;
    }
    function validMime(type) {
      return typeof type === "string";
    }
  }
});

// node_modules/fresh/index.js
var require_fresh = __commonJS({
  "node_modules/fresh/index.js"(exports2, module2) {
    "use strict";
    var CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/;
    module2.exports = fresh;
    function fresh(reqHeaders, resHeaders) {
      var modifiedSince = reqHeaders["if-modified-since"];
      var noneMatch = reqHeaders["if-none-match"];
      if (!modifiedSince && !noneMatch) {
        return false;
      }
      var cacheControl = reqHeaders["cache-control"];
      if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) {
        return false;
      }
      if (noneMatch) {
        if (noneMatch === "*") {
          return true;
        }
        var etag = resHeaders.etag;
        if (!etag) {
          return false;
        }
        var matches = parseTokenList(noneMatch);
        for (var i = 0; i < matches.length; i++) {
          var match = matches[i];
          if (match === etag || match === "W/" + etag || "W/" + match === etag) {
            return true;
          }
        }
        return false;
      }
      if (modifiedSince) {
        var lastModified = resHeaders["last-modified"];
        var modifiedStale = !lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince));
        if (modifiedStale) {
          return false;
        }
      }
      return true;
    }
    function parseHttpDate(date6) {
      var timestamp = date6 && Date.parse(date6);
      return typeof timestamp === "number" ? timestamp : NaN;
    }
    function parseTokenList(str) {
      var end = 0;
      var list2 = [];
      var start = 0;
      for (var i = 0, len = str.length; i < len; i++) {
        switch (str.charCodeAt(i)) {
          case 32:
            if (start === end) {
              start = end = i + 1;
            }
            break;
          case 44:
            list2.push(str.substring(start, end));
            start = end = i + 1;
            break;
          default:
            end = i + 1;
            break;
        }
      }
      list2.push(str.substring(start, end));
      return list2;
    }
  }
});

// node_modules/range-parser/index.js
var require_range_parser = __commonJS({
  "node_modules/range-parser/index.js"(exports2, module2) {
    "use strict";
    module2.exports = rangeParser;
    function rangeParser(size, str, options) {
      if (typeof str !== "string") {
        throw new TypeError("argument str must be a string");
      }
      var index = str.indexOf("=");
      if (index === -1) {
        return -2;
      }
      var arr = str.slice(index + 1).split(",");
      var ranges = [];
      ranges.type = str.slice(0, index);
      for (var i = 0; i < arr.length; i++) {
        var range = arr[i].split("-");
        var start = parseInt(range[0], 10);
        var end = parseInt(range[1], 10);
        if (isNaN(start)) {
          start = size - end;
          end = size - 1;
        } else if (isNaN(end)) {
          end = size - 1;
        }
        if (end > size - 1) {
          end = size - 1;
        }
        if (isNaN(start) || isNaN(end) || start > end || start < 0) {
          continue;
        }
        ranges.push({
          start,
          end
        });
      }
      if (ranges.length < 1) {
        return -1;
      }
      return options && options.combine ? combineRanges(ranges) : ranges;
    }
    function combineRanges(ranges) {
      var ordered = ranges.map(mapWithIndex).sort(sortByRangeStart);
      for (var j = 0, i = 1; i < ordered.length; i++) {
        var range = ordered[i];
        var current = ordered[j];
        if (range.start > current.end + 1) {
          ordered[++j] = range;
        } else if (range.end > current.end) {
          current.end = range.end;
          current.index = Math.min(current.index, range.index);
        }
      }
      ordered.length = j + 1;
      var combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex);
      combined.type = ranges.type;
      return combined;
    }
    function mapWithIndex(range, index) {
      return {
        start: range.start,
        end: range.end,
        index
      };
    }
    function mapWithoutIndex(range) {
      return {
        start: range.start,
        end: range.end
      };
    }
    function sortByRangeIndex(a, b) {
      return a.index - b.index;
    }
    function sortByRangeStart(a, b) {
      return a.start - b.start;
    }
  }
});

// node_modules/express/lib/request.js
var require_request = __commonJS({
  "node_modules/express/lib/request.js"(exports2, module2) {
    "use strict";
    var accepts = require_accepts();
    var isIP = require("node:net").isIP;
    var typeis = require_type_is();
    var http4 = require("node:http");
    var fresh = require_fresh();
    var parseRange = require_range_parser();
    var parse4 = require_parseurl();
    var proxyaddr = require_proxy_addr();
    var req = Object.create(http4.IncomingMessage.prototype);
    module2.exports = req;
    req.get = req.header = function header(name28) {
      if (!name28) {
        throw new TypeError("name argument is required to req.get");
      }
      if (typeof name28 !== "string") {
        throw new TypeError("name must be a string to req.get");
      }
      var lc = name28.toLowerCase();
      switch (lc) {
        case "referer":
        case "referrer":
          return this.headers.referrer || this.headers.referer;
        default:
          return this.headers[lc];
      }
    };
    req.accepts = function() {
      var accept = accepts(this);
      return accept.types.apply(accept, arguments);
    };
    req.acceptsEncodings = function() {
      var accept = accepts(this);
      return accept.encodings.apply(accept, arguments);
    };
    req.acceptsCharsets = function() {
      var accept = accepts(this);
      return accept.charsets.apply(accept, arguments);
    };
    req.acceptsLanguages = function(...languages) {
      return accepts(this).languages(...languages);
    };
    req.range = function range(size, options) {
      var range2 = this.get("Range");
      if (!range2) return;
      return parseRange(size, range2, options);
    };
    defineGetter(req, "query", function query() {
      var queryparse = this.app.get("query parser fn");
      if (!queryparse) {
        return /* @__PURE__ */ Object.create(null);
      }
      var querystring = parse4(this).query;
      return queryparse(querystring);
    });
    req.is = function is(types) {
      var arr = types;
      if (!Array.isArray(types)) {
        arr = new Array(arguments.length);
        for (var i = 0; i < arr.length; i++) {
          arr[i] = arguments[i];
        }
      }
      return typeis(this, arr);
    };
    defineGetter(req, "protocol", function protocol() {
      var proto = this.socket.encrypted ? "https" : "http";
      var trust = this.app.get("trust proxy fn");
      if (!trust(this.socket.remoteAddress, 0)) {
        return proto;
      }
      var header = this.get("X-Forwarded-Proto") || proto;
      var index = header.indexOf(",");
      return index !== -1 ? header.substring(0, index).trim() : header.trim();
    });
    defineGetter(req, "secure", function secure() {
      return this.protocol === "https";
    });
    defineGetter(req, "ip", function ip() {
      var trust = this.app.get("trust proxy fn");
      return proxyaddr(this, trust);
    });
    defineGetter(req, "ips", function ips() {
      var trust = this.app.get("trust proxy fn");
      var addrs = proxyaddr.all(this, trust);
      addrs.reverse().pop();
      return addrs;
    });
    defineGetter(req, "subdomains", function subdomains() {
      var hostname4 = this.hostname;
      if (!hostname4) return [];
      var offset = this.app.get("subdomain offset");
      var subdomains2 = !isIP(hostname4) ? hostname4.split(".").reverse() : [hostname4];
      return subdomains2.slice(offset);
    });
    defineGetter(req, "path", function path33() {
      return parse4(this).pathname;
    });
    defineGetter(req, "host", function host() {
      var trust = this.app.get("trust proxy fn");
      var val = this.get("X-Forwarded-Host");
      if (!val || !trust(this.socket.remoteAddress, 0)) {
        val = this.get("Host");
      } else if (val.indexOf(",") !== -1) {
        val = val.substring(0, val.indexOf(",")).trimRight();
      }
      return val || void 0;
    });
    defineGetter(req, "hostname", function hostname4() {
      var host = this.host;
      if (!host) return;
      var offset = host[0] === "[" ? host.indexOf("]") + 1 : 0;
      var index = host.indexOf(":", offset);
      return index !== -1 ? host.substring(0, index) : host;
    });
    defineGetter(req, "fresh", function() {
      var method = this.method;
      var res = this.res;
      var status = res.statusCode;
      if ("GET" !== method && "HEAD" !== method) return false;
      if (status >= 200 && status < 300 || 304 === status) {
        return fresh(this.headers, {
          "etag": res.get("ETag"),
          "last-modified": res.get("Last-Modified")
        });
      }
      return false;
    });
    defineGetter(req, "stale", function stale() {
      return !this.fresh;
    });
    defineGetter(req, "xhr", function xhr() {
      var val = this.get("X-Requested-With") || "";
      return val.toLowerCase() === "xmlhttprequest";
    });
    function defineGetter(obj, name28, getter) {
      Object.defineProperty(obj, name28, {
        configurable: true,
        enumerable: true,
        get: getter
      });
    }
  }
});

// node_modules/content-disposition/index.js
var require_content_disposition = __commonJS({
  "node_modules/content-disposition/index.js"(exports2, module2) {
    "use strict";
    module2.exports = contentDisposition;
    module2.exports.parse = parse4;
    var basename = require("path").basename;
    var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g;
    var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;
    var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g;
    var NON_LATIN1_REGEXP = /[^\x20-\x7e\xa0-\xff]/g;
    var QESC_REGEXP = /\\([\u0000-\u007f])/g;
    var QUOTE_REGEXP = /([\\"])/g;
    var PARAM_REGEXP = /;[\x09\x20]*([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*=[\x09\x20]*("(?:[\x20!\x23-\x5b\x5d-\x7e\x80-\xff]|\\[\x20-\x7e])*"|[!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*/g;
    var TEXT_REGEXP = /^[\x20-\x7e\x80-\xff]+$/;
    var TOKEN_REGEXP = /^[!#$%&'*+.0-9A-Z^_`a-z|~-]+$/;
    var EXT_VALUE_REGEXP = /^([A-Za-z0-9!#$%&+\-^_`{}~]+)'(?:[A-Za-z]{2,3}(?:-[A-Za-z]{3}){0,3}|[A-Za-z]{4,8}|)'((?:%[0-9A-Fa-f]{2}|[A-Za-z0-9!#$&+.^_`|~-])+)$/;
    var DISPOSITION_TYPE_REGEXP = /^([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*(?:$|;)/;
    function contentDisposition(filename, options) {
      var opts = options || {};
      var type = opts.type || "attachment";
      var params = createparams(filename, opts.fallback);
      return format(new ContentDisposition(type, params));
    }
    function createparams(filename, fallback) {
      if (filename === void 0) {
        return;
      }
      var params = {};
      if (typeof filename !== "string") {
        throw new TypeError("filename must be a string");
      }
      if (fallback === void 0) {
        fallback = true;
      }
      if (typeof fallback !== "string" && typeof fallback !== "boolean") {
        throw new TypeError("fallback must be a string or boolean");
      }
      if (typeof fallback === "string" && NON_LATIN1_REGEXP.test(fallback)) {
        throw new TypeError("fallback must be ISO-8859-1 string");
      }
      var name28 = basename(filename);
      var isQuotedString = TEXT_REGEXP.test(name28);
      var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name28) : basename(fallback);
      var hasFallback = typeof fallbackName === "string" && fallbackName !== name28;
      if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name28)) {
        params["filename*"] = name28;
      }
      if (isQuotedString || hasFallback) {
        params.filename = hasFallback ? fallbackName : name28;
      }
      return params;
    }
    function format(obj) {
      var parameters = obj.parameters;
      var type = obj.type;
      if (!type || typeof type !== "string" || !TOKEN_REGEXP.test(type)) {
        throw new TypeError("invalid type");
      }
      var string5 = String(type).toLowerCase();
      if (parameters && typeof parameters === "object") {
        var param;
        var params = Object.keys(parameters).sort();
        for (var i = 0; i < params.length; i++) {
          param = params[i];
          var val = param.slice(-1) === "*" ? ustring(parameters[param]) : qstring(parameters[param]);
          string5 += "; " + param + "=" + val;
        }
      }
      return string5;
    }
    function decodefield(str) {
      var match = EXT_VALUE_REGEXP.exec(str);
      if (!match) {
        throw new TypeError("invalid extended field value");
      }
      var charset = match[1].toLowerCase();
      var encoded = match[2];
      var value;
      var binary = encoded.replace(HEX_ESCAPE_REPLACE_REGEXP, pdecode);
      switch (charset) {
        case "iso-8859-1":
          value = getlatin1(binary);
          break;
        case "utf-8":
        case "utf8":
          value = Buffer.from(binary, "binary").toString("utf8");
          break;
        default:
          throw new TypeError("unsupported charset in extended field");
      }
      return value;
    }
    function getlatin1(val) {
      return String(val).replace(NON_LATIN1_REGEXP, "?");
    }
    function parse4(string5) {
      if (!string5 || typeof string5 !== "string") {
        throw new TypeError("argument string is required");
      }
      var match = DISPOSITION_TYPE_REGEXP.exec(string5);
      if (!match) {
        throw new TypeError("invalid type format");
      }
      var index = match[0].length;
      var type = match[1].toLowerCase();
      var key;
      var names = [];
      var params = {};
      var value;
      index = PARAM_REGEXP.lastIndex = match[0].slice(-1) === ";" ? index - 1 : index;
      while (match = PARAM_REGEXP.exec(string5)) {
        if (match.index !== index) {
          throw new TypeError("invalid parameter format");
        }
        index += match[0].length;
        key = match[1].toLowerCase();
        value = match[2];
        if (names.indexOf(key) !== -1) {
          throw new TypeError("invalid duplicate parameter");
        }
        names.push(key);
        if (key.indexOf("*") + 1 === key.length) {
          key = key.slice(0, -1);
          value = decodefield(value);
          params[key] = value;
          continue;
        }
        if (typeof params[key] === "string") {
          continue;
        }
        if (value[0] === '"') {
          value = value.slice(1, -1).replace(QESC_REGEXP, "$1");
        }
        params[key] = value;
      }
      if (index !== -1 && index !== string5.length) {
        throw new TypeError("invalid parameter format");
      }
      return new ContentDisposition(type, params);
    }
    function pdecode(str, hex4) {
      return String.fromCharCode(parseInt(hex4, 16));
    }
    function pencode(char) {
      return "%" + String(char).charCodeAt(0).toString(16).toUpperCase();
    }
    function qstring(val) {
      var str = String(val);
      return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
    }
    function ustring(val) {
      var str = String(val);
      var encoded = encodeURIComponent(str).replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode);
      return "UTF-8''" + encoded;
    }
    function ContentDisposition(type, parameters) {
      this.type = type;
      this.parameters = parameters;
    }
  }
});

// node_modules/cookie-signature/index.js
var require_cookie_signature = __commonJS({
  "node_modules/cookie-signature/index.js"(exports2) {
    "use strict";
    var crypto7 = require("crypto");
    exports2.sign = function(val, secret) {
      if ("string" != typeof val) throw new TypeError("Cookie value must be provided as a string.");
      if (null == secret) throw new TypeError("Secret key must be provided.");
      return val + "." + crypto7.createHmac("sha256", secret).update(val).digest("base64").replace(/\=+$/, "");
    };
    exports2.unsign = function(input, secret) {
      if ("string" != typeof input) throw new TypeError("Signed cookie string must be provided.");
      if (null == secret) throw new TypeError("Secret key must be provided.");
      var tentativeValue = input.slice(0, input.lastIndexOf(".")), expectedInput = exports2.sign(tentativeValue, secret), expectedBuffer = Buffer.from(expectedInput), inputBuffer = Buffer.from(input);
      return expectedBuffer.length === inputBuffer.length && crypto7.timingSafeEqual(expectedBuffer, inputBuffer) ? tentativeValue : false;
    };
  }
});

// node_modules/cookie/index.js
var require_cookie = __commonJS({
  "node_modules/cookie/index.js"(exports2) {
    "use strict";
    exports2.parse = parse4;
    exports2.serialize = serialize;
    var __toString = Object.prototype.toString;
    var __hasOwnProperty = Object.prototype.hasOwnProperty;
    var cookieNameRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
    var cookieValueRegExp = /^("?)[\u0021\u0023-\u002B\u002D-\u003A\u003C-\u005B\u005D-\u007E]*\1$/;
    var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
    var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
    function parse4(str, opt) {
      if (typeof str !== "string") {
        throw new TypeError("argument str must be a string");
      }
      var obj = {};
      var len = str.length;
      if (len < 2) return obj;
      var dec = opt && opt.decode || decode4;
      var index = 0;
      var eqIdx = 0;
      var endIdx = 0;
      do {
        eqIdx = str.indexOf("=", index);
        if (eqIdx === -1) break;
        endIdx = str.indexOf(";", index);
        if (endIdx === -1) {
          endIdx = len;
        } else if (eqIdx > endIdx) {
          index = str.lastIndexOf(";", eqIdx - 1) + 1;
          continue;
        }
        var keyStartIdx = startIndex(str, index, eqIdx);
        var keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
        var key = str.slice(keyStartIdx, keyEndIdx);
        if (!__hasOwnProperty.call(obj, key)) {
          var valStartIdx = startIndex(str, eqIdx + 1, endIdx);
          var valEndIdx = endIndex(str, endIdx, valStartIdx);
          if (str.charCodeAt(valStartIdx) === 34 && str.charCodeAt(valEndIdx - 1) === 34) {
            valStartIdx++;
            valEndIdx--;
          }
          var val = str.slice(valStartIdx, valEndIdx);
          obj[key] = tryDecode(val, dec);
        }
        index = endIdx + 1;
      } while (index < len);
      return obj;
    }
    function startIndex(str, index, max) {
      do {
        var code = str.charCodeAt(index);
        if (code !== 32 && code !== 9) return index;
      } while (++index < max);
      return max;
    }
    function endIndex(str, index, min) {
      while (index > min) {
        var code = str.charCodeAt(--index);
        if (code !== 32 && code !== 9) return index + 1;
      }
      return min;
    }
    function serialize(name28, val, opt) {
      var enc = opt && opt.encode || encodeURIComponent;
      if (typeof enc !== "function") {
        throw new TypeError("option encode is invalid");
      }
      if (!cookieNameRegExp.test(name28)) {
        throw new TypeError("argument name is invalid");
      }
      var value = enc(val);
      if (!cookieValueRegExp.test(value)) {
        throw new TypeError("argument val is invalid");
      }
      var str = name28 + "=" + value;
      if (!opt) return str;
      if (null != opt.maxAge) {
        var maxAge = Math.floor(opt.maxAge);
        if (!isFinite(maxAge)) {
          throw new TypeError("option maxAge is invalid");
        }
        str += "; Max-Age=" + maxAge;
      }
      if (opt.domain) {
        if (!domainValueRegExp.test(opt.domain)) {
          throw new TypeError("option domain is invalid");
        }
        str += "; Domain=" + opt.domain;
      }
      if (opt.path) {
        if (!pathValueRegExp.test(opt.path)) {
          throw new TypeError("option path is invalid");
        }
        str += "; Path=" + opt.path;
      }
      if (opt.expires) {
        var expires = opt.expires;
        if (!isDate2(expires) || isNaN(expires.valueOf())) {
          throw new TypeError("option expires is invalid");
        }
        str += "; Expires=" + expires.toUTCString();
      }
      if (opt.httpOnly) {
        str += "; HttpOnly";
      }
      if (opt.secure) {
        str += "; Secure";
      }
      if (opt.partitioned) {
        str += "; Partitioned";
      }
      if (opt.priority) {
        var priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
        switch (priority) {
          case "low":
            str += "; Priority=Low";
            break;
          case "medium":
            str += "; Priority=Medium";
            break;
          case "high":
            str += "; Priority=High";
            break;
          default:
            throw new TypeError("option priority is invalid");
        }
      }
      if (opt.sameSite) {
        var sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
        switch (sameSite) {
          case true:
            str += "; SameSite=Strict";
            break;
          case "lax":
            str += "; SameSite=Lax";
            break;
          case "strict":
            str += "; SameSite=Strict";
            break;
          case "none":
            str += "; SameSite=None";
            break;
          default:
            throw new TypeError("option sameSite is invalid");
        }
      }
      return str;
    }
    function decode4(str) {
      return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
    }
    function isDate2(val) {
      return __toString.call(val) === "[object Date]";
    }
    function tryDecode(str, decode5) {
      try {
        return decode5(str);
      } catch (e) {
        return str;
      }
    }
  }
});

// node_modules/send/index.js
var require_send = __commonJS({
  "node_modules/send/index.js"(exports2, module2) {
    "use strict";
    var createError = require_http_errors();
    var debug = require_src()("send");
    var encodeUrl = require_encodeurl();
    var escapeHtml = require_escape_html();
    var etag = require_etag();
    var fresh = require_fresh();
    var fs34 = require("fs");
    var mime = require_mime_types();
    var ms = require_ms();
    var onFinished = require_on_finished();
    var parseRange = require_range_parser();
    var path33 = require("path");
    var statuses = require_statuses();
    var Stream = require("stream");
    var util4 = require("util");
    var extname = path33.extname;
    var join2 = path33.join;
    var normalize = path33.normalize;
    var resolve3 = path33.resolve;
    var sep = path33.sep;
    var BYTES_RANGE_REGEXP = /^ *bytes=/;
    var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1e3;
    var UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
    module2.exports = send;
    function send(req, path34, options) {
      return new SendStream(req, path34, options);
    }
    function SendStream(req, path34, options) {
      Stream.call(this);
      var opts = options || {};
      this.options = opts;
      this.path = path34;
      this.req = req;
      this._acceptRanges = opts.acceptRanges !== void 0 ? Boolean(opts.acceptRanges) : true;
      this._cacheControl = opts.cacheControl !== void 0 ? Boolean(opts.cacheControl) : true;
      this._etag = opts.etag !== void 0 ? Boolean(opts.etag) : true;
      this._dotfiles = opts.dotfiles !== void 0 ? opts.dotfiles : "ignore";
      if (this._dotfiles !== "ignore" && this._dotfiles !== "allow" && this._dotfiles !== "deny") {
        throw new TypeError('dotfiles option must be "allow", "deny", or "ignore"');
      }
      this._extensions = opts.extensions !== void 0 ? normalizeList(opts.extensions, "extensions option") : [];
      this._immutable = opts.immutable !== void 0 ? Boolean(opts.immutable) : false;
      this._index = opts.index !== void 0 ? normalizeList(opts.index, "index option") : ["index.html"];
      this._lastModified = opts.lastModified !== void 0 ? Boolean(opts.lastModified) : true;
      this._maxage = opts.maxAge || opts.maxage;
      this._maxage = typeof this._maxage === "string" ? ms(this._maxage) : Number(this._maxage);
      this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;
      this._root = opts.root ? resolve3(opts.root) : null;
    }
    util4.inherits(SendStream, Stream);
    SendStream.prototype.error = function error73(status, err) {
      if (hasListeners(this, "error")) {
        return this.emit("error", createHttpError(status, err));
      }
      var res = this.res;
      var msg = statuses.message[status] || String(status);
      var doc = createHtmlDocument("Error", escapeHtml(msg));
      clearHeaders(res);
      if (err && err.headers) {
        setHeaders(res, err.headers);
      }
      res.statusCode = status;
      res.setHeader("Content-Type", "text/html; charset=UTF-8");
      res.setHeader("Content-Length", Buffer.byteLength(doc));
      res.setHeader("Content-Security-Policy", "default-src 'none'");
      res.setHeader("X-Content-Type-Options", "nosniff");
      res.end(doc);
    };
    SendStream.prototype.hasTrailingSlash = function hasTrailingSlash() {
      return this.path[this.path.length - 1] === "/";
    };
    SendStream.prototype.isConditionalGET = function isConditionalGET() {
      return this.req.headers["if-match"] || this.req.headers["if-unmodified-since"] || this.req.headers["if-none-match"] || this.req.headers["if-modified-since"];
    };
    SendStream.prototype.isPreconditionFailure = function isPreconditionFailure() {
      var req = this.req;
      var res = this.res;
      var match = req.headers["if-match"];
      if (match) {
        var etag2 = res.getHeader("ETag");
        return !etag2 || match !== "*" && parseTokenList(match).every(function(match2) {
          return match2 !== etag2 && match2 !== "W/" + etag2 && "W/" + match2 !== etag2;
        });
      }
      var unmodifiedSince = parseHttpDate(req.headers["if-unmodified-since"]);
      if (!isNaN(unmodifiedSince)) {
        var lastModified = parseHttpDate(res.getHeader("Last-Modified"));
        return isNaN(lastModified) || lastModified > unmodifiedSince;
      }
      return false;
    };
    SendStream.prototype.removeContentHeaderFields = function removeContentHeaderFields() {
      var res = this.res;
      res.removeHeader("Content-Encoding");
      res.removeHeader("Content-Language");
      res.removeHeader("Content-Length");
      res.removeHeader("Content-Range");
      res.removeHeader("Content-Type");
    };
    SendStream.prototype.notModified = function notModified() {
      var res = this.res;
      debug("not modified");
      this.removeContentHeaderFields();
      res.statusCode = 304;
      res.end();
    };
    SendStream.prototype.headersAlreadySent = function headersAlreadySent() {
      var err = new Error("Can't set headers after they are sent.");
      debug("headers already sent");
      this.error(500, err);
    };
    SendStream.prototype.isCachable = function isCachable() {
      var statusCode = this.res.statusCode;
      return statusCode >= 200 && statusCode < 300 || statusCode === 304;
    };
    SendStream.prototype.onStatError = function onStatError(error73) {
      switch (error73.code) {
        case "ENAMETOOLONG":
        case "ENOENT":
        case "ENOTDIR":
          this.error(404, error73);
          break;
        default:
          this.error(500, error73);
          break;
      }
    };
    SendStream.prototype.isFresh = function isFresh() {
      return fresh(this.req.headers, {
        etag: this.res.getHeader("ETag"),
        "last-modified": this.res.getHeader("Last-Modified")
      });
    };
    SendStream.prototype.isRangeFresh = function isRangeFresh() {
      var ifRange = this.req.headers["if-range"];
      if (!ifRange) {
        return true;
      }
      if (ifRange.indexOf('"') !== -1) {
        var etag2 = this.res.getHeader("ETag");
        return Boolean(etag2 && ifRange.indexOf(etag2) !== -1);
      }
      var lastModified = this.res.getHeader("Last-Modified");
      return parseHttpDate(lastModified) <= parseHttpDate(ifRange);
    };
    SendStream.prototype.redirect = function redirect(path34) {
      var res = this.res;
      if (hasListeners(this, "directory")) {
        this.emit("directory", res, path34);
        return;
      }
      if (this.hasTrailingSlash()) {
        this.error(403);
        return;
      }
      var loc = encodeUrl(collapseLeadingSlashes(this.path + "/"));
      var doc = createHtmlDocument("Redirecting", "Redirecting to " + escapeHtml(loc));
      res.statusCode = 301;
      res.setHeader("Content-Type", "text/html; charset=UTF-8");
      res.setHeader("Content-Length", Buffer.byteLength(doc));
      res.setHeader("Content-Security-Policy", "default-src 'none'");
      res.setHeader("X-Content-Type-Options", "nosniff");
      res.setHeader("Location", loc);
      res.end(doc);
    };
    SendStream.prototype.pipe = function pipe3(res) {
      var root2 = this._root;
      this.res = res;
      var path34 = decode4(this.path);
      if (path34 === -1) {
        this.error(400);
        return res;
      }
      if (~path34.indexOf("\0")) {
        this.error(400);
        return res;
      }
      var parts;
      if (root2 !== null) {
        if (path34) {
          path34 = normalize("." + sep + path34);
        }
        if (UP_PATH_REGEXP.test(path34)) {
          debug('malicious path "%s"', path34);
          this.error(403);
          return res;
        }
        parts = path34.split(sep);
        path34 = normalize(join2(root2, path34));
      } else {
        if (UP_PATH_REGEXP.test(path34)) {
          debug('malicious path "%s"', path34);
          this.error(403);
          return res;
        }
        parts = normalize(path34).split(sep);
        path34 = resolve3(path34);
      }
      if (containsDotFile(parts)) {
        debug('%s dotfile "%s"', this._dotfiles, path34);
        switch (this._dotfiles) {
          case "allow":
            break;
          case "deny":
            this.error(403);
            return res;
          case "ignore":
          default:
            this.error(404);
            return res;
        }
      }
      if (this._index.length && this.hasTrailingSlash()) {
        this.sendIndex(path34);
        return res;
      }
      this.sendFile(path34);
      return res;
    };
    SendStream.prototype.send = function send2(path34, stat) {
      var len = stat.size;
      var options = this.options;
      var opts = {};
      var res = this.res;
      var req = this.req;
      var ranges = req.headers.range;
      var offset = options.start || 0;
      if (res.headersSent) {
        this.headersAlreadySent();
        return;
      }
      debug('pipe "%s"', path34);
      this.setHeader(path34, stat);
      this.type(path34);
      if (this.isConditionalGET()) {
        if (this.isPreconditionFailure()) {
          this.error(412);
          return;
        }
        if (this.isCachable() && this.isFresh()) {
          this.notModified();
          return;
        }
      }
      len = Math.max(0, len - offset);
      if (options.end !== void 0) {
        var bytes = options.end - offset + 1;
        if (len > bytes) len = bytes;
      }
      if (this._acceptRanges && BYTES_RANGE_REGEXP.test(ranges)) {
        ranges = parseRange(len, ranges, {
          combine: true
        });
        if (!this.isRangeFresh()) {
          debug("range stale");
          ranges = -2;
        }
        if (ranges === -1) {
          debug("range unsatisfiable");
          res.setHeader("Content-Range", contentRange("bytes", len));
          return this.error(416, {
            headers: { "Content-Range": res.getHeader("Content-Range") }
          });
        }
        if (ranges !== -2 && ranges.length === 1) {
          debug("range %j", ranges);
          res.statusCode = 206;
          res.setHeader("Content-Range", contentRange("bytes", len, ranges[0]));
          offset += ranges[0].start;
          len = ranges[0].end - ranges[0].start + 1;
        }
      }
      for (var prop in options) {
        opts[prop] = options[prop];
      }
      opts.start = offset;
      opts.end = Math.max(offset, offset + len - 1);
      res.setHeader("Content-Length", len);
      if (req.method === "HEAD") {
        res.end();
        return;
      }
      this.stream(path34, opts);
    };
    SendStream.prototype.sendFile = function sendFile(path34) {
      var i = 0;
      var self2 = this;
      debug('stat "%s"', path34);
      fs34.stat(path34, function onstat(err, stat) {
        var pathEndsWithSep = path34[path34.length - 1] === sep;
        if (err && err.code === "ENOENT" && !extname(path34) && !pathEndsWithSep) {
          return next(err);
        }
        if (err) return self2.onStatError(err);
        if (stat.isDirectory()) return self2.redirect(path34);
        if (pathEndsWithSep) return self2.error(404);
        self2.emit("file", path34, stat);
        self2.send(path34, stat);
      });
      function next(err) {
        if (self2._extensions.length <= i) {
          return err ? self2.onStatError(err) : self2.error(404);
        }
        var p3 = path34 + "." + self2._extensions[i++];
        debug('stat "%s"', p3);
        fs34.stat(p3, function(err2, stat) {
          if (err2) return next(err2);
          if (stat.isDirectory()) return next();
          self2.emit("file", p3, stat);
          self2.send(p3, stat);
        });
      }
    };
    SendStream.prototype.sendIndex = function sendIndex(path34) {
      var i = -1;
      var self2 = this;
      function next(err) {
        if (++i >= self2._index.length) {
          if (err) return self2.onStatError(err);
          return self2.error(404);
        }
        var p3 = join2(path34, self2._index[i]);
        debug('stat "%s"', p3);
        fs34.stat(p3, function(err2, stat) {
          if (err2) return next(err2);
          if (stat.isDirectory()) return next();
          self2.emit("file", p3, stat);
          self2.send(p3, stat);
        });
      }
      next();
    };
    SendStream.prototype.stream = function stream4(path34, options) {
      var self2 = this;
      var res = this.res;
      var stream5 = fs34.createReadStream(path34, options);
      this.emit("stream", stream5);
      stream5.pipe(res);
      function cleanup() {
        stream5.destroy();
      }
      onFinished(res, cleanup);
      stream5.on("error", function onerror(err) {
        cleanup();
        self2.onStatError(err);
      });
      stream5.on("end", function onend() {
        self2.emit("end");
      });
    };
    SendStream.prototype.type = function type(path34) {
      var res = this.res;
      if (res.getHeader("Content-Type")) return;
      var ext = extname(path34);
      var type2 = mime.contentType(ext) || "application/octet-stream";
      debug("content-type %s", type2);
      res.setHeader("Content-Type", type2);
    };
    SendStream.prototype.setHeader = function setHeader(path34, stat) {
      var res = this.res;
      this.emit("headers", res, path34, stat);
      if (this._acceptRanges && !res.getHeader("Accept-Ranges")) {
        debug("accept ranges");
        res.setHeader("Accept-Ranges", "bytes");
      }
      if (this._cacheControl && !res.getHeader("Cache-Control")) {
        var cacheControl = "public, max-age=" + Math.floor(this._maxage / 1e3);
        if (this._immutable) {
          cacheControl += ", immutable";
        }
        debug("cache-control %s", cacheControl);
        res.setHeader("Cache-Control", cacheControl);
      }
      if (this._lastModified && !res.getHeader("Last-Modified")) {
        var modified = stat.mtime.toUTCString();
        debug("modified %s", modified);
        res.setHeader("Last-Modified", modified);
      }
      if (this._etag && !res.getHeader("ETag")) {
        var val = etag(stat);
        debug("etag %s", val);
        res.setHeader("ETag", val);
      }
    };
    function clearHeaders(res) {
      for (const header of res.getHeaderNames()) {
        res.removeHeader(header);
      }
    }
    function collapseLeadingSlashes(str) {
      for (var i = 0; i < str.length; i++) {
        if (str[i] !== "/") {
          break;
        }
      }
      return i > 1 ? "/" + str.substr(i) : str;
    }
    function containsDotFile(parts) {
      for (var i = 0; i < parts.length; i++) {
        var part = parts[i];
        if (part.length > 1 && part[0] === ".") {
          return true;
        }
      }
      return false;
    }
    function contentRange(type, size, range) {
      return type + " " + (range ? range.start + "-" + range.end : "*") + "/" + size;
    }
    function createHtmlDocument(title, body) {
      return '<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="utf-8">\n<title>' + title + "</title>\n</head>\n<body>\n<pre>" + body + "</pre>\n</body>\n</html>\n";
    }
    function createHttpError(status, err) {
      if (!err) {
        return createError(status);
      }
      return err instanceof Error ? createError(status, err, { expose: false }) : createError(status, err);
    }
    function decode4(path34) {
      try {
        return decodeURIComponent(path34);
      } catch (err) {
        return -1;
      }
    }
    function hasListeners(emitter, type) {
      var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
      return count > 0;
    }
    function normalizeList(val, name28) {
      var list2 = [].concat(val || []);
      for (var i = 0; i < list2.length; i++) {
        if (typeof list2[i] !== "string") {
          throw new TypeError(name28 + " must be array of strings or false");
        }
      }
      return list2;
    }
    function parseHttpDate(date6) {
      var timestamp = date6 && Date.parse(date6);
      return typeof timestamp === "number" ? timestamp : NaN;
    }
    function parseTokenList(str) {
      var end = 0;
      var list2 = [];
      var start = 0;
      for (var i = 0, len = str.length; i < len; i++) {
        switch (str.charCodeAt(i)) {
          case 32:
            if (start === end) {
              start = end = i + 1;
            }
            break;
          case 44:
            if (start !== end) {
              list2.push(str.substring(start, end));
            }
            start = end = i + 1;
            break;
          default:
            end = i + 1;
            break;
        }
      }
      if (start !== end) {
        list2.push(str.substring(start, end));
      }
      return list2;
    }
    function setHeaders(res, headers) {
      var keys2 = Object.keys(headers);
      for (var i = 0; i < keys2.length; i++) {
        var key = keys2[i];
        res.setHeader(key, headers[key]);
      }
    }
  }
});

// node_modules/vary/index.js
var require_vary = __commonJS({
  "node_modules/vary/index.js"(exports2, module2) {
    "use strict";
    module2.exports = vary;
    module2.exports.append = append2;
    var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
    function append2(header, field) {
      if (typeof header !== "string") {
        throw new TypeError("header argument is required");
      }
      if (!field) {
        throw new TypeError("field argument is required");
      }
      var fields = !Array.isArray(field) ? parse4(String(field)) : field;
      for (var j = 0; j < fields.length; j++) {
        if (!FIELD_NAME_REGEXP.test(fields[j])) {
          throw new TypeError("field argument contains an invalid header name");
        }
      }
      if (header === "*") {
        return header;
      }
      var val = header;
      var vals = parse4(header.toLowerCase());
      if (fields.indexOf("*") !== -1 || vals.indexOf("*") !== -1) {
        return "*";
      }
      for (var i = 0; i < fields.length; i++) {
        var fld = fields[i].toLowerCase();
        if (vals.indexOf(fld) === -1) {
          vals.push(fld);
          val = val ? val + ", " + fields[i] : fields[i];
        }
      }
      return val;
    }
    function parse4(header) {
      var end = 0;
      var list2 = [];
      var start = 0;
      for (var i = 0, len = header.length; i < len; i++) {
        switch (header.charCodeAt(i)) {
          case 32:
            if (start === end) {
              start = end = i + 1;
            }
            break;
          case 44:
            list2.push(header.substring(start, end));
            start = end = i + 1;
            break;
          default:
            end = i + 1;
            break;
        }
      }
      list2.push(header.substring(start, end));
      return list2;
    }
    function vary(res, field) {
      if (!res || !res.getHeader || !res.setHeader) {
        throw new TypeError("res argument is required");
      }
      var val = res.getHeader("Vary") || "";
      var header = Array.isArray(val) ? val.join(", ") : String(val);
      if (val = append2(header, field)) {
        res.setHeader("Vary", val);
      }
    }
  }
});

// node_modules/express/lib/response.js
var require_response = __commonJS({
  "node_modules/express/lib/response.js"(exports2, module2) {
    "use strict";
    var contentDisposition = require_content_disposition();
    var createError = require_http_errors();
    var deprecate = require_depd()("express");
    var encodeUrl = require_encodeurl();
    var escapeHtml = require_escape_html();
    var http4 = require("node:http");
    var onFinished = require_on_finished();
    var mime = require_mime_types();
    var path33 = require("node:path");
    var pathIsAbsolute = require("node:path").isAbsolute;
    var statuses = require_statuses();
    var sign = require_cookie_signature().sign;
    var normalizeType = require_utils3().normalizeType;
    var normalizeTypes = require_utils3().normalizeTypes;
    var setCharset = require_utils3().setCharset;
    var cookie = require_cookie();
    var send = require_send();
    var extname = path33.extname;
    var resolve3 = path33.resolve;
    var vary = require_vary();
    var { Buffer: Buffer3 } = require("node:buffer");
    var res = Object.create(http4.ServerResponse.prototype);
    module2.exports = res;
    res.status = function status(code) {
      if (!Number.isInteger(code)) {
        throw new TypeError(`Invalid status code: ${JSON.stringify(code)}. Status code must be an integer.`);
      }
      if (code < 100 || code > 999) {
        throw new RangeError(`Invalid status code: ${JSON.stringify(code)}. Status code must be greater than 99 and less than 1000.`);
      }
      this.statusCode = code;
      return this;
    };
    res.links = function(links) {
      var link = this.get("Link") || "";
      if (link) link += ", ";
      return this.set("Link", link + Object.keys(links).map(function(rel) {
        if (Array.isArray(links[rel])) {
          return links[rel].map(function(singleLink) {
            return `<${singleLink}>; rel="${rel}"`;
          }).join(", ");
        } else {
          return `<${links[rel]}>; rel="${rel}"`;
        }
      }).join(", "));
    };
    res.send = function send2(body) {
      var chunk = body;
      var encoding;
      var req = this.req;
      var type;
      var app2 = this.app;
      switch (typeof chunk) {
        // string defaulting to html
        case "string":
          if (!this.get("Content-Type")) {
            this.type("html");
          }
          break;
        case "boolean":
        case "number":
        case "object":
          if (chunk === null) {
            chunk = "";
          } else if (ArrayBuffer.isView(chunk)) {
            if (!this.get("Content-Type")) {
              this.type("bin");
            }
          } else {
            return this.json(chunk);
          }
          break;
      }
      if (typeof chunk === "string") {
        encoding = "utf8";
        type = this.get("Content-Type");
        if (typeof type === "string") {
          this.set("Content-Type", setCharset(type, "utf-8"));
        }
      }
      var etagFn = app2.get("etag fn");
      var generateETag = !this.get("ETag") && typeof etagFn === "function";
      var len;
      if (chunk !== void 0) {
        if (Buffer3.isBuffer(chunk)) {
          len = chunk.length;
        } else if (!generateETag && chunk.length < 1e3) {
          len = Buffer3.byteLength(chunk, encoding);
        } else {
          chunk = Buffer3.from(chunk, encoding);
          encoding = void 0;
          len = chunk.length;
        }
        this.set("Content-Length", len);
      }
      var etag;
      if (generateETag && len !== void 0) {
        if (etag = etagFn(chunk, encoding)) {
          this.set("ETag", etag);
        }
      }
      if (req.fresh) this.status(304);
      if (204 === this.statusCode || 304 === this.statusCode) {
        this.removeHeader("Content-Type");
        this.removeHeader("Content-Length");
        this.removeHeader("Transfer-Encoding");
        chunk = "";
      }
      if (this.statusCode === 205) {
        this.set("Content-Length", "0");
        this.removeHeader("Transfer-Encoding");
        chunk = "";
      }
      if (req.method === "HEAD") {
        this.end();
      } else {
        this.end(chunk, encoding);
      }
      return this;
    };
    res.json = function json4(obj) {
      var app2 = this.app;
      var escape2 = app2.get("json escape");
      var replacer = app2.get("json replacer");
      var spaces = app2.get("json spaces");
      var body = stringify2(obj, replacer, spaces, escape2);
      if (!this.get("Content-Type")) {
        this.set("Content-Type", "application/json");
      }
      return this.send(body);
    };
    res.jsonp = function jsonp(obj) {
      var app2 = this.app;
      var escape2 = app2.get("json escape");
      var replacer = app2.get("json replacer");
      var spaces = app2.get("json spaces");
      var body = stringify2(obj, replacer, spaces, escape2);
      var callback = this.req.query[app2.get("jsonp callback name")];
      if (!this.get("Content-Type")) {
        this.set("X-Content-Type-Options", "nosniff");
        this.set("Content-Type", "application/json");
      }
      if (Array.isArray(callback)) {
        callback = callback[0];
      }
      if (typeof callback === "string" && callback.length !== 0) {
        this.set("X-Content-Type-Options", "nosniff");
        this.set("Content-Type", "text/javascript");
        callback = callback.replace(/[^\[\]\w$.]/g, "");
        if (body === void 0) {
          body = "";
        } else if (typeof body === "string") {
          body = body.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
        }
        body = "/**/ typeof " + callback + " === 'function' && " + callback + "(" + body + ");";
      }
      return this.send(body);
    };
    res.sendStatus = function sendStatus(statusCode) {
      var body = statuses.message[statusCode] || String(statusCode);
      this.status(statusCode);
      this.type("txt");
      return this.send(body);
    };
    res.sendFile = function sendFile(path34, options, callback) {
      var done = callback;
      var req = this.req;
      var res2 = this;
      var next = req.next;
      var opts = options || {};
      if (!path34) {
        throw new TypeError("path argument is required to res.sendFile");
      }
      if (typeof path34 !== "string") {
        throw new TypeError("path must be a string to res.sendFile");
      }
      if (typeof options === "function") {
        done = options;
        opts = {};
      }
      if (!opts.root && !pathIsAbsolute(path34)) {
        throw new TypeError("path must be absolute or specify root to res.sendFile");
      }
      var pathname = encodeURI(path34);
      opts.etag = this.app.enabled("etag");
      var file3 = send(req, pathname, opts);
      sendfile(res2, file3, opts, function(err) {
        if (done) return done(err);
        if (err && err.code === "EISDIR") return next();
        if (err && err.code !== "ECONNABORTED" && err.syscall !== "write") {
          next(err);
        }
      });
    };
    res.download = function download2(path34, filename, options, callback) {
      var done = callback;
      var name28 = filename;
      var opts = options || null;
      if (typeof filename === "function") {
        done = filename;
        name28 = null;
        opts = null;
      } else if (typeof options === "function") {
        done = options;
        opts = null;
      }
      if (typeof filename === "object" && (typeof options === "function" || options === void 0)) {
        name28 = null;
        opts = filename;
      }
      var headers = {
        "Content-Disposition": contentDisposition(name28 || path34)
      };
      if (opts && opts.headers) {
        var keys2 = Object.keys(opts.headers);
        for (var i = 0; i < keys2.length; i++) {
          var key = keys2[i];
          if (key.toLowerCase() !== "content-disposition") {
            headers[key] = opts.headers[key];
          }
        }
      }
      opts = Object.create(opts);
      opts.headers = headers;
      var fullPath = !opts.root ? resolve3(path34) : path34;
      return this.sendFile(fullPath, opts, done);
    };
    res.contentType = res.type = function contentType(type) {
      var ct = type.indexOf("/") === -1 ? mime.contentType(type) || "application/octet-stream" : type;
      return this.set("Content-Type", ct);
    };
    res.format = function(obj) {
      var req = this.req;
      var next = req.next;
      var keys2 = Object.keys(obj).filter(function(v) {
        return v !== "default";
      });
      var key = keys2.length > 0 ? req.accepts(keys2) : false;
      this.vary("Accept");
      if (key) {
        this.set("Content-Type", normalizeType(key).value);
        obj[key](req, this, next);
      } else if (obj.default) {
        obj.default(req, this, next);
      } else {
        next(createError(406, {
          types: normalizeTypes(keys2).map(function(o) {
            return o.value;
          })
        }));
      }
      return this;
    };
    res.attachment = function attachment(filename) {
      if (filename) {
        this.type(extname(filename));
      }
      this.set("Content-Disposition", contentDisposition(filename));
      return this;
    };
    res.append = function append2(field, val) {
      var prev = this.get(field);
      var value = val;
      if (prev) {
        value = Array.isArray(prev) ? prev.concat(val) : Array.isArray(val) ? [prev].concat(val) : [prev, val];
      }
      return this.set(field, value);
    };
    res.set = res.header = function header(field, val) {
      if (arguments.length === 2) {
        var value = Array.isArray(val) ? val.map(String) : String(val);
        if (field.toLowerCase() === "content-type") {
          if (Array.isArray(value)) {
            throw new TypeError("Content-Type cannot be set to an Array");
          }
          value = mime.contentType(value);
        }
        this.setHeader(field, value);
      } else {
        for (var key in field) {
          this.set(key, field[key]);
        }
      }
      return this;
    };
    res.get = function(field) {
      return this.getHeader(field);
    };
    res.clearCookie = function clearCookie(name28, options) {
      const opts = { path: "/", ...options, expires: /* @__PURE__ */ new Date(1) };
      delete opts.maxAge;
      return this.cookie(name28, "", opts);
    };
    res.cookie = function(name28, value, options) {
      var opts = { ...options };
      var secret = this.req.secret;
      var signed = opts.signed;
      if (signed && !secret) {
        throw new Error('cookieParser("secret") required for signed cookies');
      }
      var val = typeof value === "object" ? "j:" + JSON.stringify(value) : String(value);
      if (signed) {
        val = "s:" + sign(val, secret);
      }
      if (opts.maxAge != null) {
        var maxAge = opts.maxAge - 0;
        if (!isNaN(maxAge)) {
          opts.expires = new Date(Date.now() + maxAge);
          opts.maxAge = Math.floor(maxAge / 1e3);
        }
      }
      if (opts.path == null) {
        opts.path = "/";
      }
      this.append("Set-Cookie", cookie.serialize(name28, String(val), opts));
      return this;
    };
    res.location = function location(url4) {
      return this.set("Location", encodeUrl(url4));
    };
    res.redirect = function redirect(url4) {
      var address = url4;
      var body;
      var status = 302;
      if (arguments.length === 2) {
        status = arguments[0];
        address = arguments[1];
      }
      if (!address) {
        deprecate("Provide a url argument");
      }
      if (typeof address !== "string") {
        deprecate("Url must be a string");
      }
      if (typeof status !== "number") {
        deprecate("Status must be a number");
      }
      address = this.location(address).get("Location");
      this.format({
        text: function() {
          body = statuses.message[status] + ". Redirecting to " + address;
        },
        html: function() {
          var u = escapeHtml(address);
          body = "<p>" + statuses.message[status] + ". Redirecting to " + u + "</p>";
        },
        default: function() {
          body = "";
        }
      });
      this.status(status);
      this.set("Content-Length", Buffer3.byteLength(body));
      if (this.req.method === "HEAD") {
        this.end();
      } else {
        this.end(body);
      }
    };
    res.vary = function(field) {
      vary(this, field);
      return this;
    };
    res.render = function render(view, options, callback) {
      var app2 = this.req.app;
      var done = callback;
      var opts = options || {};
      var req = this.req;
      var self2 = this;
      if (typeof options === "function") {
        done = options;
        opts = {};
      }
      opts._locals = self2.locals;
      done = done || function(err, str) {
        if (err) return req.next(err);
        self2.send(str);
      };
      app2.render(view, opts, done);
    };
    function sendfile(res2, file3, options, callback) {
      var done = false;
      var streaming;
      function onaborted() {
        if (done) return;
        done = true;
        var err = new Error("Request aborted");
        err.code = "ECONNABORTED";
        callback(err);
      }
      function ondirectory() {
        if (done) return;
        done = true;
        var err = new Error("EISDIR, read");
        err.code = "EISDIR";
        callback(err);
      }
      function onerror(err) {
        if (done) return;
        done = true;
        callback(err);
      }
      function onend() {
        if (done) return;
        done = true;
        callback();
      }
      function onfile() {
        streaming = false;
      }
      function onfinish(err) {
        if (err && err.code === "ECONNRESET") return onaborted();
        if (err) return onerror(err);
        if (done) return;
        setImmediate(function() {
          if (streaming !== false && !done) {
            onaborted();
            return;
          }
          if (done) return;
          done = true;
          callback();
        });
      }
      function onstream() {
        streaming = true;
      }
      file3.on("directory", ondirectory);
      file3.on("end", onend);
      file3.on("error", onerror);
      file3.on("file", onfile);
      file3.on("stream", onstream);
      onFinished(res2, onfinish);
      if (options.headers) {
        file3.on("headers", function headers(res3) {
          var obj = options.headers;
          var keys2 = Object.keys(obj);
          for (var i = 0; i < keys2.length; i++) {
            var k = keys2[i];
            res3.setHeader(k, obj[k]);
          }
        });
      }
      file3.pipe(res2);
    }
    function stringify2(value, replacer, spaces, escape2) {
      var json4 = replacer || spaces ? JSON.stringify(value, replacer, spaces) : JSON.stringify(value);
      if (escape2 && typeof json4 === "string") {
        json4 = json4.replace(/[<>&]/g, function(c) {
          switch (c.charCodeAt(0)) {
            case 60:
              return "\\u003c";
            case 62:
              return "\\u003e";
            case 38:
              return "\\u0026";
            /* istanbul ignore next: unreachable default */
            default:
              return c;
          }
        });
      }
      return json4;
    }
  }
});

// node_modules/serve-static/index.js
var require_serve_static = __commonJS({
  "node_modules/serve-static/index.js"(exports2, module2) {
    "use strict";
    var encodeUrl = require_encodeurl();
    var escapeHtml = require_escape_html();
    var parseUrl2 = require_parseurl();
    var resolve3 = require("path").resolve;
    var send = require_send();
    var url4 = require("url");
    module2.exports = serveStatic;
    function serveStatic(root2, options) {
      if (!root2) {
        throw new TypeError("root path required");
      }
      if (typeof root2 !== "string") {
        throw new TypeError("root path must be a string");
      }
      var opts = Object.create(options || null);
      var fallthrough = opts.fallthrough !== false;
      var redirect = opts.redirect !== false;
      var setHeaders = opts.setHeaders;
      if (setHeaders && typeof setHeaders !== "function") {
        throw new TypeError("option setHeaders must be function");
      }
      opts.maxage = opts.maxage || opts.maxAge || 0;
      opts.root = resolve3(root2);
      var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener();
      return function serveStatic2(req, res, next) {
        if (req.method !== "GET" && req.method !== "HEAD") {
          if (fallthrough) {
            return next();
          }
          res.statusCode = 405;
          res.setHeader("Allow", "GET, HEAD");
          res.setHeader("Content-Length", "0");
          res.end();
          return;
        }
        var forwardError = !fallthrough;
        var originalUrl = parseUrl2.original(req);
        var path33 = parseUrl2(req).pathname;
        if (path33 === "/" && originalUrl.pathname.substr(-1) !== "/") {
          path33 = "";
        }
        var stream4 = send(req, path33, opts);
        stream4.on("directory", onDirectory);
        if (setHeaders) {
          stream4.on("headers", setHeaders);
        }
        if (fallthrough) {
          stream4.on("file", function onFile() {
            forwardError = true;
          });
        }
        stream4.on("error", function error73(err) {
          if (forwardError || !(err.statusCode < 500)) {
            next(err);
            return;
          }
          next();
        });
        stream4.pipe(res);
      };
    }
    function collapseLeadingSlashes(str) {
      for (var i = 0; i < str.length; i++) {
        if (str.charCodeAt(i) !== 47) {
          break;
        }
      }
      return i > 1 ? "/" + str.substr(i) : str;
    }
    function createHtmlDocument(title, body) {
      return '<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="utf-8">\n<title>' + title + "</title>\n</head>\n<body>\n<pre>" + body + "</pre>\n</body>\n</html>\n";
    }
    function createNotFoundDirectoryListener() {
      return function notFound() {
        this.error(404);
      };
    }
    function createRedirectDirectoryListener() {
      return function redirect(res) {
        if (this.hasTrailingSlash()) {
          this.error(404);
          return;
        }
        var originalUrl = parseUrl2.original(this.req);
        originalUrl.path = null;
        originalUrl.pathname = collapseLeadingSlashes(originalUrl.pathname + "/");
        var loc = encodeUrl(url4.format(originalUrl));
        var doc = createHtmlDocument("Redirecting", "Redirecting to " + escapeHtml(loc));
        res.statusCode = 301;
        res.setHeader("Content-Type", "text/html; charset=UTF-8");
        res.setHeader("Content-Length", Buffer.byteLength(doc));
        res.setHeader("Content-Security-Policy", "default-src 'none'");
        res.setHeader("X-Content-Type-Options", "nosniff");
        res.setHeader("Location", loc);
        res.end(doc);
      };
    }
  }
});

// node_modules/express/lib/express.js
var require_express = __commonJS({
  "node_modules/express/lib/express.js"(exports2, module2) {
    "use strict";
    var bodyParser = require_body_parser();
    var EventEmitter3 = require("node:events").EventEmitter;
    var mixin = require_merge_descriptors();
    var proto = require_application();
    var Router = require_router();
    var req = require_request();
    var res = require_response();
    exports2 = module2.exports = createApplication;
    function createApplication() {
      var app2 = function(req2, res2, next) {
        app2.handle(req2, res2, next);
      };
      mixin(app2, EventEmitter3.prototype, false);
      mixin(app2, proto, false);
      app2.request = Object.create(req, {
        app: { configurable: true, enumerable: true, writable: true, value: app2 }
      });
      app2.response = Object.create(res, {
        app: { configurable: true, enumerable: true, writable: true, value: app2 }
      });
      app2.init();
      return app2;
    }
    exports2.application = proto;
    exports2.request = req;
    exports2.response = res;
    exports2.Route = Router.Route;
    exports2.Router = Router;
    exports2.json = bodyParser.json;
    exports2.raw = bodyParser.raw;
    exports2.static = require_serve_static();
    exports2.text = bodyParser.text;
    exports2.urlencoded = bodyParser.urlencoded;
  }
});

// node_modules/express/index.js
var require_express2 = __commonJS({
  "node_modules/express/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_express();
  }
});

// node_modules/accepts/node_modules/negotiator/lib/charset.js
var require_charset2 = __commonJS({
  "node_modules/accepts/node_modules/negotiator/lib/charset.js"(exports2, module2) {
    "use strict";
    module2.exports = preferredCharsets;
    module2.exports.preferredCharsets = preferredCharsets;
    var simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
    function parseAcceptCharset(accept) {
      var accepts = accept.split(",");
      for (var i = 0, j = 0; i < accepts.length; i++) {
        var charset = parseCharset(accepts[i].trim(), i);
        if (charset) {
          accepts[j++] = charset;
        }
      }
      accepts.length = j;
      return accepts;
    }
    function parseCharset(str, i) {
      var match = simpleCharsetRegExp.exec(str);
      if (!match) return null;
      var charset = match[1];
      var q = 1;
      if (match[2]) {
        var params = match[2].split(";");
        for (var j = 0; j < params.length; j++) {
          var p3 = params[j].trim().split("=");
          if (p3[0] === "q") {
            q = parseFloat(p3[1]);
            break;
          }
        }
      }
      return {
        charset,
        q,
        i
      };
    }
    function getCharsetPriority(charset, accepted, index) {
      var priority = { o: -1, q: 0, s: 0 };
      for (var i = 0; i < accepted.length; i++) {
        var spec = specify(charset, accepted[i], index);
        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
          priority = spec;
        }
      }
      return priority;
    }
    function specify(charset, spec, index) {
      var s = 0;
      if (spec.charset.toLowerCase() === charset.toLowerCase()) {
        s |= 1;
      } else if (spec.charset !== "*") {
        return null;
      }
      return {
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    function preferredCharsets(accept, provided) {
      var accepts = parseAcceptCharset(accept === void 0 ? "*" : accept || "");
      if (!provided) {
        return accepts.filter(isQuality).sort(compareSpecs).map(getFullCharset);
      }
      var priorities = provided.map(function getPriority(type, index) {
        return getCharsetPriority(type, accepts, index);
      });
      return priorities.filter(isQuality).sort(compareSpecs).map(function getCharset(priority) {
        return provided[priorities.indexOf(priority)];
      });
    }
    function compareSpecs(a, b) {
      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
    }
    function getFullCharset(spec) {
      return spec.charset;
    }
    function isQuality(spec) {
      return spec.q > 0;
    }
  }
});

// node_modules/accepts/node_modules/negotiator/lib/encoding.js
var require_encoding2 = __commonJS({
  "node_modules/accepts/node_modules/negotiator/lib/encoding.js"(exports2, module2) {
    "use strict";
    module2.exports = preferredEncodings;
    module2.exports.preferredEncodings = preferredEncodings;
    var simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
    function parseAcceptEncoding(accept) {
      var accepts = accept.split(",");
      var hasIdentity = false;
      var minQuality = 1;
      for (var i = 0, j = 0; i < accepts.length; i++) {
        var encoding = parseEncoding(accepts[i].trim(), i);
        if (encoding) {
          accepts[j++] = encoding;
          hasIdentity = hasIdentity || specify("identity", encoding);
          minQuality = Math.min(minQuality, encoding.q || 1);
        }
      }
      if (!hasIdentity) {
        accepts[j++] = {
          encoding: "identity",
          q: minQuality,
          i
        };
      }
      accepts.length = j;
      return accepts;
    }
    function parseEncoding(str, i) {
      var match = simpleEncodingRegExp.exec(str);
      if (!match) return null;
      var encoding = match[1];
      var q = 1;
      if (match[2]) {
        var params = match[2].split(";");
        for (var j = 0; j < params.length; j++) {
          var p3 = params[j].trim().split("=");
          if (p3[0] === "q") {
            q = parseFloat(p3[1]);
            break;
          }
        }
      }
      return {
        encoding,
        q,
        i
      };
    }
    function getEncodingPriority(encoding, accepted, index) {
      var priority = { o: -1, q: 0, s: 0 };
      for (var i = 0; i < accepted.length; i++) {
        var spec = specify(encoding, accepted[i], index);
        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
          priority = spec;
        }
      }
      return priority;
    }
    function specify(encoding, spec, index) {
      var s = 0;
      if (spec.encoding.toLowerCase() === encoding.toLowerCase()) {
        s |= 1;
      } else if (spec.encoding !== "*") {
        return null;
      }
      return {
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    function preferredEncodings(accept, provided) {
      var accepts = parseAcceptEncoding(accept || "");
      if (!provided) {
        return accepts.filter(isQuality).sort(compareSpecs).map(getFullEncoding);
      }
      var priorities = provided.map(function getPriority(type, index) {
        return getEncodingPriority(type, accepts, index);
      });
      return priorities.filter(isQuality).sort(compareSpecs).map(function getEncoding(priority) {
        return provided[priorities.indexOf(priority)];
      });
    }
    function compareSpecs(a, b) {
      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
    }
    function getFullEncoding(spec) {
      return spec.encoding;
    }
    function isQuality(spec) {
      return spec.q > 0;
    }
  }
});

// node_modules/accepts/node_modules/negotiator/lib/language.js
var require_language2 = __commonJS({
  "node_modules/accepts/node_modules/negotiator/lib/language.js"(exports2, module2) {
    "use strict";
    module2.exports = preferredLanguages;
    module2.exports.preferredLanguages = preferredLanguages;
    var simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
    function parseAcceptLanguage(accept) {
      var accepts = accept.split(",");
      for (var i = 0, j = 0; i < accepts.length; i++) {
        var language = parseLanguage(accepts[i].trim(), i);
        if (language) {
          accepts[j++] = language;
        }
      }
      accepts.length = j;
      return accepts;
    }
    function parseLanguage(str, i) {
      var match = simpleLanguageRegExp.exec(str);
      if (!match) return null;
      var prefix = match[1];
      var suffix = match[2];
      var full = prefix;
      if (suffix) full += "-" + suffix;
      var q = 1;
      if (match[3]) {
        var params = match[3].split(";");
        for (var j = 0; j < params.length; j++) {
          var p3 = params[j].split("=");
          if (p3[0] === "q") q = parseFloat(p3[1]);
        }
      }
      return {
        prefix,
        suffix,
        q,
        i,
        full
      };
    }
    function getLanguagePriority(language, accepted, index) {
      var priority = { o: -1, q: 0, s: 0 };
      for (var i = 0; i < accepted.length; i++) {
        var spec = specify(language, accepted[i], index);
        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
          priority = spec;
        }
      }
      return priority;
    }
    function specify(language, spec, index) {
      var p3 = parseLanguage(language);
      if (!p3) return null;
      var s = 0;
      if (spec.full.toLowerCase() === p3.full.toLowerCase()) {
        s |= 4;
      } else if (spec.prefix.toLowerCase() === p3.full.toLowerCase()) {
        s |= 2;
      } else if (spec.full.toLowerCase() === p3.prefix.toLowerCase()) {
        s |= 1;
      } else if (spec.full !== "*") {
        return null;
      }
      return {
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    function preferredLanguages(accept, provided) {
      var accepts = parseAcceptLanguage(accept === void 0 ? "*" : accept || "");
      if (!provided) {
        return accepts.filter(isQuality).sort(compareSpecs).map(getFullLanguage);
      }
      var priorities = provided.map(function getPriority(type, index) {
        return getLanguagePriority(type, accepts, index);
      });
      return priorities.filter(isQuality).sort(compareSpecs).map(function getLanguage(priority) {
        return provided[priorities.indexOf(priority)];
      });
    }
    function compareSpecs(a, b) {
      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
    }
    function getFullLanguage(spec) {
      return spec.full;
    }
    function isQuality(spec) {
      return spec.q > 0;
    }
  }
});

// node_modules/accepts/node_modules/negotiator/lib/mediaType.js
var require_mediaType2 = __commonJS({
  "node_modules/accepts/node_modules/negotiator/lib/mediaType.js"(exports2, module2) {
    "use strict";
    module2.exports = preferredMediaTypes;
    module2.exports.preferredMediaTypes = preferredMediaTypes;
    var simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
    function parseAccept(accept) {
      var accepts = splitMediaTypes(accept);
      for (var i = 0, j = 0; i < accepts.length; i++) {
        var mediaType = parseMediaType(accepts[i].trim(), i);
        if (mediaType) {
          accepts[j++] = mediaType;
        }
      }
      accepts.length = j;
      return accepts;
    }
    function parseMediaType(str, i) {
      var match = simpleMediaTypeRegExp.exec(str);
      if (!match) return null;
      var params = /* @__PURE__ */ Object.create(null);
      var q = 1;
      var subtype = match[2];
      var type = match[1];
      if (match[3]) {
        var kvps = splitParameters(match[3]).map(splitKeyValuePair);
        for (var j = 0; j < kvps.length; j++) {
          var pair = kvps[j];
          var key = pair[0].toLowerCase();
          var val = pair[1];
          var value = val && val[0] === '"' && val[val.length - 1] === '"' ? val.substr(1, val.length - 2) : val;
          if (key === "q") {
            q = parseFloat(value);
            break;
          }
          params[key] = value;
        }
      }
      return {
        type,
        subtype,
        params,
        q,
        i
      };
    }
    function getMediaTypePriority(type, accepted, index) {
      var priority = { o: -1, q: 0, s: 0 };
      for (var i = 0; i < accepted.length; i++) {
        var spec = specify(type, accepted[i], index);
        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
          priority = spec;
        }
      }
      return priority;
    }
    function specify(type, spec, index) {
      var p3 = parseMediaType(type);
      var s = 0;
      if (!p3) {
        return null;
      }
      if (spec.type.toLowerCase() == p3.type.toLowerCase()) {
        s |= 4;
      } else if (spec.type != "*") {
        return null;
      }
      if (spec.subtype.toLowerCase() == p3.subtype.toLowerCase()) {
        s |= 2;
      } else if (spec.subtype != "*") {
        return null;
      }
      var keys2 = Object.keys(spec.params);
      if (keys2.length > 0) {
        if (keys2.every(function(k) {
          return spec.params[k] == "*" || (spec.params[k] || "").toLowerCase() == (p3.params[k] || "").toLowerCase();
        })) {
          s |= 1;
        } else {
          return null;
        }
      }
      return {
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    function preferredMediaTypes(accept, provided) {
      var accepts = parseAccept(accept === void 0 ? "*/*" : accept || "");
      if (!provided) {
        return accepts.filter(isQuality).sort(compareSpecs).map(getFullType);
      }
      var priorities = provided.map(function getPriority(type, index) {
        return getMediaTypePriority(type, accepts, index);
      });
      return priorities.filter(isQuality).sort(compareSpecs).map(function getType(priority) {
        return provided[priorities.indexOf(priority)];
      });
    }
    function compareSpecs(a, b) {
      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
    }
    function getFullType(spec) {
      return spec.type + "/" + spec.subtype;
    }
    function isQuality(spec) {
      return spec.q > 0;
    }
    function quoteCount(string5) {
      var count = 0;
      var index = 0;
      while ((index = string5.indexOf('"', index)) !== -1) {
        count++;
        index++;
      }
      return count;
    }
    function splitKeyValuePair(str) {
      var index = str.indexOf("=");
      var key;
      var val;
      if (index === -1) {
        key = str;
      } else {
        key = str.substr(0, index);
        val = str.substr(index + 1);
      }
      return [key, val];
    }
    function splitMediaTypes(accept) {
      var accepts = accept.split(",");
      for (var i = 1, j = 0; i < accepts.length; i++) {
        if (quoteCount(accepts[j]) % 2 == 0) {
          accepts[++j] = accepts[i];
        } else {
          accepts[j] += "," + accepts[i];
        }
      }
      accepts.length = j + 1;
      return accepts;
    }
    function splitParameters(str) {
      var parameters = str.split(";");
      for (var i = 1, j = 0; i < parameters.length; i++) {
        if (quoteCount(parameters[j]) % 2 == 0) {
          parameters[++j] = parameters[i];
        } else {
          parameters[j] += ";" + parameters[i];
        }
      }
      parameters.length = j + 1;
      for (var i = 0; i < parameters.length; i++) {
        parameters[i] = parameters[i].trim();
      }
      return parameters;
    }
  }
});

// node_modules/accepts/node_modules/negotiator/index.js
var require_negotiator2 = __commonJS({
  "node_modules/accepts/node_modules/negotiator/index.js"(exports2, module2) {
    "use strict";
    var preferredCharsets = require_charset2();
    var preferredEncodings = require_encoding2();
    var preferredLanguages = require_language2();
    var preferredMediaTypes = require_mediaType2();
    module2.exports = Negotiator;
    module2.exports.Negotiator = Negotiator;
    function Negotiator(request) {
      if (!(this instanceof Negotiator)) {
        return new Negotiator(request);
      }
      this.request = request;
    }
    Negotiator.prototype.charset = function charset(available) {
      var set3 = this.charsets(available);
      return set3 && set3[0];
    };
    Negotiator.prototype.charsets = function charsets(available) {
      return preferredCharsets(this.request.headers["accept-charset"], available);
    };
    Negotiator.prototype.encoding = function encoding(available) {
      var set3 = this.encodings(available);
      return set3 && set3[0];
    };
    Negotiator.prototype.encodings = function encodings(available) {
      return preferredEncodings(this.request.headers["accept-encoding"], available);
    };
    Negotiator.prototype.language = function language(available) {
      var set3 = this.languages(available);
      return set3 && set3[0];
    };
    Negotiator.prototype.languages = function languages(available) {
      return preferredLanguages(this.request.headers["accept-language"], available);
    };
    Negotiator.prototype.mediaType = function mediaType(available) {
      var set3 = this.mediaTypes(available);
      return set3 && set3[0];
    };
    Negotiator.prototype.mediaTypes = function mediaTypes(available) {
      return preferredMediaTypes(this.request.headers.accept, available);
    };
    Negotiator.prototype.preferredCharset = Negotiator.prototype.charset;
    Negotiator.prototype.preferredCharsets = Negotiator.prototype.charsets;
    Negotiator.prototype.preferredEncoding = Negotiator.prototype.encoding;
    Negotiator.prototype.preferredEncodings = Negotiator.prototype.encodings;
    Negotiator.prototype.preferredLanguage = Negotiator.prototype.language;
    Negotiator.prototype.preferredLanguages = Negotiator.prototype.languages;
    Negotiator.prototype.preferredMediaType = Negotiator.prototype.mediaType;
    Negotiator.prototype.preferredMediaTypes = Negotiator.prototype.mediaTypes;
  }
});

// node_modules/accepts/node_modules/mime-db/db.json
var require_db2 = __commonJS({
  "node_modules/accepts/node_modules/mime-db/db.json"(exports2, module2) {
    module2.exports = {
      "application/1d-interleaved-parityfec": {
        source: "iana"
      },
      "application/3gpdash-qoe-report+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/3gpp-ims+xml": {
        source: "iana",
        compressible: true
      },
      "application/3gpphal+json": {
        source: "iana",
        compressible: true
      },
      "application/3gpphalforms+json": {
        source: "iana",
        compressible: true
      },
      "application/a2l": {
        source: "iana"
      },
      "application/ace+cbor": {
        source: "iana"
      },
      "application/activemessage": {
        source: "iana"
      },
      "application/activity+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-costmap+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-costmapfilter+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-directory+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointcost+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointcostparams+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointprop+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointpropparams+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-error+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-networkmap+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-networkmapfilter+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-updatestreamcontrol+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-updatestreamparams+json": {
        source: "iana",
        compressible: true
      },
      "application/aml": {
        source: "iana"
      },
      "application/andrew-inset": {
        source: "iana",
        extensions: ["ez"]
      },
      "application/applefile": {
        source: "iana"
      },
      "application/applixware": {
        source: "apache",
        extensions: ["aw"]
      },
      "application/at+jwt": {
        source: "iana"
      },
      "application/atf": {
        source: "iana"
      },
      "application/atfx": {
        source: "iana"
      },
      "application/atom+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atom"]
      },
      "application/atomcat+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atomcat"]
      },
      "application/atomdeleted+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atomdeleted"]
      },
      "application/atomicmail": {
        source: "iana"
      },
      "application/atomsvc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atomsvc"]
      },
      "application/atsc-dwd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dwd"]
      },
      "application/atsc-dynamic-event-message": {
        source: "iana"
      },
      "application/atsc-held+xml": {
        source: "iana",
        compressible: true,
        extensions: ["held"]
      },
      "application/atsc-rdt+json": {
        source: "iana",
        compressible: true
      },
      "application/atsc-rsat+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rsat"]
      },
      "application/atxml": {
        source: "iana"
      },
      "application/auth-policy+xml": {
        source: "iana",
        compressible: true
      },
      "application/bacnet-xdd+zip": {
        source: "iana",
        compressible: false
      },
      "application/batch-smtp": {
        source: "iana"
      },
      "application/bdoc": {
        compressible: false,
        extensions: ["bdoc"]
      },
      "application/beep+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/calendar+json": {
        source: "iana",
        compressible: true
      },
      "application/calendar+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xcs"]
      },
      "application/call-completion": {
        source: "iana"
      },
      "application/cals-1840": {
        source: "iana"
      },
      "application/captive+json": {
        source: "iana",
        compressible: true
      },
      "application/cbor": {
        source: "iana"
      },
      "application/cbor-seq": {
        source: "iana"
      },
      "application/cccex": {
        source: "iana"
      },
      "application/ccmp+xml": {
        source: "iana",
        compressible: true
      },
      "application/ccxml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ccxml"]
      },
      "application/cdfx+xml": {
        source: "iana",
        compressible: true,
        extensions: ["cdfx"]
      },
      "application/cdmi-capability": {
        source: "iana",
        extensions: ["cdmia"]
      },
      "application/cdmi-container": {
        source: "iana",
        extensions: ["cdmic"]
      },
      "application/cdmi-domain": {
        source: "iana",
        extensions: ["cdmid"]
      },
      "application/cdmi-object": {
        source: "iana",
        extensions: ["cdmio"]
      },
      "application/cdmi-queue": {
        source: "iana",
        extensions: ["cdmiq"]
      },
      "application/cdni": {
        source: "iana"
      },
      "application/cea": {
        source: "iana"
      },
      "application/cea-2018+xml": {
        source: "iana",
        compressible: true
      },
      "application/cellml+xml": {
        source: "iana",
        compressible: true
      },
      "application/cfw": {
        source: "iana"
      },
      "application/city+json": {
        source: "iana",
        compressible: true
      },
      "application/clr": {
        source: "iana"
      },
      "application/clue+xml": {
        source: "iana",
        compressible: true
      },
      "application/clue_info+xml": {
        source: "iana",
        compressible: true
      },
      "application/cms": {
        source: "iana"
      },
      "application/cnrp+xml": {
        source: "iana",
        compressible: true
      },
      "application/coap-group+json": {
        source: "iana",
        compressible: true
      },
      "application/coap-payload": {
        source: "iana"
      },
      "application/commonground": {
        source: "iana"
      },
      "application/conference-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/cose": {
        source: "iana"
      },
      "application/cose-key": {
        source: "iana"
      },
      "application/cose-key-set": {
        source: "iana"
      },
      "application/cpl+xml": {
        source: "iana",
        compressible: true,
        extensions: ["cpl"]
      },
      "application/csrattrs": {
        source: "iana"
      },
      "application/csta+xml": {
        source: "iana",
        compressible: true
      },
      "application/cstadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/csvm+json": {
        source: "iana",
        compressible: true
      },
      "application/cu-seeme": {
        source: "apache",
        extensions: ["cu"]
      },
      "application/cwt": {
        source: "iana"
      },
      "application/cybercash": {
        source: "iana"
      },
      "application/dart": {
        compressible: true
      },
      "application/dash+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpd"]
      },
      "application/dash-patch+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpp"]
      },
      "application/dashdelta": {
        source: "iana"
      },
      "application/davmount+xml": {
        source: "iana",
        compressible: true,
        extensions: ["davmount"]
      },
      "application/dca-rft": {
        source: "iana"
      },
      "application/dcd": {
        source: "iana"
      },
      "application/dec-dx": {
        source: "iana"
      },
      "application/dialog-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/dicom": {
        source: "iana"
      },
      "application/dicom+json": {
        source: "iana",
        compressible: true
      },
      "application/dicom+xml": {
        source: "iana",
        compressible: true
      },
      "application/dii": {
        source: "iana"
      },
      "application/dit": {
        source: "iana"
      },
      "application/dns": {
        source: "iana"
      },
      "application/dns+json": {
        source: "iana",
        compressible: true
      },
      "application/dns-message": {
        source: "iana"
      },
      "application/docbook+xml": {
        source: "apache",
        compressible: true,
        extensions: ["dbk"]
      },
      "application/dots+cbor": {
        source: "iana"
      },
      "application/dskpp+xml": {
        source: "iana",
        compressible: true
      },
      "application/dssc+der": {
        source: "iana",
        extensions: ["dssc"]
      },
      "application/dssc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdssc"]
      },
      "application/dvcs": {
        source: "iana"
      },
      "application/ecmascript": {
        source: "iana",
        compressible: true,
        extensions: ["es", "ecma"]
      },
      "application/edi-consent": {
        source: "iana"
      },
      "application/edi-x12": {
        source: "iana",
        compressible: false
      },
      "application/edifact": {
        source: "iana",
        compressible: false
      },
      "application/efi": {
        source: "iana"
      },
      "application/elm+json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/elm+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.cap+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/emergencycalldata.comment+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.control+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.deviceinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.ecall.msd": {
        source: "iana"
      },
      "application/emergencycalldata.providerinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.serviceinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.subscriberinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.veds+xml": {
        source: "iana",
        compressible: true
      },
      "application/emma+xml": {
        source: "iana",
        compressible: true,
        extensions: ["emma"]
      },
      "application/emotionml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["emotionml"]
      },
      "application/encaprtp": {
        source: "iana"
      },
      "application/epp+xml": {
        source: "iana",
        compressible: true
      },
      "application/epub+zip": {
        source: "iana",
        compressible: false,
        extensions: ["epub"]
      },
      "application/eshop": {
        source: "iana"
      },
      "application/exi": {
        source: "iana",
        extensions: ["exi"]
      },
      "application/expect-ct-report+json": {
        source: "iana",
        compressible: true
      },
      "application/express": {
        source: "iana",
        extensions: ["exp"]
      },
      "application/fastinfoset": {
        source: "iana"
      },
      "application/fastsoap": {
        source: "iana"
      },
      "application/fdt+xml": {
        source: "iana",
        compressible: true,
        extensions: ["fdt"]
      },
      "application/fhir+json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/fhir+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/fido.trusted-apps+json": {
        compressible: true
      },
      "application/fits": {
        source: "iana"
      },
      "application/flexfec": {
        source: "iana"
      },
      "application/font-sfnt": {
        source: "iana"
      },
      "application/font-tdpfr": {
        source: "iana",
        extensions: ["pfr"]
      },
      "application/font-woff": {
        source: "iana",
        compressible: false
      },
      "application/framework-attributes+xml": {
        source: "iana",
        compressible: true
      },
      "application/geo+json": {
        source: "iana",
        compressible: true,
        extensions: ["geojson"]
      },
      "application/geo+json-seq": {
        source: "iana"
      },
      "application/geopackage+sqlite3": {
        source: "iana"
      },
      "application/geoxacml+xml": {
        source: "iana",
        compressible: true
      },
      "application/gltf-buffer": {
        source: "iana"
      },
      "application/gml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["gml"]
      },
      "application/gpx+xml": {
        source: "apache",
        compressible: true,
        extensions: ["gpx"]
      },
      "application/gxf": {
        source: "apache",
        extensions: ["gxf"]
      },
      "application/gzip": {
        source: "iana",
        compressible: false,
        extensions: ["gz"]
      },
      "application/h224": {
        source: "iana"
      },
      "application/held+xml": {
        source: "iana",
        compressible: true
      },
      "application/hjson": {
        extensions: ["hjson"]
      },
      "application/http": {
        source: "iana"
      },
      "application/hyperstudio": {
        source: "iana",
        extensions: ["stk"]
      },
      "application/ibe-key-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/ibe-pkg-reply+xml": {
        source: "iana",
        compressible: true
      },
      "application/ibe-pp-data": {
        source: "iana"
      },
      "application/iges": {
        source: "iana"
      },
      "application/im-iscomposing+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/index": {
        source: "iana"
      },
      "application/index.cmd": {
        source: "iana"
      },
      "application/index.obj": {
        source: "iana"
      },
      "application/index.response": {
        source: "iana"
      },
      "application/index.vnd": {
        source: "iana"
      },
      "application/inkml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ink", "inkml"]
      },
      "application/iotp": {
        source: "iana"
      },
      "application/ipfix": {
        source: "iana",
        extensions: ["ipfix"]
      },
      "application/ipp": {
        source: "iana"
      },
      "application/isup": {
        source: "iana"
      },
      "application/its+xml": {
        source: "iana",
        compressible: true,
        extensions: ["its"]
      },
      "application/java-archive": {
        source: "apache",
        compressible: false,
        extensions: ["jar", "war", "ear"]
      },
      "application/java-serialized-object": {
        source: "apache",
        compressible: false,
        extensions: ["ser"]
      },
      "application/java-vm": {
        source: "apache",
        compressible: false,
        extensions: ["class"]
      },
      "application/javascript": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["js", "mjs"]
      },
      "application/jf2feed+json": {
        source: "iana",
        compressible: true
      },
      "application/jose": {
        source: "iana"
      },
      "application/jose+json": {
        source: "iana",
        compressible: true
      },
      "application/jrd+json": {
        source: "iana",
        compressible: true
      },
      "application/jscalendar+json": {
        source: "iana",
        compressible: true
      },
      "application/json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["json", "map"]
      },
      "application/json-patch+json": {
        source: "iana",
        compressible: true
      },
      "application/json-seq": {
        source: "iana"
      },
      "application/json5": {
        extensions: ["json5"]
      },
      "application/jsonml+json": {
        source: "apache",
        compressible: true,
        extensions: ["jsonml"]
      },
      "application/jwk+json": {
        source: "iana",
        compressible: true
      },
      "application/jwk-set+json": {
        source: "iana",
        compressible: true
      },
      "application/jwt": {
        source: "iana"
      },
      "application/kpml-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/kpml-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/ld+json": {
        source: "iana",
        compressible: true,
        extensions: ["jsonld"]
      },
      "application/lgr+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lgr"]
      },
      "application/link-format": {
        source: "iana"
      },
      "application/load-control+xml": {
        source: "iana",
        compressible: true
      },
      "application/lost+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lostxml"]
      },
      "application/lostsync+xml": {
        source: "iana",
        compressible: true
      },
      "application/lpf+zip": {
        source: "iana",
        compressible: false
      },
      "application/lxf": {
        source: "iana"
      },
      "application/mac-binhex40": {
        source: "iana",
        extensions: ["hqx"]
      },
      "application/mac-compactpro": {
        source: "apache",
        extensions: ["cpt"]
      },
      "application/macwriteii": {
        source: "iana"
      },
      "application/mads+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mads"]
      },
      "application/manifest+json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["webmanifest"]
      },
      "application/marc": {
        source: "iana",
        extensions: ["mrc"]
      },
      "application/marcxml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mrcx"]
      },
      "application/mathematica": {
        source: "iana",
        extensions: ["ma", "nb", "mb"]
      },
      "application/mathml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mathml"]
      },
      "application/mathml-content+xml": {
        source: "iana",
        compressible: true
      },
      "application/mathml-presentation+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-associated-procedure-description+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-deregister+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-envelope+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-msk+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-msk-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-protection-description+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-reception-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-register+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-register-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-schedule+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-user-service-description+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbox": {
        source: "iana",
        extensions: ["mbox"]
      },
      "application/media-policy-dataset+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpf"]
      },
      "application/media_control+xml": {
        source: "iana",
        compressible: true
      },
      "application/mediaservercontrol+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mscml"]
      },
      "application/merge-patch+json": {
        source: "iana",
        compressible: true
      },
      "application/metalink+xml": {
        source: "apache",
        compressible: true,
        extensions: ["metalink"]
      },
      "application/metalink4+xml": {
        source: "iana",
        compressible: true,
        extensions: ["meta4"]
      },
      "application/mets+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mets"]
      },
      "application/mf4": {
        source: "iana"
      },
      "application/mikey": {
        source: "iana"
      },
      "application/mipc": {
        source: "iana"
      },
      "application/missing-blocks+cbor-seq": {
        source: "iana"
      },
      "application/mmt-aei+xml": {
        source: "iana",
        compressible: true,
        extensions: ["maei"]
      },
      "application/mmt-usd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["musd"]
      },
      "application/mods+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mods"]
      },
      "application/moss-keys": {
        source: "iana"
      },
      "application/moss-signature": {
        source: "iana"
      },
      "application/mosskey-data": {
        source: "iana"
      },
      "application/mosskey-request": {
        source: "iana"
      },
      "application/mp21": {
        source: "iana",
        extensions: ["m21", "mp21"]
      },
      "application/mp4": {
        source: "iana",
        extensions: ["mp4s", "m4p"]
      },
      "application/mpeg4-generic": {
        source: "iana"
      },
      "application/mpeg4-iod": {
        source: "iana"
      },
      "application/mpeg4-iod-xmt": {
        source: "iana"
      },
      "application/mrb-consumer+xml": {
        source: "iana",
        compressible: true
      },
      "application/mrb-publish+xml": {
        source: "iana",
        compressible: true
      },
      "application/msc-ivr+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/msc-mixer+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/msword": {
        source: "iana",
        compressible: false,
        extensions: ["doc", "dot"]
      },
      "application/mud+json": {
        source: "iana",
        compressible: true
      },
      "application/multipart-core": {
        source: "iana"
      },
      "application/mxf": {
        source: "iana",
        extensions: ["mxf"]
      },
      "application/n-quads": {
        source: "iana",
        extensions: ["nq"]
      },
      "application/n-triples": {
        source: "iana",
        extensions: ["nt"]
      },
      "application/nasdata": {
        source: "iana"
      },
      "application/news-checkgroups": {
        source: "iana",
        charset: "US-ASCII"
      },
      "application/news-groupinfo": {
        source: "iana",
        charset: "US-ASCII"
      },
      "application/news-transmission": {
        source: "iana"
      },
      "application/nlsml+xml": {
        source: "iana",
        compressible: true
      },
      "application/node": {
        source: "iana",
        extensions: ["cjs"]
      },
      "application/nss": {
        source: "iana"
      },
      "application/oauth-authz-req+jwt": {
        source: "iana"
      },
      "application/oblivious-dns-message": {
        source: "iana"
      },
      "application/ocsp-request": {
        source: "iana"
      },
      "application/ocsp-response": {
        source: "iana"
      },
      "application/octet-stream": {
        source: "iana",
        compressible: false,
        extensions: ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"]
      },
      "application/oda": {
        source: "iana",
        extensions: ["oda"]
      },
      "application/odm+xml": {
        source: "iana",
        compressible: true
      },
      "application/odx": {
        source: "iana"
      },
      "application/oebps-package+xml": {
        source: "iana",
        compressible: true,
        extensions: ["opf"]
      },
      "application/ogg": {
        source: "iana",
        compressible: false,
        extensions: ["ogx"]
      },
      "application/omdoc+xml": {
        source: "apache",
        compressible: true,
        extensions: ["omdoc"]
      },
      "application/onenote": {
        source: "apache",
        extensions: ["onetoc", "onetoc2", "onetmp", "onepkg"]
      },
      "application/opc-nodeset+xml": {
        source: "iana",
        compressible: true
      },
      "application/oscore": {
        source: "iana"
      },
      "application/oxps": {
        source: "iana",
        extensions: ["oxps"]
      },
      "application/p21": {
        source: "iana"
      },
      "application/p21+zip": {
        source: "iana",
        compressible: false
      },
      "application/p2p-overlay+xml": {
        source: "iana",
        compressible: true,
        extensions: ["relo"]
      },
      "application/parityfec": {
        source: "iana"
      },
      "application/passport": {
        source: "iana"
      },
      "application/patch-ops-error+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xer"]
      },
      "application/pdf": {
        source: "iana",
        compressible: false,
        extensions: ["pdf"]
      },
      "application/pdx": {
        source: "iana"
      },
      "application/pem-certificate-chain": {
        source: "iana"
      },
      "application/pgp-encrypted": {
        source: "iana",
        compressible: false,
        extensions: ["pgp"]
      },
      "application/pgp-keys": {
        source: "iana",
        extensions: ["asc"]
      },
      "application/pgp-signature": {
        source: "iana",
        extensions: ["asc", "sig"]
      },
      "application/pics-rules": {
        source: "apache",
        extensions: ["prf"]
      },
      "application/pidf+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/pidf-diff+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/pkcs10": {
        source: "iana",
        extensions: ["p10"]
      },
      "application/pkcs12": {
        source: "iana"
      },
      "application/pkcs7-mime": {
        source: "iana",
        extensions: ["p7m", "p7c"]
      },
      "application/pkcs7-signature": {
        source: "iana",
        extensions: ["p7s"]
      },
      "application/pkcs8": {
        source: "iana",
        extensions: ["p8"]
      },
      "application/pkcs8-encrypted": {
        source: "iana"
      },
      "application/pkix-attr-cert": {
        source: "iana",
        extensions: ["ac"]
      },
      "application/pkix-cert": {
        source: "iana",
        extensions: ["cer"]
      },
      "application/pkix-crl": {
        source: "iana",
        extensions: ["crl"]
      },
      "application/pkix-pkipath": {
        source: "iana",
        extensions: ["pkipath"]
      },
      "application/pkixcmp": {
        source: "iana",
        extensions: ["pki"]
      },
      "application/pls+xml": {
        source: "iana",
        compressible: true,
        extensions: ["pls"]
      },
      "application/poc-settings+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/postscript": {
        source: "iana",
        compressible: true,
        extensions: ["ai", "eps", "ps"]
      },
      "application/ppsp-tracker+json": {
        source: "iana",
        compressible: true
      },
      "application/problem+json": {
        source: "iana",
        compressible: true
      },
      "application/problem+xml": {
        source: "iana",
        compressible: true
      },
      "application/provenance+xml": {
        source: "iana",
        compressible: true,
        extensions: ["provx"]
      },
      "application/prs.alvestrand.titrax-sheet": {
        source: "iana"
      },
      "application/prs.cww": {
        source: "iana",
        extensions: ["cww"]
      },
      "application/prs.cyn": {
        source: "iana",
        charset: "7-BIT"
      },
      "application/prs.hpub+zip": {
        source: "iana",
        compressible: false
      },
      "application/prs.nprend": {
        source: "iana"
      },
      "application/prs.plucker": {
        source: "iana"
      },
      "application/prs.rdf-xml-crypt": {
        source: "iana"
      },
      "application/prs.xsf+xml": {
        source: "iana",
        compressible: true
      },
      "application/pskc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["pskcxml"]
      },
      "application/pvd+json": {
        source: "iana",
        compressible: true
      },
      "application/qsig": {
        source: "iana"
      },
      "application/raml+yaml": {
        compressible: true,
        extensions: ["raml"]
      },
      "application/raptorfec": {
        source: "iana"
      },
      "application/rdap+json": {
        source: "iana",
        compressible: true
      },
      "application/rdf+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rdf", "owl"]
      },
      "application/reginfo+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rif"]
      },
      "application/relax-ng-compact-syntax": {
        source: "iana",
        extensions: ["rnc"]
      },
      "application/remote-printing": {
        source: "iana"
      },
      "application/reputon+json": {
        source: "iana",
        compressible: true
      },
      "application/resource-lists+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rl"]
      },
      "application/resource-lists-diff+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rld"]
      },
      "application/rfc+xml": {
        source: "iana",
        compressible: true
      },
      "application/riscos": {
        source: "iana"
      },
      "application/rlmi+xml": {
        source: "iana",
        compressible: true
      },
      "application/rls-services+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rs"]
      },
      "application/route-apd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rapd"]
      },
      "application/route-s-tsid+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sls"]
      },
      "application/route-usd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rusd"]
      },
      "application/rpki-ghostbusters": {
        source: "iana",
        extensions: ["gbr"]
      },
      "application/rpki-manifest": {
        source: "iana",
        extensions: ["mft"]
      },
      "application/rpki-publication": {
        source: "iana"
      },
      "application/rpki-roa": {
        source: "iana",
        extensions: ["roa"]
      },
      "application/rpki-updown": {
        source: "iana"
      },
      "application/rsd+xml": {
        source: "apache",
        compressible: true,
        extensions: ["rsd"]
      },
      "application/rss+xml": {
        source: "apache",
        compressible: true,
        extensions: ["rss"]
      },
      "application/rtf": {
        source: "iana",
        compressible: true,
        extensions: ["rtf"]
      },
      "application/rtploopback": {
        source: "iana"
      },
      "application/rtx": {
        source: "iana"
      },
      "application/samlassertion+xml": {
        source: "iana",
        compressible: true
      },
      "application/samlmetadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/sarif+json": {
        source: "iana",
        compressible: true
      },
      "application/sarif-external-properties+json": {
        source: "iana",
        compressible: true
      },
      "application/sbe": {
        source: "iana"
      },
      "application/sbml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sbml"]
      },
      "application/scaip+xml": {
        source: "iana",
        compressible: true
      },
      "application/scim+json": {
        source: "iana",
        compressible: true
      },
      "application/scvp-cv-request": {
        source: "iana",
        extensions: ["scq"]
      },
      "application/scvp-cv-response": {
        source: "iana",
        extensions: ["scs"]
      },
      "application/scvp-vp-request": {
        source: "iana",
        extensions: ["spq"]
      },
      "application/scvp-vp-response": {
        source: "iana",
        extensions: ["spp"]
      },
      "application/sdp": {
        source: "iana",
        extensions: ["sdp"]
      },
      "application/secevent+jwt": {
        source: "iana"
      },
      "application/senml+cbor": {
        source: "iana"
      },
      "application/senml+json": {
        source: "iana",
        compressible: true
      },
      "application/senml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["senmlx"]
      },
      "application/senml-etch+cbor": {
        source: "iana"
      },
      "application/senml-etch+json": {
        source: "iana",
        compressible: true
      },
      "application/senml-exi": {
        source: "iana"
      },
      "application/sensml+cbor": {
        source: "iana"
      },
      "application/sensml+json": {
        source: "iana",
        compressible: true
      },
      "application/sensml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sensmlx"]
      },
      "application/sensml-exi": {
        source: "iana"
      },
      "application/sep+xml": {
        source: "iana",
        compressible: true
      },
      "application/sep-exi": {
        source: "iana"
      },
      "application/session-info": {
        source: "iana"
      },
      "application/set-payment": {
        source: "iana"
      },
      "application/set-payment-initiation": {
        source: "iana",
        extensions: ["setpay"]
      },
      "application/set-registration": {
        source: "iana"
      },
      "application/set-registration-initiation": {
        source: "iana",
        extensions: ["setreg"]
      },
      "application/sgml": {
        source: "iana"
      },
      "application/sgml-open-catalog": {
        source: "iana"
      },
      "application/shf+xml": {
        source: "iana",
        compressible: true,
        extensions: ["shf"]
      },
      "application/sieve": {
        source: "iana",
        extensions: ["siv", "sieve"]
      },
      "application/simple-filter+xml": {
        source: "iana",
        compressible: true
      },
      "application/simple-message-summary": {
        source: "iana"
      },
      "application/simplesymbolcontainer": {
        source: "iana"
      },
      "application/sipc": {
        source: "iana"
      },
      "application/slate": {
        source: "iana"
      },
      "application/smil": {
        source: "iana"
      },
      "application/smil+xml": {
        source: "iana",
        compressible: true,
        extensions: ["smi", "smil"]
      },
      "application/smpte336m": {
        source: "iana"
      },
      "application/soap+fastinfoset": {
        source: "iana"
      },
      "application/soap+xml": {
        source: "iana",
        compressible: true
      },
      "application/sparql-query": {
        source: "iana",
        extensions: ["rq"]
      },
      "application/sparql-results+xml": {
        source: "iana",
        compressible: true,
        extensions: ["srx"]
      },
      "application/spdx+json": {
        source: "iana",
        compressible: true
      },
      "application/spirits-event+xml": {
        source: "iana",
        compressible: true
      },
      "application/sql": {
        source: "iana"
      },
      "application/srgs": {
        source: "iana",
        extensions: ["gram"]
      },
      "application/srgs+xml": {
        source: "iana",
        compressible: true,
        extensions: ["grxml"]
      },
      "application/sru+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sru"]
      },
      "application/ssdl+xml": {
        source: "apache",
        compressible: true,
        extensions: ["ssdl"]
      },
      "application/ssml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ssml"]
      },
      "application/stix+json": {
        source: "iana",
        compressible: true
      },
      "application/swid+xml": {
        source: "iana",
        compressible: true,
        extensions: ["swidtag"]
      },
      "application/tamp-apex-update": {
        source: "iana"
      },
      "application/tamp-apex-update-confirm": {
        source: "iana"
      },
      "application/tamp-community-update": {
        source: "iana"
      },
      "application/tamp-community-update-confirm": {
        source: "iana"
      },
      "application/tamp-error": {
        source: "iana"
      },
      "application/tamp-sequence-adjust": {
        source: "iana"
      },
      "application/tamp-sequence-adjust-confirm": {
        source: "iana"
      },
      "application/tamp-status-query": {
        source: "iana"
      },
      "application/tamp-status-response": {
        source: "iana"
      },
      "application/tamp-update": {
        source: "iana"
      },
      "application/tamp-update-confirm": {
        source: "iana"
      },
      "application/tar": {
        compressible: true
      },
      "application/taxii+json": {
        source: "iana",
        compressible: true
      },
      "application/td+json": {
        source: "iana",
        compressible: true
      },
      "application/tei+xml": {
        source: "iana",
        compressible: true,
        extensions: ["tei", "teicorpus"]
      },
      "application/tetra_isi": {
        source: "iana"
      },
      "application/thraud+xml": {
        source: "iana",
        compressible: true,
        extensions: ["tfi"]
      },
      "application/timestamp-query": {
        source: "iana"
      },
      "application/timestamp-reply": {
        source: "iana"
      },
      "application/timestamped-data": {
        source: "iana",
        extensions: ["tsd"]
      },
      "application/tlsrpt+gzip": {
        source: "iana"
      },
      "application/tlsrpt+json": {
        source: "iana",
        compressible: true
      },
      "application/tnauthlist": {
        source: "iana"
      },
      "application/token-introspection+jwt": {
        source: "iana"
      },
      "application/toml": {
        compressible: true,
        extensions: ["toml"]
      },
      "application/trickle-ice-sdpfrag": {
        source: "iana"
      },
      "application/trig": {
        source: "iana",
        extensions: ["trig"]
      },
      "application/ttml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ttml"]
      },
      "application/tve-trigger": {
        source: "iana"
      },
      "application/tzif": {
        source: "iana"
      },
      "application/tzif-leap": {
        source: "iana"
      },
      "application/ubjson": {
        compressible: false,
        extensions: ["ubj"]
      },
      "application/ulpfec": {
        source: "iana"
      },
      "application/urc-grpsheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/urc-ressheet+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rsheet"]
      },
      "application/urc-targetdesc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["td"]
      },
      "application/urc-uisocketdesc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vcard+json": {
        source: "iana",
        compressible: true
      },
      "application/vcard+xml": {
        source: "iana",
        compressible: true
      },
      "application/vemmi": {
        source: "iana"
      },
      "application/vividence.scriptfile": {
        source: "apache"
      },
      "application/vnd.1000minds.decision-model+xml": {
        source: "iana",
        compressible: true,
        extensions: ["1km"]
      },
      "application/vnd.3gpp-prose+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp-prose-pc3ch+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp-v2x-local-service-information": {
        source: "iana"
      },
      "application/vnd.3gpp.5gnas": {
        source: "iana"
      },
      "application/vnd.3gpp.access-transfer-events+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.bsf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.gmop+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.gtpc": {
        source: "iana"
      },
      "application/vnd.3gpp.interworking-data": {
        source: "iana"
      },
      "application/vnd.3gpp.lpp": {
        source: "iana"
      },
      "application/vnd.3gpp.mc-signalling-ear": {
        source: "iana"
      },
      "application/vnd.3gpp.mcdata-affiliation-command+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-payload": {
        source: "iana"
      },
      "application/vnd.3gpp.mcdata-service-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-signalling": {
        source: "iana"
      },
      "application/vnd.3gpp.mcdata-ue-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-user-profile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-affiliation-command+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-floor-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-location-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-mbms-usage-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-service-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-signed+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-ue-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-ue-init-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-user-profile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-affiliation-command+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-affiliation-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-location-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-service-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-transmission-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-ue-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-user-profile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mid-call+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.ngap": {
        source: "iana"
      },
      "application/vnd.3gpp.pfcp": {
        source: "iana"
      },
      "application/vnd.3gpp.pic-bw-large": {
        source: "iana",
        extensions: ["plb"]
      },
      "application/vnd.3gpp.pic-bw-small": {
        source: "iana",
        extensions: ["psb"]
      },
      "application/vnd.3gpp.pic-bw-var": {
        source: "iana",
        extensions: ["pvb"]
      },
      "application/vnd.3gpp.s1ap": {
        source: "iana"
      },
      "application/vnd.3gpp.sms": {
        source: "iana"
      },
      "application/vnd.3gpp.sms+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.srvcc-ext+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.srvcc-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.state-and-event-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.ussd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp2.bcmcsinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp2.sms": {
        source: "iana"
      },
      "application/vnd.3gpp2.tcap": {
        source: "iana",
        extensions: ["tcap"]
      },
      "application/vnd.3lightssoftware.imagescal": {
        source: "iana"
      },
      "application/vnd.3m.post-it-notes": {
        source: "iana",
        extensions: ["pwn"]
      },
      "application/vnd.accpac.simply.aso": {
        source: "iana",
        extensions: ["aso"]
      },
      "application/vnd.accpac.simply.imp": {
        source: "iana",
        extensions: ["imp"]
      },
      "application/vnd.acucobol": {
        source: "iana",
        extensions: ["acu"]
      },
      "application/vnd.acucorp": {
        source: "iana",
        extensions: ["atc", "acutc"]
      },
      "application/vnd.adobe.air-application-installer-package+zip": {
        source: "apache",
        compressible: false,
        extensions: ["air"]
      },
      "application/vnd.adobe.flash.movie": {
        source: "iana"
      },
      "application/vnd.adobe.formscentral.fcdt": {
        source: "iana",
        extensions: ["fcdt"]
      },
      "application/vnd.adobe.fxp": {
        source: "iana",
        extensions: ["fxp", "fxpl"]
      },
      "application/vnd.adobe.partial-upload": {
        source: "iana"
      },
      "application/vnd.adobe.xdp+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdp"]
      },
      "application/vnd.adobe.xfdf": {
        source: "iana",
        extensions: ["xfdf"]
      },
      "application/vnd.aether.imp": {
        source: "iana"
      },
      "application/vnd.afpc.afplinedata": {
        source: "iana"
      },
      "application/vnd.afpc.afplinedata-pagedef": {
        source: "iana"
      },
      "application/vnd.afpc.cmoca-cmresource": {
        source: "iana"
      },
      "application/vnd.afpc.foca-charset": {
        source: "iana"
      },
      "application/vnd.afpc.foca-codedfont": {
        source: "iana"
      },
      "application/vnd.afpc.foca-codepage": {
        source: "iana"
      },
      "application/vnd.afpc.modca": {
        source: "iana"
      },
      "application/vnd.afpc.modca-cmtable": {
        source: "iana"
      },
      "application/vnd.afpc.modca-formdef": {
        source: "iana"
      },
      "application/vnd.afpc.modca-mediummap": {
        source: "iana"
      },
      "application/vnd.afpc.modca-objectcontainer": {
        source: "iana"
      },
      "application/vnd.afpc.modca-overlay": {
        source: "iana"
      },
      "application/vnd.afpc.modca-pagesegment": {
        source: "iana"
      },
      "application/vnd.age": {
        source: "iana",
        extensions: ["age"]
      },
      "application/vnd.ah-barcode": {
        source: "iana"
      },
      "application/vnd.ahead.space": {
        source: "iana",
        extensions: ["ahead"]
      },
      "application/vnd.airzip.filesecure.azf": {
        source: "iana",
        extensions: ["azf"]
      },
      "application/vnd.airzip.filesecure.azs": {
        source: "iana",
        extensions: ["azs"]
      },
      "application/vnd.amadeus+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.amazon.ebook": {
        source: "apache",
        extensions: ["azw"]
      },
      "application/vnd.amazon.mobi8-ebook": {
        source: "iana"
      },
      "application/vnd.americandynamics.acc": {
        source: "iana",
        extensions: ["acc"]
      },
      "application/vnd.amiga.ami": {
        source: "iana",
        extensions: ["ami"]
      },
      "application/vnd.amundsen.maze+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.android.ota": {
        source: "iana"
      },
      "application/vnd.android.package-archive": {
        source: "apache",
        compressible: false,
        extensions: ["apk"]
      },
      "application/vnd.anki": {
        source: "iana"
      },
      "application/vnd.anser-web-certificate-issue-initiation": {
        source: "iana",
        extensions: ["cii"]
      },
      "application/vnd.anser-web-funds-transfer-initiation": {
        source: "apache",
        extensions: ["fti"]
      },
      "application/vnd.antix.game-component": {
        source: "iana",
        extensions: ["atx"]
      },
      "application/vnd.apache.arrow.file": {
        source: "iana"
      },
      "application/vnd.apache.arrow.stream": {
        source: "iana"
      },
      "application/vnd.apache.thrift.binary": {
        source: "iana"
      },
      "application/vnd.apache.thrift.compact": {
        source: "iana"
      },
      "application/vnd.apache.thrift.json": {
        source: "iana"
      },
      "application/vnd.api+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.aplextor.warrp+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.apothekende.reservation+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.apple.installer+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpkg"]
      },
      "application/vnd.apple.keynote": {
        source: "iana",
        extensions: ["key"]
      },
      "application/vnd.apple.mpegurl": {
        source: "iana",
        extensions: ["m3u8"]
      },
      "application/vnd.apple.numbers": {
        source: "iana",
        extensions: ["numbers"]
      },
      "application/vnd.apple.pages": {
        source: "iana",
        extensions: ["pages"]
      },
      "application/vnd.apple.pkpass": {
        compressible: false,
        extensions: ["pkpass"]
      },
      "application/vnd.arastra.swi": {
        source: "iana"
      },
      "application/vnd.aristanetworks.swi": {
        source: "iana",
        extensions: ["swi"]
      },
      "application/vnd.artisan+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.artsquare": {
        source: "iana"
      },
      "application/vnd.astraea-software.iota": {
        source: "iana",
        extensions: ["iota"]
      },
      "application/vnd.audiograph": {
        source: "iana",
        extensions: ["aep"]
      },
      "application/vnd.autopackage": {
        source: "iana"
      },
      "application/vnd.avalon+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.avistar+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.balsamiq.bmml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["bmml"]
      },
      "application/vnd.balsamiq.bmpr": {
        source: "iana"
      },
      "application/vnd.banana-accounting": {
        source: "iana"
      },
      "application/vnd.bbf.usp.error": {
        source: "iana"
      },
      "application/vnd.bbf.usp.msg": {
        source: "iana"
      },
      "application/vnd.bbf.usp.msg+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.bekitzur-stech+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.bint.med-content": {
        source: "iana"
      },
      "application/vnd.biopax.rdf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.blink-idb-value-wrapper": {
        source: "iana"
      },
      "application/vnd.blueice.multipass": {
        source: "iana",
        extensions: ["mpm"]
      },
      "application/vnd.bluetooth.ep.oob": {
        source: "iana"
      },
      "application/vnd.bluetooth.le.oob": {
        source: "iana"
      },
      "application/vnd.bmi": {
        source: "iana",
        extensions: ["bmi"]
      },
      "application/vnd.bpf": {
        source: "iana"
      },
      "application/vnd.bpf3": {
        source: "iana"
      },
      "application/vnd.businessobjects": {
        source: "iana",
        extensions: ["rep"]
      },
      "application/vnd.byu.uapi+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cab-jscript": {
        source: "iana"
      },
      "application/vnd.canon-cpdl": {
        source: "iana"
      },
      "application/vnd.canon-lips": {
        source: "iana"
      },
      "application/vnd.capasystems-pg+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cendio.thinlinc.clientconf": {
        source: "iana"
      },
      "application/vnd.century-systems.tcp_stream": {
        source: "iana"
      },
      "application/vnd.chemdraw+xml": {
        source: "iana",
        compressible: true,
        extensions: ["cdxml"]
      },
      "application/vnd.chess-pgn": {
        source: "iana"
      },
      "application/vnd.chipnuts.karaoke-mmd": {
        source: "iana",
        extensions: ["mmd"]
      },
      "application/vnd.ciedi": {
        source: "iana"
      },
      "application/vnd.cinderella": {
        source: "iana",
        extensions: ["cdy"]
      },
      "application/vnd.cirpack.isdn-ext": {
        source: "iana"
      },
      "application/vnd.citationstyles.style+xml": {
        source: "iana",
        compressible: true,
        extensions: ["csl"]
      },
      "application/vnd.claymore": {
        source: "iana",
        extensions: ["cla"]
      },
      "application/vnd.cloanto.rp9": {
        source: "iana",
        extensions: ["rp9"]
      },
      "application/vnd.clonk.c4group": {
        source: "iana",
        extensions: ["c4g", "c4d", "c4f", "c4p", "c4u"]
      },
      "application/vnd.cluetrust.cartomobile-config": {
        source: "iana",
        extensions: ["c11amc"]
      },
      "application/vnd.cluetrust.cartomobile-config-pkg": {
        source: "iana",
        extensions: ["c11amz"]
      },
      "application/vnd.coffeescript": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.document": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.document-template": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.presentation": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.presentation-template": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.spreadsheet": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.spreadsheet-template": {
        source: "iana"
      },
      "application/vnd.collection+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.collection.doc+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.collection.next+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.comicbook+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.comicbook-rar": {
        source: "iana"
      },
      "application/vnd.commerce-battelle": {
        source: "iana"
      },
      "application/vnd.commonspace": {
        source: "iana",
        extensions: ["csp"]
      },
      "application/vnd.contact.cmsg": {
        source: "iana",
        extensions: ["cdbcmsg"]
      },
      "application/vnd.coreos.ignition+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cosmocaller": {
        source: "iana",
        extensions: ["cmc"]
      },
      "application/vnd.crick.clicker": {
        source: "iana",
        extensions: ["clkx"]
      },
      "application/vnd.crick.clicker.keyboard": {
        source: "iana",
        extensions: ["clkk"]
      },
      "application/vnd.crick.clicker.palette": {
        source: "iana",
        extensions: ["clkp"]
      },
      "application/vnd.crick.clicker.template": {
        source: "iana",
        extensions: ["clkt"]
      },
      "application/vnd.crick.clicker.wordbank": {
        source: "iana",
        extensions: ["clkw"]
      },
      "application/vnd.criticaltools.wbs+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wbs"]
      },
      "application/vnd.cryptii.pipe+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.crypto-shade-file": {
        source: "iana"
      },
      "application/vnd.cryptomator.encrypted": {
        source: "iana"
      },
      "application/vnd.cryptomator.vault": {
        source: "iana"
      },
      "application/vnd.ctc-posml": {
        source: "iana",
        extensions: ["pml"]
      },
      "application/vnd.ctct.ws+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cups-pdf": {
        source: "iana"
      },
      "application/vnd.cups-postscript": {
        source: "iana"
      },
      "application/vnd.cups-ppd": {
        source: "iana",
        extensions: ["ppd"]
      },
      "application/vnd.cups-raster": {
        source: "iana"
      },
      "application/vnd.cups-raw": {
        source: "iana"
      },
      "application/vnd.curl": {
        source: "iana"
      },
      "application/vnd.curl.car": {
        source: "apache",
        extensions: ["car"]
      },
      "application/vnd.curl.pcurl": {
        source: "apache",
        extensions: ["pcurl"]
      },
      "application/vnd.cyan.dean.root+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cybank": {
        source: "iana"
      },
      "application/vnd.cyclonedx+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cyclonedx+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.d2l.coursepackage1p0+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.d3m-dataset": {
        source: "iana"
      },
      "application/vnd.d3m-problem": {
        source: "iana"
      },
      "application/vnd.dart": {
        source: "iana",
        compressible: true,
        extensions: ["dart"]
      },
      "application/vnd.data-vision.rdz": {
        source: "iana",
        extensions: ["rdz"]
      },
      "application/vnd.datapackage+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dataresource+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dbf": {
        source: "iana",
        extensions: ["dbf"]
      },
      "application/vnd.debian.binary-package": {
        source: "iana"
      },
      "application/vnd.dece.data": {
        source: "iana",
        extensions: ["uvf", "uvvf", "uvd", "uvvd"]
      },
      "application/vnd.dece.ttml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["uvt", "uvvt"]
      },
      "application/vnd.dece.unspecified": {
        source: "iana",
        extensions: ["uvx", "uvvx"]
      },
      "application/vnd.dece.zip": {
        source: "iana",
        extensions: ["uvz", "uvvz"]
      },
      "application/vnd.denovo.fcselayout-link": {
        source: "iana",
        extensions: ["fe_launch"]
      },
      "application/vnd.desmume.movie": {
        source: "iana"
      },
      "application/vnd.dir-bi.plate-dl-nosuffix": {
        source: "iana"
      },
      "application/vnd.dm.delegation+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dna": {
        source: "iana",
        extensions: ["dna"]
      },
      "application/vnd.document+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dolby.mlp": {
        source: "apache",
        extensions: ["mlp"]
      },
      "application/vnd.dolby.mobile.1": {
        source: "iana"
      },
      "application/vnd.dolby.mobile.2": {
        source: "iana"
      },
      "application/vnd.doremir.scorecloud-binary-document": {
        source: "iana"
      },
      "application/vnd.dpgraph": {
        source: "iana",
        extensions: ["dpg"]
      },
      "application/vnd.dreamfactory": {
        source: "iana",
        extensions: ["dfac"]
      },
      "application/vnd.drive+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ds-keypoint": {
        source: "apache",
        extensions: ["kpxx"]
      },
      "application/vnd.dtg.local": {
        source: "iana"
      },
      "application/vnd.dtg.local.flash": {
        source: "iana"
      },
      "application/vnd.dtg.local.html": {
        source: "iana"
      },
      "application/vnd.dvb.ait": {
        source: "iana",
        extensions: ["ait"]
      },
      "application/vnd.dvb.dvbisl+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.dvbj": {
        source: "iana"
      },
      "application/vnd.dvb.esgcontainer": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcdftnotifaccess": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcesgaccess": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcesgaccess2": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcesgpdd": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcroaming": {
        source: "iana"
      },
      "application/vnd.dvb.iptv.alfec-base": {
        source: "iana"
      },
      "application/vnd.dvb.iptv.alfec-enhancement": {
        source: "iana"
      },
      "application/vnd.dvb.notif-aggregate-root+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-container+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-generic+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-ia-msglist+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-ia-registration-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-ia-registration-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-init+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.pfr": {
        source: "iana"
      },
      "application/vnd.dvb.service": {
        source: "iana",
        extensions: ["svc"]
      },
      "application/vnd.dxr": {
        source: "iana"
      },
      "application/vnd.dynageo": {
        source: "iana",
        extensions: ["geo"]
      },
      "application/vnd.dzr": {
        source: "iana"
      },
      "application/vnd.easykaraoke.cdgdownload": {
        source: "iana"
      },
      "application/vnd.ecdis-update": {
        source: "iana"
      },
      "application/vnd.ecip.rlp": {
        source: "iana"
      },
      "application/vnd.eclipse.ditto+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ecowin.chart": {
        source: "iana",
        extensions: ["mag"]
      },
      "application/vnd.ecowin.filerequest": {
        source: "iana"
      },
      "application/vnd.ecowin.fileupdate": {
        source: "iana"
      },
      "application/vnd.ecowin.series": {
        source: "iana"
      },
      "application/vnd.ecowin.seriesrequest": {
        source: "iana"
      },
      "application/vnd.ecowin.seriesupdate": {
        source: "iana"
      },
      "application/vnd.efi.img": {
        source: "iana"
      },
      "application/vnd.efi.iso": {
        source: "iana"
      },
      "application/vnd.emclient.accessrequest+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.enliven": {
        source: "iana",
        extensions: ["nml"]
      },
      "application/vnd.enphase.envoy": {
        source: "iana"
      },
      "application/vnd.eprints.data+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.epson.esf": {
        source: "iana",
        extensions: ["esf"]
      },
      "application/vnd.epson.msf": {
        source: "iana",
        extensions: ["msf"]
      },
      "application/vnd.epson.quickanime": {
        source: "iana",
        extensions: ["qam"]
      },
      "application/vnd.epson.salt": {
        source: "iana",
        extensions: ["slt"]
      },
      "application/vnd.epson.ssf": {
        source: "iana",
        extensions: ["ssf"]
      },
      "application/vnd.ericsson.quickcall": {
        source: "iana"
      },
      "application/vnd.espass-espass+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.eszigno3+xml": {
        source: "iana",
        compressible: true,
        extensions: ["es3", "et3"]
      },
      "application/vnd.etsi.aoc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.asic-e+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.etsi.asic-s+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.etsi.cug+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvcommand+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvdiscovery+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsad-bc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsad-cod+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsad-npvr+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvservice+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsync+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvueprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.mcid+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.mheg5": {
        source: "iana"
      },
      "application/vnd.etsi.overload-control-policy-dataset+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.pstn+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.sci+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.simservs+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.timestamp-token": {
        source: "iana"
      },
      "application/vnd.etsi.tsl+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.tsl.der": {
        source: "iana"
      },
      "application/vnd.eu.kasparian.car+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.eudora.data": {
        source: "iana"
      },
      "application/vnd.evolv.ecig.profile": {
        source: "iana"
      },
      "application/vnd.evolv.ecig.settings": {
        source: "iana"
      },
      "application/vnd.evolv.ecig.theme": {
        source: "iana"
      },
      "application/vnd.exstream-empower+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.exstream-package": {
        source: "iana"
      },
      "application/vnd.ezpix-album": {
        source: "iana",
        extensions: ["ez2"]
      },
      "application/vnd.ezpix-package": {
        source: "iana",
        extensions: ["ez3"]
      },
      "application/vnd.f-secure.mobile": {
        source: "iana"
      },
      "application/vnd.familysearch.gedcom+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.fastcopy-disk-image": {
        source: "iana"
      },
      "application/vnd.fdf": {
        source: "iana",
        extensions: ["fdf"]
      },
      "application/vnd.fdsn.mseed": {
        source: "iana",
        extensions: ["mseed"]
      },
      "application/vnd.fdsn.seed": {
        source: "iana",
        extensions: ["seed", "dataless"]
      },
      "application/vnd.ffsns": {
        source: "iana"
      },
      "application/vnd.ficlab.flb+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.filmit.zfc": {
        source: "iana"
      },
      "application/vnd.fints": {
        source: "iana"
      },
      "application/vnd.firemonkeys.cloudcell": {
        source: "iana"
      },
      "application/vnd.flographit": {
        source: "iana",
        extensions: ["gph"]
      },
      "application/vnd.fluxtime.clip": {
        source: "iana",
        extensions: ["ftc"]
      },
      "application/vnd.font-fontforge-sfd": {
        source: "iana"
      },
      "application/vnd.framemaker": {
        source: "iana",
        extensions: ["fm", "frame", "maker", "book"]
      },
      "application/vnd.frogans.fnc": {
        source: "iana",
        extensions: ["fnc"]
      },
      "application/vnd.frogans.ltf": {
        source: "iana",
        extensions: ["ltf"]
      },
      "application/vnd.fsc.weblaunch": {
        source: "iana",
        extensions: ["fsc"]
      },
      "application/vnd.fujifilm.fb.docuworks": {
        source: "iana"
      },
      "application/vnd.fujifilm.fb.docuworks.binder": {
        source: "iana"
      },
      "application/vnd.fujifilm.fb.docuworks.container": {
        source: "iana"
      },
      "application/vnd.fujifilm.fb.jfi+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.fujitsu.oasys": {
        source: "iana",
        extensions: ["oas"]
      },
      "application/vnd.fujitsu.oasys2": {
        source: "iana",
        extensions: ["oa2"]
      },
      "application/vnd.fujitsu.oasys3": {
        source: "iana",
        extensions: ["oa3"]
      },
      "application/vnd.fujitsu.oasysgp": {
        source: "iana",
        extensions: ["fg5"]
      },
      "application/vnd.fujitsu.oasysprs": {
        source: "iana",
        extensions: ["bh2"]
      },
      "application/vnd.fujixerox.art-ex": {
        source: "iana"
      },
      "application/vnd.fujixerox.art4": {
        source: "iana"
      },
      "application/vnd.fujixerox.ddd": {
        source: "iana",
        extensions: ["ddd"]
      },
      "application/vnd.fujixerox.docuworks": {
        source: "iana",
        extensions: ["xdw"]
      },
      "application/vnd.fujixerox.docuworks.binder": {
        source: "iana",
        extensions: ["xbd"]
      },
      "application/vnd.fujixerox.docuworks.container": {
        source: "iana"
      },
      "application/vnd.fujixerox.hbpl": {
        source: "iana"
      },
      "application/vnd.fut-misnet": {
        source: "iana"
      },
      "application/vnd.futoin+cbor": {
        source: "iana"
      },
      "application/vnd.futoin+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.fuzzysheet": {
        source: "iana",
        extensions: ["fzs"]
      },
      "application/vnd.genomatix.tuxedo": {
        source: "iana",
        extensions: ["txd"]
      },
      "application/vnd.gentics.grd+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.geo+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.geocube+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.geogebra.file": {
        source: "iana",
        extensions: ["ggb"]
      },
      "application/vnd.geogebra.slides": {
        source: "iana"
      },
      "application/vnd.geogebra.tool": {
        source: "iana",
        extensions: ["ggt"]
      },
      "application/vnd.geometry-explorer": {
        source: "iana",
        extensions: ["gex", "gre"]
      },
      "application/vnd.geonext": {
        source: "iana",
        extensions: ["gxt"]
      },
      "application/vnd.geoplan": {
        source: "iana",
        extensions: ["g2w"]
      },
      "application/vnd.geospace": {
        source: "iana",
        extensions: ["g3w"]
      },
      "application/vnd.gerber": {
        source: "iana"
      },
      "application/vnd.globalplatform.card-content-mgt": {
        source: "iana"
      },
      "application/vnd.globalplatform.card-content-mgt-response": {
        source: "iana"
      },
      "application/vnd.gmx": {
        source: "iana",
        extensions: ["gmx"]
      },
      "application/vnd.google-apps.document": {
        compressible: false,
        extensions: ["gdoc"]
      },
      "application/vnd.google-apps.presentation": {
        compressible: false,
        extensions: ["gslides"]
      },
      "application/vnd.google-apps.spreadsheet": {
        compressible: false,
        extensions: ["gsheet"]
      },
      "application/vnd.google-earth.kml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["kml"]
      },
      "application/vnd.google-earth.kmz": {
        source: "iana",
        compressible: false,
        extensions: ["kmz"]
      },
      "application/vnd.gov.sk.e-form+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.gov.sk.e-form+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.gov.sk.xmldatacontainer+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.grafeq": {
        source: "iana",
        extensions: ["gqf", "gqs"]
      },
      "application/vnd.gridmp": {
        source: "iana"
      },
      "application/vnd.groove-account": {
        source: "iana",
        extensions: ["gac"]
      },
      "application/vnd.groove-help": {
        source: "iana",
        extensions: ["ghf"]
      },
      "application/vnd.groove-identity-message": {
        source: "iana",
        extensions: ["gim"]
      },
      "application/vnd.groove-injector": {
        source: "iana",
        extensions: ["grv"]
      },
      "application/vnd.groove-tool-message": {
        source: "iana",
        extensions: ["gtm"]
      },
      "application/vnd.groove-tool-template": {
        source: "iana",
        extensions: ["tpl"]
      },
      "application/vnd.groove-vcard": {
        source: "iana",
        extensions: ["vcg"]
      },
      "application/vnd.hal+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hal+xml": {
        source: "iana",
        compressible: true,
        extensions: ["hal"]
      },
      "application/vnd.handheld-entertainment+xml": {
        source: "iana",
        compressible: true,
        extensions: ["zmm"]
      },
      "application/vnd.hbci": {
        source: "iana",
        extensions: ["hbci"]
      },
      "application/vnd.hc+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hcl-bireports": {
        source: "iana"
      },
      "application/vnd.hdt": {
        source: "iana"
      },
      "application/vnd.heroku+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hhe.lesson-player": {
        source: "iana",
        extensions: ["les"]
      },
      "application/vnd.hl7cda+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.hl7v2+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.hp-hpgl": {
        source: "iana",
        extensions: ["hpgl"]
      },
      "application/vnd.hp-hpid": {
        source: "iana",
        extensions: ["hpid"]
      },
      "application/vnd.hp-hps": {
        source: "iana",
        extensions: ["hps"]
      },
      "application/vnd.hp-jlyt": {
        source: "iana",
        extensions: ["jlt"]
      },
      "application/vnd.hp-pcl": {
        source: "iana",
        extensions: ["pcl"]
      },
      "application/vnd.hp-pclxl": {
        source: "iana",
        extensions: ["pclxl"]
      },
      "application/vnd.httphone": {
        source: "iana"
      },
      "application/vnd.hydrostatix.sof-data": {
        source: "iana",
        extensions: ["sfd-hdstx"]
      },
      "application/vnd.hyper+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hyper-item+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hyperdrive+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hzn-3d-crossword": {
        source: "iana"
      },
      "application/vnd.ibm.afplinedata": {
        source: "iana"
      },
      "application/vnd.ibm.electronic-media": {
        source: "iana"
      },
      "application/vnd.ibm.minipay": {
        source: "iana",
        extensions: ["mpy"]
      },
      "application/vnd.ibm.modcap": {
        source: "iana",
        extensions: ["afp", "listafp", "list3820"]
      },
      "application/vnd.ibm.rights-management": {
        source: "iana",
        extensions: ["irm"]
      },
      "application/vnd.ibm.secure-container": {
        source: "iana",
        extensions: ["sc"]
      },
      "application/vnd.iccprofile": {
        source: "iana",
        extensions: ["icc", "icm"]
      },
      "application/vnd.ieee.1905": {
        source: "iana"
      },
      "application/vnd.igloader": {
        source: "iana",
        extensions: ["igl"]
      },
      "application/vnd.imagemeter.folder+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.imagemeter.image+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.immervision-ivp": {
        source: "iana",
        extensions: ["ivp"]
      },
      "application/vnd.immervision-ivu": {
        source: "iana",
        extensions: ["ivu"]
      },
      "application/vnd.ims.imsccv1p1": {
        source: "iana"
      },
      "application/vnd.ims.imsccv1p2": {
        source: "iana"
      },
      "application/vnd.ims.imsccv1p3": {
        source: "iana"
      },
      "application/vnd.ims.lis.v2.result+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolconsumerprofile+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolproxy+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolproxy.id+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolsettings+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolsettings.simple+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.informedcontrol.rms+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.informix-visionary": {
        source: "iana"
      },
      "application/vnd.infotech.project": {
        source: "iana"
      },
      "application/vnd.infotech.project+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.innopath.wamp.notification": {
        source: "iana"
      },
      "application/vnd.insors.igm": {
        source: "iana",
        extensions: ["igm"]
      },
      "application/vnd.intercon.formnet": {
        source: "iana",
        extensions: ["xpw", "xpx"]
      },
      "application/vnd.intergeo": {
        source: "iana",
        extensions: ["i2g"]
      },
      "application/vnd.intertrust.digibox": {
        source: "iana"
      },
      "application/vnd.intertrust.nncp": {
        source: "iana"
      },
      "application/vnd.intu.qbo": {
        source: "iana",
        extensions: ["qbo"]
      },
      "application/vnd.intu.qfx": {
        source: "iana",
        extensions: ["qfx"]
      },
      "application/vnd.iptc.g2.catalogitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.conceptitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.knowledgeitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.newsitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.newsmessage+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.packageitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.planningitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ipunplugged.rcprofile": {
        source: "iana",
        extensions: ["rcprofile"]
      },
      "application/vnd.irepository.package+xml": {
        source: "iana",
        compressible: true,
        extensions: ["irp"]
      },
      "application/vnd.is-xpr": {
        source: "iana",
        extensions: ["xpr"]
      },
      "application/vnd.isac.fcs": {
        source: "iana",
        extensions: ["fcs"]
      },
      "application/vnd.iso11783-10+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.jam": {
        source: "iana",
        extensions: ["jam"]
      },
      "application/vnd.japannet-directory-service": {
        source: "iana"
      },
      "application/vnd.japannet-jpnstore-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-payment-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-registration": {
        source: "iana"
      },
      "application/vnd.japannet-registration-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-setstore-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-verification": {
        source: "iana"
      },
      "application/vnd.japannet-verification-wakeup": {
        source: "iana"
      },
      "application/vnd.jcp.javame.midlet-rms": {
        source: "iana",
        extensions: ["rms"]
      },
      "application/vnd.jisp": {
        source: "iana",
        extensions: ["jisp"]
      },
      "application/vnd.joost.joda-archive": {
        source: "iana",
        extensions: ["joda"]
      },
      "application/vnd.jsk.isdn-ngn": {
        source: "iana"
      },
      "application/vnd.kahootz": {
        source: "iana",
        extensions: ["ktz", "ktr"]
      },
      "application/vnd.kde.karbon": {
        source: "iana",
        extensions: ["karbon"]
      },
      "application/vnd.kde.kchart": {
        source: "iana",
        extensions: ["chrt"]
      },
      "application/vnd.kde.kformula": {
        source: "iana",
        extensions: ["kfo"]
      },
      "application/vnd.kde.kivio": {
        source: "iana",
        extensions: ["flw"]
      },
      "application/vnd.kde.kontour": {
        source: "iana",
        extensions: ["kon"]
      },
      "application/vnd.kde.kpresenter": {
        source: "iana",
        extensions: ["kpr", "kpt"]
      },
      "application/vnd.kde.kspread": {
        source: "iana",
        extensions: ["ksp"]
      },
      "application/vnd.kde.kword": {
        source: "iana",
        extensions: ["kwd", "kwt"]
      },
      "application/vnd.kenameaapp": {
        source: "iana",
        extensions: ["htke"]
      },
      "application/vnd.kidspiration": {
        source: "iana",
        extensions: ["kia"]
      },
      "application/vnd.kinar": {
        source: "iana",
        extensions: ["kne", "knp"]
      },
      "application/vnd.koan": {
        source: "iana",
        extensions: ["skp", "skd", "skt", "skm"]
      },
      "application/vnd.kodak-descriptor": {
        source: "iana",
        extensions: ["sse"]
      },
      "application/vnd.las": {
        source: "iana"
      },
      "application/vnd.las.las+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.las.las+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lasxml"]
      },
      "application/vnd.laszip": {
        source: "iana"
      },
      "application/vnd.leap+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.liberty-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.llamagraphics.life-balance.desktop": {
        source: "iana",
        extensions: ["lbd"]
      },
      "application/vnd.llamagraphics.life-balance.exchange+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lbe"]
      },
      "application/vnd.logipipe.circuit+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.loom": {
        source: "iana"
      },
      "application/vnd.lotus-1-2-3": {
        source: "iana",
        extensions: ["123"]
      },
      "application/vnd.lotus-approach": {
        source: "iana",
        extensions: ["apr"]
      },
      "application/vnd.lotus-freelance": {
        source: "iana",
        extensions: ["pre"]
      },
      "application/vnd.lotus-notes": {
        source: "iana",
        extensions: ["nsf"]
      },
      "application/vnd.lotus-organizer": {
        source: "iana",
        extensions: ["org"]
      },
      "application/vnd.lotus-screencam": {
        source: "iana",
        extensions: ["scm"]
      },
      "application/vnd.lotus-wordpro": {
        source: "iana",
        extensions: ["lwp"]
      },
      "application/vnd.macports.portpkg": {
        source: "iana",
        extensions: ["portpkg"]
      },
      "application/vnd.mapbox-vector-tile": {
        source: "iana",
        extensions: ["mvt"]
      },
      "application/vnd.marlin.drm.actiontoken+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.marlin.drm.conftoken+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.marlin.drm.license+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.marlin.drm.mdcf": {
        source: "iana"
      },
      "application/vnd.mason+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.maxar.archive.3tz+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.maxmind.maxmind-db": {
        source: "iana"
      },
      "application/vnd.mcd": {
        source: "iana",
        extensions: ["mcd"]
      },
      "application/vnd.medcalcdata": {
        source: "iana",
        extensions: ["mc1"]
      },
      "application/vnd.mediastation.cdkey": {
        source: "iana",
        extensions: ["cdkey"]
      },
      "application/vnd.meridian-slingshot": {
        source: "iana"
      },
      "application/vnd.mfer": {
        source: "iana",
        extensions: ["mwf"]
      },
      "application/vnd.mfmp": {
        source: "iana",
        extensions: ["mfm"]
      },
      "application/vnd.micro+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.micrografx.flo": {
        source: "iana",
        extensions: ["flo"]
      },
      "application/vnd.micrografx.igx": {
        source: "iana",
        extensions: ["igx"]
      },
      "application/vnd.microsoft.portable-executable": {
        source: "iana"
      },
      "application/vnd.microsoft.windows.thumbnail-cache": {
        source: "iana"
      },
      "application/vnd.miele+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.mif": {
        source: "iana",
        extensions: ["mif"]
      },
      "application/vnd.minisoft-hp3000-save": {
        source: "iana"
      },
      "application/vnd.mitsubishi.misty-guard.trustweb": {
        source: "iana"
      },
      "application/vnd.mobius.daf": {
        source: "iana",
        extensions: ["daf"]
      },
      "application/vnd.mobius.dis": {
        source: "iana",
        extensions: ["dis"]
      },
      "application/vnd.mobius.mbk": {
        source: "iana",
        extensions: ["mbk"]
      },
      "application/vnd.mobius.mqy": {
        source: "iana",
        extensions: ["mqy"]
      },
      "application/vnd.mobius.msl": {
        source: "iana",
        extensions: ["msl"]
      },
      "application/vnd.mobius.plc": {
        source: "iana",
        extensions: ["plc"]
      },
      "application/vnd.mobius.txf": {
        source: "iana",
        extensions: ["txf"]
      },
      "application/vnd.mophun.application": {
        source: "iana",
        extensions: ["mpn"]
      },
      "application/vnd.mophun.certificate": {
        source: "iana",
        extensions: ["mpc"]
      },
      "application/vnd.motorola.flexsuite": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.adsi": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.fis": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.gotap": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.kmr": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.ttc": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.wem": {
        source: "iana"
      },
      "application/vnd.motorola.iprm": {
        source: "iana"
      },
      "application/vnd.mozilla.xul+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xul"]
      },
      "application/vnd.ms-3mfdocument": {
        source: "iana"
      },
      "application/vnd.ms-artgalry": {
        source: "iana",
        extensions: ["cil"]
      },
      "application/vnd.ms-asf": {
        source: "iana"
      },
      "application/vnd.ms-cab-compressed": {
        source: "iana",
        extensions: ["cab"]
      },
      "application/vnd.ms-color.iccprofile": {
        source: "apache"
      },
      "application/vnd.ms-excel": {
        source: "iana",
        compressible: false,
        extensions: ["xls", "xlm", "xla", "xlc", "xlt", "xlw"]
      },
      "application/vnd.ms-excel.addin.macroenabled.12": {
        source: "iana",
        extensions: ["xlam"]
      },
      "application/vnd.ms-excel.sheet.binary.macroenabled.12": {
        source: "iana",
        extensions: ["xlsb"]
      },
      "application/vnd.ms-excel.sheet.macroenabled.12": {
        source: "iana",
        extensions: ["xlsm"]
      },
      "application/vnd.ms-excel.template.macroenabled.12": {
        source: "iana",
        extensions: ["xltm"]
      },
      "application/vnd.ms-fontobject": {
        source: "iana",
        compressible: true,
        extensions: ["eot"]
      },
      "application/vnd.ms-htmlhelp": {
        source: "iana",
        extensions: ["chm"]
      },
      "application/vnd.ms-ims": {
        source: "iana",
        extensions: ["ims"]
      },
      "application/vnd.ms-lrm": {
        source: "iana",
        extensions: ["lrm"]
      },
      "application/vnd.ms-office.activex+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-officetheme": {
        source: "iana",
        extensions: ["thmx"]
      },
      "application/vnd.ms-opentype": {
        source: "apache",
        compressible: true
      },
      "application/vnd.ms-outlook": {
        compressible: false,
        extensions: ["msg"]
      },
      "application/vnd.ms-package.obfuscated-opentype": {
        source: "apache"
      },
      "application/vnd.ms-pki.seccat": {
        source: "apache",
        extensions: ["cat"]
      },
      "application/vnd.ms-pki.stl": {
        source: "apache",
        extensions: ["stl"]
      },
      "application/vnd.ms-playready.initiator+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-powerpoint": {
        source: "iana",
        compressible: false,
        extensions: ["ppt", "pps", "pot"]
      },
      "application/vnd.ms-powerpoint.addin.macroenabled.12": {
        source: "iana",
        extensions: ["ppam"]
      },
      "application/vnd.ms-powerpoint.presentation.macroenabled.12": {
        source: "iana",
        extensions: ["pptm"]
      },
      "application/vnd.ms-powerpoint.slide.macroenabled.12": {
        source: "iana",
        extensions: ["sldm"]
      },
      "application/vnd.ms-powerpoint.slideshow.macroenabled.12": {
        source: "iana",
        extensions: ["ppsm"]
      },
      "application/vnd.ms-powerpoint.template.macroenabled.12": {
        source: "iana",
        extensions: ["potm"]
      },
      "application/vnd.ms-printdevicecapabilities+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-printing.printticket+xml": {
        source: "apache",
        compressible: true
      },
      "application/vnd.ms-printschematicket+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-project": {
        source: "iana",
        extensions: ["mpp", "mpt"]
      },
      "application/vnd.ms-tnef": {
        source: "iana"
      },
      "application/vnd.ms-windows.devicepairing": {
        source: "iana"
      },
      "application/vnd.ms-windows.nwprinting.oob": {
        source: "iana"
      },
      "application/vnd.ms-windows.printerpairing": {
        source: "iana"
      },
      "application/vnd.ms-windows.wsd.oob": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.lic-chlg-req": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.lic-resp": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.meter-chlg-req": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.meter-resp": {
        source: "iana"
      },
      "application/vnd.ms-word.document.macroenabled.12": {
        source: "iana",
        extensions: ["docm"]
      },
      "application/vnd.ms-word.template.macroenabled.12": {
        source: "iana",
        extensions: ["dotm"]
      },
      "application/vnd.ms-works": {
        source: "iana",
        extensions: ["wps", "wks", "wcm", "wdb"]
      },
      "application/vnd.ms-wpl": {
        source: "iana",
        extensions: ["wpl"]
      },
      "application/vnd.ms-xpsdocument": {
        source: "iana",
        compressible: false,
        extensions: ["xps"]
      },
      "application/vnd.msa-disk-image": {
        source: "iana"
      },
      "application/vnd.mseq": {
        source: "iana",
        extensions: ["mseq"]
      },
      "application/vnd.msign": {
        source: "iana"
      },
      "application/vnd.multiad.creator": {
        source: "iana"
      },
      "application/vnd.multiad.creator.cif": {
        source: "iana"
      },
      "application/vnd.music-niff": {
        source: "iana"
      },
      "application/vnd.musician": {
        source: "iana",
        extensions: ["mus"]
      },
      "application/vnd.muvee.style": {
        source: "iana",
        extensions: ["msty"]
      },
      "application/vnd.mynfc": {
        source: "iana",
        extensions: ["taglet"]
      },
      "application/vnd.nacamar.ybrid+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ncd.control": {
        source: "iana"
      },
      "application/vnd.ncd.reference": {
        source: "iana"
      },
      "application/vnd.nearst.inv+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nebumind.line": {
        source: "iana"
      },
      "application/vnd.nervana": {
        source: "iana"
      },
      "application/vnd.netfpx": {
        source: "iana"
      },
      "application/vnd.neurolanguage.nlu": {
        source: "iana",
        extensions: ["nlu"]
      },
      "application/vnd.nimn": {
        source: "iana"
      },
      "application/vnd.nintendo.nitro.rom": {
        source: "iana"
      },
      "application/vnd.nintendo.snes.rom": {
        source: "iana"
      },
      "application/vnd.nitf": {
        source: "iana",
        extensions: ["ntf", "nitf"]
      },
      "application/vnd.noblenet-directory": {
        source: "iana",
        extensions: ["nnd"]
      },
      "application/vnd.noblenet-sealer": {
        source: "iana",
        extensions: ["nns"]
      },
      "application/vnd.noblenet-web": {
        source: "iana",
        extensions: ["nnw"]
      },
      "application/vnd.nokia.catalogs": {
        source: "iana"
      },
      "application/vnd.nokia.conml+wbxml": {
        source: "iana"
      },
      "application/vnd.nokia.conml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.iptv.config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.isds-radio-presets": {
        source: "iana"
      },
      "application/vnd.nokia.landmark+wbxml": {
        source: "iana"
      },
      "application/vnd.nokia.landmark+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.landmarkcollection+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.n-gage.ac+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ac"]
      },
      "application/vnd.nokia.n-gage.data": {
        source: "iana",
        extensions: ["ngdat"]
      },
      "application/vnd.nokia.n-gage.symbian.install": {
        source: "iana",
        extensions: ["n-gage"]
      },
      "application/vnd.nokia.ncd": {
        source: "iana"
      },
      "application/vnd.nokia.pcd+wbxml": {
        source: "iana"
      },
      "application/vnd.nokia.pcd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.radio-preset": {
        source: "iana",
        extensions: ["rpst"]
      },
      "application/vnd.nokia.radio-presets": {
        source: "iana",
        extensions: ["rpss"]
      },
      "application/vnd.novadigm.edm": {
        source: "iana",
        extensions: ["edm"]
      },
      "application/vnd.novadigm.edx": {
        source: "iana",
        extensions: ["edx"]
      },
      "application/vnd.novadigm.ext": {
        source: "iana",
        extensions: ["ext"]
      },
      "application/vnd.ntt-local.content-share": {
        source: "iana"
      },
      "application/vnd.ntt-local.file-transfer": {
        source: "iana"
      },
      "application/vnd.ntt-local.ogw_remote-access": {
        source: "iana"
      },
      "application/vnd.ntt-local.sip-ta_remote": {
        source: "iana"
      },
      "application/vnd.ntt-local.sip-ta_tcp_stream": {
        source: "iana"
      },
      "application/vnd.oasis.opendocument.chart": {
        source: "iana",
        extensions: ["odc"]
      },
      "application/vnd.oasis.opendocument.chart-template": {
        source: "iana",
        extensions: ["otc"]
      },
      "application/vnd.oasis.opendocument.database": {
        source: "iana",
        extensions: ["odb"]
      },
      "application/vnd.oasis.opendocument.formula": {
        source: "iana",
        extensions: ["odf"]
      },
      "application/vnd.oasis.opendocument.formula-template": {
        source: "iana",
        extensions: ["odft"]
      },
      "application/vnd.oasis.opendocument.graphics": {
        source: "iana",
        compressible: false,
        extensions: ["odg"]
      },
      "application/vnd.oasis.opendocument.graphics-template": {
        source: "iana",
        extensions: ["otg"]
      },
      "application/vnd.oasis.opendocument.image": {
        source: "iana",
        extensions: ["odi"]
      },
      "application/vnd.oasis.opendocument.image-template": {
        source: "iana",
        extensions: ["oti"]
      },
      "application/vnd.oasis.opendocument.presentation": {
        source: "iana",
        compressible: false,
        extensions: ["odp"]
      },
      "application/vnd.oasis.opendocument.presentation-template": {
        source: "iana",
        extensions: ["otp"]
      },
      "application/vnd.oasis.opendocument.spreadsheet": {
        source: "iana",
        compressible: false,
        extensions: ["ods"]
      },
      "application/vnd.oasis.opendocument.spreadsheet-template": {
        source: "iana",
        extensions: ["ots"]
      },
      "application/vnd.oasis.opendocument.text": {
        source: "iana",
        compressible: false,
        extensions: ["odt"]
      },
      "application/vnd.oasis.opendocument.text-master": {
        source: "iana",
        extensions: ["odm"]
      },
      "application/vnd.oasis.opendocument.text-template": {
        source: "iana",
        extensions: ["ott"]
      },
      "application/vnd.oasis.opendocument.text-web": {
        source: "iana",
        extensions: ["oth"]
      },
      "application/vnd.obn": {
        source: "iana"
      },
      "application/vnd.ocf+cbor": {
        source: "iana"
      },
      "application/vnd.oci.image.manifest.v1+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oftn.l10n+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.contentaccessdownload+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.contentaccessstreaming+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.cspg-hexbinary": {
        source: "iana"
      },
      "application/vnd.oipf.dae.svg+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.dae.xhtml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.mippvcontrolmessage+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.pae.gem": {
        source: "iana"
      },
      "application/vnd.oipf.spdiscovery+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.spdlist+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.ueprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.userprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.olpc-sugar": {
        source: "iana",
        extensions: ["xo"]
      },
      "application/vnd.oma-scws-config": {
        source: "iana"
      },
      "application/vnd.oma-scws-http-request": {
        source: "iana"
      },
      "application/vnd.oma-scws-http-response": {
        source: "iana"
      },
      "application/vnd.oma.bcast.associated-procedure-parameter+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.drm-trigger+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.imd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.ltkm": {
        source: "iana"
      },
      "application/vnd.oma.bcast.notification+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.provisioningtrigger": {
        source: "iana"
      },
      "application/vnd.oma.bcast.sgboot": {
        source: "iana"
      },
      "application/vnd.oma.bcast.sgdd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.sgdu": {
        source: "iana"
      },
      "application/vnd.oma.bcast.simple-symbol-container": {
        source: "iana"
      },
      "application/vnd.oma.bcast.smartcard-trigger+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.sprov+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.stkm": {
        source: "iana"
      },
      "application/vnd.oma.cab-address-book+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-feature-handler+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-pcc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-subs-invite+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-user-prefs+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.dcd": {
        source: "iana"
      },
      "application/vnd.oma.dcdc": {
        source: "iana"
      },
      "application/vnd.oma.dd2+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dd2"]
      },
      "application/vnd.oma.drm.risd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.group-usage-list+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.lwm2m+cbor": {
        source: "iana"
      },
      "application/vnd.oma.lwm2m+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.lwm2m+tlv": {
        source: "iana"
      },
      "application/vnd.oma.pal+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.detailed-progress-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.final-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.groups+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.invocation-descriptor+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.optimized-progress-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.push": {
        source: "iana"
      },
      "application/vnd.oma.scidm.messages+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.xcap-directory+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.omads-email+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.omads-file+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.omads-folder+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.omaloc-supl-init": {
        source: "iana"
      },
      "application/vnd.onepager": {
        source: "iana"
      },
      "application/vnd.onepagertamp": {
        source: "iana"
      },
      "application/vnd.onepagertamx": {
        source: "iana"
      },
      "application/vnd.onepagertat": {
        source: "iana"
      },
      "application/vnd.onepagertatp": {
        source: "iana"
      },
      "application/vnd.onepagertatx": {
        source: "iana"
      },
      "application/vnd.openblox.game+xml": {
        source: "iana",
        compressible: true,
        extensions: ["obgx"]
      },
      "application/vnd.openblox.game-binary": {
        source: "iana"
      },
      "application/vnd.openeye.oeb": {
        source: "iana"
      },
      "application/vnd.openofficeorg.extension": {
        source: "apache",
        extensions: ["oxt"]
      },
      "application/vnd.openstreetmap.data+xml": {
        source: "iana",
        compressible: true,
        extensions: ["osm"]
      },
      "application/vnd.opentimestamps.ots": {
        source: "iana"
      },
      "application/vnd.openxmlformats-officedocument.custom-properties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawing+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.extended-properties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.presentation": {
        source: "iana",
        compressible: false,
        extensions: ["pptx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slide": {
        source: "iana",
        extensions: ["sldx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slideshow": {
        source: "iana",
        extensions: ["ppsx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.template": {
        source: "iana",
        extensions: ["potx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": {
        source: "iana",
        compressible: false,
        extensions: ["xlsx"]
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.template": {
        source: "iana",
        extensions: ["xltx"]
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.theme+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.themeoverride+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.vmldrawing": {
        source: "iana"
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document": {
        source: "iana",
        compressible: false,
        extensions: ["docx"]
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.template": {
        source: "iana",
        extensions: ["dotx"]
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-package.core-properties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-package.relationships+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oracle.resource+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.orange.indata": {
        source: "iana"
      },
      "application/vnd.osa.netdeploy": {
        source: "iana"
      },
      "application/vnd.osgeo.mapguide.package": {
        source: "iana",
        extensions: ["mgp"]
      },
      "application/vnd.osgi.bundle": {
        source: "iana"
      },
      "application/vnd.osgi.dp": {
        source: "iana",
        extensions: ["dp"]
      },
      "application/vnd.osgi.subsystem": {
        source: "iana",
        extensions: ["esa"]
      },
      "application/vnd.otps.ct-kip+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oxli.countgraph": {
        source: "iana"
      },
      "application/vnd.pagerduty+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.palm": {
        source: "iana",
        extensions: ["pdb", "pqa", "oprc"]
      },
      "application/vnd.panoply": {
        source: "iana"
      },
      "application/vnd.paos.xml": {
        source: "iana"
      },
      "application/vnd.patentdive": {
        source: "iana"
      },
      "application/vnd.patientecommsdoc": {
        source: "iana"
      },
      "application/vnd.pawaafile": {
        source: "iana",
        extensions: ["paw"]
      },
      "application/vnd.pcos": {
        source: "iana"
      },
      "application/vnd.pg.format": {
        source: "iana",
        extensions: ["str"]
      },
      "application/vnd.pg.osasli": {
        source: "iana",
        extensions: ["ei6"]
      },
      "application/vnd.piaccess.application-licence": {
        source: "iana"
      },
      "application/vnd.picsel": {
        source: "iana",
        extensions: ["efif"]
      },
      "application/vnd.pmi.widget": {
        source: "iana",
        extensions: ["wg"]
      },
      "application/vnd.poc.group-advertisement+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.pocketlearn": {
        source: "iana",
        extensions: ["plf"]
      },
      "application/vnd.powerbuilder6": {
        source: "iana",
        extensions: ["pbd"]
      },
      "application/vnd.powerbuilder6-s": {
        source: "iana"
      },
      "application/vnd.powerbuilder7": {
        source: "iana"
      },
      "application/vnd.powerbuilder7-s": {
        source: "iana"
      },
      "application/vnd.powerbuilder75": {
        source: "iana"
      },
      "application/vnd.powerbuilder75-s": {
        source: "iana"
      },
      "application/vnd.preminet": {
        source: "iana"
      },
      "application/vnd.previewsystems.box": {
        source: "iana",
        extensions: ["box"]
      },
      "application/vnd.proteus.magazine": {
        source: "iana",
        extensions: ["mgz"]
      },
      "application/vnd.psfs": {
        source: "iana"
      },
      "application/vnd.publishare-delta-tree": {
        source: "iana",
        extensions: ["qps"]
      },
      "application/vnd.pvi.ptid1": {
        source: "iana",
        extensions: ["ptid"]
      },
      "application/vnd.pwg-multiplexed": {
        source: "iana"
      },
      "application/vnd.pwg-xhtml-print+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.qualcomm.brew-app-res": {
        source: "iana"
      },
      "application/vnd.quarantainenet": {
        source: "iana"
      },
      "application/vnd.quark.quarkxpress": {
        source: "iana",
        extensions: ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"]
      },
      "application/vnd.quobject-quoxdocument": {
        source: "iana"
      },
      "application/vnd.radisys.moml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-conf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-conn+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-dialog+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-stream+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-conf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-base+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-fax-detect+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-group+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-speech+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-transform+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.rainstor.data": {
        source: "iana"
      },
      "application/vnd.rapid": {
        source: "iana"
      },
      "application/vnd.rar": {
        source: "iana",
        extensions: ["rar"]
      },
      "application/vnd.realvnc.bed": {
        source: "iana",
        extensions: ["bed"]
      },
      "application/vnd.recordare.musicxml": {
        source: "iana",
        extensions: ["mxl"]
      },
      "application/vnd.recordare.musicxml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["musicxml"]
      },
      "application/vnd.renlearn.rlprint": {
        source: "iana"
      },
      "application/vnd.resilient.logic": {
        source: "iana"
      },
      "application/vnd.restful+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.rig.cryptonote": {
        source: "iana",
        extensions: ["cryptonote"]
      },
      "application/vnd.rim.cod": {
        source: "apache",
        extensions: ["cod"]
      },
      "application/vnd.rn-realmedia": {
        source: "apache",
        extensions: ["rm"]
      },
      "application/vnd.rn-realmedia-vbr": {
        source: "apache",
        extensions: ["rmvb"]
      },
      "application/vnd.route66.link66+xml": {
        source: "iana",
        compressible: true,
        extensions: ["link66"]
      },
      "application/vnd.rs-274x": {
        source: "iana"
      },
      "application/vnd.ruckus.download": {
        source: "iana"
      },
      "application/vnd.s3sms": {
        source: "iana"
      },
      "application/vnd.sailingtracker.track": {
        source: "iana",
        extensions: ["st"]
      },
      "application/vnd.sar": {
        source: "iana"
      },
      "application/vnd.sbm.cid": {
        source: "iana"
      },
      "application/vnd.sbm.mid2": {
        source: "iana"
      },
      "application/vnd.scribus": {
        source: "iana"
      },
      "application/vnd.sealed.3df": {
        source: "iana"
      },
      "application/vnd.sealed.csf": {
        source: "iana"
      },
      "application/vnd.sealed.doc": {
        source: "iana"
      },
      "application/vnd.sealed.eml": {
        source: "iana"
      },
      "application/vnd.sealed.mht": {
        source: "iana"
      },
      "application/vnd.sealed.net": {
        source: "iana"
      },
      "application/vnd.sealed.ppt": {
        source: "iana"
      },
      "application/vnd.sealed.tiff": {
        source: "iana"
      },
      "application/vnd.sealed.xls": {
        source: "iana"
      },
      "application/vnd.sealedmedia.softseal.html": {
        source: "iana"
      },
      "application/vnd.sealedmedia.softseal.pdf": {
        source: "iana"
      },
      "application/vnd.seemail": {
        source: "iana",
        extensions: ["see"]
      },
      "application/vnd.seis+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.sema": {
        source: "iana",
        extensions: ["sema"]
      },
      "application/vnd.semd": {
        source: "iana",
        extensions: ["semd"]
      },
      "application/vnd.semf": {
        source: "iana",
        extensions: ["semf"]
      },
      "application/vnd.shade-save-file": {
        source: "iana"
      },
      "application/vnd.shana.informed.formdata": {
        source: "iana",
        extensions: ["ifm"]
      },
      "application/vnd.shana.informed.formtemplate": {
        source: "iana",
        extensions: ["itp"]
      },
      "application/vnd.shana.informed.interchange": {
        source: "iana",
        extensions: ["iif"]
      },
      "application/vnd.shana.informed.package": {
        source: "iana",
        extensions: ["ipk"]
      },
      "application/vnd.shootproof+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.shopkick+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.shp": {
        source: "iana"
      },
      "application/vnd.shx": {
        source: "iana"
      },
      "application/vnd.sigrok.session": {
        source: "iana"
      },
      "application/vnd.simtech-mindmapper": {
        source: "iana",
        extensions: ["twd", "twds"]
      },
      "application/vnd.siren+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.smaf": {
        source: "iana",
        extensions: ["mmf"]
      },
      "application/vnd.smart.notebook": {
        source: "iana"
      },
      "application/vnd.smart.teacher": {
        source: "iana",
        extensions: ["teacher"]
      },
      "application/vnd.snesdev-page-table": {
        source: "iana"
      },
      "application/vnd.software602.filler.form+xml": {
        source: "iana",
        compressible: true,
        extensions: ["fo"]
      },
      "application/vnd.software602.filler.form-xml-zip": {
        source: "iana"
      },
      "application/vnd.solent.sdkm+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sdkm", "sdkd"]
      },
      "application/vnd.spotfire.dxp": {
        source: "iana",
        extensions: ["dxp"]
      },
      "application/vnd.spotfire.sfs": {
        source: "iana",
        extensions: ["sfs"]
      },
      "application/vnd.sqlite3": {
        source: "iana"
      },
      "application/vnd.sss-cod": {
        source: "iana"
      },
      "application/vnd.sss-dtf": {
        source: "iana"
      },
      "application/vnd.sss-ntf": {
        source: "iana"
      },
      "application/vnd.stardivision.calc": {
        source: "apache",
        extensions: ["sdc"]
      },
      "application/vnd.stardivision.draw": {
        source: "apache",
        extensions: ["sda"]
      },
      "application/vnd.stardivision.impress": {
        source: "apache",
        extensions: ["sdd"]
      },
      "application/vnd.stardivision.math": {
        source: "apache",
        extensions: ["smf"]
      },
      "application/vnd.stardivision.writer": {
        source: "apache",
        extensions: ["sdw", "vor"]
      },
      "application/vnd.stardivision.writer-global": {
        source: "apache",
        extensions: ["sgl"]
      },
      "application/vnd.stepmania.package": {
        source: "iana",
        extensions: ["smzip"]
      },
      "application/vnd.stepmania.stepchart": {
        source: "iana",
        extensions: ["sm"]
      },
      "application/vnd.street-stream": {
        source: "iana"
      },
      "application/vnd.sun.wadl+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wadl"]
      },
      "application/vnd.sun.xml.calc": {
        source: "apache",
        extensions: ["sxc"]
      },
      "application/vnd.sun.xml.calc.template": {
        source: "apache",
        extensions: ["stc"]
      },
      "application/vnd.sun.xml.draw": {
        source: "apache",
        extensions: ["sxd"]
      },
      "application/vnd.sun.xml.draw.template": {
        source: "apache",
        extensions: ["std"]
      },
      "application/vnd.sun.xml.impress": {
        source: "apache",
        extensions: ["sxi"]
      },
      "application/vnd.sun.xml.impress.template": {
        source: "apache",
        extensions: ["sti"]
      },
      "application/vnd.sun.xml.math": {
        source: "apache",
        extensions: ["sxm"]
      },
      "application/vnd.sun.xml.writer": {
        source: "apache",
        extensions: ["sxw"]
      },
      "application/vnd.sun.xml.writer.global": {
        source: "apache",
        extensions: ["sxg"]
      },
      "application/vnd.sun.xml.writer.template": {
        source: "apache",
        extensions: ["stw"]
      },
      "application/vnd.sus-calendar": {
        source: "iana",
        extensions: ["sus", "susp"]
      },
      "application/vnd.svd": {
        source: "iana",
        extensions: ["svd"]
      },
      "application/vnd.swiftview-ics": {
        source: "iana"
      },
      "application/vnd.sycle+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.syft+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.symbian.install": {
        source: "apache",
        extensions: ["sis", "sisx"]
      },
      "application/vnd.syncml+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["xsm"]
      },
      "application/vnd.syncml.dm+wbxml": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["bdm"]
      },
      "application/vnd.syncml.dm+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["xdm"]
      },
      "application/vnd.syncml.dm.notification": {
        source: "iana"
      },
      "application/vnd.syncml.dmddf+wbxml": {
        source: "iana"
      },
      "application/vnd.syncml.dmddf+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["ddf"]
      },
      "application/vnd.syncml.dmtnds+wbxml": {
        source: "iana"
      },
      "application/vnd.syncml.dmtnds+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.syncml.ds.notification": {
        source: "iana"
      },
      "application/vnd.tableschema+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.tao.intent-module-archive": {
        source: "iana",
        extensions: ["tao"]
      },
      "application/vnd.tcpdump.pcap": {
        source: "iana",
        extensions: ["pcap", "cap", "dmp"]
      },
      "application/vnd.think-cell.ppttc+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.tmd.mediaflex.api+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.tml": {
        source: "iana"
      },
      "application/vnd.tmobile-livetv": {
        source: "iana",
        extensions: ["tmo"]
      },
      "application/vnd.tri.onesource": {
        source: "iana"
      },
      "application/vnd.trid.tpt": {
        source: "iana",
        extensions: ["tpt"]
      },
      "application/vnd.triscape.mxs": {
        source: "iana",
        extensions: ["mxs"]
      },
      "application/vnd.trueapp": {
        source: "iana",
        extensions: ["tra"]
      },
      "application/vnd.truedoc": {
        source: "iana"
      },
      "application/vnd.ubisoft.webplayer": {
        source: "iana"
      },
      "application/vnd.ufdl": {
        source: "iana",
        extensions: ["ufd", "ufdl"]
      },
      "application/vnd.uiq.theme": {
        source: "iana",
        extensions: ["utz"]
      },
      "application/vnd.umajin": {
        source: "iana",
        extensions: ["umj"]
      },
      "application/vnd.unity": {
        source: "iana",
        extensions: ["unityweb"]
      },
      "application/vnd.uoml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["uoml"]
      },
      "application/vnd.uplanet.alert": {
        source: "iana"
      },
      "application/vnd.uplanet.alert-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.bearer-choice": {
        source: "iana"
      },
      "application/vnd.uplanet.bearer-choice-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.cacheop": {
        source: "iana"
      },
      "application/vnd.uplanet.cacheop-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.channel": {
        source: "iana"
      },
      "application/vnd.uplanet.channel-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.list": {
        source: "iana"
      },
      "application/vnd.uplanet.list-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.listcmd": {
        source: "iana"
      },
      "application/vnd.uplanet.listcmd-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.signal": {
        source: "iana"
      },
      "application/vnd.uri-map": {
        source: "iana"
      },
      "application/vnd.valve.source.material": {
        source: "iana"
      },
      "application/vnd.vcx": {
        source: "iana",
        extensions: ["vcx"]
      },
      "application/vnd.vd-study": {
        source: "iana"
      },
      "application/vnd.vectorworks": {
        source: "iana"
      },
      "application/vnd.vel+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.verimatrix.vcas": {
        source: "iana"
      },
      "application/vnd.veritone.aion+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.veryant.thin": {
        source: "iana"
      },
      "application/vnd.ves.encrypted": {
        source: "iana"
      },
      "application/vnd.vidsoft.vidconference": {
        source: "iana"
      },
      "application/vnd.visio": {
        source: "iana",
        extensions: ["vsd", "vst", "vss", "vsw"]
      },
      "application/vnd.visionary": {
        source: "iana",
        extensions: ["vis"]
      },
      "application/vnd.vividence.scriptfile": {
        source: "iana"
      },
      "application/vnd.vsf": {
        source: "iana",
        extensions: ["vsf"]
      },
      "application/vnd.wap.sic": {
        source: "iana"
      },
      "application/vnd.wap.slc": {
        source: "iana"
      },
      "application/vnd.wap.wbxml": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["wbxml"]
      },
      "application/vnd.wap.wmlc": {
        source: "iana",
        extensions: ["wmlc"]
      },
      "application/vnd.wap.wmlscriptc": {
        source: "iana",
        extensions: ["wmlsc"]
      },
      "application/vnd.webturbo": {
        source: "iana",
        extensions: ["wtb"]
      },
      "application/vnd.wfa.dpp": {
        source: "iana"
      },
      "application/vnd.wfa.p2p": {
        source: "iana"
      },
      "application/vnd.wfa.wsc": {
        source: "iana"
      },
      "application/vnd.windows.devicepairing": {
        source: "iana"
      },
      "application/vnd.wmc": {
        source: "iana"
      },
      "application/vnd.wmf.bootstrap": {
        source: "iana"
      },
      "application/vnd.wolfram.mathematica": {
        source: "iana"
      },
      "application/vnd.wolfram.mathematica.package": {
        source: "iana"
      },
      "application/vnd.wolfram.player": {
        source: "iana",
        extensions: ["nbp"]
      },
      "application/vnd.wordperfect": {
        source: "iana",
        extensions: ["wpd"]
      },
      "application/vnd.wqd": {
        source: "iana",
        extensions: ["wqd"]
      },
      "application/vnd.wrq-hp3000-labelled": {
        source: "iana"
      },
      "application/vnd.wt.stf": {
        source: "iana",
        extensions: ["stf"]
      },
      "application/vnd.wv.csp+wbxml": {
        source: "iana"
      },
      "application/vnd.wv.csp+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.wv.ssp+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.xacml+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.xara": {
        source: "iana",
        extensions: ["xar"]
      },
      "application/vnd.xfdl": {
        source: "iana",
        extensions: ["xfdl"]
      },
      "application/vnd.xfdl.webform": {
        source: "iana"
      },
      "application/vnd.xmi+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.xmpie.cpkg": {
        source: "iana"
      },
      "application/vnd.xmpie.dpkg": {
        source: "iana"
      },
      "application/vnd.xmpie.plan": {
        source: "iana"
      },
      "application/vnd.xmpie.ppkg": {
        source: "iana"
      },
      "application/vnd.xmpie.xlim": {
        source: "iana"
      },
      "application/vnd.yamaha.hv-dic": {
        source: "iana",
        extensions: ["hvd"]
      },
      "application/vnd.yamaha.hv-script": {
        source: "iana",
        extensions: ["hvs"]
      },
      "application/vnd.yamaha.hv-voice": {
        source: "iana",
        extensions: ["hvp"]
      },
      "application/vnd.yamaha.openscoreformat": {
        source: "iana",
        extensions: ["osf"]
      },
      "application/vnd.yamaha.openscoreformat.osfpvg+xml": {
        source: "iana",
        compressible: true,
        extensions: ["osfpvg"]
      },
      "application/vnd.yamaha.remote-setup": {
        source: "iana"
      },
      "application/vnd.yamaha.smaf-audio": {
        source: "iana",
        extensions: ["saf"]
      },
      "application/vnd.yamaha.smaf-phrase": {
        source: "iana",
        extensions: ["spf"]
      },
      "application/vnd.yamaha.through-ngn": {
        source: "iana"
      },
      "application/vnd.yamaha.tunnel-udpencap": {
        source: "iana"
      },
      "application/vnd.yaoweme": {
        source: "iana"
      },
      "application/vnd.yellowriver-custom-menu": {
        source: "iana",
        extensions: ["cmp"]
      },
      "application/vnd.youtube.yt": {
        source: "iana"
      },
      "application/vnd.zul": {
        source: "iana",
        extensions: ["zir", "zirz"]
      },
      "application/vnd.zzazz.deck+xml": {
        source: "iana",
        compressible: true,
        extensions: ["zaz"]
      },
      "application/voicexml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["vxml"]
      },
      "application/voucher-cms+json": {
        source: "iana",
        compressible: true
      },
      "application/vq-rtcpxr": {
        source: "iana"
      },
      "application/wasm": {
        source: "iana",
        compressible: true,
        extensions: ["wasm"]
      },
      "application/watcherinfo+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wif"]
      },
      "application/webpush-options+json": {
        source: "iana",
        compressible: true
      },
      "application/whoispp-query": {
        source: "iana"
      },
      "application/whoispp-response": {
        source: "iana"
      },
      "application/widget": {
        source: "iana",
        extensions: ["wgt"]
      },
      "application/winhlp": {
        source: "apache",
        extensions: ["hlp"]
      },
      "application/wita": {
        source: "iana"
      },
      "application/wordperfect5.1": {
        source: "iana"
      },
      "application/wsdl+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wsdl"]
      },
      "application/wspolicy+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wspolicy"]
      },
      "application/x-7z-compressed": {
        source: "apache",
        compressible: false,
        extensions: ["7z"]
      },
      "application/x-abiword": {
        source: "apache",
        extensions: ["abw"]
      },
      "application/x-ace-compressed": {
        source: "apache",
        extensions: ["ace"]
      },
      "application/x-amf": {
        source: "apache"
      },
      "application/x-apple-diskimage": {
        source: "apache",
        extensions: ["dmg"]
      },
      "application/x-arj": {
        compressible: false,
        extensions: ["arj"]
      },
      "application/x-authorware-bin": {
        source: "apache",
        extensions: ["aab", "x32", "u32", "vox"]
      },
      "application/x-authorware-map": {
        source: "apache",
        extensions: ["aam"]
      },
      "application/x-authorware-seg": {
        source: "apache",
        extensions: ["aas"]
      },
      "application/x-bcpio": {
        source: "apache",
        extensions: ["bcpio"]
      },
      "application/x-bdoc": {
        compressible: false,
        extensions: ["bdoc"]
      },
      "application/x-bittorrent": {
        source: "apache",
        extensions: ["torrent"]
      },
      "application/x-blorb": {
        source: "apache",
        extensions: ["blb", "blorb"]
      },
      "application/x-bzip": {
        source: "apache",
        compressible: false,
        extensions: ["bz"]
      },
      "application/x-bzip2": {
        source: "apache",
        compressible: false,
        extensions: ["bz2", "boz"]
      },
      "application/x-cbr": {
        source: "apache",
        extensions: ["cbr", "cba", "cbt", "cbz", "cb7"]
      },
      "application/x-cdlink": {
        source: "apache",
        extensions: ["vcd"]
      },
      "application/x-cfs-compressed": {
        source: "apache",
        extensions: ["cfs"]
      },
      "application/x-chat": {
        source: "apache",
        extensions: ["chat"]
      },
      "application/x-chess-pgn": {
        source: "apache",
        extensions: ["pgn"]
      },
      "application/x-chrome-extension": {
        extensions: ["crx"]
      },
      "application/x-cocoa": {
        source: "nginx",
        extensions: ["cco"]
      },
      "application/x-compress": {
        source: "apache"
      },
      "application/x-conference": {
        source: "apache",
        extensions: ["nsc"]
      },
      "application/x-cpio": {
        source: "apache",
        extensions: ["cpio"]
      },
      "application/x-csh": {
        source: "apache",
        extensions: ["csh"]
      },
      "application/x-deb": {
        compressible: false
      },
      "application/x-debian-package": {
        source: "apache",
        extensions: ["deb", "udeb"]
      },
      "application/x-dgc-compressed": {
        source: "apache",
        extensions: ["dgc"]
      },
      "application/x-director": {
        source: "apache",
        extensions: ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"]
      },
      "application/x-doom": {
        source: "apache",
        extensions: ["wad"]
      },
      "application/x-dtbncx+xml": {
        source: "apache",
        compressible: true,
        extensions: ["ncx"]
      },
      "application/x-dtbook+xml": {
        source: "apache",
        compressible: true,
        extensions: ["dtb"]
      },
      "application/x-dtbresource+xml": {
        source: "apache",
        compressible: true,
        extensions: ["res"]
      },
      "application/x-dvi": {
        source: "apache",
        compressible: false,
        extensions: ["dvi"]
      },
      "application/x-envoy": {
        source: "apache",
        extensions: ["evy"]
      },
      "application/x-eva": {
        source: "apache",
        extensions: ["eva"]
      },
      "application/x-font-bdf": {
        source: "apache",
        extensions: ["bdf"]
      },
      "application/x-font-dos": {
        source: "apache"
      },
      "application/x-font-framemaker": {
        source: "apache"
      },
      "application/x-font-ghostscript": {
        source: "apache",
        extensions: ["gsf"]
      },
      "application/x-font-libgrx": {
        source: "apache"
      },
      "application/x-font-linux-psf": {
        source: "apache",
        extensions: ["psf"]
      },
      "application/x-font-pcf": {
        source: "apache",
        extensions: ["pcf"]
      },
      "application/x-font-snf": {
        source: "apache",
        extensions: ["snf"]
      },
      "application/x-font-speedo": {
        source: "apache"
      },
      "application/x-font-sunos-news": {
        source: "apache"
      },
      "application/x-font-type1": {
        source: "apache",
        extensions: ["pfa", "pfb", "pfm", "afm"]
      },
      "application/x-font-vfont": {
        source: "apache"
      },
      "application/x-freearc": {
        source: "apache",
        extensions: ["arc"]
      },
      "application/x-futuresplash": {
        source: "apache",
        extensions: ["spl"]
      },
      "application/x-gca-compressed": {
        source: "apache",
        extensions: ["gca"]
      },
      "application/x-glulx": {
        source: "apache",
        extensions: ["ulx"]
      },
      "application/x-gnumeric": {
        source: "apache",
        extensions: ["gnumeric"]
      },
      "application/x-gramps-xml": {
        source: "apache",
        extensions: ["gramps"]
      },
      "application/x-gtar": {
        source: "apache",
        extensions: ["gtar"]
      },
      "application/x-gzip": {
        source: "apache"
      },
      "application/x-hdf": {
        source: "apache",
        extensions: ["hdf"]
      },
      "application/x-httpd-php": {
        compressible: true,
        extensions: ["php"]
      },
      "application/x-install-instructions": {
        source: "apache",
        extensions: ["install"]
      },
      "application/x-iso9660-image": {
        source: "apache",
        extensions: ["iso"]
      },
      "application/x-iwork-keynote-sffkey": {
        extensions: ["key"]
      },
      "application/x-iwork-numbers-sffnumbers": {
        extensions: ["numbers"]
      },
      "application/x-iwork-pages-sffpages": {
        extensions: ["pages"]
      },
      "application/x-java-archive-diff": {
        source: "nginx",
        extensions: ["jardiff"]
      },
      "application/x-java-jnlp-file": {
        source: "apache",
        compressible: false,
        extensions: ["jnlp"]
      },
      "application/x-javascript": {
        compressible: true
      },
      "application/x-keepass2": {
        extensions: ["kdbx"]
      },
      "application/x-latex": {
        source: "apache",
        compressible: false,
        extensions: ["latex"]
      },
      "application/x-lua-bytecode": {
        extensions: ["luac"]
      },
      "application/x-lzh-compressed": {
        source: "apache",
        extensions: ["lzh", "lha"]
      },
      "application/x-makeself": {
        source: "nginx",
        extensions: ["run"]
      },
      "application/x-mie": {
        source: "apache",
        extensions: ["mie"]
      },
      "application/x-mobipocket-ebook": {
        source: "apache",
        extensions: ["prc", "mobi"]
      },
      "application/x-mpegurl": {
        compressible: false
      },
      "application/x-ms-application": {
        source: "apache",
        extensions: ["application"]
      },
      "application/x-ms-shortcut": {
        source: "apache",
        extensions: ["lnk"]
      },
      "application/x-ms-wmd": {
        source: "apache",
        extensions: ["wmd"]
      },
      "application/x-ms-wmz": {
        source: "apache",
        extensions: ["wmz"]
      },
      "application/x-ms-xbap": {
        source: "apache",
        extensions: ["xbap"]
      },
      "application/x-msaccess": {
        source: "apache",
        extensions: ["mdb"]
      },
      "application/x-msbinder": {
        source: "apache",
        extensions: ["obd"]
      },
      "application/x-mscardfile": {
        source: "apache",
        extensions: ["crd"]
      },
      "application/x-msclip": {
        source: "apache",
        extensions: ["clp"]
      },
      "application/x-msdos-program": {
        extensions: ["exe"]
      },
      "application/x-msdownload": {
        source: "apache",
        extensions: ["exe", "dll", "com", "bat", "msi"]
      },
      "application/x-msmediaview": {
        source: "apache",
        extensions: ["mvb", "m13", "m14"]
      },
      "application/x-msmetafile": {
        source: "apache",
        extensions: ["wmf", "wmz", "emf", "emz"]
      },
      "application/x-msmoney": {
        source: "apache",
        extensions: ["mny"]
      },
      "application/x-mspublisher": {
        source: "apache",
        extensions: ["pub"]
      },
      "application/x-msschedule": {
        source: "apache",
        extensions: ["scd"]
      },
      "application/x-msterminal": {
        source: "apache",
        extensions: ["trm"]
      },
      "application/x-mswrite": {
        source: "apache",
        extensions: ["wri"]
      },
      "application/x-netcdf": {
        source: "apache",
        extensions: ["nc", "cdf"]
      },
      "application/x-ns-proxy-autoconfig": {
        compressible: true,
        extensions: ["pac"]
      },
      "application/x-nzb": {
        source: "apache",
        extensions: ["nzb"]
      },
      "application/x-perl": {
        source: "nginx",
        extensions: ["pl", "pm"]
      },
      "application/x-pilot": {
        source: "nginx",
        extensions: ["prc", "pdb"]
      },
      "application/x-pkcs12": {
        source: "apache",
        compressible: false,
        extensions: ["p12", "pfx"]
      },
      "application/x-pkcs7-certificates": {
        source: "apache",
        extensions: ["p7b", "spc"]
      },
      "application/x-pkcs7-certreqresp": {
        source: "apache",
        extensions: ["p7r"]
      },
      "application/x-pki-message": {
        source: "iana"
      },
      "application/x-rar-compressed": {
        source: "apache",
        compressible: false,
        extensions: ["rar"]
      },
      "application/x-redhat-package-manager": {
        source: "nginx",
        extensions: ["rpm"]
      },
      "application/x-research-info-systems": {
        source: "apache",
        extensions: ["ris"]
      },
      "application/x-sea": {
        source: "nginx",
        extensions: ["sea"]
      },
      "application/x-sh": {
        source: "apache",
        compressible: true,
        extensions: ["sh"]
      },
      "application/x-shar": {
        source: "apache",
        extensions: ["shar"]
      },
      "application/x-shockwave-flash": {
        source: "apache",
        compressible: false,
        extensions: ["swf"]
      },
      "application/x-silverlight-app": {
        source: "apache",
        extensions: ["xap"]
      },
      "application/x-sql": {
        source: "apache",
        extensions: ["sql"]
      },
      "application/x-stuffit": {
        source: "apache",
        compressible: false,
        extensions: ["sit"]
      },
      "application/x-stuffitx": {
        source: "apache",
        extensions: ["sitx"]
      },
      "application/x-subrip": {
        source: "apache",
        extensions: ["srt"]
      },
      "application/x-sv4cpio": {
        source: "apache",
        extensions: ["sv4cpio"]
      },
      "application/x-sv4crc": {
        source: "apache",
        extensions: ["sv4crc"]
      },
      "application/x-t3vm-image": {
        source: "apache",
        extensions: ["t3"]
      },
      "application/x-tads": {
        source: "apache",
        extensions: ["gam"]
      },
      "application/x-tar": {
        source: "apache",
        compressible: true,
        extensions: ["tar"]
      },
      "application/x-tcl": {
        source: "apache",
        extensions: ["tcl", "tk"]
      },
      "application/x-tex": {
        source: "apache",
        extensions: ["tex"]
      },
      "application/x-tex-tfm": {
        source: "apache",
        extensions: ["tfm"]
      },
      "application/x-texinfo": {
        source: "apache",
        extensions: ["texinfo", "texi"]
      },
      "application/x-tgif": {
        source: "apache",
        extensions: ["obj"]
      },
      "application/x-ustar": {
        source: "apache",
        extensions: ["ustar"]
      },
      "application/x-virtualbox-hdd": {
        compressible: true,
        extensions: ["hdd"]
      },
      "application/x-virtualbox-ova": {
        compressible: true,
        extensions: ["ova"]
      },
      "application/x-virtualbox-ovf": {
        compressible: true,
        extensions: ["ovf"]
      },
      "application/x-virtualbox-vbox": {
        compressible: true,
        extensions: ["vbox"]
      },
      "application/x-virtualbox-vbox-extpack": {
        compressible: false,
        extensions: ["vbox-extpack"]
      },
      "application/x-virtualbox-vdi": {
        compressible: true,
        extensions: ["vdi"]
      },
      "application/x-virtualbox-vhd": {
        compressible: true,
        extensions: ["vhd"]
      },
      "application/x-virtualbox-vmdk": {
        compressible: true,
        extensions: ["vmdk"]
      },
      "application/x-wais-source": {
        source: "apache",
        extensions: ["src"]
      },
      "application/x-web-app-manifest+json": {
        compressible: true,
        extensions: ["webapp"]
      },
      "application/x-www-form-urlencoded": {
        source: "iana",
        compressible: true
      },
      "application/x-x509-ca-cert": {
        source: "iana",
        extensions: ["der", "crt", "pem"]
      },
      "application/x-x509-ca-ra-cert": {
        source: "iana"
      },
      "application/x-x509-next-ca-cert": {
        source: "iana"
      },
      "application/x-xfig": {
        source: "apache",
        extensions: ["fig"]
      },
      "application/x-xliff+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xlf"]
      },
      "application/x-xpinstall": {
        source: "apache",
        compressible: false,
        extensions: ["xpi"]
      },
      "application/x-xz": {
        source: "apache",
        extensions: ["xz"]
      },
      "application/x-zmachine": {
        source: "apache",
        extensions: ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"]
      },
      "application/x400-bp": {
        source: "iana"
      },
      "application/xacml+xml": {
        source: "iana",
        compressible: true
      },
      "application/xaml+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xaml"]
      },
      "application/xcap-att+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xav"]
      },
      "application/xcap-caps+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xca"]
      },
      "application/xcap-diff+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdf"]
      },
      "application/xcap-el+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xel"]
      },
      "application/xcap-error+xml": {
        source: "iana",
        compressible: true
      },
      "application/xcap-ns+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xns"]
      },
      "application/xcon-conference-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/xcon-conference-info-diff+xml": {
        source: "iana",
        compressible: true
      },
      "application/xenc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xenc"]
      },
      "application/xhtml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xhtml", "xht"]
      },
      "application/xhtml-voice+xml": {
        source: "apache",
        compressible: true
      },
      "application/xliff+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xlf"]
      },
      "application/xml": {
        source: "iana",
        compressible: true,
        extensions: ["xml", "xsl", "xsd", "rng"]
      },
      "application/xml-dtd": {
        source: "iana",
        compressible: true,
        extensions: ["dtd"]
      },
      "application/xml-external-parsed-entity": {
        source: "iana"
      },
      "application/xml-patch+xml": {
        source: "iana",
        compressible: true
      },
      "application/xmpp+xml": {
        source: "iana",
        compressible: true
      },
      "application/xop+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xop"]
      },
      "application/xproc+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xpl"]
      },
      "application/xslt+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xsl", "xslt"]
      },
      "application/xspf+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xspf"]
      },
      "application/xv+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mxml", "xhvml", "xvml", "xvm"]
      },
      "application/yang": {
        source: "iana",
        extensions: ["yang"]
      },
      "application/yang-data+json": {
        source: "iana",
        compressible: true
      },
      "application/yang-data+xml": {
        source: "iana",
        compressible: true
      },
      "application/yang-patch+json": {
        source: "iana",
        compressible: true
      },
      "application/yang-patch+xml": {
        source: "iana",
        compressible: true
      },
      "application/yin+xml": {
        source: "iana",
        compressible: true,
        extensions: ["yin"]
      },
      "application/zip": {
        source: "iana",
        compressible: false,
        extensions: ["zip"]
      },
      "application/zlib": {
        source: "iana"
      },
      "application/zstd": {
        source: "iana"
      },
      "audio/1d-interleaved-parityfec": {
        source: "iana"
      },
      "audio/32kadpcm": {
        source: "iana"
      },
      "audio/3gpp": {
        source: "iana",
        compressible: false,
        extensions: ["3gpp"]
      },
      "audio/3gpp2": {
        source: "iana"
      },
      "audio/aac": {
        source: "iana"
      },
      "audio/ac3": {
        source: "iana"
      },
      "audio/adpcm": {
        source: "apache",
        extensions: ["adp"]
      },
      "audio/amr": {
        source: "iana",
        extensions: ["amr"]
      },
      "audio/amr-wb": {
        source: "iana"
      },
      "audio/amr-wb+": {
        source: "iana"
      },
      "audio/aptx": {
        source: "iana"
      },
      "audio/asc": {
        source: "iana"
      },
      "audio/atrac-advanced-lossless": {
        source: "iana"
      },
      "audio/atrac-x": {
        source: "iana"
      },
      "audio/atrac3": {
        source: "iana"
      },
      "audio/basic": {
        source: "iana",
        compressible: false,
        extensions: ["au", "snd"]
      },
      "audio/bv16": {
        source: "iana"
      },
      "audio/bv32": {
        source: "iana"
      },
      "audio/clearmode": {
        source: "iana"
      },
      "audio/cn": {
        source: "iana"
      },
      "audio/dat12": {
        source: "iana"
      },
      "audio/dls": {
        source: "iana"
      },
      "audio/dsr-es201108": {
        source: "iana"
      },
      "audio/dsr-es202050": {
        source: "iana"
      },
      "audio/dsr-es202211": {
        source: "iana"
      },
      "audio/dsr-es202212": {
        source: "iana"
      },
      "audio/dv": {
        source: "iana"
      },
      "audio/dvi4": {
        source: "iana"
      },
      "audio/eac3": {
        source: "iana"
      },
      "audio/encaprtp": {
        source: "iana"
      },
      "audio/evrc": {
        source: "iana"
      },
      "audio/evrc-qcp": {
        source: "iana"
      },
      "audio/evrc0": {
        source: "iana"
      },
      "audio/evrc1": {
        source: "iana"
      },
      "audio/evrcb": {
        source: "iana"
      },
      "audio/evrcb0": {
        source: "iana"
      },
      "audio/evrcb1": {
        source: "iana"
      },
      "audio/evrcnw": {
        source: "iana"
      },
      "audio/evrcnw0": {
        source: "iana"
      },
      "audio/evrcnw1": {
        source: "iana"
      },
      "audio/evrcwb": {
        source: "iana"
      },
      "audio/evrcwb0": {
        source: "iana"
      },
      "audio/evrcwb1": {
        source: "iana"
      },
      "audio/evs": {
        source: "iana"
      },
      "audio/flexfec": {
        source: "iana"
      },
      "audio/fwdred": {
        source: "iana"
      },
      "audio/g711-0": {
        source: "iana"
      },
      "audio/g719": {
        source: "iana"
      },
      "audio/g722": {
        source: "iana"
      },
      "audio/g7221": {
        source: "iana"
      },
      "audio/g723": {
        source: "iana"
      },
      "audio/g726-16": {
        source: "iana"
      },
      "audio/g726-24": {
        source: "iana"
      },
      "audio/g726-32": {
        source: "iana"
      },
      "audio/g726-40": {
        source: "iana"
      },
      "audio/g728": {
        source: "iana"
      },
      "audio/g729": {
        source: "iana"
      },
      "audio/g7291": {
        source: "iana"
      },
      "audio/g729d": {
        source: "iana"
      },
      "audio/g729e": {
        source: "iana"
      },
      "audio/gsm": {
        source: "iana"
      },
      "audio/gsm-efr": {
        source: "iana"
      },
      "audio/gsm-hr-08": {
        source: "iana"
      },
      "audio/ilbc": {
        source: "iana"
      },
      "audio/ip-mr_v2.5": {
        source: "iana"
      },
      "audio/isac": {
        source: "apache"
      },
      "audio/l16": {
        source: "iana"
      },
      "audio/l20": {
        source: "iana"
      },
      "audio/l24": {
        source: "iana",
        compressible: false
      },
      "audio/l8": {
        source: "iana"
      },
      "audio/lpc": {
        source: "iana"
      },
      "audio/melp": {
        source: "iana"
      },
      "audio/melp1200": {
        source: "iana"
      },
      "audio/melp2400": {
        source: "iana"
      },
      "audio/melp600": {
        source: "iana"
      },
      "audio/mhas": {
        source: "iana"
      },
      "audio/midi": {
        source: "apache",
        extensions: ["mid", "midi", "kar", "rmi"]
      },
      "audio/mobile-xmf": {
        source: "iana",
        extensions: ["mxmf"]
      },
      "audio/mp3": {
        compressible: false,
        extensions: ["mp3"]
      },
      "audio/mp4": {
        source: "iana",
        compressible: false,
        extensions: ["m4a", "mp4a"]
      },
      "audio/mp4a-latm": {
        source: "iana"
      },
      "audio/mpa": {
        source: "iana"
      },
      "audio/mpa-robust": {
        source: "iana"
      },
      "audio/mpeg": {
        source: "iana",
        compressible: false,
        extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"]
      },
      "audio/mpeg4-generic": {
        source: "iana"
      },
      "audio/musepack": {
        source: "apache"
      },
      "audio/ogg": {
        source: "iana",
        compressible: false,
        extensions: ["oga", "ogg", "spx", "opus"]
      },
      "audio/opus": {
        source: "iana"
      },
      "audio/parityfec": {
        source: "iana"
      },
      "audio/pcma": {
        source: "iana"
      },
      "audio/pcma-wb": {
        source: "iana"
      },
      "audio/pcmu": {
        source: "iana"
      },
      "audio/pcmu-wb": {
        source: "iana"
      },
      "audio/prs.sid": {
        source: "iana"
      },
      "audio/qcelp": {
        source: "iana"
      },
      "audio/raptorfec": {
        source: "iana"
      },
      "audio/red": {
        source: "iana"
      },
      "audio/rtp-enc-aescm128": {
        source: "iana"
      },
      "audio/rtp-midi": {
        source: "iana"
      },
      "audio/rtploopback": {
        source: "iana"
      },
      "audio/rtx": {
        source: "iana"
      },
      "audio/s3m": {
        source: "apache",
        extensions: ["s3m"]
      },
      "audio/scip": {
        source: "iana"
      },
      "audio/silk": {
        source: "apache",
        extensions: ["sil"]
      },
      "audio/smv": {
        source: "iana"
      },
      "audio/smv-qcp": {
        source: "iana"
      },
      "audio/smv0": {
        source: "iana"
      },
      "audio/sofa": {
        source: "iana"
      },
      "audio/sp-midi": {
        source: "iana"
      },
      "audio/speex": {
        source: "iana"
      },
      "audio/t140c": {
        source: "iana"
      },
      "audio/t38": {
        source: "iana"
      },
      "audio/telephone-event": {
        source: "iana"
      },
      "audio/tetra_acelp": {
        source: "iana"
      },
      "audio/tetra_acelp_bb": {
        source: "iana"
      },
      "audio/tone": {
        source: "iana"
      },
      "audio/tsvcis": {
        source: "iana"
      },
      "audio/uemclip": {
        source: "iana"
      },
      "audio/ulpfec": {
        source: "iana"
      },
      "audio/usac": {
        source: "iana"
      },
      "audio/vdvi": {
        source: "iana"
      },
      "audio/vmr-wb": {
        source: "iana"
      },
      "audio/vnd.3gpp.iufp": {
        source: "iana"
      },
      "audio/vnd.4sb": {
        source: "iana"
      },
      "audio/vnd.audiokoz": {
        source: "iana"
      },
      "audio/vnd.celp": {
        source: "iana"
      },
      "audio/vnd.cisco.nse": {
        source: "iana"
      },
      "audio/vnd.cmles.radio-events": {
        source: "iana"
      },
      "audio/vnd.cns.anp1": {
        source: "iana"
      },
      "audio/vnd.cns.inf1": {
        source: "iana"
      },
      "audio/vnd.dece.audio": {
        source: "iana",
        extensions: ["uva", "uvva"]
      },
      "audio/vnd.digital-winds": {
        source: "iana",
        extensions: ["eol"]
      },
      "audio/vnd.dlna.adts": {
        source: "iana"
      },
      "audio/vnd.dolby.heaac.1": {
        source: "iana"
      },
      "audio/vnd.dolby.heaac.2": {
        source: "iana"
      },
      "audio/vnd.dolby.mlp": {
        source: "iana"
      },
      "audio/vnd.dolby.mps": {
        source: "iana"
      },
      "audio/vnd.dolby.pl2": {
        source: "iana"
      },
      "audio/vnd.dolby.pl2x": {
        source: "iana"
      },
      "audio/vnd.dolby.pl2z": {
        source: "iana"
      },
      "audio/vnd.dolby.pulse.1": {
        source: "iana"
      },
      "audio/vnd.dra": {
        source: "iana",
        extensions: ["dra"]
      },
      "audio/vnd.dts": {
        source: "iana",
        extensions: ["dts"]
      },
      "audio/vnd.dts.hd": {
        source: "iana",
        extensions: ["dtshd"]
      },
      "audio/vnd.dts.uhd": {
        source: "iana"
      },
      "audio/vnd.dvb.file": {
        source: "iana"
      },
      "audio/vnd.everad.plj": {
        source: "iana"
      },
      "audio/vnd.hns.audio": {
        source: "iana"
      },
      "audio/vnd.lucent.voice": {
        source: "iana",
        extensions: ["lvp"]
      },
      "audio/vnd.ms-playready.media.pya": {
        source: "iana",
        extensions: ["pya"]
      },
      "audio/vnd.nokia.mobile-xmf": {
        source: "iana"
      },
      "audio/vnd.nortel.vbk": {
        source: "iana"
      },
      "audio/vnd.nuera.ecelp4800": {
        source: "iana",
        extensions: ["ecelp4800"]
      },
      "audio/vnd.nuera.ecelp7470": {
        source: "iana",
        extensions: ["ecelp7470"]
      },
      "audio/vnd.nuera.ecelp9600": {
        source: "iana",
        extensions: ["ecelp9600"]
      },
      "audio/vnd.octel.sbc": {
        source: "iana"
      },
      "audio/vnd.presonus.multitrack": {
        source: "iana"
      },
      "audio/vnd.qcelp": {
        source: "iana"
      },
      "audio/vnd.rhetorex.32kadpcm": {
        source: "iana"
      },
      "audio/vnd.rip": {
        source: "iana",
        extensions: ["rip"]
      },
      "audio/vnd.rn-realaudio": {
        compressible: false
      },
      "audio/vnd.sealedmedia.softseal.mpeg": {
        source: "iana"
      },
      "audio/vnd.vmx.cvsd": {
        source: "iana"
      },
      "audio/vnd.wave": {
        compressible: false
      },
      "audio/vorbis": {
        source: "iana",
        compressible: false
      },
      "audio/vorbis-config": {
        source: "iana"
      },
      "audio/wav": {
        compressible: false,
        extensions: ["wav"]
      },
      "audio/wave": {
        compressible: false,
        extensions: ["wav"]
      },
      "audio/webm": {
        source: "apache",
        compressible: false,
        extensions: ["weba"]
      },
      "audio/x-aac": {
        source: "apache",
        compressible: false,
        extensions: ["aac"]
      },
      "audio/x-aiff": {
        source: "apache",
        extensions: ["aif", "aiff", "aifc"]
      },
      "audio/x-caf": {
        source: "apache",
        compressible: false,
        extensions: ["caf"]
      },
      "audio/x-flac": {
        source: "apache",
        extensions: ["flac"]
      },
      "audio/x-m4a": {
        source: "nginx",
        extensions: ["m4a"]
      },
      "audio/x-matroska": {
        source: "apache",
        extensions: ["mka"]
      },
      "audio/x-mpegurl": {
        source: "apache",
        extensions: ["m3u"]
      },
      "audio/x-ms-wax": {
        source: "apache",
        extensions: ["wax"]
      },
      "audio/x-ms-wma": {
        source: "apache",
        extensions: ["wma"]
      },
      "audio/x-pn-realaudio": {
        source: "apache",
        extensions: ["ram", "ra"]
      },
      "audio/x-pn-realaudio-plugin": {
        source: "apache",
        extensions: ["rmp"]
      },
      "audio/x-realaudio": {
        source: "nginx",
        extensions: ["ra"]
      },
      "audio/x-tta": {
        source: "apache"
      },
      "audio/x-wav": {
        source: "apache",
        extensions: ["wav"]
      },
      "audio/xm": {
        source: "apache",
        extensions: ["xm"]
      },
      "chemical/x-cdx": {
        source: "apache",
        extensions: ["cdx"]
      },
      "chemical/x-cif": {
        source: "apache",
        extensions: ["cif"]
      },
      "chemical/x-cmdf": {
        source: "apache",
        extensions: ["cmdf"]
      },
      "chemical/x-cml": {
        source: "apache",
        extensions: ["cml"]
      },
      "chemical/x-csml": {
        source: "apache",
        extensions: ["csml"]
      },
      "chemical/x-pdb": {
        source: "apache"
      },
      "chemical/x-xyz": {
        source: "apache",
        extensions: ["xyz"]
      },
      "font/collection": {
        source: "iana",
        extensions: ["ttc"]
      },
      "font/otf": {
        source: "iana",
        compressible: true,
        extensions: ["otf"]
      },
      "font/sfnt": {
        source: "iana"
      },
      "font/ttf": {
        source: "iana",
        compressible: true,
        extensions: ["ttf"]
      },
      "font/woff": {
        source: "iana",
        extensions: ["woff"]
      },
      "font/woff2": {
        source: "iana",
        extensions: ["woff2"]
      },
      "image/aces": {
        source: "iana",
        extensions: ["exr"]
      },
      "image/apng": {
        compressible: false,
        extensions: ["apng"]
      },
      "image/avci": {
        source: "iana",
        extensions: ["avci"]
      },
      "image/avcs": {
        source: "iana",
        extensions: ["avcs"]
      },
      "image/avif": {
        source: "iana",
        compressible: false,
        extensions: ["avif"]
      },
      "image/bmp": {
        source: "iana",
        compressible: true,
        extensions: ["bmp"]
      },
      "image/cgm": {
        source: "iana",
        extensions: ["cgm"]
      },
      "image/dicom-rle": {
        source: "iana",
        extensions: ["drle"]
      },
      "image/emf": {
        source: "iana",
        extensions: ["emf"]
      },
      "image/fits": {
        source: "iana",
        extensions: ["fits"]
      },
      "image/g3fax": {
        source: "iana",
        extensions: ["g3"]
      },
      "image/gif": {
        source: "iana",
        compressible: false,
        extensions: ["gif"]
      },
      "image/heic": {
        source: "iana",
        extensions: ["heic"]
      },
      "image/heic-sequence": {
        source: "iana",
        extensions: ["heics"]
      },
      "image/heif": {
        source: "iana",
        extensions: ["heif"]
      },
      "image/heif-sequence": {
        source: "iana",
        extensions: ["heifs"]
      },
      "image/hej2k": {
        source: "iana",
        extensions: ["hej2"]
      },
      "image/hsj2": {
        source: "iana",
        extensions: ["hsj2"]
      },
      "image/ief": {
        source: "iana",
        extensions: ["ief"]
      },
      "image/jls": {
        source: "iana",
        extensions: ["jls"]
      },
      "image/jp2": {
        source: "iana",
        compressible: false,
        extensions: ["jp2", "jpg2"]
      },
      "image/jpeg": {
        source: "iana",
        compressible: false,
        extensions: ["jpeg", "jpg", "jpe"]
      },
      "image/jph": {
        source: "iana",
        extensions: ["jph"]
      },
      "image/jphc": {
        source: "iana",
        extensions: ["jhc"]
      },
      "image/jpm": {
        source: "iana",
        compressible: false,
        extensions: ["jpm"]
      },
      "image/jpx": {
        source: "iana",
        compressible: false,
        extensions: ["jpx", "jpf"]
      },
      "image/jxr": {
        source: "iana",
        extensions: ["jxr"]
      },
      "image/jxra": {
        source: "iana",
        extensions: ["jxra"]
      },
      "image/jxrs": {
        source: "iana",
        extensions: ["jxrs"]
      },
      "image/jxs": {
        source: "iana",
        extensions: ["jxs"]
      },
      "image/jxsc": {
        source: "iana",
        extensions: ["jxsc"]
      },
      "image/jxsi": {
        source: "iana",
        extensions: ["jxsi"]
      },
      "image/jxss": {
        source: "iana",
        extensions: ["jxss"]
      },
      "image/ktx": {
        source: "iana",
        extensions: ["ktx"]
      },
      "image/ktx2": {
        source: "iana",
        extensions: ["ktx2"]
      },
      "image/naplps": {
        source: "iana"
      },
      "image/pjpeg": {
        compressible: false
      },
      "image/png": {
        source: "iana",
        compressible: false,
        extensions: ["png"]
      },
      "image/prs.btif": {
        source: "iana",
        extensions: ["btif"]
      },
      "image/prs.pti": {
        source: "iana",
        extensions: ["pti"]
      },
      "image/pwg-raster": {
        source: "iana"
      },
      "image/sgi": {
        source: "apache",
        extensions: ["sgi"]
      },
      "image/svg+xml": {
        source: "iana",
        compressible: true,
        extensions: ["svg", "svgz"]
      },
      "image/t38": {
        source: "iana",
        extensions: ["t38"]
      },
      "image/tiff": {
        source: "iana",
        compressible: false,
        extensions: ["tif", "tiff"]
      },
      "image/tiff-fx": {
        source: "iana",
        extensions: ["tfx"]
      },
      "image/vnd.adobe.photoshop": {
        source: "iana",
        compressible: true,
        extensions: ["psd"]
      },
      "image/vnd.airzip.accelerator.azv": {
        source: "iana",
        extensions: ["azv"]
      },
      "image/vnd.cns.inf2": {
        source: "iana"
      },
      "image/vnd.dece.graphic": {
        source: "iana",
        extensions: ["uvi", "uvvi", "uvg", "uvvg"]
      },
      "image/vnd.djvu": {
        source: "iana",
        extensions: ["djvu", "djv"]
      },
      "image/vnd.dvb.subtitle": {
        source: "iana",
        extensions: ["sub"]
      },
      "image/vnd.dwg": {
        source: "iana",
        extensions: ["dwg"]
      },
      "image/vnd.dxf": {
        source: "iana",
        extensions: ["dxf"]
      },
      "image/vnd.fastbidsheet": {
        source: "iana",
        extensions: ["fbs"]
      },
      "image/vnd.fpx": {
        source: "iana",
        extensions: ["fpx"]
      },
      "image/vnd.fst": {
        source: "iana",
        extensions: ["fst"]
      },
      "image/vnd.fujixerox.edmics-mmr": {
        source: "iana",
        extensions: ["mmr"]
      },
      "image/vnd.fujixerox.edmics-rlc": {
        source: "iana",
        extensions: ["rlc"]
      },
      "image/vnd.globalgraphics.pgb": {
        source: "iana"
      },
      "image/vnd.microsoft.icon": {
        source: "iana",
        compressible: true,
        extensions: ["ico"]
      },
      "image/vnd.mix": {
        source: "iana"
      },
      "image/vnd.mozilla.apng": {
        source: "iana"
      },
      "image/vnd.ms-dds": {
        compressible: true,
        extensions: ["dds"]
      },
      "image/vnd.ms-modi": {
        source: "iana",
        extensions: ["mdi"]
      },
      "image/vnd.ms-photo": {
        source: "apache",
        extensions: ["wdp"]
      },
      "image/vnd.net-fpx": {
        source: "iana",
        extensions: ["npx"]
      },
      "image/vnd.pco.b16": {
        source: "iana",
        extensions: ["b16"]
      },
      "image/vnd.radiance": {
        source: "iana"
      },
      "image/vnd.sealed.png": {
        source: "iana"
      },
      "image/vnd.sealedmedia.softseal.gif": {
        source: "iana"
      },
      "image/vnd.sealedmedia.softseal.jpg": {
        source: "iana"
      },
      "image/vnd.svf": {
        source: "iana"
      },
      "image/vnd.tencent.tap": {
        source: "iana",
        extensions: ["tap"]
      },
      "image/vnd.valve.source.texture": {
        source: "iana",
        extensions: ["vtf"]
      },
      "image/vnd.wap.wbmp": {
        source: "iana",
        extensions: ["wbmp"]
      },
      "image/vnd.xiff": {
        source: "iana",
        extensions: ["xif"]
      },
      "image/vnd.zbrush.pcx": {
        source: "iana",
        extensions: ["pcx"]
      },
      "image/webp": {
        source: "apache",
        extensions: ["webp"]
      },
      "image/wmf": {
        source: "iana",
        extensions: ["wmf"]
      },
      "image/x-3ds": {
        source: "apache",
        extensions: ["3ds"]
      },
      "image/x-cmu-raster": {
        source: "apache",
        extensions: ["ras"]
      },
      "image/x-cmx": {
        source: "apache",
        extensions: ["cmx"]
      },
      "image/x-freehand": {
        source: "apache",
        extensions: ["fh", "fhc", "fh4", "fh5", "fh7"]
      },
      "image/x-icon": {
        source: "apache",
        compressible: true,
        extensions: ["ico"]
      },
      "image/x-jng": {
        source: "nginx",
        extensions: ["jng"]
      },
      "image/x-mrsid-image": {
        source: "apache",
        extensions: ["sid"]
      },
      "image/x-ms-bmp": {
        source: "nginx",
        compressible: true,
        extensions: ["bmp"]
      },
      "image/x-pcx": {
        source: "apache",
        extensions: ["pcx"]
      },
      "image/x-pict": {
        source: "apache",
        extensions: ["pic", "pct"]
      },
      "image/x-portable-anymap": {
        source: "apache",
        extensions: ["pnm"]
      },
      "image/x-portable-bitmap": {
        source: "apache",
        extensions: ["pbm"]
      },
      "image/x-portable-graymap": {
        source: "apache",
        extensions: ["pgm"]
      },
      "image/x-portable-pixmap": {
        source: "apache",
        extensions: ["ppm"]
      },
      "image/x-rgb": {
        source: "apache",
        extensions: ["rgb"]
      },
      "image/x-tga": {
        source: "apache",
        extensions: ["tga"]
      },
      "image/x-xbitmap": {
        source: "apache",
        extensions: ["xbm"]
      },
      "image/x-xcf": {
        compressible: false
      },
      "image/x-xpixmap": {
        source: "apache",
        extensions: ["xpm"]
      },
      "image/x-xwindowdump": {
        source: "apache",
        extensions: ["xwd"]
      },
      "message/cpim": {
        source: "iana"
      },
      "message/delivery-status": {
        source: "iana"
      },
      "message/disposition-notification": {
        source: "iana",
        extensions: [
          "disposition-notification"
        ]
      },
      "message/external-body": {
        source: "iana"
      },
      "message/feedback-report": {
        source: "iana"
      },
      "message/global": {
        source: "iana",
        extensions: ["u8msg"]
      },
      "message/global-delivery-status": {
        source: "iana",
        extensions: ["u8dsn"]
      },
      "message/global-disposition-notification": {
        source: "iana",
        extensions: ["u8mdn"]
      },
      "message/global-headers": {
        source: "iana",
        extensions: ["u8hdr"]
      },
      "message/http": {
        source: "iana",
        compressible: false
      },
      "message/imdn+xml": {
        source: "iana",
        compressible: true
      },
      "message/news": {
        source: "iana"
      },
      "message/partial": {
        source: "iana",
        compressible: false
      },
      "message/rfc822": {
        source: "iana",
        compressible: true,
        extensions: ["eml", "mime"]
      },
      "message/s-http": {
        source: "iana"
      },
      "message/sip": {
        source: "iana"
      },
      "message/sipfrag": {
        source: "iana"
      },
      "message/tracking-status": {
        source: "iana"
      },
      "message/vnd.si.simp": {
        source: "iana"
      },
      "message/vnd.wfa.wsc": {
        source: "iana",
        extensions: ["wsc"]
      },
      "model/3mf": {
        source: "iana",
        extensions: ["3mf"]
      },
      "model/e57": {
        source: "iana"
      },
      "model/gltf+json": {
        source: "iana",
        compressible: true,
        extensions: ["gltf"]
      },
      "model/gltf-binary": {
        source: "iana",
        compressible: true,
        extensions: ["glb"]
      },
      "model/iges": {
        source: "iana",
        compressible: false,
        extensions: ["igs", "iges"]
      },
      "model/mesh": {
        source: "iana",
        compressible: false,
        extensions: ["msh", "mesh", "silo"]
      },
      "model/mtl": {
        source: "iana",
        extensions: ["mtl"]
      },
      "model/obj": {
        source: "iana",
        extensions: ["obj"]
      },
      "model/step": {
        source: "iana"
      },
      "model/step+xml": {
        source: "iana",
        compressible: true,
        extensions: ["stpx"]
      },
      "model/step+zip": {
        source: "iana",
        compressible: false,
        extensions: ["stpz"]
      },
      "model/step-xml+zip": {
        source: "iana",
        compressible: false,
        extensions: ["stpxz"]
      },
      "model/stl": {
        source: "iana",
        extensions: ["stl"]
      },
      "model/vnd.collada+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dae"]
      },
      "model/vnd.dwf": {
        source: "iana",
        extensions: ["dwf"]
      },
      "model/vnd.flatland.3dml": {
        source: "iana"
      },
      "model/vnd.gdl": {
        source: "iana",
        extensions: ["gdl"]
      },
      "model/vnd.gs-gdl": {
        source: "apache"
      },
      "model/vnd.gs.gdl": {
        source: "iana"
      },
      "model/vnd.gtw": {
        source: "iana",
        extensions: ["gtw"]
      },
      "model/vnd.moml+xml": {
        source: "iana",
        compressible: true
      },
      "model/vnd.mts": {
        source: "iana",
        extensions: ["mts"]
      },
      "model/vnd.opengex": {
        source: "iana",
        extensions: ["ogex"]
      },
      "model/vnd.parasolid.transmit.binary": {
        source: "iana",
        extensions: ["x_b"]
      },
      "model/vnd.parasolid.transmit.text": {
        source: "iana",
        extensions: ["x_t"]
      },
      "model/vnd.pytha.pyox": {
        source: "iana"
      },
      "model/vnd.rosette.annotated-data-model": {
        source: "iana"
      },
      "model/vnd.sap.vds": {
        source: "iana",
        extensions: ["vds"]
      },
      "model/vnd.usdz+zip": {
        source: "iana",
        compressible: false,
        extensions: ["usdz"]
      },
      "model/vnd.valve.source.compiled-map": {
        source: "iana",
        extensions: ["bsp"]
      },
      "model/vnd.vtu": {
        source: "iana",
        extensions: ["vtu"]
      },
      "model/vrml": {
        source: "iana",
        compressible: false,
        extensions: ["wrl", "vrml"]
      },
      "model/x3d+binary": {
        source: "apache",
        compressible: false,
        extensions: ["x3db", "x3dbz"]
      },
      "model/x3d+fastinfoset": {
        source: "iana",
        extensions: ["x3db"]
      },
      "model/x3d+vrml": {
        source: "apache",
        compressible: false,
        extensions: ["x3dv", "x3dvz"]
      },
      "model/x3d+xml": {
        source: "iana",
        compressible: true,
        extensions: ["x3d", "x3dz"]
      },
      "model/x3d-vrml": {
        source: "iana",
        extensions: ["x3dv"]
      },
      "multipart/alternative": {
        source: "iana",
        compressible: false
      },
      "multipart/appledouble": {
        source: "iana"
      },
      "multipart/byteranges": {
        source: "iana"
      },
      "multipart/digest": {
        source: "iana"
      },
      "multipart/encrypted": {
        source: "iana",
        compressible: false
      },
      "multipart/form-data": {
        source: "iana",
        compressible: false
      },
      "multipart/header-set": {
        source: "iana"
      },
      "multipart/mixed": {
        source: "iana"
      },
      "multipart/multilingual": {
        source: "iana"
      },
      "multipart/parallel": {
        source: "iana"
      },
      "multipart/related": {
        source: "iana",
        compressible: false
      },
      "multipart/report": {
        source: "iana"
      },
      "multipart/signed": {
        source: "iana",
        compressible: false
      },
      "multipart/vnd.bint.med-plus": {
        source: "iana"
      },
      "multipart/voice-message": {
        source: "iana"
      },
      "multipart/x-mixed-replace": {
        source: "iana"
      },
      "text/1d-interleaved-parityfec": {
        source: "iana"
      },
      "text/cache-manifest": {
        source: "iana",
        compressible: true,
        extensions: ["appcache", "manifest"]
      },
      "text/calendar": {
        source: "iana",
        extensions: ["ics", "ifb"]
      },
      "text/calender": {
        compressible: true
      },
      "text/cmd": {
        compressible: true
      },
      "text/coffeescript": {
        extensions: ["coffee", "litcoffee"]
      },
      "text/cql": {
        source: "iana"
      },
      "text/cql-expression": {
        source: "iana"
      },
      "text/cql-identifier": {
        source: "iana"
      },
      "text/css": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["css"]
      },
      "text/csv": {
        source: "iana",
        compressible: true,
        extensions: ["csv"]
      },
      "text/csv-schema": {
        source: "iana"
      },
      "text/directory": {
        source: "iana"
      },
      "text/dns": {
        source: "iana"
      },
      "text/ecmascript": {
        source: "iana"
      },
      "text/encaprtp": {
        source: "iana"
      },
      "text/enriched": {
        source: "iana"
      },
      "text/fhirpath": {
        source: "iana"
      },
      "text/flexfec": {
        source: "iana"
      },
      "text/fwdred": {
        source: "iana"
      },
      "text/gff3": {
        source: "iana"
      },
      "text/grammar-ref-list": {
        source: "iana"
      },
      "text/html": {
        source: "iana",
        compressible: true,
        extensions: ["html", "htm", "shtml"]
      },
      "text/jade": {
        extensions: ["jade"]
      },
      "text/javascript": {
        source: "iana",
        compressible: true
      },
      "text/jcr-cnd": {
        source: "iana"
      },
      "text/jsx": {
        compressible: true,
        extensions: ["jsx"]
      },
      "text/less": {
        compressible: true,
        extensions: ["less"]
      },
      "text/markdown": {
        source: "iana",
        compressible: true,
        extensions: ["markdown", "md"]
      },
      "text/mathml": {
        source: "nginx",
        extensions: ["mml"]
      },
      "text/mdx": {
        compressible: true,
        extensions: ["mdx"]
      },
      "text/mizar": {
        source: "iana"
      },
      "text/n3": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["n3"]
      },
      "text/parameters": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/parityfec": {
        source: "iana"
      },
      "text/plain": {
        source: "iana",
        compressible: true,
        extensions: ["txt", "text", "conf", "def", "list", "log", "in", "ini"]
      },
      "text/provenance-notation": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/prs.fallenstein.rst": {
        source: "iana"
      },
      "text/prs.lines.tag": {
        source: "iana",
        extensions: ["dsc"]
      },
      "text/prs.prop.logic": {
        source: "iana"
      },
      "text/raptorfec": {
        source: "iana"
      },
      "text/red": {
        source: "iana"
      },
      "text/rfc822-headers": {
        source: "iana"
      },
      "text/richtext": {
        source: "iana",
        compressible: true,
        extensions: ["rtx"]
      },
      "text/rtf": {
        source: "iana",
        compressible: true,
        extensions: ["rtf"]
      },
      "text/rtp-enc-aescm128": {
        source: "iana"
      },
      "text/rtploopback": {
        source: "iana"
      },
      "text/rtx": {
        source: "iana"
      },
      "text/sgml": {
        source: "iana",
        extensions: ["sgml", "sgm"]
      },
      "text/shaclc": {
        source: "iana"
      },
      "text/shex": {
        source: "iana",
        extensions: ["shex"]
      },
      "text/slim": {
        extensions: ["slim", "slm"]
      },
      "text/spdx": {
        source: "iana",
        extensions: ["spdx"]
      },
      "text/strings": {
        source: "iana"
      },
      "text/stylus": {
        extensions: ["stylus", "styl"]
      },
      "text/t140": {
        source: "iana"
      },
      "text/tab-separated-values": {
        source: "iana",
        compressible: true,
        extensions: ["tsv"]
      },
      "text/troff": {
        source: "iana",
        extensions: ["t", "tr", "roff", "man", "me", "ms"]
      },
      "text/turtle": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["ttl"]
      },
      "text/ulpfec": {
        source: "iana"
      },
      "text/uri-list": {
        source: "iana",
        compressible: true,
        extensions: ["uri", "uris", "urls"]
      },
      "text/vcard": {
        source: "iana",
        compressible: true,
        extensions: ["vcard"]
      },
      "text/vnd.a": {
        source: "iana"
      },
      "text/vnd.abc": {
        source: "iana"
      },
      "text/vnd.ascii-art": {
        source: "iana"
      },
      "text/vnd.curl": {
        source: "iana",
        extensions: ["curl"]
      },
      "text/vnd.curl.dcurl": {
        source: "apache",
        extensions: ["dcurl"]
      },
      "text/vnd.curl.mcurl": {
        source: "apache",
        extensions: ["mcurl"]
      },
      "text/vnd.curl.scurl": {
        source: "apache",
        extensions: ["scurl"]
      },
      "text/vnd.debian.copyright": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/vnd.dmclientscript": {
        source: "iana"
      },
      "text/vnd.dvb.subtitle": {
        source: "iana",
        extensions: ["sub"]
      },
      "text/vnd.esmertec.theme-descriptor": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/vnd.familysearch.gedcom": {
        source: "iana",
        extensions: ["ged"]
      },
      "text/vnd.ficlab.flt": {
        source: "iana"
      },
      "text/vnd.fly": {
        source: "iana",
        extensions: ["fly"]
      },
      "text/vnd.fmi.flexstor": {
        source: "iana",
        extensions: ["flx"]
      },
      "text/vnd.gml": {
        source: "iana"
      },
      "text/vnd.graphviz": {
        source: "iana",
        extensions: ["gv"]
      },
      "text/vnd.hans": {
        source: "iana"
      },
      "text/vnd.hgl": {
        source: "iana"
      },
      "text/vnd.in3d.3dml": {
        source: "iana",
        extensions: ["3dml"]
      },
      "text/vnd.in3d.spot": {
        source: "iana",
        extensions: ["spot"]
      },
      "text/vnd.iptc.newsml": {
        source: "iana"
      },
      "text/vnd.iptc.nitf": {
        source: "iana"
      },
      "text/vnd.latex-z": {
        source: "iana"
      },
      "text/vnd.motorola.reflex": {
        source: "iana"
      },
      "text/vnd.ms-mediapackage": {
        source: "iana"
      },
      "text/vnd.net2phone.commcenter.command": {
        source: "iana"
      },
      "text/vnd.radisys.msml-basic-layout": {
        source: "iana"
      },
      "text/vnd.senx.warpscript": {
        source: "iana"
      },
      "text/vnd.si.uricatalogue": {
        source: "iana"
      },
      "text/vnd.sosi": {
        source: "iana"
      },
      "text/vnd.sun.j2me.app-descriptor": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["jad"]
      },
      "text/vnd.trolltech.linguist": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/vnd.wap.si": {
        source: "iana"
      },
      "text/vnd.wap.sl": {
        source: "iana"
      },
      "text/vnd.wap.wml": {
        source: "iana",
        extensions: ["wml"]
      },
      "text/vnd.wap.wmlscript": {
        source: "iana",
        extensions: ["wmls"]
      },
      "text/vtt": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["vtt"]
      },
      "text/x-asm": {
        source: "apache",
        extensions: ["s", "asm"]
      },
      "text/x-c": {
        source: "apache",
        extensions: ["c", "cc", "cxx", "cpp", "h", "hh", "dic"]
      },
      "text/x-component": {
        source: "nginx",
        extensions: ["htc"]
      },
      "text/x-fortran": {
        source: "apache",
        extensions: ["f", "for", "f77", "f90"]
      },
      "text/x-gwt-rpc": {
        compressible: true
      },
      "text/x-handlebars-template": {
        extensions: ["hbs"]
      },
      "text/x-java-source": {
        source: "apache",
        extensions: ["java"]
      },
      "text/x-jquery-tmpl": {
        compressible: true
      },
      "text/x-lua": {
        extensions: ["lua"]
      },
      "text/x-markdown": {
        compressible: true,
        extensions: ["mkd"]
      },
      "text/x-nfo": {
        source: "apache",
        extensions: ["nfo"]
      },
      "text/x-opml": {
        source: "apache",
        extensions: ["opml"]
      },
      "text/x-org": {
        compressible: true,
        extensions: ["org"]
      },
      "text/x-pascal": {
        source: "apache",
        extensions: ["p", "pas"]
      },
      "text/x-processing": {
        compressible: true,
        extensions: ["pde"]
      },
      "text/x-sass": {
        extensions: ["sass"]
      },
      "text/x-scss": {
        extensions: ["scss"]
      },
      "text/x-setext": {
        source: "apache",
        extensions: ["etx"]
      },
      "text/x-sfv": {
        source: "apache",
        extensions: ["sfv"]
      },
      "text/x-suse-ymp": {
        compressible: true,
        extensions: ["ymp"]
      },
      "text/x-uuencode": {
        source: "apache",
        extensions: ["uu"]
      },
      "text/x-vcalendar": {
        source: "apache",
        extensions: ["vcs"]
      },
      "text/x-vcard": {
        source: "apache",
        extensions: ["vcf"]
      },
      "text/xml": {
        source: "iana",
        compressible: true,
        extensions: ["xml"]
      },
      "text/xml-external-parsed-entity": {
        source: "iana"
      },
      "text/yaml": {
        compressible: true,
        extensions: ["yaml", "yml"]
      },
      "video/1d-interleaved-parityfec": {
        source: "iana"
      },
      "video/3gpp": {
        source: "iana",
        extensions: ["3gp", "3gpp"]
      },
      "video/3gpp-tt": {
        source: "iana"
      },
      "video/3gpp2": {
        source: "iana",
        extensions: ["3g2"]
      },
      "video/av1": {
        source: "iana"
      },
      "video/bmpeg": {
        source: "iana"
      },
      "video/bt656": {
        source: "iana"
      },
      "video/celb": {
        source: "iana"
      },
      "video/dv": {
        source: "iana"
      },
      "video/encaprtp": {
        source: "iana"
      },
      "video/ffv1": {
        source: "iana"
      },
      "video/flexfec": {
        source: "iana"
      },
      "video/h261": {
        source: "iana",
        extensions: ["h261"]
      },
      "video/h263": {
        source: "iana",
        extensions: ["h263"]
      },
      "video/h263-1998": {
        source: "iana"
      },
      "video/h263-2000": {
        source: "iana"
      },
      "video/h264": {
        source: "iana",
        extensions: ["h264"]
      },
      "video/h264-rcdo": {
        source: "iana"
      },
      "video/h264-svc": {
        source: "iana"
      },
      "video/h265": {
        source: "iana"
      },
      "video/iso.segment": {
        source: "iana",
        extensions: ["m4s"]
      },
      "video/jpeg": {
        source: "iana",
        extensions: ["jpgv"]
      },
      "video/jpeg2000": {
        source: "iana"
      },
      "video/jpm": {
        source: "apache",
        extensions: ["jpm", "jpgm"]
      },
      "video/jxsv": {
        source: "iana"
      },
      "video/mj2": {
        source: "iana",
        extensions: ["mj2", "mjp2"]
      },
      "video/mp1s": {
        source: "iana"
      },
      "video/mp2p": {
        source: "iana"
      },
      "video/mp2t": {
        source: "iana",
        extensions: ["ts"]
      },
      "video/mp4": {
        source: "iana",
        compressible: false,
        extensions: ["mp4", "mp4v", "mpg4"]
      },
      "video/mp4v-es": {
        source: "iana"
      },
      "video/mpeg": {
        source: "iana",
        compressible: false,
        extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"]
      },
      "video/mpeg4-generic": {
        source: "iana"
      },
      "video/mpv": {
        source: "iana"
      },
      "video/nv": {
        source: "iana"
      },
      "video/ogg": {
        source: "iana",
        compressible: false,
        extensions: ["ogv"]
      },
      "video/parityfec": {
        source: "iana"
      },
      "video/pointer": {
        source: "iana"
      },
      "video/quicktime": {
        source: "iana",
        compressible: false,
        extensions: ["qt", "mov"]
      },
      "video/raptorfec": {
        source: "iana"
      },
      "video/raw": {
        source: "iana"
      },
      "video/rtp-enc-aescm128": {
        source: "iana"
      },
      "video/rtploopback": {
        source: "iana"
      },
      "video/rtx": {
        source: "iana"
      },
      "video/scip": {
        source: "iana"
      },
      "video/smpte291": {
        source: "iana"
      },
      "video/smpte292m": {
        source: "iana"
      },
      "video/ulpfec": {
        source: "iana"
      },
      "video/vc1": {
        source: "iana"
      },
      "video/vc2": {
        source: "iana"
      },
      "video/vnd.cctv": {
        source: "iana"
      },
      "video/vnd.dece.hd": {
        source: "iana",
        extensions: ["uvh", "uvvh"]
      },
      "video/vnd.dece.mobile": {
        source: "iana",
        extensions: ["uvm", "uvvm"]
      },
      "video/vnd.dece.mp4": {
        source: "iana"
      },
      "video/vnd.dece.pd": {
        source: "iana",
        extensions: ["uvp", "uvvp"]
      },
      "video/vnd.dece.sd": {
        source: "iana",
        extensions: ["uvs", "uvvs"]
      },
      "video/vnd.dece.video": {
        source: "iana",
        extensions: ["uvv", "uvvv"]
      },
      "video/vnd.directv.mpeg": {
        source: "iana"
      },
      "video/vnd.directv.mpeg-tts": {
        source: "iana"
      },
      "video/vnd.dlna.mpeg-tts": {
        source: "iana"
      },
      "video/vnd.dvb.file": {
        source: "iana",
        extensions: ["dvb"]
      },
      "video/vnd.fvt": {
        source: "iana",
        extensions: ["fvt"]
      },
      "video/vnd.hns.video": {
        source: "iana"
      },
      "video/vnd.iptvforum.1dparityfec-1010": {
        source: "iana"
      },
      "video/vnd.iptvforum.1dparityfec-2005": {
        source: "iana"
      },
      "video/vnd.iptvforum.2dparityfec-1010": {
        source: "iana"
      },
      "video/vnd.iptvforum.2dparityfec-2005": {
        source: "iana"
      },
      "video/vnd.iptvforum.ttsavc": {
        source: "iana"
      },
      "video/vnd.iptvforum.ttsmpeg2": {
        source: "iana"
      },
      "video/vnd.motorola.video": {
        source: "iana"
      },
      "video/vnd.motorola.videop": {
        source: "iana"
      },
      "video/vnd.mpegurl": {
        source: "iana",
        extensions: ["mxu", "m4u"]
      },
      "video/vnd.ms-playready.media.pyv": {
        source: "iana",
        extensions: ["pyv"]
      },
      "video/vnd.nokia.interleaved-multimedia": {
        source: "iana"
      },
      "video/vnd.nokia.mp4vr": {
        source: "iana"
      },
      "video/vnd.nokia.videovoip": {
        source: "iana"
      },
      "video/vnd.objectvideo": {
        source: "iana"
      },
      "video/vnd.radgamettools.bink": {
        source: "iana"
      },
      "video/vnd.radgamettools.smacker": {
        source: "iana"
      },
      "video/vnd.sealed.mpeg1": {
        source: "iana"
      },
      "video/vnd.sealed.mpeg4": {
        source: "iana"
      },
      "video/vnd.sealed.swf": {
        source: "iana"
      },
      "video/vnd.sealedmedia.softseal.mov": {
        source: "iana"
      },
      "video/vnd.uvvu.mp4": {
        source: "iana",
        extensions: ["uvu", "uvvu"]
      },
      "video/vnd.vivo": {
        source: "iana",
        extensions: ["viv"]
      },
      "video/vnd.youtube.yt": {
        source: "iana"
      },
      "video/vp8": {
        source: "iana"
      },
      "video/vp9": {
        source: "iana"
      },
      "video/webm": {
        source: "apache",
        compressible: false,
        extensions: ["webm"]
      },
      "video/x-f4v": {
        source: "apache",
        extensions: ["f4v"]
      },
      "video/x-fli": {
        source: "apache",
        extensions: ["fli"]
      },
      "video/x-flv": {
        source: "apache",
        compressible: false,
        extensions: ["flv"]
      },
      "video/x-m4v": {
        source: "apache",
        extensions: ["m4v"]
      },
      "video/x-matroska": {
        source: "apache",
        compressible: false,
        extensions: ["mkv", "mk3d", "mks"]
      },
      "video/x-mng": {
        source: "apache",
        extensions: ["mng"]
      },
      "video/x-ms-asf": {
        source: "apache",
        extensions: ["asf", "asx"]
      },
      "video/x-ms-vob": {
        source: "apache",
        extensions: ["vob"]
      },
      "video/x-ms-wm": {
        source: "apache",
        extensions: ["wm"]
      },
      "video/x-ms-wmv": {
        source: "apache",
        compressible: false,
        extensions: ["wmv"]
      },
      "video/x-ms-wmx": {
        source: "apache",
        extensions: ["wmx"]
      },
      "video/x-ms-wvx": {
        source: "apache",
        extensions: ["wvx"]
      },
      "video/x-msvideo": {
        source: "apache",
        extensions: ["avi"]
      },
      "video/x-sgi-movie": {
        source: "apache",
        extensions: ["movie"]
      },
      "video/x-smv": {
        source: "apache",
        extensions: ["smv"]
      },
      "x-conference/x-cooltalk": {
        source: "apache",
        extensions: ["ice"]
      },
      "x-shader/x-fragment": {
        compressible: true
      },
      "x-shader/x-vertex": {
        compressible: true
      }
    };
  }
});

// node_modules/accepts/node_modules/mime-db/index.js
var require_mime_db2 = __commonJS({
  "node_modules/accepts/node_modules/mime-db/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_db2();
  }
});

// node_modules/accepts/node_modules/mime-types/index.js
var require_mime_types2 = __commonJS({
  "node_modules/accepts/node_modules/mime-types/index.js"(exports2) {
    "use strict";
    var db2 = require_mime_db2();
    var extname = require("path").extname;
    var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
    var TEXT_TYPE_REGEXP = /^text\//i;
    exports2.charset = charset;
    exports2.charsets = { lookup: charset };
    exports2.contentType = contentType;
    exports2.extension = extension;
    exports2.extensions = /* @__PURE__ */ Object.create(null);
    exports2.lookup = lookup;
    exports2.types = /* @__PURE__ */ Object.create(null);
    populateMaps(exports2.extensions, exports2.types);
    function charset(type) {
      if (!type || typeof type !== "string") {
        return false;
      }
      var match = EXTRACT_TYPE_REGEXP.exec(type);
      var mime = match && db2[match[1].toLowerCase()];
      if (mime && mime.charset) {
        return mime.charset;
      }
      if (match && TEXT_TYPE_REGEXP.test(match[1])) {
        return "UTF-8";
      }
      return false;
    }
    function contentType(str) {
      if (!str || typeof str !== "string") {
        return false;
      }
      var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str;
      if (!mime) {
        return false;
      }
      if (mime.indexOf("charset") === -1) {
        var charset2 = exports2.charset(mime);
        if (charset2) mime += "; charset=" + charset2.toLowerCase();
      }
      return mime;
    }
    function extension(type) {
      if (!type || typeof type !== "string") {
        return false;
      }
      var match = EXTRACT_TYPE_REGEXP.exec(type);
      var exts = match && exports2.extensions[match[1].toLowerCase()];
      if (!exts || !exts.length) {
        return false;
      }
      return exts[0];
    }
    function lookup(path33) {
      if (!path33 || typeof path33 !== "string") {
        return false;
      }
      var extension2 = extname("x." + path33).toLowerCase().substr(1);
      if (!extension2) {
        return false;
      }
      return exports2.types[extension2] || false;
    }
    function populateMaps(extensions, types) {
      var preference = ["nginx", "apache", void 0, "iana"];
      Object.keys(db2).forEach(function forEachMimeType(type) {
        var mime = db2[type];
        var exts = mime.extensions;
        if (!exts || !exts.length) {
          return;
        }
        extensions[type] = exts;
        for (var i = 0; i < exts.length; i++) {
          var extension2 = exts[i];
          if (types[extension2]) {
            var from = preference.indexOf(db2[types[extension2]].source);
            var to = preference.indexOf(mime.source);
            if (types[extension2] !== "application/octet-stream" && (from > to || from === to && types[extension2].substr(0, 12) === "application/")) {
              continue;
            }
          }
          types[extension2] = type;
        }
      });
    }
  }
});

// node_modules/accepts/index.js
var require_accepts2 = __commonJS({
  "node_modules/accepts/index.js"(exports2, module2) {
    "use strict";
    var Negotiator = require_negotiator2();
    var mime = require_mime_types2();
    module2.exports = Accepts;
    function Accepts(req) {
      if (!(this instanceof Accepts)) {
        return new Accepts(req);
      }
      this.headers = req.headers;
      this.negotiator = new Negotiator(req);
    }
    Accepts.prototype.type = Accepts.prototype.types = function(types_) {
      var types = types_;
      if (types && !Array.isArray(types)) {
        types = new Array(arguments.length);
        for (var i = 0; i < types.length; i++) {
          types[i] = arguments[i];
        }
      }
      if (!types || types.length === 0) {
        return this.negotiator.mediaTypes();
      }
      if (!this.headers.accept) {
        return types[0];
      }
      var mimes = types.map(extToMime);
      var accepts = this.negotiator.mediaTypes(mimes.filter(validMime));
      var first = accepts[0];
      return first ? types[mimes.indexOf(first)] : false;
    };
    Accepts.prototype.encoding = Accepts.prototype.encodings = function(encodings_) {
      var encodings = encodings_;
      if (encodings && !Array.isArray(encodings)) {
        encodings = new Array(arguments.length);
        for (var i = 0; i < encodings.length; i++) {
          encodings[i] = arguments[i];
        }
      }
      if (!encodings || encodings.length === 0) {
        return this.negotiator.encodings();
      }
      return this.negotiator.encodings(encodings)[0] || false;
    };
    Accepts.prototype.charset = Accepts.prototype.charsets = function(charsets_) {
      var charsets = charsets_;
      if (charsets && !Array.isArray(charsets)) {
        charsets = new Array(arguments.length);
        for (var i = 0; i < charsets.length; i++) {
          charsets[i] = arguments[i];
        }
      }
      if (!charsets || charsets.length === 0) {
        return this.negotiator.charsets();
      }
      return this.negotiator.charsets(charsets)[0] || false;
    };
    Accepts.prototype.lang = Accepts.prototype.langs = Accepts.prototype.language = Accepts.prototype.languages = function(languages_) {
      var languages = languages_;
      if (languages && !Array.isArray(languages)) {
        languages = new Array(arguments.length);
        for (var i = 0; i < languages.length; i++) {
          languages[i] = arguments[i];
        }
      }
      if (!languages || languages.length === 0) {
        return this.negotiator.languages();
      }
      return this.negotiator.languages(languages)[0] || false;
    };
    function extToMime(type) {
      return type.indexOf("/") === -1 ? mime.lookup(type) : type;
    }
    function validMime(type) {
      return typeof type === "string";
    }
  }
});

// node_modules/base64id/lib/base64id.js
var require_base64id = __commonJS({
  "node_modules/base64id/lib/base64id.js"(exports2, module2) {
    "use strict";
    var crypto7 = require("crypto");
    var Base64Id = function() {
    };
    Base64Id.prototype.getRandomBytes = function(bytes) {
      var BUFFER_SIZE = 4096;
      var self2 = this;
      bytes = bytes || 12;
      if (bytes > BUFFER_SIZE) {
        return crypto7.randomBytes(bytes);
      }
      var bytesInBuffer = parseInt(BUFFER_SIZE / bytes);
      var threshold = parseInt(bytesInBuffer * 0.85);
      if (!threshold) {
        return crypto7.randomBytes(bytes);
      }
      if (this.bytesBufferIndex == null) {
        this.bytesBufferIndex = -1;
      }
      if (this.bytesBufferIndex == bytesInBuffer) {
        this.bytesBuffer = null;
        this.bytesBufferIndex = -1;
      }
      if (this.bytesBufferIndex == -1 || this.bytesBufferIndex > threshold) {
        if (!this.isGeneratingBytes) {
          this.isGeneratingBytes = true;
          crypto7.randomBytes(BUFFER_SIZE, function(err, bytes2) {
            self2.bytesBuffer = bytes2;
            self2.bytesBufferIndex = 0;
            self2.isGeneratingBytes = false;
          });
        }
        if (this.bytesBufferIndex == -1) {
          return crypto7.randomBytes(bytes);
        }
      }
      var result = this.bytesBuffer.slice(bytes * this.bytesBufferIndex, bytes * (this.bytesBufferIndex + 1));
      this.bytesBufferIndex++;
      return result;
    };
    Base64Id.prototype.generateId = function() {
      var rand = Buffer.alloc(15);
      if (!rand.writeInt32BE) {
        return Math.abs(Math.random() * Math.random() * Date.now() | 0).toString() + Math.abs(Math.random() * Math.random() * Date.now() | 0).toString();
      }
      this.sequenceNumber = this.sequenceNumber + 1 | 0;
      rand.writeInt32BE(this.sequenceNumber, 11);
      if (crypto7.randomBytes) {
        this.getRandomBytes(12).copy(rand);
      } else {
        [0, 4, 8].forEach(function(i) {
          rand.writeInt32BE(Math.random() * Math.pow(2, 32) | 0, i);
        });
      }
      return rand.toString("base64").replace(/\//g, "_").replace(/\+/g, "-");
    };
    exports2 = module2.exports = new Base64Id();
  }
});

// node_modules/engine.io-parser/build/cjs/commons.js
var require_commons = __commonJS({
  "node_modules/engine.io-parser/build/cjs/commons.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ERROR_PACKET = exports2.PACKET_TYPES_REVERSE = exports2.PACKET_TYPES = void 0;
    var PACKET_TYPES = /* @__PURE__ */ Object.create(null);
    exports2.PACKET_TYPES = PACKET_TYPES;
    PACKET_TYPES["open"] = "0";
    PACKET_TYPES["close"] = "1";
    PACKET_TYPES["ping"] = "2";
    PACKET_TYPES["pong"] = "3";
    PACKET_TYPES["message"] = "4";
    PACKET_TYPES["upgrade"] = "5";
    PACKET_TYPES["noop"] = "6";
    var PACKET_TYPES_REVERSE = /* @__PURE__ */ Object.create(null);
    exports2.PACKET_TYPES_REVERSE = PACKET_TYPES_REVERSE;
    Object.keys(PACKET_TYPES).forEach((key) => {
      PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
    });
    var ERROR_PACKET = { type: "error", data: "parser error" };
    exports2.ERROR_PACKET = ERROR_PACKET;
  }
});

// node_modules/engine.io-parser/build/cjs/encodePacket.js
var require_encodePacket = __commonJS({
  "node_modules/engine.io-parser/build/cjs/encodePacket.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.encodePacket = void 0;
    exports2.encodePacketToBinary = encodePacketToBinary;
    var commons_js_1 = require_commons();
    var encodePacket = ({ type, data }, supportsBinary, callback) => {
      if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
        return callback(supportsBinary ? data : "b" + toBuffer(data, true).toString("base64"));
      }
      return callback(commons_js_1.PACKET_TYPES[type] + (data || ""));
    };
    exports2.encodePacket = encodePacket;
    var toBuffer = (data, forceBufferConversion) => {
      if (Buffer.isBuffer(data) || data instanceof Uint8Array && !forceBufferConversion) {
        return data;
      } else if (data instanceof ArrayBuffer) {
        return Buffer.from(data);
      } else {
        return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
      }
    };
    var TEXT_ENCODER;
    function encodePacketToBinary(packet, callback) {
      if (packet.data instanceof ArrayBuffer || ArrayBuffer.isView(packet.data)) {
        return callback(toBuffer(packet.data, false));
      }
      (0, exports2.encodePacket)(packet, true, (encoded) => {
        if (!TEXT_ENCODER) {
          TEXT_ENCODER = new TextEncoder();
        }
        callback(TEXT_ENCODER.encode(encoded));
      });
    }
  }
});

// node_modules/engine.io-parser/build/cjs/decodePacket.js
var require_decodePacket = __commonJS({
  "node_modules/engine.io-parser/build/cjs/decodePacket.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.decodePacket = void 0;
    var commons_js_1 = require_commons();
    var decodePacket = (encodedPacket, binaryType) => {
      if (typeof encodedPacket !== "string") {
        return {
          type: "message",
          data: mapBinary(encodedPacket, binaryType)
        };
      }
      const type = encodedPacket.charAt(0);
      if (type === "b") {
        const buffer = Buffer.from(encodedPacket.substring(1), "base64");
        return {
          type: "message",
          data: mapBinary(buffer, binaryType)
        };
      }
      if (!commons_js_1.PACKET_TYPES_REVERSE[type]) {
        return commons_js_1.ERROR_PACKET;
      }
      return encodedPacket.length > 1 ? {
        type: commons_js_1.PACKET_TYPES_REVERSE[type],
        data: encodedPacket.substring(1)
      } : {
        type: commons_js_1.PACKET_TYPES_REVERSE[type]
      };
    };
    exports2.decodePacket = decodePacket;
    var mapBinary = (data, binaryType) => {
      switch (binaryType) {
        case "arraybuffer":
          if (data instanceof ArrayBuffer) {
            return data;
          } else if (Buffer.isBuffer(data)) {
            return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
          } else {
            return data.buffer;
          }
        case "nodebuffer":
        default:
          if (Buffer.isBuffer(data)) {
            return data;
          } else {
            return Buffer.from(data);
          }
      }
    };
  }
});

// node_modules/engine.io-parser/build/cjs/index.js
var require_cjs = __commonJS({
  "node_modules/engine.io-parser/build/cjs/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.decodePayload = exports2.decodePacket = exports2.encodePayload = exports2.encodePacket = exports2.protocol = void 0;
    exports2.createPacketEncoderStream = createPacketEncoderStream;
    exports2.createPacketDecoderStream = createPacketDecoderStream;
    var encodePacket_js_1 = require_encodePacket();
    Object.defineProperty(exports2, "encodePacket", { enumerable: true, get: function() {
      return encodePacket_js_1.encodePacket;
    } });
    var decodePacket_js_1 = require_decodePacket();
    Object.defineProperty(exports2, "decodePacket", { enumerable: true, get: function() {
      return decodePacket_js_1.decodePacket;
    } });
    var commons_js_1 = require_commons();
    var SEPARATOR = String.fromCharCode(30);
    var encodePayload = (packets, callback) => {
      const length = packets.length;
      const encodedPackets = new Array(length);
      let count = 0;
      packets.forEach((packet, i) => {
        (0, encodePacket_js_1.encodePacket)(packet, false, (encodedPacket) => {
          encodedPackets[i] = encodedPacket;
          if (++count === length) {
            callback(encodedPackets.join(SEPARATOR));
          }
        });
      });
    };
    exports2.encodePayload = encodePayload;
    var decodePayload = (encodedPayload, binaryType) => {
      const encodedPackets = encodedPayload.split(SEPARATOR);
      const packets = [];
      for (let i = 0; i < encodedPackets.length; i++) {
        const decodedPacket = (0, decodePacket_js_1.decodePacket)(encodedPackets[i], binaryType);
        packets.push(decodedPacket);
        if (decodedPacket.type === "error") {
          break;
        }
      }
      return packets;
    };
    exports2.decodePayload = decodePayload;
    function createPacketEncoderStream() {
      return new TransformStream({
        transform(packet, controller) {
          (0, encodePacket_js_1.encodePacketToBinary)(packet, (encodedPacket) => {
            const payloadLength = encodedPacket.length;
            let header;
            if (payloadLength < 126) {
              header = new Uint8Array(1);
              new DataView(header.buffer).setUint8(0, payloadLength);
            } else if (payloadLength < 65536) {
              header = new Uint8Array(3);
              const view = new DataView(header.buffer);
              view.setUint8(0, 126);
              view.setUint16(1, payloadLength);
            } else {
              header = new Uint8Array(9);
              const view = new DataView(header.buffer);
              view.setUint8(0, 127);
              view.setBigUint64(1, BigInt(payloadLength));
            }
            if (packet.data && typeof packet.data !== "string") {
              header[0] |= 128;
            }
            controller.enqueue(header);
            controller.enqueue(encodedPacket);
          });
        }
      });
    }
    var TEXT_DECODER;
    function totalLength(chunks) {
      return chunks.reduce((acc, chunk) => acc + chunk.length, 0);
    }
    function concatChunks(chunks, size) {
      if (chunks[0].length === size) {
        return chunks.shift();
      }
      const buffer = new Uint8Array(size);
      let j = 0;
      for (let i = 0; i < size; i++) {
        buffer[i] = chunks[0][j++];
        if (j === chunks[0].length) {
          chunks.shift();
          j = 0;
        }
      }
      if (chunks.length && j < chunks[0].length) {
        chunks[0] = chunks[0].slice(j);
      }
      return buffer;
    }
    function createPacketDecoderStream(maxPayload, binaryType) {
      if (!TEXT_DECODER) {
        TEXT_DECODER = new TextDecoder();
      }
      const chunks = [];
      let state = 0;
      let expectedLength = -1;
      let isBinary = false;
      return new TransformStream({
        transform(chunk, controller) {
          chunks.push(chunk);
          while (true) {
            if (state === 0) {
              if (totalLength(chunks) < 1) {
                break;
              }
              const header = concatChunks(chunks, 1);
              isBinary = (header[0] & 128) === 128;
              expectedLength = header[0] & 127;
              if (expectedLength < 126) {
                state = 3;
              } else if (expectedLength === 126) {
                state = 1;
              } else {
                state = 2;
              }
            } else if (state === 1) {
              if (totalLength(chunks) < 2) {
                break;
              }
              const headerArray = concatChunks(chunks, 2);
              expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);
              state = 3;
            } else if (state === 2) {
              if (totalLength(chunks) < 8) {
                break;
              }
              const headerArray = concatChunks(chunks, 8);
              const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);
              const n = view.getUint32(0);
              if (n > Math.pow(2, 53 - 32) - 1) {
                controller.enqueue(commons_js_1.ERROR_PACKET);
                break;
              }
              expectedLength = n * Math.pow(2, 32) + view.getUint32(4);
              state = 3;
            } else {
              if (totalLength(chunks) < expectedLength) {
                break;
              }
              const data = concatChunks(chunks, expectedLength);
              controller.enqueue((0, decodePacket_js_1.decodePacket)(isBinary ? data : TEXT_DECODER.decode(data), binaryType));
              state = 0;
            }
            if (expectedLength === 0 || expectedLength > maxPayload) {
              controller.enqueue(commons_js_1.ERROR_PACKET);
              break;
            }
          }
        }
      });
    }
    exports2.protocol = 4;
  }
});

// node_modules/engine.io/build/parser-v3/utf8.js
var require_utf8 = __commonJS({
  "node_modules/engine.io/build/parser-v3/utf8.js"(exports2, module2) {
    "use strict";
    var stringFromCharCode = String.fromCharCode;
    function ucs2decode(string5) {
      var output = [];
      var counter = 0;
      var length = string5.length;
      var value;
      var extra;
      while (counter < length) {
        value = string5.charCodeAt(counter++);
        if (value >= 55296 && value <= 56319 && counter < length) {
          extra = string5.charCodeAt(counter++);
          if ((extra & 64512) == 56320) {
            output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
          } else {
            output.push(value);
            counter--;
          }
        } else {
          output.push(value);
        }
      }
      return output;
    }
    function ucs2encode(array4) {
      var length = array4.length;
      var index = -1;
      var value;
      var output = "";
      while (++index < length) {
        value = array4[index];
        if (value > 65535) {
          value -= 65536;
          output += stringFromCharCode(value >>> 10 & 1023 | 55296);
          value = 56320 | value & 1023;
        }
        output += stringFromCharCode(value);
      }
      return output;
    }
    function checkScalarValue(codePoint, strict) {
      if (codePoint >= 55296 && codePoint <= 57343) {
        if (strict) {
          throw Error("Lone surrogate U+" + codePoint.toString(16).toUpperCase() + " is not a scalar value");
        }
        return false;
      }
      return true;
    }
    function createByte(codePoint, shift) {
      return stringFromCharCode(codePoint >> shift & 63 | 128);
    }
    function encodeCodePoint(codePoint, strict) {
      if ((codePoint & 4294967168) == 0) {
        return stringFromCharCode(codePoint);
      }
      var symbol30 = "";
      if ((codePoint & 4294965248) == 0) {
        symbol30 = stringFromCharCode(codePoint >> 6 & 31 | 192);
      } else if ((codePoint & 4294901760) == 0) {
        if (!checkScalarValue(codePoint, strict)) {
          codePoint = 65533;
        }
        symbol30 = stringFromCharCode(codePoint >> 12 & 15 | 224);
        symbol30 += createByte(codePoint, 6);
      } else if ((codePoint & 4292870144) == 0) {
        symbol30 = stringFromCharCode(codePoint >> 18 & 7 | 240);
        symbol30 += createByte(codePoint, 12);
        symbol30 += createByte(codePoint, 6);
      }
      symbol30 += stringFromCharCode(codePoint & 63 | 128);
      return symbol30;
    }
    function utf8encode(string5, opts) {
      opts = opts || {};
      var strict = false !== opts.strict;
      var codePoints = ucs2decode(string5);
      var length = codePoints.length;
      var index = -1;
      var codePoint;
      var byteString = "";
      while (++index < length) {
        codePoint = codePoints[index];
        byteString += encodeCodePoint(codePoint, strict);
      }
      return byteString;
    }
    function readContinuationByte() {
      if (byteIndex >= byteCount) {
        throw Error("Invalid byte index");
      }
      var continuationByte = byteArray[byteIndex] & 255;
      byteIndex++;
      if ((continuationByte & 192) == 128) {
        return continuationByte & 63;
      }
      throw Error("Invalid continuation byte");
    }
    function decodeSymbol(strict) {
      var byte1;
      var byte2;
      var byte3;
      var byte4;
      var codePoint;
      if (byteIndex > byteCount) {
        throw Error("Invalid byte index");
      }
      if (byteIndex == byteCount) {
        return false;
      }
      byte1 = byteArray[byteIndex] & 255;
      byteIndex++;
      if ((byte1 & 128) == 0) {
        return byte1;
      }
      if ((byte1 & 224) == 192) {
        byte2 = readContinuationByte();
        codePoint = (byte1 & 31) << 6 | byte2;
        if (codePoint >= 128) {
          return codePoint;
        } else {
          throw Error("Invalid continuation byte");
        }
      }
      if ((byte1 & 240) == 224) {
        byte2 = readContinuationByte();
        byte3 = readContinuationByte();
        codePoint = (byte1 & 15) << 12 | byte2 << 6 | byte3;
        if (codePoint >= 2048) {
          return checkScalarValue(codePoint, strict) ? codePoint : 65533;
        } else {
          throw Error("Invalid continuation byte");
        }
      }
      if ((byte1 & 248) == 240) {
        byte2 = readContinuationByte();
        byte3 = readContinuationByte();
        byte4 = readContinuationByte();
        codePoint = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
        if (codePoint >= 65536 && codePoint <= 1114111) {
          return codePoint;
        }
      }
      throw Error("Invalid UTF-8 detected");
    }
    var byteArray;
    var byteCount;
    var byteIndex;
    function utf8decode(byteString, opts) {
      opts = opts || {};
      var strict = false !== opts.strict;
      byteArray = ucs2decode(byteString);
      byteCount = byteArray.length;
      byteIndex = 0;
      var codePoints = [];
      var tmp;
      while ((tmp = decodeSymbol(strict)) !== false) {
        codePoints.push(tmp);
      }
      return ucs2encode(codePoints);
    }
    module2.exports = {
      version: "2.1.2",
      encode: utf8encode,
      decode: utf8decode
    };
  }
});

// node_modules/engine.io/build/parser-v3/index.js
var require_parser_v3 = __commonJS({
  "node_modules/engine.io/build/parser-v3/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.packets = exports2.protocol = void 0;
    exports2.encodePacket = encodePacket;
    exports2.encodeBase64Packet = encodeBase64Packet;
    exports2.decodePacket = decodePacket;
    exports2.decodeBase64Packet = decodeBase64Packet;
    exports2.encodePayload = encodePayload;
    exports2.decodePayload = decodePayload;
    exports2.encodePayloadAsBinary = encodePayloadAsBinary;
    exports2.decodePayloadAsBinary = decodePayloadAsBinary;
    var utf8 = require_utf8();
    exports2.protocol = 3;
    var hasBinary = (packets) => {
      for (const packet of packets) {
        if (packet.data instanceof ArrayBuffer || ArrayBuffer.isView(packet.data)) {
          return true;
        }
      }
      return false;
    };
    exports2.packets = {
      open: 0,
      close: 1,
      ping: 2,
      pong: 3,
      message: 4,
      upgrade: 5,
      noop: 6
    };
    var packetslist = Object.keys(exports2.packets);
    var err = { type: "error", data: "parser error" };
    var EMPTY_BUFFER = Buffer.concat([]);
    function encodePacket(packet, supportsBinary, utf8encode, callback) {
      if (typeof supportsBinary === "function") {
        callback = supportsBinary;
        supportsBinary = null;
      }
      if (typeof utf8encode === "function") {
        callback = utf8encode;
        utf8encode = null;
      }
      if (Buffer.isBuffer(packet.data)) {
        return encodeBuffer(packet, supportsBinary, callback);
      } else if (packet.data && (packet.data.buffer || packet.data) instanceof ArrayBuffer) {
        return encodeBuffer({ type: packet.type, data: arrayBufferToBuffer(packet.data) }, supportsBinary, callback);
      }
      var encoded = exports2.packets[packet.type];
      if (void 0 !== packet.data) {
        encoded += utf8encode ? utf8.encode(String(packet.data), { strict: false }) : String(packet.data);
      }
      return callback("" + encoded);
    }
    function encodeBuffer(packet, supportsBinary, callback) {
      if (!supportsBinary) {
        return encodeBase64Packet(packet, callback);
      }
      var data = packet.data;
      var typeBuffer = Buffer.allocUnsafe(1);
      typeBuffer[0] = exports2.packets[packet.type];
      return callback(Buffer.concat([typeBuffer, data]));
    }
    function encodeBase64Packet(packet, callback) {
      var data = Buffer.isBuffer(packet.data) ? packet.data : arrayBufferToBuffer(packet.data);
      var message = "b" + exports2.packets[packet.type];
      message += data.toString("base64");
      return callback(message);
    }
    function decodePacket(data, binaryType, utf8decode) {
      if (data === void 0) {
        return err;
      }
      let type;
      if (typeof data === "string") {
        type = data.charAt(0);
        if (type === "b") {
          return decodeBase64Packet(data.slice(1), binaryType);
        }
        if (utf8decode) {
          data = tryDecode(data);
          if (data === false) {
            return err;
          }
        }
        if (Number(type) != type || !packetslist[type]) {
          return err;
        }
        if (data.length > 1) {
          return { type: packetslist[type], data: data.slice(1) };
        } else {
          return { type: packetslist[type] };
        }
      }
      if (binaryType === "arraybuffer") {
        var intArray = new Uint8Array(data);
        type = intArray[0];
        return { type: packetslist[type], data: intArray.buffer.slice(1) };
      }
      if (data instanceof ArrayBuffer) {
        data = arrayBufferToBuffer(data);
      }
      type = data[0];
      return { type: packetslist[type], data: data.slice(1) };
    }
    function tryDecode(data) {
      try {
        data = utf8.decode(data, { strict: false });
      } catch (e) {
        return false;
      }
      return data;
    }
    function decodeBase64Packet(msg, binaryType) {
      var type = packetslist[msg.charAt(0)];
      var data = Buffer.from(msg.slice(1), "base64");
      if (binaryType === "arraybuffer") {
        var abv = new Uint8Array(data.length);
        for (var i = 0; i < abv.length; i++) {
          abv[i] = data[i];
        }
        data = abv.buffer;
      }
      return { type, data };
    }
    function encodePayload(packets, supportsBinary, callback) {
      if (typeof supportsBinary === "function") {
        callback = supportsBinary;
        supportsBinary = null;
      }
      if (supportsBinary && hasBinary(packets)) {
        return encodePayloadAsBinary(packets, callback);
      }
      if (!packets.length) {
        return callback("0:");
      }
      function encodeOne(packet, doneCallback) {
        encodePacket(packet, supportsBinary, false, function(message) {
          doneCallback(null, setLengthHeader(message));
        });
      }
      map3(packets, encodeOne, function(err2, results) {
        return callback(results.join(""));
      });
    }
    function setLengthHeader(message) {
      return message.length + ":" + message;
    }
    function map3(ary, each, done) {
      const results = new Array(ary.length);
      let count = 0;
      for (let i = 0; i < ary.length; i++) {
        each(ary[i], (error73, msg) => {
          results[i] = msg;
          if (++count === ary.length) {
            done(null, results);
          }
        });
      }
    }
    function decodePayload(data, binaryType, callback) {
      if (typeof data !== "string") {
        return decodePayloadAsBinary(data, binaryType, callback);
      }
      if (typeof binaryType === "function") {
        callback = binaryType;
        binaryType = null;
      }
      if (data === "") {
        return callback(err, 0, 1);
      }
      var length = "", n, msg, packet;
      for (var i = 0, l = data.length; i < l; i++) {
        var chr = data.charAt(i);
        if (chr !== ":") {
          length += chr;
          continue;
        }
        if (length === "" || length != (n = Number(length))) {
          return callback(err, 0, 1);
        }
        msg = data.slice(i + 1, i + 1 + n);
        if (length != msg.length) {
          return callback(err, 0, 1);
        }
        if (msg.length) {
          packet = decodePacket(msg, binaryType, false);
          if (err.type === packet.type && err.data === packet.data) {
            return callback(err, 0, 1);
          }
          var more = callback(packet, i + n, l);
          if (false === more)
            return;
        }
        i += n;
        length = "";
      }
      if (length !== "") {
        return callback(err, 0, 1);
      }
    }
    function bufferToString(buffer) {
      var str = "";
      for (var i = 0, l = buffer.length; i < l; i++) {
        str += String.fromCharCode(buffer[i]);
      }
      return str;
    }
    function stringToBuffer(string5) {
      var buf = Buffer.allocUnsafe(string5.length);
      for (var i = 0, l = string5.length; i < l; i++) {
        buf.writeUInt8(string5.charCodeAt(i), i);
      }
      return buf;
    }
    function arrayBufferToBuffer(data) {
      var length = data.byteLength || data.length;
      var offset = data.byteOffset || 0;
      return Buffer.from(data.buffer || data, offset, length);
    }
    function encodePayloadAsBinary(packets, callback) {
      if (!packets.length) {
        return callback(EMPTY_BUFFER);
      }
      map3(packets, encodeOneBinaryPacket, function(err2, results) {
        return callback(Buffer.concat(results));
      });
    }
    function encodeOneBinaryPacket(p3, doneCallback) {
      function onBinaryPacketEncode(packet) {
        var encodingLength = "" + packet.length;
        var sizeBuffer;
        if (typeof packet === "string") {
          sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
          sizeBuffer[0] = 0;
          for (var i = 0; i < encodingLength.length; i++) {
            sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
          }
          sizeBuffer[sizeBuffer.length - 1] = 255;
          return doneCallback(null, Buffer.concat([sizeBuffer, stringToBuffer(packet)]));
        }
        sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
        sizeBuffer[0] = 1;
        for (var i = 0; i < encodingLength.length; i++) {
          sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
        }
        sizeBuffer[sizeBuffer.length - 1] = 255;
        doneCallback(null, Buffer.concat([sizeBuffer, packet]));
      }
      encodePacket(p3, true, true, onBinaryPacketEncode);
    }
    function decodePayloadAsBinary(data, binaryType, callback) {
      if (typeof binaryType === "function") {
        callback = binaryType;
        binaryType = null;
      }
      var bufferTail = data;
      var buffers = [];
      var i;
      while (bufferTail.length > 0) {
        var strLen = "";
        var isString2 = bufferTail[0] === 0;
        for (i = 1; ; i++) {
          if (bufferTail[i] === 255)
            break;
          if (strLen.length > 310) {
            return callback(err, 0, 1);
          }
          strLen += "" + bufferTail[i];
        }
        bufferTail = bufferTail.slice(strLen.length + 1);
        var msgLength = parseInt(strLen, 10);
        var msg = bufferTail.slice(1, msgLength + 1);
        if (isString2)
          msg = bufferToString(msg);
        buffers.push(msg);
        bufferTail = bufferTail.slice(msgLength + 1);
      }
      var total = buffers.length;
      for (i = 0; i < total; i++) {
        var buffer = buffers[i];
        callback(decodePacket(buffer, binaryType, true), i, total);
      }
    }
  }
});

// node_modules/engine.io/build/transport.js
var require_transport = __commonJS({
  "node_modules/engine.io/build/transport.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Transport = void 0;
    var events_1 = require("events");
    var parser_v4 = require_cjs();
    var parser_v3 = require_parser_v3();
    var debug_1 = require_src();
    var debug = (0, debug_1.default)("engine:transport");
    function noop4() {
    }
    var Transport = class extends events_1.EventEmitter {
      get readyState() {
        return this._readyState;
      }
      set readyState(state) {
        debug("readyState updated from %s to %s (%s)", this._readyState, state, this.name);
        this._readyState = state;
      }
      /**
       * Transport constructor.
       *
       * @param {EngineRequest} req
       */
      constructor(req) {
        super();
        this.writable = false;
        this._readyState = "open";
        this.discarded = false;
        this.protocol = req._query.EIO === "4" ? 4 : 3;
        this.parser = this.protocol === 4 ? parser_v4 : parser_v3;
        this.supportsBinary = !(req._query && req._query.b64);
      }
      /**
       * Flags the transport as discarded.
       *
       * @package
       */
      discard() {
        this.discarded = true;
      }
      /**
       * Called with an incoming HTTP request.
       *
       * @param req
       * @package
       */
      onRequest(req) {
      }
      /**
       * Closes the transport.
       *
       * @package
       */
      close(fn) {
        if ("closed" === this.readyState || "closing" === this.readyState)
          return;
        this.readyState = "closing";
        this.doClose(fn || noop4);
      }
      /**
       * Called with a transport error.
       *
       * @param {String} msg - message error
       * @param {Object} desc - error description
       * @protected
       */
      onError(msg, desc) {
        if (this.listeners("error").length) {
          const err = new Error(msg);
          err.type = "TransportError";
          err.description = desc;
          this.emit("error", err);
        } else {
          debug("ignored transport error %s (%s)", msg, desc);
        }
      }
      /**
       * Called with parsed out a packets from the data stream.
       *
       * @param {Object} packet
       * @protected
       */
      onPacket(packet) {
        this.emit("packet", packet);
      }
      /**
       * Called with the encoded packet data.
       *
       * @param data
       * @protected
       */
      onData(data) {
        this.onPacket(this.parser.decodePacket(data));
      }
      /**
       * Called upon transport close.
       *
       * @protected
       */
      onClose() {
        this.readyState = "closed";
        this.emit("close");
      }
    };
    exports2.Transport = Transport;
    Transport.upgradesTo = [];
  }
});

// node_modules/engine.io/build/transports/polling.js
var require_polling = __commonJS({
  "node_modules/engine.io/build/transports/polling.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Polling = void 0;
    var transport_1 = require_transport();
    var zlib_1 = require("zlib");
    var accepts = require_accepts2();
    var debug_1 = require_src();
    var debug = (0, debug_1.default)("engine:polling");
    var compressionMethods = {
      gzip: zlib_1.createGzip,
      deflate: zlib_1.createDeflate
    };
    var Polling = class extends transport_1.Transport {
      /**
       * HTTP polling constructor.
       */
      constructor(req) {
        super(req);
        this.closeTimeout = 30 * 1e3;
      }
      /**
       * Transport name
       */
      get name() {
        return "polling";
      }
      /**
       * Overrides onRequest.
       *
       * @param {EngineRequest} req
       * @package
       */
      onRequest(req) {
        const res = req.res;
        req.res = null;
        if ("GET" === req.method) {
          this.onPollRequest(req, res);
        } else if ("POST" === req.method) {
          this.onDataRequest(req, res);
        } else {
          res.writeHead(500);
          res.end();
        }
      }
      /**
       * The client sends a request awaiting for us to send data.
       *
       * @private
       */
      onPollRequest(req, res) {
        if (this.req) {
          debug("request overlap");
          this.onError("overlap from client");
          res.writeHead(400);
          res.end();
          return;
        }
        debug("setting request");
        this.req = req;
        this.res = res;
        const onClose = () => {
          this.onError("poll connection closed prematurely");
        };
        const cleanup = () => {
          req.removeListener("close", onClose);
          this.req = this.res = null;
        };
        req.cleanup = cleanup;
        req.on("close", onClose);
        this.writable = true;
        this.emit("ready");
        if (this.writable && this.shouldClose) {
          debug("triggering empty send to append close packet");
          this.send([{ type: "noop" }]);
        }
      }
      /**
       * The client sends a request with data.
       *
       * @private
       */
      onDataRequest(req, res) {
        if (this.dataReq) {
          this.onError("data request overlap from client");
          res.writeHead(400);
          res.end();
          return;
        }
        const isBinary = "application/octet-stream" === req.headers["content-type"];
        if (isBinary && this.protocol === 4) {
          return this.onError("invalid content");
        }
        this.dataReq = req;
        this.dataRes = res;
        let chunks = isBinary ? Buffer.concat([]) : "";
        const cleanup = () => {
          req.removeListener("data", onData);
          req.removeListener("end", onEnd);
          req.removeListener("close", onClose);
          this.dataReq = this.dataRes = chunks = null;
        };
        const onClose = () => {
          cleanup();
          this.onError("data request connection closed prematurely");
        };
        const onData = (data) => {
          let contentLength;
          if (isBinary) {
            chunks = Buffer.concat([chunks, data]);
            contentLength = chunks.length;
          } else {
            chunks += data;
            contentLength = Buffer.byteLength(chunks);
          }
          if (contentLength > this.maxHttpBufferSize) {
            res.writeHead(413).end();
            cleanup();
          }
        };
        const onEnd = () => {
          this.onData(chunks);
          const headers = {
            // text/html is required instead of text/plain to avoid an
            // unwanted download dialog on certain user-agents (GH-43)
            "Content-Type": "text/html",
            "Content-Length": "2"
          };
          res.writeHead(200, this.headers(req, headers));
          res.end("ok");
          cleanup();
        };
        req.on("close", onClose);
        if (!isBinary)
          req.setEncoding("utf8");
        req.on("data", onData);
        req.on("end", onEnd);
      }
      /**
       * Processes the incoming data payload.
       *
       * @param data - encoded payload
       * @protected
       */
      onData(data) {
        debug('received "%s"', data);
        const callback = (packet) => {
          if ("close" === packet.type) {
            debug("got xhr close packet");
            this.onClose();
            return false;
          }
          this.onPacket(packet);
        };
        if (this.protocol === 3) {
          this.parser.decodePayload(data, callback);
        } else {
          this.parser.decodePayload(data).forEach(callback);
        }
      }
      /**
       * Overrides onClose.
       *
       * @private
       */
      onClose() {
        if (this.writable) {
          this.send([{ type: "noop" }]);
        }
        super.onClose();
      }
      send(packets) {
        this.writable = false;
        if (this.shouldClose) {
          debug("appending close packet to payload");
          packets.push({ type: "close" });
          this.shouldClose();
          this.shouldClose = null;
        }
        const doWrite = (data) => {
          const compress = packets.some((packet) => {
            return packet.options && packet.options.compress;
          });
          this.write(data, { compress });
        };
        if (this.protocol === 3) {
          this.parser.encodePayload(packets, this.supportsBinary, doWrite);
        } else {
          this.parser.encodePayload(packets, doWrite);
        }
      }
      /**
       * Writes data as response to poll request.
       *
       * @param {String} data
       * @param {Object} options
       * @private
       */
      write(data, options) {
        debug('writing "%s"', data);
        this.doWrite(data, options, () => {
          this.req.cleanup();
          this.emit("drain");
        });
      }
      /**
       * Performs the write.
       *
       * @protected
       */
      doWrite(data, options, callback) {
        const isString2 = typeof data === "string";
        const contentType = isString2 ? "text/plain; charset=UTF-8" : "application/octet-stream";
        const headers = {
          "Content-Type": contentType
        };
        const respond = (data2) => {
          headers["Content-Length"] = "string" === typeof data2 ? Buffer.byteLength(data2) : data2.length;
          this.res.writeHead(200, this.headers(this.req, headers));
          this.res.end(data2);
          callback();
        };
        if (!this.httpCompression || !options.compress) {
          respond(data);
          return;
        }
        const len = isString2 ? Buffer.byteLength(data) : data.length;
        if (len < this.httpCompression.threshold) {
          respond(data);
          return;
        }
        const encoding = accepts(this.req).encodings(["gzip", "deflate"]);
        if (!encoding) {
          respond(data);
          return;
        }
        this.compress(data, encoding, (err, data2) => {
          if (err) {
            this.res.writeHead(500);
            this.res.end();
            callback(err);
            return;
          }
          headers["Content-Encoding"] = encoding;
          respond(data2);
        });
      }
      /**
       * Compresses data.
       *
       * @private
       */
      compress(data, encoding, callback) {
        debug("compressing");
        const buffers = [];
        let nread = 0;
        compressionMethods[encoding](this.httpCompression).on("error", callback).on("data", function(chunk) {
          buffers.push(chunk);
          nread += chunk.length;
        }).on("end", function() {
          callback(null, Buffer.concat(buffers, nread));
        }).end(data);
      }
      /**
       * Closes the transport.
       *
       * @private
       */
      doClose(fn) {
        debug("closing");
        let closeTimeoutTimer;
        if (this.dataReq) {
          debug("aborting ongoing data request");
          this.dataReq.destroy();
        }
        const onClose = () => {
          clearTimeout(closeTimeoutTimer);
          fn();
          this.onClose();
        };
        if (this.writable) {
          debug("transport writable - closing right away");
          this.send([{ type: "close" }]);
          onClose();
        } else if (this.discarded) {
          debug("transport discarded - closing right away");
          onClose();
        } else {
          debug("transport not writable - buffering orderly close");
          this.shouldClose = onClose;
          closeTimeoutTimer = setTimeout(onClose, this.closeTimeout);
        }
      }
      /**
       * Returns headers for a response.
       *
       * @param {http.IncomingMessage} req
       * @param {Object} headers - extra headers
       * @private
       */
      headers(req, headers = {}) {
        const ua = req.headers["user-agent"];
        if (ua && (~ua.indexOf(";MSIE") || ~ua.indexOf("Trident/"))) {
          headers["X-XSS-Protection"] = "0";
        }
        headers["cache-control"] = "no-store";
        this.emit("headers", headers, req);
        return headers;
      }
    };
    exports2.Polling = Polling;
  }
});

// node_modules/engine.io/build/transports/polling-jsonp.js
var require_polling_jsonp = __commonJS({
  "node_modules/engine.io/build/transports/polling-jsonp.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.JSONP = void 0;
    var polling_1 = require_polling();
    var qs = require("querystring");
    var rDoubleSlashes = /\\\\n/g;
    var rSlashes = /(\\)?\\n/g;
    var JSONP = class extends polling_1.Polling {
      /**
       * JSON-P polling transport.
       */
      constructor(req) {
        super(req);
        this.head = "___eio[" + (req._query.j || "").replace(/[^0-9]/g, "") + "](";
        this.foot = ");";
      }
      onData(data) {
        data = qs.parse(data).d;
        if ("string" === typeof data) {
          data = data.replace(rSlashes, function(match, slashes) {
            return slashes ? match : "\n";
          });
          super.onData(data.replace(rDoubleSlashes, "\\n"));
        }
      }
      doWrite(data, options, callback) {
        const js = JSON.stringify(data).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
        data = this.head + js + this.foot;
        super.doWrite(data, options, callback);
      }
    };
    exports2.JSONP = JSONP;
  }
});

// node_modules/engine.io/build/transports/websocket.js
var require_websocket = __commonJS({
  "node_modules/engine.io/build/transports/websocket.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.WebSocket = void 0;
    var transport_1 = require_transport();
    var debug_1 = require_src();
    var debug = (0, debug_1.default)("engine:ws");
    var WebSocket = class extends transport_1.Transport {
      /**
       * WebSocket transport
       *
       * @param {EngineRequest} req
       */
      constructor(req) {
        super(req);
        this._doSend = (data) => {
          this.socket.send(data, this._onSent);
        };
        this._doSendLast = (data) => {
          this.socket.send(data, this._onSentLast);
        };
        this._onSent = (err) => {
          if (err) {
            this.onError("write error", err.stack);
          }
        };
        this._onSentLast = (err) => {
          if (err) {
            this.onError("write error", err.stack);
          } else {
            this.emit("drain");
            this.writable = true;
            this.emit("ready");
          }
        };
        this.socket = req.websocket;
        this.socket.on("message", (data, isBinary) => {
          const message = isBinary ? data : data.toString();
          debug('received "%s"', message);
          super.onData(message);
        });
        this.socket.once("close", this.onClose.bind(this));
        this.socket.on("error", this.onError.bind(this));
        this.writable = true;
        this.perMessageDeflate = null;
      }
      /**
       * Transport name
       */
      get name() {
        return "websocket";
      }
      /**
       * Advertise upgrade support.
       */
      get handlesUpgrades() {
        return true;
      }
      send(packets) {
        this.writable = false;
        for (let i = 0; i < packets.length; i++) {
          const packet = packets[i];
          const isLast = i + 1 === packets.length;
          if (this._canSendPreEncodedFrame(packet)) {
            this.socket._sender.sendFrame(packet.options.wsPreEncodedFrame, isLast ? this._onSentLast : this._onSent);
          } else {
            this.parser.encodePacket(packet, this.supportsBinary, isLast ? this._doSendLast : this._doSend);
          }
        }
      }
      /**
       * Whether the encoding of the WebSocket frame can be skipped.
       * @param packet
       * @private
       */
      _canSendPreEncodedFrame(packet) {
        var _a31, _b27, _c;
        return !this.perMessageDeflate && // @ts-expect-error use of untyped member
        typeof ((_b27 = (_a31 = this.socket) === null || _a31 === void 0 ? void 0 : _a31._sender) === null || _b27 === void 0 ? void 0 : _b27.sendFrame) === "function" && ((_c = packet.options) === null || _c === void 0 ? void 0 : _c.wsPreEncodedFrame) !== void 0;
      }
      doClose(fn) {
        debug("closing");
        this.socket.close();
        fn && fn();
      }
    };
    exports2.WebSocket = WebSocket;
  }
});

// node_modules/engine.io/build/transports/webtransport.js
var require_webtransport = __commonJS({
  "node_modules/engine.io/build/transports/webtransport.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.WebTransport = void 0;
    var transport_1 = require_transport();
    var debug_1 = require_src();
    var engine_io_parser_1 = require_cjs();
    var debug = (0, debug_1.default)("engine:webtransport");
    var WebTransport = class extends transport_1.Transport {
      constructor(session, stream4, reader) {
        super({ _query: { EIO: "4" } });
        this.session = session;
        const transformStream = (0, engine_io_parser_1.createPacketEncoderStream)();
        transformStream.readable.pipeTo(stream4.writable).catch(() => {
          debug("the stream was closed");
        });
        this.writer = transformStream.writable.getWriter();
        (async () => {
          try {
            while (true) {
              const { value, done } = await reader.read();
              if (done) {
                debug("session is closed");
                break;
              }
              debug("received chunk: %o", value);
              this.onPacket(value);
            }
          } catch (e) {
            debug("error while reading: %s", e.message);
          }
        })();
        session.closed.then(() => this.onClose());
        this.writable = true;
      }
      get name() {
        return "webtransport";
      }
      async send(packets) {
        this.writable = false;
        try {
          for (let i = 0; i < packets.length; i++) {
            const packet = packets[i];
            await this.writer.write(packet);
          }
        } catch (e) {
          debug("error while writing: %s", e.message);
        }
        this.emit("drain");
        this.writable = true;
        this.emit("ready");
      }
      doClose(fn) {
        debug("closing WebTransport session");
        this.session.close();
        fn && fn();
      }
    };
    exports2.WebTransport = WebTransport;
  }
});

// node_modules/engine.io/build/transports/index.js
var require_transports = __commonJS({
  "node_modules/engine.io/build/transports/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var polling_1 = require_polling();
    var polling_jsonp_1 = require_polling_jsonp();
    var websocket_1 = require_websocket();
    var webtransport_1 = require_webtransport();
    exports2.default = {
      polling,
      websocket: websocket_1.WebSocket,
      webtransport: webtransport_1.WebTransport
    };
    function polling(req) {
      if ("string" === typeof req._query.j) {
        return new polling_jsonp_1.JSONP(req);
      } else {
        return new polling_1.Polling(req);
      }
    }
    polling.upgradesTo = ["websocket", "webtransport"];
  }
});

// node_modules/engine.io/build/socket.js
var require_socket = __commonJS({
  "node_modules/engine.io/build/socket.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Socket = void 0;
    var events_1 = require("events");
    var debug_1 = require_src();
    var timers_1 = require("timers");
    var debug = (0, debug_1.default)("engine:socket");
    var Socket2 = class extends events_1.EventEmitter {
      get readyState() {
        return this._readyState;
      }
      set readyState(state) {
        debug("readyState updated from %s to %s", this._readyState, state);
        this._readyState = state;
      }
      constructor(id, server2, transport, req, protocol) {
        super();
        this._readyState = "opening";
        this.upgrading = false;
        this.upgraded = false;
        this.writeBuffer = [];
        this.packetsFn = [];
        this.sentCallbackFn = [];
        this.cleanupFn = [];
        this.id = id;
        this.server = server2;
        this.request = req;
        this.protocol = protocol;
        if (req) {
          if (req.websocket && req.websocket._socket) {
            this.remoteAddress = req.websocket._socket.remoteAddress;
          } else {
            this.remoteAddress = req.connection.remoteAddress;
          }
        } else {
        }
        this.pingTimeoutTimer = null;
        this.pingIntervalTimer = null;
        this.setTransport(transport);
        this.onOpen();
      }
      /**
       * Called upon transport considered open.
       *
       * @private
       */
      onOpen() {
        this.readyState = "open";
        this.transport.sid = this.id;
        this.sendPacket("open", JSON.stringify({
          sid: this.id,
          upgrades: this.getAvailableUpgrades(),
          pingInterval: this.server.opts.pingInterval,
          pingTimeout: this.server.opts.pingTimeout,
          maxPayload: this.server.opts.maxHttpBufferSize
        }));
        if (this.server.opts.initialPacket) {
          this.sendPacket("message", this.server.opts.initialPacket);
        }
        this.emit("open");
        if (this.protocol === 3) {
          this.resetPingTimeout();
        } else {
          this.schedulePing();
        }
      }
      /**
       * Called upon transport packet.
       *
       * @param {Object} packet
       * @private
       */
      onPacket(packet) {
        if ("open" !== this.readyState) {
          return debug("packet received with closed socket");
        }
        debug(`received packet ${packet.type}`);
        this.emit("packet", packet);
        switch (packet.type) {
          case "ping":
            if (this.transport.protocol !== 3) {
              this.onError(new Error("invalid heartbeat direction"));
              return;
            }
            debug("got ping");
            this.pingTimeoutTimer.refresh();
            this.sendPacket("pong");
            this.emit("heartbeat");
            break;
          case "pong":
            if (this.transport.protocol === 3) {
              this.onError(new Error("invalid heartbeat direction"));
              return;
            }
            debug("got pong");
            (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
            this.pingIntervalTimer.refresh();
            this.emit("heartbeat");
            break;
          case "error":
            this.onClose("parse error");
            break;
          case "message":
            this.emit("data", packet.data);
            this.emit("message", packet.data);
            break;
        }
      }
      /**
       * Called upon transport error.
       *
       * @param {Error} err - error object
       * @private
       */
      onError(err) {
        debug("transport error");
        this.onClose("transport error", err);
      }
      /**
       * Pings client every `this.pingInterval` and expects response
       * within `this.pingTimeout` or closes connection.
       *
       * @private
       */
      schedulePing() {
        this.pingIntervalTimer = (0, timers_1.setTimeout)(() => {
          debug("writing ping packet - expecting pong within %sms", this.server.opts.pingTimeout);
          this.sendPacket("ping");
          this.resetPingTimeout();
        }, this.server.opts.pingInterval);
      }
      /**
       * Resets ping timeout.
       *
       * @private
       */
      resetPingTimeout() {
        (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
        this.pingTimeoutTimer = (0, timers_1.setTimeout)(() => {
          if (this.readyState === "closed")
            return;
          this.onClose("ping timeout");
        }, this.protocol === 3 ? this.server.opts.pingInterval + this.server.opts.pingTimeout : this.server.opts.pingTimeout);
      }
      /**
       * Attaches handlers for the given transport.
       *
       * @param {Transport} transport
       * @private
       */
      setTransport(transport) {
        const onError = this.onError.bind(this);
        const onReady = () => this.flush();
        const onPacket = this.onPacket.bind(this);
        const onDrain = this.onDrain.bind(this);
        const onClose = this.onClose.bind(this, "transport close");
        this.transport = transport;
        this.transport.once("error", onError);
        this.transport.on("ready", onReady);
        this.transport.on("packet", onPacket);
        this.transport.on("drain", onDrain);
        this.transport.once("close", onClose);
        this.cleanupFn.push(function() {
          transport.removeListener("error", onError);
          transport.removeListener("ready", onReady);
          transport.removeListener("packet", onPacket);
          transport.removeListener("drain", onDrain);
          transport.removeListener("close", onClose);
        });
      }
      /**
       * Upon transport "drain" event
       *
       * @private
       */
      onDrain() {
        if (this.sentCallbackFn.length > 0) {
          debug("executing batch send callback");
          const seqFn = this.sentCallbackFn.shift();
          if (seqFn) {
            for (let i = 0; i < seqFn.length; i++) {
              seqFn[i](this.transport);
            }
          }
        }
      }
      /**
       * Upgrades socket to the given transport
       *
       * @param {Transport} transport
       * @private
       */
      /* private */
      _maybeUpgrade(transport) {
        debug('might upgrade socket transport from "%s" to "%s"', this.transport.name, transport.name);
        this.upgrading = true;
        const upgradeTimeoutTimer = (0, timers_1.setTimeout)(() => {
          debug("client did not complete upgrade - closing transport");
          cleanup();
          if ("open" === transport.readyState) {
            transport.close();
          }
        }, this.server.opts.upgradeTimeout);
        let checkIntervalTimer;
        const onPacket = (packet) => {
          if ("ping" === packet.type && "probe" === packet.data) {
            debug("got probe ping packet, sending pong");
            transport.send([{ type: "pong", data: "probe" }]);
            this.emit("upgrading", transport);
            clearInterval(checkIntervalTimer);
            checkIntervalTimer = setInterval(check3, 100);
          } else if ("upgrade" === packet.type && this.readyState !== "closed") {
            debug("got upgrade packet - upgrading");
            cleanup();
            this.transport.discard();
            this.upgraded = true;
            this.clearTransport();
            this.setTransport(transport);
            this.emit("upgrade", transport);
            this.flush();
            if (this.readyState === "closing") {
              transport.close(() => {
                this.onClose("forced close");
              });
            }
          } else {
            cleanup();
            transport.close();
          }
        };
        const check3 = () => {
          if ("polling" === this.transport.name && this.transport.writable) {
            debug("writing a noop packet to polling for fast upgrade");
            this.transport.send([{ type: "noop" }]);
          }
        };
        const cleanup = () => {
          this.upgrading = false;
          clearInterval(checkIntervalTimer);
          (0, timers_1.clearTimeout)(upgradeTimeoutTimer);
          transport.removeListener("packet", onPacket);
          transport.removeListener("close", onTransportClose);
          transport.removeListener("error", onError);
          this.removeListener("close", onClose);
        };
        const onError = (err) => {
          debug("client did not complete upgrade - %s", err);
          cleanup();
          transport.close();
          transport = null;
        };
        const onTransportClose = () => {
          onError("transport closed");
        };
        const onClose = () => {
          onError("socket closed");
        };
        transport.on("packet", onPacket);
        transport.once("close", onTransportClose);
        transport.once("error", onError);
        this.once("close", onClose);
      }
      /**
       * Clears listeners and timers associated with current transport.
       *
       * @private
       */
      clearTransport() {
        let cleanup;
        const toCleanUp = this.cleanupFn.length;
        for (let i = 0; i < toCleanUp; i++) {
          cleanup = this.cleanupFn.shift();
          cleanup();
        }
        this.transport.on("error", function() {
          debug("error triggered by discarded transport");
        });
        this.transport.close();
        (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
      }
      /**
       * Called upon transport considered closed.
       * Possible reasons: `ping timeout`, `client error`, `parse error`,
       * `transport error`, `server close`, `transport close`
       */
      onClose(reason, description) {
        if ("closed" !== this.readyState) {
          this.readyState = "closed";
          (0, timers_1.clearTimeout)(this.pingIntervalTimer);
          (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
          process.nextTick(() => {
            this.writeBuffer = [];
          });
          this.packetsFn = [];
          this.sentCallbackFn = [];
          this.clearTransport();
          this.emit("close", reason, description);
        }
      }
      /**
       * Sends a message packet.
       *
       * @param {Object} data
       * @param {Object} options
       * @param {Function} callback
       * @return {Socket} for chaining
       */
      send(data, options, callback) {
        this.sendPacket("message", data, options, callback);
        return this;
      }
      /**
       * Alias of {@link send}.
       *
       * @param data
       * @param options
       * @param callback
       */
      write(data, options, callback) {
        this.sendPacket("message", data, options, callback);
        return this;
      }
      /**
       * Sends a packet.
       *
       * @param {String} type - packet type
       * @param {String} data
       * @param {Object} options
       * @param {Function} callback
       *
       * @private
       */
      sendPacket(type, data, options = {}, callback) {
        if ("function" === typeof options) {
          callback = options;
          options = {};
        }
        if ("closing" !== this.readyState && "closed" !== this.readyState) {
          debug('sending packet "%s" (%s)', type, data);
          options.compress = options.compress !== false;
          const packet = {
            type,
            options
          };
          if (data)
            packet.data = data;
          this.emit("packetCreate", packet);
          this.writeBuffer.push(packet);
          if ("function" === typeof callback)
            this.packetsFn.push(callback);
          this.flush();
        }
      }
      /**
       * Attempts to flush the packets buffer.
       *
       * @private
       */
      flush() {
        if ("closed" !== this.readyState && this.transport.writable && this.writeBuffer.length) {
          debug("flushing buffer to transport");
          this.emit("flush", this.writeBuffer);
          this.server.emit("flush", this, this.writeBuffer);
          const wbuf = this.writeBuffer;
          this.writeBuffer = [];
          if (this.packetsFn.length) {
            this.sentCallbackFn.push(this.packetsFn);
            this.packetsFn = [];
          } else {
            this.sentCallbackFn.push(null);
          }
          this.transport.send(wbuf);
          this.emit("drain");
          this.server.emit("drain", this);
        }
      }
      /**
       * Get available upgrades for this socket.
       *
       * @private
       */
      getAvailableUpgrades() {
        const availableUpgrades = [];
        const allUpgrades = this.server.upgrades(this.transport.name);
        for (let i = 0; i < allUpgrades.length; ++i) {
          const upg = allUpgrades[i];
          if (this.server.opts.transports.indexOf(upg) !== -1) {
            availableUpgrades.push(upg);
          }
        }
        return availableUpgrades;
      }
      /**
       * Closes the socket and underlying transport.
       *
       * @param {Boolean} discard - optional, discard the transport
       * @return {Socket} for chaining
       */
      close(discard) {
        if (discard && (this.readyState === "open" || this.readyState === "closing")) {
          return this.closeTransport(discard);
        }
        if ("open" !== this.readyState)
          return;
        this.readyState = "closing";
        if (this.writeBuffer.length) {
          debug("there are %d remaining packets in the buffer, waiting for the 'drain' event", this.writeBuffer.length);
          this.once("drain", () => {
            debug("all packets have been sent, closing the transport");
            this.closeTransport(discard);
          });
          return;
        }
        debug("the buffer is empty, closing the transport right away");
        this.closeTransport(discard);
      }
      /**
       * Closes the underlying transport.
       *
       * @param {Boolean} discard
       * @private
       */
      closeTransport(discard) {
        debug("closing the transport (discard? %s)", !!discard);
        if (discard)
          this.transport.discard();
        this.transport.close(this.onClose.bind(this, "forced close"));
      }
    };
    exports2.Socket = Socket2;
  }
});

// node_modules/ws/lib/constants.js
var require_constants = __commonJS({
  "node_modules/ws/lib/constants.js"(exports2, module2) {
    "use strict";
    var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
    var hasBlob = typeof Blob !== "undefined";
    if (hasBlob) BINARY_TYPES.push("blob");
    module2.exports = {
      BINARY_TYPES,
      EMPTY_BUFFER: Buffer.alloc(0),
      GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
      hasBlob,
      kForOnEventAttribute: /* @__PURE__ */ Symbol("kIsForOnEventAttribute"),
      kListener: /* @__PURE__ */ Symbol("kListener"),
      kStatusCode: /* @__PURE__ */ Symbol("status-code"),
      kWebSocket: /* @__PURE__ */ Symbol("websocket"),
      NOOP: () => {
      }
    };
  }
});

// node_modules/ws/lib/buffer-util.js
var require_buffer_util = __commonJS({
  "node_modules/ws/lib/buffer-util.js"(exports2, module2) {
    "use strict";
    var { EMPTY_BUFFER } = require_constants();
    var FastBuffer = Buffer[Symbol.species];
    function concat(list2, totalLength) {
      if (list2.length === 0) return EMPTY_BUFFER;
      if (list2.length === 1) return list2[0];
      const target = Buffer.allocUnsafe(totalLength);
      let offset = 0;
      for (let i = 0; i < list2.length; i++) {
        const buf = list2[i];
        target.set(buf, offset);
        offset += buf.length;
      }
      if (offset < totalLength) {
        return new FastBuffer(target.buffer, target.byteOffset, offset);
      }
      return target;
    }
    function _mask(source, mask, output, offset, length) {
      for (let i = 0; i < length; i++) {
        output[offset + i] = source[i] ^ mask[i & 3];
      }
    }
    function _unmask(buffer, mask) {
      for (let i = 0; i < buffer.length; i++) {
        buffer[i] ^= mask[i & 3];
      }
    }
    function toArrayBuffer(buf) {
      if (buf.length === buf.buffer.byteLength) {
        return buf.buffer;
      }
      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
    }
    function toBuffer(data) {
      toBuffer.readOnly = true;
      if (Buffer.isBuffer(data)) return data;
      let buf;
      if (data instanceof ArrayBuffer) {
        buf = new FastBuffer(data);
      } else if (ArrayBuffer.isView(data)) {
        buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
      } else {
        buf = Buffer.from(data);
        toBuffer.readOnly = false;
      }
      return buf;
    }
    module2.exports = {
      concat,
      mask: _mask,
      toArrayBuffer,
      toBuffer,
      unmask: _unmask
    };
    if (!process.env.WS_NO_BUFFER_UTIL) {
      try {
        const bufferUtil = require("bufferutil");
        module2.exports.mask = function(source, mask, output, offset, length) {
          if (length < 48) _mask(source, mask, output, offset, length);
          else bufferUtil.mask(source, mask, output, offset, length);
        };
        module2.exports.unmask = function(buffer, mask) {
          if (buffer.length < 32) _unmask(buffer, mask);
          else bufferUtil.unmask(buffer, mask);
        };
      } catch (e) {
      }
    }
  }
});

// node_modules/ws/lib/limiter.js
var require_limiter = __commonJS({
  "node_modules/ws/lib/limiter.js"(exports2, module2) {
    "use strict";
    var kDone = /* @__PURE__ */ Symbol("kDone");
    var kRun = /* @__PURE__ */ Symbol("kRun");
    var Limiter = class {
      /**
       * Creates a new `Limiter`.
       *
       * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
       *     to run concurrently
       */
      constructor(concurrency) {
        this[kDone] = () => {
          this.pending--;
          this[kRun]();
        };
        this.concurrency = concurrency || Infinity;
        this.jobs = [];
        this.pending = 0;
      }
      /**
       * Adds a job to the queue.
       *
       * @param {Function} job The job to run
       * @public
       */
      add(job) {
        this.jobs.push(job);
        this[kRun]();
      }
      /**
       * Removes a job from the queue and runs it if possible.
       *
       * @private
       */
      [kRun]() {
        if (this.pending === this.concurrency) return;
        if (this.jobs.length) {
          const job = this.jobs.shift();
          this.pending++;
          job(this[kDone]);
        }
      }
    };
    module2.exports = Limiter;
  }
});

// node_modules/ws/lib/permessage-deflate.js
var require_permessage_deflate = __commonJS({
  "node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
    "use strict";
    var zlib2 = require("zlib");
    var bufferUtil = require_buffer_util();
    var Limiter = require_limiter();
    var { kStatusCode } = require_constants();
    var FastBuffer = Buffer[Symbol.species];
    var TRAILER = Buffer.from([0, 0, 255, 255]);
    var kPerMessageDeflate = /* @__PURE__ */ Symbol("permessage-deflate");
    var kTotalLength = /* @__PURE__ */ Symbol("total-length");
    var kCallback = /* @__PURE__ */ Symbol("callback");
    var kBuffers = /* @__PURE__ */ Symbol("buffers");
    var kError = /* @__PURE__ */ Symbol("error");
    var zlibLimiter;
    var PerMessageDeflate = class {
      /**
       * Creates a PerMessageDeflate instance.
       *
       * @param {Object} [options] Configuration options
       * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
       *     for, or request, a custom client window size
       * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
       *     acknowledge disabling of client context takeover
       * @param {Number} [options.concurrencyLimit=10] The number of concurrent
       *     calls to zlib
       * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
       *     use of a custom server window size
       * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
       *     disabling of server context takeover
       * @param {Number} [options.threshold=1024] Size (in bytes) below which
       *     messages should not be compressed if context takeover is disabled
       * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
       *     deflate
       * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
       *     inflate
       * @param {Boolean} [isServer=false] Create the instance in either server or
       *     client mode
       * @param {Number} [maxPayload=0] The maximum allowed message length
       */
      constructor(options, isServer, maxPayload) {
        this._maxPayload = maxPayload | 0;
        this._options = options || {};
        this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
        this._isServer = !!isServer;
        this._deflate = null;
        this._inflate = null;
        this.params = null;
        if (!zlibLimiter) {
          const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
          zlibLimiter = new Limiter(concurrency);
        }
      }
      /**
       * @type {String}
       */
      static get extensionName() {
        return "permessage-deflate";
      }
      /**
       * Create an extension negotiation offer.
       *
       * @return {Object} Extension parameters
       * @public
       */
      offer() {
        const params = {};
        if (this._options.serverNoContextTakeover) {
          params.server_no_context_takeover = true;
        }
        if (this._options.clientNoContextTakeover) {
          params.client_no_context_takeover = true;
        }
        if (this._options.serverMaxWindowBits) {
          params.server_max_window_bits = this._options.serverMaxWindowBits;
        }
        if (this._options.clientMaxWindowBits) {
          params.client_max_window_bits = this._options.clientMaxWindowBits;
        } else if (this._options.clientMaxWindowBits == null) {
          params.client_max_window_bits = true;
        }
        return params;
      }
      /**
       * Accept an extension negotiation offer/response.
       *
       * @param {Array} configurations The extension negotiation offers/reponse
       * @return {Object} Accepted configuration
       * @public
       */
      accept(configurations) {
        configurations = this.normalizeParams(configurations);
        this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
        return this.params;
      }
      /**
       * Releases all resources used by the extension.
       *
       * @public
       */
      cleanup() {
        if (this._inflate) {
          this._inflate.close();
          this._inflate = null;
        }
        if (this._deflate) {
          const callback = this._deflate[kCallback];
          this._deflate.close();
          this._deflate = null;
          if (callback) {
            callback(
              new Error(
                "The deflate stream was closed while data was being processed"
              )
            );
          }
        }
      }
      /**
       *  Accept an extension negotiation offer.
       *
       * @param {Array} offers The extension negotiation offers
       * @return {Object} Accepted configuration
       * @private
       */
      acceptAsServer(offers) {
        const opts = this._options;
        const accepted = offers.find((params) => {
          if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
            return false;
          }
          return true;
        });
        if (!accepted) {
          throw new Error("None of the extension offers can be accepted");
        }
        if (opts.serverNoContextTakeover) {
          accepted.server_no_context_takeover = true;
        }
        if (opts.clientNoContextTakeover) {
          accepted.client_no_context_takeover = true;
        }
        if (typeof opts.serverMaxWindowBits === "number") {
          accepted.server_max_window_bits = opts.serverMaxWindowBits;
        }
        if (typeof opts.clientMaxWindowBits === "number") {
          accepted.client_max_window_bits = opts.clientMaxWindowBits;
        } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
          delete accepted.client_max_window_bits;
        }
        return accepted;
      }
      /**
       * Accept the extension negotiation response.
       *
       * @param {Array} response The extension negotiation response
       * @return {Object} Accepted configuration
       * @private
       */
      acceptAsClient(response) {
        const params = response[0];
        if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
          throw new Error('Unexpected parameter "client_no_context_takeover"');
        }
        if (!params.client_max_window_bits) {
          if (typeof this._options.clientMaxWindowBits === "number") {
            params.client_max_window_bits = this._options.clientMaxWindowBits;
          }
        } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
          throw new Error(
            'Unexpected or invalid parameter "client_max_window_bits"'
          );
        }
        return params;
      }
      /**
       * Normalize parameters.
       *
       * @param {Array} configurations The extension negotiation offers/reponse
       * @return {Array} The offers/response with normalized parameters
       * @private
       */
      normalizeParams(configurations) {
        configurations.forEach((params) => {
          Object.keys(params).forEach((key) => {
            let value = params[key];
            if (value.length > 1) {
              throw new Error(`Parameter "${key}" must have only a single value`);
            }
            value = value[0];
            if (key === "client_max_window_bits") {
              if (value !== true) {
                const num = +value;
                if (!Number.isInteger(num) || num < 8 || num > 15) {
                  throw new TypeError(
                    `Invalid value for parameter "${key}": ${value}`
                  );
                }
                value = num;
              } else if (!this._isServer) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
            } else if (key === "server_max_window_bits") {
              const num = +value;
              if (!Number.isInteger(num) || num < 8 || num > 15) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
              value = num;
            } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
              if (value !== true) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
            } else {
              throw new Error(`Unknown parameter "${key}"`);
            }
            params[key] = value;
          });
        });
        return configurations;
      }
      /**
       * Decompress data. Concurrency limited.
       *
       * @param {Buffer} data Compressed data
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @public
       */
      decompress(data, fin, callback) {
        zlibLimiter.add((done) => {
          this._decompress(data, fin, (err, result) => {
            done();
            callback(err, result);
          });
        });
      }
      /**
       * Compress data. Concurrency limited.
       *
       * @param {(Buffer|String)} data Data to compress
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @public
       */
      compress(data, fin, callback) {
        zlibLimiter.add((done) => {
          this._compress(data, fin, (err, result) => {
            done();
            callback(err, result);
          });
        });
      }
      /**
       * Decompress data.
       *
       * @param {Buffer} data Compressed data
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @private
       */
      _decompress(data, fin, callback) {
        const endpoint2 = this._isServer ? "client" : "server";
        if (!this._inflate) {
          const key = `${endpoint2}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib2.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._inflate = zlib2.createInflateRaw({
            ...this._options.zlibInflateOptions,
            windowBits
          });
          this._inflate[kPerMessageDeflate] = this;
          this._inflate[kTotalLength] = 0;
          this._inflate[kBuffers] = [];
          this._inflate.on("error", inflateOnError);
          this._inflate.on("data", inflateOnData);
        }
        this._inflate[kCallback] = callback;
        this._inflate.write(data);
        if (fin) this._inflate.write(TRAILER);
        this._inflate.flush(() => {
          const err = this._inflate[kError];
          if (err) {
            this._inflate.close();
            this._inflate = null;
            callback(err);
            return;
          }
          const data2 = bufferUtil.concat(
            this._inflate[kBuffers],
            this._inflate[kTotalLength]
          );
          if (this._inflate._readableState.endEmitted) {
            this._inflate.close();
            this._inflate = null;
          } else {
            this._inflate[kTotalLength] = 0;
            this._inflate[kBuffers] = [];
            if (fin && this.params[`${endpoint2}_no_context_takeover`]) {
              this._inflate.reset();
            }
          }
          callback(null, data2);
        });
      }
      /**
       * Compress data.
       *
       * @param {(Buffer|String)} data Data to compress
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @private
       */
      _compress(data, fin, callback) {
        const endpoint2 = this._isServer ? "server" : "client";
        if (!this._deflate) {
          const key = `${endpoint2}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib2.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._deflate = zlib2.createDeflateRaw({
            ...this._options.zlibDeflateOptions,
            windowBits
          });
          this._deflate[kTotalLength] = 0;
          this._deflate[kBuffers] = [];
          this._deflate.on("data", deflateOnData);
        }
        this._deflate[kCallback] = callback;
        this._deflate.write(data);
        this._deflate.flush(zlib2.Z_SYNC_FLUSH, () => {
          if (!this._deflate) {
            return;
          }
          let data2 = bufferUtil.concat(
            this._deflate[kBuffers],
            this._deflate[kTotalLength]
          );
          if (fin) {
            data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4);
          }
          this._deflate[kCallback] = null;
          this._deflate[kTotalLength] = 0;
          this._deflate[kBuffers] = [];
          if (fin && this.params[`${endpoint2}_no_context_takeover`]) {
            this._deflate.reset();
          }
          callback(null, data2);
        });
      }
    };
    module2.exports = PerMessageDeflate;
    function deflateOnData(chunk) {
      this[kBuffers].push(chunk);
      this[kTotalLength] += chunk.length;
    }
    function inflateOnData(chunk) {
      this[kTotalLength] += chunk.length;
      if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
        this[kBuffers].push(chunk);
        return;
      }
      this[kError] = new RangeError("Max payload size exceeded");
      this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
      this[kError][kStatusCode] = 1009;
      this.removeListener("data", inflateOnData);
      this.reset();
    }
    function inflateOnError(err) {
      this[kPerMessageDeflate]._inflate = null;
      if (this[kError]) {
        this[kCallback](this[kError]);
        return;
      }
      err[kStatusCode] = 1007;
      this[kCallback](err);
    }
  }
});

// node_modules/ws/lib/validation.js
var require_validation = __commonJS({
  "node_modules/ws/lib/validation.js"(exports2, module2) {
    "use strict";
    var { isUtf8 } = require("buffer");
    var { hasBlob } = require_constants();
    var tokenChars = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      // 0 - 15
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      // 16 - 31
      0,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      1,
      1,
      0,
      1,
      1,
      0,
      // 32 - 47
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      // 48 - 63
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 64 - 79
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      1,
      1,
      // 80 - 95
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 96 - 111
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      0,
      1,
      0
      // 112 - 127
    ];
    function isValidStatusCode(code) {
      return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
    }
    function _isValidUTF8(buf) {
      const len = buf.length;
      let i = 0;
      while (i < len) {
        if ((buf[i] & 128) === 0) {
          i++;
        } else if ((buf[i] & 224) === 192) {
          if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
            return false;
          }
          i += 2;
        } else if ((buf[i] & 240) === 224) {
          if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || // Overlong
          buf[i] === 237 && (buf[i + 1] & 224) === 160) {
            return false;
          }
          i += 3;
        } else if ((buf[i] & 248) === 240) {
          if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || // Overlong
          buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
            return false;
          }
          i += 4;
        } else {
          return false;
        }
      }
      return true;
    }
    function isBlob2(value) {
      return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File");
    }
    module2.exports = {
      isBlob: isBlob2,
      isValidStatusCode,
      isValidUTF8: _isValidUTF8,
      tokenChars
    };
    if (isUtf8) {
      module2.exports.isValidUTF8 = function(buf) {
        return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
      };
    } else if (!process.env.WS_NO_UTF_8_VALIDATE) {
      try {
        const isValidUTF8 = require("utf-8-validate");
        module2.exports.isValidUTF8 = function(buf) {
          return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
        };
      } catch (e) {
      }
    }
  }
});

// node_modules/ws/lib/receiver.js
var require_receiver = __commonJS({
  "node_modules/ws/lib/receiver.js"(exports2, module2) {
    "use strict";
    var { Writable } = require("stream");
    var PerMessageDeflate = require_permessage_deflate();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      kStatusCode,
      kWebSocket
    } = require_constants();
    var { concat, toArrayBuffer, unmask } = require_buffer_util();
    var { isValidStatusCode, isValidUTF8 } = require_validation();
    var FastBuffer = Buffer[Symbol.species];
    var GET_INFO = 0;
    var GET_PAYLOAD_LENGTH_16 = 1;
    var GET_PAYLOAD_LENGTH_64 = 2;
    var GET_MASK = 3;
    var GET_DATA = 4;
    var INFLATING = 5;
    var DEFER_EVENT = 6;
    var Receiver = class extends Writable {
      /**
       * Creates a Receiver instance.
       *
       * @param {Object} [options] Options object
       * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
       *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
       *     multiple times in the same tick
       * @param {String} [options.binaryType=nodebuffer] The type for binary data
       * @param {Object} [options.extensions] An object containing the negotiated
       *     extensions
       * @param {Boolean} [options.isServer=false] Specifies whether to operate in
       *     client or server mode
       * @param {Number} [options.maxPayload=0] The maximum allowed message length
       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
       *     not to skip UTF-8 validation for text and close messages
       */
      constructor(options = {}) {
        super();
        this._allowSynchronousEvents = options.allowSynchronousEvents !== void 0 ? options.allowSynchronousEvents : true;
        this._binaryType = options.binaryType || BINARY_TYPES[0];
        this._extensions = options.extensions || {};
        this._isServer = !!options.isServer;
        this._maxPayload = options.maxPayload | 0;
        this._skipUTF8Validation = !!options.skipUTF8Validation;
        this[kWebSocket] = void 0;
        this._bufferedBytes = 0;
        this._buffers = [];
        this._compressed = false;
        this._payloadLength = 0;
        this._mask = void 0;
        this._fragmented = 0;
        this._masked = false;
        this._fin = false;
        this._opcode = 0;
        this._totalPayloadLength = 0;
        this._messageLength = 0;
        this._fragments = [];
        this._errored = false;
        this._loop = false;
        this._state = GET_INFO;
      }
      /**
       * Implements `Writable.prototype._write()`.
       *
       * @param {Buffer} chunk The chunk of data to write
       * @param {String} encoding The character encoding of `chunk`
       * @param {Function} cb Callback
       * @private
       */
      _write(chunk, encoding, cb) {
        if (this._opcode === 8 && this._state == GET_INFO) return cb();
        this._bufferedBytes += chunk.length;
        this._buffers.push(chunk);
        this.startLoop(cb);
      }
      /**
       * Consumes `n` bytes from the buffered data.
       *
       * @param {Number} n The number of bytes to consume
       * @return {Buffer} The consumed bytes
       * @private
       */
      consume(n) {
        this._bufferedBytes -= n;
        if (n === this._buffers[0].length) return this._buffers.shift();
        if (n < this._buffers[0].length) {
          const buf = this._buffers[0];
          this._buffers[0] = new FastBuffer(
            buf.buffer,
            buf.byteOffset + n,
            buf.length - n
          );
          return new FastBuffer(buf.buffer, buf.byteOffset, n);
        }
        const dst = Buffer.allocUnsafe(n);
        do {
          const buf = this._buffers[0];
          const offset = dst.length - n;
          if (n >= buf.length) {
            dst.set(this._buffers.shift(), offset);
          } else {
            dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
            this._buffers[0] = new FastBuffer(
              buf.buffer,
              buf.byteOffset + n,
              buf.length - n
            );
          }
          n -= buf.length;
        } while (n > 0);
        return dst;
      }
      /**
       * Starts the parsing loop.
       *
       * @param {Function} cb Callback
       * @private
       */
      startLoop(cb) {
        this._loop = true;
        do {
          switch (this._state) {
            case GET_INFO:
              this.getInfo(cb);
              break;
            case GET_PAYLOAD_LENGTH_16:
              this.getPayloadLength16(cb);
              break;
            case GET_PAYLOAD_LENGTH_64:
              this.getPayloadLength64(cb);
              break;
            case GET_MASK:
              this.getMask();
              break;
            case GET_DATA:
              this.getData(cb);
              break;
            case INFLATING:
            case DEFER_EVENT:
              this._loop = false;
              return;
          }
        } while (this._loop);
        if (!this._errored) cb();
      }
      /**
       * Reads the first two bytes of a frame.
       *
       * @param {Function} cb Callback
       * @private
       */
      getInfo(cb) {
        if (this._bufferedBytes < 2) {
          this._loop = false;
          return;
        }
        const buf = this.consume(2);
        if ((buf[0] & 48) !== 0) {
          const error73 = this.createError(
            RangeError,
            "RSV2 and RSV3 must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_RSV_2_3"
          );
          cb(error73);
          return;
        }
        const compressed = (buf[0] & 64) === 64;
        if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
          const error73 = this.createError(
            RangeError,
            "RSV1 must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_RSV_1"
          );
          cb(error73);
          return;
        }
        this._fin = (buf[0] & 128) === 128;
        this._opcode = buf[0] & 15;
        this._payloadLength = buf[1] & 127;
        if (this._opcode === 0) {
          if (compressed) {
            const error73 = this.createError(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
            cb(error73);
            return;
          }
          if (!this._fragmented) {
            const error73 = this.createError(
              RangeError,
              "invalid opcode 0",
              true,
              1002,
              "WS_ERR_INVALID_OPCODE"
            );
            cb(error73);
            return;
          }
          this._opcode = this._fragmented;
        } else if (this._opcode === 1 || this._opcode === 2) {
          if (this._fragmented) {
            const error73 = this.createError(
              RangeError,
              `invalid opcode ${this._opcode}`,
              true,
              1002,
              "WS_ERR_INVALID_OPCODE"
            );
            cb(error73);
            return;
          }
          this._compressed = compressed;
        } else if (this._opcode > 7 && this._opcode < 11) {
          if (!this._fin) {
            const error73 = this.createError(
              RangeError,
              "FIN must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_FIN"
            );
            cb(error73);
            return;
          }
          if (compressed) {
            const error73 = this.createError(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
            cb(error73);
            return;
          }
          if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
            const error73 = this.createError(
              RangeError,
              `invalid payload length ${this._payloadLength}`,
              true,
              1002,
              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
            );
            cb(error73);
            return;
          }
        } else {
          const error73 = this.createError(
            RangeError,
            `invalid opcode ${this._opcode}`,
            true,
            1002,
            "WS_ERR_INVALID_OPCODE"
          );
          cb(error73);
          return;
        }
        if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
        this._masked = (buf[1] & 128) === 128;
        if (this._isServer) {
          if (!this._masked) {
            const error73 = this.createError(
              RangeError,
              "MASK must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_MASK"
            );
            cb(error73);
            return;
          }
        } else if (this._masked) {
          const error73 = this.createError(
            RangeError,
            "MASK must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_MASK"
          );
          cb(error73);
          return;
        }
        if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
        else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
        else this.haveLength(cb);
      }
      /**
       * Gets extended payload length (7+16).
       *
       * @param {Function} cb Callback
       * @private
       */
      getPayloadLength16(cb) {
        if (this._bufferedBytes < 2) {
          this._loop = false;
          return;
        }
        this._payloadLength = this.consume(2).readUInt16BE(0);
        this.haveLength(cb);
      }
      /**
       * Gets extended payload length (7+64).
       *
       * @param {Function} cb Callback
       * @private
       */
      getPayloadLength64(cb) {
        if (this._bufferedBytes < 8) {
          this._loop = false;
          return;
        }
        const buf = this.consume(8);
        const num = buf.readUInt32BE(0);
        if (num > Math.pow(2, 53 - 32) - 1) {
          const error73 = this.createError(
            RangeError,
            "Unsupported WebSocket frame: payload length > 2^53 - 1",
            false,
            1009,
            "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
          );
          cb(error73);
          return;
        }
        this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
        this.haveLength(cb);
      }
      /**
       * Payload length has been read.
       *
       * @param {Function} cb Callback
       * @private
       */
      haveLength(cb) {
        if (this._payloadLength && this._opcode < 8) {
          this._totalPayloadLength += this._payloadLength;
          if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
            const error73 = this.createError(
              RangeError,
              "Max payload size exceeded",
              false,
              1009,
              "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
            );
            cb(error73);
            return;
          }
        }
        if (this._masked) this._state = GET_MASK;
        else this._state = GET_DATA;
      }
      /**
       * Reads mask bytes.
       *
       * @private
       */
      getMask() {
        if (this._bufferedBytes < 4) {
          this._loop = false;
          return;
        }
        this._mask = this.consume(4);
        this._state = GET_DATA;
      }
      /**
       * Reads data bytes.
       *
       * @param {Function} cb Callback
       * @private
       */
      getData(cb) {
        let data = EMPTY_BUFFER;
        if (this._payloadLength) {
          if (this._bufferedBytes < this._payloadLength) {
            this._loop = false;
            return;
          }
          data = this.consume(this._payloadLength);
          if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
            unmask(data, this._mask);
          }
        }
        if (this._opcode > 7) {
          this.controlMessage(data, cb);
          return;
        }
        if (this._compressed) {
          this._state = INFLATING;
          this.decompress(data, cb);
          return;
        }
        if (data.length) {
          this._messageLength = this._totalPayloadLength;
          this._fragments.push(data);
        }
        this.dataMessage(cb);
      }
      /**
       * Decompresses data.
       *
       * @param {Buffer} data Compressed data
       * @param {Function} cb Callback
       * @private
       */
      decompress(data, cb) {
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        perMessageDeflate.decompress(data, this._fin, (err, buf) => {
          if (err) return cb(err);
          if (buf.length) {
            this._messageLength += buf.length;
            if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
              const error73 = this.createError(
                RangeError,
                "Max payload size exceeded",
                false,
                1009,
                "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
              );
              cb(error73);
              return;
            }
            this._fragments.push(buf);
          }
          this.dataMessage(cb);
          if (this._state === GET_INFO) this.startLoop(cb);
        });
      }
      /**
       * Handles a data message.
       *
       * @param {Function} cb Callback
       * @private
       */
      dataMessage(cb) {
        if (!this._fin) {
          this._state = GET_INFO;
          return;
        }
        const messageLength = this._messageLength;
        const fragments = this._fragments;
        this._totalPayloadLength = 0;
        this._messageLength = 0;
        this._fragmented = 0;
        this._fragments = [];
        if (this._opcode === 2) {
          let data;
          if (this._binaryType === "nodebuffer") {
            data = concat(fragments, messageLength);
          } else if (this._binaryType === "arraybuffer") {
            data = toArrayBuffer(concat(fragments, messageLength));
          } else if (this._binaryType === "blob") {
            data = new Blob(fragments);
          } else {
            data = fragments;
          }
          if (this._allowSynchronousEvents) {
            this.emit("message", data, true);
            this._state = GET_INFO;
          } else {
            this._state = DEFER_EVENT;
            setImmediate(() => {
              this.emit("message", data, true);
              this._state = GET_INFO;
              this.startLoop(cb);
            });
          }
        } else {
          const buf = concat(fragments, messageLength);
          if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
            const error73 = this.createError(
              Error,
              "invalid UTF-8 sequence",
              true,
              1007,
              "WS_ERR_INVALID_UTF8"
            );
            cb(error73);
            return;
          }
          if (this._state === INFLATING || this._allowSynchronousEvents) {
            this.emit("message", buf, false);
            this._state = GET_INFO;
          } else {
            this._state = DEFER_EVENT;
            setImmediate(() => {
              this.emit("message", buf, false);
              this._state = GET_INFO;
              this.startLoop(cb);
            });
          }
        }
      }
      /**
       * Handles a control message.
       *
       * @param {Buffer} data Data to handle
       * @return {(Error|RangeError|undefined)} A possible error
       * @private
       */
      controlMessage(data, cb) {
        if (this._opcode === 8) {
          if (data.length === 0) {
            this._loop = false;
            this.emit("conclude", 1005, EMPTY_BUFFER);
            this.end();
          } else {
            const code = data.readUInt16BE(0);
            if (!isValidStatusCode(code)) {
              const error73 = this.createError(
                RangeError,
                `invalid status code ${code}`,
                true,
                1002,
                "WS_ERR_INVALID_CLOSE_CODE"
              );
              cb(error73);
              return;
            }
            const buf = new FastBuffer(
              data.buffer,
              data.byteOffset + 2,
              data.length - 2
            );
            if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
              const error73 = this.createError(
                Error,
                "invalid UTF-8 sequence",
                true,
                1007,
                "WS_ERR_INVALID_UTF8"
              );
              cb(error73);
              return;
            }
            this._loop = false;
            this.emit("conclude", code, buf);
            this.end();
          }
          this._state = GET_INFO;
          return;
        }
        if (this._allowSynchronousEvents) {
          this.emit(this._opcode === 9 ? "ping" : "pong", data);
          this._state = GET_INFO;
        } else {
          this._state = DEFER_EVENT;
          setImmediate(() => {
            this.emit(this._opcode === 9 ? "ping" : "pong", data);
            this._state = GET_INFO;
            this.startLoop(cb);
          });
        }
      }
      /**
       * Builds an error object.
       *
       * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
       * @param {String} message The error message
       * @param {Boolean} prefix Specifies whether or not to add a default prefix to
       *     `message`
       * @param {Number} statusCode The status code
       * @param {String} errorCode The exposed error code
       * @return {(Error|RangeError)} The error
       * @private
       */
      createError(ErrorCtor, message, prefix, statusCode, errorCode) {
        this._loop = false;
        this._errored = true;
        const err = new ErrorCtor(
          prefix ? `Invalid WebSocket frame: ${message}` : message
        );
        Error.captureStackTrace(err, this.createError);
        err.code = errorCode;
        err[kStatusCode] = statusCode;
        return err;
      }
    };
    module2.exports = Receiver;
  }
});

// node_modules/ws/lib/sender.js
var require_sender = __commonJS({
  "node_modules/ws/lib/sender.js"(exports2, module2) {
    "use strict";
    var { Duplex } = require("stream");
    var { randomFillSync: randomFillSync2 } = require("crypto");
    var PerMessageDeflate = require_permessage_deflate();
    var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
    var { isBlob: isBlob2, isValidStatusCode } = require_validation();
    var { mask: applyMask, toBuffer } = require_buffer_util();
    var kByteLength = /* @__PURE__ */ Symbol("kByteLength");
    var maskBuffer = Buffer.alloc(4);
    var RANDOM_POOL_SIZE = 8 * 1024;
    var randomPool;
    var randomPoolPointer = RANDOM_POOL_SIZE;
    var DEFAULT = 0;
    var DEFLATING = 1;
    var GET_BLOB_DATA = 2;
    var Sender = class _Sender {
      /**
       * Creates a Sender instance.
       *
       * @param {Duplex} socket The connection socket
       * @param {Object} [extensions] An object containing the negotiated extensions
       * @param {Function} [generateMask] The function used to generate the masking
       *     key
       */
      constructor(socket, extensions, generateMask) {
        this._extensions = extensions || {};
        if (generateMask) {
          this._generateMask = generateMask;
          this._maskBuffer = Buffer.alloc(4);
        }
        this._socket = socket;
        this._firstFragment = true;
        this._compress = false;
        this._bufferedBytes = 0;
        this._queue = [];
        this._state = DEFAULT;
        this.onerror = NOOP;
        this[kWebSocket] = void 0;
      }
      /**
       * Frames a piece of data according to the HyBi WebSocket protocol.
       *
       * @param {(Buffer|String)} data The data to frame
       * @param {Object} options Options object
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
       *     key
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @return {(Buffer|String)[]} The framed data
       * @public
       */
      static frame(data, options) {
        let mask;
        let merge4 = false;
        let offset = 2;
        let skipMasking = false;
        if (options.mask) {
          mask = options.maskBuffer || maskBuffer;
          if (options.generateMask) {
            options.generateMask(mask);
          } else {
            if (randomPoolPointer === RANDOM_POOL_SIZE) {
              if (randomPool === void 0) {
                randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
              }
              randomFillSync2(randomPool, 0, RANDOM_POOL_SIZE);
              randomPoolPointer = 0;
            }
            mask[0] = randomPool[randomPoolPointer++];
            mask[1] = randomPool[randomPoolPointer++];
            mask[2] = randomPool[randomPoolPointer++];
            mask[3] = randomPool[randomPoolPointer++];
          }
          skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
          offset = 6;
        }
        let dataLength;
        if (typeof data === "string") {
          if ((!options.mask || skipMasking) && options[kByteLength] !== void 0) {
            dataLength = options[kByteLength];
          } else {
            data = Buffer.from(data);
            dataLength = data.length;
          }
        } else {
          dataLength = data.length;
          merge4 = options.mask && options.readOnly && !skipMasking;
        }
        let payloadLength = dataLength;
        if (dataLength >= 65536) {
          offset += 8;
          payloadLength = 127;
        } else if (dataLength > 125) {
          offset += 2;
          payloadLength = 126;
        }
        const target = Buffer.allocUnsafe(merge4 ? dataLength + offset : offset);
        target[0] = options.fin ? options.opcode | 128 : options.opcode;
        if (options.rsv1) target[0] |= 64;
        target[1] = payloadLength;
        if (payloadLength === 126) {
          target.writeUInt16BE(dataLength, 2);
        } else if (payloadLength === 127) {
          target[2] = target[3] = 0;
          target.writeUIntBE(dataLength, 4, 6);
        }
        if (!options.mask) return [target, data];
        target[1] |= 128;
        target[offset - 4] = mask[0];
        target[offset - 3] = mask[1];
        target[offset - 2] = mask[2];
        target[offset - 1] = mask[3];
        if (skipMasking) return [target, data];
        if (merge4) {
          applyMask(data, mask, target, offset, dataLength);
          return [target];
        }
        applyMask(data, mask, data, 0, dataLength);
        return [target, data];
      }
      /**
       * Sends a close message to the other peer.
       *
       * @param {Number} [code] The status code component of the body
       * @param {(String|Buffer)} [data] The message component of the body
       * @param {Boolean} [mask=false] Specifies whether or not to mask the message
       * @param {Function} [cb] Callback
       * @public
       */
      close(code, data, mask, cb) {
        let buf;
        if (code === void 0) {
          buf = EMPTY_BUFFER;
        } else if (typeof code !== "number" || !isValidStatusCode(code)) {
          throw new TypeError("First argument must be a valid error code number");
        } else if (data === void 0 || !data.length) {
          buf = Buffer.allocUnsafe(2);
          buf.writeUInt16BE(code, 0);
        } else {
          const length = Buffer.byteLength(data);
          if (length > 123) {
            throw new RangeError("The message must not be greater than 123 bytes");
          }
          buf = Buffer.allocUnsafe(2 + length);
          buf.writeUInt16BE(code, 0);
          if (typeof data === "string") {
            buf.write(data, 2);
          } else {
            buf.set(data, 2);
          }
        }
        const options = {
          [kByteLength]: buf.length,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 8,
          readOnly: false,
          rsv1: false
        };
        if (this._state !== DEFAULT) {
          this.enqueue([this.dispatch, buf, false, options, cb]);
        } else {
          this.sendFrame(_Sender.frame(buf, options), cb);
        }
      }
      /**
       * Sends a ping message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback
       * @public
       */
      ping(data, mask, cb) {
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          readOnly = false;
        } else if (isBlob2(data)) {
          byteLength = data.size;
          readOnly = false;
        } else {
          data = toBuffer(data);
          byteLength = data.length;
          readOnly = toBuffer.readOnly;
        }
        if (byteLength > 125) {
          throw new RangeError("The data size must not be greater than 125 bytes");
        }
        const options = {
          [kByteLength]: byteLength,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 9,
          readOnly,
          rsv1: false
        };
        if (isBlob2(data)) {
          if (this._state !== DEFAULT) {
            this.enqueue([this.getBlobData, data, false, options, cb]);
          } else {
            this.getBlobData(data, false, options, cb);
          }
        } else if (this._state !== DEFAULT) {
          this.enqueue([this.dispatch, data, false, options, cb]);
        } else {
          this.sendFrame(_Sender.frame(data, options), cb);
        }
      }
      /**
       * Sends a pong message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback
       * @public
       */
      pong(data, mask, cb) {
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          readOnly = false;
        } else if (isBlob2(data)) {
          byteLength = data.size;
          readOnly = false;
        } else {
          data = toBuffer(data);
          byteLength = data.length;
          readOnly = toBuffer.readOnly;
        }
        if (byteLength > 125) {
          throw new RangeError("The data size must not be greater than 125 bytes");
        }
        const options = {
          [kByteLength]: byteLength,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 10,
          readOnly,
          rsv1: false
        };
        if (isBlob2(data)) {
          if (this._state !== DEFAULT) {
            this.enqueue([this.getBlobData, data, false, options, cb]);
          } else {
            this.getBlobData(data, false, options, cb);
          }
        } else if (this._state !== DEFAULT) {
          this.enqueue([this.dispatch, data, false, options, cb]);
        } else {
          this.sendFrame(_Sender.frame(data, options), cb);
        }
      }
      /**
       * Sends a data message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Object} options Options object
       * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
       *     or text
       * @param {Boolean} [options.compress=false] Specifies whether or not to
       *     compress `data`
       * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
       *     last one
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Function} [cb] Callback
       * @public
       */
      send(data, options, cb) {
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        let opcode = options.binary ? 2 : 1;
        let rsv1 = options.compress;
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          readOnly = false;
        } else if (isBlob2(data)) {
          byteLength = data.size;
          readOnly = false;
        } else {
          data = toBuffer(data);
          byteLength = data.length;
          readOnly = toBuffer.readOnly;
        }
        if (this._firstFragment) {
          this._firstFragment = false;
          if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) {
            rsv1 = byteLength >= perMessageDeflate._threshold;
          }
          this._compress = rsv1;
        } else {
          rsv1 = false;
          opcode = 0;
        }
        if (options.fin) this._firstFragment = true;
        const opts = {
          [kByteLength]: byteLength,
          fin: options.fin,
          generateMask: this._generateMask,
          mask: options.mask,
          maskBuffer: this._maskBuffer,
          opcode,
          readOnly,
          rsv1
        };
        if (isBlob2(data)) {
          if (this._state !== DEFAULT) {
            this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
          } else {
            this.getBlobData(data, this._compress, opts, cb);
          }
        } else if (this._state !== DEFAULT) {
          this.enqueue([this.dispatch, data, this._compress, opts, cb]);
        } else {
          this.dispatch(data, this._compress, opts, cb);
        }
      }
      /**
       * Gets the contents of a blob as binary data.
       *
       * @param {Blob} blob The blob
       * @param {Boolean} [compress=false] Specifies whether or not to compress
       *     the data
       * @param {Object} options Options object
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
       *     key
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @param {Function} [cb] Callback
       * @private
       */
      getBlobData(blob, compress, options, cb) {
        this._bufferedBytes += options[kByteLength];
        this._state = GET_BLOB_DATA;
        blob.arrayBuffer().then((arrayBuffer) => {
          if (this._socket.destroyed) {
            const err = new Error(
              "The socket was closed while the blob was being read"
            );
            process.nextTick(callCallbacks, this, err, cb);
            return;
          }
          this._bufferedBytes -= options[kByteLength];
          const data = toBuffer(arrayBuffer);
          if (!compress) {
            this._state = DEFAULT;
            this.sendFrame(_Sender.frame(data, options), cb);
            this.dequeue();
          } else {
            this.dispatch(data, compress, options, cb);
          }
        }).catch((err) => {
          process.nextTick(onError, this, err, cb);
        });
      }
      /**
       * Dispatches a message.
       *
       * @param {(Buffer|String)} data The message to send
       * @param {Boolean} [compress=false] Specifies whether or not to compress
       *     `data`
       * @param {Object} options Options object
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
       *     key
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @param {Function} [cb] Callback
       * @private
       */
      dispatch(data, compress, options, cb) {
        if (!compress) {
          this.sendFrame(_Sender.frame(data, options), cb);
          return;
        }
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        this._bufferedBytes += options[kByteLength];
        this._state = DEFLATING;
        perMessageDeflate.compress(data, options.fin, (_, buf) => {
          if (this._socket.destroyed) {
            const err = new Error(
              "The socket was closed while data was being compressed"
            );
            callCallbacks(this, err, cb);
            return;
          }
          this._bufferedBytes -= options[kByteLength];
          this._state = DEFAULT;
          options.readOnly = false;
          this.sendFrame(_Sender.frame(buf, options), cb);
          this.dequeue();
        });
      }
      /**
       * Executes queued send operations.
       *
       * @private
       */
      dequeue() {
        while (this._state === DEFAULT && this._queue.length) {
          const params = this._queue.shift();
          this._bufferedBytes -= params[3][kByteLength];
          Reflect.apply(params[0], this, params.slice(1));
        }
      }
      /**
       * Enqueues a send operation.
       *
       * @param {Array} params Send operation parameters.
       * @private
       */
      enqueue(params) {
        this._bufferedBytes += params[3][kByteLength];
        this._queue.push(params);
      }
      /**
       * Sends a frame.
       *
       * @param {(Buffer | String)[]} list The frame to send
       * @param {Function} [cb] Callback
       * @private
       */
      sendFrame(list2, cb) {
        if (list2.length === 2) {
          this._socket.cork();
          this._socket.write(list2[0]);
          this._socket.write(list2[1], cb);
          this._socket.uncork();
        } else {
          this._socket.write(list2[0], cb);
        }
      }
    };
    module2.exports = Sender;
    function callCallbacks(sender, err, cb) {
      if (typeof cb === "function") cb(err);
      for (let i = 0; i < sender._queue.length; i++) {
        const params = sender._queue[i];
        const callback = params[params.length - 1];
        if (typeof callback === "function") callback(err);
      }
    }
    function onError(sender, err, cb) {
      callCallbacks(sender, err, cb);
      sender.onerror(err);
    }
  }
});

// node_modules/ws/lib/event-target.js
var require_event_target = __commonJS({
  "node_modules/ws/lib/event-target.js"(exports2, module2) {
    "use strict";
    var { kForOnEventAttribute, kListener } = require_constants();
    var kCode = /* @__PURE__ */ Symbol("kCode");
    var kData = /* @__PURE__ */ Symbol("kData");
    var kError = /* @__PURE__ */ Symbol("kError");
    var kMessage = /* @__PURE__ */ Symbol("kMessage");
    var kReason = /* @__PURE__ */ Symbol("kReason");
    var kTarget = /* @__PURE__ */ Symbol("kTarget");
    var kType = /* @__PURE__ */ Symbol("kType");
    var kWasClean = /* @__PURE__ */ Symbol("kWasClean");
    var Event = class {
      /**
       * Create a new `Event`.
       *
       * @param {String} type The name of the event
       * @throws {TypeError} If the `type` argument is not specified
       */
      constructor(type) {
        this[kTarget] = null;
        this[kType] = type;
      }
      /**
       * @type {*}
       */
      get target() {
        return this[kTarget];
      }
      /**
       * @type {String}
       */
      get type() {
        return this[kType];
      }
    };
    Object.defineProperty(Event.prototype, "target", { enumerable: true });
    Object.defineProperty(Event.prototype, "type", { enumerable: true });
    var CloseEvent = class extends Event {
      /**
       * Create a new `CloseEvent`.
       *
       * @param {String} type The name of the event
       * @param {Object} [options] A dictionary object that allows for setting
       *     attributes via object members of the same name
       * @param {Number} [options.code=0] The status code explaining why the
       *     connection was closed
       * @param {String} [options.reason=''] A human-readable string explaining why
       *     the connection was closed
       * @param {Boolean} [options.wasClean=false] Indicates whether or not the
       *     connection was cleanly closed
       */
      constructor(type, options = {}) {
        super(type);
        this[kCode] = options.code === void 0 ? 0 : options.code;
        this[kReason] = options.reason === void 0 ? "" : options.reason;
        this[kWasClean] = options.wasClean === void 0 ? false : options.wasClean;
      }
      /**
       * @type {Number}
       */
      get code() {
        return this[kCode];
      }
      /**
       * @type {String}
       */
      get reason() {
        return this[kReason];
      }
      /**
       * @type {Boolean}
       */
      get wasClean() {
        return this[kWasClean];
      }
    };
    Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
    Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
    Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
    var ErrorEvent = class extends Event {
      /**
       * Create a new `ErrorEvent`.
       *
       * @param {String} type The name of the event
       * @param {Object} [options] A dictionary object that allows for setting
       *     attributes via object members of the same name
       * @param {*} [options.error=null] The error that generated this event
       * @param {String} [options.message=''] The error message
       */
      constructor(type, options = {}) {
        super(type);
        this[kError] = options.error === void 0 ? null : options.error;
        this[kMessage] = options.message === void 0 ? "" : options.message;
      }
      /**
       * @type {*}
       */
      get error() {
        return this[kError];
      }
      /**
       * @type {String}
       */
      get message() {
        return this[kMessage];
      }
    };
    Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
    Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
    var MessageEvent = class extends Event {
      /**
       * Create a new `MessageEvent`.
       *
       * @param {String} type The name of the event
       * @param {Object} [options] A dictionary object that allows for setting
       *     attributes via object members of the same name
       * @param {*} [options.data=null] The message content
       */
      constructor(type, options = {}) {
        super(type);
        this[kData] = options.data === void 0 ? null : options.data;
      }
      /**
       * @type {*}
       */
      get data() {
        return this[kData];
      }
    };
    Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
    var EventTarget = {
      /**
       * Register an event listener.
       *
       * @param {String} type A string representing the event type to listen for
       * @param {(Function|Object)} handler The listener to add
       * @param {Object} [options] An options object specifies characteristics about
       *     the event listener
       * @param {Boolean} [options.once=false] A `Boolean` indicating that the
       *     listener should be invoked at most once after being added. If `true`,
       *     the listener would be automatically removed when invoked.
       * @public
       */
      addEventListener(type, handler, options = {}) {
        for (const listener of this.listeners(type)) {
          if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) {
            return;
          }
        }
        let wrapper;
        if (type === "message") {
          wrapper = function onMessage(data, isBinary) {
            const event = new MessageEvent("message", {
              data: isBinary ? data : data.toString()
            });
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else if (type === "close") {
          wrapper = function onClose(code, message) {
            const event = new CloseEvent("close", {
              code,
              reason: message.toString(),
              wasClean: this._closeFrameReceived && this._closeFrameSent
            });
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else if (type === "error") {
          wrapper = function onError(error73) {
            const event = new ErrorEvent("error", {
              error: error73,
              message: error73.message
            });
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else if (type === "open") {
          wrapper = function onOpen() {
            const event = new Event("open");
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else {
          return;
        }
        wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
        wrapper[kListener] = handler;
        if (options.once) {
          this.once(type, wrapper);
        } else {
          this.on(type, wrapper);
        }
      },
      /**
       * Remove an event listener.
       *
       * @param {String} type A string representing the event type to remove
       * @param {(Function|Object)} handler The listener to remove
       * @public
       */
      removeEventListener(type, handler) {
        for (const listener of this.listeners(type)) {
          if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
            this.removeListener(type, listener);
            break;
          }
        }
      }
    };
    module2.exports = {
      CloseEvent,
      ErrorEvent,
      Event,
      EventTarget,
      MessageEvent
    };
    function callListener(listener, thisArg, event) {
      if (typeof listener === "object" && listener.handleEvent) {
        listener.handleEvent.call(listener, event);
      } else {
        listener.call(thisArg, event);
      }
    }
  }
});

// node_modules/ws/lib/extension.js
var require_extension = __commonJS({
  "node_modules/ws/lib/extension.js"(exports2, module2) {
    "use strict";
    var { tokenChars } = require_validation();
    function push(dest, name28, elem) {
      if (dest[name28] === void 0) dest[name28] = [elem];
      else dest[name28].push(elem);
    }
    function parse4(header) {
      const offers = /* @__PURE__ */ Object.create(null);
      let params = /* @__PURE__ */ Object.create(null);
      let mustUnescape = false;
      let isEscaping = false;
      let inQuotes = false;
      let extensionName;
      let paramName;
      let start = -1;
      let code = -1;
      let end = -1;
      let i = 0;
      for (; i < header.length; i++) {
        code = header.charCodeAt(i);
        if (extensionName === void 0) {
          if (end === -1 && tokenChars[code] === 1) {
            if (start === -1) start = i;
          } else if (i !== 0 && (code === 32 || code === 9)) {
            if (end === -1 && start !== -1) end = i;
          } else if (code === 59 || code === 44) {
            if (start === -1) {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
            if (end === -1) end = i;
            const name28 = header.slice(start, end);
            if (code === 44) {
              push(offers, name28, params);
              params = /* @__PURE__ */ Object.create(null);
            } else {
              extensionName = name28;
            }
            start = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i}`);
          }
        } else if (paramName === void 0) {
          if (end === -1 && tokenChars[code] === 1) {
            if (start === -1) start = i;
          } else if (code === 32 || code === 9) {
            if (end === -1 && start !== -1) end = i;
          } else if (code === 59 || code === 44) {
            if (start === -1) {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
            if (end === -1) end = i;
            push(params, header.slice(start, end), true);
            if (code === 44) {
              push(offers, extensionName, params);
              params = /* @__PURE__ */ Object.create(null);
              extensionName = void 0;
            }
            start = end = -1;
          } else if (code === 61 && start !== -1 && end === -1) {
            paramName = header.slice(start, i);
            start = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i}`);
          }
        } else {
          if (isEscaping) {
            if (tokenChars[code] !== 1) {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
            if (start === -1) start = i;
            else if (!mustUnescape) mustUnescape = true;
            isEscaping = false;
          } else if (inQuotes) {
            if (tokenChars[code] === 1) {
              if (start === -1) start = i;
            } else if (code === 34 && start !== -1) {
              inQuotes = false;
              end = i;
            } else if (code === 92) {
              isEscaping = true;
            } else {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
          } else if (code === 34 && header.charCodeAt(i - 1) === 61) {
            inQuotes = true;
          } else if (end === -1 && tokenChars[code] === 1) {
            if (start === -1) start = i;
          } else if (start !== -1 && (code === 32 || code === 9)) {
            if (end === -1) end = i;
          } else if (code === 59 || code === 44) {
            if (start === -1) {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
            if (end === -1) end = i;
            let value = header.slice(start, end);
            if (mustUnescape) {
              value = value.replace(/\\/g, "");
              mustUnescape = false;
            }
            push(params, paramName, value);
            if (code === 44) {
              push(offers, extensionName, params);
              params = /* @__PURE__ */ Object.create(null);
              extensionName = void 0;
            }
            paramName = void 0;
            start = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i}`);
          }
        }
      }
      if (start === -1 || inQuotes || code === 32 || code === 9) {
        throw new SyntaxError("Unexpected end of input");
      }
      if (end === -1) end = i;
      const token = header.slice(start, end);
      if (extensionName === void 0) {
        push(offers, token, params);
      } else {
        if (paramName === void 0) {
          push(params, token, true);
        } else if (mustUnescape) {
          push(params, paramName, token.replace(/\\/g, ""));
        } else {
          push(params, paramName, token);
        }
        push(offers, extensionName, params);
      }
      return offers;
    }
    function format(extensions) {
      return Object.keys(extensions).map((extension) => {
        let configurations = extensions[extension];
        if (!Array.isArray(configurations)) configurations = [configurations];
        return configurations.map((params) => {
          return [extension].concat(
            Object.keys(params).map((k) => {
              let values = params[k];
              if (!Array.isArray(values)) values = [values];
              return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
            })
          ).join("; ");
        }).join(", ");
      }).join(", ");
    }
    module2.exports = { format, parse: parse4 };
  }
});

// node_modules/ws/lib/websocket.js
var require_websocket2 = __commonJS({
  "node_modules/ws/lib/websocket.js"(exports2, module2) {
    "use strict";
    var EventEmitter3 = require("events");
    var https2 = require("https");
    var http4 = require("http");
    var net = require("net");
    var tls = require("tls");
    var { randomBytes, createHash } = require("crypto");
    var { Duplex, Readable: Readable2 } = require("stream");
    var { URL: URL2 } = require("url");
    var PerMessageDeflate = require_permessage_deflate();
    var Receiver = require_receiver();
    var Sender = require_sender();
    var { isBlob: isBlob2 } = require_validation();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      GUID,
      kForOnEventAttribute,
      kListener,
      kStatusCode,
      kWebSocket,
      NOOP
    } = require_constants();
    var {
      EventTarget: { addEventListener, removeEventListener }
    } = require_event_target();
    var { format, parse: parse4 } = require_extension();
    var { toBuffer } = require_buffer_util();
    var closeTimeout = 30 * 1e3;
    var kAborted = /* @__PURE__ */ Symbol("kAborted");
    var protocolVersions = [8, 13];
    var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
    var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
    var WebSocket = class _WebSocket extends EventEmitter3 {
      /**
       * Create a new `WebSocket`.
       *
       * @param {(String|URL)} address The URL to which to connect
       * @param {(String|String[])} [protocols] The subprotocols
       * @param {Object} [options] Connection options
       */
      constructor(address, protocols, options) {
        super();
        this._binaryType = BINARY_TYPES[0];
        this._closeCode = 1006;
        this._closeFrameReceived = false;
        this._closeFrameSent = false;
        this._closeMessage = EMPTY_BUFFER;
        this._closeTimer = null;
        this._errorEmitted = false;
        this._extensions = {};
        this._paused = false;
        this._protocol = "";
        this._readyState = _WebSocket.CONNECTING;
        this._receiver = null;
        this._sender = null;
        this._socket = null;
        if (address !== null) {
          this._bufferedAmount = 0;
          this._isServer = false;
          this._redirects = 0;
          if (protocols === void 0) {
            protocols = [];
          } else if (!Array.isArray(protocols)) {
            if (typeof protocols === "object" && protocols !== null) {
              options = protocols;
              protocols = [];
            } else {
              protocols = [protocols];
            }
          }
          initAsClient(this, address, protocols, options);
        } else {
          this._autoPong = options.autoPong;
          this._isServer = true;
        }
      }
      /**
       * For historical reasons, the custom "nodebuffer" type is used by the default
       * instead of "blob".
       *
       * @type {String}
       */
      get binaryType() {
        return this._binaryType;
      }
      set binaryType(type) {
        if (!BINARY_TYPES.includes(type)) return;
        this._binaryType = type;
        if (this._receiver) this._receiver._binaryType = type;
      }
      /**
       * @type {Number}
       */
      get bufferedAmount() {
        if (!this._socket) return this._bufferedAmount;
        return this._socket._writableState.length + this._sender._bufferedBytes;
      }
      /**
       * @type {String}
       */
      get extensions() {
        return Object.keys(this._extensions).join();
      }
      /**
       * @type {Boolean}
       */
      get isPaused() {
        return this._paused;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onclose() {
        return null;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onerror() {
        return null;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onopen() {
        return null;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onmessage() {
        return null;
      }
      /**
       * @type {String}
       */
      get protocol() {
        return this._protocol;
      }
      /**
       * @type {Number}
       */
      get readyState() {
        return this._readyState;
      }
      /**
       * @type {String}
       */
      get url() {
        return this._url;
      }
      /**
       * Set up the socket and the internal resources.
       *
       * @param {Duplex} socket The network socket between the server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Object} options Options object
       * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
       *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
       *     multiple times in the same tick
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Number} [options.maxPayload=0] The maximum allowed message size
       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
       *     not to skip UTF-8 validation for text and close messages
       * @private
       */
      setSocket(socket, head, options) {
        const receiver = new Receiver({
          allowSynchronousEvents: options.allowSynchronousEvents,
          binaryType: this.binaryType,
          extensions: this._extensions,
          isServer: this._isServer,
          maxPayload: options.maxPayload,
          skipUTF8Validation: options.skipUTF8Validation
        });
        const sender = new Sender(socket, this._extensions, options.generateMask);
        this._receiver = receiver;
        this._sender = sender;
        this._socket = socket;
        receiver[kWebSocket] = this;
        sender[kWebSocket] = this;
        socket[kWebSocket] = this;
        receiver.on("conclude", receiverOnConclude);
        receiver.on("drain", receiverOnDrain);
        receiver.on("error", receiverOnError);
        receiver.on("message", receiverOnMessage);
        receiver.on("ping", receiverOnPing);
        receiver.on("pong", receiverOnPong);
        sender.onerror = senderOnError;
        if (socket.setTimeout) socket.setTimeout(0);
        if (socket.setNoDelay) socket.setNoDelay();
        if (head.length > 0) socket.unshift(head);
        socket.on("close", socketOnClose);
        socket.on("data", socketOnData);
        socket.on("end", socketOnEnd);
        socket.on("error", socketOnError);
        this._readyState = _WebSocket.OPEN;
        this.emit("open");
      }
      /**
       * Emit the `'close'` event.
       *
       * @private
       */
      emitClose() {
        if (!this._socket) {
          this._readyState = _WebSocket.CLOSED;
          this.emit("close", this._closeCode, this._closeMessage);
          return;
        }
        if (this._extensions[PerMessageDeflate.extensionName]) {
          this._extensions[PerMessageDeflate.extensionName].cleanup();
        }
        this._receiver.removeAllListeners();
        this._readyState = _WebSocket.CLOSED;
        this.emit("close", this._closeCode, this._closeMessage);
      }
      /**
       * Start a closing handshake.
       *
       *          +----------+   +-----------+   +----------+
       *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
       *    |     +----------+   +-----------+   +----------+     |
       *          +----------+   +-----------+         |
       * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
       *          +----------+   +-----------+   |
       *    |           |                        |   +---+        |
       *                +------------------------+-->|fin| - - - -
       *    |         +---+                      |   +---+
       *     - - - - -|fin|<---------------------+
       *              +---+
       *
       * @param {Number} [code] Status code explaining why the connection is closing
       * @param {(String|Buffer)} [data] The reason why the connection is
       *     closing
       * @public
       */
      close(code, data) {
        if (this.readyState === _WebSocket.CLOSED) return;
        if (this.readyState === _WebSocket.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          abortHandshake(this, this._req, msg);
          return;
        }
        if (this.readyState === _WebSocket.CLOSING) {
          if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
            this._socket.end();
          }
          return;
        }
        this._readyState = _WebSocket.CLOSING;
        this._sender.close(code, data, !this._isServer, (err) => {
          if (err) return;
          this._closeFrameSent = true;
          if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
            this._socket.end();
          }
        });
        setCloseTimer(this);
      }
      /**
       * Pause the socket.
       *
       * @public
       */
      pause() {
        if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
          return;
        }
        this._paused = true;
        this._socket.pause();
      }
      /**
       * Send a ping.
       *
       * @param {*} [data] The data to send
       * @param {Boolean} [mask] Indicates whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when the ping is sent
       * @public
       */
      ping(data, mask, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof data === "function") {
          cb = data;
          data = mask = void 0;
        } else if (typeof mask === "function") {
          cb = mask;
          mask = void 0;
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        if (mask === void 0) mask = !this._isServer;
        this._sender.ping(data || EMPTY_BUFFER, mask, cb);
      }
      /**
       * Send a pong.
       *
       * @param {*} [data] The data to send
       * @param {Boolean} [mask] Indicates whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when the pong is sent
       * @public
       */
      pong(data, mask, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof data === "function") {
          cb = data;
          data = mask = void 0;
        } else if (typeof mask === "function") {
          cb = mask;
          mask = void 0;
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        if (mask === void 0) mask = !this._isServer;
        this._sender.pong(data || EMPTY_BUFFER, mask, cb);
      }
      /**
       * Resume the socket.
       *
       * @public
       */
      resume() {
        if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
          return;
        }
        this._paused = false;
        if (!this._receiver._writableState.needDrain) this._socket.resume();
      }
      /**
       * Send a data message.
       *
       * @param {*} data The message to send
       * @param {Object} [options] Options object
       * @param {Boolean} [options.binary] Specifies whether `data` is binary or
       *     text
       * @param {Boolean} [options.compress] Specifies whether or not to compress
       *     `data`
       * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
       *     last one
       * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when data is written out
       * @public
       */
      send(data, options, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof options === "function") {
          cb = options;
          options = {};
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        const opts = {
          binary: typeof data !== "string",
          mask: !this._isServer,
          compress: true,
          fin: true,
          ...options
        };
        if (!this._extensions[PerMessageDeflate.extensionName]) {
          opts.compress = false;
        }
        this._sender.send(data || EMPTY_BUFFER, opts, cb);
      }
      /**
       * Forcibly close the connection.
       *
       * @public
       */
      terminate() {
        if (this.readyState === _WebSocket.CLOSED) return;
        if (this.readyState === _WebSocket.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          abortHandshake(this, this._req, msg);
          return;
        }
        if (this._socket) {
          this._readyState = _WebSocket.CLOSING;
          this._socket.destroy();
        }
      }
    };
    Object.defineProperty(WebSocket, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket.prototype, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket.prototype, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket.prototype, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    Object.defineProperty(WebSocket.prototype, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    [
      "binaryType",
      "bufferedAmount",
      "extensions",
      "isPaused",
      "protocol",
      "readyState",
      "url"
    ].forEach((property2) => {
      Object.defineProperty(WebSocket.prototype, property2, { enumerable: true });
    });
    ["open", "error", "close", "message"].forEach((method) => {
      Object.defineProperty(WebSocket.prototype, `on${method}`, {
        enumerable: true,
        get() {
          for (const listener of this.listeners(method)) {
            if (listener[kForOnEventAttribute]) return listener[kListener];
          }
          return null;
        },
        set(handler) {
          for (const listener of this.listeners(method)) {
            if (listener[kForOnEventAttribute]) {
              this.removeListener(method, listener);
              break;
            }
          }
          if (typeof handler !== "function") return;
          this.addEventListener(method, handler, {
            [kForOnEventAttribute]: true
          });
        }
      });
    });
    WebSocket.prototype.addEventListener = addEventListener;
    WebSocket.prototype.removeEventListener = removeEventListener;
    module2.exports = WebSocket;
    function initAsClient(websocket, address, protocols, options) {
      const opts = {
        allowSynchronousEvents: true,
        autoPong: true,
        protocolVersion: protocolVersions[1],
        maxPayload: 100 * 1024 * 1024,
        skipUTF8Validation: false,
        perMessageDeflate: true,
        followRedirects: false,
        maxRedirects: 10,
        ...options,
        socketPath: void 0,
        hostname: void 0,
        protocol: void 0,
        timeout: void 0,
        method: "GET",
        host: void 0,
        path: void 0,
        port: void 0
      };
      websocket._autoPong = opts.autoPong;
      if (!protocolVersions.includes(opts.protocolVersion)) {
        throw new RangeError(
          `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
        );
      }
      let parsedUrl;
      if (address instanceof URL2) {
        parsedUrl = address;
      } else {
        try {
          parsedUrl = new URL2(address);
        } catch (e) {
          throw new SyntaxError(`Invalid URL: ${address}`);
        }
      }
      if (parsedUrl.protocol === "http:") {
        parsedUrl.protocol = "ws:";
      } else if (parsedUrl.protocol === "https:") {
        parsedUrl.protocol = "wss:";
      }
      websocket._url = parsedUrl.href;
      const isSecure = parsedUrl.protocol === "wss:";
      const isIpcUrl = parsedUrl.protocol === "ws+unix:";
      let invalidUrlMessage;
      if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
        invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"`;
      } else if (isIpcUrl && !parsedUrl.pathname) {
        invalidUrlMessage = "The URL's pathname is empty";
      } else if (parsedUrl.hash) {
        invalidUrlMessage = "The URL contains a fragment identifier";
      }
      if (invalidUrlMessage) {
        const err = new SyntaxError(invalidUrlMessage);
        if (websocket._redirects === 0) {
          throw err;
        } else {
          emitErrorAndClose(websocket, err);
          return;
        }
      }
      const defaultPort = isSecure ? 443 : 80;
      const key = randomBytes(16).toString("base64");
      const request = isSecure ? https2.request : http4.request;
      const protocolSet = /* @__PURE__ */ new Set();
      let perMessageDeflate;
      opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
      opts.defaultPort = opts.defaultPort || defaultPort;
      opts.port = parsedUrl.port || defaultPort;
      opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
      opts.headers = {
        ...opts.headers,
        "Sec-WebSocket-Version": opts.protocolVersion,
        "Sec-WebSocket-Key": key,
        Connection: "Upgrade",
        Upgrade: "websocket"
      };
      opts.path = parsedUrl.pathname + parsedUrl.search;
      opts.timeout = opts.handshakeTimeout;
      if (opts.perMessageDeflate) {
        perMessageDeflate = new PerMessageDeflate(
          opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
          false,
          opts.maxPayload
        );
        opts.headers["Sec-WebSocket-Extensions"] = format({
          [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
        });
      }
      if (protocols.length) {
        for (const protocol of protocols) {
          if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) {
            throw new SyntaxError(
              "An invalid or duplicated subprotocol was specified"
            );
          }
          protocolSet.add(protocol);
        }
        opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
      }
      if (opts.origin) {
        if (opts.protocolVersion < 13) {
          opts.headers["Sec-WebSocket-Origin"] = opts.origin;
        } else {
          opts.headers.Origin = opts.origin;
        }
      }
      if (parsedUrl.username || parsedUrl.password) {
        opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
      }
      if (isIpcUrl) {
        const parts = opts.path.split(":");
        opts.socketPath = parts[0];
        opts.path = parts[1];
      }
      let req;
      if (opts.followRedirects) {
        if (websocket._redirects === 0) {
          websocket._originalIpc = isIpcUrl;
          websocket._originalSecure = isSecure;
          websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
          const headers = options && options.headers;
          options = { ...options, headers: {} };
          if (headers) {
            for (const [key2, value] of Object.entries(headers)) {
              options.headers[key2.toLowerCase()] = value;
            }
          }
        } else if (websocket.listenerCount("redirect") === 0) {
          const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
          if (!isSameHost || websocket._originalSecure && !isSecure) {
            delete opts.headers.authorization;
            delete opts.headers.cookie;
            if (!isSameHost) delete opts.headers.host;
            opts.auth = void 0;
          }
        }
        if (opts.auth && !options.headers.authorization) {
          options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
        }
        req = websocket._req = request(opts);
        if (websocket._redirects) {
          websocket.emit("redirect", websocket.url, req);
        }
      } else {
        req = websocket._req = request(opts);
      }
      if (opts.timeout) {
        req.on("timeout", () => {
          abortHandshake(websocket, req, "Opening handshake has timed out");
        });
      }
      req.on("error", (err) => {
        if (req === null || req[kAborted]) return;
        req = websocket._req = null;
        emitErrorAndClose(websocket, err);
      });
      req.on("response", (res) => {
        const location = res.headers.location;
        const statusCode = res.statusCode;
        if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
          if (++websocket._redirects > opts.maxRedirects) {
            abortHandshake(websocket, req, "Maximum redirects exceeded");
            return;
          }
          req.abort();
          let addr;
          try {
            addr = new URL2(location, address);
          } catch (e) {
            const err = new SyntaxError(`Invalid URL: ${location}`);
            emitErrorAndClose(websocket, err);
            return;
          }
          initAsClient(websocket, addr, protocols, options);
        } else if (!websocket.emit("unexpected-response", req, res)) {
          abortHandshake(
            websocket,
            req,
            `Unexpected server response: ${res.statusCode}`
          );
        }
      });
      req.on("upgrade", (res, socket, head) => {
        websocket.emit("upgrade", res);
        if (websocket.readyState !== WebSocket.CONNECTING) return;
        req = websocket._req = null;
        const upgrade = res.headers.upgrade;
        if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
          abortHandshake(websocket, socket, "Invalid Upgrade header");
          return;
        }
        const digest = createHash("sha1").update(key + GUID).digest("base64");
        if (res.headers["sec-websocket-accept"] !== digest) {
          abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
          return;
        }
        const serverProt = res.headers["sec-websocket-protocol"];
        let protError;
        if (serverProt !== void 0) {
          if (!protocolSet.size) {
            protError = "Server sent a subprotocol but none was requested";
          } else if (!protocolSet.has(serverProt)) {
            protError = "Server sent an invalid subprotocol";
          }
        } else if (protocolSet.size) {
          protError = "Server sent no subprotocol";
        }
        if (protError) {
          abortHandshake(websocket, socket, protError);
          return;
        }
        if (serverProt) websocket._protocol = serverProt;
        const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
        if (secWebSocketExtensions !== void 0) {
          if (!perMessageDeflate) {
            const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested";
            abortHandshake(websocket, socket, message);
            return;
          }
          let extensions;
          try {
            extensions = parse4(secWebSocketExtensions);
          } catch (err) {
            const message = "Invalid Sec-WebSocket-Extensions header";
            abortHandshake(websocket, socket, message);
            return;
          }
          const extensionNames = Object.keys(extensions);
          if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
            const message = "Server indicated an extension that was not requested";
            abortHandshake(websocket, socket, message);
            return;
          }
          try {
            perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
          } catch (err) {
            const message = "Invalid Sec-WebSocket-Extensions header";
            abortHandshake(websocket, socket, message);
            return;
          }
          websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
        }
        websocket.setSocket(socket, head, {
          allowSynchronousEvents: opts.allowSynchronousEvents,
          generateMask: opts.generateMask,
          maxPayload: opts.maxPayload,
          skipUTF8Validation: opts.skipUTF8Validation
        });
      });
      if (opts.finishRequest) {
        opts.finishRequest(req, websocket);
      } else {
        req.end();
      }
    }
    function emitErrorAndClose(websocket, err) {
      websocket._readyState = WebSocket.CLOSING;
      websocket._errorEmitted = true;
      websocket.emit("error", err);
      websocket.emitClose();
    }
    function netConnect(options) {
      options.path = options.socketPath;
      return net.connect(options);
    }
    function tlsConnect(options) {
      options.path = void 0;
      if (!options.servername && options.servername !== "") {
        options.servername = net.isIP(options.host) ? "" : options.host;
      }
      return tls.connect(options);
    }
    function abortHandshake(websocket, stream4, message) {
      websocket._readyState = WebSocket.CLOSING;
      const err = new Error(message);
      Error.captureStackTrace(err, abortHandshake);
      if (stream4.setHeader) {
        stream4[kAborted] = true;
        stream4.abort();
        if (stream4.socket && !stream4.socket.destroyed) {
          stream4.socket.destroy();
        }
        process.nextTick(emitErrorAndClose, websocket, err);
      } else {
        stream4.destroy(err);
        stream4.once("error", websocket.emit.bind(websocket, "error"));
        stream4.once("close", websocket.emitClose.bind(websocket));
      }
    }
    function sendAfterClose(websocket, data, cb) {
      if (data) {
        const length = isBlob2(data) ? data.size : toBuffer(data).length;
        if (websocket._socket) websocket._sender._bufferedBytes += length;
        else websocket._bufferedAmount += length;
      }
      if (cb) {
        const err = new Error(
          `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
        );
        process.nextTick(cb, err);
      }
    }
    function receiverOnConclude(code, reason) {
      const websocket = this[kWebSocket];
      websocket._closeFrameReceived = true;
      websocket._closeMessage = reason;
      websocket._closeCode = code;
      if (websocket._socket[kWebSocket] === void 0) return;
      websocket._socket.removeListener("data", socketOnData);
      process.nextTick(resume, websocket._socket);
      if (code === 1005) websocket.close();
      else websocket.close(code, reason);
    }
    function receiverOnDrain() {
      const websocket = this[kWebSocket];
      if (!websocket.isPaused) websocket._socket.resume();
    }
    function receiverOnError(err) {
      const websocket = this[kWebSocket];
      if (websocket._socket[kWebSocket] !== void 0) {
        websocket._socket.removeListener("data", socketOnData);
        process.nextTick(resume, websocket._socket);
        websocket.close(err[kStatusCode]);
      }
      if (!websocket._errorEmitted) {
        websocket._errorEmitted = true;
        websocket.emit("error", err);
      }
    }
    function receiverOnFinish() {
      this[kWebSocket].emitClose();
    }
    function receiverOnMessage(data, isBinary) {
      this[kWebSocket].emit("message", data, isBinary);
    }
    function receiverOnPing(data) {
      const websocket = this[kWebSocket];
      if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
      websocket.emit("ping", data);
    }
    function receiverOnPong(data) {
      this[kWebSocket].emit("pong", data);
    }
    function resume(stream4) {
      stream4.resume();
    }
    function senderOnError(err) {
      const websocket = this[kWebSocket];
      if (websocket.readyState === WebSocket.CLOSED) return;
      if (websocket.readyState === WebSocket.OPEN) {
        websocket._readyState = WebSocket.CLOSING;
        setCloseTimer(websocket);
      }
      this._socket.end();
      if (!websocket._errorEmitted) {
        websocket._errorEmitted = true;
        websocket.emit("error", err);
      }
    }
    function setCloseTimer(websocket) {
      websocket._closeTimer = setTimeout(
        websocket._socket.destroy.bind(websocket._socket),
        closeTimeout
      );
    }
    function socketOnClose() {
      const websocket = this[kWebSocket];
      this.removeListener("close", socketOnClose);
      this.removeListener("data", socketOnData);
      this.removeListener("end", socketOnEnd);
      websocket._readyState = WebSocket.CLOSING;
      let chunk;
      if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
        websocket._receiver.write(chunk);
      }
      websocket._receiver.end();
      this[kWebSocket] = void 0;
      clearTimeout(websocket._closeTimer);
      if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
        websocket.emitClose();
      } else {
        websocket._receiver.on("error", receiverOnFinish);
        websocket._receiver.on("finish", receiverOnFinish);
      }
    }
    function socketOnData(chunk) {
      if (!this[kWebSocket]._receiver.write(chunk)) {
        this.pause();
      }
    }
    function socketOnEnd() {
      const websocket = this[kWebSocket];
      websocket._readyState = WebSocket.CLOSING;
      websocket._receiver.end();
      this.end();
    }
    function socketOnError() {
      const websocket = this[kWebSocket];
      this.removeListener("error", socketOnError);
      this.on("error", NOOP);
      if (websocket) {
        websocket._readyState = WebSocket.CLOSING;
        this.destroy();
      }
    }
  }
});

// node_modules/ws/lib/stream.js
var require_stream = __commonJS({
  "node_modules/ws/lib/stream.js"(exports2, module2) {
    "use strict";
    var WebSocket = require_websocket2();
    var { Duplex } = require("stream");
    function emitClose(stream4) {
      stream4.emit("close");
    }
    function duplexOnEnd() {
      if (!this.destroyed && this._writableState.finished) {
        this.destroy();
      }
    }
    function duplexOnError(err) {
      this.removeListener("error", duplexOnError);
      this.destroy();
      if (this.listenerCount("error") === 0) {
        this.emit("error", err);
      }
    }
    function createWebSocketStream(ws, options) {
      let terminateOnDestroy = true;
      const duplex = new Duplex({
        ...options,
        autoDestroy: false,
        emitClose: false,
        objectMode: false,
        writableObjectMode: false
      });
      ws.on("message", function message(msg, isBinary) {
        const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
        if (!duplex.push(data)) ws.pause();
      });
      ws.once("error", function error73(err) {
        if (duplex.destroyed) return;
        terminateOnDestroy = false;
        duplex.destroy(err);
      });
      ws.once("close", function close() {
        if (duplex.destroyed) return;
        duplex.push(null);
      });
      duplex._destroy = function(err, callback) {
        if (ws.readyState === ws.CLOSED) {
          callback(err);
          process.nextTick(emitClose, duplex);
          return;
        }
        let called = false;
        ws.once("error", function error73(err2) {
          called = true;
          callback(err2);
        });
        ws.once("close", function close() {
          if (!called) callback(err);
          process.nextTick(emitClose, duplex);
        });
        if (terminateOnDestroy) ws.terminate();
      };
      duplex._final = function(callback) {
        if (ws.readyState === ws.CONNECTING) {
          ws.once("open", function open() {
            duplex._final(callback);
          });
          return;
        }
        if (ws._socket === null) return;
        if (ws._socket._writableState.finished) {
          callback();
          if (duplex._readableState.endEmitted) duplex.destroy();
        } else {
          ws._socket.once("finish", function finish() {
            callback();
          });
          ws.close();
        }
      };
      duplex._read = function() {
        if (ws.isPaused) ws.resume();
      };
      duplex._write = function(chunk, encoding, callback) {
        if (ws.readyState === ws.CONNECTING) {
          ws.once("open", function open() {
            duplex._write(chunk, encoding, callback);
          });
          return;
        }
        ws.send(chunk, callback);
      };
      duplex.on("end", duplexOnEnd);
      duplex.on("error", duplexOnError);
      return duplex;
    }
    module2.exports = createWebSocketStream;
  }
});

// node_modules/ws/lib/subprotocol.js
var require_subprotocol = __commonJS({
  "node_modules/ws/lib/subprotocol.js"(exports2, module2) {
    "use strict";
    var { tokenChars } = require_validation();
    function parse4(header) {
      const protocols = /* @__PURE__ */ new Set();
      let start = -1;
      let end = -1;
      let i = 0;
      for (i; i < header.length; i++) {
        const code = header.charCodeAt(i);
        if (end === -1 && tokenChars[code] === 1) {
          if (start === -1) start = i;
        } else if (i !== 0 && (code === 32 || code === 9)) {
          if (end === -1 && start !== -1) end = i;
        } else if (code === 44) {
          if (start === -1) {
            throw new SyntaxError(`Unexpected character at index ${i}`);
          }
          if (end === -1) end = i;
          const protocol2 = header.slice(start, end);
          if (protocols.has(protocol2)) {
            throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
          }
          protocols.add(protocol2);
          start = end = -1;
        } else {
          throw new SyntaxError(`Unexpected character at index ${i}`);
        }
      }
      if (start === -1 || end !== -1) {
        throw new SyntaxError("Unexpected end of input");
      }
      const protocol = header.slice(start, i);
      if (protocols.has(protocol)) {
        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
      }
      protocols.add(protocol);
      return protocols;
    }
    module2.exports = { parse: parse4 };
  }
});

// node_modules/ws/lib/websocket-server.js
var require_websocket_server = __commonJS({
  "node_modules/ws/lib/websocket-server.js"(exports2, module2) {
    "use strict";
    var EventEmitter3 = require("events");
    var http4 = require("http");
    var { Duplex } = require("stream");
    var { createHash } = require("crypto");
    var extension = require_extension();
    var PerMessageDeflate = require_permessage_deflate();
    var subprotocol = require_subprotocol();
    var WebSocket = require_websocket2();
    var { GUID, kWebSocket } = require_constants();
    var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
    var RUNNING = 0;
    var CLOSING = 1;
    var CLOSED = 2;
    var WebSocketServer = class extends EventEmitter3 {
      /**
       * Create a `WebSocketServer` instance.
       *
       * @param {Object} options Configuration options
       * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
       *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
       *     multiple times in the same tick
       * @param {Boolean} [options.autoPong=true] Specifies whether or not to
       *     automatically send a pong in response to a ping
       * @param {Number} [options.backlog=511] The maximum length of the queue of
       *     pending connections
       * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
       *     track clients
       * @param {Function} [options.handleProtocols] A hook to handle protocols
       * @param {String} [options.host] The hostname where to bind the server
       * @param {Number} [options.maxPayload=104857600] The maximum allowed message
       *     size
       * @param {Boolean} [options.noServer=false] Enable no server mode
       * @param {String} [options.path] Accept only connections matching this path
       * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
       *     permessage-deflate
       * @param {Number} [options.port] The port where to bind the server
       * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
       *     server to use
       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
       *     not to skip UTF-8 validation for text and close messages
       * @param {Function} [options.verifyClient] A hook to reject connections
       * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
       *     class to use. It must be the `WebSocket` class or class that extends it
       * @param {Function} [callback] A listener for the `listening` event
       */
      constructor(options, callback) {
        super();
        options = {
          allowSynchronousEvents: true,
          autoPong: true,
          maxPayload: 100 * 1024 * 1024,
          skipUTF8Validation: false,
          perMessageDeflate: false,
          handleProtocols: null,
          clientTracking: true,
          verifyClient: null,
          noServer: false,
          backlog: null,
          // use default (511 as implemented in net.js)
          server: null,
          host: null,
          path: null,
          port: null,
          WebSocket,
          ...options
        };
        if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
          throw new TypeError(
            'One and only one of the "port", "server", or "noServer" options must be specified'
          );
        }
        if (options.port != null) {
          this._server = http4.createServer((req, res) => {
            const body = http4.STATUS_CODES[426];
            res.writeHead(426, {
              "Content-Length": body.length,
              "Content-Type": "text/plain"
            });
            res.end(body);
          });
          this._server.listen(
            options.port,
            options.host,
            options.backlog,
            callback
          );
        } else if (options.server) {
          this._server = options.server;
        }
        if (this._server) {
          const emitConnection = this.emit.bind(this, "connection");
          this._removeListeners = addListeners(this._server, {
            listening: this.emit.bind(this, "listening"),
            error: this.emit.bind(this, "error"),
            upgrade: (req, socket, head) => {
              this.handleUpgrade(req, socket, head, emitConnection);
            }
          });
        }
        if (options.perMessageDeflate === true) options.perMessageDeflate = {};
        if (options.clientTracking) {
          this.clients = /* @__PURE__ */ new Set();
          this._shouldEmitClose = false;
        }
        this.options = options;
        this._state = RUNNING;
      }
      /**
       * Returns the bound address, the address family name, and port of the server
       * as reported by the operating system if listening on an IP socket.
       * If the server is listening on a pipe or UNIX domain socket, the name is
       * returned as a string.
       *
       * @return {(Object|String|null)} The address of the server
       * @public
       */
      address() {
        if (this.options.noServer) {
          throw new Error('The server is operating in "noServer" mode');
        }
        if (!this._server) return null;
        return this._server.address();
      }
      /**
       * Stop the server from accepting new connections and emit the `'close'` event
       * when all existing connections are closed.
       *
       * @param {Function} [cb] A one-time listener for the `'close'` event
       * @public
       */
      close(cb) {
        if (this._state === CLOSED) {
          if (cb) {
            this.once("close", () => {
              cb(new Error("The server is not running"));
            });
          }
          process.nextTick(emitClose, this);
          return;
        }
        if (cb) this.once("close", cb);
        if (this._state === CLOSING) return;
        this._state = CLOSING;
        if (this.options.noServer || this.options.server) {
          if (this._server) {
            this._removeListeners();
            this._removeListeners = this._server = null;
          }
          if (this.clients) {
            if (!this.clients.size) {
              process.nextTick(emitClose, this);
            } else {
              this._shouldEmitClose = true;
            }
          } else {
            process.nextTick(emitClose, this);
          }
        } else {
          const server2 = this._server;
          this._removeListeners();
          this._removeListeners = this._server = null;
          server2.close(() => {
            emitClose(this);
          });
        }
      }
      /**
       * See if a given request should be handled by this server instance.
       *
       * @param {http.IncomingMessage} req Request object to inspect
       * @return {Boolean} `true` if the request is valid, else `false`
       * @public
       */
      shouldHandle(req) {
        if (this.options.path) {
          const index = req.url.indexOf("?");
          const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
          if (pathname !== this.options.path) return false;
        }
        return true;
      }
      /**
       * Handle a HTTP Upgrade request.
       *
       * @param {http.IncomingMessage} req The request object
       * @param {Duplex} socket The network socket between the server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Function} cb Callback
       * @public
       */
      handleUpgrade(req, socket, head, cb) {
        socket.on("error", socketOnError);
        const key = req.headers["sec-websocket-key"];
        const upgrade = req.headers.upgrade;
        const version3 = +req.headers["sec-websocket-version"];
        if (req.method !== "GET") {
          const message = "Invalid HTTP method";
          abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
          return;
        }
        if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
          const message = "Invalid Upgrade header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (key === void 0 || !keyRegex.test(key)) {
          const message = "Missing or invalid Sec-WebSocket-Key header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (version3 !== 13 && version3 !== 8) {
          const message = "Missing or invalid Sec-WebSocket-Version header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
            "Sec-WebSocket-Version": "13, 8"
          });
          return;
        }
        if (!this.shouldHandle(req)) {
          abortHandshake(socket, 400);
          return;
        }
        const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
        let protocols = /* @__PURE__ */ new Set();
        if (secWebSocketProtocol !== void 0) {
          try {
            protocols = subprotocol.parse(secWebSocketProtocol);
          } catch (err) {
            const message = "Invalid Sec-WebSocket-Protocol header";
            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
            return;
          }
        }
        const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
        const extensions = {};
        if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
          const perMessageDeflate = new PerMessageDeflate(
            this.options.perMessageDeflate,
            true,
            this.options.maxPayload
          );
          try {
            const offers = extension.parse(secWebSocketExtensions);
            if (offers[PerMessageDeflate.extensionName]) {
              perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
              extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
            }
          } catch (err) {
            const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
            return;
          }
        }
        if (this.options.verifyClient) {
          const info = {
            origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
            secure: !!(req.socket.authorized || req.socket.encrypted),
            req
          };
          if (this.options.verifyClient.length === 2) {
            this.options.verifyClient(info, (verified, code, message, headers) => {
              if (!verified) {
                return abortHandshake(socket, code || 401, message, headers);
              }
              this.completeUpgrade(
                extensions,
                key,
                protocols,
                req,
                socket,
                head,
                cb
              );
            });
            return;
          }
          if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
        }
        this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
      }
      /**
       * Upgrade the connection to WebSocket.
       *
       * @param {Object} extensions The accepted extensions
       * @param {String} key The value of the `Sec-WebSocket-Key` header
       * @param {Set} protocols The subprotocols
       * @param {http.IncomingMessage} req The request object
       * @param {Duplex} socket The network socket between the server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Function} cb Callback
       * @throws {Error} If called more than once with the same socket
       * @private
       */
      completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
        if (!socket.readable || !socket.writable) return socket.destroy();
        if (socket[kWebSocket]) {
          throw new Error(
            "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
          );
        }
        if (this._state > RUNNING) return abortHandshake(socket, 503);
        const digest = createHash("sha1").update(key + GUID).digest("base64");
        const headers = [
          "HTTP/1.1 101 Switching Protocols",
          "Upgrade: websocket",
          "Connection: Upgrade",
          `Sec-WebSocket-Accept: ${digest}`
        ];
        const ws = new this.options.WebSocket(null, void 0, this.options);
        if (protocols.size) {
          const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
          if (protocol) {
            headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
            ws._protocol = protocol;
          }
        }
        if (extensions[PerMessageDeflate.extensionName]) {
          const params = extensions[PerMessageDeflate.extensionName].params;
          const value = extension.format({
            [PerMessageDeflate.extensionName]: [params]
          });
          headers.push(`Sec-WebSocket-Extensions: ${value}`);
          ws._extensions = extensions;
        }
        this.emit("headers", headers, req);
        socket.write(headers.concat("\r\n").join("\r\n"));
        socket.removeListener("error", socketOnError);
        ws.setSocket(socket, head, {
          allowSynchronousEvents: this.options.allowSynchronousEvents,
          maxPayload: this.options.maxPayload,
          skipUTF8Validation: this.options.skipUTF8Validation
        });
        if (this.clients) {
          this.clients.add(ws);
          ws.on("close", () => {
            this.clients.delete(ws);
            if (this._shouldEmitClose && !this.clients.size) {
              process.nextTick(emitClose, this);
            }
          });
        }
        cb(ws, req);
      }
    };
    module2.exports = WebSocketServer;
    function addListeners(server2, map3) {
      for (const event of Object.keys(map3)) server2.on(event, map3[event]);
      return function removeListeners() {
        for (const event of Object.keys(map3)) {
          server2.removeListener(event, map3[event]);
        }
      };
    }
    function emitClose(server2) {
      server2._state = CLOSED;
      server2.emit("close");
    }
    function socketOnError() {
      this.destroy();
    }
    function abortHandshake(socket, code, message, headers) {
      message = message || http4.STATUS_CODES[code];
      headers = {
        Connection: "close",
        "Content-Type": "text/html",
        "Content-Length": Buffer.byteLength(message),
        ...headers
      };
      socket.once("finish", socket.destroy);
      socket.end(
        `HTTP/1.1 ${code} ${http4.STATUS_CODES[code]}\r
` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
      );
    }
    function abortHandshakeOrEmitwsClientError(server2, req, socket, code, message, headers) {
      if (server2.listenerCount("wsClientError")) {
        const err = new Error(message);
        Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
        server2.emit("wsClientError", err, socket, req);
      } else {
        abortHandshake(socket, code, message, headers);
      }
    }
  }
});

// node_modules/ws/index.js
var require_ws = __commonJS({
  "node_modules/ws/index.js"(exports2, module2) {
    "use strict";
    var WebSocket = require_websocket2();
    WebSocket.createWebSocketStream = require_stream();
    WebSocket.Server = require_websocket_server();
    WebSocket.Receiver = require_receiver();
    WebSocket.Sender = require_sender();
    WebSocket.WebSocket = WebSocket;
    WebSocket.WebSocketServer = WebSocket.Server;
    module2.exports = WebSocket;
  }
});

// node_modules/object-assign/index.js
var require_object_assign = __commonJS({
  "node_modules/object-assign/index.js"(exports2, module2) {
    "use strict";
    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
    var hasOwnProperty11 = Object.prototype.hasOwnProperty;
    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
    function toObject(val) {
      if (val === null || val === void 0) {
        throw new TypeError("Object.assign cannot be called with null or undefined");
      }
      return Object(val);
    }
    function shouldUseNative() {
      try {
        if (!Object.assign) {
          return false;
        }
        var test1 = new String("abc");
        test1[5] = "de";
        if (Object.getOwnPropertyNames(test1)[0] === "5") {
          return false;
        }
        var test2 = {};
        for (var i = 0; i < 10; i++) {
          test2["_" + String.fromCharCode(i)] = i;
        }
        var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
          return test2[n];
        });
        if (order2.join("") !== "0123456789") {
          return false;
        }
        var test3 = {};
        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
          test3[letter] = letter;
        });
        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
          return false;
        }
        return true;
      } catch (err) {
        return false;
      }
    }
    module2.exports = shouldUseNative() ? Object.assign : function(target, source) {
      var from;
      var to = toObject(target);
      var symbols;
      for (var s = 1; s < arguments.length; s++) {
        from = Object(arguments[s]);
        for (var key in from) {
          if (hasOwnProperty11.call(from, key)) {
            to[key] = from[key];
          }
        }
        if (getOwnPropertySymbols) {
          symbols = getOwnPropertySymbols(from);
          for (var i = 0; i < symbols.length; i++) {
            if (propIsEnumerable.call(from, symbols[i])) {
              to[symbols[i]] = from[symbols[i]];
            }
          }
        }
      }
      return to;
    };
  }
});

// node_modules/cors/lib/index.js
var require_lib3 = __commonJS({
  "node_modules/cors/lib/index.js"(exports2, module2) {
    "use strict";
    (function() {
      "use strict";
      var assign = require_object_assign();
      var vary = require_vary();
      var defaults2 = {
        origin: "*",
        methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
        preflightContinue: false,
        optionsSuccessStatus: 204
      };
      function isString2(s) {
        return typeof s === "string" || s instanceof String;
      }
      function isOriginAllowed(origin2, allowedOrigin) {
        if (Array.isArray(allowedOrigin)) {
          for (var i = 0; i < allowedOrigin.length; ++i) {
            if (isOriginAllowed(origin2, allowedOrigin[i])) {
              return true;
            }
          }
          return false;
        } else if (isString2(allowedOrigin)) {
          return origin2 === allowedOrigin;
        } else if (allowedOrigin instanceof RegExp) {
          return allowedOrigin.test(origin2);
        } else {
          return !!allowedOrigin;
        }
      }
      function configureOrigin(options, req) {
        var requestOrigin = req.headers.origin, headers = [], isAllowed;
        if (!options.origin || options.origin === "*") {
          headers.push([{
            key: "Access-Control-Allow-Origin",
            value: "*"
          }]);
        } else if (isString2(options.origin)) {
          headers.push([{
            key: "Access-Control-Allow-Origin",
            value: options.origin
          }]);
          headers.push([{
            key: "Vary",
            value: "Origin"
          }]);
        } else {
          isAllowed = isOriginAllowed(requestOrigin, options.origin);
          headers.push([{
            key: "Access-Control-Allow-Origin",
            value: isAllowed ? requestOrigin : false
          }]);
          headers.push([{
            key: "Vary",
            value: "Origin"
          }]);
        }
        return headers;
      }
      function configureMethods(options) {
        var methods = options.methods;
        if (methods.join) {
          methods = options.methods.join(",");
        }
        return {
          key: "Access-Control-Allow-Methods",
          value: methods
        };
      }
      function configureCredentials(options) {
        if (options.credentials === true) {
          return {
            key: "Access-Control-Allow-Credentials",
            value: "true"
          };
        }
        return null;
      }
      function configureAllowedHeaders(options, req) {
        var allowedHeaders = options.allowedHeaders || options.headers;
        var headers = [];
        if (!allowedHeaders) {
          allowedHeaders = req.headers["access-control-request-headers"];
          headers.push([{
            key: "Vary",
            value: "Access-Control-Request-Headers"
          }]);
        } else if (allowedHeaders.join) {
          allowedHeaders = allowedHeaders.join(",");
        }
        if (allowedHeaders && allowedHeaders.length) {
          headers.push([{
            key: "Access-Control-Allow-Headers",
            value: allowedHeaders
          }]);
        }
        return headers;
      }
      function configureExposedHeaders(options) {
        var headers = options.exposedHeaders;
        if (!headers) {
          return null;
        } else if (headers.join) {
          headers = headers.join(",");
        }
        if (headers && headers.length) {
          return {
            key: "Access-Control-Expose-Headers",
            value: headers
          };
        }
        return null;
      }
      function configureMaxAge(options) {
        var maxAge = (typeof options.maxAge === "number" || options.maxAge) && options.maxAge.toString();
        if (maxAge && maxAge.length) {
          return {
            key: "Access-Control-Max-Age",
            value: maxAge
          };
        }
        return null;
      }
      function applyHeaders(headers, res) {
        for (var i = 0, n = headers.length; i < n; i++) {
          var header = headers[i];
          if (header) {
            if (Array.isArray(header)) {
              applyHeaders(header, res);
            } else if (header.key === "Vary" && header.value) {
              vary(res, header.value);
            } else if (header.value) {
              res.setHeader(header.key, header.value);
            }
          }
        }
      }
      function cors2(options, req, res, next) {
        var headers = [], method = req.method && req.method.toUpperCase && req.method.toUpperCase();
        if (method === "OPTIONS") {
          headers.push(configureOrigin(options, req));
          headers.push(configureCredentials(options));
          headers.push(configureMethods(options));
          headers.push(configureAllowedHeaders(options, req));
          headers.push(configureMaxAge(options));
          headers.push(configureExposedHeaders(options));
          applyHeaders(headers, res);
          if (options.preflightContinue) {
            next();
          } else {
            res.statusCode = options.optionsSuccessStatus;
            res.setHeader("Content-Length", "0");
            res.end();
          }
        } else {
          headers.push(configureOrigin(options, req));
          headers.push(configureCredentials(options));
          headers.push(configureExposedHeaders(options));
          applyHeaders(headers, res);
          next();
        }
      }
      function middlewareWrapper(o) {
        var optionsCallback = null;
        if (typeof o === "function") {
          optionsCallback = o;
        } else {
          optionsCallback = function(req, cb) {
            cb(null, o);
          };
        }
        return function corsMiddleware(req, res, next) {
          optionsCallback(req, function(err, options) {
            if (err) {
              next(err);
            } else {
              var corsOptions = assign({}, defaults2, options);
              var originCallback = null;
              if (corsOptions.origin && typeof corsOptions.origin === "function") {
                originCallback = corsOptions.origin;
              } else if (corsOptions.origin) {
                originCallback = function(origin2, cb) {
                  cb(null, corsOptions.origin);
                };
              }
              if (originCallback) {
                originCallback(req.headers.origin, function(err2, origin2) {
                  if (err2 || !origin2) {
                    next(err2);
                  } else {
                    corsOptions.origin = origin2;
                    cors2(corsOptions, req, res, next);
                  }
                });
              } else {
                next();
              }
            }
          });
        };
      }
      module2.exports = middlewareWrapper;
    })();
  }
});

// node_modules/engine.io/build/server.js
var require_server = __commonJS({
  "node_modules/engine.io/build/server.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Server = exports2.BaseServer = void 0;
    var base64id = require_base64id();
    var transports_1 = require_transports();
    var events_1 = require("events");
    var socket_1 = require_socket();
    var debug_1 = require_src();
    var cookie_1 = require_cookie();
    var ws_1 = require_ws();
    var webtransport_1 = require_webtransport();
    var engine_io_parser_1 = require_cjs();
    var debug = (0, debug_1.default)("engine");
    var kResponseHeaders = /* @__PURE__ */ Symbol("responseHeaders");
    function parseSessionId(data) {
      try {
        const parsed = JSON.parse(data);
        if (typeof parsed.sid === "string") {
          return parsed.sid;
        }
      } catch (e) {
      }
    }
    var BaseServer = class extends events_1.EventEmitter {
      /**
       * Server constructor.
       *
       * @param {Object} opts - options
       */
      constructor(opts = {}) {
        super();
        this.middlewares = [];
        this.clients = {};
        this.clientsCount = 0;
        this.opts = Object.assign({
          wsEngine: ws_1.Server,
          pingTimeout: 2e4,
          pingInterval: 25e3,
          upgradeTimeout: 1e4,
          maxHttpBufferSize: 1e6,
          transports: ["polling", "websocket"],
          // WebTransport is disabled by default
          allowUpgrades: true,
          httpCompression: {
            threshold: 1024
          },
          cors: false,
          allowEIO3: false
        }, opts);
        if (opts.cookie) {
          this.opts.cookie = Object.assign({
            name: "io",
            path: "/",
            // @ts-ignore
            httpOnly: opts.cookie.path !== false,
            sameSite: "lax"
          }, opts.cookie);
        }
        if (this.opts.cors) {
          this.use(require_lib3()(this.opts.cors));
        }
        if (opts.perMessageDeflate) {
          this.opts.perMessageDeflate = Object.assign({
            threshold: 1024
          }, opts.perMessageDeflate);
        }
        this.init();
      }
      /**
       * Compute the pathname of the requests that are handled by the server
       * @param options
       * @protected
       */
      _computePath(options) {
        let path33 = (options.path || "/engine.io").replace(/\/$/, "");
        if (options.addTrailingSlash !== false) {
          path33 += "/";
        }
        return path33;
      }
      /**
       * Returns a list of available transports for upgrade given a certain transport.
       */
      upgrades(transport) {
        if (!this.opts.allowUpgrades)
          return [];
        return transports_1.default[transport].upgradesTo || [];
      }
      /**
       * Verifies a request.
       *
       * @param {EngineRequest} req
       * @param upgrade - whether it's an upgrade request
       * @param fn
       * @protected
       * @return whether the request is valid
       */
      verify(req, upgrade, fn) {
        const transport = req._query.transport;
        if (!~this.opts.transports.indexOf(transport) || transport === "webtransport") {
          debug('unknown transport "%s"', transport);
          return fn(Server2.errors.UNKNOWN_TRANSPORT, { transport });
        }
        const isOriginInvalid = checkInvalidHeaderChar(req.headers.origin);
        if (isOriginInvalid) {
          const origin2 = req.headers.origin;
          req.headers.origin = null;
          debug("origin header invalid");
          return fn(Server2.errors.BAD_REQUEST, {
            name: "INVALID_ORIGIN",
            origin: origin2
          });
        }
        const sid = req._query.sid;
        if (sid) {
          if (!this.clients.hasOwnProperty(sid)) {
            debug('unknown sid "%s"', sid);
            return fn(Server2.errors.UNKNOWN_SID, {
              sid
            });
          }
          const previousTransport = this.clients[sid].transport.name;
          if (!upgrade && previousTransport !== transport) {
            debug("bad request: unexpected transport without upgrade");
            return fn(Server2.errors.BAD_REQUEST, {
              name: "TRANSPORT_MISMATCH",
              transport,
              previousTransport
            });
          }
        } else {
          if ("GET" !== req.method) {
            return fn(Server2.errors.BAD_HANDSHAKE_METHOD, {
              method: req.method
            });
          }
          if (transport === "websocket" && !upgrade) {
            debug("invalid transport upgrade");
            return fn(Server2.errors.BAD_REQUEST, {
              name: "TRANSPORT_HANDSHAKE_ERROR"
            });
          }
          if (!this.opts.allowRequest)
            return fn();
          return this.opts.allowRequest(req, (message, success5) => {
            if (!success5) {
              return fn(Server2.errors.FORBIDDEN, {
                message
              });
            }
            fn();
          });
        }
        fn();
      }
      /**
       * Adds a new middleware.
       *
       * @example
       * import helmet from "helmet";
       *
       * engine.use(helmet());
       *
       * @param fn
       */
      use(fn) {
        this.middlewares.push(fn);
      }
      /**
       * Apply the middlewares to the request.
       *
       * @param req
       * @param res
       * @param callback
       * @protected
       */
      _applyMiddlewares(req, res, callback) {
        if (this.middlewares.length === 0) {
          debug("no middleware to apply, skipping");
          return callback();
        }
        const apply = (i) => {
          debug("applying middleware n\xB0%d", i + 1);
          this.middlewares[i](req, res, (err) => {
            if (err) {
              return callback(err);
            }
            if (i + 1 < this.middlewares.length) {
              apply(i + 1);
            } else {
              callback();
            }
          });
        };
        apply(0);
      }
      /**
       * Closes all clients.
       */
      close() {
        debug("closing all open clients");
        for (let i in this.clients) {
          if (this.clients.hasOwnProperty(i)) {
            this.clients[i].close(true);
          }
        }
        this.cleanup();
        return this;
      }
      /**
       * generate a socket id.
       * Overwrite this method to generate your custom socket id
       *
       * @param {IncomingMessage} req - the request object
       */
      generateId(req) {
        return base64id.generateId();
      }
      /**
       * Handshakes a new client.
       *
       * @param {String} transportName
       * @param {Object} req - the request object
       * @param {Function} closeConnection
       *
       * @protected
       */
      async handshake(transportName, req, closeConnection) {
        const protocol = req._query.EIO === "4" ? 4 : 3;
        if (protocol === 3 && !this.opts.allowEIO3) {
          debug("unsupported protocol version");
          this.emit("connection_error", {
            req,
            code: Server2.errors.UNSUPPORTED_PROTOCOL_VERSION,
            message: Server2.errorMessages[Server2.errors.UNSUPPORTED_PROTOCOL_VERSION],
            context: {
              protocol
            }
          });
          closeConnection(Server2.errors.UNSUPPORTED_PROTOCOL_VERSION);
          return;
        }
        let id;
        try {
          id = await this.generateId(req);
        } catch (e) {
          debug("error while generating an id");
          this.emit("connection_error", {
            req,
            code: Server2.errors.BAD_REQUEST,
            message: Server2.errorMessages[Server2.errors.BAD_REQUEST],
            context: {
              name: "ID_GENERATION_ERROR",
              error: e
            }
          });
          closeConnection(Server2.errors.BAD_REQUEST);
          return;
        }
        debug('handshaking client "%s"', id);
        try {
          var transport = this.createTransport(transportName, req);
          if ("polling" === transportName) {
            transport.maxHttpBufferSize = this.opts.maxHttpBufferSize;
            transport.httpCompression = this.opts.httpCompression;
          } else if ("websocket" === transportName) {
            transport.perMessageDeflate = this.opts.perMessageDeflate;
          }
        } catch (e) {
          debug('error handshaking to transport "%s"', transportName);
          this.emit("connection_error", {
            req,
            code: Server2.errors.BAD_REQUEST,
            message: Server2.errorMessages[Server2.errors.BAD_REQUEST],
            context: {
              name: "TRANSPORT_HANDSHAKE_ERROR",
              error: e
            }
          });
          closeConnection(Server2.errors.BAD_REQUEST);
          return;
        }
        const socket = new socket_1.Socket(id, this, transport, req, protocol);
        transport.on("headers", (headers, req2) => {
          const isInitialRequest = !req2._query.sid;
          if (isInitialRequest) {
            if (this.opts.cookie) {
              headers["Set-Cookie"] = [
                // @ts-ignore
                (0, cookie_1.serialize)(this.opts.cookie.name, id, this.opts.cookie)
              ];
            }
            this.emit("initial_headers", headers, req2);
          }
          this.emit("headers", headers, req2);
        });
        transport.onRequest(req);
        this.clients[id] = socket;
        this.clientsCount++;
        socket.once("close", () => {
          delete this.clients[id];
          this.clientsCount--;
        });
        this.emit("connection", socket);
        return transport;
      }
      async onWebTransportSession(session) {
        const timeout = setTimeout(() => {
          debug("the client failed to establish a bidirectional stream in the given period");
          session.close();
        }, this.opts.upgradeTimeout);
        const streamReader = session.incomingBidirectionalStreams.getReader();
        const result = await streamReader.read();
        if (result.done) {
          debug("session is closed");
          return;
        }
        const stream4 = result.value;
        const transformStream = (0, engine_io_parser_1.createPacketDecoderStream)(this.opts.maxHttpBufferSize, "nodebuffer");
        const reader = stream4.readable.pipeThrough(transformStream).getReader();
        const { value, done } = await reader.read();
        if (done) {
          debug("stream is closed");
          return;
        }
        clearTimeout(timeout);
        if (value.type !== "open") {
          debug("invalid WebTransport handshake");
          return session.close();
        }
        if (value.data === void 0) {
          const transport = new webtransport_1.WebTransport(session, stream4, reader);
          const id = base64id.generateId();
          debug('handshaking client "%s" (WebTransport)', id);
          const socket = new socket_1.Socket(id, this, transport, null, 4);
          this.clients[id] = socket;
          this.clientsCount++;
          socket.once("close", () => {
            delete this.clients[id];
            this.clientsCount--;
          });
          this.emit("connection", socket);
          return;
        }
        const sid = parseSessionId(value.data);
        if (!sid) {
          debug("invalid WebTransport handshake");
          return session.close();
        }
        const client = this.clients[sid];
        if (!client) {
          debug("upgrade attempt for closed client");
          session.close();
        } else if (client.upgrading) {
          debug("transport has already been trying to upgrade");
          session.close();
        } else if (client.upgraded) {
          debug("transport had already been upgraded");
          session.close();
        } else {
          debug("upgrading existing transport");
          const transport = new webtransport_1.WebTransport(session, stream4, reader);
          client._maybeUpgrade(transport);
        }
      }
    };
    exports2.BaseServer = BaseServer;
    BaseServer.errors = {
      UNKNOWN_TRANSPORT: 0,
      UNKNOWN_SID: 1,
      BAD_HANDSHAKE_METHOD: 2,
      BAD_REQUEST: 3,
      FORBIDDEN: 4,
      UNSUPPORTED_PROTOCOL_VERSION: 5
    };
    BaseServer.errorMessages = {
      0: "Transport unknown",
      1: "Session ID unknown",
      2: "Bad handshake method",
      3: "Bad request",
      4: "Forbidden",
      5: "Unsupported protocol version"
    };
    var WebSocketResponse = class {
      constructor(req, socket) {
        this.req = req;
        this.socket = socket;
        req[kResponseHeaders] = {};
      }
      setHeader(name28, value) {
        this.req[kResponseHeaders][name28] = value;
      }
      getHeader(name28) {
        return this.req[kResponseHeaders][name28];
      }
      removeHeader(name28) {
        delete this.req[kResponseHeaders][name28];
      }
      write() {
      }
      writeHead() {
      }
      end() {
        this.socket.destroy();
      }
    };
    var Server2 = class _Server extends BaseServer {
      /**
       * Initialize websocket server
       *
       * @protected
       */
      init() {
        if (!~this.opts.transports.indexOf("websocket"))
          return;
        if (this.ws)
          this.ws.close();
        this.ws = new this.opts.wsEngine({
          noServer: true,
          clientTracking: false,
          perMessageDeflate: this.opts.perMessageDeflate,
          maxPayload: this.opts.maxHttpBufferSize
        });
        if (typeof this.ws.on === "function") {
          this.ws.on("headers", (headersArray, req) => {
            const additionalHeaders = req[kResponseHeaders] || {};
            delete req[kResponseHeaders];
            const isInitialRequest = !req._query.sid;
            if (isInitialRequest) {
              this.emit("initial_headers", additionalHeaders, req);
            }
            this.emit("headers", additionalHeaders, req);
            debug("writing headers: %j", additionalHeaders);
            Object.keys(additionalHeaders).forEach((key) => {
              headersArray.push(`${key}: ${additionalHeaders[key]}`);
            });
          });
        }
      }
      cleanup() {
        if (this.ws) {
          debug("closing webSocketServer");
          this.ws.close();
        }
      }
      /**
       * Prepares a request by processing the query string.
       *
       * @private
       */
      prepare(req) {
        if (!req._query) {
          const url4 = new URL(req.url, "https://socket.io");
          req._query = Object.fromEntries(url4.searchParams.entries());
        }
      }
      createTransport(transportName, req) {
        return new transports_1.default[transportName](req);
      }
      /**
       * Handles an Engine.IO HTTP request.
       *
       * @param {EngineRequest} req
       * @param {ServerResponse} res
       */
      handleRequest(req, res) {
        debug('handling "%s" http request "%s"', req.method, req.url);
        this.prepare(req);
        req.res = res;
        const callback = (errorCode, errorContext) => {
          if (errorCode !== void 0) {
            this.emit("connection_error", {
              req,
              code: errorCode,
              message: _Server.errorMessages[errorCode],
              context: errorContext
            });
            abortRequest(res, errorCode, errorContext);
            return;
          }
          if (req._query.sid) {
            debug("setting new request for existing client");
            this.clients[req._query.sid].transport.onRequest(req);
          } else {
            const closeConnection = (errorCode2, errorContext2) => abortRequest(res, errorCode2, errorContext2);
            this.handshake(req._query.transport, req, closeConnection);
          }
        };
        this._applyMiddlewares(req, res, (err) => {
          if (err) {
            callback(_Server.errors.BAD_REQUEST, { name: "MIDDLEWARE_FAILURE" });
          } else {
            this.verify(req, false, callback);
          }
        });
      }
      /**
       * Handles an Engine.IO HTTP Upgrade.
       */
      handleUpgrade(req, socket, upgradeHead) {
        this.prepare(req);
        const res = new WebSocketResponse(req, socket);
        const callback = (errorCode, errorContext) => {
          if (errorCode !== void 0) {
            this.emit("connection_error", {
              req,
              code: errorCode,
              message: _Server.errorMessages[errorCode],
              context: errorContext
            });
            abortUpgrade(socket, errorCode, errorContext);
            return;
          }
          const head = Buffer.from(upgradeHead);
          upgradeHead = null;
          res.writeHead();
          this.ws.handleUpgrade(req, socket, head, (websocket) => {
            this.onWebSocket(req, socket, websocket);
          });
        };
        this._applyMiddlewares(req, res, (err) => {
          if (err) {
            callback(_Server.errors.BAD_REQUEST, { name: "MIDDLEWARE_FAILURE" });
          } else {
            this.verify(req, true, callback);
          }
        });
      }
      /**
       * Called upon a ws.io connection.
       * @param req
       * @param socket
       * @param websocket
       * @private
       */
      onWebSocket(req, socket, websocket) {
        websocket.on("error", onUpgradeError);
        if (transports_1.default[req._query.transport] !== void 0 && !transports_1.default[req._query.transport].prototype.handlesUpgrades) {
          debug("transport doesnt handle upgraded requests");
          websocket.close();
          return;
        }
        const id = req._query.sid;
        req.websocket = websocket;
        if (id) {
          const client = this.clients[id];
          if (!client) {
            debug("upgrade attempt for closed client");
            websocket.close();
          } else if (client.upgrading) {
            debug("transport has already been trying to upgrade");
            websocket.close();
          } else if (client.upgraded) {
            debug("transport had already been upgraded");
            websocket.close();
          } else {
            debug("upgrading existing transport");
            websocket.removeListener("error", onUpgradeError);
            const transport = this.createTransport(req._query.transport, req);
            transport.perMessageDeflate = this.opts.perMessageDeflate;
            client._maybeUpgrade(transport);
          }
        } else {
          const closeConnection = (errorCode, errorContext) => abortUpgrade(socket, errorCode, errorContext);
          this.handshake(req._query.transport, req, closeConnection);
        }
        function onUpgradeError() {
          debug("websocket error before upgrade");
        }
      }
      /**
       * Captures upgrade requests for a http.Server.
       *
       * @param {http.Server} server
       * @param {Object} options
       */
      attach(server2, options = {}) {
        const path33 = this._computePath(options);
        const destroyUpgradeTimeout = options.destroyUpgradeTimeout || 1e3;
        function check3(req) {
          return path33 === req.url.slice(0, path33.length);
        }
        const listeners = server2.listeners("request").slice(0);
        server2.removeAllListeners("request");
        server2.on("close", this.close.bind(this));
        server2.on("listening", this.init.bind(this));
        server2.on("request", (req, res) => {
          if (check3(req)) {
            debug('intercepting request for path "%s"', path33);
            this.handleRequest(req, res);
          } else {
            let i = 0;
            const l = listeners.length;
            for (; i < l; i++) {
              listeners[i].call(server2, req, res);
            }
          }
        });
        if (~this.opts.transports.indexOf("websocket")) {
          server2.on("upgrade", (req, socket, head) => {
            if (check3(req)) {
              this.handleUpgrade(req, socket, head);
            } else if (false !== options.destroyUpgrade) {
              setTimeout(function() {
                if (socket.writable && socket.bytesWritten <= 0) {
                  socket.on("error", (e) => {
                    debug("error while destroying upgrade: %s", e.message);
                  });
                  return socket.end();
                }
              }, destroyUpgradeTimeout);
            }
          });
        }
      }
    };
    exports2.Server = Server2;
    function abortRequest(res, errorCode, errorContext) {
      const statusCode = errorCode === Server2.errors.FORBIDDEN ? 403 : 400;
      const message = errorContext && errorContext.message ? errorContext.message : Server2.errorMessages[errorCode];
      res.writeHead(statusCode, { "Content-Type": "application/json" });
      res.end(JSON.stringify({
        code: errorCode,
        message
      }));
    }
    function abortUpgrade(socket, errorCode, errorContext = {}) {
      socket.on("error", () => {
        debug("ignoring error from closed connection");
      });
      if (socket.writable) {
        const message = errorContext.message || Server2.errorMessages[errorCode];
        const length = Buffer.byteLength(message);
        socket.write("HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-type: text/html\r\nContent-Length: " + length + "\r\n\r\n" + message);
      }
      socket.destroy();
    }
    var validHdrChars = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      // 0 - 15
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      // 16 - 31
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 32 - 47
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 48 - 63
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 64 - 79
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 80 - 95
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 96 - 111
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      // 112 - 127
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 128 ...
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1
      // ... 255
    ];
    function checkInvalidHeaderChar(val) {
      val += "";
      if (val.length < 1)
        return false;
      if (!validHdrChars[val.charCodeAt(0)]) {
        debug('invalid header, index 0, char "%s"', val.charCodeAt(0));
        return true;
      }
      if (val.length < 2)
        return false;
      if (!validHdrChars[val.charCodeAt(1)]) {
        debug('invalid header, index 1, char "%s"', val.charCodeAt(1));
        return true;
      }
      if (val.length < 3)
        return false;
      if (!validHdrChars[val.charCodeAt(2)]) {
        debug('invalid header, index 2, char "%s"', val.charCodeAt(2));
        return true;
      }
      if (val.length < 4)
        return false;
      if (!validHdrChars[val.charCodeAt(3)]) {
        debug('invalid header, index 3, char "%s"', val.charCodeAt(3));
        return true;
      }
      for (let i = 4; i < val.length; ++i) {
        if (!validHdrChars[val.charCodeAt(i)]) {
          debug('invalid header, index "%i", char "%s"', i, val.charCodeAt(i));
          return true;
        }
      }
      return false;
    }
  }
});

// node_modules/engine.io/build/transports-uws/polling.js
var require_polling2 = __commonJS({
  "node_modules/engine.io/build/transports-uws/polling.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Polling = void 0;
    var transport_1 = require_transport();
    var zlib_1 = require("zlib");
    var accepts = require_accepts2();
    var debug_1 = require_src();
    var debug = (0, debug_1.default)("engine:polling");
    var compressionMethods = {
      gzip: zlib_1.createGzip,
      deflate: zlib_1.createDeflate
    };
    var Polling = class extends transport_1.Transport {
      /**
       * HTTP polling constructor.
       */
      constructor(req) {
        super(req);
        this.closeTimeout = 30 * 1e3;
      }
      /**
       * Transport name
       */
      get name() {
        return "polling";
      }
      /**
       * Overrides onRequest.
       *
       * @param req
       *
       * @private
       */
      onRequest(req) {
        const res = req.res;
        req.res = null;
        if (req.getMethod() === "get") {
          this.onPollRequest(req, res);
        } else if (req.getMethod() === "post") {
          this.onDataRequest(req, res);
        } else {
          res.writeStatus("500 Internal Server Error");
          res.end();
        }
      }
      /**
       * The client sends a request awaiting for us to send data.
       *
       * @private
       */
      onPollRequest(req, res) {
        if (this.req) {
          debug("request overlap");
          this.onError("overlap from client");
          res.writeStatus("500 Internal Server Error");
          res.end();
          return;
        }
        debug("setting request");
        this.req = req;
        this.res = res;
        const onClose = () => {
          this.writable = false;
          this.onError("poll connection closed prematurely");
        };
        const cleanup = () => {
          this.req = this.res = null;
        };
        req.cleanup = cleanup;
        res.onAborted(onClose);
        this.writable = true;
        this.emit("ready");
        if (this.writable && this.shouldClose) {
          debug("triggering empty send to append close packet");
          this.send([{ type: "noop" }]);
        }
      }
      /**
       * The client sends a request with data.
       *
       * @private
       */
      onDataRequest(req, res) {
        if (this.dataReq) {
          this.onError("data request overlap from client");
          res.writeStatus("500 Internal Server Error");
          res.end();
          return;
        }
        const expectedContentLength = Number(req.headers["content-length"]);
        if (!expectedContentLength) {
          this.onError("content-length header required");
          res.writeStatus("411 Length Required").end();
          return;
        }
        if (expectedContentLength > this.maxHttpBufferSize) {
          this.onError("payload too large");
          res.writeStatus("413 Payload Too Large").end();
          return;
        }
        const isBinary = "application/octet-stream" === req.headers["content-type"];
        if (isBinary && this.protocol === 4) {
          return this.onError("invalid content");
        }
        this.dataReq = req;
        this.dataRes = res;
        let buffer;
        let offset = 0;
        const headers = {
          // text/html is required instead of text/plain to avoid an
          // unwanted download dialog on certain user-agents (GH-43)
          "Content-Type": "text/html"
        };
        this.headers(req, headers);
        for (let key in headers) {
          res.writeHeader(key, String(headers[key]));
        }
        const onEnd = (buffer2) => {
          this.onData(buffer2.toString());
          this.onDataRequestCleanup();
          res.cork(() => {
            res.end("ok");
          });
        };
        res.onAborted(() => {
          this.onDataRequestCleanup();
          this.onError("data request connection closed prematurely");
        });
        res.onData((arrayBuffer, isLast) => {
          const totalLength = offset + arrayBuffer.byteLength;
          if (totalLength > expectedContentLength) {
            this.onError("content-length mismatch");
            res.close();
            return;
          }
          if (!buffer) {
            if (isLast) {
              onEnd(Buffer.from(arrayBuffer));
              return;
            }
            buffer = Buffer.allocUnsafe(expectedContentLength);
          }
          Buffer.from(arrayBuffer).copy(buffer, offset);
          if (isLast) {
            if (totalLength != expectedContentLength) {
              this.onError("content-length mismatch");
              res.writeStatus("400 Content-Length Mismatch").end();
              this.onDataRequestCleanup();
              return;
            }
            onEnd(buffer);
            return;
          }
          offset = totalLength;
        });
      }
      /**
       * Cleanup request.
       *
       * @private
       */
      onDataRequestCleanup() {
        this.dataReq = this.dataRes = null;
      }
      /**
       * Processes the incoming data payload.
       *
       * @param {String} encoded payload
       * @private
       */
      onData(data) {
        debug('received "%s"', data);
        const callback = (packet) => {
          if ("close" === packet.type) {
            debug("got xhr close packet");
            this.onClose();
            return false;
          }
          this.onPacket(packet);
        };
        if (this.protocol === 3) {
          this.parser.decodePayload(data, callback);
        } else {
          this.parser.decodePayload(data).forEach(callback);
        }
      }
      /**
       * Overrides onClose.
       *
       * @private
       */
      onClose() {
        if (this.writable) {
          this.send([{ type: "noop" }]);
        }
        super.onClose();
      }
      /**
       * Writes a packet payload.
       *
       * @param {Object} packet
       * @private
       */
      send(packets) {
        this.writable = false;
        if (this.shouldClose) {
          debug("appending close packet to payload");
          packets.push({ type: "close" });
          this.shouldClose();
          this.shouldClose = null;
        }
        const doWrite = (data) => {
          const compress = packets.some((packet) => {
            return packet.options && packet.options.compress;
          });
          this.write(data, { compress });
        };
        if (this.protocol === 3) {
          this.parser.encodePayload(packets, this.supportsBinary, doWrite);
        } else {
          this.parser.encodePayload(packets, doWrite);
        }
      }
      /**
       * Writes data as response to poll request.
       *
       * @param {String} data
       * @param {Object} options
       * @private
       */
      write(data, options) {
        debug('writing "%s"', data);
        this.doWrite(data, options, () => {
          this.req.cleanup();
          this.emit("drain");
        });
      }
      /**
       * Performs the write.
       *
       * @private
       */
      doWrite(data, options, callback) {
        const isString2 = typeof data === "string";
        const contentType = isString2 ? "text/plain; charset=UTF-8" : "application/octet-stream";
        const headers = {
          "Content-Type": contentType
        };
        const respond = (data2) => {
          this.headers(this.req, headers);
          this.res.cork(() => {
            Object.keys(headers).forEach((key) => {
              this.res.writeHeader(key, String(headers[key]));
            });
            this.res.end(data2);
          });
          callback();
        };
        if (!this.httpCompression || !options.compress) {
          respond(data);
          return;
        }
        const len = isString2 ? Buffer.byteLength(data) : data.length;
        if (len < this.httpCompression.threshold) {
          respond(data);
          return;
        }
        const encoding = accepts(this.req).encodings(["gzip", "deflate"]);
        if (!encoding) {
          respond(data);
          return;
        }
        this.compress(data, encoding, (err, data2) => {
          if (err) {
            this.res.writeStatus("500 Internal Server Error");
            this.res.end();
            callback(err);
            return;
          }
          headers["Content-Encoding"] = encoding;
          respond(data2);
        });
      }
      /**
       * Compresses data.
       *
       * @private
       */
      compress(data, encoding, callback) {
        debug("compressing");
        const buffers = [];
        let nread = 0;
        compressionMethods[encoding](this.httpCompression).on("error", callback).on("data", function(chunk) {
          buffers.push(chunk);
          nread += chunk.length;
        }).on("end", function() {
          callback(null, Buffer.concat(buffers, nread));
        }).end(data);
      }
      /**
       * Closes the transport.
       *
       * @private
       */
      doClose(fn) {
        debug("closing");
        let closeTimeoutTimer;
        const onClose = () => {
          clearTimeout(closeTimeoutTimer);
          fn();
          this.onClose();
        };
        if (this.writable) {
          debug("transport writable - closing right away");
          this.send([{ type: "close" }]);
          onClose();
        } else if (this.discarded) {
          debug("transport discarded - closing right away");
          onClose();
        } else {
          debug("transport not writable - buffering orderly close");
          this.shouldClose = onClose;
          closeTimeoutTimer = setTimeout(onClose, this.closeTimeout);
        }
      }
      /**
       * Returns headers for a response.
       *
       * @param req - request
       * @param {Object} extra headers
       * @private
       */
      headers(req, headers) {
        headers = headers || {};
        const ua = req.headers["user-agent"];
        if (ua && (~ua.indexOf(";MSIE") || ~ua.indexOf("Trident/"))) {
          headers["X-XSS-Protection"] = "0";
        }
        headers["cache-control"] = "no-store";
        this.emit("headers", headers, req);
        return headers;
      }
    };
    exports2.Polling = Polling;
  }
});

// node_modules/engine.io/build/transports-uws/websocket.js
var require_websocket3 = __commonJS({
  "node_modules/engine.io/build/transports-uws/websocket.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.WebSocket = void 0;
    var transport_1 = require_transport();
    var debug_1 = require_src();
    var debug = (0, debug_1.default)("engine:ws");
    var WebSocket = class extends transport_1.Transport {
      /**
       * WebSocket transport
       *
       * @param req
       */
      constructor(req) {
        super(req);
        this.writable = false;
        this.perMessageDeflate = null;
      }
      /**
       * Transport name
       */
      get name() {
        return "websocket";
      }
      /**
       * Advertise upgrade support.
       */
      get handlesUpgrades() {
        return true;
      }
      /**
       * Writes a packet payload.
       *
       * @param {Array} packets
       * @private
       */
      send(packets) {
        this.writable = false;
        for (let i = 0; i < packets.length; i++) {
          const packet = packets[i];
          const isLast = i + 1 === packets.length;
          const send = (data) => {
            const isBinary = typeof data !== "string";
            const compress = this.perMessageDeflate && Buffer.byteLength(data) > this.perMessageDeflate.threshold;
            debug('writing "%s"', data);
            this.socket.send(data, isBinary, compress);
            if (isLast) {
              this.emit("drain");
              this.writable = true;
              this.emit("ready");
            }
          };
          if (packet.options && typeof packet.options.wsPreEncoded === "string") {
            send(packet.options.wsPreEncoded);
          } else {
            this.parser.encodePacket(packet, this.supportsBinary, send);
          }
        }
      }
      /**
       * Closes the transport.
       *
       * @private
       */
      doClose(fn) {
        debug("closing");
        fn && fn();
        this.socket.end();
      }
    };
    exports2.WebSocket = WebSocket;
  }
});

// node_modules/engine.io/build/transports-uws/index.js
var require_transports_uws = __commonJS({
  "node_modules/engine.io/build/transports-uws/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var polling_1 = require_polling2();
    var websocket_1 = require_websocket3();
    exports2.default = {
      polling: polling_1.Polling,
      websocket: websocket_1.WebSocket
    };
  }
});

// node_modules/engine.io/build/userver.js
var require_userver = __commonJS({
  "node_modules/engine.io/build/userver.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.uServer = void 0;
    var debug_1 = require_src();
    var server_1 = require_server();
    var transports_uws_1 = require_transports_uws();
    var debug = (0, debug_1.default)("engine:uws");
    var uServer = class extends server_1.BaseServer {
      init() {
      }
      cleanup() {
      }
      /**
       * Prepares a request by processing the query string.
       *
       * @private
       */
      prepare(req, res) {
        req.method = req.getMethod().toUpperCase();
        req.url = req.getUrl();
        const params = new URLSearchParams(req.getQuery());
        req._query = Object.fromEntries(params.entries());
        req.headers = {};
        req.forEach((key, value) => {
          req.headers[key] = value;
        });
        req.connection = {
          remoteAddress: Buffer.from(res.getRemoteAddressAsText()).toString()
        };
        res.onAborted(() => {
          debug("response has been aborted");
        });
      }
      createTransport(transportName, req) {
        return new transports_uws_1.default[transportName](req);
      }
      /**
       * Attach the engine to a µWebSockets.js server
       * @param app
       * @param options
       */
      attach(app2, options = {}) {
        const path33 = this._computePath(options);
        app2.any(path33, this.handleRequest.bind(this)).ws(path33, {
          compression: options.compression,
          idleTimeout: options.idleTimeout,
          maxBackpressure: options.maxBackpressure,
          maxPayloadLength: this.opts.maxHttpBufferSize,
          upgrade: this.handleUpgrade.bind(this),
          open: (ws) => {
            const transport = ws.getUserData().transport;
            transport.socket = ws;
            transport.writable = true;
            transport.emit("ready");
          },
          message: (ws, message, isBinary) => {
            ws.getUserData().transport.onData(isBinary ? message : Buffer.from(message).toString());
          },
          close: (ws, code, message) => {
            ws.getUserData().transport.onClose(code, message);
          }
        });
      }
      _applyMiddlewares(req, res, callback) {
        if (this.middlewares.length === 0) {
          return callback();
        }
        req.res = new ResponseWrapper(res);
        super._applyMiddlewares(req, req.res, (err) => {
          req.res.writeHead();
          callback(err);
        });
      }
      handleRequest(res, req) {
        debug('handling "%s" http request "%s"', req.getMethod(), req.getUrl());
        this.prepare(req, res);
        req.res = res;
        const callback = (errorCode, errorContext) => {
          if (errorCode !== void 0) {
            this.emit("connection_error", {
              req,
              code: errorCode,
              message: server_1.Server.errorMessages[errorCode],
              context: errorContext
            });
            this.abortRequest(req.res, errorCode, errorContext);
            return;
          }
          if (req._query.sid) {
            debug("setting new request for existing client");
            this.clients[req._query.sid].transport.onRequest(req);
          } else {
            const closeConnection = (errorCode2, errorContext2) => this.abortRequest(res, errorCode2, errorContext2);
            this.handshake(req._query.transport, req, closeConnection);
          }
        };
        this._applyMiddlewares(req, res, (err) => {
          if (err) {
            callback(server_1.Server.errors.BAD_REQUEST, { name: "MIDDLEWARE_FAILURE" });
          } else {
            this.verify(req, false, callback);
          }
        });
      }
      handleUpgrade(res, req, context2) {
        debug("on upgrade");
        this.prepare(req, res);
        req.res = res;
        const callback = async (errorCode, errorContext) => {
          if (errorCode !== void 0) {
            this.emit("connection_error", {
              req,
              code: errorCode,
              message: server_1.Server.errorMessages[errorCode],
              context: errorContext
            });
            this.abortRequest(res, errorCode, errorContext);
            return;
          }
          const id = req._query.sid;
          let transport;
          if (id) {
            const client = this.clients[id];
            if (!client) {
              debug("upgrade attempt for closed client");
              return res.close();
            } else if (client.upgrading) {
              debug("transport has already been trying to upgrade");
              return res.close();
            } else if (client.upgraded) {
              debug("transport had already been upgraded");
              return res.close();
            } else {
              debug("upgrading existing transport");
              transport = this.createTransport(req._query.transport, req);
              client._maybeUpgrade(transport);
            }
          } else {
            transport = await this.handshake(req._query.transport, req, (errorCode2, errorContext2) => this.abortRequest(res, errorCode2, errorContext2));
            if (!transport) {
              return;
            }
          }
          const additionalHeaders = {};
          const isInitialRequest = !id;
          if (isInitialRequest) {
            this.emit("initial_headers", additionalHeaders, req);
          }
          this.emit("headers", additionalHeaders, req);
          req.res.writeStatus("101 Switching Protocols");
          Object.keys(additionalHeaders).forEach((key) => {
            req.res.writeHeader(key, additionalHeaders[key]);
          });
          res.upgrade({
            transport
          }, req.getHeader("sec-websocket-key"), req.getHeader("sec-websocket-protocol"), req.getHeader("sec-websocket-extensions"), context2);
        };
        this._applyMiddlewares(req, res, (err) => {
          if (err) {
            callback(server_1.Server.errors.BAD_REQUEST, { name: "MIDDLEWARE_FAILURE" });
          } else {
            this.verify(req, true, callback);
          }
        });
      }
      abortRequest(res, errorCode, errorContext) {
        const statusCode = errorCode === server_1.Server.errors.FORBIDDEN ? "403 Forbidden" : "400 Bad Request";
        const message = errorContext && errorContext.message ? errorContext.message : server_1.Server.errorMessages[errorCode];
        res.writeStatus(statusCode);
        res.writeHeader("Content-Type", "application/json");
        res.end(JSON.stringify({
          code: errorCode,
          message
        }));
      }
    };
    exports2.uServer = uServer;
    var ResponseWrapper = class {
      constructor(res) {
        this.res = res;
        this.statusWritten = false;
        this.headers = [];
        this.isAborted = false;
      }
      set statusCode(status) {
        if (!status) {
          return;
        }
        this.writeStatus(status === 200 ? "200 OK" : "204 No Content");
      }
      writeHead(status) {
        this.statusCode = status;
      }
      setHeader(key, value) {
        if (Array.isArray(value)) {
          value.forEach((val) => {
            this.writeHeader(key, val);
          });
        } else {
          this.writeHeader(key, value);
        }
      }
      removeHeader() {
      }
      // needed by vary: https://github.com/jshttp/vary/blob/5d725d059b3871025cf753e9dfa08924d0bcfa8f/index.js#L134
      getHeader() {
      }
      writeStatus(status) {
        if (this.isAborted)
          return;
        this.res.writeStatus(status);
        this.statusWritten = true;
        this.writeBufferedHeaders();
        return this;
      }
      writeHeader(key, value) {
        if (this.isAborted)
          return;
        if (key === "Content-Length") {
          return;
        }
        if (this.statusWritten) {
          this.res.writeHeader(key, value);
        } else {
          this.headers.push([key, value]);
        }
      }
      writeBufferedHeaders() {
        this.headers.forEach(([key, value]) => {
          this.res.writeHeader(key, value);
        });
      }
      end(data) {
        if (this.isAborted)
          return;
        this.res.cork(() => {
          if (!this.statusWritten) {
            this.writeBufferedHeaders();
          }
          this.res.end(data);
        });
      }
      onData(fn) {
        if (this.isAborted)
          return;
        this.res.onData(fn);
      }
      onAborted(fn) {
        if (this.isAborted)
          return;
        this.res.onAborted(() => {
          this.isAborted = true;
          fn();
        });
      }
      cork(fn) {
        if (this.isAborted)
          return;
        this.res.cork(fn);
      }
    };
  }
});

// node_modules/engine.io/build/engine.io.js
var require_engine_io = __commonJS({
  "node_modules/engine.io/build/engine.io.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.protocol = exports2.Transport = exports2.Socket = exports2.uServer = exports2.parser = exports2.transports = exports2.Server = void 0;
    exports2.listen = listen;
    exports2.attach = attach;
    var http_1 = require("http");
    var server_1 = require_server();
    Object.defineProperty(exports2, "Server", { enumerable: true, get: function() {
      return server_1.Server;
    } });
    var index_1 = require_transports();
    exports2.transports = index_1.default;
    var parser = require_cjs();
    exports2.parser = parser;
    var userver_1 = require_userver();
    Object.defineProperty(exports2, "uServer", { enumerable: true, get: function() {
      return userver_1.uServer;
    } });
    var socket_1 = require_socket();
    Object.defineProperty(exports2, "Socket", { enumerable: true, get: function() {
      return socket_1.Socket;
    } });
    var transport_1 = require_transport();
    Object.defineProperty(exports2, "Transport", { enumerable: true, get: function() {
      return transport_1.Transport;
    } });
    exports2.protocol = parser.protocol;
    function listen(port, options, listenCallback) {
      if ("function" === typeof options) {
        listenCallback = options;
        options = {};
      }
      const server2 = (0, http_1.createServer)(function(req, res) {
        res.writeHead(501);
        res.end("Not Implemented");
      });
      const engine = attach(server2, options);
      engine.httpServer = server2;
      server2.listen(port, listenCallback);
      return engine;
    }
    function attach(server2, options) {
      const engine = new server_1.Server(options);
      engine.attach(server2, options);
      return engine;
    }
  }
});

// node_modules/@socket.io/component-emitter/lib/cjs/index.js
var require_cjs2 = __commonJS({
  "node_modules/@socket.io/component-emitter/lib/cjs/index.js"(exports2) {
    "use strict";
    exports2.Emitter = Emitter;
    function Emitter(obj) {
      if (obj) return mixin(obj);
    }
    function mixin(obj) {
      for (var key in Emitter.prototype) {
        obj[key] = Emitter.prototype[key];
      }
      return obj;
    }
    Emitter.prototype.on = Emitter.prototype.addEventListener = function(event, fn) {
      this._callbacks = this._callbacks || {};
      (this._callbacks["$" + event] = this._callbacks["$" + event] || []).push(fn);
      return this;
    };
    Emitter.prototype.once = function(event, fn) {
      function on() {
        this.off(event, on);
        fn.apply(this, arguments);
      }
      on.fn = fn;
      this.on(event, on);
      return this;
    };
    Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function(event, fn) {
      this._callbacks = this._callbacks || {};
      if (0 == arguments.length) {
        this._callbacks = {};
        return this;
      }
      var callbacks = this._callbacks["$" + event];
      if (!callbacks) return this;
      if (1 == arguments.length) {
        delete this._callbacks["$" + event];
        return this;
      }
      var cb;
      for (var i = 0; i < callbacks.length; i++) {
        cb = callbacks[i];
        if (cb === fn || cb.fn === fn) {
          callbacks.splice(i, 1);
          break;
        }
      }
      if (callbacks.length === 0) {
        delete this._callbacks["$" + event];
      }
      return this;
    };
    Emitter.prototype.emit = function(event) {
      this._callbacks = this._callbacks || {};
      var args = new Array(arguments.length - 1), callbacks = this._callbacks["$" + event];
      for (var i = 1; i < arguments.length; i++) {
        args[i - 1] = arguments[i];
      }
      if (callbacks) {
        callbacks = callbacks.slice(0);
        for (var i = 0, len = callbacks.length; i < len; ++i) {
          callbacks[i].apply(this, args);
        }
      }
      return this;
    };
    Emitter.prototype.emitReserved = Emitter.prototype.emit;
    Emitter.prototype.listeners = function(event) {
      this._callbacks = this._callbacks || {};
      return this._callbacks["$" + event] || [];
    };
    Emitter.prototype.hasListeners = function(event) {
      return !!this.listeners(event).length;
    };
  }
});

// node_modules/socket.io-parser/build/cjs/is-binary.js
var require_is_binary = __commonJS({
  "node_modules/socket.io-parser/build/cjs/is-binary.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isBinary = isBinary;
    exports2.hasBinary = hasBinary;
    var withNativeArrayBuffer = typeof ArrayBuffer === "function";
    var isView = (obj) => {
      return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer;
    };
    var toString4 = Object.prototype.toString;
    var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && toString4.call(Blob) === "[object BlobConstructor]";
    var withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString4.call(File) === "[object FileConstructor]";
    function isBinary(obj) {
      return withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj)) || withNativeBlob && obj instanceof Blob || withNativeFile && obj instanceof File;
    }
    function hasBinary(obj, toJSON2) {
      if (!obj || typeof obj !== "object") {
        return false;
      }
      if (Array.isArray(obj)) {
        for (let i = 0, l = obj.length; i < l; i++) {
          if (hasBinary(obj[i])) {
            return true;
          }
        }
        return false;
      }
      if (isBinary(obj)) {
        return true;
      }
      if (obj.toJSON && typeof obj.toJSON === "function" && arguments.length === 1) {
        return hasBinary(obj.toJSON(), true);
      }
      for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
          return true;
        }
      }
      return false;
    }
  }
});

// node_modules/socket.io-parser/build/cjs/binary.js
var require_binary = __commonJS({
  "node_modules/socket.io-parser/build/cjs/binary.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.deconstructPacket = deconstructPacket;
    exports2.reconstructPacket = reconstructPacket;
    var is_binary_js_1 = require_is_binary();
    function deconstructPacket(packet) {
      const buffers = [];
      const packetData = packet.data;
      const pack = packet;
      pack.data = _deconstructPacket(packetData, buffers);
      pack.attachments = buffers.length;
      return { packet: pack, buffers };
    }
    function _deconstructPacket(data, buffers) {
      if (!data)
        return data;
      if ((0, is_binary_js_1.isBinary)(data)) {
        const placeholder = { _placeholder: true, num: buffers.length };
        buffers.push(data);
        return placeholder;
      } else if (Array.isArray(data)) {
        const newData = new Array(data.length);
        for (let i = 0; i < data.length; i++) {
          newData[i] = _deconstructPacket(data[i], buffers);
        }
        return newData;
      } else if (typeof data === "object" && !(data instanceof Date)) {
        const newData = {};
        for (const key in data) {
          if (Object.prototype.hasOwnProperty.call(data, key)) {
            newData[key] = _deconstructPacket(data[key], buffers);
          }
        }
        return newData;
      }
      return data;
    }
    function reconstructPacket(packet, buffers) {
      packet.data = _reconstructPacket(packet.data, buffers);
      delete packet.attachments;
      return packet;
    }
    function _reconstructPacket(data, buffers) {
      if (!data)
        return data;
      if (data && data._placeholder === true) {
        const isIndexValid = typeof data.num === "number" && data.num >= 0 && data.num < buffers.length;
        if (isIndexValid) {
          return buffers[data.num];
        } else {
          throw new Error("illegal attachments");
        }
      } else if (Array.isArray(data)) {
        for (let i = 0; i < data.length; i++) {
          data[i] = _reconstructPacket(data[i], buffers);
        }
      } else if (typeof data === "object") {
        for (const key in data) {
          if (Object.prototype.hasOwnProperty.call(data, key)) {
            data[key] = _reconstructPacket(data[key], buffers);
          }
        }
      }
      return data;
    }
  }
});

// node_modules/socket.io-parser/build/cjs/index.js
var require_cjs3 = __commonJS({
  "node_modules/socket.io-parser/build/cjs/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Decoder = exports2.Encoder = exports2.PacketType = exports2.protocol = void 0;
    exports2.isPacketValid = isPacketValid;
    var component_emitter_1 = require_cjs2();
    var binary_js_1 = require_binary();
    var is_binary_js_1 = require_is_binary();
    var debug_1 = require_src();
    var debug = (0, debug_1.default)("socket.io-parser");
    var RESERVED_EVENTS = [
      "connect",
      // used on the client side
      "connect_error",
      // used on the client side
      "disconnect",
      // used on both sides
      "disconnecting",
      // used on the server side
      "newListener",
      // used by the Node.js EventEmitter
      "removeListener"
      // used by the Node.js EventEmitter
    ];
    exports2.protocol = 5;
    var PacketType;
    (function(PacketType2) {
      PacketType2[PacketType2["CONNECT"] = 0] = "CONNECT";
      PacketType2[PacketType2["DISCONNECT"] = 1] = "DISCONNECT";
      PacketType2[PacketType2["EVENT"] = 2] = "EVENT";
      PacketType2[PacketType2["ACK"] = 3] = "ACK";
      PacketType2[PacketType2["CONNECT_ERROR"] = 4] = "CONNECT_ERROR";
      PacketType2[PacketType2["BINARY_EVENT"] = 5] = "BINARY_EVENT";
      PacketType2[PacketType2["BINARY_ACK"] = 6] = "BINARY_ACK";
    })(PacketType || (exports2.PacketType = PacketType = {}));
    var Encoder = class {
      /**
       * Encoder constructor
       *
       * @param {function} replacer - custom replacer to pass down to JSON.parse
       */
      constructor(replacer) {
        this.replacer = replacer;
      }
      /**
       * Encode a packet as a single string if non-binary, or as a
       * buffer sequence, depending on packet type.
       *
       * @param {Object} obj - packet object
       */
      encode(obj) {
        debug("encoding packet %j", obj);
        if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
          if ((0, is_binary_js_1.hasBinary)(obj)) {
            return this.encodeAsBinary({
              type: obj.type === PacketType.EVENT ? PacketType.BINARY_EVENT : PacketType.BINARY_ACK,
              nsp: obj.nsp,
              data: obj.data,
              id: obj.id
            });
          }
        }
        return [this.encodeAsString(obj)];
      }
      /**
       * Encode packet as string.
       */
      encodeAsString(obj) {
        let str = "" + obj.type;
        if (obj.type === PacketType.BINARY_EVENT || obj.type === PacketType.BINARY_ACK) {
          str += obj.attachments + "-";
        }
        if (obj.nsp && "/" !== obj.nsp) {
          str += obj.nsp + ",";
        }
        if (null != obj.id) {
          str += obj.id;
        }
        if (null != obj.data) {
          str += JSON.stringify(obj.data, this.replacer);
        }
        debug("encoded %j as %s", obj, str);
        return str;
      }
      /**
       * Encode packet as 'buffer sequence' by removing blobs, and
       * deconstructing packet into object with placeholders and
       * a list of buffers.
       */
      encodeAsBinary(obj) {
        const deconstruction = (0, binary_js_1.deconstructPacket)(obj);
        const pack = this.encodeAsString(deconstruction.packet);
        const buffers = deconstruction.buffers;
        buffers.unshift(pack);
        return buffers;
      }
    };
    exports2.Encoder = Encoder;
    var Decoder = class _Decoder extends component_emitter_1.Emitter {
      /**
       * Decoder constructor
       */
      constructor(opts) {
        super();
        this.opts = Object.assign({
          reviver: void 0,
          maxAttachments: 10
        }, typeof opts === "function" ? { reviver: opts } : opts);
      }
      /**
       * Decodes an encoded packet string into packet JSON.
       *
       * @param {String} obj - encoded packet
       */
      add(obj) {
        let packet;
        if (typeof obj === "string") {
          if (this.reconstructor) {
            throw new Error("got plaintext data when reconstructing a packet");
          }
          packet = this.decodeString(obj);
          const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
          if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
            packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
            this.reconstructor = new BinaryReconstructor(packet);
            if (packet.attachments === 0) {
              super.emitReserved("decoded", packet);
            }
          } else {
            super.emitReserved("decoded", packet);
          }
        } else if ((0, is_binary_js_1.isBinary)(obj) || obj.base64) {
          if (!this.reconstructor) {
            throw new Error("got binary data when not reconstructing a packet");
          } else {
            packet = this.reconstructor.takeBinaryData(obj);
            if (packet) {
              this.reconstructor = null;
              super.emitReserved("decoded", packet);
            }
          }
        } else {
          throw new Error("Unknown type: " + obj);
        }
      }
      /**
       * Decode a packet String (JSON data)
       *
       * @param {String} str
       * @return {Object} packet
       */
      decodeString(str) {
        let i = 0;
        const p3 = {
          type: Number(str.charAt(0))
        };
        if (PacketType[p3.type] === void 0) {
          throw new Error("unknown packet type " + p3.type);
        }
        if (p3.type === PacketType.BINARY_EVENT || p3.type === PacketType.BINARY_ACK) {
          const start = i + 1;
          while (str.charAt(++i) !== "-" && i != str.length) {
          }
          const buf = str.substring(start, i);
          if (buf != Number(buf) || str.charAt(i) !== "-") {
            throw new Error("Illegal attachments");
          }
          const n = Number(buf);
          if (!isInteger(n) || n < 0) {
            throw new Error("Illegal attachments");
          } else if (n > this.opts.maxAttachments) {
            throw new Error("too many attachments");
          }
          p3.attachments = n;
        }
        if ("/" === str.charAt(i + 1)) {
          const start = i + 1;
          while (++i) {
            const c = str.charAt(i);
            if ("," === c)
              break;
            if (i === str.length)
              break;
          }
          p3.nsp = str.substring(start, i);
        } else {
          p3.nsp = "/";
        }
        const next = str.charAt(i + 1);
        if ("" !== next && Number(next) == next) {
          const start = i + 1;
          while (++i) {
            const c = str.charAt(i);
            if (null == c || Number(c) != c) {
              --i;
              break;
            }
            if (i === str.length)
              break;
          }
          p3.id = Number(str.substring(start, i + 1));
        }
        if (str.charAt(++i)) {
          const payload = this.tryParse(str.substr(i));
          if (_Decoder.isPayloadValid(p3.type, payload)) {
            p3.data = payload;
          } else {
            throw new Error("invalid payload");
          }
        }
        debug("decoded %s as %j", str, p3);
        return p3;
      }
      tryParse(str) {
        try {
          return JSON.parse(str, this.opts.reviver);
        } catch (e) {
          return false;
        }
      }
      static isPayloadValid(type, payload) {
        switch (type) {
          case PacketType.CONNECT:
            return isObject5(payload);
          case PacketType.DISCONNECT:
            return payload === void 0;
          case PacketType.CONNECT_ERROR:
            return typeof payload === "string" || isObject5(payload);
          case PacketType.EVENT:
          case PacketType.BINARY_EVENT:
            return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS.indexOf(payload[0]) === -1);
          case PacketType.ACK:
          case PacketType.BINARY_ACK:
            return Array.isArray(payload);
        }
      }
      /**
       * Deallocates a parser's resources
       */
      destroy() {
        if (this.reconstructor) {
          this.reconstructor.finishedReconstruction();
          this.reconstructor = null;
        }
      }
    };
    exports2.Decoder = Decoder;
    var BinaryReconstructor = class {
      constructor(packet) {
        this.packet = packet;
        this.buffers = [];
        this.reconPack = packet;
      }
      /**
       * Method to be called when binary data received from connection
       * after a BINARY_EVENT packet.
       *
       * @param {Buffer | ArrayBuffer} binData - the raw binary data received
       * @return {null | Object} returns null if more binary data is expected or
       *   a reconstructed packet object if all buffers have been received.
       */
      takeBinaryData(binData) {
        this.buffers.push(binData);
        if (this.buffers.length === this.reconPack.attachments) {
          const packet = (0, binary_js_1.reconstructPacket)(this.reconPack, this.buffers);
          this.finishedReconstruction();
          return packet;
        }
        return null;
      }
      /**
       * Cleans up binary packet reconstruction variables.
       */
      finishedReconstruction() {
        this.reconPack = null;
        this.buffers = [];
      }
    };
    function isNamespaceValid(nsp) {
      return typeof nsp === "string";
    }
    var isInteger = Number.isInteger || function(value) {
      return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
    };
    function isAckIdValid(id) {
      return id === void 0 || isInteger(id);
    }
    function isObject5(value) {
      return Object.prototype.toString.call(value) === "[object Object]";
    }
    function isDataValid(type, payload) {
      switch (type) {
        case PacketType.CONNECT:
          return payload === void 0 || isObject5(payload);
        case PacketType.DISCONNECT:
          return payload === void 0;
        case PacketType.EVENT:
          return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS.indexOf(payload[0]) === -1);
        case PacketType.ACK:
          return Array.isArray(payload);
        case PacketType.CONNECT_ERROR:
          return typeof payload === "string" || isObject5(payload);
        default:
          return false;
      }
    }
    function isPacketValid(packet) {
      return isNamespaceValid(packet.nsp) && isAckIdValid(packet.id) && isDataValid(packet.type, packet.data);
    }
  }
});

// node_modules/socket.io/dist/client.js
var require_client = __commonJS({
  "node_modules/socket.io/dist/client.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Client = void 0;
    var socket_io_parser_1 = require_cjs3();
    var debug_1 = __importDefault(require_src());
    var debug = (0, debug_1.default)("socket.io:client");
    var Client2 = class {
      /**
       * Client constructor.
       *
       * @param server instance
       * @param conn
       * @package
       */
      constructor(server2, conn) {
        this.sockets = /* @__PURE__ */ new Map();
        this.nsps = /* @__PURE__ */ new Map();
        this.server = server2;
        this.conn = conn;
        this.encoder = server2.encoder;
        this.decoder = new server2._parser.Decoder();
        this.id = conn.id;
        this.setup();
      }
      /**
       * @return the reference to the request that originated the Engine.IO connection
       *
       * @public
       */
      get request() {
        return this.conn.request;
      }
      /**
       * Sets up event listeners.
       *
       * @private
       */
      setup() {
        this.onclose = this.onclose.bind(this);
        this.ondata = this.ondata.bind(this);
        this.onerror = this.onerror.bind(this);
        this.ondecoded = this.ondecoded.bind(this);
        this.decoder.on("decoded", this.ondecoded);
        this.conn.on("data", this.ondata);
        this.conn.on("error", this.onerror);
        this.conn.on("close", this.onclose);
        this.connectTimeout = setTimeout(() => {
          if (this.nsps.size === 0) {
            debug("no namespace joined yet, close the client");
            this.close();
          } else {
            debug("the client has already joined a namespace, nothing to do");
          }
        }, this.server._connectTimeout);
      }
      /**
       * Connects a client to a namespace.
       *
       * @param {String} name - the namespace
       * @param {Object} auth - the auth parameters
       * @private
       */
      connect(name28, auth = {}) {
        if (this.server._nsps.has(name28)) {
          debug("connecting to namespace %s", name28);
          return this.doConnect(name28, auth);
        }
        this.server._checkNamespace(name28, auth, (dynamicNspName) => {
          if (dynamicNspName) {
            this.doConnect(name28, auth);
          } else {
            debug("creation of namespace %s was denied", name28);
            this._packet({
              type: socket_io_parser_1.PacketType.CONNECT_ERROR,
              nsp: name28,
              data: {
                message: "Invalid namespace"
              }
            });
          }
        });
      }
      /**
       * Connects a client to a namespace.
       *
       * @param name - the namespace
       * @param {Object} auth - the auth parameters
       *
       * @private
       */
      doConnect(name28, auth) {
        const nsp = this.server.of(name28);
        nsp._add(this, auth, (socket) => {
          this.sockets.set(socket.id, socket);
          this.nsps.set(nsp.name, socket);
          if (this.connectTimeout) {
            clearTimeout(this.connectTimeout);
            this.connectTimeout = void 0;
          }
        });
      }
      /**
       * Disconnects from all namespaces and closes transport.
       *
       * @private
       */
      _disconnect() {
        for (const socket of this.sockets.values()) {
          socket.disconnect();
        }
        this.sockets.clear();
        this.close();
      }
      /**
       * Removes a socket. Called by each `Socket`.
       *
       * @private
       */
      _remove(socket) {
        if (this.sockets.has(socket.id)) {
          const nsp = this.sockets.get(socket.id).nsp.name;
          this.sockets.delete(socket.id);
          this.nsps.delete(nsp);
        } else {
          debug("ignoring remove for %s", socket.id);
        }
      }
      /**
       * Closes the underlying connection.
       *
       * @private
       */
      close() {
        if ("open" === this.conn.readyState) {
          debug("forcing transport close");
          this.conn.close();
          this.onclose("forced server close");
        }
      }
      /**
       * Writes a packet to the transport.
       *
       * @param {Object} packet object
       * @param {Object} opts
       * @private
       */
      _packet(packet, opts = {}) {
        if (this.conn.readyState !== "open") {
          debug("ignoring packet write %j", packet);
          return;
        }
        const encodedPackets = opts.preEncoded ? packet : this.encoder.encode(packet);
        this.writeToEngine(encodedPackets, opts);
      }
      writeToEngine(encodedPackets, opts) {
        if (opts.volatile && !this.conn.transport.writable) {
          debug("volatile packet is discarded since the transport is not currently writable");
          return;
        }
        const packets = Array.isArray(encodedPackets) ? encodedPackets : [encodedPackets];
        for (const encodedPacket of packets) {
          this.conn.write(encodedPacket, opts);
        }
      }
      /**
       * Called with incoming transport data.
       *
       * @private
       */
      ondata(data) {
        try {
          this.decoder.add(data);
        } catch (e) {
          debug("invalid packet format");
          this.onerror(e);
        }
      }
      /**
       * Called when parser fully decodes a packet.
       *
       * @private
       */
      ondecoded(packet) {
        const { namespace, authPayload } = this._parseNamespace(packet);
        const socket = this.nsps.get(namespace);
        if (!socket && packet.type === socket_io_parser_1.PacketType.CONNECT) {
          this.connect(namespace, authPayload);
        } else if (socket && packet.type !== socket_io_parser_1.PacketType.CONNECT && packet.type !== socket_io_parser_1.PacketType.CONNECT_ERROR) {
          process.nextTick(function() {
            socket._onpacket(packet);
          });
        } else {
          debug("invalid state (packet type: %s)", packet.type);
          this.close();
        }
      }
      _parseNamespace(packet) {
        if (this.conn.protocol !== 3) {
          return {
            namespace: packet.nsp,
            authPayload: packet.data
          };
        }
        const url4 = new URL(packet.nsp, "https://socket.io");
        return {
          namespace: url4.pathname,
          authPayload: Object.fromEntries(url4.searchParams.entries())
        };
      }
      /**
       * Handles an error.
       *
       * @param {Object} err object
       * @private
       */
      onerror(err) {
        for (const socket of this.sockets.values()) {
          socket._onerror(err);
        }
        this.conn.close();
      }
      /**
       * Called upon transport close.
       *
       * @param reason
       * @param description
       * @private
       */
      onclose(reason, description) {
        debug("client close with reason %s", reason);
        this.destroy();
        for (const socket of this.sockets.values()) {
          socket._onclose(reason, description);
        }
        this.sockets.clear();
        this.decoder.destroy();
      }
      /**
       * Cleans up event listeners.
       * @private
       */
      destroy() {
        this.conn.removeListener("data", this.ondata);
        this.conn.removeListener("error", this.onerror);
        this.conn.removeListener("close", this.onclose);
        this.decoder.removeListener("decoded", this.ondecoded);
        if (this.connectTimeout) {
          clearTimeout(this.connectTimeout);
          this.connectTimeout = void 0;
        }
      }
    };
    exports2.Client = Client2;
  }
});

// node_modules/socket.io/dist/typed-events.js
var require_typed_events = __commonJS({
  "node_modules/socket.io/dist/typed-events.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.StrictEventEmitter = void 0;
    var events_1 = require("events");
    var StrictEventEmitter = class extends events_1.EventEmitter {
      /**
       * Adds the `listener` function as an event listener for `ev`.
       *
       * @param ev Name of the event
       * @param listener Callback function
       */
      on(ev, listener) {
        return super.on(ev, listener);
      }
      /**
       * Adds a one-time `listener` function as an event listener for `ev`.
       *
       * @param ev Name of the event
       * @param listener Callback function
       */
      once(ev, listener) {
        return super.once(ev, listener);
      }
      /**
       * Emits an event.
       *
       * @param ev Name of the event
       * @param args Values to send to listeners of this event
       */
      emit(ev, ...args) {
        return super.emit(ev, ...args);
      }
      /**
       * Emits a reserved event.
       *
       * This method is `protected`, so that only a class extending
       * `StrictEventEmitter` can emit its own reserved events.
       *
       * @param ev Reserved event name
       * @param args Arguments to emit along with the event
       */
      emitReserved(ev, ...args) {
        return super.emit(ev, ...args);
      }
      /**
       * Emits an event.
       *
       * This method is `protected`, so that only a class extending
       * `StrictEventEmitter` can get around the strict typing. This is useful for
       * calling `emit.apply`, which can be called as `emitUntyped.apply`.
       *
       * @param ev Event name
       * @param args Arguments to emit along with the event
       */
      emitUntyped(ev, ...args) {
        return super.emit(ev, ...args);
      }
      /**
       * Returns the listeners listening to an event.
       *
       * @param event Event name
       * @returns Array of listeners subscribed to `event`
       */
      listeners(event) {
        return super.listeners(event);
      }
    };
    exports2.StrictEventEmitter = StrictEventEmitter;
  }
});

// node_modules/socket.io/dist/socket-types.js
var require_socket_types = __commonJS({
  "node_modules/socket.io/dist/socket-types.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.RESERVED_EVENTS = void 0;
    exports2.RESERVED_EVENTS = /* @__PURE__ */ new Set([
      "connect",
      "connect_error",
      "disconnect",
      "disconnecting",
      "newListener",
      "removeListener"
    ]);
  }
});

// node_modules/socket.io/dist/broadcast-operator.js
var require_broadcast_operator = __commonJS({
  "node_modules/socket.io/dist/broadcast-operator.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.RemoteSocket = exports2.BroadcastOperator = void 0;
    var socket_types_1 = require_socket_types();
    var socket_io_parser_1 = require_cjs3();
    var BroadcastOperator = class _BroadcastOperator {
      constructor(adapter2, rooms = /* @__PURE__ */ new Set(), exceptRooms = /* @__PURE__ */ new Set(), flags = {}) {
        this.adapter = adapter2;
        this.rooms = rooms;
        this.exceptRooms = exceptRooms;
        this.flags = flags;
      }
      /**
       * Targets a room when emitting.
       *
       * @example
       * // the “foo” event will be broadcast to all connected clients in the “room-101” room
       * io.to("room-101").emit("foo", "bar");
       *
       * // with an array of rooms (a client will be notified at most once)
       * io.to(["room-101", "room-102"]).emit("foo", "bar");
       *
       * // with multiple chained calls
       * io.to("room-101").to("room-102").emit("foo", "bar");
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      to(room) {
        const rooms = new Set(this.rooms);
        if (Array.isArray(room)) {
          room.forEach((r) => rooms.add(r));
        } else {
          rooms.add(room);
        }
        return new _BroadcastOperator(this.adapter, rooms, this.exceptRooms, this.flags);
      }
      /**
       * Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
       *
       * @example
       * // disconnect all clients in the "room-101" room
       * io.in("room-101").disconnectSockets();
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      in(room) {
        return this.to(room);
      }
      /**
       * Excludes a room when emitting.
       *
       * @example
       * // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
       * io.except("room-101").emit("foo", "bar");
       *
       * // with an array of rooms
       * io.except(["room-101", "room-102"]).emit("foo", "bar");
       *
       * // with multiple chained calls
       * io.except("room-101").except("room-102").emit("foo", "bar");
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      except(room) {
        const exceptRooms = new Set(this.exceptRooms);
        if (Array.isArray(room)) {
          room.forEach((r) => exceptRooms.add(r));
        } else {
          exceptRooms.add(room);
        }
        return new _BroadcastOperator(this.adapter, this.rooms, exceptRooms, this.flags);
      }
      /**
       * Sets the compress flag.
       *
       * @example
       * io.compress(false).emit("hello");
       *
       * @param compress - if `true`, compresses the sending data
       * @return a new BroadcastOperator instance
       */
      compress(compress) {
        const flags = Object.assign({}, this.flags, { compress });
        return new _BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
      }
      /**
       * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
       * receive messages (because of network slowness or other issues, or because they’re connected through long polling
       * and is in the middle of a request-response cycle).
       *
       * @example
       * io.volatile.emit("hello"); // the clients may or may not receive it
       *
       * @return a new BroadcastOperator instance
       */
      get volatile() {
        const flags = Object.assign({}, this.flags, { volatile: true });
        return new _BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
      }
      /**
       * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
       *
       * @example
       * // the “foo” event will be broadcast to all connected clients on this node
       * io.local.emit("foo", "bar");
       *
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      get local() {
        const flags = Object.assign({}, this.flags, { local: true });
        return new _BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
      }
      /**
       * Adds a timeout in milliseconds for the next operation
       *
       * @example
       * io.timeout(1000).emit("some-event", (err, responses) => {
       *   if (err) {
       *     // some clients did not acknowledge the event in the given delay
       *   } else {
       *     console.log(responses); // one response per client
       *   }
       * });
       *
       * @param timeout
       */
      timeout(timeout) {
        const flags = Object.assign({}, this.flags, { timeout });
        return new _BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
      }
      /**
       * Emits to all clients.
       *
       * @example
       * // the “foo” event will be broadcast to all connected clients
       * io.emit("foo", "bar");
       *
       * // the “foo” event will be broadcast to all connected clients in the “room-101” room
       * io.to("room-101").emit("foo", "bar");
       *
       * // with an acknowledgement expected from all connected clients
       * io.timeout(1000).emit("some-event", (err, responses) => {
       *   if (err) {
       *     // some clients did not acknowledge the event in the given delay
       *   } else {
       *     console.log(responses); // one response per client
       *   }
       * });
       *
       * @return Always true
       */
      emit(ev, ...args) {
        if (socket_types_1.RESERVED_EVENTS.has(ev)) {
          throw new Error(`"${String(ev)}" is a reserved event name`);
        }
        const data = [ev, ...args];
        const packet = {
          type: socket_io_parser_1.PacketType.EVENT,
          data
        };
        const withAck = typeof data[data.length - 1] === "function";
        if (!withAck) {
          this.adapter.broadcast(packet, {
            rooms: this.rooms,
            except: this.exceptRooms,
            flags: this.flags
          });
          return true;
        }
        const ack = data.pop();
        let timedOut = false;
        let responses = [];
        const timer = setTimeout(() => {
          timedOut = true;
          ack.apply(this, [
            new Error("operation has timed out"),
            this.flags.expectSingleResponse ? null : responses
          ]);
        }, this.flags.timeout);
        let expectedServerCount = -1;
        let actualServerCount = 0;
        let expectedClientCount = 0;
        const checkCompleteness = () => {
          if (!timedOut && expectedServerCount === actualServerCount && responses.length === expectedClientCount) {
            clearTimeout(timer);
            ack.apply(this, [
              null,
              this.flags.expectSingleResponse ? responses[0] : responses
            ]);
          }
        };
        this.adapter.broadcastWithAck(packet, {
          rooms: this.rooms,
          except: this.exceptRooms,
          flags: this.flags
        }, (clientCount) => {
          expectedClientCount += clientCount;
          actualServerCount++;
          checkCompleteness();
        }, (clientResponse) => {
          responses.push(clientResponse);
          checkCompleteness();
        });
        this.adapter.serverCount().then((serverCount) => {
          expectedServerCount = serverCount;
          checkCompleteness();
        });
        return true;
      }
      /**
       * Emits an event and waits for an acknowledgement from all clients.
       *
       * @example
       * try {
       *   const responses = await io.timeout(1000).emitWithAck("some-event");
       *   console.log(responses); // one response per client
       * } catch (e) {
       *   // some clients did not acknowledge the event in the given delay
       * }
       *
       * @return a Promise that will be fulfilled when all clients have acknowledged the event
       */
      emitWithAck(ev, ...args) {
        return new Promise((resolve3, reject) => {
          args.push((err, responses) => {
            if (err) {
              err.responses = responses;
              return reject(err);
            } else {
              return resolve3(responses);
            }
          });
          this.emit(ev, ...args);
        });
      }
      /**
       * Gets a list of clients.
       *
       * @deprecated this method will be removed in the next major release, please use {@link Server#serverSideEmit} or
       * {@link fetchSockets} instead.
       */
      allSockets() {
        if (!this.adapter) {
          throw new Error("No adapter for this namespace, are you trying to get the list of clients of a dynamic namespace?");
        }
        return this.adapter.sockets(this.rooms);
      }
      /**
       * Returns the matching socket instances. This method works across a cluster of several Socket.IO servers.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * // return all Socket instances
       * const sockets = await io.fetchSockets();
       *
       * // return all Socket instances in the "room1" room
       * const sockets = await io.in("room1").fetchSockets();
       *
       * for (const socket of sockets) {
       *   console.log(socket.id);
       *   console.log(socket.handshake);
       *   console.log(socket.rooms);
       *   console.log(socket.data);
       *
       *   socket.emit("hello");
       *   socket.join("room1");
       *   socket.leave("room2");
       *   socket.disconnect();
       * }
       */
      fetchSockets() {
        return this.adapter.fetchSockets({
          rooms: this.rooms,
          except: this.exceptRooms,
          flags: this.flags
        }).then((sockets) => {
          return sockets.map((socket) => {
            if (socket.server) {
              return socket;
            } else {
              return new RemoteSocket(this.adapter, socket);
            }
          });
        });
      }
      /**
       * Makes the matching socket instances join the specified rooms.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       *
       * // make all socket instances join the "room1" room
       * io.socketsJoin("room1");
       *
       * // make all socket instances in the "room1" room join the "room2" and "room3" rooms
       * io.in("room1").socketsJoin(["room2", "room3"]);
       *
       * @param room - a room, or an array of rooms
       */
      socketsJoin(room) {
        this.adapter.addSockets({
          rooms: this.rooms,
          except: this.exceptRooms,
          flags: this.flags
        }, Array.isArray(room) ? room : [room]);
      }
      /**
       * Makes the matching socket instances leave the specified rooms.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * // make all socket instances leave the "room1" room
       * io.socketsLeave("room1");
       *
       * // make all socket instances in the "room1" room leave the "room2" and "room3" rooms
       * io.in("room1").socketsLeave(["room2", "room3"]);
       *
       * @param room - a room, or an array of rooms
       */
      socketsLeave(room) {
        this.adapter.delSockets({
          rooms: this.rooms,
          except: this.exceptRooms,
          flags: this.flags
        }, Array.isArray(room) ? room : [room]);
      }
      /**
       * Makes the matching socket instances disconnect.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * // make all socket instances disconnect (the connections might be kept alive for other namespaces)
       * io.disconnectSockets();
       *
       * // make all socket instances in the "room1" room disconnect and close the underlying connections
       * io.in("room1").disconnectSockets(true);
       *
       * @param close - whether to close the underlying connection
       */
      disconnectSockets(close = false) {
        this.adapter.disconnectSockets({
          rooms: this.rooms,
          except: this.exceptRooms,
          flags: this.flags
        }, close);
      }
    };
    exports2.BroadcastOperator = BroadcastOperator;
    var RemoteSocket = class {
      constructor(adapter2, details) {
        this.id = details.id;
        this.handshake = details.handshake;
        this.rooms = new Set(details.rooms);
        this.data = details.data;
        this.operator = new BroadcastOperator(adapter2, /* @__PURE__ */ new Set([this.id]), /* @__PURE__ */ new Set(), {
          expectSingleResponse: true
          // so that remoteSocket.emit() with acknowledgement behaves like socket.emit()
        });
      }
      /**
       * Adds a timeout in milliseconds for the next operation.
       *
       * @example
       * const sockets = await io.fetchSockets();
       *
       * for (const socket of sockets) {
       *   if (someCondition) {
       *     socket.timeout(1000).emit("some-event", (err) => {
       *       if (err) {
       *         // the client did not acknowledge the event in the given delay
       *       }
       *     });
       *   }
       * }
       *
       * // note: if possible, using a room instead of looping over all sockets is preferable
       * io.timeout(1000).to(someConditionRoom).emit("some-event", (err, responses) => {
       *   // ...
       * });
       *
       * @param timeout
       */
      timeout(timeout) {
        return this.operator.timeout(timeout);
      }
      emit(ev, ...args) {
        return this.operator.emit(ev, ...args);
      }
      /**
       * Joins a room.
       *
       * @param {String|Array} room - room or array of rooms
       */
      join(room) {
        return this.operator.socketsJoin(room);
      }
      /**
       * Leaves a room.
       *
       * @param {String} room
       */
      leave(room) {
        return this.operator.socketsLeave(room);
      }
      /**
       * Disconnects this client.
       *
       * @param {Boolean} close - if `true`, closes the underlying connection
       * @return {Socket} self
       */
      disconnect(close = false) {
        this.operator.disconnectSockets(close);
        return this;
      }
    };
    exports2.RemoteSocket = RemoteSocket;
  }
});

// node_modules/socket.io/dist/socket.js
var require_socket2 = __commonJS({
  "node_modules/socket.io/dist/socket.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Socket = void 0;
    var socket_io_parser_1 = require_cjs3();
    var debug_1 = __importDefault(require_src());
    var typed_events_1 = require_typed_events();
    var base64id_1 = __importDefault(require_base64id());
    var broadcast_operator_1 = require_broadcast_operator();
    var socket_types_1 = require_socket_types();
    var debug = (0, debug_1.default)("socket.io:socket");
    var RECOVERABLE_DISCONNECT_REASONS = /* @__PURE__ */ new Set([
      "transport error",
      "transport close",
      "forced close",
      "ping timeout",
      "server shutting down",
      "forced server close"
    ]);
    function noop4() {
    }
    var Socket2 = class extends typed_events_1.StrictEventEmitter {
      /**
       * Interface to a `Client` for a given `Namespace`.
       *
       * @param {Namespace} nsp
       * @param {Client} client
       * @param {Object} auth
       * @package
       */
      constructor(nsp, client, auth, previousSession) {
        super();
        this.nsp = nsp;
        this.client = client;
        this.recovered = false;
        this.data = {};
        this.connected = false;
        this.acks = /* @__PURE__ */ new Map();
        this.fns = [];
        this.flags = {};
        this.server = nsp.server;
        this.adapter = nsp.adapter;
        if (previousSession) {
          this.id = previousSession.sid;
          this.pid = previousSession.pid;
          previousSession.rooms.forEach((room) => this.join(room));
          this.data = previousSession.data;
          previousSession.missedPackets.forEach((packet) => {
            this.packet({
              type: socket_io_parser_1.PacketType.EVENT,
              data: packet
            });
          });
          this.recovered = true;
        } else {
          if (client.conn.protocol === 3) {
            this.id = nsp.name !== "/" ? nsp.name + "#" + client.id : client.id;
          } else {
            this.id = base64id_1.default.generateId();
          }
          if (this.server._opts.connectionStateRecovery) {
            this.pid = base64id_1.default.generateId();
          }
        }
        this.handshake = this.buildHandshake(auth);
        this.on("error", noop4);
      }
      /**
       * Builds the `handshake` BC object
       *
       * @private
       */
      buildHandshake(auth) {
        var _a31, _b27, _c, _d;
        return {
          headers: ((_a31 = this.request) === null || _a31 === void 0 ? void 0 : _a31.headers) || {},
          time: /* @__PURE__ */ new Date() + "",
          address: this.conn.remoteAddress,
          xdomain: !!((_b27 = this.request) === null || _b27 === void 0 ? void 0 : _b27.headers.origin),
          // @ts-ignore
          secure: !this.request || !!this.request.connection.encrypted,
          issued: +/* @__PURE__ */ new Date(),
          url: (_c = this.request) === null || _c === void 0 ? void 0 : _c.url,
          // @ts-ignore
          query: ((_d = this.request) === null || _d === void 0 ? void 0 : _d._query) || {},
          auth
        };
      }
      /**
       * Emits to this client.
       *
       * @example
       * io.on("connection", (socket) => {
       *   socket.emit("hello", "world");
       *
       *   // all serializable datastructures are supported (no need to call JSON.stringify)
       *   socket.emit("hello", 1, "2", { 3: ["4"], 5: Buffer.from([6]) });
       *
       *   // with an acknowledgement from the client
       *   socket.emit("hello", "world", (val) => {
       *     // ...
       *   });
       * });
       *
       * @return Always returns `true`.
       */
      emit(ev, ...args) {
        if (socket_types_1.RESERVED_EVENTS.has(ev)) {
          throw new Error(`"${String(ev)}" is a reserved event name`);
        }
        const data = [ev, ...args];
        const packet = {
          type: socket_io_parser_1.PacketType.EVENT,
          data
        };
        if (typeof data[data.length - 1] === "function") {
          const id = this.nsp._ids++;
          debug("emitting packet with ack id %d", id);
          this.registerAckCallback(id, data.pop());
          packet.id = id;
        }
        const flags = Object.assign({}, this.flags);
        this.flags = {};
        if (this.nsp.server.opts.connectionStateRecovery) {
          this.adapter.broadcast(packet, {
            rooms: /* @__PURE__ */ new Set([this.id]),
            except: /* @__PURE__ */ new Set(),
            flags
          });
        } else {
          this.notifyOutgoingListeners(packet);
          this.packet(packet, flags);
        }
        return true;
      }
      /**
       * Emits an event and waits for an acknowledgement
       *
       * @example
       * io.on("connection", async (socket) => {
       *   // without timeout
       *   const response = await socket.emitWithAck("hello", "world");
       *
       *   // with a specific timeout
       *   try {
       *     const response = await socket.timeout(1000).emitWithAck("hello", "world");
       *   } catch (err) {
       *     // the client did not acknowledge the event in the given delay
       *   }
       * });
       *
       * @return a Promise that will be fulfilled when the client acknowledges the event
       */
      emitWithAck(ev, ...args) {
        const withErr = this.flags.timeout !== void 0;
        return new Promise((resolve3, reject) => {
          args.push((arg1, arg2) => {
            if (withErr) {
              return arg1 ? reject(arg1) : resolve3(arg2);
            } else {
              return resolve3(arg1);
            }
          });
          this.emit(ev, ...args);
        });
      }
      /**
       * @private
       */
      registerAckCallback(id, ack) {
        const timeout = this.flags.timeout;
        if (timeout === void 0) {
          this.acks.set(id, ack);
          return;
        }
        const timer = setTimeout(() => {
          debug("event with ack id %d has timed out after %d ms", id, timeout);
          this.acks.delete(id);
          ack.call(this, new Error("operation has timed out"));
        }, timeout);
        this.acks.set(id, (...args) => {
          clearTimeout(timer);
          ack.apply(this, [null, ...args]);
        });
      }
      /**
       * Targets a room when broadcasting.
       *
       * @example
       * io.on("connection", (socket) => {
       *   // the “foo” event will be broadcast to all connected clients in the “room-101” room, except this socket
       *   socket.to("room-101").emit("foo", "bar");
       *
       *   // the code above is equivalent to:
       *   io.to("room-101").except(socket.id).emit("foo", "bar");
       *
       *   // with an array of rooms (a client will be notified at most once)
       *   socket.to(["room-101", "room-102"]).emit("foo", "bar");
       *
       *   // with multiple chained calls
       *   socket.to("room-101").to("room-102").emit("foo", "bar");
       * });
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      to(room) {
        return this.newBroadcastOperator().to(room);
      }
      /**
       * Targets a room when broadcasting. Similar to `to()`, but might feel clearer in some cases:
       *
       * @example
       * io.on("connection", (socket) => {
       *   // disconnect all clients in the "room-101" room, except this socket
       *   socket.in("room-101").disconnectSockets();
       * });
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      in(room) {
        return this.newBroadcastOperator().in(room);
      }
      /**
       * Excludes a room when broadcasting.
       *
       * @example
       * io.on("connection", (socket) => {
       *   // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
       *   // and this socket
       *   socket.except("room-101").emit("foo", "bar");
       *
       *   // with an array of rooms
       *   socket.except(["room-101", "room-102"]).emit("foo", "bar");
       *
       *   // with multiple chained calls
       *   socket.except("room-101").except("room-102").emit("foo", "bar");
       * });
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      except(room) {
        return this.newBroadcastOperator().except(room);
      }
      /**
       * Sends a `message` event.
       *
       * This method mimics the WebSocket.send() method.
       *
       * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
       *
       * @example
       * io.on("connection", (socket) => {
       *   socket.send("hello");
       *
       *   // this is equivalent to
       *   socket.emit("message", "hello");
       * });
       *
       * @return self
       */
      send(...args) {
        this.emit("message", ...args);
        return this;
      }
      /**
       * Sends a `message` event. Alias of {@link send}.
       *
       * @return self
       */
      write(...args) {
        this.emit("message", ...args);
        return this;
      }
      /**
       * Writes a packet.
       *
       * @param {Object} packet - packet object
       * @param {Object} opts - options
       * @private
       */
      packet(packet, opts = {}) {
        packet.nsp = this.nsp.name;
        opts.compress = false !== opts.compress;
        this.client._packet(packet, opts);
      }
      /**
       * Joins a room.
       *
       * @example
       * io.on("connection", (socket) => {
       *   // join a single room
       *   socket.join("room1");
       *
       *   // join multiple rooms
       *   socket.join(["room1", "room2"]);
       * });
       *
       * @param {String|Array} rooms - room or array of rooms
       * @return a Promise or nothing, depending on the adapter
       */
      join(rooms) {
        debug("join room %s", rooms);
        return this.adapter.addAll(this.id, new Set(Array.isArray(rooms) ? rooms : [rooms]));
      }
      /**
       * Leaves a room.
       *
       * @example
       * io.on("connection", (socket) => {
       *   // leave a single room
       *   socket.leave("room1");
       *
       *   // leave multiple rooms
       *   socket.leave("room1").leave("room2");
       * });
       *
       * @param {String} room
       * @return a Promise or nothing, depending on the adapter
       */
      leave(room) {
        debug("leave room %s", room);
        return this.adapter.del(this.id, room);
      }
      /**
       * Leave all rooms.
       *
       * @private
       */
      leaveAll() {
        this.adapter.delAll(this.id);
      }
      /**
       * Called by `Namespace` upon successful
       * middleware execution (ie: authorization).
       * Socket is added to namespace array before
       * call to join, so adapters can access it.
       *
       * @private
       */
      _onconnect() {
        debug("socket connected - writing packet");
        this.connected = true;
        this.join(this.id);
        if (this.conn.protocol === 3) {
          this.packet({ type: socket_io_parser_1.PacketType.CONNECT });
        } else {
          this.packet({
            type: socket_io_parser_1.PacketType.CONNECT,
            data: { sid: this.id, pid: this.pid }
          });
        }
      }
      /**
       * Called with each packet. Called by `Client`.
       *
       * @param {Object} packet
       * @private
       */
      _onpacket(packet) {
        debug("got packet %j", packet);
        switch (packet.type) {
          case socket_io_parser_1.PacketType.EVENT:
            this.onevent(packet);
            break;
          case socket_io_parser_1.PacketType.BINARY_EVENT:
            this.onevent(packet);
            break;
          case socket_io_parser_1.PacketType.ACK:
            this.onack(packet);
            break;
          case socket_io_parser_1.PacketType.BINARY_ACK:
            this.onack(packet);
            break;
          case socket_io_parser_1.PacketType.DISCONNECT:
            this.ondisconnect();
            break;
        }
      }
      /**
       * Called upon event packet.
       *
       * @param {Packet} packet - packet object
       * @private
       */
      onevent(packet) {
        const args = packet.data || [];
        debug("emitting event %j", args);
        if (null != packet.id) {
          debug("attaching ack callback to event");
          args.push(this.ack(packet.id));
        }
        if (this._anyListeners && this._anyListeners.length) {
          const listeners = this._anyListeners.slice();
          for (const listener of listeners) {
            listener.apply(this, args);
          }
        }
        this.dispatch(args);
      }
      /**
       * Produces an ack callback to emit with an event.
       *
       * @param {Number} id - packet id
       * @private
       */
      ack(id) {
        const self2 = this;
        let sent = false;
        return function() {
          if (sent)
            return;
          const args = Array.prototype.slice.call(arguments);
          debug("sending ack %j", args);
          self2.packet({
            id,
            type: socket_io_parser_1.PacketType.ACK,
            data: args
          });
          sent = true;
        };
      }
      /**
       * Called upon ack packet.
       *
       * @private
       */
      onack(packet) {
        const ack = this.acks.get(packet.id);
        if ("function" == typeof ack) {
          debug("calling ack %s with %j", packet.id, packet.data);
          ack.apply(this, packet.data);
          this.acks.delete(packet.id);
        } else {
          debug("bad ack %s", packet.id);
        }
      }
      /**
       * Called upon client disconnect packet.
       *
       * @private
       */
      ondisconnect() {
        debug("got disconnect packet");
        this._onclose("client namespace disconnect");
      }
      /**
       * Handles a client error.
       *
       * @private
       */
      _onerror(err) {
        this.emitReserved("error", err);
      }
      /**
       * Called upon closing. Called by `Client`.
       *
       * @param {String} reason
       * @param description
       * @throw {Error} optional error object
       *
       * @private
       */
      _onclose(reason, description) {
        if (!this.connected)
          return this;
        debug("closing socket - reason %s", reason);
        this.emitReserved("disconnecting", reason, description);
        if (this.server._opts.connectionStateRecovery && RECOVERABLE_DISCONNECT_REASONS.has(reason)) {
          debug("connection state recovery is enabled for sid %s", this.id);
          this.adapter.persistSession({
            sid: this.id,
            pid: this.pid,
            rooms: [...this.rooms],
            data: this.data
          });
        }
        this._cleanup();
        this.client._remove(this);
        this.connected = false;
        this.emitReserved("disconnect", reason, description);
        return;
      }
      /**
       * Makes the socket leave all the rooms it was part of and prevents it from joining any other room
       *
       * @private
       */
      _cleanup() {
        this.leaveAll();
        this.nsp._remove(this);
        this.join = noop4;
      }
      /**
       * Produces an `error` packet.
       *
       * @param {Object} err - error object
       *
       * @private
       */
      _error(err) {
        this.packet({ type: socket_io_parser_1.PacketType.CONNECT_ERROR, data: err });
      }
      /**
       * Disconnects this client.
       *
       * @example
       * io.on("connection", (socket) => {
       *   // disconnect this socket (the connection might be kept alive for other namespaces)
       *   socket.disconnect();
       *
       *   // disconnect this socket and close the underlying connection
       *   socket.disconnect(true);
       * })
       *
       * @param {Boolean} close - if `true`, closes the underlying connection
       * @return self
       */
      disconnect(close = false) {
        if (!this.connected)
          return this;
        if (close) {
          this.client._disconnect();
        } else {
          this.packet({ type: socket_io_parser_1.PacketType.DISCONNECT });
          this._onclose("server namespace disconnect");
        }
        return this;
      }
      /**
       * Sets the compress flag.
       *
       * @example
       * io.on("connection", (socket) => {
       *   socket.compress(false).emit("hello");
       * });
       *
       * @param {Boolean} compress - if `true`, compresses the sending data
       * @return {Socket} self
       */
      compress(compress) {
        this.flags.compress = compress;
        return this;
      }
      /**
       * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
       * receive messages (because of network slowness or other issues, or because they’re connected through long polling
       * and is in the middle of a request-response cycle).
       *
       * @example
       * io.on("connection", (socket) => {
       *   socket.volatile.emit("hello"); // the client may or may not receive it
       * });
       *
       * @return {Socket} self
       */
      get volatile() {
        this.flags.volatile = true;
        return this;
      }
      /**
       * Sets a modifier for a subsequent event emission that the event data will only be broadcast to every sockets but the
       * sender.
       *
       * @example
       * io.on("connection", (socket) => {
       *   // the “foo” event will be broadcast to all connected clients, except this socket
       *   socket.broadcast.emit("foo", "bar");
       * });
       *
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      get broadcast() {
        return this.newBroadcastOperator();
      }
      /**
       * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
       *
       * @example
       * io.on("connection", (socket) => {
       *   // the “foo” event will be broadcast to all connected clients on this node, except this socket
       *   socket.local.emit("foo", "bar");
       * });
       *
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      get local() {
        return this.newBroadcastOperator().local;
      }
      /**
       * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
       * given number of milliseconds have elapsed without an acknowledgement from the client:
       *
       * @example
       * io.on("connection", (socket) => {
       *   socket.timeout(5000).emit("my-event", (err) => {
       *     if (err) {
       *       // the client did not acknowledge the event in the given delay
       *     }
       *   });
       * });
       *
       * @returns self
       */
      timeout(timeout) {
        this.flags.timeout = timeout;
        return this;
      }
      /**
       * Dispatch incoming event to socket listeners.
       *
       * @param {Array} event - event that will get emitted
       * @private
       */
      dispatch(event) {
        debug("dispatching an event %j", event);
        this.run(event, (err) => {
          process.nextTick(() => {
            if (err) {
              return this._onerror(err);
            }
            if (this.connected) {
              super.emitUntyped.apply(this, event);
            } else {
              debug("ignore packet received after disconnection");
            }
          });
        });
      }
      /**
       * Sets up socket middleware.
       *
       * @example
       * io.on("connection", (socket) => {
       *   socket.use(([event, ...args], next) => {
       *     if (isUnauthorized(event)) {
       *       return next(new Error("unauthorized event"));
       *     }
       *     // do not forget to call next
       *     next();
       *   });
       *
       *   socket.on("error", (err) => {
       *     if (err && err.message === "unauthorized event") {
       *       socket.disconnect();
       *     }
       *   });
       * });
       *
       * @param {Function} fn - middleware function (event, next)
       * @return {Socket} self
       */
      use(fn) {
        this.fns.push(fn);
        return this;
      }
      /**
       * Executes the middleware for an incoming event.
       *
       * @param {Array} event - event that will get emitted
       * @param {Function} fn - last fn call in the middleware
       * @private
       */
      run(event, fn) {
        if (!this.fns.length)
          return fn();
        const fns = this.fns.slice(0);
        function run(i) {
          fns[i](event, (err) => {
            if (err)
              return fn(err);
            if (!fns[i + 1])
              return fn();
            run(i + 1);
          });
        }
        run(0);
      }
      /**
       * Whether the socket is currently disconnected
       */
      get disconnected() {
        return !this.connected;
      }
      /**
       * A reference to the request that originated the underlying Engine.IO Socket.
       */
      get request() {
        return this.client.request;
      }
      /**
       * A reference to the underlying Client transport connection (Engine.IO Socket object).
       *
       * @example
       * io.on("connection", (socket) => {
       *   console.log(socket.conn.transport.name); // prints "polling" or "websocket"
       *
       *   socket.conn.once("upgrade", () => {
       *     console.log(socket.conn.transport.name); // prints "websocket"
       *   });
       * });
       */
      get conn() {
        return this.client.conn;
      }
      /**
       * Returns the rooms the socket is currently in.
       *
       * @example
       * io.on("connection", (socket) => {
       *   console.log(socket.rooms); // Set { <socket.id> }
       *
       *   socket.join("room1");
       *
       *   console.log(socket.rooms); // Set { <socket.id>, "room1" }
       * });
       */
      get rooms() {
        return this.adapter.socketRooms(this.id) || /* @__PURE__ */ new Set();
      }
      /**
       * Adds a listener that will be fired when any event is received. The event name is passed as the first argument to
       * the callback.
       *
       * @example
       * io.on("connection", (socket) => {
       *   socket.onAny((event, ...args) => {
       *     console.log(`got event ${event}`);
       *   });
       * });
       *
       * @param listener
       */
      onAny(listener) {
        this._anyListeners = this._anyListeners || [];
        this._anyListeners.push(listener);
        return this;
      }
      /**
       * Adds a listener that will be fired when any event is received. The event name is passed as the first argument to
       * the callback. The listener is added to the beginning of the listeners array.
       *
       * @param listener
       */
      prependAny(listener) {
        this._anyListeners = this._anyListeners || [];
        this._anyListeners.unshift(listener);
        return this;
      }
      /**
       * Removes the listener that will be fired when any event is received.
       *
       * @example
       * io.on("connection", (socket) => {
       *   const catchAllListener = (event, ...args) => {
       *     console.log(`got event ${event}`);
       *   }
       *
       *   socket.onAny(catchAllListener);
       *
       *   // remove a specific listener
       *   socket.offAny(catchAllListener);
       *
       *   // or remove all listeners
       *   socket.offAny();
       * });
       *
       * @param listener
       */
      offAny(listener) {
        if (!this._anyListeners) {
          return this;
        }
        if (listener) {
          const listeners = this._anyListeners;
          for (let i = 0; i < listeners.length; i++) {
            if (listener === listeners[i]) {
              listeners.splice(i, 1);
              return this;
            }
          }
        } else {
          this._anyListeners = [];
        }
        return this;
      }
      /**
       * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
       * e.g. to remove listeners.
       */
      listenersAny() {
        return this._anyListeners || [];
      }
      /**
       * Adds a listener that will be fired when any event is sent. The event name is passed as the first argument to
       * the callback.
       *
       * Note: acknowledgements sent to the client are not included.
       *
       * @example
       * io.on("connection", (socket) => {
       *   socket.onAnyOutgoing((event, ...args) => {
       *     console.log(`sent event ${event}`);
       *   });
       * });
       *
       * @param listener
       */
      onAnyOutgoing(listener) {
        this._anyOutgoingListeners = this._anyOutgoingListeners || [];
        this._anyOutgoingListeners.push(listener);
        return this;
      }
      /**
       * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
       * callback. The listener is added to the beginning of the listeners array.
       *
       * @example
       * io.on("connection", (socket) => {
       *   socket.prependAnyOutgoing((event, ...args) => {
       *     console.log(`sent event ${event}`);
       *   });
       * });
       *
       * @param listener
       */
      prependAnyOutgoing(listener) {
        this._anyOutgoingListeners = this._anyOutgoingListeners || [];
        this._anyOutgoingListeners.unshift(listener);
        return this;
      }
      /**
       * Removes the listener that will be fired when any event is sent.
       *
       * @example
       * io.on("connection", (socket) => {
       *   const catchAllListener = (event, ...args) => {
       *     console.log(`sent event ${event}`);
       *   }
       *
       *   socket.onAnyOutgoing(catchAllListener);
       *
       *   // remove a specific listener
       *   socket.offAnyOutgoing(catchAllListener);
       *
       *   // or remove all listeners
       *   socket.offAnyOutgoing();
       * });
       *
       * @param listener - the catch-all listener
       */
      offAnyOutgoing(listener) {
        if (!this._anyOutgoingListeners) {
          return this;
        }
        if (listener) {
          const listeners = this._anyOutgoingListeners;
          for (let i = 0; i < listeners.length; i++) {
            if (listener === listeners[i]) {
              listeners.splice(i, 1);
              return this;
            }
          }
        } else {
          this._anyOutgoingListeners = [];
        }
        return this;
      }
      /**
       * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
       * e.g. to remove listeners.
       */
      listenersAnyOutgoing() {
        return this._anyOutgoingListeners || [];
      }
      /**
       * Notify the listeners for each packet sent (emit or broadcast)
       *
       * @param packet
       *
       * @private
       */
      notifyOutgoingListeners(packet) {
        if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
          const listeners = this._anyOutgoingListeners.slice();
          for (const listener of listeners) {
            listener.apply(this, packet.data);
          }
        }
      }
      newBroadcastOperator() {
        const flags = Object.assign({}, this.flags);
        this.flags = {};
        return new broadcast_operator_1.BroadcastOperator(this.adapter, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set([this.id]), flags);
      }
    };
    exports2.Socket = Socket2;
  }
});

// node_modules/socket.io/dist/namespace.js
var require_namespace = __commonJS({
  "node_modules/socket.io/dist/namespace.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Namespace = exports2.RESERVED_EVENTS = void 0;
    var socket_1 = require_socket2();
    var typed_events_1 = require_typed_events();
    var debug_1 = __importDefault(require_src());
    var broadcast_operator_1 = require_broadcast_operator();
    var debug = (0, debug_1.default)("socket.io:namespace");
    exports2.RESERVED_EVENTS = /* @__PURE__ */ new Set(["connect", "connection", "new_namespace"]);
    var Namespace2 = class extends typed_events_1.StrictEventEmitter {
      /**
       * Namespace constructor.
       *
       * @param server instance
       * @param name
       */
      constructor(server2, name28) {
        super();
        this.sockets = /* @__PURE__ */ new Map();
        this._preConnectSockets = /* @__PURE__ */ new Map();
        this._fns = [];
        this._ids = 0;
        this.server = server2;
        this.name = name28;
        this._initAdapter();
      }
      /**
       * Initializes the `Adapter` for this nsp.
       * Run upon changing adapter by `Server#adapter`
       * in addition to the constructor.
       *
       * @private
       */
      _initAdapter() {
        this.adapter = new (this.server.adapter())(this);
        Promise.resolve(this.adapter.init()).catch((err) => {
          debug("error while initializing adapter: %s", err);
        });
      }
      /**
       * Registers a middleware, which is a function that gets executed for every incoming {@link Socket}.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * myNamespace.use((socket, next) => {
       *   // ...
       *   next();
       * });
       *
       * @param fn - the middleware function
       */
      use(fn) {
        this._fns.push(fn);
        return this;
      }
      /**
       * Executes the middleware for an incoming client.
       *
       * @param socket - the socket that will get added
       * @param fn - last fn call in the middleware
       * @private
       */
      run(socket, fn) {
        if (!this._fns.length)
          return fn();
        const fns = this._fns.slice(0);
        function run(i) {
          fns[i](socket, (err) => {
            if (err)
              return fn(err);
            if (!fns[i + 1])
              return fn();
            run(i + 1);
          });
        }
        run(0);
      }
      /**
       * Targets a room when emitting.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * // the “foo” event will be broadcast to all connected clients in the “room-101” room
       * myNamespace.to("room-101").emit("foo", "bar");
       *
       * // with an array of rooms (a client will be notified at most once)
       * myNamespace.to(["room-101", "room-102"]).emit("foo", "bar");
       *
       * // with multiple chained calls
       * myNamespace.to("room-101").to("room-102").emit("foo", "bar");
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      to(room) {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).to(room);
      }
      /**
       * Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * // disconnect all clients in the "room-101" room
       * myNamespace.in("room-101").disconnectSockets();
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      in(room) {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).in(room);
      }
      /**
       * Excludes a room when emitting.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
       * myNamespace.except("room-101").emit("foo", "bar");
       *
       * // with an array of rooms
       * myNamespace.except(["room-101", "room-102"]).emit("foo", "bar");
       *
       * // with multiple chained calls
       * myNamespace.except("room-101").except("room-102").emit("foo", "bar");
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      except(room) {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).except(room);
      }
      /**
       * Adds a new client.
       *
       * @return {Socket}
       * @private
       */
      async _add(client, auth, fn) {
        var _a31;
        debug("adding socket to nsp %s", this.name);
        const socket = await this._createSocket(client, auth);
        this._preConnectSockets.set(socket.id, socket);
        if (
          // @ts-ignore
          ((_a31 = this.server.opts.connectionStateRecovery) === null || _a31 === void 0 ? void 0 : _a31.skipMiddlewares) && socket.recovered && client.conn.readyState === "open"
        ) {
          return this._doConnect(socket, fn);
        }
        this.run(socket, (err) => {
          process.nextTick(() => {
            if ("open" !== client.conn.readyState) {
              debug("next called after client was closed - ignoring socket");
              socket._cleanup();
              return;
            }
            if (err) {
              debug("middleware error, sending CONNECT_ERROR packet to the client");
              socket._cleanup();
              if (client.conn.protocol === 3) {
                return socket._error(err.data || err.message);
              } else {
                return socket._error({
                  message: err.message,
                  data: err.data
                });
              }
            }
            this._doConnect(socket, fn);
          });
        });
      }
      async _createSocket(client, auth) {
        const sessionId = auth.pid;
        const offset = auth.offset;
        if (
          // @ts-ignore
          this.server.opts.connectionStateRecovery && typeof sessionId === "string" && typeof offset === "string"
        ) {
          let session;
          try {
            session = await this.adapter.restoreSession(sessionId, offset);
          } catch (e) {
            debug("error while restoring session: %s", e);
          }
          if (session) {
            debug("connection state recovered for sid %s", session.sid);
            return new socket_1.Socket(this, client, auth, session);
          }
        }
        return new socket_1.Socket(this, client, auth);
      }
      _doConnect(socket, fn) {
        this._preConnectSockets.delete(socket.id);
        this.sockets.set(socket.id, socket);
        socket._onconnect();
        if (fn)
          fn(socket);
        this.emitReserved("connect", socket);
        this.emitReserved("connection", socket);
      }
      /**
       * Removes a client. Called by each `Socket`.
       *
       * @private
       */
      _remove(socket) {
        this.sockets.delete(socket.id) || this._preConnectSockets.delete(socket.id);
      }
      /**
       * Emits to all connected clients.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * myNamespace.emit("hello", "world");
       *
       * // all serializable datastructures are supported (no need to call JSON.stringify)
       * myNamespace.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
       *
       * // with an acknowledgement from the clients
       * myNamespace.timeout(1000).emit("some-event", (err, responses) => {
       *   if (err) {
       *     // some clients did not acknowledge the event in the given delay
       *   } else {
       *     console.log(responses); // one response per client
       *   }
       * });
       *
       * @return Always true
       */
      emit(ev, ...args) {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).emit(ev, ...args);
      }
      /**
       * Sends a `message` event to all clients.
       *
       * This method mimics the WebSocket.send() method.
       *
       * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * myNamespace.send("hello");
       *
       * // this is equivalent to
       * myNamespace.emit("message", "hello");
       *
       * @return self
       */
      send(...args) {
        this.emit("message", ...args);
        return this;
      }
      /**
       * Sends a `message` event to all clients. Sends a `message` event. Alias of {@link send}.
       *
       * @return self
       */
      write(...args) {
        this.emit("message", ...args);
        return this;
      }
      /**
       * Sends a message to the other Socket.IO servers of the cluster.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * myNamespace.serverSideEmit("hello", "world");
       *
       * myNamespace.on("hello", (arg1) => {
       *   console.log(arg1); // prints "world"
       * });
       *
       * // acknowledgements (without binary content) are supported too:
       * myNamespace.serverSideEmit("ping", (err, responses) => {
       *  if (err) {
       *     // some servers did not acknowledge the event in the given delay
       *   } else {
       *     console.log(responses); // one response per server (except the current one)
       *   }
       * });
       *
       * myNamespace.on("ping", (cb) => {
       *   cb("pong");
       * });
       *
       * @param ev - the event name
       * @param args - an array of arguments, which may include an acknowledgement callback at the end
       */
      serverSideEmit(ev, ...args) {
        if (exports2.RESERVED_EVENTS.has(ev)) {
          throw new Error(`"${String(ev)}" is a reserved event name`);
        }
        args.unshift(ev);
        this.adapter.serverSideEmit(args);
        return true;
      }
      /**
       * Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * try {
       *   const responses = await myNamespace.serverSideEmitWithAck("ping");
       *   console.log(responses); // one response per server (except the current one)
       * } catch (e) {
       *   // some servers did not acknowledge the event in the given delay
       * }
       *
       * @param ev - the event name
       * @param args - an array of arguments
       *
       * @return a Promise that will be fulfilled when all servers have acknowledged the event
       */
      serverSideEmitWithAck(ev, ...args) {
        return new Promise((resolve3, reject) => {
          args.push((err, responses) => {
            if (err) {
              err.responses = responses;
              return reject(err);
            } else {
              return resolve3(responses);
            }
          });
          this.serverSideEmit(ev, ...args);
        });
      }
      /**
       * Called when a packet is received from another Socket.IO server
       *
       * @param args - an array of arguments, which may include an acknowledgement callback at the end
       *
       * @private
       */
      _onServerSideEmit(args) {
        super.emitUntyped.apply(this, args);
      }
      /**
       * Gets a list of clients.
       *
       * @deprecated this method will be removed in the next major release, please use {@link Namespace#serverSideEmit} or
       * {@link Namespace#fetchSockets} instead.
       */
      allSockets() {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).allSockets();
      }
      /**
       * Sets the compress flag.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * myNamespace.compress(false).emit("hello");
       *
       * @param compress - if `true`, compresses the sending data
       * @return self
       */
      compress(compress) {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).compress(compress);
      }
      /**
       * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
       * receive messages (because of network slowness or other issues, or because they’re connected through long polling
       * and is in the middle of a request-response cycle).
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * myNamespace.volatile.emit("hello"); // the clients may or may not receive it
       *
       * @return self
       */
      get volatile() {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).volatile;
      }
      /**
       * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * // the “foo” event will be broadcast to all connected clients on this node
       * myNamespace.local.emit("foo", "bar");
       *
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      get local() {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).local;
      }
      /**
       * Adds a timeout in milliseconds for the next operation.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * myNamespace.timeout(1000).emit("some-event", (err, responses) => {
       *   if (err) {
       *     // some clients did not acknowledge the event in the given delay
       *   } else {
       *     console.log(responses); // one response per client
       *   }
       * });
       *
       * @param timeout
       */
      timeout(timeout) {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).timeout(timeout);
      }
      /**
       * Returns the matching socket instances.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * // return all Socket instances
       * const sockets = await myNamespace.fetchSockets();
       *
       * // return all Socket instances in the "room1" room
       * const sockets = await myNamespace.in("room1").fetchSockets();
       *
       * for (const socket of sockets) {
       *   console.log(socket.id);
       *   console.log(socket.handshake);
       *   console.log(socket.rooms);
       *   console.log(socket.data);
       *
       *   socket.emit("hello");
       *   socket.join("room1");
       *   socket.leave("room2");
       *   socket.disconnect();
       * }
       */
      fetchSockets() {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).fetchSockets();
      }
      /**
       * Makes the matching socket instances join the specified rooms.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * // make all socket instances join the "room1" room
       * myNamespace.socketsJoin("room1");
       *
       * // make all socket instances in the "room1" room join the "room2" and "room3" rooms
       * myNamespace.in("room1").socketsJoin(["room2", "room3"]);
       *
       * @param room - a room, or an array of rooms
       */
      socketsJoin(room) {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsJoin(room);
      }
      /**
       * Makes the matching socket instances leave the specified rooms.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * // make all socket instances leave the "room1" room
       * myNamespace.socketsLeave("room1");
       *
       * // make all socket instances in the "room1" room leave the "room2" and "room3" rooms
       * myNamespace.in("room1").socketsLeave(["room2", "room3"]);
       *
       * @param room - a room, or an array of rooms
       */
      socketsLeave(room) {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsLeave(room);
      }
      /**
       * Makes the matching socket instances disconnect.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * const myNamespace = io.of("/my-namespace");
       *
       * // make all socket instances disconnect (the connections might be kept alive for other namespaces)
       * myNamespace.disconnectSockets();
       *
       * // make all socket instances in the "room1" room disconnect and close the underlying connections
       * myNamespace.in("room1").disconnectSockets(true);
       *
       * @param close - whether to close the underlying connection
       */
      disconnectSockets(close = false) {
        return new broadcast_operator_1.BroadcastOperator(this.adapter).disconnectSockets(close);
      }
    };
    exports2.Namespace = Namespace2;
  }
});

// node_modules/socket.io-adapter/dist/contrib/yeast.js
var require_yeast = __commonJS({
  "node_modules/socket.io-adapter/dist/contrib/yeast.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.encode = encode6;
    exports2.decode = decode4;
    exports2.yeast = yeast;
    var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".split("");
    var length = 64;
    var map3 = {};
    var seed = 0;
    var i = 0;
    var prev;
    function encode6(num) {
      let encoded = "";
      do {
        encoded = alphabet[num % length] + encoded;
        num = Math.floor(num / length);
      } while (num > 0);
      return encoded;
    }
    function decode4(str) {
      let decoded = 0;
      for (i = 0; i < str.length; i++) {
        decoded = decoded * length + map3[str.charAt(i)];
      }
      return decoded;
    }
    function yeast() {
      const now2 = encode6(+/* @__PURE__ */ new Date());
      if (now2 !== prev)
        return seed = 0, prev = now2;
      return now2 + "." + encode6(seed++);
    }
    for (; i < length; i++)
      map3[alphabet[i]] = i;
  }
});

// node_modules/socket.io-adapter/dist/in-memory-adapter.js
var require_in_memory_adapter = __commonJS({
  "node_modules/socket.io-adapter/dist/in-memory-adapter.js"(exports2) {
    "use strict";
    var _a31;
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SessionAwareAdapter = exports2.Adapter = void 0;
    var events_1 = require("events");
    var yeast_1 = require_yeast();
    var WebSocket = require_ws();
    var canPreComputeFrame = typeof ((_a31 = WebSocket === null || WebSocket === void 0 ? void 0 : WebSocket.Sender) === null || _a31 === void 0 ? void 0 : _a31.frame) === "function";
    var Adapter = class extends events_1.EventEmitter {
      /**
       * In-memory adapter constructor.
       *
       * @param nsp
       */
      constructor(nsp) {
        super();
        this.nsp = nsp;
        this.rooms = /* @__PURE__ */ new Map();
        this.sids = /* @__PURE__ */ new Map();
        this.encoder = nsp.server.encoder;
      }
      /**
       * To be overridden
       */
      init() {
      }
      /**
       * To be overridden
       */
      close() {
      }
      /**
       * Returns the number of Socket.IO servers in the cluster
       *
       * @public
       */
      serverCount() {
        return Promise.resolve(1);
      }
      /**
       * Adds a socket to a list of room.
       *
       * @param {SocketId}  id      the socket id
       * @param {Set<Room>} rooms   a set of rooms
       * @public
       */
      addAll(id, rooms) {
        if (!this.sids.has(id)) {
          this.sids.set(id, /* @__PURE__ */ new Set());
        }
        for (const room of rooms) {
          this.sids.get(id).add(room);
          if (!this.rooms.has(room)) {
            this.rooms.set(room, /* @__PURE__ */ new Set());
            this.emit("create-room", room);
          }
          if (!this.rooms.get(room).has(id)) {
            this.rooms.get(room).add(id);
            this.emit("join-room", room, id);
          }
        }
      }
      /**
       * Removes a socket from a room.
       *
       * @param {SocketId} id     the socket id
       * @param {Room}     room   the room name
       */
      del(id, room) {
        if (this.sids.has(id)) {
          this.sids.get(id).delete(room);
        }
        this._del(room, id);
      }
      _del(room, id) {
        const _room = this.rooms.get(room);
        if (_room != null) {
          const deleted = _room.delete(id);
          if (deleted) {
            this.emit("leave-room", room, id);
          }
          if (_room.size === 0 && this.rooms.delete(room)) {
            this.emit("delete-room", room);
          }
        }
      }
      /**
       * Removes a socket from all rooms it's joined.
       *
       * @param {SocketId} id   the socket id
       */
      delAll(id) {
        if (!this.sids.has(id)) {
          return;
        }
        for (const room of this.sids.get(id)) {
          this._del(room, id);
        }
        this.sids.delete(id);
      }
      /**
       * Broadcasts a packet.
       *
       * Options:
       *  - `flags` {Object} flags for this packet
       *  - `except` {Array} sids that should be excluded
       *  - `rooms` {Array} list of rooms to broadcast to
       *
       * @param {Object} packet   the packet object
       * @param {Object} opts     the options
       * @public
       */
      broadcast(packet, opts) {
        const flags = opts.flags || {};
        const packetOpts = {
          preEncoded: true,
          volatile: flags.volatile,
          compress: flags.compress
        };
        packet.nsp = this.nsp.name;
        const encodedPackets = this._encode(packet, packetOpts);
        this.apply(opts, (socket) => {
          if (typeof socket.notifyOutgoingListeners === "function") {
            socket.notifyOutgoingListeners(packet);
          }
          socket.client.writeToEngine(encodedPackets, packetOpts);
        });
      }
      /**
       * Broadcasts a packet and expects multiple acknowledgements.
       *
       * Options:
       *  - `flags` {Object} flags for this packet
       *  - `except` {Array} sids that should be excluded
       *  - `rooms` {Array} list of rooms to broadcast to
       *
       * @param {Object} packet   the packet object
       * @param {Object} opts     the options
       * @param clientCountCallback - the number of clients that received the packet
       * @param ack                 - the callback that will be called for each client response
       *
       * @public
       */
      broadcastWithAck(packet, opts, clientCountCallback, ack) {
        const flags = opts.flags || {};
        const packetOpts = {
          preEncoded: true,
          volatile: flags.volatile,
          compress: flags.compress
        };
        packet.nsp = this.nsp.name;
        packet.id = this.nsp._ids++;
        const encodedPackets = this._encode(packet, packetOpts);
        let clientCount = 0;
        this.apply(opts, (socket) => {
          clientCount++;
          socket.acks.set(packet.id, ack);
          if (typeof socket.notifyOutgoingListeners === "function") {
            socket.notifyOutgoingListeners(packet);
          }
          socket.client.writeToEngine(encodedPackets, packetOpts);
        });
        clientCountCallback(clientCount);
      }
      _encode(packet, packetOpts) {
        const encodedPackets = this.encoder.encode(packet);
        if (canPreComputeFrame && encodedPackets.length === 1 && typeof encodedPackets[0] === "string") {
          const data = Buffer.from("4" + encodedPackets[0]);
          packetOpts.wsPreEncodedFrame = WebSocket.Sender.frame(data, {
            readOnly: false,
            mask: false,
            rsv1: false,
            opcode: 1,
            fin: true
          });
        }
        return encodedPackets;
      }
      /**
       * Gets a list of sockets by sid.
       *
       * @param {Set<Room>} rooms   the explicit set of rooms to check.
       */
      sockets(rooms) {
        const sids = /* @__PURE__ */ new Set();
        this.apply({ rooms }, (socket) => {
          sids.add(socket.id);
        });
        return Promise.resolve(sids);
      }
      /**
       * Gets the list of rooms a given socket has joined.
       *
       * @param {SocketId} id   the socket id
       */
      socketRooms(id) {
        return this.sids.get(id);
      }
      /**
       * Returns the matching socket instances
       *
       * @param opts - the filters to apply
       */
      fetchSockets(opts) {
        const sockets = [];
        this.apply(opts, (socket) => {
          sockets.push(socket);
        });
        return Promise.resolve(sockets);
      }
      /**
       * Makes the matching socket instances join the specified rooms
       *
       * @param opts - the filters to apply
       * @param rooms - the rooms to join
       */
      addSockets(opts, rooms) {
        this.apply(opts, (socket) => {
          socket.join(rooms);
        });
      }
      /**
       * Makes the matching socket instances leave the specified rooms
       *
       * @param opts - the filters to apply
       * @param rooms - the rooms to leave
       */
      delSockets(opts, rooms) {
        this.apply(opts, (socket) => {
          rooms.forEach((room) => socket.leave(room));
        });
      }
      /**
       * Makes the matching socket instances disconnect
       *
       * @param opts - the filters to apply
       * @param close - whether to close the underlying connection
       */
      disconnectSockets(opts, close) {
        this.apply(opts, (socket) => {
          socket.disconnect(close);
        });
      }
      apply(opts, callback) {
        const rooms = opts.rooms;
        const except = this.computeExceptSids(opts.except);
        if (rooms.size) {
          const ids = /* @__PURE__ */ new Set();
          for (const room of rooms) {
            if (!this.rooms.has(room))
              continue;
            for (const id of this.rooms.get(room)) {
              if (ids.has(id) || except.has(id))
                continue;
              const socket = this.nsp.sockets.get(id);
              if (socket) {
                callback(socket);
                ids.add(id);
              }
            }
          }
        } else {
          for (const [id] of this.sids) {
            if (except.has(id))
              continue;
            const socket = this.nsp.sockets.get(id);
            if (socket)
              callback(socket);
          }
        }
      }
      computeExceptSids(exceptRooms) {
        const exceptSids = /* @__PURE__ */ new Set();
        if (exceptRooms && exceptRooms.size > 0) {
          for (const room of exceptRooms) {
            if (this.rooms.has(room)) {
              this.rooms.get(room).forEach((sid) => exceptSids.add(sid));
            }
          }
        }
        return exceptSids;
      }
      /**
       * Send a packet to the other Socket.IO servers in the cluster
       * @param packet - an array of arguments, which may include an acknowledgement callback at the end
       */
      serverSideEmit(packet) {
        console.warn("this adapter does not support the serverSideEmit() functionality");
      }
      /**
       * Save the client session in order to restore it upon reconnection.
       */
      persistSession(session) {
      }
      /**
       * Restore the session and find the packets that were missed by the client.
       * @param pid
       * @param offset
       */
      restoreSession(pid, offset) {
        return null;
      }
    };
    exports2.Adapter = Adapter;
    var SessionAwareAdapter = class extends Adapter {
      constructor(nsp) {
        super(nsp);
        this.nsp = nsp;
        this.sessions = /* @__PURE__ */ new Map();
        this.packets = [];
        this.maxDisconnectionDuration = nsp.server.opts.connectionStateRecovery.maxDisconnectionDuration;
        const timer = setInterval(() => {
          const threshold = Date.now() - this.maxDisconnectionDuration;
          this.sessions.forEach((session, sessionId) => {
            const hasExpired = session.disconnectedAt < threshold;
            if (hasExpired) {
              this.sessions.delete(sessionId);
            }
          });
          for (let i = this.packets.length - 1; i >= 0; i--) {
            const hasExpired = this.packets[i].emittedAt < threshold;
            if (hasExpired) {
              this.packets.splice(0, i + 1);
              break;
            }
          }
        }, 60 * 1e3);
        timer.unref();
      }
      persistSession(session) {
        session.disconnectedAt = Date.now();
        this.sessions.set(session.pid, session);
      }
      restoreSession(pid, offset) {
        const session = this.sessions.get(pid);
        if (!session) {
          return null;
        }
        const hasExpired = session.disconnectedAt + this.maxDisconnectionDuration < Date.now();
        if (hasExpired) {
          this.sessions.delete(pid);
          return null;
        }
        const index = this.packets.findIndex((packet) => packet.id === offset);
        if (index === -1) {
          return null;
        }
        const missedPackets = [];
        for (let i = index + 1; i < this.packets.length; i++) {
          const packet = this.packets[i];
          if (shouldIncludePacket(session.rooms, packet.opts)) {
            missedPackets.push(packet.data);
          }
        }
        return Promise.resolve(Object.assign(Object.assign({}, session), { missedPackets }));
      }
      broadcast(packet, opts) {
        var _a37;
        const isEventPacket = packet.type === 2;
        const withoutAcknowledgement = packet.id === void 0;
        const notVolatile = ((_a37 = opts.flags) === null || _a37 === void 0 ? void 0 : _a37.volatile) === void 0;
        if (isEventPacket && withoutAcknowledgement && notVolatile) {
          const id = (0, yeast_1.yeast)();
          packet.data.push(id);
          this.packets.push({
            id,
            opts,
            data: packet.data,
            emittedAt: Date.now()
          });
        }
        super.broadcast(packet, opts);
      }
    };
    exports2.SessionAwareAdapter = SessionAwareAdapter;
    function shouldIncludePacket(sessionRooms, opts) {
      const included = opts.rooms.size === 0 || sessionRooms.some((room) => opts.rooms.has(room));
      const notExcluded = sessionRooms.every((room) => !opts.except.has(room));
      return included && notExcluded;
    }
  }
});

// node_modules/socket.io-adapter/dist/cluster-adapter.js
var require_cluster_adapter = __commonJS({
  "node_modules/socket.io-adapter/dist/cluster-adapter.js"(exports2) {
    "use strict";
    var __rest = exports2 && exports2.__rest || function(s, e) {
      var t = {};
      for (var p3 in s) if (Object.prototype.hasOwnProperty.call(s, p3) && e.indexOf(p3) < 0)
        t[p3] = s[p3];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p3 = Object.getOwnPropertySymbols(s); i < p3.length; i++) {
          if (e.indexOf(p3[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p3[i]))
            t[p3[i]] = s[p3[i]];
        }
      return t;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ClusterAdapterWithHeartbeat = exports2.ClusterAdapter = exports2.MessageType = void 0;
    var in_memory_adapter_1 = require_in_memory_adapter();
    var debug_1 = require_src();
    var crypto_1 = require("crypto");
    var debug = (0, debug_1.debug)("socket.io-adapter");
    var EMITTER_UID = "emitter";
    var DEFAULT_TIMEOUT = 5e3;
    function randomId() {
      return (0, crypto_1.randomBytes)(8).toString("hex");
    }
    var MessageType;
    (function(MessageType2) {
      MessageType2[MessageType2["INITIAL_HEARTBEAT"] = 1] = "INITIAL_HEARTBEAT";
      MessageType2[MessageType2["HEARTBEAT"] = 2] = "HEARTBEAT";
      MessageType2[MessageType2["BROADCAST"] = 3] = "BROADCAST";
      MessageType2[MessageType2["SOCKETS_JOIN"] = 4] = "SOCKETS_JOIN";
      MessageType2[MessageType2["SOCKETS_LEAVE"] = 5] = "SOCKETS_LEAVE";
      MessageType2[MessageType2["DISCONNECT_SOCKETS"] = 6] = "DISCONNECT_SOCKETS";
      MessageType2[MessageType2["FETCH_SOCKETS"] = 7] = "FETCH_SOCKETS";
      MessageType2[MessageType2["FETCH_SOCKETS_RESPONSE"] = 8] = "FETCH_SOCKETS_RESPONSE";
      MessageType2[MessageType2["SERVER_SIDE_EMIT"] = 9] = "SERVER_SIDE_EMIT";
      MessageType2[MessageType2["SERVER_SIDE_EMIT_RESPONSE"] = 10] = "SERVER_SIDE_EMIT_RESPONSE";
      MessageType2[MessageType2["BROADCAST_CLIENT_COUNT"] = 11] = "BROADCAST_CLIENT_COUNT";
      MessageType2[MessageType2["BROADCAST_ACK"] = 12] = "BROADCAST_ACK";
      MessageType2[MessageType2["ADAPTER_CLOSE"] = 13] = "ADAPTER_CLOSE";
    })(MessageType || (exports2.MessageType = MessageType = {}));
    function encodeOptions(opts) {
      return {
        rooms: [...opts.rooms],
        except: [...opts.except],
        flags: opts.flags
      };
    }
    function decodeOptions(opts) {
      return {
        rooms: new Set(opts.rooms),
        except: new Set(opts.except),
        flags: opts.flags
      };
    }
    var ClusterAdapter = class extends in_memory_adapter_1.Adapter {
      constructor(nsp) {
        super(nsp);
        this.requests = /* @__PURE__ */ new Map();
        this.ackRequests = /* @__PURE__ */ new Map();
        this.uid = randomId();
      }
      /**
       * Called when receiving a message from another member of the cluster.
       *
       * @param message
       * @param offset
       * @protected
       */
      onMessage(message, offset) {
        if (message.uid === this.uid) {
          return debug("[%s] ignore message from self", this.uid);
        }
        if (message.nsp !== this.nsp.name) {
          return debug("[%s] ignore message from another namespace (%s)", this.uid, message.nsp);
        }
        debug("[%s] new event of type %d from %s", this.uid, message.type, message.uid);
        switch (message.type) {
          case MessageType.BROADCAST: {
            const withAck = message.data.requestId !== void 0;
            if (withAck) {
              super.broadcastWithAck(message.data.packet, decodeOptions(message.data.opts), (clientCount) => {
                debug("[%s] waiting for %d client acknowledgements", this.uid, clientCount);
                this.publishResponse(message.uid, {
                  type: MessageType.BROADCAST_CLIENT_COUNT,
                  data: {
                    requestId: message.data.requestId,
                    clientCount
                  }
                });
              }, (arg) => {
                debug("[%s] received acknowledgement with value %j", this.uid, arg);
                this.publishResponse(message.uid, {
                  type: MessageType.BROADCAST_ACK,
                  data: {
                    requestId: message.data.requestId,
                    packet: arg
                  }
                });
              });
            } else {
              const packet = message.data.packet;
              const opts = decodeOptions(message.data.opts);
              this.addOffsetIfNecessary(packet, opts, offset);
              super.broadcast(packet, opts);
            }
            break;
          }
          case MessageType.SOCKETS_JOIN:
            super.addSockets(decodeOptions(message.data.opts), message.data.rooms);
            break;
          case MessageType.SOCKETS_LEAVE:
            super.delSockets(decodeOptions(message.data.opts), message.data.rooms);
            break;
          case MessageType.DISCONNECT_SOCKETS:
            super.disconnectSockets(decodeOptions(message.data.opts), message.data.close);
            break;
          case MessageType.FETCH_SOCKETS: {
            debug("[%s] calling fetchSockets with opts %j", this.uid, message.data.opts);
            super.fetchSockets(decodeOptions(message.data.opts)).then((localSockets) => {
              this.publishResponse(message.uid, {
                type: MessageType.FETCH_SOCKETS_RESPONSE,
                data: {
                  requestId: message.data.requestId,
                  sockets: localSockets.map((socket) => {
                    const _a31 = socket.handshake, { sessionStore } = _a31, handshake = __rest(_a31, ["sessionStore"]);
                    return {
                      id: socket.id,
                      handshake,
                      rooms: [...socket.rooms],
                      data: socket.data
                    };
                  })
                }
              });
            });
            break;
          }
          case MessageType.SERVER_SIDE_EMIT: {
            const packet = message.data.packet;
            const withAck = message.data.requestId !== void 0;
            if (!withAck) {
              this.nsp._onServerSideEmit(packet);
              return;
            }
            let called = false;
            const callback = (arg) => {
              if (called) {
                return;
              }
              called = true;
              debug("[%s] calling acknowledgement with %j", this.uid, arg);
              this.publishResponse(message.uid, {
                type: MessageType.SERVER_SIDE_EMIT_RESPONSE,
                data: {
                  requestId: message.data.requestId,
                  packet: arg
                }
              });
            };
            this.nsp._onServerSideEmit([...packet, callback]);
            break;
          }
          // @ts-ignore
          case MessageType.BROADCAST_CLIENT_COUNT:
          // @ts-ignore
          case MessageType.BROADCAST_ACK:
          // @ts-ignore
          case MessageType.FETCH_SOCKETS_RESPONSE:
          // @ts-ignore
          case MessageType.SERVER_SIDE_EMIT_RESPONSE:
            this.onResponse(message);
            break;
          default:
            debug("[%s] unknown message type: %s", this.uid, message.type);
        }
      }
      /**
       * Called when receiving a response from another member of the cluster.
       *
       * @param response
       * @protected
       */
      onResponse(response) {
        var _a31, _b27;
        const requestId = response.data.requestId;
        debug("[%s] received response %s to request %s", this.uid, response.type, requestId);
        switch (response.type) {
          case MessageType.BROADCAST_CLIENT_COUNT: {
            (_a31 = this.ackRequests.get(requestId)) === null || _a31 === void 0 ? void 0 : _a31.clientCountCallback(response.data.clientCount);
            break;
          }
          case MessageType.BROADCAST_ACK: {
            (_b27 = this.ackRequests.get(requestId)) === null || _b27 === void 0 ? void 0 : _b27.ack(response.data.packet);
            break;
          }
          case MessageType.FETCH_SOCKETS_RESPONSE: {
            const request = this.requests.get(requestId);
            if (!request) {
              return;
            }
            request.current++;
            response.data.sockets.forEach((socket) => request.responses.push(socket));
            if (request.current === request.expected) {
              clearTimeout(request.timeout);
              request.resolve(request.responses);
              this.requests.delete(requestId);
            }
            break;
          }
          case MessageType.SERVER_SIDE_EMIT_RESPONSE: {
            const request = this.requests.get(requestId);
            if (!request) {
              return;
            }
            request.current++;
            request.responses.push(response.data.packet);
            if (request.current === request.expected) {
              clearTimeout(request.timeout);
              request.resolve(null, request.responses);
              this.requests.delete(requestId);
            }
            break;
          }
          default:
            debug("[%s] unknown response type: %s", this.uid, response.type);
        }
      }
      async broadcast(packet, opts) {
        var _a31;
        const onlyLocal = (_a31 = opts.flags) === null || _a31 === void 0 ? void 0 : _a31.local;
        if (!onlyLocal) {
          try {
            const offset = await this.publishAndReturnOffset({
              type: MessageType.BROADCAST,
              data: {
                packet,
                opts: encodeOptions(opts)
              }
            });
            this.addOffsetIfNecessary(packet, opts, offset);
          } catch (e) {
            return debug("[%s] error while broadcasting message: %s", this.uid, e.message);
          }
        }
        super.broadcast(packet, opts);
      }
      /**
       * Adds an offset at the end of the data array in order to allow the client to receive any missed packets when it
       * reconnects after a temporary disconnection.
       *
       * @param packet
       * @param opts
       * @param offset
       * @private
       */
      addOffsetIfNecessary(packet, opts, offset) {
        var _a31;
        if (!this.nsp.server.opts.connectionStateRecovery) {
          return;
        }
        const isEventPacket = packet.type === 2;
        const withoutAcknowledgement = packet.id === void 0;
        const notVolatile = ((_a31 = opts.flags) === null || _a31 === void 0 ? void 0 : _a31.volatile) === void 0;
        if (isEventPacket && withoutAcknowledgement && notVolatile) {
          packet.data.push(offset);
        }
      }
      broadcastWithAck(packet, opts, clientCountCallback, ack) {
        var _a31;
        const onlyLocal = (_a31 = opts === null || opts === void 0 ? void 0 : opts.flags) === null || _a31 === void 0 ? void 0 : _a31.local;
        if (!onlyLocal) {
          const requestId = randomId();
          this.ackRequests.set(requestId, {
            clientCountCallback,
            ack
          });
          this.publish({
            type: MessageType.BROADCAST,
            data: {
              packet,
              requestId,
              opts: encodeOptions(opts)
            }
          });
          setTimeout(() => {
            this.ackRequests.delete(requestId);
          }, opts.flags.timeout);
        }
        super.broadcastWithAck(packet, opts, clientCountCallback, ack);
      }
      async addSockets(opts, rooms) {
        var _a31;
        const onlyLocal = (_a31 = opts.flags) === null || _a31 === void 0 ? void 0 : _a31.local;
        if (!onlyLocal) {
          try {
            await this.publishAndReturnOffset({
              type: MessageType.SOCKETS_JOIN,
              data: {
                opts: encodeOptions(opts),
                rooms
              }
            });
          } catch (e) {
            debug("[%s] error while publishing message: %s", this.uid, e.message);
          }
        }
        super.addSockets(opts, rooms);
      }
      async delSockets(opts, rooms) {
        var _a31;
        const onlyLocal = (_a31 = opts.flags) === null || _a31 === void 0 ? void 0 : _a31.local;
        if (!onlyLocal) {
          try {
            await this.publishAndReturnOffset({
              type: MessageType.SOCKETS_LEAVE,
              data: {
                opts: encodeOptions(opts),
                rooms
              }
            });
          } catch (e) {
            debug("[%s] error while publishing message: %s", this.uid, e.message);
          }
        }
        super.delSockets(opts, rooms);
      }
      async disconnectSockets(opts, close) {
        var _a31;
        const onlyLocal = (_a31 = opts.flags) === null || _a31 === void 0 ? void 0 : _a31.local;
        if (!onlyLocal) {
          try {
            await this.publishAndReturnOffset({
              type: MessageType.DISCONNECT_SOCKETS,
              data: {
                opts: encodeOptions(opts),
                close
              }
            });
          } catch (e) {
            debug("[%s] error while publishing message: %s", this.uid, e.message);
          }
        }
        super.disconnectSockets(opts, close);
      }
      async fetchSockets(opts) {
        var _a31;
        const [localSockets, serverCount] = await Promise.all([
          super.fetchSockets(opts),
          this.serverCount()
        ]);
        const expectedResponseCount = serverCount - 1;
        if (((_a31 = opts.flags) === null || _a31 === void 0 ? void 0 : _a31.local) || expectedResponseCount <= 0) {
          return localSockets;
        }
        const requestId = randomId();
        return new Promise((resolve3, reject) => {
          const timeout = setTimeout(() => {
            const storedRequest2 = this.requests.get(requestId);
            if (storedRequest2) {
              reject(new Error(`timeout reached: only ${storedRequest2.current} responses received out of ${storedRequest2.expected}`));
              this.requests.delete(requestId);
            }
          }, opts.flags.timeout || DEFAULT_TIMEOUT);
          const storedRequest = {
            type: MessageType.FETCH_SOCKETS,
            resolve: resolve3,
            timeout,
            current: 0,
            expected: expectedResponseCount,
            responses: localSockets
          };
          this.requests.set(requestId, storedRequest);
          this.publish({
            type: MessageType.FETCH_SOCKETS,
            data: {
              opts: encodeOptions(opts),
              requestId
            }
          });
        });
      }
      async serverSideEmit(packet) {
        const withAck = typeof packet[packet.length - 1] === "function";
        if (!withAck) {
          return this.publish({
            type: MessageType.SERVER_SIDE_EMIT,
            data: {
              packet
            }
          });
        }
        const ack = packet.pop();
        const expectedResponseCount = await this.serverCount() - 1;
        debug('[%s] waiting for %d responses to "serverSideEmit" request', this.uid, expectedResponseCount);
        if (expectedResponseCount <= 0) {
          return ack(null, []);
        }
        const requestId = randomId();
        const timeout = setTimeout(() => {
          const storedRequest2 = this.requests.get(requestId);
          if (storedRequest2) {
            ack(new Error(`timeout reached: only ${storedRequest2.current} responses received out of ${storedRequest2.expected}`), storedRequest2.responses);
            this.requests.delete(requestId);
          }
        }, DEFAULT_TIMEOUT);
        const storedRequest = {
          type: MessageType.SERVER_SIDE_EMIT,
          resolve: ack,
          timeout,
          current: 0,
          expected: expectedResponseCount,
          responses: []
        };
        this.requests.set(requestId, storedRequest);
        this.publish({
          type: MessageType.SERVER_SIDE_EMIT,
          data: {
            requestId,
            // the presence of this attribute defines whether an acknowledgement is needed
            packet
          }
        });
      }
      publish(message) {
        debug("[%s] sending message %s", this.uid, message.type);
        this.publishAndReturnOffset(message).catch((err) => {
          debug("[%s] error while publishing message: %s", this.uid, err);
        });
      }
      publishAndReturnOffset(message) {
        message.uid = this.uid;
        message.nsp = this.nsp.name;
        return this.doPublish(message);
      }
      publishResponse(requesterUid, response) {
        response.uid = this.uid;
        response.nsp = this.nsp.name;
        debug("[%s] sending response %s to %s", this.uid, response.type, requesterUid);
        this.doPublishResponse(requesterUid, response).catch((err) => {
          debug("[%s] error while publishing response: %s", this.uid, err);
        });
      }
    };
    exports2.ClusterAdapter = ClusterAdapter;
    var ClusterAdapterWithHeartbeat = class extends ClusterAdapter {
      constructor(nsp, opts) {
        super(nsp);
        this.nodesMap = /* @__PURE__ */ new Map();
        this.customRequests = /* @__PURE__ */ new Map();
        this._opts = Object.assign({
          heartbeatInterval: 5e3,
          heartbeatTimeout: 1e4
        }, opts);
        this.cleanupTimer = setInterval(() => {
          const now2 = Date.now();
          this.nodesMap.forEach((lastSeen, uid) => {
            const nodeSeemsDown = now2 - lastSeen > this._opts.heartbeatTimeout;
            if (nodeSeemsDown) {
              debug("[%s] node %s seems down", this.uid, uid);
              this.removeNode(uid);
            }
          });
        }, 1e3);
      }
      init() {
        this.publish({
          type: MessageType.INITIAL_HEARTBEAT
        });
      }
      scheduleHeartbeat() {
        if (this.heartbeatTimer) {
          this.heartbeatTimer.refresh();
        } else {
          this.heartbeatTimer = setTimeout(() => {
            this.publish({
              type: MessageType.HEARTBEAT
            });
          }, this._opts.heartbeatInterval);
        }
      }
      close() {
        this.publish({
          type: MessageType.ADAPTER_CLOSE
        });
        clearTimeout(this.heartbeatTimer);
        if (this.cleanupTimer) {
          clearInterval(this.cleanupTimer);
        }
      }
      onMessage(message, offset) {
        if (message.uid === this.uid) {
          return debug("[%s] ignore message from self", this.uid);
        }
        if (message.uid && message.uid !== EMITTER_UID) {
          this.nodesMap.set(message.uid, Date.now());
        }
        switch (message.type) {
          case MessageType.INITIAL_HEARTBEAT:
            this.publish({
              type: MessageType.HEARTBEAT
            });
            break;
          case MessageType.HEARTBEAT:
            break;
          case MessageType.ADAPTER_CLOSE:
            this.removeNode(message.uid);
            break;
          default:
            super.onMessage(message, offset);
        }
      }
      serverCount() {
        return Promise.resolve(1 + this.nodesMap.size);
      }
      publish(message) {
        this.scheduleHeartbeat();
        return super.publish(message);
      }
      async serverSideEmit(packet) {
        const withAck = typeof packet[packet.length - 1] === "function";
        if (!withAck) {
          return this.publish({
            type: MessageType.SERVER_SIDE_EMIT,
            data: {
              packet
            }
          });
        }
        const ack = packet.pop();
        const expectedResponseCount = this.nodesMap.size;
        debug('[%s] waiting for %d responses to "serverSideEmit" request', this.uid, expectedResponseCount);
        if (expectedResponseCount <= 0) {
          return ack(null, []);
        }
        const requestId = randomId();
        const timeout = setTimeout(() => {
          const storedRequest2 = this.customRequests.get(requestId);
          if (storedRequest2) {
            ack(new Error(`timeout reached: missing ${storedRequest2.missingUids.size} responses`), storedRequest2.responses);
            this.customRequests.delete(requestId);
          }
        }, DEFAULT_TIMEOUT);
        const storedRequest = {
          type: MessageType.SERVER_SIDE_EMIT,
          resolve: ack,
          timeout,
          missingUids: /* @__PURE__ */ new Set([...this.nodesMap.keys()]),
          responses: []
        };
        this.customRequests.set(requestId, storedRequest);
        this.publish({
          type: MessageType.SERVER_SIDE_EMIT,
          data: {
            requestId,
            // the presence of this attribute defines whether an acknowledgement is needed
            packet
          }
        });
      }
      async fetchSockets(opts) {
        var _a31;
        const [localSockets, serverCount] = await Promise.all([
          super.fetchSockets({
            rooms: opts.rooms,
            except: opts.except,
            flags: {
              local: true
            }
          }),
          this.serverCount()
        ]);
        const expectedResponseCount = serverCount - 1;
        if (((_a31 = opts.flags) === null || _a31 === void 0 ? void 0 : _a31.local) || expectedResponseCount <= 0) {
          return localSockets;
        }
        const requestId = randomId();
        return new Promise((resolve3, reject) => {
          const timeout = setTimeout(() => {
            const storedRequest2 = this.customRequests.get(requestId);
            if (storedRequest2) {
              reject(new Error(`timeout reached: missing ${storedRequest2.missingUids.size} responses`));
              this.customRequests.delete(requestId);
            }
          }, opts.flags.timeout || DEFAULT_TIMEOUT);
          const storedRequest = {
            type: MessageType.FETCH_SOCKETS,
            resolve: resolve3,
            timeout,
            missingUids: /* @__PURE__ */ new Set([...this.nodesMap.keys()]),
            responses: localSockets
          };
          this.customRequests.set(requestId, storedRequest);
          this.publish({
            type: MessageType.FETCH_SOCKETS,
            data: {
              opts: encodeOptions(opts),
              requestId
            }
          });
        });
      }
      onResponse(response) {
        const requestId = response.data.requestId;
        debug("[%s] received response %s to request %s", this.uid, response.type, requestId);
        switch (response.type) {
          case MessageType.FETCH_SOCKETS_RESPONSE: {
            const request = this.customRequests.get(requestId);
            if (!request) {
              return;
            }
            response.data.sockets.forEach((socket) => request.responses.push(socket));
            request.missingUids.delete(response.uid);
            if (request.missingUids.size === 0) {
              clearTimeout(request.timeout);
              request.resolve(request.responses);
              this.customRequests.delete(requestId);
            }
            break;
          }
          case MessageType.SERVER_SIDE_EMIT_RESPONSE: {
            const request = this.customRequests.get(requestId);
            if (!request) {
              return;
            }
            request.responses.push(response.data.packet);
            request.missingUids.delete(response.uid);
            if (request.missingUids.size === 0) {
              clearTimeout(request.timeout);
              request.resolve(null, request.responses);
              this.customRequests.delete(requestId);
            }
            break;
          }
          default:
            super.onResponse(response);
        }
      }
      removeNode(uid) {
        this.customRequests.forEach((request, requestId) => {
          request.missingUids.delete(uid);
          if (request.missingUids.size === 0) {
            clearTimeout(request.timeout);
            if (request.type === MessageType.FETCH_SOCKETS) {
              request.resolve(request.responses);
            } else if (request.type === MessageType.SERVER_SIDE_EMIT) {
              request.resolve(null, request.responses);
            }
            this.customRequests.delete(requestId);
          }
        });
        this.nodesMap.delete(uid);
      }
    };
    exports2.ClusterAdapterWithHeartbeat = ClusterAdapterWithHeartbeat;
  }
});

// node_modules/socket.io-adapter/dist/index.js
var require_dist2 = __commonJS({
  "node_modules/socket.io-adapter/dist/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.MessageType = exports2.ClusterAdapterWithHeartbeat = exports2.ClusterAdapter = exports2.SessionAwareAdapter = exports2.Adapter = void 0;
    var in_memory_adapter_1 = require_in_memory_adapter();
    Object.defineProperty(exports2, "Adapter", { enumerable: true, get: function() {
      return in_memory_adapter_1.Adapter;
    } });
    Object.defineProperty(exports2, "SessionAwareAdapter", { enumerable: true, get: function() {
      return in_memory_adapter_1.SessionAwareAdapter;
    } });
    var cluster_adapter_1 = require_cluster_adapter();
    Object.defineProperty(exports2, "ClusterAdapter", { enumerable: true, get: function() {
      return cluster_adapter_1.ClusterAdapter;
    } });
    Object.defineProperty(exports2, "ClusterAdapterWithHeartbeat", { enumerable: true, get: function() {
      return cluster_adapter_1.ClusterAdapterWithHeartbeat;
    } });
    Object.defineProperty(exports2, "MessageType", { enumerable: true, get: function() {
      return cluster_adapter_1.MessageType;
    } });
  }
});

// node_modules/socket.io/dist/parent-namespace.js
var require_parent_namespace = __commonJS({
  "node_modules/socket.io/dist/parent-namespace.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ParentNamespace = void 0;
    var namespace_1 = require_namespace();
    var socket_io_adapter_1 = require_dist2();
    var debug_1 = __importDefault(require_src());
    var debug = (0, debug_1.default)("socket.io:parent-namespace");
    var ParentNamespace = class _ParentNamespace extends namespace_1.Namespace {
      constructor(server2) {
        super(server2, "/_" + _ParentNamespace.count++);
        this.children = /* @__PURE__ */ new Set();
      }
      /**
       * @private
       */
      _initAdapter() {
        this.adapter = new ParentBroadcastAdapter(this);
      }
      emit(ev, ...args) {
        this.children.forEach((nsp) => {
          nsp.emit(ev, ...args);
        });
        return true;
      }
      createChild(name28) {
        debug("creating child namespace %s", name28);
        const namespace = new namespace_1.Namespace(this.server, name28);
        this["_fns"].forEach((fn) => namespace.use(fn));
        this.listeners("connect").forEach((listener) => namespace.on("connect", listener));
        this.listeners("connection").forEach((listener) => namespace.on("connection", listener));
        this.children.add(namespace);
        if (this.server._opts.cleanupEmptyChildNamespaces) {
          const remove = namespace._remove;
          namespace._remove = (socket) => {
            remove.call(namespace, socket);
            if (namespace.sockets.size === 0) {
              debug("closing child namespace %s", name28);
              namespace.adapter.close();
              this.server._nsps.delete(namespace.name);
              this.children.delete(namespace);
            }
          };
        }
        this.server._nsps.set(name28, namespace);
        this.server.sockets.emitReserved("new_namespace", namespace);
        return namespace;
      }
      fetchSockets() {
        throw new Error("fetchSockets() is not supported on parent namespaces");
      }
    };
    exports2.ParentNamespace = ParentNamespace;
    ParentNamespace.count = 0;
    var ParentBroadcastAdapter = class extends socket_io_adapter_1.Adapter {
      broadcast(packet, opts) {
        this.nsp.children.forEach((nsp) => {
          nsp.adapter.broadcast(packet, opts);
        });
      }
    };
  }
});

// node_modules/socket.io/dist/uws.js
var require_uws = __commonJS({
  "node_modules/socket.io/dist/uws.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.patchAdapter = patchAdapter;
    exports2.restoreAdapter = restoreAdapter;
    exports2.serveFile = serveFile;
    var socket_io_adapter_1 = require_dist2();
    var fs_1 = require("fs");
    var debug_1 = __importDefault(require_src());
    var debug = (0, debug_1.default)("socket.io:adapter-uws");
    var SEPARATOR = "";
    var { addAll, del, broadcast } = socket_io_adapter_1.Adapter.prototype;
    function patchAdapter(app2) {
      socket_io_adapter_1.Adapter.prototype.addAll = function(id, rooms) {
        const isNew = !this.sids.has(id);
        addAll.call(this, id, rooms);
        const socket = this.nsp.sockets.get(id) || this.nsp._preConnectSockets.get(id);
        if (!socket) {
          return;
        }
        if (socket.conn.transport.name === "websocket") {
          subscribe(this.nsp.name, socket, isNew, rooms);
          return;
        }
        if (isNew) {
          socket.conn.on("upgrade", () => {
            const rooms2 = this.sids.get(id);
            if (rooms2) {
              subscribe(this.nsp.name, socket, isNew, rooms2);
            }
          });
        }
      };
      socket_io_adapter_1.Adapter.prototype.del = function(id, room) {
        del.call(this, id, room);
        const socket = this.nsp.sockets.get(id) || this.nsp._preConnectSockets.get(id);
        if (socket && socket.conn.transport.name === "websocket") {
          const sessionId = socket.conn.id;
          const websocket = socket.conn.transport.socket;
          const topic = `${this.nsp.name}${SEPARATOR}${room}`;
          debug("unsubscribe connection %s from topic %s", sessionId, topic);
          websocket.unsubscribe(topic);
        }
      };
      socket_io_adapter_1.Adapter.prototype.broadcast = function(packet, opts) {
        const useFastPublish = opts.rooms.size <= 1 && opts.except.size === 0;
        if (!useFastPublish) {
          broadcast.call(this, packet, opts);
          return;
        }
        const flags = opts.flags || {};
        const basePacketOpts = {
          preEncoded: true,
          volatile: flags.volatile,
          compress: flags.compress
        };
        packet.nsp = this.nsp.name;
        const encodedPackets = this.encoder.encode(packet);
        const topic = opts.rooms.size === 0 ? this.nsp.name : `${this.nsp.name}${SEPARATOR}${opts.rooms.keys().next().value}`;
        debug("fast publish to %s", topic);
        encodedPackets.forEach((encodedPacket) => {
          const isBinary = typeof encodedPacket !== "string";
          app2.publish(topic, isBinary ? encodedPacket : "4" + encodedPacket, isBinary);
        });
        this.apply(opts, (socket) => {
          if (socket.conn.transport.name !== "websocket") {
            socket.client.writeToEngine(encodedPackets, basePacketOpts);
          }
        });
      };
    }
    function subscribe(namespaceName, socket, isNew, rooms) {
      const sessionId = socket.conn.id;
      const websocket = socket.conn.transport.socket;
      if (isNew) {
        debug("subscribe connection %s to topic %s", sessionId, namespaceName);
        websocket.subscribe(namespaceName);
      }
      rooms.forEach((room) => {
        const topic = `${namespaceName}${SEPARATOR}${room}`;
        debug("subscribe connection %s to topic %s", sessionId, topic);
        websocket.subscribe(topic);
      });
    }
    function restoreAdapter() {
      socket_io_adapter_1.Adapter.prototype.addAll = addAll;
      socket_io_adapter_1.Adapter.prototype.del = del;
      socket_io_adapter_1.Adapter.prototype.broadcast = broadcast;
    }
    var toArrayBuffer = (buffer) => {
      const { buffer: arrayBuffer, byteOffset, byteLength } = buffer;
      return arrayBuffer.slice(byteOffset, byteOffset + byteLength);
    };
    function serveFile(res, filepath) {
      const { size } = (0, fs_1.statSync)(filepath);
      const readStream2 = (0, fs_1.createReadStream)(filepath);
      const destroyReadStream = () => !readStream2.destroyed && readStream2.destroy();
      const onError = (error73) => {
        destroyReadStream();
        throw error73;
      };
      const onDataChunk = (chunk) => {
        const arrayBufferChunk = toArrayBuffer(chunk);
        res.cork(() => {
          const lastOffset = res.getWriteOffset();
          const [ok, done] = res.tryEnd(arrayBufferChunk, size);
          if (!done && !ok) {
            readStream2.pause();
            res.onWritable((offset) => {
              const [ok2, done2] = res.tryEnd(arrayBufferChunk.slice(offset - lastOffset), size);
              if (!done2 && ok2) {
                readStream2.resume();
              }
              return ok2;
            });
          }
        });
      };
      res.onAborted(destroyReadStream);
      readStream2.on("data", onDataChunk).on("error", onError).on("end", destroyReadStream);
    }
  }
});

// node_modules/socket.io/package.json
var require_package2 = __commonJS({
  "node_modules/socket.io/package.json"(exports2, module2) {
    module2.exports = {
      name: "socket.io",
      version: "4.8.3",
      description: "node.js realtime framework server",
      keywords: [
        "realtime",
        "framework",
        "websocket",
        "tcp",
        "events",
        "socket",
        "io"
      ],
      files: [
        "dist/",
        "client-dist/",
        "wrapper.mjs",
        "!**/*.tsbuildinfo"
      ],
      directories: {
        doc: "docs/",
        example: "example/",
        lib: "lib/",
        test: "test/"
      },
      type: "commonjs",
      main: "./dist/index.js",
      exports: {
        ".": {
          types: "./dist/index.d.ts",
          import: "./wrapper.mjs",
          require: "./dist/index.js"
        },
        "./package.json": "./package.json"
      },
      types: "./dist/index.d.ts",
      license: "MIT",
      homepage: "https://github.com/socketio/socket.io/tree/main/packages/socket.io#readme",
      repository: {
        type: "git",
        url: "git+https://github.com/socketio/socket.io.git"
      },
      bugs: {
        url: "https://github.com/socketio/socket.io/issues"
      },
      scripts: {
        compile: "rimraf ./dist && tsc",
        test: "npm run format:check && npm run compile && npm run test:types && npm run test:unit",
        "test:types": "tsd",
        "test:unit": "nyc mocha --import=tsx --reporter spec --slow 200 --bail --timeout 10000 test/index.ts",
        "format:check": 'prettier --check "lib/**/*.ts" "test/**/*.ts"',
        "format:fix": 'prettier --write "lib/**/*.ts" "test/**/*.ts"',
        prepack: "npm run compile"
      },
      dependencies: {
        accepts: "~1.3.4",
        base64id: "~2.0.0",
        cors: "~2.8.5",
        debug: "~4.4.1",
        "engine.io": "~6.6.0",
        "socket.io-adapter": "~2.5.2",
        "socket.io-parser": "~4.2.4"
      },
      contributors: [
        {
          name: "Guillermo Rauch",
          email: "rauchg@gmail.com"
        },
        {
          name: "Arnout Kazemier",
          email: "info@3rd-eden.com"
        },
        {
          name: "Vladimir Dronnikov",
          email: "dronnikov@gmail.com"
        },
        {
          name: "Einar Otto Stangvik",
          email: "einaros@gmail.com"
        }
      ],
      engines: {
        node: ">=10.2.0"
      },
      tsd: {
        directory: "test"
      }
    };
  }
});

// node_modules/socket.io/dist/index.js
var require_dist3 = __commonJS({
  "node_modules/socket.io/dist/index.js"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Namespace = exports2.Socket = exports2.Server = void 0;
    var http_1 = __importDefault(require("http"));
    var fs_1 = require("fs");
    var zlib_1 = require("zlib");
    var accepts = require_accepts2();
    var stream_1 = require("stream");
    var path33 = require("path");
    var engine_io_1 = require_engine_io();
    var client_1 = require_client();
    var events_1 = require("events");
    var namespace_1 = require_namespace();
    Object.defineProperty(exports2, "Namespace", { enumerable: true, get: function() {
      return namespace_1.Namespace;
    } });
    var parent_namespace_1 = require_parent_namespace();
    var socket_io_adapter_1 = require_dist2();
    var parser = __importStar(require_cjs3());
    var debug_1 = __importDefault(require_src());
    var socket_1 = require_socket2();
    Object.defineProperty(exports2, "Socket", { enumerable: true, get: function() {
      return socket_1.Socket;
    } });
    var typed_events_1 = require_typed_events();
    var uws_1 = require_uws();
    var cors_1 = __importDefault(require_lib3());
    var debug = (0, debug_1.default)("socket.io:server");
    var clientVersion = require_package2().version;
    var dotMapRegex = /\.map/;
    var Server2 = class _Server extends typed_events_1.StrictEventEmitter {
      constructor(srv, opts = {}) {
        super();
        this._nsps = /* @__PURE__ */ new Map();
        this.parentNsps = /* @__PURE__ */ new Map();
        this.parentNamespacesFromRegExp = /* @__PURE__ */ new Map();
        if ("object" === typeof srv && srv instanceof Object && !srv.listen) {
          opts = srv;
          srv = void 0;
        }
        this.path(opts.path || "/socket.io");
        this.connectTimeout(opts.connectTimeout || 45e3);
        this.serveClient(false !== opts.serveClient);
        this._parser = opts.parser || parser;
        this.encoder = new this._parser.Encoder();
        this.opts = opts;
        if (opts.connectionStateRecovery) {
          opts.connectionStateRecovery = Object.assign({
            maxDisconnectionDuration: 2 * 60 * 1e3,
            skipMiddlewares: true
          }, opts.connectionStateRecovery);
          this.adapter(opts.adapter || socket_io_adapter_1.SessionAwareAdapter);
        } else {
          this.adapter(opts.adapter || socket_io_adapter_1.Adapter);
        }
        opts.cleanupEmptyChildNamespaces = !!opts.cleanupEmptyChildNamespaces;
        this.sockets = this.of("/");
        if (srv || typeof srv == "number")
          this.attach(srv);
        if (this.opts.cors) {
          this._corsMiddleware = (0, cors_1.default)(this.opts.cors);
        }
      }
      get _opts() {
        return this.opts;
      }
      serveClient(v) {
        if (!arguments.length)
          return this._serveClient;
        this._serveClient = v;
        return this;
      }
      /**
       * Executes the middleware for an incoming namespace not already created on the server.
       *
       * @param name - name of incoming namespace
       * @param auth - the auth parameters
       * @param fn - callback
       *
       * @private
       */
      _checkNamespace(name28, auth, fn) {
        if (this.parentNsps.size === 0)
          return fn(false);
        const keysIterator = this.parentNsps.keys();
        const run = () => {
          const nextFn = keysIterator.next();
          if (nextFn.done) {
            return fn(false);
          }
          nextFn.value(name28, auth, (err, allow) => {
            if (err || !allow) {
              return run();
            }
            if (this._nsps.has(name28)) {
              debug("dynamic namespace %s already exists", name28);
              return fn(this._nsps.get(name28));
            }
            const namespace = this.parentNsps.get(nextFn.value).createChild(name28);
            debug("dynamic namespace %s was created", name28);
            fn(namespace);
          });
        };
        run();
      }
      path(v) {
        if (!arguments.length)
          return this._path;
        this._path = v.replace(/\/$/, "");
        const escapedPath = this._path.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
        this.clientPathRegex = new RegExp("^" + escapedPath + "/socket\\.io(\\.msgpack|\\.esm)?(\\.min)?\\.js(\\.map)?(?:\\?|$)");
        return this;
      }
      connectTimeout(v) {
        if (v === void 0)
          return this._connectTimeout;
        this._connectTimeout = v;
        return this;
      }
      adapter(v) {
        if (!arguments.length)
          return this._adapter;
        this._adapter = v;
        for (const nsp of this._nsps.values()) {
          nsp._initAdapter();
        }
        return this;
      }
      /**
       * Attaches socket.io to a server or port.
       *
       * @param srv - server or port
       * @param opts - options passed to engine.io
       * @return self
       */
      listen(srv, opts = {}) {
        return this.attach(srv, opts);
      }
      /**
       * Attaches socket.io to a server or port.
       *
       * @param srv - server or port
       * @param opts - options passed to engine.io
       * @return self
       */
      attach(srv, opts = {}) {
        if ("function" == typeof srv) {
          const msg = "You are trying to attach socket.io to an express request handler function. Please pass a http.Server instance.";
          throw new Error(msg);
        }
        if (Number(srv) == srv) {
          srv = Number(srv);
        }
        if ("number" == typeof srv) {
          debug("creating http server and binding to %d", srv);
          const port = srv;
          srv = http_1.default.createServer((req, res) => {
            res.writeHead(404);
            res.end();
          });
          srv.listen(port);
        }
        Object.assign(opts, this.opts);
        opts.path = opts.path || this._path;
        this.initEngine(srv, opts);
        return this;
      }
      /**
       * Attaches socket.io to a uWebSockets.js app.
       * @param app
       * @param opts
       */
      attachApp(app2, opts = {}) {
        Object.assign(opts, this.opts);
        opts.path = opts.path || this._path;
        debug("creating uWebSockets.js-based engine with opts %j", opts);
        const engine = new engine_io_1.uServer(opts);
        engine.attach(app2, opts);
        this.bind(engine);
        if (this._serveClient) {
          app2.get(`${this._path}/*`, (res, req) => {
            if (!this.clientPathRegex.test(req.getUrl())) {
              req.setYield(true);
              return;
            }
            const filename = req.getUrl().replace(this._path, "").replace(/\?.*$/, "").replace(/^\//, "");
            const isMap = dotMapRegex.test(filename);
            const type = isMap ? "map" : "source";
            const expectedEtag = '"' + clientVersion + '"';
            const weakEtag = "W/" + expectedEtag;
            const etag = req.getHeader("if-none-match");
            if (etag) {
              if (expectedEtag === etag || weakEtag === etag) {
                debug("serve client %s 304", type);
                res.writeStatus("304 Not Modified");
                res.end();
                return;
              }
            }
            debug("serve client %s", type);
            res.writeHeader("cache-control", "public, max-age=0");
            res.writeHeader("content-type", "application/" + (isMap ? "json" : "javascript") + "; charset=utf-8");
            res.writeHeader("etag", expectedEtag);
            const filepath = path33.join(__dirname, "../client-dist/", filename);
            (0, uws_1.serveFile)(res, filepath);
          });
        }
        (0, uws_1.patchAdapter)(app2);
      }
      /**
       * Initialize engine
       *
       * @param srv - the server to attach to
       * @param opts - options passed to engine.io
       * @private
       */
      initEngine(srv, opts) {
        debug("creating engine.io instance with opts %j", opts);
        this.eio = (0, engine_io_1.attach)(srv, opts);
        if (this._serveClient)
          this.attachServe(srv);
        this.httpServer = srv;
        this.bind(this.eio);
      }
      /**
       * Attaches the static file serving.
       *
       * @param srv http server
       * @private
       */
      attachServe(srv) {
        debug("attaching client serving req handler");
        const evs = srv.listeners("request").slice(0);
        srv.removeAllListeners("request");
        srv.on("request", (req, res) => {
          if (this.clientPathRegex.test(req.url)) {
            if (this._corsMiddleware) {
              this._corsMiddleware(req, res, () => {
                this.serve(req, res);
              });
            } else {
              this.serve(req, res);
            }
          } else {
            for (let i = 0; i < evs.length; i++) {
              evs[i].call(srv, req, res);
            }
          }
        });
      }
      /**
       * Handles a request serving of client source and map
       *
       * @param req
       * @param res
       * @private
       */
      serve(req, res) {
        const filename = req.url.replace(this._path, "").replace(/\?.*$/, "");
        const isMap = dotMapRegex.test(filename);
        const type = isMap ? "map" : "source";
        const expectedEtag = '"' + clientVersion + '"';
        const weakEtag = "W/" + expectedEtag;
        const etag = req.headers["if-none-match"];
        if (etag) {
          if (expectedEtag === etag || weakEtag === etag) {
            debug("serve client %s 304", type);
            res.writeHead(304);
            res.end();
            return;
          }
        }
        debug("serve client %s", type);
        res.setHeader("Cache-Control", "public, max-age=0");
        res.setHeader("Content-Type", "application/" + (isMap ? "json" : "javascript") + "; charset=utf-8");
        res.setHeader("ETag", expectedEtag);
        _Server.sendFile(filename, req, res);
      }
      /**
       * @param filename
       * @param req
       * @param res
       * @private
       */
      static sendFile(filename, req, res) {
        const readStream2 = (0, fs_1.createReadStream)(path33.join(__dirname, "../client-dist/", filename));
        const encoding = accepts(req).encodings(["br", "gzip", "deflate"]);
        const onError = (err) => {
          if (err) {
            res.end();
          }
        };
        switch (encoding) {
          case "br":
            res.writeHead(200, { "content-encoding": "br" });
            (0, stream_1.pipeline)(readStream2, (0, zlib_1.createBrotliCompress)(), res, onError);
            break;
          case "gzip":
            res.writeHead(200, { "content-encoding": "gzip" });
            (0, stream_1.pipeline)(readStream2, (0, zlib_1.createGzip)(), res, onError);
            break;
          case "deflate":
            res.writeHead(200, { "content-encoding": "deflate" });
            (0, stream_1.pipeline)(readStream2, (0, zlib_1.createDeflate)(), res, onError);
            break;
          default:
            res.writeHead(200);
            (0, stream_1.pipeline)(readStream2, res, onError);
        }
      }
      /**
       * Binds socket.io to an engine.io instance.
       *
       * @param engine engine.io (or compatible) server
       * @return self
       */
      bind(engine) {
        this.engine = engine;
        this.engine.on("connection", this.onconnection.bind(this));
        return this;
      }
      /**
       * Called with each incoming transport connection.
       *
       * @param {engine.Socket} conn
       * @return self
       * @private
       */
      onconnection(conn) {
        debug("incoming connection with id %s", conn.id);
        const client = new client_1.Client(this, conn);
        if (conn.protocol === 3) {
          client.connect("/");
        }
        return this;
      }
      /**
       * Looks up a namespace.
       *
       * @example
       * // with a simple string
       * const myNamespace = io.of("/my-namespace");
       *
       * // with a regex
       * const dynamicNsp = io.of(/^\/dynamic-\d+$/).on("connection", (socket) => {
       *   const namespace = socket.nsp; // newNamespace.name === "/dynamic-101"
       *
       *   // broadcast to all clients in the given sub-namespace
       *   namespace.emit("hello");
       * });
       *
       * @param name - nsp name
       * @param fn optional, nsp `connection` ev handler
       */
      of(name28, fn) {
        if (typeof name28 === "function" || name28 instanceof RegExp) {
          const parentNsp = new parent_namespace_1.ParentNamespace(this);
          debug("initializing parent namespace %s", parentNsp.name);
          if (typeof name28 === "function") {
            this.parentNsps.set(name28, parentNsp);
          } else {
            this.parentNsps.set((nsp2, conn, next) => next(null, name28.test(nsp2)), parentNsp);
            this.parentNamespacesFromRegExp.set(name28, parentNsp);
          }
          if (fn) {
            parentNsp.on("connect", fn);
          }
          return parentNsp;
        }
        if (String(name28)[0] !== "/")
          name28 = "/" + name28;
        let nsp = this._nsps.get(name28);
        if (!nsp) {
          for (const [regex, parentNamespace] of this.parentNamespacesFromRegExp) {
            if (regex.test(name28)) {
              debug("attaching namespace %s to parent namespace %s", name28, regex);
              return parentNamespace.createChild(name28);
            }
          }
          debug("initializing namespace %s", name28);
          nsp = new namespace_1.Namespace(this, name28);
          this._nsps.set(name28, nsp);
          if (name28 !== "/") {
            this.sockets.emitReserved("new_namespace", nsp);
          }
        }
        if (fn)
          nsp.on("connect", fn);
        return nsp;
      }
      /**
       * Closes server connection
       *
       * @param [fn] optional, called as `fn([err])` on error OR all conns closed
       */
      async close(fn) {
        await Promise.allSettled([...this._nsps.values()].map(async (nsp) => {
          nsp.sockets.forEach((socket) => {
            socket._onclose("server shutting down");
          });
          await nsp.adapter.close();
        }));
        this.engine.close();
        (0, uws_1.restoreAdapter)();
        if (this.httpServer) {
          return new Promise((resolve3) => {
            this.httpServer.close((err) => {
              fn && fn(err);
              if (err) {
                debug("server was not running");
              }
              resolve3();
            });
          });
        } else {
          fn && fn();
        }
      }
      /**
       * Registers a middleware, which is a function that gets executed for every incoming {@link Socket}.
       *
       * @example
       * io.use((socket, next) => {
       *   // ...
       *   next();
       * });
       *
       * @param fn - the middleware function
       */
      use(fn) {
        this.sockets.use(fn);
        return this;
      }
      /**
       * Targets a room when emitting.
       *
       * @example
       * // the “foo” event will be broadcast to all connected clients in the “room-101” room
       * io.to("room-101").emit("foo", "bar");
       *
       * // with an array of rooms (a client will be notified at most once)
       * io.to(["room-101", "room-102"]).emit("foo", "bar");
       *
       * // with multiple chained calls
       * io.to("room-101").to("room-102").emit("foo", "bar");
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      to(room) {
        return this.sockets.to(room);
      }
      /**
       * Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
       *
       * @example
       * // disconnect all clients in the "room-101" room
       * io.in("room-101").disconnectSockets();
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      in(room) {
        return this.sockets.in(room);
      }
      /**
       * Excludes a room when emitting.
       *
       * @example
       * // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
       * io.except("room-101").emit("foo", "bar");
       *
       * // with an array of rooms
       * io.except(["room-101", "room-102"]).emit("foo", "bar");
       *
       * // with multiple chained calls
       * io.except("room-101").except("room-102").emit("foo", "bar");
       *
       * @param room - a room, or an array of rooms
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      except(room) {
        return this.sockets.except(room);
      }
      /**
       * Sends a `message` event to all clients.
       *
       * This method mimics the WebSocket.send() method.
       *
       * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
       *
       * @example
       * io.send("hello");
       *
       * // this is equivalent to
       * io.emit("message", "hello");
       *
       * @return self
       */
      send(...args) {
        this.sockets.emit("message", ...args);
        return this;
      }
      /**
       * Sends a `message` event to all clients. Alias of {@link send}.
       *
       * @return self
       */
      write(...args) {
        this.sockets.emit("message", ...args);
        return this;
      }
      /**
       * Sends a message to the other Socket.IO servers of the cluster.
       *
       * @example
       * io.serverSideEmit("hello", "world");
       *
       * io.on("hello", (arg1) => {
       *   console.log(arg1); // prints "world"
       * });
       *
       * // acknowledgements (without binary content) are supported too:
       * io.serverSideEmit("ping", (err, responses) => {
       *  if (err) {
       *     // some servers did not acknowledge the event in the given delay
       *   } else {
       *     console.log(responses); // one response per server (except the current one)
       *   }
       * });
       *
       * io.on("ping", (cb) => {
       *   cb("pong");
       * });
       *
       * @param ev - the event name
       * @param args - an array of arguments, which may include an acknowledgement callback at the end
       */
      serverSideEmit(ev, ...args) {
        return this.sockets.serverSideEmit(ev, ...args);
      }
      /**
       * Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster.
       *
       * @example
       * try {
       *   const responses = await io.serverSideEmitWithAck("ping");
       *   console.log(responses); // one response per server (except the current one)
       * } catch (e) {
       *   // some servers did not acknowledge the event in the given delay
       * }
       *
       * @param ev - the event name
       * @param args - an array of arguments
       *
       * @return a Promise that will be fulfilled when all servers have acknowledged the event
       */
      serverSideEmitWithAck(ev, ...args) {
        return this.sockets.serverSideEmitWithAck(ev, ...args);
      }
      /**
       * Gets a list of socket ids.
       *
       * @deprecated this method will be removed in the next major release, please use {@link Server#serverSideEmit} or
       * {@link Server#fetchSockets} instead.
       */
      allSockets() {
        return this.sockets.allSockets();
      }
      /**
       * Sets the compress flag.
       *
       * @example
       * io.compress(false).emit("hello");
       *
       * @param compress - if `true`, compresses the sending data
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      compress(compress) {
        return this.sockets.compress(compress);
      }
      /**
       * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
       * receive messages (because of network slowness or other issues, or because they’re connected through long polling
       * and is in the middle of a request-response cycle).
       *
       * @example
       * io.volatile.emit("hello"); // the clients may or may not receive it
       *
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      get volatile() {
        return this.sockets.volatile;
      }
      /**
       * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
       *
       * @example
       * // the “foo” event will be broadcast to all connected clients on this node
       * io.local.emit("foo", "bar");
       *
       * @return a new {@link BroadcastOperator} instance for chaining
       */
      get local() {
        return this.sockets.local;
      }
      /**
       * Adds a timeout in milliseconds for the next operation.
       *
       * @example
       * io.timeout(1000).emit("some-event", (err, responses) => {
       *   if (err) {
       *     // some clients did not acknowledge the event in the given delay
       *   } else {
       *     console.log(responses); // one response per client
       *   }
       * });
       *
       * @param timeout
       */
      timeout(timeout) {
        return this.sockets.timeout(timeout);
      }
      /**
       * Returns the matching socket instances.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * // return all Socket instances
       * const sockets = await io.fetchSockets();
       *
       * // return all Socket instances in the "room1" room
       * const sockets = await io.in("room1").fetchSockets();
       *
       * for (const socket of sockets) {
       *   console.log(socket.id);
       *   console.log(socket.handshake);
       *   console.log(socket.rooms);
       *   console.log(socket.data);
       *
       *   socket.emit("hello");
       *   socket.join("room1");
       *   socket.leave("room2");
       *   socket.disconnect();
       * }
       */
      fetchSockets() {
        return this.sockets.fetchSockets();
      }
      /**
       * Makes the matching socket instances join the specified rooms.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       *
       * // make all socket instances join the "room1" room
       * io.socketsJoin("room1");
       *
       * // make all socket instances in the "room1" room join the "room2" and "room3" rooms
       * io.in("room1").socketsJoin(["room2", "room3"]);
       *
       * @param room - a room, or an array of rooms
       */
      socketsJoin(room) {
        return this.sockets.socketsJoin(room);
      }
      /**
       * Makes the matching socket instances leave the specified rooms.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * // make all socket instances leave the "room1" room
       * io.socketsLeave("room1");
       *
       * // make all socket instances in the "room1" room leave the "room2" and "room3" rooms
       * io.in("room1").socketsLeave(["room2", "room3"]);
       *
       * @param room - a room, or an array of rooms
       */
      socketsLeave(room) {
        return this.sockets.socketsLeave(room);
      }
      /**
       * Makes the matching socket instances disconnect.
       *
       * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
       *
       * @example
       * // make all socket instances disconnect (the connections might be kept alive for other namespaces)
       * io.disconnectSockets();
       *
       * // make all socket instances in the "room1" room disconnect and close the underlying connections
       * io.in("room1").disconnectSockets(true);
       *
       * @param close - whether to close the underlying connection
       */
      disconnectSockets(close = false) {
        return this.sockets.disconnectSockets(close);
      }
    };
    exports2.Server = Server2;
    var emitterMethods = Object.keys(events_1.EventEmitter.prototype).filter(function(key) {
      return typeof events_1.EventEmitter.prototype[key] === "function";
    });
    emitterMethods.forEach(function(fn) {
      Server2.prototype[fn] = function() {
        return this.sockets[fn].apply(this.sockets, arguments);
      };
    });
    module2.exports = (srv, opts) => new Server2(srv, opts);
    module2.exports.Server = Server2;
    module2.exports.Namespace = namespace_1.Namespace;
    module2.exports.Socket = socket_1.Socket;
  }
});

// node_modules/express-ws/node_modules/ws/lib/constants.js
var require_constants2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/constants.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
      GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
      kStatusCode: /* @__PURE__ */ Symbol("status-code"),
      kWebSocket: /* @__PURE__ */ Symbol("websocket"),
      EMPTY_BUFFER: Buffer.alloc(0),
      NOOP: () => {
      }
    };
  }
});

// node_modules/express-ws/node_modules/ws/lib/buffer-util.js
var require_buffer_util2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/buffer-util.js"(exports2, module2) {
    "use strict";
    var { EMPTY_BUFFER } = require_constants2();
    function concat(list2, totalLength) {
      if (list2.length === 0) return EMPTY_BUFFER;
      if (list2.length === 1) return list2[0];
      const target = Buffer.allocUnsafe(totalLength);
      let offset = 0;
      for (let i = 0; i < list2.length; i++) {
        const buf = list2[i];
        target.set(buf, offset);
        offset += buf.length;
      }
      if (offset < totalLength) return target.slice(0, offset);
      return target;
    }
    function _mask(source, mask, output, offset, length) {
      for (let i = 0; i < length; i++) {
        output[offset + i] = source[i] ^ mask[i & 3];
      }
    }
    function _unmask(buffer, mask) {
      const length = buffer.length;
      for (let i = 0; i < length; i++) {
        buffer[i] ^= mask[i & 3];
      }
    }
    function toArrayBuffer(buf) {
      if (buf.byteLength === buf.buffer.byteLength) {
        return buf.buffer;
      }
      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
    }
    function toBuffer(data) {
      toBuffer.readOnly = true;
      if (Buffer.isBuffer(data)) return data;
      let buf;
      if (data instanceof ArrayBuffer) {
        buf = Buffer.from(data);
      } else if (ArrayBuffer.isView(data)) {
        buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
      } else {
        buf = Buffer.from(data);
        toBuffer.readOnly = false;
      }
      return buf;
    }
    try {
      const bufferUtil = require("bufferutil");
      const bu = bufferUtil.BufferUtil || bufferUtil;
      module2.exports = {
        concat,
        mask(source, mask, output, offset, length) {
          if (length < 48) _mask(source, mask, output, offset, length);
          else bu.mask(source, mask, output, offset, length);
        },
        toArrayBuffer,
        toBuffer,
        unmask(buffer, mask) {
          if (buffer.length < 32) _unmask(buffer, mask);
          else bu.unmask(buffer, mask);
        }
      };
    } catch (e) {
      module2.exports = {
        concat,
        mask: _mask,
        toArrayBuffer,
        toBuffer,
        unmask: _unmask
      };
    }
  }
});

// node_modules/express-ws/node_modules/ws/lib/limiter.js
var require_limiter2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/limiter.js"(exports2, module2) {
    "use strict";
    var kDone = /* @__PURE__ */ Symbol("kDone");
    var kRun = /* @__PURE__ */ Symbol("kRun");
    var Limiter = class {
      /**
       * Creates a new `Limiter`.
       *
       * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
       *     to run concurrently
       */
      constructor(concurrency) {
        this[kDone] = () => {
          this.pending--;
          this[kRun]();
        };
        this.concurrency = concurrency || Infinity;
        this.jobs = [];
        this.pending = 0;
      }
      /**
       * Adds a job to the queue.
       *
       * @param {Function} job The job to run
       * @public
       */
      add(job) {
        this.jobs.push(job);
        this[kRun]();
      }
      /**
       * Removes a job from the queue and runs it if possible.
       *
       * @private
       */
      [kRun]() {
        if (this.pending === this.concurrency) return;
        if (this.jobs.length) {
          const job = this.jobs.shift();
          this.pending++;
          job(this[kDone]);
        }
      }
    };
    module2.exports = Limiter;
  }
});

// node_modules/express-ws/node_modules/ws/lib/permessage-deflate.js
var require_permessage_deflate2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
    "use strict";
    var zlib2 = require("zlib");
    var bufferUtil = require_buffer_util2();
    var Limiter = require_limiter2();
    var { kStatusCode, NOOP } = require_constants2();
    var TRAILER = Buffer.from([0, 0, 255, 255]);
    var kPerMessageDeflate = /* @__PURE__ */ Symbol("permessage-deflate");
    var kTotalLength = /* @__PURE__ */ Symbol("total-length");
    var kCallback = /* @__PURE__ */ Symbol("callback");
    var kBuffers = /* @__PURE__ */ Symbol("buffers");
    var kError = /* @__PURE__ */ Symbol("error");
    var zlibLimiter;
    var PerMessageDeflate = class {
      /**
       * Creates a PerMessageDeflate instance.
       *
       * @param {Object} [options] Configuration options
       * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
       *     disabling of server context takeover
       * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
       *     acknowledge disabling of client context takeover
       * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
       *     use of a custom server window size
       * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
       *     for, or request, a custom client window size
       * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
       *     deflate
       * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
       *     inflate
       * @param {Number} [options.threshold=1024] Size (in bytes) below which
       *     messages should not be compressed
       * @param {Number} [options.concurrencyLimit=10] The number of concurrent
       *     calls to zlib
       * @param {Boolean} [isServer=false] Create the instance in either server or
       *     client mode
       * @param {Number} [maxPayload=0] The maximum allowed message length
       */
      constructor(options, isServer, maxPayload) {
        this._maxPayload = maxPayload | 0;
        this._options = options || {};
        this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
        this._isServer = !!isServer;
        this._deflate = null;
        this._inflate = null;
        this.params = null;
        if (!zlibLimiter) {
          const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
          zlibLimiter = new Limiter(concurrency);
        }
      }
      /**
       * @type {String}
       */
      static get extensionName() {
        return "permessage-deflate";
      }
      /**
       * Create an extension negotiation offer.
       *
       * @return {Object} Extension parameters
       * @public
       */
      offer() {
        const params = {};
        if (this._options.serverNoContextTakeover) {
          params.server_no_context_takeover = true;
        }
        if (this._options.clientNoContextTakeover) {
          params.client_no_context_takeover = true;
        }
        if (this._options.serverMaxWindowBits) {
          params.server_max_window_bits = this._options.serverMaxWindowBits;
        }
        if (this._options.clientMaxWindowBits) {
          params.client_max_window_bits = this._options.clientMaxWindowBits;
        } else if (this._options.clientMaxWindowBits == null) {
          params.client_max_window_bits = true;
        }
        return params;
      }
      /**
       * Accept an extension negotiation offer/response.
       *
       * @param {Array} configurations The extension negotiation offers/reponse
       * @return {Object} Accepted configuration
       * @public
       */
      accept(configurations) {
        configurations = this.normalizeParams(configurations);
        this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
        return this.params;
      }
      /**
       * Releases all resources used by the extension.
       *
       * @public
       */
      cleanup() {
        if (this._inflate) {
          this._inflate.close();
          this._inflate = null;
        }
        if (this._deflate) {
          const callback = this._deflate[kCallback];
          this._deflate.close();
          this._deflate = null;
          if (callback) {
            callback(
              new Error(
                "The deflate stream was closed while data was being processed"
              )
            );
          }
        }
      }
      /**
       *  Accept an extension negotiation offer.
       *
       * @param {Array} offers The extension negotiation offers
       * @return {Object} Accepted configuration
       * @private
       */
      acceptAsServer(offers) {
        const opts = this._options;
        const accepted = offers.find((params) => {
          if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
            return false;
          }
          return true;
        });
        if (!accepted) {
          throw new Error("None of the extension offers can be accepted");
        }
        if (opts.serverNoContextTakeover) {
          accepted.server_no_context_takeover = true;
        }
        if (opts.clientNoContextTakeover) {
          accepted.client_no_context_takeover = true;
        }
        if (typeof opts.serverMaxWindowBits === "number") {
          accepted.server_max_window_bits = opts.serverMaxWindowBits;
        }
        if (typeof opts.clientMaxWindowBits === "number") {
          accepted.client_max_window_bits = opts.clientMaxWindowBits;
        } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
          delete accepted.client_max_window_bits;
        }
        return accepted;
      }
      /**
       * Accept the extension negotiation response.
       *
       * @param {Array} response The extension negotiation response
       * @return {Object} Accepted configuration
       * @private
       */
      acceptAsClient(response) {
        const params = response[0];
        if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
          throw new Error('Unexpected parameter "client_no_context_takeover"');
        }
        if (!params.client_max_window_bits) {
          if (typeof this._options.clientMaxWindowBits === "number") {
            params.client_max_window_bits = this._options.clientMaxWindowBits;
          }
        } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
          throw new Error(
            'Unexpected or invalid parameter "client_max_window_bits"'
          );
        }
        return params;
      }
      /**
       * Normalize parameters.
       *
       * @param {Array} configurations The extension negotiation offers/reponse
       * @return {Array} The offers/response with normalized parameters
       * @private
       */
      normalizeParams(configurations) {
        configurations.forEach((params) => {
          Object.keys(params).forEach((key) => {
            let value = params[key];
            if (value.length > 1) {
              throw new Error(`Parameter "${key}" must have only a single value`);
            }
            value = value[0];
            if (key === "client_max_window_bits") {
              if (value !== true) {
                const num = +value;
                if (!Number.isInteger(num) || num < 8 || num > 15) {
                  throw new TypeError(
                    `Invalid value for parameter "${key}": ${value}`
                  );
                }
                value = num;
              } else if (!this._isServer) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
            } else if (key === "server_max_window_bits") {
              const num = +value;
              if (!Number.isInteger(num) || num < 8 || num > 15) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
              value = num;
            } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
              if (value !== true) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
            } else {
              throw new Error(`Unknown parameter "${key}"`);
            }
            params[key] = value;
          });
        });
        return configurations;
      }
      /**
       * Decompress data. Concurrency limited.
       *
       * @param {Buffer} data Compressed data
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @public
       */
      decompress(data, fin, callback) {
        zlibLimiter.add((done) => {
          this._decompress(data, fin, (err, result) => {
            done();
            callback(err, result);
          });
        });
      }
      /**
       * Compress data. Concurrency limited.
       *
       * @param {Buffer} data Data to compress
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @public
       */
      compress(data, fin, callback) {
        zlibLimiter.add((done) => {
          this._compress(data, fin, (err, result) => {
            done();
            callback(err, result);
          });
        });
      }
      /**
       * Decompress data.
       *
       * @param {Buffer} data Compressed data
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @private
       */
      _decompress(data, fin, callback) {
        const endpoint2 = this._isServer ? "client" : "server";
        if (!this._inflate) {
          const key = `${endpoint2}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib2.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._inflate = zlib2.createInflateRaw({
            ...this._options.zlibInflateOptions,
            windowBits
          });
          this._inflate[kPerMessageDeflate] = this;
          this._inflate[kTotalLength] = 0;
          this._inflate[kBuffers] = [];
          this._inflate.on("error", inflateOnError);
          this._inflate.on("data", inflateOnData);
        }
        this._inflate[kCallback] = callback;
        this._inflate.write(data);
        if (fin) this._inflate.write(TRAILER);
        this._inflate.flush(() => {
          const err = this._inflate[kError];
          if (err) {
            this._inflate.close();
            this._inflate = null;
            callback(err);
            return;
          }
          const data2 = bufferUtil.concat(
            this._inflate[kBuffers],
            this._inflate[kTotalLength]
          );
          if (this._inflate._readableState.endEmitted) {
            this._inflate.close();
            this._inflate = null;
          } else {
            this._inflate[kTotalLength] = 0;
            this._inflate[kBuffers] = [];
            if (fin && this.params[`${endpoint2}_no_context_takeover`]) {
              this._inflate.reset();
            }
          }
          callback(null, data2);
        });
      }
      /**
       * Compress data.
       *
       * @param {Buffer} data Data to compress
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @private
       */
      _compress(data, fin, callback) {
        const endpoint2 = this._isServer ? "server" : "client";
        if (!this._deflate) {
          const key = `${endpoint2}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib2.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._deflate = zlib2.createDeflateRaw({
            ...this._options.zlibDeflateOptions,
            windowBits
          });
          this._deflate[kTotalLength] = 0;
          this._deflate[kBuffers] = [];
          this._deflate.on("error", NOOP);
          this._deflate.on("data", deflateOnData);
        }
        this._deflate[kCallback] = callback;
        this._deflate.write(data);
        this._deflate.flush(zlib2.Z_SYNC_FLUSH, () => {
          if (!this._deflate) {
            return;
          }
          let data2 = bufferUtil.concat(
            this._deflate[kBuffers],
            this._deflate[kTotalLength]
          );
          if (fin) data2 = data2.slice(0, data2.length - 4);
          this._deflate[kCallback] = null;
          this._deflate[kTotalLength] = 0;
          this._deflate[kBuffers] = [];
          if (fin && this.params[`${endpoint2}_no_context_takeover`]) {
            this._deflate.reset();
          }
          callback(null, data2);
        });
      }
    };
    module2.exports = PerMessageDeflate;
    function deflateOnData(chunk) {
      this[kBuffers].push(chunk);
      this[kTotalLength] += chunk.length;
    }
    function inflateOnData(chunk) {
      this[kTotalLength] += chunk.length;
      if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
        this[kBuffers].push(chunk);
        return;
      }
      this[kError] = new RangeError("Max payload size exceeded");
      this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
      this[kError][kStatusCode] = 1009;
      this.removeListener("data", inflateOnData);
      this.reset();
    }
    function inflateOnError(err) {
      this[kPerMessageDeflate]._inflate = null;
      err[kStatusCode] = 1007;
      this[kCallback](err);
    }
  }
});

// node_modules/express-ws/node_modules/ws/lib/validation.js
var require_validation2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/validation.js"(exports2, module2) {
    "use strict";
    function isValidStatusCode(code) {
      return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
    }
    function _isValidUTF8(buf) {
      const len = buf.length;
      let i = 0;
      while (i < len) {
        if ((buf[i] & 128) === 0) {
          i++;
        } else if ((buf[i] & 224) === 192) {
          if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
            return false;
          }
          i += 2;
        } else if ((buf[i] & 240) === 224) {
          if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || // Overlong
          buf[i] === 237 && (buf[i + 1] & 224) === 160) {
            return false;
          }
          i += 3;
        } else if ((buf[i] & 248) === 240) {
          if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || // Overlong
          buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
            return false;
          }
          i += 4;
        } else {
          return false;
        }
      }
      return true;
    }
    try {
      let isValidUTF8 = require("utf-8-validate");
      if (typeof isValidUTF8 === "object") {
        isValidUTF8 = isValidUTF8.Validation.isValidUTF8;
      }
      module2.exports = {
        isValidStatusCode,
        isValidUTF8(buf) {
          return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
        }
      };
    } catch (e) {
      module2.exports = {
        isValidStatusCode,
        isValidUTF8: _isValidUTF8
      };
    }
  }
});

// node_modules/express-ws/node_modules/ws/lib/receiver.js
var require_receiver2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/receiver.js"(exports2, module2) {
    "use strict";
    var { Writable } = require("stream");
    var PerMessageDeflate = require_permessage_deflate2();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      kStatusCode,
      kWebSocket
    } = require_constants2();
    var { concat, toArrayBuffer, unmask } = require_buffer_util2();
    var { isValidStatusCode, isValidUTF8 } = require_validation2();
    var GET_INFO = 0;
    var GET_PAYLOAD_LENGTH_16 = 1;
    var GET_PAYLOAD_LENGTH_64 = 2;
    var GET_MASK = 3;
    var GET_DATA = 4;
    var INFLATING = 5;
    var Receiver = class extends Writable {
      /**
       * Creates a Receiver instance.
       *
       * @param {String} [binaryType=nodebuffer] The type for binary data
       * @param {Object} [extensions] An object containing the negotiated extensions
       * @param {Boolean} [isServer=false] Specifies whether to operate in client or
       *     server mode
       * @param {Number} [maxPayload=0] The maximum allowed message length
       */
      constructor(binaryType, extensions, isServer, maxPayload) {
        super();
        this._binaryType = binaryType || BINARY_TYPES[0];
        this[kWebSocket] = void 0;
        this._extensions = extensions || {};
        this._isServer = !!isServer;
        this._maxPayload = maxPayload | 0;
        this._bufferedBytes = 0;
        this._buffers = [];
        this._compressed = false;
        this._payloadLength = 0;
        this._mask = void 0;
        this._fragmented = 0;
        this._masked = false;
        this._fin = false;
        this._opcode = 0;
        this._totalPayloadLength = 0;
        this._messageLength = 0;
        this._fragments = [];
        this._state = GET_INFO;
        this._loop = false;
      }
      /**
       * Implements `Writable.prototype._write()`.
       *
       * @param {Buffer} chunk The chunk of data to write
       * @param {String} encoding The character encoding of `chunk`
       * @param {Function} cb Callback
       * @private
       */
      _write(chunk, encoding, cb) {
        if (this._opcode === 8 && this._state == GET_INFO) return cb();
        this._bufferedBytes += chunk.length;
        this._buffers.push(chunk);
        this.startLoop(cb);
      }
      /**
       * Consumes `n` bytes from the buffered data.
       *
       * @param {Number} n The number of bytes to consume
       * @return {Buffer} The consumed bytes
       * @private
       */
      consume(n) {
        this._bufferedBytes -= n;
        if (n === this._buffers[0].length) return this._buffers.shift();
        if (n < this._buffers[0].length) {
          const buf = this._buffers[0];
          this._buffers[0] = buf.slice(n);
          return buf.slice(0, n);
        }
        const dst = Buffer.allocUnsafe(n);
        do {
          const buf = this._buffers[0];
          const offset = dst.length - n;
          if (n >= buf.length) {
            dst.set(this._buffers.shift(), offset);
          } else {
            dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
            this._buffers[0] = buf.slice(n);
          }
          n -= buf.length;
        } while (n > 0);
        return dst;
      }
      /**
       * Starts the parsing loop.
       *
       * @param {Function} cb Callback
       * @private
       */
      startLoop(cb) {
        let err;
        this._loop = true;
        do {
          switch (this._state) {
            case GET_INFO:
              err = this.getInfo();
              break;
            case GET_PAYLOAD_LENGTH_16:
              err = this.getPayloadLength16();
              break;
            case GET_PAYLOAD_LENGTH_64:
              err = this.getPayloadLength64();
              break;
            case GET_MASK:
              this.getMask();
              break;
            case GET_DATA:
              err = this.getData(cb);
              break;
            default:
              this._loop = false;
              return;
          }
        } while (this._loop);
        cb(err);
      }
      /**
       * Reads the first two bytes of a frame.
       *
       * @return {(RangeError|undefined)} A possible error
       * @private
       */
      getInfo() {
        if (this._bufferedBytes < 2) {
          this._loop = false;
          return;
        }
        const buf = this.consume(2);
        if ((buf[0] & 48) !== 0) {
          this._loop = false;
          return error73(
            RangeError,
            "RSV2 and RSV3 must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_RSV_2_3"
          );
        }
        const compressed = (buf[0] & 64) === 64;
        if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
          this._loop = false;
          return error73(
            RangeError,
            "RSV1 must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_RSV_1"
          );
        }
        this._fin = (buf[0] & 128) === 128;
        this._opcode = buf[0] & 15;
        this._payloadLength = buf[1] & 127;
        if (this._opcode === 0) {
          if (compressed) {
            this._loop = false;
            return error73(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
          }
          if (!this._fragmented) {
            this._loop = false;
            return error73(
              RangeError,
              "invalid opcode 0",
              true,
              1002,
              "WS_ERR_INVALID_OPCODE"
            );
          }
          this._opcode = this._fragmented;
        } else if (this._opcode === 1 || this._opcode === 2) {
          if (this._fragmented) {
            this._loop = false;
            return error73(
              RangeError,
              `invalid opcode ${this._opcode}`,
              true,
              1002,
              "WS_ERR_INVALID_OPCODE"
            );
          }
          this._compressed = compressed;
        } else if (this._opcode > 7 && this._opcode < 11) {
          if (!this._fin) {
            this._loop = false;
            return error73(
              RangeError,
              "FIN must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_FIN"
            );
          }
          if (compressed) {
            this._loop = false;
            return error73(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
          }
          if (this._payloadLength > 125) {
            this._loop = false;
            return error73(
              RangeError,
              `invalid payload length ${this._payloadLength}`,
              true,
              1002,
              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
            );
          }
        } else {
          this._loop = false;
          return error73(
            RangeError,
            `invalid opcode ${this._opcode}`,
            true,
            1002,
            "WS_ERR_INVALID_OPCODE"
          );
        }
        if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
        this._masked = (buf[1] & 128) === 128;
        if (this._isServer) {
          if (!this._masked) {
            this._loop = false;
            return error73(
              RangeError,
              "MASK must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_MASK"
            );
          }
        } else if (this._masked) {
          this._loop = false;
          return error73(
            RangeError,
            "MASK must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_MASK"
          );
        }
        if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
        else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
        else return this.haveLength();
      }
      /**
       * Gets extended payload length (7+16).
       *
       * @return {(RangeError|undefined)} A possible error
       * @private
       */
      getPayloadLength16() {
        if (this._bufferedBytes < 2) {
          this._loop = false;
          return;
        }
        this._payloadLength = this.consume(2).readUInt16BE(0);
        return this.haveLength();
      }
      /**
       * Gets extended payload length (7+64).
       *
       * @return {(RangeError|undefined)} A possible error
       * @private
       */
      getPayloadLength64() {
        if (this._bufferedBytes < 8) {
          this._loop = false;
          return;
        }
        const buf = this.consume(8);
        const num = buf.readUInt32BE(0);
        if (num > Math.pow(2, 53 - 32) - 1) {
          this._loop = false;
          return error73(
            RangeError,
            "Unsupported WebSocket frame: payload length > 2^53 - 1",
            false,
            1009,
            "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
          );
        }
        this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
        return this.haveLength();
      }
      /**
       * Payload length has been read.
       *
       * @return {(RangeError|undefined)} A possible error
       * @private
       */
      haveLength() {
        if (this._payloadLength && this._opcode < 8) {
          this._totalPayloadLength += this._payloadLength;
          if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
            this._loop = false;
            return error73(
              RangeError,
              "Max payload size exceeded",
              false,
              1009,
              "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
            );
          }
        }
        if (this._masked) this._state = GET_MASK;
        else this._state = GET_DATA;
      }
      /**
       * Reads mask bytes.
       *
       * @private
       */
      getMask() {
        if (this._bufferedBytes < 4) {
          this._loop = false;
          return;
        }
        this._mask = this.consume(4);
        this._state = GET_DATA;
      }
      /**
       * Reads data bytes.
       *
       * @param {Function} cb Callback
       * @return {(Error|RangeError|undefined)} A possible error
       * @private
       */
      getData(cb) {
        let data = EMPTY_BUFFER;
        if (this._payloadLength) {
          if (this._bufferedBytes < this._payloadLength) {
            this._loop = false;
            return;
          }
          data = this.consume(this._payloadLength);
          if (this._masked) unmask(data, this._mask);
        }
        if (this._opcode > 7) return this.controlMessage(data);
        if (this._compressed) {
          this._state = INFLATING;
          this.decompress(data, cb);
          return;
        }
        if (data.length) {
          this._messageLength = this._totalPayloadLength;
          this._fragments.push(data);
        }
        return this.dataMessage();
      }
      /**
       * Decompresses data.
       *
       * @param {Buffer} data Compressed data
       * @param {Function} cb Callback
       * @private
       */
      decompress(data, cb) {
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        perMessageDeflate.decompress(data, this._fin, (err, buf) => {
          if (err) return cb(err);
          if (buf.length) {
            this._messageLength += buf.length;
            if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
              return cb(
                error73(
                  RangeError,
                  "Max payload size exceeded",
                  false,
                  1009,
                  "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
                )
              );
            }
            this._fragments.push(buf);
          }
          const er = this.dataMessage();
          if (er) return cb(er);
          this.startLoop(cb);
        });
      }
      /**
       * Handles a data message.
       *
       * @return {(Error|undefined)} A possible error
       * @private
       */
      dataMessage() {
        if (this._fin) {
          const messageLength = this._messageLength;
          const fragments = this._fragments;
          this._totalPayloadLength = 0;
          this._messageLength = 0;
          this._fragmented = 0;
          this._fragments = [];
          if (this._opcode === 2) {
            let data;
            if (this._binaryType === "nodebuffer") {
              data = concat(fragments, messageLength);
            } else if (this._binaryType === "arraybuffer") {
              data = toArrayBuffer(concat(fragments, messageLength));
            } else {
              data = fragments;
            }
            this.emit("message", data);
          } else {
            const buf = concat(fragments, messageLength);
            if (!isValidUTF8(buf)) {
              this._loop = false;
              return error73(
                Error,
                "invalid UTF-8 sequence",
                true,
                1007,
                "WS_ERR_INVALID_UTF8"
              );
            }
            this.emit("message", buf.toString());
          }
        }
        this._state = GET_INFO;
      }
      /**
       * Handles a control message.
       *
       * @param {Buffer} data Data to handle
       * @return {(Error|RangeError|undefined)} A possible error
       * @private
       */
      controlMessage(data) {
        if (this._opcode === 8) {
          this._loop = false;
          if (data.length === 0) {
            this.emit("conclude", 1005, "");
            this.end();
          } else if (data.length === 1) {
            return error73(
              RangeError,
              "invalid payload length 1",
              true,
              1002,
              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
            );
          } else {
            const code = data.readUInt16BE(0);
            if (!isValidStatusCode(code)) {
              return error73(
                RangeError,
                `invalid status code ${code}`,
                true,
                1002,
                "WS_ERR_INVALID_CLOSE_CODE"
              );
            }
            const buf = data.slice(2);
            if (!isValidUTF8(buf)) {
              return error73(
                Error,
                "invalid UTF-8 sequence",
                true,
                1007,
                "WS_ERR_INVALID_UTF8"
              );
            }
            this.emit("conclude", code, buf.toString());
            this.end();
          }
        } else if (this._opcode === 9) {
          this.emit("ping", data);
        } else {
          this.emit("pong", data);
        }
        this._state = GET_INFO;
      }
    };
    module2.exports = Receiver;
    function error73(ErrorCtor, message, prefix, statusCode, errorCode) {
      const err = new ErrorCtor(
        prefix ? `Invalid WebSocket frame: ${message}` : message
      );
      Error.captureStackTrace(err, error73);
      err.code = errorCode;
      err[kStatusCode] = statusCode;
      return err;
    }
  }
});

// node_modules/express-ws/node_modules/ws/lib/sender.js
var require_sender2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/sender.js"(exports2, module2) {
    "use strict";
    var net = require("net");
    var tls = require("tls");
    var { randomFillSync: randomFillSync2 } = require("crypto");
    var PerMessageDeflate = require_permessage_deflate2();
    var { EMPTY_BUFFER } = require_constants2();
    var { isValidStatusCode } = require_validation2();
    var { mask: applyMask, toBuffer } = require_buffer_util2();
    var mask = Buffer.alloc(4);
    var Sender = class _Sender {
      /**
       * Creates a Sender instance.
       *
       * @param {(net.Socket|tls.Socket)} socket The connection socket
       * @param {Object} [extensions] An object containing the negotiated extensions
       */
      constructor(socket, extensions) {
        this._extensions = extensions || {};
        this._socket = socket;
        this._firstFragment = true;
        this._compress = false;
        this._bufferedBytes = 0;
        this._deflating = false;
        this._queue = [];
      }
      /**
       * Frames a piece of data according to the HyBi WebSocket protocol.
       *
       * @param {Buffer} data The data to frame
       * @param {Object} options Options object
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @return {Buffer[]} The framed data as a list of `Buffer` instances
       * @public
       */
      static frame(data, options) {
        const merge4 = options.mask && options.readOnly;
        let offset = options.mask ? 6 : 2;
        let payloadLength = data.length;
        if (data.length >= 65536) {
          offset += 8;
          payloadLength = 127;
        } else if (data.length > 125) {
          offset += 2;
          payloadLength = 126;
        }
        const target = Buffer.allocUnsafe(merge4 ? data.length + offset : offset);
        target[0] = options.fin ? options.opcode | 128 : options.opcode;
        if (options.rsv1) target[0] |= 64;
        target[1] = payloadLength;
        if (payloadLength === 126) {
          target.writeUInt16BE(data.length, 2);
        } else if (payloadLength === 127) {
          target.writeUInt32BE(0, 2);
          target.writeUInt32BE(data.length, 6);
        }
        if (!options.mask) return [target, data];
        randomFillSync2(mask, 0, 4);
        target[1] |= 128;
        target[offset - 4] = mask[0];
        target[offset - 3] = mask[1];
        target[offset - 2] = mask[2];
        target[offset - 1] = mask[3];
        if (merge4) {
          applyMask(data, mask, target, offset, data.length);
          return [target];
        }
        applyMask(data, mask, data, 0, data.length);
        return [target, data];
      }
      /**
       * Sends a close message to the other peer.
       *
       * @param {Number} [code] The status code component of the body
       * @param {String} [data] The message component of the body
       * @param {Boolean} [mask=false] Specifies whether or not to mask the message
       * @param {Function} [cb] Callback
       * @public
       */
      close(code, data, mask2, cb) {
        let buf;
        if (code === void 0) {
          buf = EMPTY_BUFFER;
        } else if (typeof code !== "number" || !isValidStatusCode(code)) {
          throw new TypeError("First argument must be a valid error code number");
        } else if (data === void 0 || data === "") {
          buf = Buffer.allocUnsafe(2);
          buf.writeUInt16BE(code, 0);
        } else {
          const length = Buffer.byteLength(data);
          if (length > 123) {
            throw new RangeError("The message must not be greater than 123 bytes");
          }
          buf = Buffer.allocUnsafe(2 + length);
          buf.writeUInt16BE(code, 0);
          buf.write(data, 2);
        }
        if (this._deflating) {
          this.enqueue([this.doClose, buf, mask2, cb]);
        } else {
          this.doClose(buf, mask2, cb);
        }
      }
      /**
       * Frames and sends a close message.
       *
       * @param {Buffer} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback
       * @private
       */
      doClose(data, mask2, cb) {
        this.sendFrame(
          _Sender.frame(data, {
            fin: true,
            rsv1: false,
            opcode: 8,
            mask: mask2,
            readOnly: false
          }),
          cb
        );
      }
      /**
       * Sends a ping message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback
       * @public
       */
      ping(data, mask2, cb) {
        const buf = toBuffer(data);
        if (buf.length > 125) {
          throw new RangeError("The data size must not be greater than 125 bytes");
        }
        if (this._deflating) {
          this.enqueue([this.doPing, buf, mask2, toBuffer.readOnly, cb]);
        } else {
          this.doPing(buf, mask2, toBuffer.readOnly, cb);
        }
      }
      /**
       * Frames and sends a ping message.
       *
       * @param {Buffer} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
       * @param {Function} [cb] Callback
       * @private
       */
      doPing(data, mask2, readOnly, cb) {
        this.sendFrame(
          _Sender.frame(data, {
            fin: true,
            rsv1: false,
            opcode: 9,
            mask: mask2,
            readOnly
          }),
          cb
        );
      }
      /**
       * Sends a pong message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback
       * @public
       */
      pong(data, mask2, cb) {
        const buf = toBuffer(data);
        if (buf.length > 125) {
          throw new RangeError("The data size must not be greater than 125 bytes");
        }
        if (this._deflating) {
          this.enqueue([this.doPong, buf, mask2, toBuffer.readOnly, cb]);
        } else {
          this.doPong(buf, mask2, toBuffer.readOnly, cb);
        }
      }
      /**
       * Frames and sends a pong message.
       *
       * @param {Buffer} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
       * @param {Function} [cb] Callback
       * @private
       */
      doPong(data, mask2, readOnly, cb) {
        this.sendFrame(
          _Sender.frame(data, {
            fin: true,
            rsv1: false,
            opcode: 10,
            mask: mask2,
            readOnly
          }),
          cb
        );
      }
      /**
       * Sends a data message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Object} options Options object
       * @param {Boolean} [options.compress=false] Specifies whether or not to
       *     compress `data`
       * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
       *     or text
       * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
       *     last one
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Function} [cb] Callback
       * @public
       */
      send(data, options, cb) {
        const buf = toBuffer(data);
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        let opcode = options.binary ? 2 : 1;
        let rsv1 = options.compress;
        if (this._firstFragment) {
          this._firstFragment = false;
          if (rsv1 && perMessageDeflate) {
            rsv1 = buf.length >= perMessageDeflate._threshold;
          }
          this._compress = rsv1;
        } else {
          rsv1 = false;
          opcode = 0;
        }
        if (options.fin) this._firstFragment = true;
        if (perMessageDeflate) {
          const opts = {
            fin: options.fin,
            rsv1,
            opcode,
            mask: options.mask,
            readOnly: toBuffer.readOnly
          };
          if (this._deflating) {
            this.enqueue([this.dispatch, buf, this._compress, opts, cb]);
          } else {
            this.dispatch(buf, this._compress, opts, cb);
          }
        } else {
          this.sendFrame(
            _Sender.frame(buf, {
              fin: options.fin,
              rsv1: false,
              opcode,
              mask: options.mask,
              readOnly: toBuffer.readOnly
            }),
            cb
          );
        }
      }
      /**
       * Dispatches a data message.
       *
       * @param {Buffer} data The message to send
       * @param {Boolean} [compress=false] Specifies whether or not to compress
       *     `data`
       * @param {Object} options Options object
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @param {Function} [cb] Callback
       * @private
       */
      dispatch(data, compress, options, cb) {
        if (!compress) {
          this.sendFrame(_Sender.frame(data, options), cb);
          return;
        }
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        this._bufferedBytes += data.length;
        this._deflating = true;
        perMessageDeflate.compress(data, options.fin, (_, buf) => {
          if (this._socket.destroyed) {
            const err = new Error(
              "The socket was closed while data was being compressed"
            );
            if (typeof cb === "function") cb(err);
            for (let i = 0; i < this._queue.length; i++) {
              const callback = this._queue[i][4];
              if (typeof callback === "function") callback(err);
            }
            return;
          }
          this._bufferedBytes -= data.length;
          this._deflating = false;
          options.readOnly = false;
          this.sendFrame(_Sender.frame(buf, options), cb);
          this.dequeue();
        });
      }
      /**
       * Executes queued send operations.
       *
       * @private
       */
      dequeue() {
        while (!this._deflating && this._queue.length) {
          const params = this._queue.shift();
          this._bufferedBytes -= params[1].length;
          Reflect.apply(params[0], this, params.slice(1));
        }
      }
      /**
       * Enqueues a send operation.
       *
       * @param {Array} params Send operation parameters.
       * @private
       */
      enqueue(params) {
        this._bufferedBytes += params[1].length;
        this._queue.push(params);
      }
      /**
       * Sends a frame.
       *
       * @param {Buffer[]} list The frame to send
       * @param {Function} [cb] Callback
       * @private
       */
      sendFrame(list2, cb) {
        if (list2.length === 2) {
          this._socket.cork();
          this._socket.write(list2[0]);
          this._socket.write(list2[1], cb);
          this._socket.uncork();
        } else {
          this._socket.write(list2[0], cb);
        }
      }
    };
    module2.exports = Sender;
  }
});

// node_modules/express-ws/node_modules/ws/lib/event-target.js
var require_event_target2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/event-target.js"(exports2, module2) {
    "use strict";
    var Event = class {
      /**
       * Create a new `Event`.
       *
       * @param {String} type The name of the event
       * @param {Object} target A reference to the target to which the event was
       *     dispatched
       */
      constructor(type, target) {
        this.target = target;
        this.type = type;
      }
    };
    var MessageEvent = class extends Event {
      /**
       * Create a new `MessageEvent`.
       *
       * @param {(String|Buffer|ArrayBuffer|Buffer[])} data The received data
       * @param {WebSocket} target A reference to the target to which the event was
       *     dispatched
       */
      constructor(data, target) {
        super("message", target);
        this.data = data;
      }
    };
    var CloseEvent = class extends Event {
      /**
       * Create a new `CloseEvent`.
       *
       * @param {Number} code The status code explaining why the connection is being
       *     closed
       * @param {String} reason A human-readable string explaining why the
       *     connection is closing
       * @param {WebSocket} target A reference to the target to which the event was
       *     dispatched
       */
      constructor(code, reason, target) {
        super("close", target);
        this.wasClean = target._closeFrameReceived && target._closeFrameSent;
        this.reason = reason;
        this.code = code;
      }
    };
    var OpenEvent = class extends Event {
      /**
       * Create a new `OpenEvent`.
       *
       * @param {WebSocket} target A reference to the target to which the event was
       *     dispatched
       */
      constructor(target) {
        super("open", target);
      }
    };
    var ErrorEvent = class extends Event {
      /**
       * Create a new `ErrorEvent`.
       *
       * @param {Object} error The error that generated this event
       * @param {WebSocket} target A reference to the target to which the event was
       *     dispatched
       */
      constructor(error73, target) {
        super("error", target);
        this.message = error73.message;
        this.error = error73;
      }
    };
    var EventTarget = {
      /**
       * Register an event listener.
       *
       * @param {String} type A string representing the event type to listen for
       * @param {Function} listener The listener to add
       * @param {Object} [options] An options object specifies characteristics about
       *     the event listener
       * @param {Boolean} [options.once=false] A `Boolean`` indicating that the
       *     listener should be invoked at most once after being added. If `true`,
       *     the listener would be automatically removed when invoked.
       * @public
       */
      addEventListener(type, listener, options) {
        if (typeof listener !== "function") return;
        function onMessage(data) {
          listener.call(this, new MessageEvent(data, this));
        }
        function onClose(code, message) {
          listener.call(this, new CloseEvent(code, message, this));
        }
        function onError(error73) {
          listener.call(this, new ErrorEvent(error73, this));
        }
        function onOpen() {
          listener.call(this, new OpenEvent(this));
        }
        const method = options && options.once ? "once" : "on";
        if (type === "message") {
          onMessage._listener = listener;
          this[method](type, onMessage);
        } else if (type === "close") {
          onClose._listener = listener;
          this[method](type, onClose);
        } else if (type === "error") {
          onError._listener = listener;
          this[method](type, onError);
        } else if (type === "open") {
          onOpen._listener = listener;
          this[method](type, onOpen);
        } else {
          this[method](type, listener);
        }
      },
      /**
       * Remove an event listener.
       *
       * @param {String} type A string representing the event type to remove
       * @param {Function} listener The listener to remove
       * @public
       */
      removeEventListener(type, listener) {
        const listeners = this.listeners(type);
        for (let i = 0; i < listeners.length; i++) {
          if (listeners[i] === listener || listeners[i]._listener === listener) {
            this.removeListener(type, listeners[i]);
          }
        }
      }
    };
    module2.exports = EventTarget;
  }
});

// node_modules/express-ws/node_modules/ws/lib/extension.js
var require_extension2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/extension.js"(exports2, module2) {
    "use strict";
    var tokenChars = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      // 0 - 15
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      // 16 - 31
      0,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      1,
      1,
      0,
      1,
      1,
      0,
      // 32 - 47
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      // 48 - 63
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 64 - 79
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      1,
      1,
      // 80 - 95
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 96 - 111
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      0,
      1,
      0
      // 112 - 127
    ];
    function push(dest, name28, elem) {
      if (dest[name28] === void 0) dest[name28] = [elem];
      else dest[name28].push(elem);
    }
    function parse4(header) {
      const offers = /* @__PURE__ */ Object.create(null);
      if (header === void 0 || header === "") return offers;
      let params = /* @__PURE__ */ Object.create(null);
      let mustUnescape = false;
      let isEscaping = false;
      let inQuotes = false;
      let extensionName;
      let paramName;
      let start = -1;
      let end = -1;
      let i = 0;
      for (; i < header.length; i++) {
        const code = header.charCodeAt(i);
        if (extensionName === void 0) {
          if (end === -1 && tokenChars[code] === 1) {
            if (start === -1) start = i;
          } else if (code === 32 || code === 9) {
            if (end === -1 && start !== -1) end = i;
          } else if (code === 59 || code === 44) {
            if (start === -1) {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
            if (end === -1) end = i;
            const name28 = header.slice(start, end);
            if (code === 44) {
              push(offers, name28, params);
              params = /* @__PURE__ */ Object.create(null);
            } else {
              extensionName = name28;
            }
            start = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i}`);
          }
        } else if (paramName === void 0) {
          if (end === -1 && tokenChars[code] === 1) {
            if (start === -1) start = i;
          } else if (code === 32 || code === 9) {
            if (end === -1 && start !== -1) end = i;
          } else if (code === 59 || code === 44) {
            if (start === -1) {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
            if (end === -1) end = i;
            push(params, header.slice(start, end), true);
            if (code === 44) {
              push(offers, extensionName, params);
              params = /* @__PURE__ */ Object.create(null);
              extensionName = void 0;
            }
            start = end = -1;
          } else if (code === 61 && start !== -1 && end === -1) {
            paramName = header.slice(start, i);
            start = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i}`);
          }
        } else {
          if (isEscaping) {
            if (tokenChars[code] !== 1) {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
            if (start === -1) start = i;
            else if (!mustUnescape) mustUnescape = true;
            isEscaping = false;
          } else if (inQuotes) {
            if (tokenChars[code] === 1) {
              if (start === -1) start = i;
            } else if (code === 34 && start !== -1) {
              inQuotes = false;
              end = i;
            } else if (code === 92) {
              isEscaping = true;
            } else {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
          } else if (code === 34 && header.charCodeAt(i - 1) === 61) {
            inQuotes = true;
          } else if (end === -1 && tokenChars[code] === 1) {
            if (start === -1) start = i;
          } else if (start !== -1 && (code === 32 || code === 9)) {
            if (end === -1) end = i;
          } else if (code === 59 || code === 44) {
            if (start === -1) {
              throw new SyntaxError(`Unexpected character at index ${i}`);
            }
            if (end === -1) end = i;
            let value = header.slice(start, end);
            if (mustUnescape) {
              value = value.replace(/\\/g, "");
              mustUnescape = false;
            }
            push(params, paramName, value);
            if (code === 44) {
              push(offers, extensionName, params);
              params = /* @__PURE__ */ Object.create(null);
              extensionName = void 0;
            }
            paramName = void 0;
            start = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i}`);
          }
        }
      }
      if (start === -1 || inQuotes) {
        throw new SyntaxError("Unexpected end of input");
      }
      if (end === -1) end = i;
      const token = header.slice(start, end);
      if (extensionName === void 0) {
        push(offers, token, params);
      } else {
        if (paramName === void 0) {
          push(params, token, true);
        } else if (mustUnescape) {
          push(params, paramName, token.replace(/\\/g, ""));
        } else {
          push(params, paramName, token);
        }
        push(offers, extensionName, params);
      }
      return offers;
    }
    function format(extensions) {
      return Object.keys(extensions).map((extension) => {
        let configurations = extensions[extension];
        if (!Array.isArray(configurations)) configurations = [configurations];
        return configurations.map((params) => {
          return [extension].concat(
            Object.keys(params).map((k) => {
              let values = params[k];
              if (!Array.isArray(values)) values = [values];
              return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
            })
          ).join("; ");
        }).join(", ");
      }).join(", ");
    }
    module2.exports = { format, parse: parse4 };
  }
});

// node_modules/express-ws/node_modules/ws/lib/websocket.js
var require_websocket4 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/websocket.js"(exports2, module2) {
    "use strict";
    var EventEmitter3 = require("events");
    var https2 = require("https");
    var http4 = require("http");
    var net = require("net");
    var tls = require("tls");
    var { randomBytes, createHash } = require("crypto");
    var { Readable: Readable2 } = require("stream");
    var { URL: URL2 } = require("url");
    var PerMessageDeflate = require_permessage_deflate2();
    var Receiver = require_receiver2();
    var Sender = require_sender2();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      GUID,
      kStatusCode,
      kWebSocket,
      NOOP
    } = require_constants2();
    var { addEventListener, removeEventListener } = require_event_target2();
    var { format, parse: parse4 } = require_extension2();
    var { toBuffer } = require_buffer_util2();
    var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
    var protocolVersions = [8, 13];
    var closeTimeout = 30 * 1e3;
    var WebSocket = class _WebSocket extends EventEmitter3 {
      /**
       * Create a new `WebSocket`.
       *
       * @param {(String|URL)} address The URL to which to connect
       * @param {(String|String[])} [protocols] The subprotocols
       * @param {Object} [options] Connection options
       */
      constructor(address, protocols, options) {
        super();
        this._binaryType = BINARY_TYPES[0];
        this._closeCode = 1006;
        this._closeFrameReceived = false;
        this._closeFrameSent = false;
        this._closeMessage = "";
        this._closeTimer = null;
        this._extensions = {};
        this._protocol = "";
        this._readyState = _WebSocket.CONNECTING;
        this._receiver = null;
        this._sender = null;
        this._socket = null;
        if (address !== null) {
          this._bufferedAmount = 0;
          this._isServer = false;
          this._redirects = 0;
          if (Array.isArray(protocols)) {
            protocols = protocols.join(", ");
          } else if (typeof protocols === "object" && protocols !== null) {
            options = protocols;
            protocols = void 0;
          }
          initAsClient(this, address, protocols, options);
        } else {
          this._isServer = true;
        }
      }
      /**
       * This deviates from the WHATWG interface since ws doesn't support the
       * required default "blob" type (instead we define a custom "nodebuffer"
       * type).
       *
       * @type {String}
       */
      get binaryType() {
        return this._binaryType;
      }
      set binaryType(type) {
        if (!BINARY_TYPES.includes(type)) return;
        this._binaryType = type;
        if (this._receiver) this._receiver._binaryType = type;
      }
      /**
       * @type {Number}
       */
      get bufferedAmount() {
        if (!this._socket) return this._bufferedAmount;
        return this._socket._writableState.length + this._sender._bufferedBytes;
      }
      /**
       * @type {String}
       */
      get extensions() {
        return Object.keys(this._extensions).join();
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onclose() {
        return void 0;
      }
      /* istanbul ignore next */
      set onclose(listener) {
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onerror() {
        return void 0;
      }
      /* istanbul ignore next */
      set onerror(listener) {
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onopen() {
        return void 0;
      }
      /* istanbul ignore next */
      set onopen(listener) {
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onmessage() {
        return void 0;
      }
      /* istanbul ignore next */
      set onmessage(listener) {
      }
      /**
       * @type {String}
       */
      get protocol() {
        return this._protocol;
      }
      /**
       * @type {Number}
       */
      get readyState() {
        return this._readyState;
      }
      /**
       * @type {String}
       */
      get url() {
        return this._url;
      }
      /**
       * Set up the socket and the internal resources.
       *
       * @param {(net.Socket|tls.Socket)} socket The network socket between the
       *     server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Number} [maxPayload=0] The maximum allowed message size
       * @private
       */
      setSocket(socket, head, maxPayload) {
        const receiver = new Receiver(
          this.binaryType,
          this._extensions,
          this._isServer,
          maxPayload
        );
        this._sender = new Sender(socket, this._extensions);
        this._receiver = receiver;
        this._socket = socket;
        receiver[kWebSocket] = this;
        socket[kWebSocket] = this;
        receiver.on("conclude", receiverOnConclude);
        receiver.on("drain", receiverOnDrain);
        receiver.on("error", receiverOnError);
        receiver.on("message", receiverOnMessage);
        receiver.on("ping", receiverOnPing);
        receiver.on("pong", receiverOnPong);
        socket.setTimeout(0);
        socket.setNoDelay();
        if (head.length > 0) socket.unshift(head);
        socket.on("close", socketOnClose);
        socket.on("data", socketOnData);
        socket.on("end", socketOnEnd);
        socket.on("error", socketOnError);
        this._readyState = _WebSocket.OPEN;
        this.emit("open");
      }
      /**
       * Emit the `'close'` event.
       *
       * @private
       */
      emitClose() {
        if (!this._socket) {
          this._readyState = _WebSocket.CLOSED;
          this.emit("close", this._closeCode, this._closeMessage);
          return;
        }
        if (this._extensions[PerMessageDeflate.extensionName]) {
          this._extensions[PerMessageDeflate.extensionName].cleanup();
        }
        this._receiver.removeAllListeners();
        this._readyState = _WebSocket.CLOSED;
        this.emit("close", this._closeCode, this._closeMessage);
      }
      /**
       * Start a closing handshake.
       *
       *          +----------+   +-----------+   +----------+
       *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
       *    |     +----------+   +-----------+   +----------+     |
       *          +----------+   +-----------+         |
       * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
       *          +----------+   +-----------+   |
       *    |           |                        |   +---+        |
       *                +------------------------+-->|fin| - - - -
       *    |         +---+                      |   +---+
       *     - - - - -|fin|<---------------------+
       *              +---+
       *
       * @param {Number} [code] Status code explaining why the connection is closing
       * @param {String} [data] A string explaining why the connection is closing
       * @public
       */
      close(code, data) {
        if (this.readyState === _WebSocket.CLOSED) return;
        if (this.readyState === _WebSocket.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          return abortHandshake(this, this._req, msg);
        }
        if (this.readyState === _WebSocket.CLOSING) {
          if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
            this._socket.end();
          }
          return;
        }
        this._readyState = _WebSocket.CLOSING;
        this._sender.close(code, data, !this._isServer, (err) => {
          if (err) return;
          this._closeFrameSent = true;
          if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
            this._socket.end();
          }
        });
        this._closeTimer = setTimeout(
          this._socket.destroy.bind(this._socket),
          closeTimeout
        );
      }
      /**
       * Send a ping.
       *
       * @param {*} [data] The data to send
       * @param {Boolean} [mask] Indicates whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when the ping is sent
       * @public
       */
      ping(data, mask, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof data === "function") {
          cb = data;
          data = mask = void 0;
        } else if (typeof mask === "function") {
          cb = mask;
          mask = void 0;
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        if (mask === void 0) mask = !this._isServer;
        this._sender.ping(data || EMPTY_BUFFER, mask, cb);
      }
      /**
       * Send a pong.
       *
       * @param {*} [data] The data to send
       * @param {Boolean} [mask] Indicates whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when the pong is sent
       * @public
       */
      pong(data, mask, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof data === "function") {
          cb = data;
          data = mask = void 0;
        } else if (typeof mask === "function") {
          cb = mask;
          mask = void 0;
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        if (mask === void 0) mask = !this._isServer;
        this._sender.pong(data || EMPTY_BUFFER, mask, cb);
      }
      /**
       * Send a data message.
       *
       * @param {*} data The message to send
       * @param {Object} [options] Options object
       * @param {Boolean} [options.compress] Specifies whether or not to compress
       *     `data`
       * @param {Boolean} [options.binary] Specifies whether `data` is binary or
       *     text
       * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
       *     last one
       * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when data is written out
       * @public
       */
      send(data, options, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof options === "function") {
          cb = options;
          options = {};
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        const opts = {
          binary: typeof data !== "string",
          mask: !this._isServer,
          compress: true,
          fin: true,
          ...options
        };
        if (!this._extensions[PerMessageDeflate.extensionName]) {
          opts.compress = false;
        }
        this._sender.send(data || EMPTY_BUFFER, opts, cb);
      }
      /**
       * Forcibly close the connection.
       *
       * @public
       */
      terminate() {
        if (this.readyState === _WebSocket.CLOSED) return;
        if (this.readyState === _WebSocket.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          return abortHandshake(this, this._req, msg);
        }
        if (this._socket) {
          this._readyState = _WebSocket.CLOSING;
          this._socket.destroy();
        }
      }
    };
    Object.defineProperty(WebSocket, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket.prototype, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket.prototype, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket.prototype, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    Object.defineProperty(WebSocket.prototype, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    [
      "binaryType",
      "bufferedAmount",
      "extensions",
      "protocol",
      "readyState",
      "url"
    ].forEach((property2) => {
      Object.defineProperty(WebSocket.prototype, property2, { enumerable: true });
    });
    ["open", "error", "close", "message"].forEach((method) => {
      Object.defineProperty(WebSocket.prototype, `on${method}`, {
        enumerable: true,
        get() {
          const listeners = this.listeners(method);
          for (let i = 0; i < listeners.length; i++) {
            if (listeners[i]._listener) return listeners[i]._listener;
          }
          return void 0;
        },
        set(listener) {
          const listeners = this.listeners(method);
          for (let i = 0; i < listeners.length; i++) {
            if (listeners[i]._listener) this.removeListener(method, listeners[i]);
          }
          this.addEventListener(method, listener);
        }
      });
    });
    WebSocket.prototype.addEventListener = addEventListener;
    WebSocket.prototype.removeEventListener = removeEventListener;
    module2.exports = WebSocket;
    function initAsClient(websocket, address, protocols, options) {
      const opts = {
        protocolVersion: protocolVersions[1],
        maxPayload: 100 * 1024 * 1024,
        perMessageDeflate: true,
        followRedirects: false,
        maxRedirects: 10,
        ...options,
        createConnection: void 0,
        socketPath: void 0,
        hostname: void 0,
        protocol: void 0,
        timeout: void 0,
        method: void 0,
        host: void 0,
        path: void 0,
        port: void 0
      };
      if (!protocolVersions.includes(opts.protocolVersion)) {
        throw new RangeError(
          `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
        );
      }
      let parsedUrl;
      if (address instanceof URL2) {
        parsedUrl = address;
        websocket._url = address.href;
      } else {
        parsedUrl = new URL2(address);
        websocket._url = address;
      }
      const isUnixSocket = parsedUrl.protocol === "ws+unix:";
      if (!parsedUrl.host && (!isUnixSocket || !parsedUrl.pathname)) {
        const err = new Error(`Invalid URL: ${websocket.url}`);
        if (websocket._redirects === 0) {
          throw err;
        } else {
          emitErrorAndClose(websocket, err);
          return;
        }
      }
      const isSecure = parsedUrl.protocol === "wss:" || parsedUrl.protocol === "https:";
      const defaultPort = isSecure ? 443 : 80;
      const key = randomBytes(16).toString("base64");
      const get2 = isSecure ? https2.get : http4.get;
      let perMessageDeflate;
      opts.createConnection = isSecure ? tlsConnect : netConnect;
      opts.defaultPort = opts.defaultPort || defaultPort;
      opts.port = parsedUrl.port || defaultPort;
      opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
      opts.headers = {
        "Sec-WebSocket-Version": opts.protocolVersion,
        "Sec-WebSocket-Key": key,
        Connection: "Upgrade",
        Upgrade: "websocket",
        ...opts.headers
      };
      opts.path = parsedUrl.pathname + parsedUrl.search;
      opts.timeout = opts.handshakeTimeout;
      if (opts.perMessageDeflate) {
        perMessageDeflate = new PerMessageDeflate(
          opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
          false,
          opts.maxPayload
        );
        opts.headers["Sec-WebSocket-Extensions"] = format({
          [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
        });
      }
      if (protocols) {
        opts.headers["Sec-WebSocket-Protocol"] = protocols;
      }
      if (opts.origin) {
        if (opts.protocolVersion < 13) {
          opts.headers["Sec-WebSocket-Origin"] = opts.origin;
        } else {
          opts.headers.Origin = opts.origin;
        }
      }
      if (parsedUrl.username || parsedUrl.password) {
        opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
      }
      if (isUnixSocket) {
        const parts = opts.path.split(":");
        opts.socketPath = parts[0];
        opts.path = parts[1];
      }
      if (opts.followRedirects) {
        if (websocket._redirects === 0) {
          websocket._originalUnixSocket = isUnixSocket;
          websocket._originalSecure = isSecure;
          websocket._originalHostOrSocketPath = isUnixSocket ? opts.socketPath : parsedUrl.host;
          const headers = options && options.headers;
          options = { ...options, headers: {} };
          if (headers) {
            for (const [key2, value] of Object.entries(headers)) {
              options.headers[key2.toLowerCase()] = value;
            }
          }
        } else {
          const isSameHost = isUnixSocket ? websocket._originalUnixSocket ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalUnixSocket ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
          if (!isSameHost || websocket._originalSecure && !isSecure) {
            delete opts.headers.authorization;
            delete opts.headers.cookie;
            if (!isSameHost) delete opts.headers.host;
            opts.auth = void 0;
          }
        }
        if (opts.auth && !options.headers.authorization) {
          options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
        }
      }
      let req = websocket._req = get2(opts);
      if (opts.timeout) {
        req.on("timeout", () => {
          abortHandshake(websocket, req, "Opening handshake has timed out");
        });
      }
      req.on("error", (err) => {
        if (req === null || req.aborted) return;
        req = websocket._req = null;
        emitErrorAndClose(websocket, err);
      });
      req.on("response", (res) => {
        const location = res.headers.location;
        const statusCode = res.statusCode;
        if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
          if (++websocket._redirects > opts.maxRedirects) {
            abortHandshake(websocket, req, "Maximum redirects exceeded");
            return;
          }
          req.abort();
          let addr;
          try {
            addr = new URL2(location, address);
          } catch (err) {
            emitErrorAndClose(websocket, err);
            return;
          }
          initAsClient(websocket, addr, protocols, options);
        } else if (!websocket.emit("unexpected-response", req, res)) {
          abortHandshake(
            websocket,
            req,
            `Unexpected server response: ${res.statusCode}`
          );
        }
      });
      req.on("upgrade", (res, socket, head) => {
        websocket.emit("upgrade", res);
        if (websocket.readyState !== WebSocket.CONNECTING) return;
        req = websocket._req = null;
        const upgrade = res.headers.upgrade;
        if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
          abortHandshake(websocket, socket, "Invalid Upgrade header");
          return;
        }
        const digest = createHash("sha1").update(key + GUID).digest("base64");
        if (res.headers["sec-websocket-accept"] !== digest) {
          abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
          return;
        }
        const serverProt = res.headers["sec-websocket-protocol"];
        const protList = (protocols || "").split(/, */);
        let protError;
        if (!protocols && serverProt) {
          protError = "Server sent a subprotocol but none was requested";
        } else if (protocols && !serverProt) {
          protError = "Server sent no subprotocol";
        } else if (serverProt && !protList.includes(serverProt)) {
          protError = "Server sent an invalid subprotocol";
        }
        if (protError) {
          abortHandshake(websocket, socket, protError);
          return;
        }
        if (serverProt) websocket._protocol = serverProt;
        const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
        if (secWebSocketExtensions !== void 0) {
          if (!perMessageDeflate) {
            const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested";
            abortHandshake(websocket, socket, message);
            return;
          }
          let extensions;
          try {
            extensions = parse4(secWebSocketExtensions);
          } catch (err) {
            const message = "Invalid Sec-WebSocket-Extensions header";
            abortHandshake(websocket, socket, message);
            return;
          }
          const extensionNames = Object.keys(extensions);
          if (extensionNames.length) {
            if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
              const message = "Server indicated an extension that was not requested";
              abortHandshake(websocket, socket, message);
              return;
            }
            try {
              perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
            } catch (err) {
              const message = "Invalid Sec-WebSocket-Extensions header";
              abortHandshake(websocket, socket, message);
              return;
            }
            websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
          }
        }
        websocket.setSocket(socket, head, opts.maxPayload);
      });
    }
    function emitErrorAndClose(websocket, err) {
      websocket._readyState = WebSocket.CLOSING;
      websocket.emit("error", err);
      websocket.emitClose();
    }
    function netConnect(options) {
      options.path = options.socketPath;
      return net.connect(options);
    }
    function tlsConnect(options) {
      options.path = void 0;
      if (!options.servername && options.servername !== "") {
        options.servername = net.isIP(options.host) ? "" : options.host;
      }
      return tls.connect(options);
    }
    function abortHandshake(websocket, stream4, message) {
      websocket._readyState = WebSocket.CLOSING;
      const err = new Error(message);
      Error.captureStackTrace(err, abortHandshake);
      if (stream4.setHeader) {
        stream4.abort();
        if (stream4.socket && !stream4.socket.destroyed) {
          stream4.socket.destroy();
        }
        stream4.once("abort", websocket.emitClose.bind(websocket));
        websocket.emit("error", err);
      } else {
        stream4.destroy(err);
        stream4.once("error", websocket.emit.bind(websocket, "error"));
        stream4.once("close", websocket.emitClose.bind(websocket));
      }
    }
    function sendAfterClose(websocket, data, cb) {
      if (data) {
        const length = toBuffer(data).length;
        if (websocket._socket) websocket._sender._bufferedBytes += length;
        else websocket._bufferedAmount += length;
      }
      if (cb) {
        const err = new Error(
          `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
        );
        cb(err);
      }
    }
    function receiverOnConclude(code, reason) {
      const websocket = this[kWebSocket];
      websocket._closeFrameReceived = true;
      websocket._closeMessage = reason;
      websocket._closeCode = code;
      if (websocket._socket[kWebSocket] === void 0) return;
      websocket._socket.removeListener("data", socketOnData);
      process.nextTick(resume, websocket._socket);
      if (code === 1005) websocket.close();
      else websocket.close(code, reason);
    }
    function receiverOnDrain() {
      this[kWebSocket]._socket.resume();
    }
    function receiverOnError(err) {
      const websocket = this[kWebSocket];
      if (websocket._socket[kWebSocket] !== void 0) {
        websocket._socket.removeListener("data", socketOnData);
        process.nextTick(resume, websocket._socket);
        websocket.close(err[kStatusCode]);
      }
      websocket.emit("error", err);
    }
    function receiverOnFinish() {
      this[kWebSocket].emitClose();
    }
    function receiverOnMessage(data) {
      this[kWebSocket].emit("message", data);
    }
    function receiverOnPing(data) {
      const websocket = this[kWebSocket];
      websocket.pong(data, !websocket._isServer, NOOP);
      websocket.emit("ping", data);
    }
    function receiverOnPong(data) {
      this[kWebSocket].emit("pong", data);
    }
    function resume(stream4) {
      stream4.resume();
    }
    function socketOnClose() {
      const websocket = this[kWebSocket];
      this.removeListener("close", socketOnClose);
      this.removeListener("data", socketOnData);
      this.removeListener("end", socketOnEnd);
      websocket._readyState = WebSocket.CLOSING;
      let chunk;
      if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
        websocket._receiver.write(chunk);
      }
      websocket._receiver.end();
      this[kWebSocket] = void 0;
      clearTimeout(websocket._closeTimer);
      if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
        websocket.emitClose();
      } else {
        websocket._receiver.on("error", receiverOnFinish);
        websocket._receiver.on("finish", receiverOnFinish);
      }
    }
    function socketOnData(chunk) {
      if (!this[kWebSocket]._receiver.write(chunk)) {
        this.pause();
      }
    }
    function socketOnEnd() {
      const websocket = this[kWebSocket];
      websocket._readyState = WebSocket.CLOSING;
      websocket._receiver.end();
      this.end();
    }
    function socketOnError() {
      const websocket = this[kWebSocket];
      this.removeListener("error", socketOnError);
      this.on("error", NOOP);
      if (websocket) {
        websocket._readyState = WebSocket.CLOSING;
        this.destroy();
      }
    }
  }
});

// node_modules/express-ws/node_modules/ws/lib/stream.js
var require_stream2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/stream.js"(exports2, module2) {
    "use strict";
    var { Duplex } = require("stream");
    function emitClose(stream4) {
      stream4.emit("close");
    }
    function duplexOnEnd() {
      if (!this.destroyed && this._writableState.finished) {
        this.destroy();
      }
    }
    function duplexOnError(err) {
      this.removeListener("error", duplexOnError);
      this.destroy();
      if (this.listenerCount("error") === 0) {
        this.emit("error", err);
      }
    }
    function createWebSocketStream(ws, options) {
      let resumeOnReceiverDrain = true;
      let terminateOnDestroy = true;
      function receiverOnDrain() {
        if (resumeOnReceiverDrain) ws._socket.resume();
      }
      if (ws.readyState === ws.CONNECTING) {
        ws.once("open", function open() {
          ws._receiver.removeAllListeners("drain");
          ws._receiver.on("drain", receiverOnDrain);
        });
      } else {
        ws._receiver.removeAllListeners("drain");
        ws._receiver.on("drain", receiverOnDrain);
      }
      const duplex = new Duplex({
        ...options,
        autoDestroy: false,
        emitClose: false,
        objectMode: false,
        writableObjectMode: false
      });
      ws.on("message", function message(msg) {
        if (!duplex.push(msg)) {
          resumeOnReceiverDrain = false;
          ws._socket.pause();
        }
      });
      ws.once("error", function error73(err) {
        if (duplex.destroyed) return;
        terminateOnDestroy = false;
        duplex.destroy(err);
      });
      ws.once("close", function close() {
        if (duplex.destroyed) return;
        duplex.push(null);
      });
      duplex._destroy = function(err, callback) {
        if (ws.readyState === ws.CLOSED) {
          callback(err);
          process.nextTick(emitClose, duplex);
          return;
        }
        let called = false;
        ws.once("error", function error73(err2) {
          called = true;
          callback(err2);
        });
        ws.once("close", function close() {
          if (!called) callback(err);
          process.nextTick(emitClose, duplex);
        });
        if (terminateOnDestroy) ws.terminate();
      };
      duplex._final = function(callback) {
        if (ws.readyState === ws.CONNECTING) {
          ws.once("open", function open() {
            duplex._final(callback);
          });
          return;
        }
        if (ws._socket === null) return;
        if (ws._socket._writableState.finished) {
          callback();
          if (duplex._readableState.endEmitted) duplex.destroy();
        } else {
          ws._socket.once("finish", function finish() {
            callback();
          });
          ws.close();
        }
      };
      duplex._read = function() {
        if ((ws.readyState === ws.OPEN || ws.readyState === ws.CLOSING) && !resumeOnReceiverDrain) {
          resumeOnReceiverDrain = true;
          if (!ws._receiver._writableState.needDrain) ws._socket.resume();
        }
      };
      duplex._write = function(chunk, encoding, callback) {
        if (ws.readyState === ws.CONNECTING) {
          ws.once("open", function open() {
            duplex._write(chunk, encoding, callback);
          });
          return;
        }
        ws.send(chunk, callback);
      };
      duplex.on("end", duplexOnEnd);
      duplex.on("error", duplexOnError);
      return duplex;
    }
    module2.exports = createWebSocketStream;
  }
});

// node_modules/express-ws/node_modules/ws/lib/websocket-server.js
var require_websocket_server2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/lib/websocket-server.js"(exports2, module2) {
    "use strict";
    var EventEmitter3 = require("events");
    var http4 = require("http");
    var https2 = require("https");
    var net = require("net");
    var tls = require("tls");
    var { createHash } = require("crypto");
    var PerMessageDeflate = require_permessage_deflate2();
    var WebSocket = require_websocket4();
    var { format, parse: parse4 } = require_extension2();
    var { GUID, kWebSocket } = require_constants2();
    var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
    var RUNNING = 0;
    var CLOSING = 1;
    var CLOSED = 2;
    var WebSocketServer = class extends EventEmitter3 {
      /**
       * Create a `WebSocketServer` instance.
       *
       * @param {Object} options Configuration options
       * @param {Number} [options.backlog=511] The maximum length of the queue of
       *     pending connections
       * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
       *     track clients
       * @param {Function} [options.handleProtocols] A hook to handle protocols
       * @param {String} [options.host] The hostname where to bind the server
       * @param {Number} [options.maxPayload=104857600] The maximum allowed message
       *     size
       * @param {Boolean} [options.noServer=false] Enable no server mode
       * @param {String} [options.path] Accept only connections matching this path
       * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
       *     permessage-deflate
       * @param {Number} [options.port] The port where to bind the server
       * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
       *     server to use
       * @param {Function} [options.verifyClient] A hook to reject connections
       * @param {Function} [callback] A listener for the `listening` event
       */
      constructor(options, callback) {
        super();
        options = {
          maxPayload: 100 * 1024 * 1024,
          perMessageDeflate: false,
          handleProtocols: null,
          clientTracking: true,
          verifyClient: null,
          noServer: false,
          backlog: null,
          // use default (511 as implemented in net.js)
          server: null,
          host: null,
          path: null,
          port: null,
          ...options
        };
        if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
          throw new TypeError(
            'One and only one of the "port", "server", or "noServer" options must be specified'
          );
        }
        if (options.port != null) {
          this._server = http4.createServer((req, res) => {
            const body = http4.STATUS_CODES[426];
            res.writeHead(426, {
              "Content-Length": body.length,
              "Content-Type": "text/plain"
            });
            res.end(body);
          });
          this._server.listen(
            options.port,
            options.host,
            options.backlog,
            callback
          );
        } else if (options.server) {
          this._server = options.server;
        }
        if (this._server) {
          const emitConnection = this.emit.bind(this, "connection");
          this._removeListeners = addListeners(this._server, {
            listening: this.emit.bind(this, "listening"),
            error: this.emit.bind(this, "error"),
            upgrade: (req, socket, head) => {
              this.handleUpgrade(req, socket, head, emitConnection);
            }
          });
        }
        if (options.perMessageDeflate === true) options.perMessageDeflate = {};
        if (options.clientTracking) this.clients = /* @__PURE__ */ new Set();
        this.options = options;
        this._state = RUNNING;
      }
      /**
       * Returns the bound address, the address family name, and port of the server
       * as reported by the operating system if listening on an IP socket.
       * If the server is listening on a pipe or UNIX domain socket, the name is
       * returned as a string.
       *
       * @return {(Object|String|null)} The address of the server
       * @public
       */
      address() {
        if (this.options.noServer) {
          throw new Error('The server is operating in "noServer" mode');
        }
        if (!this._server) return null;
        return this._server.address();
      }
      /**
       * Close the server.
       *
       * @param {Function} [cb] Callback
       * @public
       */
      close(cb) {
        if (cb) this.once("close", cb);
        if (this._state === CLOSED) {
          process.nextTick(emitClose, this);
          return;
        }
        if (this._state === CLOSING) return;
        this._state = CLOSING;
        if (this.clients) {
          for (const client of this.clients) client.terminate();
        }
        const server2 = this._server;
        if (server2) {
          this._removeListeners();
          this._removeListeners = this._server = null;
          if (this.options.port != null) {
            server2.close(emitClose.bind(void 0, this));
            return;
          }
        }
        process.nextTick(emitClose, this);
      }
      /**
       * See if a given request should be handled by this server instance.
       *
       * @param {http.IncomingMessage} req Request object to inspect
       * @return {Boolean} `true` if the request is valid, else `false`
       * @public
       */
      shouldHandle(req) {
        if (this.options.path) {
          const index = req.url.indexOf("?");
          const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
          if (pathname !== this.options.path) return false;
        }
        return true;
      }
      /**
       * Handle a HTTP Upgrade request.
       *
       * @param {http.IncomingMessage} req The request object
       * @param {(net.Socket|tls.Socket)} socket The network socket between the
       *     server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Function} cb Callback
       * @public
       */
      handleUpgrade(req, socket, head, cb) {
        socket.on("error", socketOnError);
        const key = req.headers["sec-websocket-key"] !== void 0 ? req.headers["sec-websocket-key"].trim() : false;
        const upgrade = req.headers.upgrade;
        const version3 = +req.headers["sec-websocket-version"];
        const extensions = {};
        if (req.method !== "GET" || upgrade === void 0 || upgrade.toLowerCase() !== "websocket" || !key || !keyRegex.test(key) || version3 !== 8 && version3 !== 13 || !this.shouldHandle(req)) {
          return abortHandshake(socket, 400);
        }
        if (this.options.perMessageDeflate) {
          const perMessageDeflate = new PerMessageDeflate(
            this.options.perMessageDeflate,
            true,
            this.options.maxPayload
          );
          try {
            const offers = parse4(req.headers["sec-websocket-extensions"]);
            if (offers[PerMessageDeflate.extensionName]) {
              perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
              extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
            }
          } catch (err) {
            return abortHandshake(socket, 400);
          }
        }
        if (this.options.verifyClient) {
          const info = {
            origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
            secure: !!(req.socket.authorized || req.socket.encrypted),
            req
          };
          if (this.options.verifyClient.length === 2) {
            this.options.verifyClient(info, (verified, code, message, headers) => {
              if (!verified) {
                return abortHandshake(socket, code || 401, message, headers);
              }
              this.completeUpgrade(key, extensions, req, socket, head, cb);
            });
            return;
          }
          if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
        }
        this.completeUpgrade(key, extensions, req, socket, head, cb);
      }
      /**
       * Upgrade the connection to WebSocket.
       *
       * @param {String} key The value of the `Sec-WebSocket-Key` header
       * @param {Object} extensions The accepted extensions
       * @param {http.IncomingMessage} req The request object
       * @param {(net.Socket|tls.Socket)} socket The network socket between the
       *     server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Function} cb Callback
       * @throws {Error} If called more than once with the same socket
       * @private
       */
      completeUpgrade(key, extensions, req, socket, head, cb) {
        if (!socket.readable || !socket.writable) return socket.destroy();
        if (socket[kWebSocket]) {
          throw new Error(
            "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
          );
        }
        if (this._state > RUNNING) return abortHandshake(socket, 503);
        const digest = createHash("sha1").update(key + GUID).digest("base64");
        const headers = [
          "HTTP/1.1 101 Switching Protocols",
          "Upgrade: websocket",
          "Connection: Upgrade",
          `Sec-WebSocket-Accept: ${digest}`
        ];
        const ws = new WebSocket(null);
        let protocol = req.headers["sec-websocket-protocol"];
        if (protocol) {
          protocol = protocol.split(",").map(trim2);
          if (this.options.handleProtocols) {
            protocol = this.options.handleProtocols(protocol, req);
          } else {
            protocol = protocol[0];
          }
          if (protocol) {
            headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
            ws._protocol = protocol;
          }
        }
        if (extensions[PerMessageDeflate.extensionName]) {
          const params = extensions[PerMessageDeflate.extensionName].params;
          const value = format({
            [PerMessageDeflate.extensionName]: [params]
          });
          headers.push(`Sec-WebSocket-Extensions: ${value}`);
          ws._extensions = extensions;
        }
        this.emit("headers", headers, req);
        socket.write(headers.concat("\r\n").join("\r\n"));
        socket.removeListener("error", socketOnError);
        ws.setSocket(socket, head, this.options.maxPayload);
        if (this.clients) {
          this.clients.add(ws);
          ws.on("close", () => this.clients.delete(ws));
        }
        cb(ws, req);
      }
    };
    module2.exports = WebSocketServer;
    function addListeners(server2, map3) {
      for (const event of Object.keys(map3)) server2.on(event, map3[event]);
      return function removeListeners() {
        for (const event of Object.keys(map3)) {
          server2.removeListener(event, map3[event]);
        }
      };
    }
    function emitClose(server2) {
      server2._state = CLOSED;
      server2.emit("close");
    }
    function socketOnError() {
      this.destroy();
    }
    function abortHandshake(socket, code, message, headers) {
      if (socket.writable) {
        message = message || http4.STATUS_CODES[code];
        headers = {
          Connection: "close",
          "Content-Type": "text/html",
          "Content-Length": Buffer.byteLength(message),
          ...headers
        };
        socket.write(
          `HTTP/1.1 ${code} ${http4.STATUS_CODES[code]}\r
` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
        );
      }
      socket.removeListener("error", socketOnError);
      socket.destroy();
    }
    function trim2(str) {
      return str.trim();
    }
  }
});

// node_modules/express-ws/node_modules/ws/index.js
var require_ws2 = __commonJS({
  "node_modules/express-ws/node_modules/ws/index.js"(exports2, module2) {
    "use strict";
    var WebSocket = require_websocket4();
    WebSocket.createWebSocketStream = require_stream2();
    WebSocket.Server = require_websocket_server2();
    WebSocket.Receiver = require_receiver2();
    WebSocket.Sender = require_sender2();
    module2.exports = WebSocket;
  }
});

// node_modules/express-ws/lib/trailing-slash.js
var require_trailing_slash = __commonJS({
  "node_modules/express-ws/lib/trailing-slash.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = addTrailingSlash;
    function addTrailingSlash(string5) {
      var suffixed = string5;
      if (suffixed.charAt(suffixed.length - 1) !== "/") {
        suffixed = suffixed + "/";
      }
      return suffixed;
    }
  }
});

// node_modules/express-ws/lib/websocket-url.js
var require_websocket_url = __commonJS({
  "node_modules/express-ws/lib/websocket-url.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    var _slicedToArray = /* @__PURE__ */ (function() {
      function sliceIterator(arr, i) {
        var _arr = [];
        var _n = true;
        var _d = false;
        var _e = void 0;
        try {
          for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
            _arr.push(_s.value);
            if (i && _arr.length === i) break;
          }
        } catch (err) {
          _d = true;
          _e = err;
        } finally {
          try {
            if (!_n && _i["return"]) _i["return"]();
          } finally {
            if (_d) throw _e;
          }
        }
        return _arr;
      }
      return function(arr, i) {
        if (Array.isArray(arr)) {
          return arr;
        } else if (Symbol.iterator in Object(arr)) {
          return sliceIterator(arr, i);
        } else {
          throw new TypeError("Invalid attempt to destructure non-iterable instance");
        }
      };
    })();
    exports2.default = websocketUrl;
    var _trailingSlash = require_trailing_slash();
    var _trailingSlash2 = _interopRequireDefault(_trailingSlash);
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    function websocketUrl(url4) {
      if (url4.indexOf("?") !== -1) {
        var _url$split = url4.split("?"), _url$split2 = _slicedToArray(_url$split, 2), baseUrl = _url$split2[0], query = _url$split2[1];
        return (0, _trailingSlash2.default)(baseUrl) + ".websocket?" + query;
      }
      return (0, _trailingSlash2.default)(url4) + ".websocket";
    }
  }
});

// node_modules/express-ws/lib/wrap-middleware.js
var require_wrap_middleware = __commonJS({
  "node_modules/express-ws/lib/wrap-middleware.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = wrapMiddleware;
    function wrapMiddleware(middleware) {
      return function(req, res, next) {
        if (req.ws !== null && req.ws !== void 0) {
          req.wsHandled = true;
          try {
            middleware(req.ws, req, next);
          } catch (err) {
            next(err);
          }
        } else {
          next();
        }
      };
    }
  }
});

// node_modules/express-ws/lib/add-ws-method.js
var require_add_ws_method = __commonJS({
  "node_modules/express-ws/lib/add-ws-method.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = addWsMethod;
    var _wrapMiddleware = require_wrap_middleware();
    var _wrapMiddleware2 = _interopRequireDefault(_wrapMiddleware);
    var _websocketUrl = require_websocket_url();
    var _websocketUrl2 = _interopRequireDefault(_websocketUrl);
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    function _toConsumableArray(arr) {
      if (Array.isArray(arr)) {
        for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
          arr2[i] = arr[i];
        }
        return arr2;
      } else {
        return Array.from(arr);
      }
    }
    function addWsMethod(target) {
      if (target.ws === null || target.ws === void 0) {
        target.ws = function addWsRoute(route) {
          for (var _len = arguments.length, middlewares = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            middlewares[_key - 1] = arguments[_key];
          }
          var wrappedMiddlewares = middlewares.map(_wrapMiddleware2.default);
          var wsRoute = (0, _websocketUrl2.default)(route);
          this.get.apply(this, _toConsumableArray([wsRoute].concat(wrappedMiddlewares)));
          return this;
        };
      }
    }
  }
});

// node_modules/express-ws/lib/index.js
var require_lib4 = __commonJS({
  "node_modules/express-ws/lib/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = expressWs2;
    var _http = require("http");
    var _http2 = _interopRequireDefault(_http);
    var _express = require_express2();
    var _express2 = _interopRequireDefault(_express);
    var _ws = require_ws2();
    var _ws2 = _interopRequireDefault(_ws);
    var _websocketUrl = require_websocket_url();
    var _websocketUrl2 = _interopRequireDefault(_websocketUrl);
    var _addWsMethod = require_add_ws_method();
    var _addWsMethod2 = _interopRequireDefault(_addWsMethod);
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    function expressWs2(app2, httpServer) {
      var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
      var server2 = httpServer;
      if (server2 === null || server2 === void 0) {
        server2 = _http2.default.createServer(app2);
        app2.listen = function serverListen() {
          var _server;
          return (_server = server2).listen.apply(_server, arguments);
        };
      }
      (0, _addWsMethod2.default)(app2);
      if (!options.leaveRouterUntouched) {
        (0, _addWsMethod2.default)(_express2.default.Router);
      }
      var wsOptions = options.wsOptions || {};
      wsOptions.server = server2;
      var wsServer = new _ws2.default.Server(wsOptions);
      wsServer.on("connection", function(socket, request) {
        if ("upgradeReq" in socket) {
          request = socket.upgradeReq;
        }
        request.ws = socket;
        request.wsHandled = false;
        request.url = (0, _websocketUrl2.default)(request.url);
        var dummyResponse = new _http2.default.ServerResponse(request);
        dummyResponse.writeHead = function writeHead(statusCode) {
          if (statusCode > 200) {
            dummyResponse._header = "";
            socket.close();
          }
        };
        app2.handle(request, dummyResponse, function() {
          if (!request.wsHandled) {
            socket.close();
          }
        });
      });
      return {
        app: app2,
        getWss: function getWss() {
          return wsServer;
        },
        applyTo: function applyTo(router173) {
          (0, _addWsMethod2.default)(router173);
        }
      };
    }
  }
});

// node_modules/express-ws/index.js
var require_express_ws = __commonJS({
  "node_modules/express-ws/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_lib4().default;
  }
});

// node_modules/basic-auth/node_modules/safe-buffer/index.js
var require_safe_buffer = __commonJS({
  "node_modules/basic-auth/node_modules/safe-buffer/index.js"(exports2, module2) {
    "use strict";
    var buffer = require("buffer");
    var Buffer3 = buffer.Buffer;
    function copyProps(src, dst) {
      for (var key in src) {
        dst[key] = src[key];
      }
    }
    if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow) {
      module2.exports = buffer;
    } else {
      copyProps(buffer, exports2);
      exports2.Buffer = SafeBuffer;
    }
    function SafeBuffer(arg, encodingOrOffset, length) {
      return Buffer3(arg, encodingOrOffset, length);
    }
    copyProps(Buffer3, SafeBuffer);
    SafeBuffer.from = function(arg, encodingOrOffset, length) {
      if (typeof arg === "number") {
        throw new TypeError("Argument must not be a number");
      }
      return Buffer3(arg, encodingOrOffset, length);
    };
    SafeBuffer.alloc = function(size, fill, encoding) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      var buf = Buffer3(size);
      if (fill !== void 0) {
        if (typeof encoding === "string") {
          buf.fill(fill, encoding);
        } else {
          buf.fill(fill);
        }
      } else {
        buf.fill(0);
      }
      return buf;
    };
    SafeBuffer.allocUnsafe = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return Buffer3(size);
    };
    SafeBuffer.allocUnsafeSlow = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return buffer.SlowBuffer(size);
    };
  }
});

// node_modules/basic-auth/index.js
var require_basic_auth = __commonJS({
  "node_modules/basic-auth/index.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safe_buffer().Buffer;
    module2.exports = auth;
    module2.exports.parse = parse4;
    var CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
    var USER_PASS_REGEXP = /^([^:]*):(.*)$/;
    function auth(req) {
      if (!req) {
        throw new TypeError("argument req is required");
      }
      if (typeof req !== "object") {
        throw new TypeError("argument req is required to be an object");
      }
      var header = getAuthorization(req);
      return parse4(header);
    }
    function decodeBase64(str) {
      return Buffer3.from(str, "base64").toString();
    }
    function getAuthorization(req) {
      if (!req.headers || typeof req.headers !== "object") {
        throw new TypeError("argument req is required to have headers property");
      }
      return req.headers.authorization;
    }
    function parse4(string5) {
      if (typeof string5 !== "string") {
        return void 0;
      }
      var match = CREDENTIALS_REGEXP.exec(string5);
      if (!match) {
        return void 0;
      }
      var userPass = USER_PASS_REGEXP.exec(decodeBase64(match[1]));
      if (!userPass) {
        return void 0;
      }
      return new Credentials(userPass[1], userPass[2]);
    }
    function Credentials(name28, pass) {
      this.name = name28;
      this.pass = pass;
    }
  }
});

// node_modules/morgan/node_modules/ms/index.js
var require_ms2 = __commonJS({
  "node_modules/morgan/node_modules/ms/index.js"(exports2, module2) {
    "use strict";
    var s = 1e3;
    var m = s * 60;
    var h = m * 60;
    var d = h * 24;
    var y = d * 365.25;
    module2.exports = function(val, options) {
      options = options || {};
      var type = typeof val;
      if (type === "string" && val.length > 0) {
        return parse4(val);
      } else if (type === "number" && isNaN(val) === false) {
        return options.long ? fmtLong(val) : fmtShort(val);
      }
      throw new Error(
        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
      );
    };
    function parse4(str) {
      str = String(str);
      if (str.length > 100) {
        return;
      }
      var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
        str
      );
      if (!match) {
        return;
      }
      var n = parseFloat(match[1]);
      var type = (match[2] || "ms").toLowerCase();
      switch (type) {
        case "years":
        case "year":
        case "yrs":
        case "yr":
        case "y":
          return n * y;
        case "days":
        case "day":
        case "d":
          return n * d;
        case "hours":
        case "hour":
        case "hrs":
        case "hr":
        case "h":
          return n * h;
        case "minutes":
        case "minute":
        case "mins":
        case "min":
        case "m":
          return n * m;
        case "seconds":
        case "second":
        case "secs":
        case "sec":
        case "s":
          return n * s;
        case "milliseconds":
        case "millisecond":
        case "msecs":
        case "msec":
        case "ms":
          return n;
        default:
          return void 0;
      }
    }
    function fmtShort(ms) {
      if (ms >= d) {
        return Math.round(ms / d) + "d";
      }
      if (ms >= h) {
        return Math.round(ms / h) + "h";
      }
      if (ms >= m) {
        return Math.round(ms / m) + "m";
      }
      if (ms >= s) {
        return Math.round(ms / s) + "s";
      }
      return ms + "ms";
    }
    function fmtLong(ms) {
      return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms";
    }
    function plural(ms, n, name28) {
      if (ms < n) {
        return;
      }
      if (ms < n * 1.5) {
        return Math.floor(ms / n) + " " + name28;
      }
      return Math.ceil(ms / n) + " " + name28 + "s";
    }
  }
});

// node_modules/morgan/node_modules/debug/src/debug.js
var require_debug = __commonJS({
  "node_modules/morgan/node_modules/debug/src/debug.js"(exports2, module2) {
    "use strict";
    exports2 = module2.exports = createDebug.debug = createDebug["default"] = createDebug;
    exports2.coerce = coerce;
    exports2.disable = disable;
    exports2.enable = enable;
    exports2.enabled = enabled;
    exports2.humanize = require_ms2();
    exports2.names = [];
    exports2.skips = [];
    exports2.formatters = {};
    var prevTime;
    function selectColor(namespace) {
      var hash3 = 0, i;
      for (i in namespace) {
        hash3 = (hash3 << 5) - hash3 + namespace.charCodeAt(i);
        hash3 |= 0;
      }
      return exports2.colors[Math.abs(hash3) % exports2.colors.length];
    }
    function createDebug(namespace) {
      function debug() {
        if (!debug.enabled) return;
        var self2 = debug;
        var curr = +/* @__PURE__ */ new Date();
        var ms = curr - (prevTime || curr);
        self2.diff = ms;
        self2.prev = prevTime;
        self2.curr = curr;
        prevTime = curr;
        var args = new Array(arguments.length);
        for (var i = 0; i < args.length; i++) {
          args[i] = arguments[i];
        }
        args[0] = exports2.coerce(args[0]);
        if ("string" !== typeof args[0]) {
          args.unshift("%O");
        }
        var index = 0;
        args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
          if (match === "%%") return match;
          index++;
          var formatter = exports2.formatters[format];
          if ("function" === typeof formatter) {
            var val = args[index];
            match = formatter.call(self2, val);
            args.splice(index, 1);
            index--;
          }
          return match;
        });
        exports2.formatArgs.call(self2, args);
        var logFn = debug.log || exports2.log || console.log.bind(console);
        logFn.apply(self2, args);
      }
      debug.namespace = namespace;
      debug.enabled = exports2.enabled(namespace);
      debug.useColors = exports2.useColors();
      debug.color = selectColor(namespace);
      if ("function" === typeof exports2.init) {
        exports2.init(debug);
      }
      return debug;
    }
    function enable(namespaces) {
      exports2.save(namespaces);
      exports2.names = [];
      exports2.skips = [];
      var split2 = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
      var len = split2.length;
      for (var i = 0; i < len; i++) {
        if (!split2[i]) continue;
        namespaces = split2[i].replace(/\*/g, ".*?");
        if (namespaces[0] === "-") {
          exports2.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
        } else {
          exports2.names.push(new RegExp("^" + namespaces + "$"));
        }
      }
    }
    function disable() {
      exports2.enable("");
    }
    function enabled(name28) {
      var i, len;
      for (i = 0, len = exports2.skips.length; i < len; i++) {
        if (exports2.skips[i].test(name28)) {
          return false;
        }
      }
      for (i = 0, len = exports2.names.length; i < len; i++) {
        if (exports2.names[i].test(name28)) {
          return true;
        }
      }
      return false;
    }
    function coerce(val) {
      if (val instanceof Error) return val.stack || val.message;
      return val;
    }
  }
});

// node_modules/morgan/node_modules/debug/src/browser.js
var require_browser2 = __commonJS({
  "node_modules/morgan/node_modules/debug/src/browser.js"(exports2, module2) {
    "use strict";
    exports2 = module2.exports = require_debug();
    exports2.log = log;
    exports2.formatArgs = formatArgs;
    exports2.save = save;
    exports2.load = load;
    exports2.useColors = useColors;
    exports2.storage = "undefined" != typeof chrome && "undefined" != typeof chrome.storage ? chrome.storage.local : localstorage();
    exports2.colors = [
      "lightseagreen",
      "forestgreen",
      "goldenrod",
      "dodgerblue",
      "darkorchid",
      "crimson"
    ];
    function useColors() {
      if (typeof window !== "undefined" && window.process && window.process.type === "renderer") {
        return true;
      }
      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // is firebug? http://stackoverflow.com/a/398120/376773
      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // is firefox >= v31?
      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // double check webkit in userAgent just in case we are in a worker
      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
    }
    exports2.formatters.j = function(v) {
      try {
        return JSON.stringify(v);
      } catch (err) {
        return "[UnexpectedJSONParseError]: " + err.message;
      }
    };
    function formatArgs(args) {
      var useColors2 = this.useColors;
      args[0] = (useColors2 ? "%c" : "") + this.namespace + (useColors2 ? " %c" : " ") + args[0] + (useColors2 ? "%c " : " ") + "+" + exports2.humanize(this.diff);
      if (!useColors2) return;
      var c = "color: " + this.color;
      args.splice(1, 0, c, "color: inherit");
      var index = 0;
      var lastC = 0;
      args[0].replace(/%[a-zA-Z%]/g, function(match) {
        if ("%%" === match) return;
        index++;
        if ("%c" === match) {
          lastC = index;
        }
      });
      args.splice(lastC, 0, c);
    }
    function log() {
      return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
    }
    function save(namespaces) {
      try {
        if (null == namespaces) {
          exports2.storage.removeItem("debug");
        } else {
          exports2.storage.debug = namespaces;
        }
      } catch (e) {
      }
    }
    function load() {
      var r;
      try {
        r = exports2.storage.debug;
      } catch (e) {
      }
      if (!r && typeof process !== "undefined" && "env" in process) {
        r = process.env.DEBUG;
      }
      return r;
    }
    exports2.enable(load());
    function localstorage() {
      try {
        return window.localStorage;
      } catch (e) {
      }
    }
  }
});

// node_modules/morgan/node_modules/debug/src/node.js
var require_node2 = __commonJS({
  "node_modules/morgan/node_modules/debug/src/node.js"(exports2, module2) {
    "use strict";
    var tty = require("tty");
    var util4 = require("util");
    exports2 = module2.exports = require_debug();
    exports2.init = init;
    exports2.log = log;
    exports2.formatArgs = formatArgs;
    exports2.save = save;
    exports2.load = load;
    exports2.useColors = useColors;
    exports2.colors = [6, 2, 3, 4, 5, 1];
    exports2.inspectOpts = Object.keys(process.env).filter(function(key) {
      return /^debug_/i.test(key);
    }).reduce(function(obj, key) {
      var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function(_, k) {
        return k.toUpperCase();
      });
      var val = process.env[key];
      if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
      else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
      else if (val === "null") val = null;
      else val = Number(val);
      obj[prop] = val;
      return obj;
    }, {});
    var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
    if (1 !== fd && 2 !== fd) {
      util4.deprecate(function() {
      }, "except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)")();
    }
    var stream4 = 1 === fd ? process.stdout : 2 === fd ? process.stderr : createWritableStdioStream(fd);
    function useColors() {
      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(fd);
    }
    exports2.formatters.o = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v, this.inspectOpts).split("\n").map(function(str) {
        return str.trim();
      }).join(" ");
    };
    exports2.formatters.O = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v, this.inspectOpts);
    };
    function formatArgs(args) {
      var name28 = this.namespace;
      var useColors2 = this.useColors;
      if (useColors2) {
        var c = this.color;
        var prefix = "  \x1B[3" + c + ";1m" + name28 + " \x1B[0m";
        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
        args.push("\x1B[3" + c + "m+" + exports2.humanize(this.diff) + "\x1B[0m");
      } else {
        args[0] = (/* @__PURE__ */ new Date()).toUTCString() + " " + name28 + " " + args[0];
      }
    }
    function log() {
      return stream4.write(util4.format.apply(util4, arguments) + "\n");
    }
    function save(namespaces) {
      if (null == namespaces) {
        delete process.env.DEBUG;
      } else {
        process.env.DEBUG = namespaces;
      }
    }
    function load() {
      return process.env.DEBUG;
    }
    function createWritableStdioStream(fd2) {
      var stream5;
      var tty_wrap = process.binding("tty_wrap");
      switch (tty_wrap.guessHandleType(fd2)) {
        case "TTY":
          stream5 = new tty.WriteStream(fd2);
          stream5._type = "tty";
          if (stream5._handle && stream5._handle.unref) {
            stream5._handle.unref();
          }
          break;
        case "FILE":
          var fs34 = require("fs");
          stream5 = new fs34.SyncWriteStream(fd2, { autoClose: false });
          stream5._type = "fs";
          break;
        case "PIPE":
        case "TCP":
          var net = require("net");
          stream5 = new net.Socket({
            fd: fd2,
            readable: false,
            writable: true
          });
          stream5.readable = false;
          stream5.read = null;
          stream5._type = "pipe";
          if (stream5._handle && stream5._handle.unref) {
            stream5._handle.unref();
          }
          break;
        default:
          throw new Error("Implement me. Unknown stream file type!");
      }
      stream5.fd = fd2;
      stream5._isStdio = true;
      return stream5;
    }
    function init(debug) {
      debug.inspectOpts = {};
      var keys2 = Object.keys(exports2.inspectOpts);
      for (var i = 0; i < keys2.length; i++) {
        debug.inspectOpts[keys2[i]] = exports2.inspectOpts[keys2[i]];
      }
    }
    exports2.enable(load());
  }
});

// node_modules/morgan/node_modules/debug/src/index.js
var require_src2 = __commonJS({
  "node_modules/morgan/node_modules/debug/src/index.js"(exports2, module2) {
    "use strict";
    if (typeof process !== "undefined" && process.type === "renderer") {
      module2.exports = require_browser2();
    } else {
      module2.exports = require_node2();
    }
  }
});

// node_modules/morgan/node_modules/on-finished/index.js
var require_on_finished2 = __commonJS({
  "node_modules/morgan/node_modules/on-finished/index.js"(exports2, module2) {
    "use strict";
    module2.exports = onFinished;
    module2.exports.isFinished = isFinished;
    var first = require_ee_first();
    var defer = typeof setImmediate === "function" ? setImmediate : function(fn) {
      process.nextTick(fn.bind.apply(fn, arguments));
    };
    function onFinished(msg, listener) {
      if (isFinished(msg) !== false) {
        defer(listener, null, msg);
        return msg;
      }
      attachListener(msg, listener);
      return msg;
    }
    function isFinished(msg) {
      var socket = msg.socket;
      if (typeof msg.finished === "boolean") {
        return Boolean(msg.finished || socket && !socket.writable);
      }
      if (typeof msg.complete === "boolean") {
        return Boolean(msg.upgrade || !socket || !socket.readable || msg.complete && !msg.readable);
      }
      return void 0;
    }
    function attachFinishedListener(msg, callback) {
      var eeMsg;
      var eeSocket;
      var finished = false;
      function onFinish(error73) {
        eeMsg.cancel();
        eeSocket.cancel();
        finished = true;
        callback(error73);
      }
      eeMsg = eeSocket = first([[msg, "end", "finish"]], onFinish);
      function onSocket(socket) {
        msg.removeListener("socket", onSocket);
        if (finished) return;
        if (eeMsg !== eeSocket) return;
        eeSocket = first([[socket, "error", "close"]], onFinish);
      }
      if (msg.socket) {
        onSocket(msg.socket);
        return;
      }
      msg.on("socket", onSocket);
      if (msg.socket === void 0) {
        patchAssignSocket(msg, onSocket);
      }
    }
    function attachListener(msg, listener) {
      var attached = msg.__onFinished;
      if (!attached || !attached.queue) {
        attached = msg.__onFinished = createListener(msg);
        attachFinishedListener(msg, attached);
      }
      attached.queue.push(listener);
    }
    function createListener(msg) {
      function listener(err) {
        if (msg.__onFinished === listener) msg.__onFinished = null;
        if (!listener.queue) return;
        var queue = listener.queue;
        listener.queue = null;
        for (var i = 0; i < queue.length; i++) {
          queue[i](err, msg);
        }
      }
      listener.queue = [];
      return listener;
    }
    function patchAssignSocket(res, callback) {
      var assignSocket = res.assignSocket;
      if (typeof assignSocket !== "function") return;
      res.assignSocket = function _assignSocket(socket) {
        assignSocket.call(this, socket);
        callback(socket);
      };
    }
  }
});

// node_modules/on-headers/index.js
var require_on_headers = __commonJS({
  "node_modules/on-headers/index.js"(exports2, module2) {
    "use strict";
    module2.exports = onHeaders;
    var http4 = require("http");
    var isAppendHeaderSupported = typeof http4.ServerResponse.prototype.appendHeader === "function";
    var set1dArray = isAppendHeaderSupported ? set1dArrayWithAppend : set1dArrayWithSet;
    function createWriteHead(prevWriteHead, listener) {
      var fired = false;
      return function writeHead(statusCode) {
        var args = setWriteHeadHeaders.apply(this, arguments);
        if (!fired) {
          fired = true;
          listener.call(this);
          if (typeof args[0] === "number" && this.statusCode !== args[0]) {
            args[0] = this.statusCode;
            args.length = 1;
          }
        }
        return prevWriteHead.apply(this, args);
      };
    }
    function onHeaders(res, listener) {
      if (!res) {
        throw new TypeError("argument res is required");
      }
      if (typeof listener !== "function") {
        throw new TypeError("argument listener must be a function");
      }
      res.writeHead = createWriteHead(res.writeHead, listener);
    }
    function setHeadersFromArray(res, headers) {
      if (headers.length && Array.isArray(headers[0])) {
        set2dArray(res, headers);
      } else {
        if (headers.length % 2 !== 0) {
          throw new TypeError("headers array is malformed");
        }
        set1dArray(res, headers);
      }
    }
    function setHeadersFromObject(res, headers) {
      var keys2 = Object.keys(headers);
      for (var i = 0; i < keys2.length; i++) {
        var k = keys2[i];
        if (k) res.setHeader(k, headers[k]);
      }
    }
    function setWriteHeadHeaders(statusCode) {
      var length = arguments.length;
      var headerIndex = length > 1 && typeof arguments[1] === "string" ? 2 : 1;
      var headers = length >= headerIndex + 1 ? arguments[headerIndex] : void 0;
      this.statusCode = statusCode;
      if (Array.isArray(headers)) {
        setHeadersFromArray(this, headers);
      } else if (headers) {
        setHeadersFromObject(this, headers);
      }
      var args = new Array(Math.min(length, headerIndex));
      for (var i = 0; i < args.length; i++) {
        args[i] = arguments[i];
      }
      return args;
    }
    function set2dArray(res, headers) {
      var key;
      for (var i = 0; i < headers.length; i++) {
        key = headers[i][0];
        if (key) {
          res.setHeader(key, headers[i][1]);
        }
      }
    }
    function set1dArrayWithAppend(res, headers) {
      for (var i = 0; i < headers.length; i += 2) {
        res.removeHeader(headers[i]);
      }
      var key;
      for (var j = 0; j < headers.length; j += 2) {
        key = headers[j];
        if (key) {
          res.appendHeader(key, headers[j + 1]);
        }
      }
    }
    function set1dArrayWithSet(res, headers) {
      var key;
      for (var i = 0; i < headers.length; i += 2) {
        key = headers[i];
        if (key) {
          res.setHeader(key, headers[i + 1]);
        }
      }
    }
  }
});

// node_modules/morgan/index.js
var require_morgan = __commonJS({
  "node_modules/morgan/index.js"(exports2, module2) {
    "use strict";
    module2.exports = morgan;
    module2.exports.compile = compile;
    module2.exports.format = format;
    module2.exports.token = token;
    var auth = require_basic_auth();
    var debug = require_src2()("morgan");
    var deprecate = require_depd()("morgan");
    var onFinished = require_on_finished2();
    var onHeaders = require_on_headers();
    var CLF_MONTH = [
      "Jan",
      "Feb",
      "Mar",
      "Apr",
      "May",
      "Jun",
      "Jul",
      "Aug",
      "Sep",
      "Oct",
      "Nov",
      "Dec"
    ];
    var DEFAULT_BUFFER_DURATION = 1e3;
    function morgan(format2, options) {
      var fmt = format2;
      var opts = options || {};
      if (format2 && typeof format2 === "object") {
        opts = format2;
        fmt = opts.format || "default";
        deprecate("morgan(options): use morgan(" + (typeof fmt === "string" ? JSON.stringify(fmt) : "format") + ", options) instead");
      }
      if (fmt === void 0) {
        deprecate("undefined format: specify a format");
      }
      var immediate = opts.immediate;
      var skip = opts.skip || false;
      var formatLine = typeof fmt !== "function" ? getFormatFunction(fmt) : fmt;
      var buffer = opts.buffer;
      var stream4 = opts.stream || process.stdout;
      if (buffer) {
        deprecate("buffer option");
        var interval = typeof buffer !== "number" ? DEFAULT_BUFFER_DURATION : buffer;
        stream4 = createBufferStream(stream4, interval);
      }
      return function logger3(req, res, next) {
        req._startAt = void 0;
        req._startTime = void 0;
        req._remoteAddress = getip(req);
        res._startAt = void 0;
        res._startTime = void 0;
        recordStartTime.call(req);
        function logRequest() {
          if (skip !== false && skip(req, res)) {
            debug("skip request");
            return;
          }
          var line = formatLine(morgan, req, res);
          if (line == null) {
            debug("skip line");
            return;
          }
          debug("log request");
          stream4.write(line + "\n");
        }
        ;
        if (immediate) {
          logRequest();
        } else {
          onHeaders(res, recordStartTime);
          onFinished(res, logRequest);
        }
        next();
      };
    }
    morgan.format("combined", ':remote-addr - :remote-user [:date[clf]] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"');
    morgan.format("common", ':remote-addr - :remote-user [:date[clf]] ":method :url HTTP/:http-version" :status :res[content-length]');
    morgan.format("default", ':remote-addr - :remote-user [:date] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent"');
    deprecate.property(morgan, "default", "default format: use combined format");
    morgan.format("short", ":remote-addr :remote-user :method :url HTTP/:http-version :status :res[content-length] - :response-time ms");
    morgan.format("tiny", ":method :url :status :res[content-length] - :response-time ms");
    morgan.format("dev", function developmentFormatLine(tokens, req, res) {
      var status = headersSent(res) ? res.statusCode : void 0;
      var color = status >= 500 ? 31 : status >= 400 ? 33 : status >= 300 ? 36 : status >= 200 ? 32 : 0;
      var fn = developmentFormatLine[color];
      if (!fn) {
        fn = developmentFormatLine[color] = compile("\x1B[0m:method :url \x1B[" + color + "m:status\x1B[0m :response-time ms - :res[content-length]\x1B[0m");
      }
      return fn(tokens, req, res);
    });
    morgan.token("url", function getUrlToken(req) {
      return req.originalUrl || req.url;
    });
    morgan.token("method", function getMethodToken(req) {
      return req.method;
    });
    morgan.token("response-time", function getResponseTimeToken(req, res, digits) {
      if (!req._startAt || !res._startAt) {
        return;
      }
      var ms = (res._startAt[0] - req._startAt[0]) * 1e3 + (res._startAt[1] - req._startAt[1]) * 1e-6;
      return ms.toFixed(digits === void 0 ? 3 : digits);
    });
    morgan.token("total-time", function getTotalTimeToken(req, res, digits) {
      if (!req._startAt || !res._startAt) {
        return;
      }
      var elapsed = process.hrtime(req._startAt);
      var ms = elapsed[0] * 1e3 + elapsed[1] * 1e-6;
      return ms.toFixed(digits === void 0 ? 3 : digits);
    });
    morgan.token("date", function getDateToken(req, res, format2) {
      var date6 = /* @__PURE__ */ new Date();
      switch (format2 || "web") {
        case "clf":
          return clfdate(date6);
        case "iso":
          return date6.toISOString();
        case "web":
          return date6.toUTCString();
      }
    });
    morgan.token("status", function getStatusToken(req, res) {
      return headersSent(res) ? String(res.statusCode) : void 0;
    });
    morgan.token("referrer", function getReferrerToken(req) {
      return req.headers.referer || req.headers.referrer;
    });
    morgan.token("remote-addr", getip);
    morgan.token("remote-user", function getRemoteUserToken(req) {
      var credentials = auth(req);
      return credentials ? credentials.name : void 0;
    });
    morgan.token("http-version", function getHttpVersionToken(req) {
      return req.httpVersionMajor + "." + req.httpVersionMinor;
    });
    morgan.token("user-agent", function getUserAgentToken(req) {
      return req.headers["user-agent"];
    });
    morgan.token("req", function getRequestToken(req, res, field) {
      var header = req.headers[field.toLowerCase()];
      return Array.isArray(header) ? header.join(", ") : header;
    });
    morgan.token("res", function getResponseHeader(req, res, field) {
      if (!headersSent(res)) {
        return void 0;
      }
      var header = res.getHeader(field);
      return Array.isArray(header) ? header.join(", ") : header;
    });
    function clfdate(dateTime) {
      var date6 = dateTime.getUTCDate();
      var hour = dateTime.getUTCHours();
      var mins = dateTime.getUTCMinutes();
      var secs = dateTime.getUTCSeconds();
      var year = dateTime.getUTCFullYear();
      var month = CLF_MONTH[dateTime.getUTCMonth()];
      return pad2(date6) + "/" + month + "/" + year + ":" + pad2(hour) + ":" + pad2(mins) + ":" + pad2(secs) + " +0000";
    }
    function compile(format2) {
      if (typeof format2 !== "string") {
        throw new TypeError("argument format must be a string");
      }
      var fmt = String(JSON.stringify(format2));
      var js = '  "use strict"\n  return ' + fmt.replace(/:([-\w]{2,})(?:\[([^\]]+)\])?/g, function(_, name28, arg) {
        var tokenArguments = "req, res";
        var tokenFunction = "tokens[" + String(JSON.stringify(name28)) + "]";
        if (arg !== void 0) {
          tokenArguments += ", " + String(JSON.stringify(arg));
        }
        return '" +\n    (' + tokenFunction + "(" + tokenArguments + ') || "-") + "';
      });
      return new Function("tokens, req, res", js);
    }
    function createBufferStream(stream4, interval) {
      var buf = [];
      var timer = null;
      function flush() {
        timer = null;
        stream4.write(buf.join(""));
        buf.length = 0;
      }
      function write(str) {
        if (timer === null) {
          timer = setTimeout(flush, interval);
        }
        buf.push(str);
      }
      return { write };
    }
    function format(name28, fmt) {
      morgan[name28] = fmt;
      return this;
    }
    function getFormatFunction(name28) {
      var fmt = morgan[name28] || name28 || morgan.default;
      return typeof fmt !== "function" ? compile(fmt) : fmt;
    }
    function getip(req) {
      return req.ip || req._remoteAddress || req.connection && req.connection.remoteAddress || void 0;
    }
    function headersSent(res) {
      return typeof res.headersSent !== "boolean" ? Boolean(res._header) : res.headersSent;
    }
    function pad2(num) {
      var str = String(num);
      return (str.length === 1 ? "0" : "") + str;
    }
    function recordStartTime() {
      this._startAt = process.hrtime();
      this._startTime = /* @__PURE__ */ new Date();
    }
    function token(name28, fn) {
      morgan[name28] = fn;
      return this;
    }
  }
});

// node_modules/fast-glob/out/utils/array.js
var require_array = __commonJS({
  "node_modules/fast-glob/out/utils/array.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.splitWhen = exports2.flatten = void 0;
    function flatten(items) {
      return items.reduce((collection, item) => [].concat(collection, item), []);
    }
    exports2.flatten = flatten;
    function splitWhen(items, predicate) {
      const result = [[]];
      let groupIndex = 0;
      for (const item of items) {
        if (predicate(item)) {
          groupIndex++;
          result[groupIndex] = [];
        } else {
          result[groupIndex].push(item);
        }
      }
      return result;
    }
    exports2.splitWhen = splitWhen;
  }
});

// node_modules/fast-glob/out/utils/errno.js
var require_errno = __commonJS({
  "node_modules/fast-glob/out/utils/errno.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isEnoentCodeError = void 0;
    function isEnoentCodeError(error73) {
      return error73.code === "ENOENT";
    }
    exports2.isEnoentCodeError = isEnoentCodeError;
  }
});

// node_modules/fast-glob/out/utils/fs.js
var require_fs = __commonJS({
  "node_modules/fast-glob/out/utils/fs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createDirentFromStats = void 0;
    var DirentFromStats = class {
      constructor(name28, stats) {
        this.name = name28;
        this.isBlockDevice = stats.isBlockDevice.bind(stats);
        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
        this.isDirectory = stats.isDirectory.bind(stats);
        this.isFIFO = stats.isFIFO.bind(stats);
        this.isFile = stats.isFile.bind(stats);
        this.isSocket = stats.isSocket.bind(stats);
        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
      }
    };
    function createDirentFromStats(name28, stats) {
      return new DirentFromStats(name28, stats);
    }
    exports2.createDirentFromStats = createDirentFromStats;
  }
});

// node_modules/fast-glob/out/utils/path.js
var require_path = __commonJS({
  "node_modules/fast-glob/out/utils/path.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.convertPosixPathToPattern = exports2.convertWindowsPathToPattern = exports2.convertPathToPattern = exports2.escapePosixPath = exports2.escapeWindowsPath = exports2.escape = exports2.removeLeadingDotSegment = exports2.makeAbsolute = exports2.unixify = void 0;
    var os = require("os");
    var path33 = require("path");
    var IS_WINDOWS_PLATFORM = os.platform() === "win32";
    var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
    var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
    var WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
    var DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
    var WINDOWS_BACKSLASHES_RE = /\\(?![!()+@[\]{}])/g;
    function unixify(filepath) {
      return filepath.replace(/\\/g, "/");
    }
    exports2.unixify = unixify;
    function makeAbsolute(cwd, filepath) {
      return path33.resolve(cwd, filepath);
    }
    exports2.makeAbsolute = makeAbsolute;
    function removeLeadingDotSegment(entry) {
      if (entry.charAt(0) === ".") {
        const secondCharactery = entry.charAt(1);
        if (secondCharactery === "/" || secondCharactery === "\\") {
          return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
        }
      }
      return entry;
    }
    exports2.removeLeadingDotSegment = removeLeadingDotSegment;
    exports2.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
    function escapeWindowsPath(pattern) {
      return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
    }
    exports2.escapeWindowsPath = escapeWindowsPath;
    function escapePosixPath(pattern) {
      return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, "\\$2");
    }
    exports2.escapePosixPath = escapePosixPath;
    exports2.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
    function convertWindowsPathToPattern(filepath) {
      return escapeWindowsPath(filepath).replace(DOS_DEVICE_PATH_RE, "//$1").replace(WINDOWS_BACKSLASHES_RE, "/");
    }
    exports2.convertWindowsPathToPattern = convertWindowsPathToPattern;
    function convertPosixPathToPattern(filepath) {
      return escapePosixPath(filepath);
    }
    exports2.convertPosixPathToPattern = convertPosixPathToPattern;
  }
});

// node_modules/is-extglob/index.js
var require_is_extglob = __commonJS({
  "node_modules/is-extglob/index.js"(exports2, module2) {
    "use strict";
    module2.exports = function isExtglob(str) {
      if (typeof str !== "string" || str === "") {
        return false;
      }
      var match;
      while (match = /(\\).|([@?!+*]\(.*\))/g.exec(str)) {
        if (match[2]) return true;
        str = str.slice(match.index + match[0].length);
      }
      return false;
    };
  }
});

// node_modules/is-glob/index.js
var require_is_glob = __commonJS({
  "node_modules/is-glob/index.js"(exports2, module2) {
    "use strict";
    var isExtglob = require_is_extglob();
    var chars = { "{": "}", "(": ")", "[": "]" };
    var strictCheck = function(str) {
      if (str[0] === "!") {
        return true;
      }
      var index = 0;
      var pipeIndex = -2;
      var closeSquareIndex = -2;
      var closeCurlyIndex = -2;
      var closeParenIndex = -2;
      var backSlashIndex = -2;
      while (index < str.length) {
        if (str[index] === "*") {
          return true;
        }
        if (str[index + 1] === "?" && /[\].+)]/.test(str[index])) {
          return true;
        }
        if (closeSquareIndex !== -1 && str[index] === "[" && str[index + 1] !== "]") {
          if (closeSquareIndex < index) {
            closeSquareIndex = str.indexOf("]", index);
          }
          if (closeSquareIndex > index) {
            if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
              return true;
            }
            backSlashIndex = str.indexOf("\\", index);
            if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
              return true;
            }
          }
        }
        if (closeCurlyIndex !== -1 && str[index] === "{" && str[index + 1] !== "}") {
          closeCurlyIndex = str.indexOf("}", index);
          if (closeCurlyIndex > index) {
            backSlashIndex = str.indexOf("\\", index);
            if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) {
              return true;
            }
          }
        }
        if (closeParenIndex !== -1 && str[index] === "(" && str[index + 1] === "?" && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ")") {
          closeParenIndex = str.indexOf(")", index);
          if (closeParenIndex > index) {
            backSlashIndex = str.indexOf("\\", index);
            if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
              return true;
            }
          }
        }
        if (pipeIndex !== -1 && str[index] === "(" && str[index + 1] !== "|") {
          if (pipeIndex < index) {
            pipeIndex = str.indexOf("|", index);
          }
          if (pipeIndex !== -1 && str[pipeIndex + 1] !== ")") {
            closeParenIndex = str.indexOf(")", pipeIndex);
            if (closeParenIndex > pipeIndex) {
              backSlashIndex = str.indexOf("\\", pipeIndex);
              if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
                return true;
              }
            }
          }
        }
        if (str[index] === "\\") {
          var open = str[index + 1];
          index += 2;
          var close = chars[open];
          if (close) {
            var n = str.indexOf(close, index);
            if (n !== -1) {
              index = n + 1;
            }
          }
          if (str[index] === "!") {
            return true;
          }
        } else {
          index++;
        }
      }
      return false;
    };
    var relaxedCheck = function(str) {
      if (str[0] === "!") {
        return true;
      }
      var index = 0;
      while (index < str.length) {
        if (/[*?{}()[\]]/.test(str[index])) {
          return true;
        }
        if (str[index] === "\\") {
          var open = str[index + 1];
          index += 2;
          var close = chars[open];
          if (close) {
            var n = str.indexOf(close, index);
            if (n !== -1) {
              index = n + 1;
            }
          }
          if (str[index] === "!") {
            return true;
          }
        } else {
          index++;
        }
      }
      return false;
    };
    module2.exports = function isGlob(str, options) {
      if (typeof str !== "string" || str === "") {
        return false;
      }
      if (isExtglob(str)) {
        return true;
      }
      var check3 = strictCheck;
      if (options && options.strict === false) {
        check3 = relaxedCheck;
      }
      return check3(str);
    };
  }
});

// node_modules/glob-parent/index.js
var require_glob_parent = __commonJS({
  "node_modules/glob-parent/index.js"(exports2, module2) {
    "use strict";
    var isGlob = require_is_glob();
    var pathPosixDirname = require("path").posix.dirname;
    var isWin32 = require("os").platform() === "win32";
    var slash = "/";
    var backslash = /\\/g;
    var enclosure = /[\{\[].*[\}\]]$/;
    var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
    var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
    module2.exports = function globParent(str, opts) {
      var options = Object.assign({ flipBackslashes: true }, opts);
      if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
        str = str.replace(backslash, slash);
      }
      if (enclosure.test(str)) {
        str += slash;
      }
      str += "a";
      do {
        str = pathPosixDirname(str);
      } while (isGlob(str) || globby.test(str));
      return str.replace(escaped, "$1");
    };
  }
});

// node_modules/braces/lib/utils.js
var require_utils4 = __commonJS({
  "node_modules/braces/lib/utils.js"(exports2) {
    "use strict";
    exports2.isInteger = (num) => {
      if (typeof num === "number") {
        return Number.isInteger(num);
      }
      if (typeof num === "string" && num.trim() !== "") {
        return Number.isInteger(Number(num));
      }
      return false;
    };
    exports2.find = (node, type) => node.nodes.find((node2) => node2.type === type);
    exports2.exceedsLimit = (min, max, step = 1, limit) => {
      if (limit === false) return false;
      if (!exports2.isInteger(min) || !exports2.isInteger(max)) return false;
      return (Number(max) - Number(min)) / Number(step) >= limit;
    };
    exports2.escapeNode = (block, n = 0, type) => {
      const node = block.nodes[n];
      if (!node) return;
      if (type && node.type === type || node.type === "open" || node.type === "close") {
        if (node.escaped !== true) {
          node.value = "\\" + node.value;
          node.escaped = true;
        }
      }
    };
    exports2.encloseBrace = (node) => {
      if (node.type !== "brace") return false;
      if (node.commas >> 0 + node.ranges >> 0 === 0) {
        node.invalid = true;
        return true;
      }
      return false;
    };
    exports2.isInvalidBrace = (block) => {
      if (block.type !== "brace") return false;
      if (block.invalid === true || block.dollar) return true;
      if (block.commas >> 0 + block.ranges >> 0 === 0) {
        block.invalid = true;
        return true;
      }
      if (block.open !== true || block.close !== true) {
        block.invalid = true;
        return true;
      }
      return false;
    };
    exports2.isOpenOrClose = (node) => {
      if (node.type === "open" || node.type === "close") {
        return true;
      }
      return node.open === true || node.close === true;
    };
    exports2.reduce = (nodes) => nodes.reduce((acc, node) => {
      if (node.type === "text") acc.push(node.value);
      if (node.type === "range") node.type = "text";
      return acc;
    }, []);
    exports2.flatten = (...args) => {
      const result = [];
      const flat = (arr) => {
        for (let i = 0; i < arr.length; i++) {
          const ele = arr[i];
          if (Array.isArray(ele)) {
            flat(ele);
            continue;
          }
          if (ele !== void 0) {
            result.push(ele);
          }
        }
        return result;
      };
      flat(args);
      return result;
    };
  }
});

// node_modules/braces/lib/stringify.js
var require_stringify2 = __commonJS({
  "node_modules/braces/lib/stringify.js"(exports2, module2) {
    "use strict";
    var utils = require_utils4();
    module2.exports = (ast, options = {}) => {
      const stringify2 = (node, parent = {}) => {
        const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
        const invalidNode = node.invalid === true && options.escapeInvalid === true;
        let output = "";
        if (node.value) {
          if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
            return "\\" + node.value;
          }
          return node.value;
        }
        if (node.value) {
          return node.value;
        }
        if (node.nodes) {
          for (const child of node.nodes) {
            output += stringify2(child);
          }
        }
        return output;
      };
      return stringify2(ast);
    };
  }
});

// node_modules/is-number/index.js
var require_is_number = __commonJS({
  "node_modules/is-number/index.js"(exports2, module2) {
    "use strict";
    module2.exports = function(num) {
      if (typeof num === "number") {
        return num - num === 0;
      }
      if (typeof num === "string" && num.trim() !== "") {
        return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
      }
      return false;
    };
  }
});

// node_modules/to-regex-range/index.js
var require_to_regex_range = __commonJS({
  "node_modules/to-regex-range/index.js"(exports2, module2) {
    "use strict";
    var isNumber2 = require_is_number();
    var toRegexRange = (min, max, options) => {
      if (isNumber2(min) === false) {
        throw new TypeError("toRegexRange: expected the first argument to be a number");
      }
      if (max === void 0 || min === max) {
        return String(min);
      }
      if (isNumber2(max) === false) {
        throw new TypeError("toRegexRange: expected the second argument to be a number.");
      }
      let opts = { relaxZeros: true, ...options };
      if (typeof opts.strictZeros === "boolean") {
        opts.relaxZeros = opts.strictZeros === false;
      }
      let relax = String(opts.relaxZeros);
      let shorthand = String(opts.shorthand);
      let capture = String(opts.capture);
      let wrap = String(opts.wrap);
      let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap;
      if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
        return toRegexRange.cache[cacheKey].result;
      }
      let a = Math.min(min, max);
      let b = Math.max(min, max);
      if (Math.abs(a - b) === 1) {
        let result = min + "|" + max;
        if (opts.capture) {
          return `(${result})`;
        }
        if (opts.wrap === false) {
          return result;
        }
        return `(?:${result})`;
      }
      let isPadded = hasPadding(min) || hasPadding(max);
      let state = { min, max, a, b };
      let positives = [];
      let negatives = [];
      if (isPadded) {
        state.isPadded = isPadded;
        state.maxLen = String(state.max).length;
      }
      if (a < 0) {
        let newMin = b < 0 ? Math.abs(b) : 1;
        negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
        a = state.a = 0;
      }
      if (b >= 0) {
        positives = splitToPatterns(a, b, state, opts);
      }
      state.negatives = negatives;
      state.positives = positives;
      state.result = collatePatterns(negatives, positives, opts);
      if (opts.capture === true) {
        state.result = `(${state.result})`;
      } else if (opts.wrap !== false && positives.length + negatives.length > 1) {
        state.result = `(?:${state.result})`;
      }
      toRegexRange.cache[cacheKey] = state;
      return state.result;
    };
    function collatePatterns(neg, pos, options) {
      let onlyNegative = filterPatterns(neg, pos, "-", false, options) || [];
      let onlyPositive = filterPatterns(pos, neg, "", false, options) || [];
      let intersected = filterPatterns(neg, pos, "-?", true, options) || [];
      let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
      return subpatterns.join("|");
    }
    function splitToRanges(min, max) {
      let nines = 1;
      let zeros = 1;
      let stop = countNines(min, nines);
      let stops = /* @__PURE__ */ new Set([max]);
      while (min <= stop && stop <= max) {
        stops.add(stop);
        nines += 1;
        stop = countNines(min, nines);
      }
      stop = countZeros(max + 1, zeros) - 1;
      while (min < stop && stop <= max) {
        stops.add(stop);
        zeros += 1;
        stop = countZeros(max + 1, zeros) - 1;
      }
      stops = [...stops];
      stops.sort(compare);
      return stops;
    }
    function rangeToPattern(start, stop, options) {
      if (start === stop) {
        return { pattern: start, count: [], digits: 0 };
      }
      let zipped = zip(start, stop);
      let digits = zipped.length;
      let pattern = "";
      let count = 0;
      for (let i = 0; i < digits; i++) {
        let [startDigit, stopDigit] = zipped[i];
        if (startDigit === stopDigit) {
          pattern += startDigit;
        } else if (startDigit !== "0" || stopDigit !== "9") {
          pattern += toCharacterClass(startDigit, stopDigit, options);
        } else {
          count++;
        }
      }
      if (count) {
        pattern += options.shorthand === true ? "\\d" : "[0-9]";
      }
      return { pattern, count: [count], digits };
    }
    function splitToPatterns(min, max, tok, options) {
      let ranges = splitToRanges(min, max);
      let tokens = [];
      let start = min;
      let prev;
      for (let i = 0; i < ranges.length; i++) {
        let max2 = ranges[i];
        let obj = rangeToPattern(String(start), String(max2), options);
        let zeros = "";
        if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
          if (prev.count.length > 1) {
            prev.count.pop();
          }
          prev.count.push(obj.count[0]);
          prev.string = prev.pattern + toQuantifier(prev.count);
          start = max2 + 1;
          continue;
        }
        if (tok.isPadded) {
          zeros = padZeros(max2, tok, options);
        }
        obj.string = zeros + obj.pattern + toQuantifier(obj.count);
        tokens.push(obj);
        start = max2 + 1;
        prev = obj;
      }
      return tokens;
    }
    function filterPatterns(arr, comparison, prefix, intersection3, options) {
      let result = [];
      for (let ele of arr) {
        let { string: string5 } = ele;
        if (!intersection3 && !contains(comparison, "string", string5)) {
          result.push(prefix + string5);
        }
        if (intersection3 && contains(comparison, "string", string5)) {
          result.push(prefix + string5);
        }
      }
      return result;
    }
    function zip(a, b) {
      let arr = [];
      for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
      return arr;
    }
    function compare(a, b) {
      return a > b ? 1 : b > a ? -1 : 0;
    }
    function contains(arr, key, val) {
      return arr.some((ele) => ele[key] === val);
    }
    function countNines(min, len) {
      return Number(String(min).slice(0, -len) + "9".repeat(len));
    }
    function countZeros(integer3, zeros) {
      return integer3 - integer3 % Math.pow(10, zeros);
    }
    function toQuantifier(digits) {
      let [start = 0, stop = ""] = digits;
      if (stop || start > 1) {
        return `{${start + (stop ? "," + stop : "")}}`;
      }
      return "";
    }
    function toCharacterClass(a, b, options) {
      return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
    }
    function hasPadding(str) {
      return /^-?(0+)\d/.test(str);
    }
    function padZeros(value, tok, options) {
      if (!tok.isPadded) {
        return value;
      }
      let diff = Math.abs(tok.maxLen - String(value).length);
      let relax = options.relaxZeros !== false;
      switch (diff) {
        case 0:
          return "";
        case 1:
          return relax ? "0?" : "0";
        case 2:
          return relax ? "0{0,2}" : "00";
        default: {
          return relax ? `0{0,${diff}}` : `0{${diff}}`;
        }
      }
    }
    toRegexRange.cache = {};
    toRegexRange.clearCache = () => toRegexRange.cache = {};
    module2.exports = toRegexRange;
  }
});

// node_modules/fill-range/index.js
var require_fill_range = __commonJS({
  "node_modules/fill-range/index.js"(exports2, module2) {
    "use strict";
    var util4 = require("util");
    var toRegexRange = require_to_regex_range();
    var isObject5 = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
    var transform8 = (toNumber2) => {
      return (value) => toNumber2 === true ? Number(value) : String(value);
    };
    var isValidValue = (value) => {
      return typeof value === "number" || typeof value === "string" && value !== "";
    };
    var isNumber2 = (num) => Number.isInteger(+num);
    var zeros = (input) => {
      let value = `${input}`;
      let index = -1;
      if (value[0] === "-") value = value.slice(1);
      if (value === "0") return false;
      while (value[++index] === "0") ;
      return index > 0;
    };
    var stringify2 = (start, end, options) => {
      if (typeof start === "string" || typeof end === "string") {
        return true;
      }
      return options.stringify === true;
    };
    var pad = (input, maxLength, toNumber2) => {
      if (maxLength > 0) {
        let dash = input[0] === "-" ? "-" : "";
        if (dash) input = input.slice(1);
        input = dash + input.padStart(dash ? maxLength - 1 : maxLength, "0");
      }
      if (toNumber2 === false) {
        return String(input);
      }
      return input;
    };
    var toMaxLen = (input, maxLength) => {
      let negative = input[0] === "-" ? "-" : "";
      if (negative) {
        input = input.slice(1);
        maxLength--;
      }
      while (input.length < maxLength) input = "0" + input;
      return negative ? "-" + input : input;
    };
    var toSequence = (parts, options, maxLen) => {
      parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
      parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
      let prefix = options.capture ? "" : "?:";
      let positives = "";
      let negatives = "";
      let result;
      if (parts.positives.length) {
        positives = parts.positives.map((v) => toMaxLen(String(v), maxLen)).join("|");
      }
      if (parts.negatives.length) {
        negatives = `-(${prefix}${parts.negatives.map((v) => toMaxLen(String(v), maxLen)).join("|")})`;
      }
      if (positives && negatives) {
        result = `${positives}|${negatives}`;
      } else {
        result = positives || negatives;
      }
      if (options.wrap) {
        return `(${prefix}${result})`;
      }
      return result;
    };
    var toRange = (a, b, isNumbers, options) => {
      if (isNumbers) {
        return toRegexRange(a, b, { wrap: false, ...options });
      }
      let start = String.fromCharCode(a);
      if (a === b) return start;
      let stop = String.fromCharCode(b);
      return `[${start}-${stop}]`;
    };
    var toRegex = (start, end, options) => {
      if (Array.isArray(start)) {
        let wrap = options.wrap === true;
        let prefix = options.capture ? "" : "?:";
        return wrap ? `(${prefix}${start.join("|")})` : start.join("|");
      }
      return toRegexRange(start, end, options);
    };
    var rangeError = (...args) => {
      return new RangeError("Invalid range arguments: " + util4.inspect(...args));
    };
    var invalidRange = (start, end, options) => {
      if (options.strictRanges === true) throw rangeError([start, end]);
      return [];
    };
    var invalidStep = (step, options) => {
      if (options.strictRanges === true) {
        throw new TypeError(`Expected step "${step}" to be a number`);
      }
      return [];
    };
    var fillNumbers = (start, end, step = 1, options = {}) => {
      let a = Number(start);
      let b = Number(end);
      if (!Number.isInteger(a) || !Number.isInteger(b)) {
        if (options.strictRanges === true) throw rangeError([start, end]);
        return [];
      }
      if (a === 0) a = 0;
      if (b === 0) b = 0;
      let descending = a > b;
      let startString = String(start);
      let endString = String(end);
      let stepString = String(step);
      step = Math.max(Math.abs(step), 1);
      let padded = zeros(startString) || zeros(endString) || zeros(stepString);
      let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
      let toNumber2 = padded === false && stringify2(start, end, options) === false;
      let format = options.transform || transform8(toNumber2);
      if (options.toRegex && step === 1) {
        return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
      }
      let parts = { negatives: [], positives: [] };
      let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
      let range = [];
      let index = 0;
      while (descending ? a >= b : a <= b) {
        if (options.toRegex === true && step > 1) {
          push(a);
        } else {
          range.push(pad(format(a, index), maxLen, toNumber2));
        }
        a = descending ? a - step : a + step;
        index++;
      }
      if (options.toRegex === true) {
        return step > 1 ? toSequence(parts, options, maxLen) : toRegex(range, null, { wrap: false, ...options });
      }
      return range;
    };
    var fillLetters = (start, end, step = 1, options = {}) => {
      if (!isNumber2(start) && start.length > 1 || !isNumber2(end) && end.length > 1) {
        return invalidRange(start, end, options);
      }
      let format = options.transform || ((val) => String.fromCharCode(val));
      let a = `${start}`.charCodeAt(0);
      let b = `${end}`.charCodeAt(0);
      let descending = a > b;
      let min = Math.min(a, b);
      let max = Math.max(a, b);
      if (options.toRegex && step === 1) {
        return toRange(min, max, false, options);
      }
      let range = [];
      let index = 0;
      while (descending ? a >= b : a <= b) {
        range.push(format(a, index));
        a = descending ? a - step : a + step;
        index++;
      }
      if (options.toRegex === true) {
        return toRegex(range, null, { wrap: false, options });
      }
      return range;
    };
    var fill = (start, end, step, options = {}) => {
      if (end == null && isValidValue(start)) {
        return [start];
      }
      if (!isValidValue(start) || !isValidValue(end)) {
        return invalidRange(start, end, options);
      }
      if (typeof step === "function") {
        return fill(start, end, 1, { transform: step });
      }
      if (isObject5(step)) {
        return fill(start, end, 0, step);
      }
      let opts = { ...options };
      if (opts.capture === true) opts.wrap = true;
      step = step || opts.step || 1;
      if (!isNumber2(step)) {
        if (step != null && !isObject5(step)) return invalidStep(step, opts);
        return fill(start, end, 1, step);
      }
      if (isNumber2(start) && isNumber2(end)) {
        return fillNumbers(start, end, step, opts);
      }
      return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
    };
    module2.exports = fill;
  }
});

// node_modules/braces/lib/compile.js
var require_compile = __commonJS({
  "node_modules/braces/lib/compile.js"(exports2, module2) {
    "use strict";
    var fill = require_fill_range();
    var utils = require_utils4();
    var compile = (ast, options = {}) => {
      const walk = (node, parent = {}) => {
        const invalidBlock = utils.isInvalidBrace(parent);
        const invalidNode = node.invalid === true && options.escapeInvalid === true;
        const invalid = invalidBlock === true || invalidNode === true;
        const prefix = options.escapeInvalid === true ? "\\" : "";
        let output = "";
        if (node.isOpen === true) {
          return prefix + node.value;
        }
        if (node.isClose === true) {
          console.log("node.isClose", prefix, node.value);
          return prefix + node.value;
        }
        if (node.type === "open") {
          return invalid ? prefix + node.value : "(";
        }
        if (node.type === "close") {
          return invalid ? prefix + node.value : ")";
        }
        if (node.type === "comma") {
          return node.prev.type === "comma" ? "" : invalid ? node.value : "|";
        }
        if (node.value) {
          return node.value;
        }
        if (node.nodes && node.ranges > 0) {
          const args = utils.reduce(node.nodes);
          const range = fill(...args, { ...options, wrap: false, toRegex: true, strictZeros: true });
          if (range.length !== 0) {
            return args.length > 1 && range.length > 1 ? `(${range})` : range;
          }
        }
        if (node.nodes) {
          for (const child of node.nodes) {
            output += walk(child, node);
          }
        }
        return output;
      };
      return walk(ast);
    };
    module2.exports = compile;
  }
});

// node_modules/braces/lib/expand.js
var require_expand = __commonJS({
  "node_modules/braces/lib/expand.js"(exports2, module2) {
    "use strict";
    var fill = require_fill_range();
    var stringify2 = require_stringify2();
    var utils = require_utils4();
    var append2 = (queue = "", stash = "", enclose = false) => {
      const result = [];
      queue = [].concat(queue);
      stash = [].concat(stash);
      if (!stash.length) return queue;
      if (!queue.length) {
        return enclose ? utils.flatten(stash).map((ele) => `{${ele}}`) : stash;
      }
      for (const item of queue) {
        if (Array.isArray(item)) {
          for (const value of item) {
            result.push(append2(value, stash, enclose));
          }
        } else {
          for (let ele of stash) {
            if (enclose === true && typeof ele === "string") ele = `{${ele}}`;
            result.push(Array.isArray(ele) ? append2(item, ele, enclose) : item + ele);
          }
        }
      }
      return utils.flatten(result);
    };
    var expand = (ast, options = {}) => {
      const rangeLimit = options.rangeLimit === void 0 ? 1e3 : options.rangeLimit;
      const walk = (node, parent = {}) => {
        node.queue = [];
        let p3 = parent;
        let q = parent.queue;
        while (p3.type !== "brace" && p3.type !== "root" && p3.parent) {
          p3 = p3.parent;
          q = p3.queue;
        }
        if (node.invalid || node.dollar) {
          q.push(append2(q.pop(), stringify2(node, options)));
          return;
        }
        if (node.type === "brace" && node.invalid !== true && node.nodes.length === 2) {
          q.push(append2(q.pop(), ["{}"]));
          return;
        }
        if (node.nodes && node.ranges > 0) {
          const args = utils.reduce(node.nodes);
          if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
            throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
          }
          let range = fill(...args, options);
          if (range.length === 0) {
            range = stringify2(node, options);
          }
          q.push(append2(q.pop(), range));
          node.nodes = [];
          return;
        }
        const enclose = utils.encloseBrace(node);
        let queue = node.queue;
        let block = node;
        while (block.type !== "brace" && block.type !== "root" && block.parent) {
          block = block.parent;
          queue = block.queue;
        }
        for (let i = 0; i < node.nodes.length; i++) {
          const child = node.nodes[i];
          if (child.type === "comma" && node.type === "brace") {
            if (i === 1) queue.push("");
            queue.push("");
            continue;
          }
          if (child.type === "close") {
            q.push(append2(q.pop(), queue, enclose));
            continue;
          }
          if (child.value && child.type !== "open") {
            queue.push(append2(queue.pop(), child.value));
            continue;
          }
          if (child.nodes) {
            walk(child, node);
          }
        }
        return queue;
      };
      return utils.flatten(walk(ast));
    };
    module2.exports = expand;
  }
});

// node_modules/braces/lib/constants.js
var require_constants3 = __commonJS({
  "node_modules/braces/lib/constants.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      MAX_LENGTH: 1e4,
      // Digits
      CHAR_0: "0",
      /* 0 */
      CHAR_9: "9",
      /* 9 */
      // Alphabet chars.
      CHAR_UPPERCASE_A: "A",
      /* A */
      CHAR_LOWERCASE_A: "a",
      /* a */
      CHAR_UPPERCASE_Z: "Z",
      /* Z */
      CHAR_LOWERCASE_Z: "z",
      /* z */
      CHAR_LEFT_PARENTHESES: "(",
      /* ( */
      CHAR_RIGHT_PARENTHESES: ")",
      /* ) */
      CHAR_ASTERISK: "*",
      /* * */
      // Non-alphabetic chars.
      CHAR_AMPERSAND: "&",
      /* & */
      CHAR_AT: "@",
      /* @ */
      CHAR_BACKSLASH: "\\",
      /* \ */
      CHAR_BACKTICK: "`",
      /* ` */
      CHAR_CARRIAGE_RETURN: "\r",
      /* \r */
      CHAR_CIRCUMFLEX_ACCENT: "^",
      /* ^ */
      CHAR_COLON: ":",
      /* : */
      CHAR_COMMA: ",",
      /* , */
      CHAR_DOLLAR: "$",
      /* . */
      CHAR_DOT: ".",
      /* . */
      CHAR_DOUBLE_QUOTE: '"',
      /* " */
      CHAR_EQUAL: "=",
      /* = */
      CHAR_EXCLAMATION_MARK: "!",
      /* ! */
      CHAR_FORM_FEED: "\f",
      /* \f */
      CHAR_FORWARD_SLASH: "/",
      /* / */
      CHAR_HASH: "#",
      /* # */
      CHAR_HYPHEN_MINUS: "-",
      /* - */
      CHAR_LEFT_ANGLE_BRACKET: "<",
      /* < */
      CHAR_LEFT_CURLY_BRACE: "{",
      /* { */
      CHAR_LEFT_SQUARE_BRACKET: "[",
      /* [ */
      CHAR_LINE_FEED: "\n",
      /* \n */
      CHAR_NO_BREAK_SPACE: "\xA0",
      /* \u00A0 */
      CHAR_PERCENT: "%",
      /* % */
      CHAR_PLUS: "+",
      /* + */
      CHAR_QUESTION_MARK: "?",
      /* ? */
      CHAR_RIGHT_ANGLE_BRACKET: ">",
      /* > */
      CHAR_RIGHT_CURLY_BRACE: "}",
      /* } */
      CHAR_RIGHT_SQUARE_BRACKET: "]",
      /* ] */
      CHAR_SEMICOLON: ";",
      /* ; */
      CHAR_SINGLE_QUOTE: "'",
      /* ' */
      CHAR_SPACE: " ",
      /*   */
      CHAR_TAB: "	",
      /* \t */
      CHAR_UNDERSCORE: "_",
      /* _ */
      CHAR_VERTICAL_LINE: "|",
      /* | */
      CHAR_ZERO_WIDTH_NOBREAK_SPACE: "\uFEFF"
      /* \uFEFF */
    };
  }
});

// node_modules/braces/lib/parse.js
var require_parse2 = __commonJS({
  "node_modules/braces/lib/parse.js"(exports2, module2) {
    "use strict";
    var stringify2 = require_stringify2();
    var {
      MAX_LENGTH,
      CHAR_BACKSLASH,
      /* \ */
      CHAR_BACKTICK,
      /* ` */
      CHAR_COMMA,
      /* , */
      CHAR_DOT,
      /* . */
      CHAR_LEFT_PARENTHESES,
      /* ( */
      CHAR_RIGHT_PARENTHESES,
      /* ) */
      CHAR_LEFT_CURLY_BRACE,
      /* { */
      CHAR_RIGHT_CURLY_BRACE,
      /* } */
      CHAR_LEFT_SQUARE_BRACKET,
      /* [ */
      CHAR_RIGHT_SQUARE_BRACKET,
      /* ] */
      CHAR_DOUBLE_QUOTE,
      /* " */
      CHAR_SINGLE_QUOTE,
      /* ' */
      CHAR_NO_BREAK_SPACE,
      CHAR_ZERO_WIDTH_NOBREAK_SPACE
    } = require_constants3();
    var parse4 = (input, options = {}) => {
      if (typeof input !== "string") {
        throw new TypeError("Expected a string");
      }
      const opts = options || {};
      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
      if (input.length > max) {
        throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
      }
      const ast = { type: "root", input, nodes: [] };
      const stack = [ast];
      let block = ast;
      let prev = ast;
      let brackets = 0;
      const length = input.length;
      let index = 0;
      let depth = 0;
      let value;
      const advance = () => input[index++];
      const push = (node) => {
        if (node.type === "text" && prev.type === "dot") {
          prev.type = "text";
        }
        if (prev && prev.type === "text" && node.type === "text") {
          prev.value += node.value;
          return;
        }
        block.nodes.push(node);
        node.parent = block;
        node.prev = prev;
        prev = node;
        return node;
      };
      push({ type: "bos" });
      while (index < length) {
        block = stack[stack.length - 1];
        value = advance();
        if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
          continue;
        }
        if (value === CHAR_BACKSLASH) {
          push({ type: "text", value: (options.keepEscaping ? value : "") + advance() });
          continue;
        }
        if (value === CHAR_RIGHT_SQUARE_BRACKET) {
          push({ type: "text", value: "\\" + value });
          continue;
        }
        if (value === CHAR_LEFT_SQUARE_BRACKET) {
          brackets++;
          let next;
          while (index < length && (next = advance())) {
            value += next;
            if (next === CHAR_LEFT_SQUARE_BRACKET) {
              brackets++;
              continue;
            }
            if (next === CHAR_BACKSLASH) {
              value += advance();
              continue;
            }
            if (next === CHAR_RIGHT_SQUARE_BRACKET) {
              brackets--;
              if (brackets === 0) {
                break;
              }
            }
          }
          push({ type: "text", value });
          continue;
        }
        if (value === CHAR_LEFT_PARENTHESES) {
          block = push({ type: "paren", nodes: [] });
          stack.push(block);
          push({ type: "text", value });
          continue;
        }
        if (value === CHAR_RIGHT_PARENTHESES) {
          if (block.type !== "paren") {
            push({ type: "text", value });
            continue;
          }
          block = stack.pop();
          push({ type: "text", value });
          block = stack[stack.length - 1];
          continue;
        }
        if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
          const open = value;
          let next;
          if (options.keepQuotes !== true) {
            value = "";
          }
          while (index < length && (next = advance())) {
            if (next === CHAR_BACKSLASH) {
              value += next + advance();
              continue;
            }
            if (next === open) {
              if (options.keepQuotes === true) value += next;
              break;
            }
            value += next;
          }
          push({ type: "text", value });
          continue;
        }
        if (value === CHAR_LEFT_CURLY_BRACE) {
          depth++;
          const dollar = prev.value && prev.value.slice(-1) === "$" || block.dollar === true;
          const brace = {
            type: "brace",
            open: true,
            close: false,
            dollar,
            depth,
            commas: 0,
            ranges: 0,
            nodes: []
          };
          block = push(brace);
          stack.push(block);
          push({ type: "open", value });
          continue;
        }
        if (value === CHAR_RIGHT_CURLY_BRACE) {
          if (block.type !== "brace") {
            push({ type: "text", value });
            continue;
          }
          const type = "close";
          block = stack.pop();
          block.close = true;
          push({ type, value });
          depth--;
          block = stack[stack.length - 1];
          continue;
        }
        if (value === CHAR_COMMA && depth > 0) {
          if (block.ranges > 0) {
            block.ranges = 0;
            const open = block.nodes.shift();
            block.nodes = [open, { type: "text", value: stringify2(block) }];
          }
          push({ type: "comma", value });
          block.commas++;
          continue;
        }
        if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
          const siblings = block.nodes;
          if (depth === 0 || siblings.length === 0) {
            push({ type: "text", value });
            continue;
          }
          if (prev.type === "dot") {
            block.range = [];
            prev.value += value;
            prev.type = "range";
            if (block.nodes.length !== 3 && block.nodes.length !== 5) {
              block.invalid = true;
              block.ranges = 0;
              prev.type = "text";
              continue;
            }
            block.ranges++;
            block.args = [];
            continue;
          }
          if (prev.type === "range") {
            siblings.pop();
            const before = siblings[siblings.length - 1];
            before.value += prev.value + value;
            prev = before;
            block.ranges--;
            continue;
          }
          push({ type: "dot", value });
          continue;
        }
        push({ type: "text", value });
      }
      do {
        block = stack.pop();
        if (block.type !== "root") {
          block.nodes.forEach((node) => {
            if (!node.nodes) {
              if (node.type === "open") node.isOpen = true;
              if (node.type === "close") node.isClose = true;
              if (!node.nodes) node.type = "text";
              node.invalid = true;
            }
          });
          const parent = stack[stack.length - 1];
          const index2 = parent.nodes.indexOf(block);
          parent.nodes.splice(index2, 1, ...block.nodes);
        }
      } while (stack.length > 0);
      push({ type: "eos" });
      return ast;
    };
    module2.exports = parse4;
  }
});

// node_modules/braces/index.js
var require_braces = __commonJS({
  "node_modules/braces/index.js"(exports2, module2) {
    "use strict";
    var stringify2 = require_stringify2();
    var compile = require_compile();
    var expand = require_expand();
    var parse4 = require_parse2();
    var braces = (input, options = {}) => {
      let output = [];
      if (Array.isArray(input)) {
        for (const pattern of input) {
          const result = braces.create(pattern, options);
          if (Array.isArray(result)) {
            output.push(...result);
          } else {
            output.push(result);
          }
        }
      } else {
        output = [].concat(braces.create(input, options));
      }
      if (options && options.expand === true && options.nodupes === true) {
        output = [...new Set(output)];
      }
      return output;
    };
    braces.parse = (input, options = {}) => parse4(input, options);
    braces.stringify = (input, options = {}) => {
      if (typeof input === "string") {
        return stringify2(braces.parse(input, options), options);
      }
      return stringify2(input, options);
    };
    braces.compile = (input, options = {}) => {
      if (typeof input === "string") {
        input = braces.parse(input, options);
      }
      return compile(input, options);
    };
    braces.expand = (input, options = {}) => {
      if (typeof input === "string") {
        input = braces.parse(input, options);
      }
      let result = expand(input, options);
      if (options.noempty === true) {
        result = result.filter(Boolean);
      }
      if (options.nodupes === true) {
        result = [...new Set(result)];
      }
      return result;
    };
    braces.create = (input, options = {}) => {
      if (input === "" || input.length < 3) {
        return [input];
      }
      return options.expand !== true ? braces.compile(input, options) : braces.expand(input, options);
    };
    module2.exports = braces;
  }
});

// node_modules/picomatch/lib/constants.js
var require_constants4 = __commonJS({
  "node_modules/picomatch/lib/constants.js"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var WIN_SLASH = "\\\\/";
    var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
    var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
    var DOT_LITERAL = "\\.";
    var PLUS_LITERAL = "\\+";
    var QMARK_LITERAL = "\\?";
    var SLASH_LITERAL = "\\/";
    var ONE_CHAR = "(?=.)";
    var QMARK = "[^/]";
    var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
    var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
    var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
    var NO_DOT = `(?!${DOT_LITERAL})`;
    var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
    var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
    var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
    var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
    var STAR = `${QMARK}*?`;
    var POSIX_CHARS = {
      DOT_LITERAL,
      PLUS_LITERAL,
      QMARK_LITERAL,
      SLASH_LITERAL,
      ONE_CHAR,
      QMARK,
      END_ANCHOR,
      DOTS_SLASH,
      NO_DOT,
      NO_DOTS,
      NO_DOT_SLASH,
      NO_DOTS_SLASH,
      QMARK_NO_DOT,
      STAR,
      START_ANCHOR
    };
    var WINDOWS_CHARS = {
      ...POSIX_CHARS,
      SLASH_LITERAL: `[${WIN_SLASH}]`,
      QMARK: WIN_NO_SLASH,
      STAR: `${WIN_NO_SLASH}*?`,
      DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
      NO_DOT: `(?!${DOT_LITERAL})`,
      NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
      NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
      NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
      QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
      START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
      END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
    };
    var POSIX_REGEX_SOURCE = {
      __proto__: null,
      alnum: "a-zA-Z0-9",
      alpha: "a-zA-Z",
      ascii: "\\x00-\\x7F",
      blank: " \\t",
      cntrl: "\\x00-\\x1F\\x7F",
      digit: "0-9",
      graph: "\\x21-\\x7E",
      lower: "a-z",
      print: "\\x20-\\x7E ",
      punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
      space: " \\t\\r\\n\\v\\f",
      upper: "A-Z",
      word: "A-Za-z0-9_",
      xdigit: "A-Fa-f0-9"
    };
    module2.exports = {
      DEFAULT_MAX_EXTGLOB_RECURSION,
      MAX_LENGTH: 1024 * 64,
      POSIX_REGEX_SOURCE,
      // regular expressions
      REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
      REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
      REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
      REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
      REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
      REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
      // Replace globs with equivalent patterns to reduce parsing time.
      REPLACEMENTS: {
        __proto__: null,
        "***": "*",
        "**/**": "**",
        "**/**/**": "**"
      },
      // Digits
      CHAR_0: 48,
      /* 0 */
      CHAR_9: 57,
      /* 9 */
      // Alphabet chars.
      CHAR_UPPERCASE_A: 65,
      /* A */
      CHAR_LOWERCASE_A: 97,
      /* a */
      CHAR_UPPERCASE_Z: 90,
      /* Z */
      CHAR_LOWERCASE_Z: 122,
      /* z */
      CHAR_LEFT_PARENTHESES: 40,
      /* ( */
      CHAR_RIGHT_PARENTHESES: 41,
      /* ) */
      CHAR_ASTERISK: 42,
      /* * */
      // Non-alphabetic chars.
      CHAR_AMPERSAND: 38,
      /* & */
      CHAR_AT: 64,
      /* @ */
      CHAR_BACKWARD_SLASH: 92,
      /* \ */
      CHAR_CARRIAGE_RETURN: 13,
      /* \r */
      CHAR_CIRCUMFLEX_ACCENT: 94,
      /* ^ */
      CHAR_COLON: 58,
      /* : */
      CHAR_COMMA: 44,
      /* , */
      CHAR_DOT: 46,
      /* . */
      CHAR_DOUBLE_QUOTE: 34,
      /* " */
      CHAR_EQUAL: 61,
      /* = */
      CHAR_EXCLAMATION_MARK: 33,
      /* ! */
      CHAR_FORM_FEED: 12,
      /* \f */
      CHAR_FORWARD_SLASH: 47,
      /* / */
      CHAR_GRAVE_ACCENT: 96,
      /* ` */
      CHAR_HASH: 35,
      /* # */
      CHAR_HYPHEN_MINUS: 45,
      /* - */
      CHAR_LEFT_ANGLE_BRACKET: 60,
      /* < */
      CHAR_LEFT_CURLY_BRACE: 123,
      /* { */
      CHAR_LEFT_SQUARE_BRACKET: 91,
      /* [ */
      CHAR_LINE_FEED: 10,
      /* \n */
      CHAR_NO_BREAK_SPACE: 160,
      /* \u00A0 */
      CHAR_PERCENT: 37,
      /* % */
      CHAR_PLUS: 43,
      /* + */
      CHAR_QUESTION_MARK: 63,
      /* ? */
      CHAR_RIGHT_ANGLE_BRACKET: 62,
      /* > */
      CHAR_RIGHT_CURLY_BRACE: 125,
      /* } */
      CHAR_RIGHT_SQUARE_BRACKET: 93,
      /* ] */
      CHAR_SEMICOLON: 59,
      /* ; */
      CHAR_SINGLE_QUOTE: 39,
      /* ' */
      CHAR_SPACE: 32,
      /*   */
      CHAR_TAB: 9,
      /* \t */
      CHAR_UNDERSCORE: 95,
      /* _ */
      CHAR_VERTICAL_LINE: 124,
      /* | */
      CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
      /* \uFEFF */
      SEP: path33.sep,
      /**
       * Create EXTGLOB_CHARS
       */
      extglobChars(chars) {
        return {
          "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
          "?": { type: "qmark", open: "(?:", close: ")?" },
          "+": { type: "plus", open: "(?:", close: ")+" },
          "*": { type: "star", open: "(?:", close: ")*" },
          "@": { type: "at", open: "(?:", close: ")" }
        };
      },
      /**
       * Create GLOB_CHARS
       */
      globChars(win32) {
        return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
      }
    };
  }
});

// node_modules/picomatch/lib/utils.js
var require_utils5 = __commonJS({
  "node_modules/picomatch/lib/utils.js"(exports2) {
    "use strict";
    var path33 = require("path");
    var win32 = process.platform === "win32";
    var {
      REGEX_BACKSLASH,
      REGEX_REMOVE_BACKSLASH,
      REGEX_SPECIAL_CHARS,
      REGEX_SPECIAL_CHARS_GLOBAL
    } = require_constants4();
    exports2.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
    exports2.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
    exports2.isRegexChar = (str) => str.length === 1 && exports2.hasRegexChars(str);
    exports2.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
    exports2.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
    exports2.removeBackslashes = (str) => {
      return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
        return match === "\\" ? "" : match;
      });
    };
    exports2.supportsLookbehinds = () => {
      const segs = process.version.slice(1).split(".").map(Number);
      if (segs.length === 3 && segs[0] >= 9 || segs[0] === 8 && segs[1] >= 10) {
        return true;
      }
      return false;
    };
    exports2.isWindows = (options) => {
      if (options && typeof options.windows === "boolean") {
        return options.windows;
      }
      return win32 === true || path33.sep === "\\";
    };
    exports2.escapeLast = (input, char, lastIdx) => {
      const idx = input.lastIndexOf(char, lastIdx);
      if (idx === -1) return input;
      if (input[idx - 1] === "\\") return exports2.escapeLast(input, char, idx - 1);
      return `${input.slice(0, idx)}\\${input.slice(idx)}`;
    };
    exports2.removePrefix = (input, state = {}) => {
      let output = input;
      if (output.startsWith("./")) {
        output = output.slice(2);
        state.prefix = "./";
      }
      return output;
    };
    exports2.wrapOutput = (input, state = {}, options = {}) => {
      const prepend = options.contains ? "" : "^";
      const append2 = options.contains ? "" : "$";
      let output = `${prepend}(?:${input})${append2}`;
      if (state.negated === true) {
        output = `(?:^(?!${output}).*$)`;
      }
      return output;
    };
  }
});

// node_modules/picomatch/lib/scan.js
var require_scan = __commonJS({
  "node_modules/picomatch/lib/scan.js"(exports2, module2) {
    "use strict";
    var utils = require_utils5();
    var {
      CHAR_ASTERISK,
      /* * */
      CHAR_AT,
      /* @ */
      CHAR_BACKWARD_SLASH,
      /* \ */
      CHAR_COMMA,
      /* , */
      CHAR_DOT,
      /* . */
      CHAR_EXCLAMATION_MARK,
      /* ! */
      CHAR_FORWARD_SLASH,
      /* / */
      CHAR_LEFT_CURLY_BRACE,
      /* { */
      CHAR_LEFT_PARENTHESES,
      /* ( */
      CHAR_LEFT_SQUARE_BRACKET,
      /* [ */
      CHAR_PLUS,
      /* + */
      CHAR_QUESTION_MARK,
      /* ? */
      CHAR_RIGHT_CURLY_BRACE,
      /* } */
      CHAR_RIGHT_PARENTHESES,
      /* ) */
      CHAR_RIGHT_SQUARE_BRACKET
      /* ] */
    } = require_constants4();
    var isPathSeparator = (code) => {
      return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
    };
    var depth = (token) => {
      if (token.isPrefix !== true) {
        token.depth = token.isGlobstar ? Infinity : 1;
      }
    };
    var scan = (input, options) => {
      const opts = options || {};
      const length = input.length - 1;
      const scanToEnd = opts.parts === true || opts.scanToEnd === true;
      const slashes = [];
      const tokens = [];
      const parts = [];
      let str = input;
      let index = -1;
      let start = 0;
      let lastIndex = 0;
      let isBrace = false;
      let isBracket = false;
      let isGlob = false;
      let isExtglob = false;
      let isGlobstar = false;
      let braceEscaped = false;
      let backslashes = false;
      let negated = false;
      let negatedExtglob = false;
      let finished = false;
      let braces = 0;
      let prev;
      let code;
      let token = { value: "", depth: 0, isGlob: false };
      const eos = () => index >= length;
      const peek = () => str.charCodeAt(index + 1);
      const advance = () => {
        prev = code;
        return str.charCodeAt(++index);
      };
      while (index < length) {
        code = advance();
        let next;
        if (code === CHAR_BACKWARD_SLASH) {
          backslashes = token.backslashes = true;
          code = advance();
          if (code === CHAR_LEFT_CURLY_BRACE) {
            braceEscaped = true;
          }
          continue;
        }
        if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
          braces++;
          while (eos() !== true && (code = advance())) {
            if (code === CHAR_BACKWARD_SLASH) {
              backslashes = token.backslashes = true;
              advance();
              continue;
            }
            if (code === CHAR_LEFT_CURLY_BRACE) {
              braces++;
              continue;
            }
            if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
              isBrace = token.isBrace = true;
              isGlob = token.isGlob = true;
              finished = true;
              if (scanToEnd === true) {
                continue;
              }
              break;
            }
            if (braceEscaped !== true && code === CHAR_COMMA) {
              isBrace = token.isBrace = true;
              isGlob = token.isGlob = true;
              finished = true;
              if (scanToEnd === true) {
                continue;
              }
              break;
            }
            if (code === CHAR_RIGHT_CURLY_BRACE) {
              braces--;
              if (braces === 0) {
                braceEscaped = false;
                isBrace = token.isBrace = true;
                finished = true;
                break;
              }
            }
          }
          if (scanToEnd === true) {
            continue;
          }
          break;
        }
        if (code === CHAR_FORWARD_SLASH) {
          slashes.push(index);
          tokens.push(token);
          token = { value: "", depth: 0, isGlob: false };
          if (finished === true) continue;
          if (prev === CHAR_DOT && index === start + 1) {
            start += 2;
            continue;
          }
          lastIndex = index + 1;
          continue;
        }
        if (opts.noext !== true) {
          const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
          if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
            isGlob = token.isGlob = true;
            isExtglob = token.isExtglob = true;
            finished = true;
            if (code === CHAR_EXCLAMATION_MARK && index === start) {
              negatedExtglob = true;
            }
            if (scanToEnd === true) {
              while (eos() !== true && (code = advance())) {
                if (code === CHAR_BACKWARD_SLASH) {
                  backslashes = token.backslashes = true;
                  code = advance();
                  continue;
                }
                if (code === CHAR_RIGHT_PARENTHESES) {
                  isGlob = token.isGlob = true;
                  finished = true;
                  break;
                }
              }
              continue;
            }
            break;
          }
        }
        if (code === CHAR_ASTERISK) {
          if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
          isGlob = token.isGlob = true;
          finished = true;
          if (scanToEnd === true) {
            continue;
          }
          break;
        }
        if (code === CHAR_QUESTION_MARK) {
          isGlob = token.isGlob = true;
          finished = true;
          if (scanToEnd === true) {
            continue;
          }
          break;
        }
        if (code === CHAR_LEFT_SQUARE_BRACKET) {
          while (eos() !== true && (next = advance())) {
            if (next === CHAR_BACKWARD_SLASH) {
              backslashes = token.backslashes = true;
              advance();
              continue;
            }
            if (next === CHAR_RIGHT_SQUARE_BRACKET) {
              isBracket = token.isBracket = true;
              isGlob = token.isGlob = true;
              finished = true;
              break;
            }
          }
          if (scanToEnd === true) {
            continue;
          }
          break;
        }
        if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
          negated = token.negated = true;
          start++;
          continue;
        }
        if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
          isGlob = token.isGlob = true;
          if (scanToEnd === true) {
            while (eos() !== true && (code = advance())) {
              if (code === CHAR_LEFT_PARENTHESES) {
                backslashes = token.backslashes = true;
                code = advance();
                continue;
              }
              if (code === CHAR_RIGHT_PARENTHESES) {
                finished = true;
                break;
              }
            }
            continue;
          }
          break;
        }
        if (isGlob === true) {
          finished = true;
          if (scanToEnd === true) {
            continue;
          }
          break;
        }
      }
      if (opts.noext === true) {
        isExtglob = false;
        isGlob = false;
      }
      let base = str;
      let prefix = "";
      let glob = "";
      if (start > 0) {
        prefix = str.slice(0, start);
        str = str.slice(start);
        lastIndex -= start;
      }
      if (base && isGlob === true && lastIndex > 0) {
        base = str.slice(0, lastIndex);
        glob = str.slice(lastIndex);
      } else if (isGlob === true) {
        base = "";
        glob = str;
      } else {
        base = str;
      }
      if (base && base !== "" && base !== "/" && base !== str) {
        if (isPathSeparator(base.charCodeAt(base.length - 1))) {
          base = base.slice(0, -1);
        }
      }
      if (opts.unescape === true) {
        if (glob) glob = utils.removeBackslashes(glob);
        if (base && backslashes === true) {
          base = utils.removeBackslashes(base);
        }
      }
      const state = {
        prefix,
        input,
        start,
        base,
        glob,
        isBrace,
        isBracket,
        isGlob,
        isExtglob,
        isGlobstar,
        negated,
        negatedExtglob
      };
      if (opts.tokens === true) {
        state.maxDepth = 0;
        if (!isPathSeparator(code)) {
          tokens.push(token);
        }
        state.tokens = tokens;
      }
      if (opts.parts === true || opts.tokens === true) {
        let prevIndex;
        for (let idx = 0; idx < slashes.length; idx++) {
          const n = prevIndex ? prevIndex + 1 : start;
          const i = slashes[idx];
          const value = input.slice(n, i);
          if (opts.tokens) {
            if (idx === 0 && start !== 0) {
              tokens[idx].isPrefix = true;
              tokens[idx].value = prefix;
            } else {
              tokens[idx].value = value;
            }
            depth(tokens[idx]);
            state.maxDepth += tokens[idx].depth;
          }
          if (idx !== 0 || value !== "") {
            parts.push(value);
          }
          prevIndex = i;
        }
        if (prevIndex && prevIndex + 1 < input.length) {
          const value = input.slice(prevIndex + 1);
          parts.push(value);
          if (opts.tokens) {
            tokens[tokens.length - 1].value = value;
            depth(tokens[tokens.length - 1]);
            state.maxDepth += tokens[tokens.length - 1].depth;
          }
        }
        state.slashes = slashes;
        state.parts = parts;
      }
      return state;
    };
    module2.exports = scan;
  }
});

// node_modules/picomatch/lib/parse.js
var require_parse3 = __commonJS({
  "node_modules/picomatch/lib/parse.js"(exports2, module2) {
    "use strict";
    var constants = require_constants4();
    var utils = require_utils5();
    var {
      MAX_LENGTH,
      POSIX_REGEX_SOURCE,
      REGEX_NON_SPECIAL_CHARS,
      REGEX_SPECIAL_CHARS_BACKREF,
      REPLACEMENTS
    } = constants;
    var expandRange = (args, options) => {
      if (typeof options.expandRange === "function") {
        return options.expandRange(...args, options);
      }
      args.sort();
      const value = `[${args.join("-")}]`;
      try {
        new RegExp(value);
      } catch (ex) {
        return args.map((v) => utils.escapeRegex(v)).join("..");
      }
      return value;
    };
    var syntaxError = (type, char) => {
      return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
    };
    var splitTopLevel = (input) => {
      const parts = [];
      let bracket = 0;
      let paren = 0;
      let quote = 0;
      let value = "";
      let escaped = false;
      for (const ch of input) {
        if (escaped === true) {
          value += ch;
          escaped = false;
          continue;
        }
        if (ch === "\\") {
          value += ch;
          escaped = true;
          continue;
        }
        if (ch === '"') {
          quote = quote === 1 ? 0 : 1;
          value += ch;
          continue;
        }
        if (quote === 0) {
          if (ch === "[") {
            bracket++;
          } else if (ch === "]" && bracket > 0) {
            bracket--;
          } else if (bracket === 0) {
            if (ch === "(") {
              paren++;
            } else if (ch === ")" && paren > 0) {
              paren--;
            } else if (ch === "|" && paren === 0) {
              parts.push(value);
              value = "";
              continue;
            }
          }
        }
        value += ch;
      }
      parts.push(value);
      return parts;
    };
    var isPlainBranch = (branch) => {
      let escaped = false;
      for (const ch of branch) {
        if (escaped === true) {
          escaped = false;
          continue;
        }
        if (ch === "\\") {
          escaped = true;
          continue;
        }
        if (/[?*+@!()[\]{}]/.test(ch)) {
          return false;
        }
      }
      return true;
    };
    var normalizeSimpleBranch = (branch) => {
      let value = branch.trim();
      let changed = true;
      while (changed === true) {
        changed = false;
        if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
          value = value.slice(2, -1);
          changed = true;
        }
      }
      if (!isPlainBranch(value)) {
        return;
      }
      return value.replace(/\\(.)/g, "$1");
    };
    var hasRepeatedCharPrefixOverlap = (branches) => {
      const values = branches.map(normalizeSimpleBranch).filter(Boolean);
      for (let i = 0; i < values.length; i++) {
        for (let j = i + 1; j < values.length; j++) {
          const a = values[i];
          const b = values[j];
          const char = a[0];
          if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
            continue;
          }
          if (a === b || a.startsWith(b) || b.startsWith(a)) {
            return true;
          }
        }
      }
      return false;
    };
    var parseRepeatedExtglob = (pattern, requireEnd = true) => {
      if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
        return;
      }
      let bracket = 0;
      let paren = 0;
      let quote = 0;
      let escaped = false;
      for (let i = 1; i < pattern.length; i++) {
        const ch = pattern[i];
        if (escaped === true) {
          escaped = false;
          continue;
        }
        if (ch === "\\") {
          escaped = true;
          continue;
        }
        if (ch === '"') {
          quote = quote === 1 ? 0 : 1;
          continue;
        }
        if (quote === 1) {
          continue;
        }
        if (ch === "[") {
          bracket++;
          continue;
        }
        if (ch === "]" && bracket > 0) {
          bracket--;
          continue;
        }
        if (bracket > 0) {
          continue;
        }
        if (ch === "(") {
          paren++;
          continue;
        }
        if (ch === ")") {
          paren--;
          if (paren === 0) {
            if (requireEnd === true && i !== pattern.length - 1) {
              return;
            }
            return {
              type: pattern[0],
              body: pattern.slice(2, i),
              end: i
            };
          }
        }
      }
    };
    var getStarExtglobSequenceOutput = (pattern) => {
      let index = 0;
      const chars = [];
      while (index < pattern.length) {
        const match = parseRepeatedExtglob(pattern.slice(index), false);
        if (!match || match.type !== "*") {
          return;
        }
        const branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
        if (branches.length !== 1) {
          return;
        }
        const branch = normalizeSimpleBranch(branches[0]);
        if (!branch || branch.length !== 1) {
          return;
        }
        chars.push(branch);
        index += match.end + 1;
      }
      if (chars.length < 1) {
        return;
      }
      const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
      return `${source}*`;
    };
    var repeatedExtglobRecursion = (pattern) => {
      let depth = 0;
      let value = pattern.trim();
      let match = parseRepeatedExtglob(value);
      while (match) {
        depth++;
        value = match.body.trim();
        match = parseRepeatedExtglob(value);
      }
      return depth;
    };
    var analyzeRepeatedExtglob = (body, options) => {
      if (options.maxExtglobRecursion === false) {
        return { risky: false };
      }
      const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
      const branches = splitTopLevel(body).map((branch) => branch.trim());
      if (branches.length > 1) {
        if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
          return { risky: true };
        }
      }
      for (const branch of branches) {
        const safeOutput = getStarExtglobSequenceOutput(branch);
        if (safeOutput) {
          return { risky: true, safeOutput };
        }
        if (repeatedExtglobRecursion(branch) > max) {
          return { risky: true };
        }
      }
      return { risky: false };
    };
    var parse4 = (input, options) => {
      if (typeof input !== "string") {
        throw new TypeError("Expected a string");
      }
      input = REPLACEMENTS[input] || input;
      const opts = { ...options };
      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
      let len = input.length;
      if (len > max) {
        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
      }
      const bos = { type: "bos", value: "", output: opts.prepend || "" };
      const tokens = [bos];
      const capture = opts.capture ? "" : "?:";
      const win32 = utils.isWindows(options);
      const PLATFORM_CHARS = constants.globChars(win32);
      const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
      const {
        DOT_LITERAL,
        PLUS_LITERAL,
        SLASH_LITERAL,
        ONE_CHAR,
        DOTS_SLASH,
        NO_DOT,
        NO_DOT_SLASH,
        NO_DOTS_SLASH,
        QMARK,
        QMARK_NO_DOT,
        STAR,
        START_ANCHOR
      } = PLATFORM_CHARS;
      const globstar = (opts2) => {
        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
      };
      const nodot = opts.dot ? "" : NO_DOT;
      const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
      let star = opts.bash === true ? globstar(opts) : STAR;
      if (opts.capture) {
        star = `(${star})`;
      }
      if (typeof opts.noext === "boolean") {
        opts.noextglob = opts.noext;
      }
      const state = {
        input,
        index: -1,
        start: 0,
        dot: opts.dot === true,
        consumed: "",
        output: "",
        prefix: "",
        backtrack: false,
        negated: false,
        brackets: 0,
        braces: 0,
        parens: 0,
        quotes: 0,
        globstar: false,
        tokens
      };
      input = utils.removePrefix(input, state);
      len = input.length;
      const extglobs = [];
      const braces = [];
      const stack = [];
      let prev = bos;
      let value;
      const eos = () => state.index === len - 1;
      const peek = state.peek = (n = 1) => input[state.index + n];
      const advance = state.advance = () => input[++state.index] || "";
      const remaining = () => input.slice(state.index + 1);
      const consume = (value2 = "", num = 0) => {
        state.consumed += value2;
        state.index += num;
      };
      const append2 = (token) => {
        state.output += token.output != null ? token.output : token.value;
        consume(token.value);
      };
      const negate = () => {
        let count = 1;
        while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
          advance();
          state.start++;
          count++;
        }
        if (count % 2 === 0) {
          return false;
        }
        state.negated = true;
        state.start++;
        return true;
      };
      const increment = (type) => {
        state[type]++;
        stack.push(type);
      };
      const decrement = (type) => {
        state[type]--;
        stack.pop();
      };
      const push = (tok) => {
        if (prev.type === "globstar") {
          const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
          const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
          if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
            state.output = state.output.slice(0, -prev.output.length);
            prev.type = "star";
            prev.value = "*";
            prev.output = star;
            state.output += prev.output;
          }
        }
        if (extglobs.length && tok.type !== "paren") {
          extglobs[extglobs.length - 1].inner += tok.value;
        }
        if (tok.value || tok.output) append2(tok);
        if (prev && prev.type === "text" && tok.type === "text") {
          prev.value += tok.value;
          prev.output = (prev.output || "") + tok.value;
          return;
        }
        tok.prev = prev;
        tokens.push(tok);
        prev = tok;
      };
      const extglobOpen = (type, value2) => {
        const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
        token.prev = prev;
        token.parens = state.parens;
        token.output = state.output;
        token.startIndex = state.index;
        token.tokensIndex = tokens.length;
        const output = (opts.capture ? "(" : "") + token.open;
        increment("parens");
        push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
        push({ type: "paren", extglob: true, value: advance(), output });
        extglobs.push(token);
      };
      const extglobClose = (token) => {
        const literal3 = input.slice(token.startIndex, state.index + 1);
        const body = input.slice(token.startIndex + 2, state.index);
        const analysis = analyzeRepeatedExtglob(body, opts);
        if ((token.type === "plus" || token.type === "star") && analysis.risky) {
          const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
          const open = tokens[token.tokensIndex];
          open.type = "text";
          open.value = literal3;
          open.output = safeOutput || utils.escapeRegex(literal3);
          for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
            tokens[i].value = "";
            tokens[i].output = "";
            delete tokens[i].suffix;
          }
          state.output = token.output + open.output;
          state.backtrack = true;
          push({ type: "paren", extglob: true, value, output: "" });
          decrement("parens");
          return;
        }
        let output = token.close + (opts.capture ? ")" : "");
        let rest;
        if (token.type === "negate") {
          let extglobStar = star;
          if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
            extglobStar = globstar(opts);
          }
          if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
            output = token.close = `)$))${extglobStar}`;
          }
          if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
            const expression = parse4(rest, { ...options, fastpaths: false }).output;
            output = token.close = `)${expression})${extglobStar})`;
          }
          if (token.prev.type === "bos") {
            state.negatedExtglob = true;
          }
        }
        push({ type: "paren", extglob: true, value, output });
        decrement("parens");
      };
      if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
        let backslashes = false;
        let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc3, chars, first, rest, index) => {
          if (first === "\\") {
            backslashes = true;
            return m;
          }
          if (first === "?") {
            if (esc3) {
              return esc3 + first + (rest ? QMARK.repeat(rest.length) : "");
            }
            if (index === 0) {
              return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
            }
            return QMARK.repeat(chars.length);
          }
          if (first === ".") {
            return DOT_LITERAL.repeat(chars.length);
          }
          if (first === "*") {
            if (esc3) {
              return esc3 + first + (rest ? star : "");
            }
            return star;
          }
          return esc3 ? m : `\\${m}`;
        });
        if (backslashes === true) {
          if (opts.unescape === true) {
            output = output.replace(/\\/g, "");
          } else {
            output = output.replace(/\\+/g, (m) => {
              return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
            });
          }
        }
        if (output === input && opts.contains === true) {
          state.output = input;
          return state;
        }
        state.output = utils.wrapOutput(output, state, options);
        return state;
      }
      while (!eos()) {
        value = advance();
        if (value === "\0") {
          continue;
        }
        if (value === "\\") {
          const next = peek();
          if (next === "/" && opts.bash !== true) {
            continue;
          }
          if (next === "." || next === ";") {
            continue;
          }
          if (!next) {
            value += "\\";
            push({ type: "text", value });
            continue;
          }
          const match = /^\\+/.exec(remaining());
          let slashes = 0;
          if (match && match[0].length > 2) {
            slashes = match[0].length;
            state.index += slashes;
            if (slashes % 2 !== 0) {
              value += "\\";
            }
          }
          if (opts.unescape === true) {
            value = advance();
          } else {
            value += advance();
          }
          if (state.brackets === 0) {
            push({ type: "text", value });
            continue;
          }
        }
        if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
          if (opts.posix !== false && value === ":") {
            const inner = prev.value.slice(1);
            if (inner.includes("[")) {
              prev.posix = true;
              if (inner.includes(":")) {
                const idx = prev.value.lastIndexOf("[");
                const pre = prev.value.slice(0, idx);
                const rest2 = prev.value.slice(idx + 2);
                const posix = POSIX_REGEX_SOURCE[rest2];
                if (posix) {
                  prev.value = pre + posix;
                  state.backtrack = true;
                  advance();
                  if (!bos.output && tokens.indexOf(prev) === 1) {
                    bos.output = ONE_CHAR;
                  }
                  continue;
                }
              }
            }
          }
          if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
            value = `\\${value}`;
          }
          if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
            value = `\\${value}`;
          }
          if (opts.posix === true && value === "!" && prev.value === "[") {
            value = "^";
          }
          prev.value += value;
          append2({ value });
          continue;
        }
        if (state.quotes === 1 && value !== '"') {
          value = utils.escapeRegex(value);
          prev.value += value;
          append2({ value });
          continue;
        }
        if (value === '"') {
          state.quotes = state.quotes === 1 ? 0 : 1;
          if (opts.keepQuotes === true) {
            push({ type: "text", value });
          }
          continue;
        }
        if (value === "(") {
          increment("parens");
          push({ type: "paren", value });
          continue;
        }
        if (value === ")") {
          if (state.parens === 0 && opts.strictBrackets === true) {
            throw new SyntaxError(syntaxError("opening", "("));
          }
          const extglob = extglobs[extglobs.length - 1];
          if (extglob && state.parens === extglob.parens + 1) {
            extglobClose(extglobs.pop());
            continue;
          }
          push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
          decrement("parens");
          continue;
        }
        if (value === "[") {
          if (opts.nobracket === true || !remaining().includes("]")) {
            if (opts.nobracket !== true && opts.strictBrackets === true) {
              throw new SyntaxError(syntaxError("closing", "]"));
            }
            value = `\\${value}`;
          } else {
            increment("brackets");
          }
          push({ type: "bracket", value });
          continue;
        }
        if (value === "]") {
          if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
            push({ type: "text", value, output: `\\${value}` });
            continue;
          }
          if (state.brackets === 0) {
            if (opts.strictBrackets === true) {
              throw new SyntaxError(syntaxError("opening", "["));
            }
            push({ type: "text", value, output: `\\${value}` });
            continue;
          }
          decrement("brackets");
          const prevValue = prev.value.slice(1);
          if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
            value = `/${value}`;
          }
          prev.value += value;
          append2({ value });
          if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
            continue;
          }
          const escaped = utils.escapeRegex(prev.value);
          state.output = state.output.slice(0, -prev.value.length);
          if (opts.literalBrackets === true) {
            state.output += escaped;
            prev.value = escaped;
            continue;
          }
          prev.value = `(${capture}${escaped}|${prev.value})`;
          state.output += prev.value;
          continue;
        }
        if (value === "{" && opts.nobrace !== true) {
          increment("braces");
          const open = {
            type: "brace",
            value,
            output: "(",
            outputIndex: state.output.length,
            tokensIndex: state.tokens.length
          };
          braces.push(open);
          push(open);
          continue;
        }
        if (value === "}") {
          const brace = braces[braces.length - 1];
          if (opts.nobrace === true || !brace) {
            push({ type: "text", value, output: value });
            continue;
          }
          let output = ")";
          if (brace.dots === true) {
            const arr = tokens.slice();
            const range = [];
            for (let i = arr.length - 1; i >= 0; i--) {
              tokens.pop();
              if (arr[i].type === "brace") {
                break;
              }
              if (arr[i].type !== "dots") {
                range.unshift(arr[i].value);
              }
            }
            output = expandRange(range, opts);
            state.backtrack = true;
          }
          if (brace.comma !== true && brace.dots !== true) {
            const out = state.output.slice(0, brace.outputIndex);
            const toks = state.tokens.slice(brace.tokensIndex);
            brace.value = brace.output = "\\{";
            value = output = "\\}";
            state.output = out;
            for (const t of toks) {
              state.output += t.output || t.value;
            }
          }
          push({ type: "brace", value, output });
          decrement("braces");
          braces.pop();
          continue;
        }
        if (value === "|") {
          if (extglobs.length > 0) {
            extglobs[extglobs.length - 1].conditions++;
          }
          push({ type: "text", value });
          continue;
        }
        if (value === ",") {
          let output = value;
          const brace = braces[braces.length - 1];
          if (brace && stack[stack.length - 1] === "braces") {
            brace.comma = true;
            output = "|";
          }
          push({ type: "comma", value, output });
          continue;
        }
        if (value === "/") {
          if (prev.type === "dot" && state.index === state.start + 1) {
            state.start = state.index + 1;
            state.consumed = "";
            state.output = "";
            tokens.pop();
            prev = bos;
            continue;
          }
          push({ type: "slash", value, output: SLASH_LITERAL });
          continue;
        }
        if (value === ".") {
          if (state.braces > 0 && prev.type === "dot") {
            if (prev.value === ".") prev.output = DOT_LITERAL;
            const brace = braces[braces.length - 1];
            prev.type = "dots";
            prev.output += value;
            prev.value += value;
            brace.dots = true;
            continue;
          }
          if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
            push({ type: "text", value, output: DOT_LITERAL });
            continue;
          }
          push({ type: "dot", value, output: DOT_LITERAL });
          continue;
        }
        if (value === "?") {
          const isGroup = prev && prev.value === "(";
          if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
            extglobOpen("qmark", value);
            continue;
          }
          if (prev && prev.type === "paren") {
            const next = peek();
            let output = value;
            if (next === "<" && !utils.supportsLookbehinds()) {
              throw new Error("Node.js v10 or higher is required for regex lookbehinds");
            }
            if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
              output = `\\${value}`;
            }
            push({ type: "text", value, output });
            continue;
          }
          if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
            push({ type: "qmark", value, output: QMARK_NO_DOT });
            continue;
          }
          push({ type: "qmark", value, output: QMARK });
          continue;
        }
        if (value === "!") {
          if (opts.noextglob !== true && peek() === "(") {
            if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
              extglobOpen("negate", value);
              continue;
            }
          }
          if (opts.nonegate !== true && state.index === 0) {
            negate();
            continue;
          }
        }
        if (value === "+") {
          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
            extglobOpen("plus", value);
            continue;
          }
          if (prev && prev.value === "(" || opts.regex === false) {
            push({ type: "plus", value, output: PLUS_LITERAL });
            continue;
          }
          if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
            push({ type: "plus", value });
            continue;
          }
          push({ type: "plus", value: PLUS_LITERAL });
          continue;
        }
        if (value === "@") {
          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
            push({ type: "at", extglob: true, value, output: "" });
            continue;
          }
          push({ type: "text", value });
          continue;
        }
        if (value !== "*") {
          if (value === "$" || value === "^") {
            value = `\\${value}`;
          }
          const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
          if (match) {
            value += match[0];
            state.index += match[0].length;
          }
          push({ type: "text", value });
          continue;
        }
        if (prev && (prev.type === "globstar" || prev.star === true)) {
          prev.type = "star";
          prev.star = true;
          prev.value += value;
          prev.output = star;
          state.backtrack = true;
          state.globstar = true;
          consume(value);
          continue;
        }
        let rest = remaining();
        if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
          extglobOpen("star", value);
          continue;
        }
        if (prev.type === "star") {
          if (opts.noglobstar === true) {
            consume(value);
            continue;
          }
          const prior = prev.prev;
          const before = prior.prev;
          const isStart = prior.type === "slash" || prior.type === "bos";
          const afterStar = before && (before.type === "star" || before.type === "globstar");
          if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
            push({ type: "star", value, output: "" });
            continue;
          }
          const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
          const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
          if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
            push({ type: "star", value, output: "" });
            continue;
          }
          while (rest.slice(0, 3) === "/**") {
            const after = input[state.index + 4];
            if (after && after !== "/") {
              break;
            }
            rest = rest.slice(3);
            consume("/**", 3);
          }
          if (prior.type === "bos" && eos()) {
            prev.type = "globstar";
            prev.value += value;
            prev.output = globstar(opts);
            state.output = prev.output;
            state.globstar = true;
            consume(value);
            continue;
          }
          if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
            state.output = state.output.slice(0, -(prior.output + prev.output).length);
            prior.output = `(?:${prior.output}`;
            prev.type = "globstar";
            prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
            prev.value += value;
            state.globstar = true;
            state.output += prior.output + prev.output;
            consume(value);
            continue;
          }
          if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
            const end = rest[1] !== void 0 ? "|$" : "";
            state.output = state.output.slice(0, -(prior.output + prev.output).length);
            prior.output = `(?:${prior.output}`;
            prev.type = "globstar";
            prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
            prev.value += value;
            state.output += prior.output + prev.output;
            state.globstar = true;
            consume(value + advance());
            push({ type: "slash", value: "/", output: "" });
            continue;
          }
          if (prior.type === "bos" && rest[0] === "/") {
            prev.type = "globstar";
            prev.value += value;
            prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
            state.output = prev.output;
            state.globstar = true;
            consume(value + advance());
            push({ type: "slash", value: "/", output: "" });
            continue;
          }
          state.output = state.output.slice(0, -prev.output.length);
          prev.type = "globstar";
          prev.output = globstar(opts);
          prev.value += value;
          state.output += prev.output;
          state.globstar = true;
          consume(value);
          continue;
        }
        const token = { type: "star", value, output: star };
        if (opts.bash === true) {
          token.output = ".*?";
          if (prev.type === "bos" || prev.type === "slash") {
            token.output = nodot + token.output;
          }
          push(token);
          continue;
        }
        if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
          token.output = value;
          push(token);
          continue;
        }
        if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
          if (prev.type === "dot") {
            state.output += NO_DOT_SLASH;
            prev.output += NO_DOT_SLASH;
          } else if (opts.dot === true) {
            state.output += NO_DOTS_SLASH;
            prev.output += NO_DOTS_SLASH;
          } else {
            state.output += nodot;
            prev.output += nodot;
          }
          if (peek() !== "*") {
            state.output += ONE_CHAR;
            prev.output += ONE_CHAR;
          }
        }
        push(token);
      }
      while (state.brackets > 0) {
        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
        state.output = utils.escapeLast(state.output, "[");
        decrement("brackets");
      }
      while (state.parens > 0) {
        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
        state.output = utils.escapeLast(state.output, "(");
        decrement("parens");
      }
      while (state.braces > 0) {
        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
        state.output = utils.escapeLast(state.output, "{");
        decrement("braces");
      }
      if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
        push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
      }
      if (state.backtrack === true) {
        state.output = "";
        for (const token of state.tokens) {
          state.output += token.output != null ? token.output : token.value;
          if (token.suffix) {
            state.output += token.suffix;
          }
        }
      }
      return state;
    };
    parse4.fastpaths = (input, options) => {
      const opts = { ...options };
      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
      const len = input.length;
      if (len > max) {
        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
      }
      input = REPLACEMENTS[input] || input;
      const win32 = utils.isWindows(options);
      const {
        DOT_LITERAL,
        SLASH_LITERAL,
        ONE_CHAR,
        DOTS_SLASH,
        NO_DOT,
        NO_DOTS,
        NO_DOTS_SLASH,
        STAR,
        START_ANCHOR
      } = constants.globChars(win32);
      const nodot = opts.dot ? NO_DOTS : NO_DOT;
      const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
      const capture = opts.capture ? "" : "?:";
      const state = { negated: false, prefix: "" };
      let star = opts.bash === true ? ".*?" : STAR;
      if (opts.capture) {
        star = `(${star})`;
      }
      const globstar = (opts2) => {
        if (opts2.noglobstar === true) return star;
        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
      };
      const create = (str) => {
        switch (str) {
          case "*":
            return `${nodot}${ONE_CHAR}${star}`;
          case ".*":
            return `${DOT_LITERAL}${ONE_CHAR}${star}`;
          case "*.*":
            return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
          case "*/*":
            return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
          case "**":
            return nodot + globstar(opts);
          case "**/*":
            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
          case "**/*.*":
            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
          case "**/.*":
            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
          default: {
            const match = /^(.*?)\.(\w+)$/.exec(str);
            if (!match) return;
            const source2 = create(match[1]);
            if (!source2) return;
            return source2 + DOT_LITERAL + match[2];
          }
        }
      };
      const output = utils.removePrefix(input, state);
      let source = create(output);
      if (source && opts.strictSlashes !== true) {
        source += `${SLASH_LITERAL}?`;
      }
      return source;
    };
    module2.exports = parse4;
  }
});

// node_modules/picomatch/lib/picomatch.js
var require_picomatch = __commonJS({
  "node_modules/picomatch/lib/picomatch.js"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var scan = require_scan();
    var parse4 = require_parse3();
    var utils = require_utils5();
    var constants = require_constants4();
    var isObject5 = (val) => val && typeof val === "object" && !Array.isArray(val);
    var picomatch = (glob, options, returnState = false) => {
      if (Array.isArray(glob)) {
        const fns = glob.map((input) => picomatch(input, options, returnState));
        const arrayMatcher = (str) => {
          for (const isMatch of fns) {
            const state2 = isMatch(str);
            if (state2) return state2;
          }
          return false;
        };
        return arrayMatcher;
      }
      const isState = isObject5(glob) && glob.tokens && glob.input;
      if (glob === "" || typeof glob !== "string" && !isState) {
        throw new TypeError("Expected pattern to be a non-empty string");
      }
      const opts = options || {};
      const posix = utils.isWindows(options);
      const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
      const state = regex.state;
      delete regex.state;
      let isIgnored = () => false;
      if (opts.ignore) {
        const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
        isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
      }
      const matcher = (input, returnObject = false) => {
        const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
        const result = { glob, state, regex, posix, input, output, match, isMatch };
        if (typeof opts.onResult === "function") {
          opts.onResult(result);
        }
        if (isMatch === false) {
          result.isMatch = false;
          return returnObject ? result : false;
        }
        if (isIgnored(input)) {
          if (typeof opts.onIgnore === "function") {
            opts.onIgnore(result);
          }
          result.isMatch = false;
          return returnObject ? result : false;
        }
        if (typeof opts.onMatch === "function") {
          opts.onMatch(result);
        }
        return returnObject ? result : true;
      };
      if (returnState) {
        matcher.state = state;
      }
      return matcher;
    };
    picomatch.test = (input, regex, options, { glob, posix } = {}) => {
      if (typeof input !== "string") {
        throw new TypeError("Expected input to be a string");
      }
      if (input === "") {
        return { isMatch: false, output: "" };
      }
      const opts = options || {};
      const format = opts.format || (posix ? utils.toPosixSlashes : null);
      let match = input === glob;
      let output = match && format ? format(input) : input;
      if (match === false) {
        output = format ? format(input) : input;
        match = output === glob;
      }
      if (match === false || opts.capture === true) {
        if (opts.matchBase === true || opts.basename === true) {
          match = picomatch.matchBase(input, regex, options, posix);
        } else {
          match = regex.exec(output);
        }
      }
      return { isMatch: Boolean(match), match, output };
    };
    picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
      const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
      return regex.test(path33.basename(input));
    };
    picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
    picomatch.parse = (pattern, options) => {
      if (Array.isArray(pattern)) return pattern.map((p3) => picomatch.parse(p3, options));
      return parse4(pattern, { ...options, fastpaths: false });
    };
    picomatch.scan = (input, options) => scan(input, options);
    picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
      if (returnOutput === true) {
        return state.output;
      }
      const opts = options || {};
      const prepend = opts.contains ? "" : "^";
      const append2 = opts.contains ? "" : "$";
      let source = `${prepend}(?:${state.output})${append2}`;
      if (state && state.negated === true) {
        source = `^(?!${source}).*$`;
      }
      const regex = picomatch.toRegex(source, options);
      if (returnState === true) {
        regex.state = state;
      }
      return regex;
    };
    picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
      if (!input || typeof input !== "string") {
        throw new TypeError("Expected a non-empty string");
      }
      let parsed = { negated: false, fastpaths: true };
      if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
        parsed.output = parse4.fastpaths(input, options);
      }
      if (!parsed.output) {
        parsed = parse4(input, options);
      }
      return picomatch.compileRe(parsed, options, returnOutput, returnState);
    };
    picomatch.toRegex = (source, options) => {
      try {
        const opts = options || {};
        return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
      } catch (err) {
        if (options && options.debug === true) throw err;
        return /$^/;
      }
    };
    picomatch.constants = constants;
    module2.exports = picomatch;
  }
});

// node_modules/picomatch/index.js
var require_picomatch2 = __commonJS({
  "node_modules/picomatch/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_picomatch();
  }
});

// node_modules/micromatch/index.js
var require_micromatch = __commonJS({
  "node_modules/micromatch/index.js"(exports2, module2) {
    "use strict";
    var util4 = require("util");
    var braces = require_braces();
    var picomatch = require_picomatch2();
    var utils = require_utils5();
    var isEmptyString = (v) => v === "" || v === "./";
    var hasBraces = (v) => {
      const index = v.indexOf("{");
      return index > -1 && v.indexOf("}", index) > -1;
    };
    var micromatch = (list2, patterns, options) => {
      patterns = [].concat(patterns);
      list2 = [].concat(list2);
      let omit3 = /* @__PURE__ */ new Set();
      let keep = /* @__PURE__ */ new Set();
      let items = /* @__PURE__ */ new Set();
      let negatives = 0;
      let onResult = (state) => {
        items.add(state.output);
        if (options && options.onResult) {
          options.onResult(state);
        }
      };
      for (let i = 0; i < patterns.length; i++) {
        let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);
        let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
        if (negated) negatives++;
        for (let item of list2) {
          let matched = isMatch(item, true);
          let match = negated ? !matched.isMatch : matched.isMatch;
          if (!match) continue;
          if (negated) {
            omit3.add(matched.output);
          } else {
            omit3.delete(matched.output);
            keep.add(matched.output);
          }
        }
      }
      let result = negatives === patterns.length ? [...items] : [...keep];
      let matches = result.filter((item) => !omit3.has(item));
      if (options && matches.length === 0) {
        if (options.failglob === true) {
          throw new Error(`No matches found for "${patterns.join(", ")}"`);
        }
        if (options.nonull === true || options.nullglob === true) {
          return options.unescape ? patterns.map((p3) => p3.replace(/\\/g, "")) : patterns;
        }
      }
      return matches;
    };
    micromatch.match = micromatch;
    micromatch.matcher = (pattern, options) => picomatch(pattern, options);
    micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
    micromatch.any = micromatch.isMatch;
    micromatch.not = (list2, patterns, options = {}) => {
      patterns = [].concat(patterns).map(String);
      let result = /* @__PURE__ */ new Set();
      let items = [];
      let onResult = (state) => {
        if (options.onResult) options.onResult(state);
        items.push(state.output);
      };
      let matches = new Set(micromatch(list2, patterns, { ...options, onResult }));
      for (let item of items) {
        if (!matches.has(item)) {
          result.add(item);
        }
      }
      return [...result];
    };
    micromatch.contains = (str, pattern, options) => {
      if (typeof str !== "string") {
        throw new TypeError(`Expected a string: "${util4.inspect(str)}"`);
      }
      if (Array.isArray(pattern)) {
        return pattern.some((p3) => micromatch.contains(str, p3, options));
      }
      if (typeof pattern === "string") {
        if (isEmptyString(str) || isEmptyString(pattern)) {
          return false;
        }
        if (str.includes(pattern) || str.startsWith("./") && str.slice(2).includes(pattern)) {
          return true;
        }
      }
      return micromatch.isMatch(str, pattern, { ...options, contains: true });
    };
    micromatch.matchKeys = (obj, patterns, options) => {
      if (!utils.isObject(obj)) {
        throw new TypeError("Expected the first argument to be an object");
      }
      let keys2 = micromatch(Object.keys(obj), patterns, options);
      let res = {};
      for (let key of keys2) res[key] = obj[key];
      return res;
    };
    micromatch.some = (list2, patterns, options) => {
      let items = [].concat(list2);
      for (let pattern of [].concat(patterns)) {
        let isMatch = picomatch(String(pattern), options);
        if (items.some((item) => isMatch(item))) {
          return true;
        }
      }
      return false;
    };
    micromatch.every = (list2, patterns, options) => {
      let items = [].concat(list2);
      for (let pattern of [].concat(patterns)) {
        let isMatch = picomatch(String(pattern), options);
        if (!items.every((item) => isMatch(item))) {
          return false;
        }
      }
      return true;
    };
    micromatch.all = (str, patterns, options) => {
      if (typeof str !== "string") {
        throw new TypeError(`Expected a string: "${util4.inspect(str)}"`);
      }
      return [].concat(patterns).every((p3) => picomatch(p3, options)(str));
    };
    micromatch.capture = (glob, input, options) => {
      let posix = utils.isWindows(options);
      let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
      let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
      if (match) {
        return match.slice(1).map((v) => v === void 0 ? "" : v);
      }
    };
    micromatch.makeRe = (...args) => picomatch.makeRe(...args);
    micromatch.scan = (...args) => picomatch.scan(...args);
    micromatch.parse = (patterns, options) => {
      let res = [];
      for (let pattern of [].concat(patterns || [])) {
        for (let str of braces(String(pattern), options)) {
          res.push(picomatch.parse(str, options));
        }
      }
      return res;
    };
    micromatch.braces = (pattern, options) => {
      if (typeof pattern !== "string") throw new TypeError("Expected a string");
      if (options && options.nobrace === true || !hasBraces(pattern)) {
        return [pattern];
      }
      return braces(pattern, options);
    };
    micromatch.braceExpand = (pattern, options) => {
      if (typeof pattern !== "string") throw new TypeError("Expected a string");
      return micromatch.braces(pattern, { ...options, expand: true });
    };
    micromatch.hasBraces = hasBraces;
    module2.exports = micromatch;
  }
});

// node_modules/fast-glob/out/utils/pattern.js
var require_pattern = __commonJS({
  "node_modules/fast-glob/out/utils/pattern.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isAbsolute = exports2.partitionAbsoluteAndRelative = exports2.removeDuplicateSlashes = exports2.matchAny = exports2.convertPatternsToRe = exports2.makeRe = exports2.getPatternParts = exports2.expandBraceExpansion = exports2.expandPatternsWithBraceExpansion = exports2.isAffectDepthOfReadingPattern = exports2.endsWithSlashGlobStar = exports2.hasGlobStar = exports2.getBaseDirectory = exports2.isPatternRelatedToParentDirectory = exports2.getPatternsOutsideCurrentDirectory = exports2.getPatternsInsideCurrentDirectory = exports2.getPositivePatterns = exports2.getNegativePatterns = exports2.isPositivePattern = exports2.isNegativePattern = exports2.convertToNegativePattern = exports2.convertToPositivePattern = exports2.isDynamicPattern = exports2.isStaticPattern = void 0;
    var path33 = require("path");
    var globParent = require_glob_parent();
    var micromatch = require_micromatch();
    var GLOBSTAR = "**";
    var ESCAPE_SYMBOL = "\\";
    var COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
    var REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
    var REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
    var GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
    var BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
    var DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
    function isStaticPattern(pattern, options = {}) {
      return !isDynamicPattern(pattern, options);
    }
    exports2.isStaticPattern = isStaticPattern;
    function isDynamicPattern(pattern, options = {}) {
      if (pattern === "") {
        return false;
      }
      if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
        return true;
      }
      if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
        return true;
      }
      if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
        return true;
      }
      if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
        return true;
      }
      return false;
    }
    exports2.isDynamicPattern = isDynamicPattern;
    function hasBraceExpansion(pattern) {
      const openingBraceIndex = pattern.indexOf("{");
      if (openingBraceIndex === -1) {
        return false;
      }
      const closingBraceIndex = pattern.indexOf("}", openingBraceIndex + 1);
      if (closingBraceIndex === -1) {
        return false;
      }
      const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
      return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
    }
    function convertToPositivePattern(pattern) {
      return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
    }
    exports2.convertToPositivePattern = convertToPositivePattern;
    function convertToNegativePattern(pattern) {
      return "!" + pattern;
    }
    exports2.convertToNegativePattern = convertToNegativePattern;
    function isNegativePattern(pattern) {
      return pattern.startsWith("!") && pattern[1] !== "(";
    }
    exports2.isNegativePattern = isNegativePattern;
    function isPositivePattern(pattern) {
      return !isNegativePattern(pattern);
    }
    exports2.isPositivePattern = isPositivePattern;
    function getNegativePatterns(patterns) {
      return patterns.filter(isNegativePattern);
    }
    exports2.getNegativePatterns = getNegativePatterns;
    function getPositivePatterns(patterns) {
      return patterns.filter(isPositivePattern);
    }
    exports2.getPositivePatterns = getPositivePatterns;
    function getPatternsInsideCurrentDirectory(patterns) {
      return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
    }
    exports2.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
    function getPatternsOutsideCurrentDirectory(patterns) {
      return patterns.filter(isPatternRelatedToParentDirectory);
    }
    exports2.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
    function isPatternRelatedToParentDirectory(pattern) {
      return pattern.startsWith("..") || pattern.startsWith("./..");
    }
    exports2.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
    function getBaseDirectory(pattern) {
      return globParent(pattern, { flipBackslashes: false });
    }
    exports2.getBaseDirectory = getBaseDirectory;
    function hasGlobStar(pattern) {
      return pattern.includes(GLOBSTAR);
    }
    exports2.hasGlobStar = hasGlobStar;
    function endsWithSlashGlobStar(pattern) {
      return pattern.endsWith("/" + GLOBSTAR);
    }
    exports2.endsWithSlashGlobStar = endsWithSlashGlobStar;
    function isAffectDepthOfReadingPattern(pattern) {
      const basename = path33.basename(pattern);
      return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
    }
    exports2.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
    function expandPatternsWithBraceExpansion(patterns) {
      return patterns.reduce((collection, pattern) => {
        return collection.concat(expandBraceExpansion(pattern));
      }, []);
    }
    exports2.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
    function expandBraceExpansion(pattern) {
      const patterns = micromatch.braces(pattern, { expand: true, nodupes: true, keepEscaping: true });
      patterns.sort((a, b) => a.length - b.length);
      return patterns.filter((pattern2) => pattern2 !== "");
    }
    exports2.expandBraceExpansion = expandBraceExpansion;
    function getPatternParts(pattern, options) {
      let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
      if (parts.length === 0) {
        parts = [pattern];
      }
      if (parts[0].startsWith("/")) {
        parts[0] = parts[0].slice(1);
        parts.unshift("");
      }
      return parts;
    }
    exports2.getPatternParts = getPatternParts;
    function makeRe(pattern, options) {
      return micromatch.makeRe(pattern, options);
    }
    exports2.makeRe = makeRe;
    function convertPatternsToRe(patterns, options) {
      return patterns.map((pattern) => makeRe(pattern, options));
    }
    exports2.convertPatternsToRe = convertPatternsToRe;
    function matchAny(entry, patternsRe) {
      return patternsRe.some((patternRe) => patternRe.test(entry));
    }
    exports2.matchAny = matchAny;
    function removeDuplicateSlashes(pattern) {
      return pattern.replace(DOUBLE_SLASH_RE, "/");
    }
    exports2.removeDuplicateSlashes = removeDuplicateSlashes;
    function partitionAbsoluteAndRelative(patterns) {
      const absolute = [];
      const relative = [];
      for (const pattern of patterns) {
        if (isAbsolute(pattern)) {
          absolute.push(pattern);
        } else {
          relative.push(pattern);
        }
      }
      return [absolute, relative];
    }
    exports2.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
    function isAbsolute(pattern) {
      return path33.isAbsolute(pattern);
    }
    exports2.isAbsolute = isAbsolute;
  }
});

// node_modules/merge2/index.js
var require_merge2 = __commonJS({
  "node_modules/merge2/index.js"(exports2, module2) {
    "use strict";
    var Stream = require("stream");
    var PassThrough = Stream.PassThrough;
    var slice = Array.prototype.slice;
    module2.exports = merge22;
    function merge22() {
      const streamsQueue = [];
      const args = slice.call(arguments);
      let merging = false;
      let options = args[args.length - 1];
      if (options && !Array.isArray(options) && options.pipe == null) {
        args.pop();
      } else {
        options = {};
      }
      const doEnd = options.end !== false;
      const doPipeError = options.pipeError === true;
      if (options.objectMode == null) {
        options.objectMode = true;
      }
      if (options.highWaterMark == null) {
        options.highWaterMark = 64 * 1024;
      }
      const mergedStream = PassThrough(options);
      function addStream() {
        for (let i = 0, len = arguments.length; i < len; i++) {
          streamsQueue.push(pauseStreams(arguments[i], options));
        }
        mergeStream();
        return this;
      }
      function mergeStream() {
        if (merging) {
          return;
        }
        merging = true;
        let streams = streamsQueue.shift();
        if (!streams) {
          process.nextTick(endStream);
          return;
        }
        if (!Array.isArray(streams)) {
          streams = [streams];
        }
        let pipesCount = streams.length + 1;
        function next() {
          if (--pipesCount > 0) {
            return;
          }
          merging = false;
          mergeStream();
        }
        function pipe3(stream4) {
          function onend() {
            stream4.removeListener("merge2UnpipeEnd", onend);
            stream4.removeListener("end", onend);
            if (doPipeError) {
              stream4.removeListener("error", onerror);
            }
            next();
          }
          function onerror(err) {
            mergedStream.emit("error", err);
          }
          if (stream4._readableState.endEmitted) {
            return next();
          }
          stream4.on("merge2UnpipeEnd", onend);
          stream4.on("end", onend);
          if (doPipeError) {
            stream4.on("error", onerror);
          }
          stream4.pipe(mergedStream, { end: false });
          stream4.resume();
        }
        for (let i = 0; i < streams.length; i++) {
          pipe3(streams[i]);
        }
        next();
      }
      function endStream() {
        merging = false;
        mergedStream.emit("queueDrain");
        if (doEnd) {
          mergedStream.end();
        }
      }
      mergedStream.setMaxListeners(0);
      mergedStream.add = addStream;
      mergedStream.on("unpipe", function(stream4) {
        stream4.emit("merge2UnpipeEnd");
      });
      if (args.length) {
        addStream.apply(null, args);
      }
      return mergedStream;
    }
    function pauseStreams(streams, options) {
      if (!Array.isArray(streams)) {
        if (!streams._readableState && streams.pipe) {
          streams = streams.pipe(PassThrough(options));
        }
        if (!streams._readableState || !streams.pause || !streams.pipe) {
          throw new Error("Only readable stream can be merged.");
        }
        streams.pause();
      } else {
        for (let i = 0, len = streams.length; i < len; i++) {
          streams[i] = pauseStreams(streams[i], options);
        }
      }
      return streams;
    }
  }
});

// node_modules/fast-glob/out/utils/stream.js
var require_stream3 = __commonJS({
  "node_modules/fast-glob/out/utils/stream.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.merge = void 0;
    var merge22 = require_merge2();
    function merge4(streams) {
      const mergedStream = merge22(streams);
      streams.forEach((stream4) => {
        stream4.once("error", (error73) => mergedStream.emit("error", error73));
      });
      mergedStream.once("close", () => propagateCloseEventToSources(streams));
      mergedStream.once("end", () => propagateCloseEventToSources(streams));
      return mergedStream;
    }
    exports2.merge = merge4;
    function propagateCloseEventToSources(streams) {
      streams.forEach((stream4) => stream4.emit("close"));
    }
  }
});

// node_modules/fast-glob/out/utils/string.js
var require_string = __commonJS({
  "node_modules/fast-glob/out/utils/string.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isEmpty = exports2.isString = void 0;
    function isString2(input) {
      return typeof input === "string";
    }
    exports2.isString = isString2;
    function isEmpty(input) {
      return input === "";
    }
    exports2.isEmpty = isEmpty;
  }
});

// node_modules/fast-glob/out/utils/index.js
var require_utils6 = __commonJS({
  "node_modules/fast-glob/out/utils/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.string = exports2.stream = exports2.pattern = exports2.path = exports2.fs = exports2.errno = exports2.array = void 0;
    var array4 = require_array();
    exports2.array = array4;
    var errno = require_errno();
    exports2.errno = errno;
    var fs34 = require_fs();
    exports2.fs = fs34;
    var path33 = require_path();
    exports2.path = path33;
    var pattern = require_pattern();
    exports2.pattern = pattern;
    var stream4 = require_stream3();
    exports2.stream = stream4;
    var string5 = require_string();
    exports2.string = string5;
  }
});

// node_modules/fast-glob/out/managers/tasks.js
var require_tasks = __commonJS({
  "node_modules/fast-glob/out/managers/tasks.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.convertPatternGroupToTask = exports2.convertPatternGroupsToTasks = exports2.groupPatternsByBaseDirectory = exports2.getNegativePatternsAsPositive = exports2.getPositivePatterns = exports2.convertPatternsToTasks = exports2.generate = void 0;
    var utils = require_utils6();
    function generate(input, settings) {
      const patterns = processPatterns(input, settings);
      const ignore = processPatterns(settings.ignore, settings);
      const positivePatterns = getPositivePatterns(patterns);
      const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
      const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
      const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
      const staticTasks = convertPatternsToTasks(
        staticPatterns,
        negativePatterns,
        /* dynamic */
        false
      );
      const dynamicTasks = convertPatternsToTasks(
        dynamicPatterns,
        negativePatterns,
        /* dynamic */
        true
      );
      return staticTasks.concat(dynamicTasks);
    }
    exports2.generate = generate;
    function processPatterns(input, settings) {
      let patterns = input;
      if (settings.braceExpansion) {
        patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns);
      }
      if (settings.baseNameMatch) {
        patterns = patterns.map((pattern) => pattern.includes("/") ? pattern : `**/${pattern}`);
      }
      return patterns.map((pattern) => utils.pattern.removeDuplicateSlashes(pattern));
    }
    function convertPatternsToTasks(positive, negative, dynamic) {
      const tasks = [];
      const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
      const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
      const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
      const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
      tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
      if ("." in insideCurrentDirectoryGroup) {
        tasks.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
      } else {
        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
      }
      return tasks;
    }
    exports2.convertPatternsToTasks = convertPatternsToTasks;
    function getPositivePatterns(patterns) {
      return utils.pattern.getPositivePatterns(patterns);
    }
    exports2.getPositivePatterns = getPositivePatterns;
    function getNegativePatternsAsPositive(patterns, ignore) {
      const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
      const positive = negative.map(utils.pattern.convertToPositivePattern);
      return positive;
    }
    exports2.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
    function groupPatternsByBaseDirectory(patterns) {
      const group = {};
      return patterns.reduce((collection, pattern) => {
        const base = utils.pattern.getBaseDirectory(pattern);
        if (base in collection) {
          collection[base].push(pattern);
        } else {
          collection[base] = [pattern];
        }
        return collection;
      }, group);
    }
    exports2.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
    function convertPatternGroupsToTasks(positive, negative, dynamic) {
      return Object.keys(positive).map((base) => {
        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
      });
    }
    exports2.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
    function convertPatternGroupToTask(base, positive, negative, dynamic) {
      return {
        dynamic,
        positive,
        negative,
        base,
        patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
      };
    }
    exports2.convertPatternGroupToTask = convertPatternGroupToTask;
  }
});

// node_modules/@nodelib/fs.stat/out/providers/async.js
var require_async = __commonJS({
  "node_modules/@nodelib/fs.stat/out/providers/async.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.read = void 0;
    function read(path33, settings, callback) {
      settings.fs.lstat(path33, (lstatError, lstat) => {
        if (lstatError !== null) {
          callFailureCallback(callback, lstatError);
          return;
        }
        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
          callSuccessCallback(callback, lstat);
          return;
        }
        settings.fs.stat(path33, (statError, stat) => {
          if (statError !== null) {
            if (settings.throwErrorOnBrokenSymbolicLink) {
              callFailureCallback(callback, statError);
              return;
            }
            callSuccessCallback(callback, lstat);
            return;
          }
          if (settings.markSymbolicLink) {
            stat.isSymbolicLink = () => true;
          }
          callSuccessCallback(callback, stat);
        });
      });
    }
    exports2.read = read;
    function callFailureCallback(callback, error73) {
      callback(error73);
    }
    function callSuccessCallback(callback, result) {
      callback(null, result);
    }
  }
});

// node_modules/@nodelib/fs.stat/out/providers/sync.js
var require_sync = __commonJS({
  "node_modules/@nodelib/fs.stat/out/providers/sync.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.read = void 0;
    function read(path33, settings) {
      const lstat = settings.fs.lstatSync(path33);
      if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
        return lstat;
      }
      try {
        const stat = settings.fs.statSync(path33);
        if (settings.markSymbolicLink) {
          stat.isSymbolicLink = () => true;
        }
        return stat;
      } catch (error73) {
        if (!settings.throwErrorOnBrokenSymbolicLink) {
          return lstat;
        }
        throw error73;
      }
    }
    exports2.read = read;
  }
});

// node_modules/@nodelib/fs.stat/out/adapters/fs.js
var require_fs2 = __commonJS({
  "node_modules/@nodelib/fs.stat/out/adapters/fs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
    var fs34 = require("fs");
    exports2.FILE_SYSTEM_ADAPTER = {
      lstat: fs34.lstat,
      stat: fs34.stat,
      lstatSync: fs34.lstatSync,
      statSync: fs34.statSync
    };
    function createFileSystemAdapter(fsMethods) {
      if (fsMethods === void 0) {
        return exports2.FILE_SYSTEM_ADAPTER;
      }
      return Object.assign(Object.assign({}, exports2.FILE_SYSTEM_ADAPTER), fsMethods);
    }
    exports2.createFileSystemAdapter = createFileSystemAdapter;
  }
});

// node_modules/@nodelib/fs.stat/out/settings.js
var require_settings = __commonJS({
  "node_modules/@nodelib/fs.stat/out/settings.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var fs34 = require_fs2();
    var Settings = class {
      constructor(_options = {}) {
        this._options = _options;
        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
        this.fs = fs34.createFileSystemAdapter(this._options.fs);
        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
      }
      _getValue(option, value) {
        return option !== null && option !== void 0 ? option : value;
      }
    };
    exports2.default = Settings;
  }
});

// node_modules/@nodelib/fs.stat/out/index.js
var require_out = __commonJS({
  "node_modules/@nodelib/fs.stat/out/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.statSync = exports2.stat = exports2.Settings = void 0;
    var async = require_async();
    var sync = require_sync();
    var settings_1 = require_settings();
    exports2.Settings = settings_1.default;
    function stat(path33, optionsOrSettingsOrCallback, callback) {
      if (typeof optionsOrSettingsOrCallback === "function") {
        async.read(path33, getSettings(), optionsOrSettingsOrCallback);
        return;
      }
      async.read(path33, getSettings(optionsOrSettingsOrCallback), callback);
    }
    exports2.stat = stat;
    function statSync(path33, optionsOrSettings) {
      const settings = getSettings(optionsOrSettings);
      return sync.read(path33, settings);
    }
    exports2.statSync = statSync;
    function getSettings(settingsOrOptions = {}) {
      if (settingsOrOptions instanceof settings_1.default) {
        return settingsOrOptions;
      }
      return new settings_1.default(settingsOrOptions);
    }
  }
});

// node_modules/queue-microtask/index.js
var require_queue_microtask = __commonJS({
  "node_modules/queue-microtask/index.js"(exports2, module2) {
    "use strict";
    var promise3;
    module2.exports = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : global) : (cb) => (promise3 || (promise3 = Promise.resolve())).then(cb).catch((err) => setTimeout(() => {
      throw err;
    }, 0));
  }
});

// node_modules/run-parallel/index.js
var require_run_parallel = __commonJS({
  "node_modules/run-parallel/index.js"(exports2, module2) {
    "use strict";
    module2.exports = runParallel;
    var queueMicrotask2 = require_queue_microtask();
    function runParallel(tasks, cb) {
      let results, pending, keys2;
      let isSync = true;
      if (Array.isArray(tasks)) {
        results = [];
        pending = tasks.length;
      } else {
        keys2 = Object.keys(tasks);
        results = {};
        pending = keys2.length;
      }
      function done(err) {
        function end() {
          if (cb) cb(err, results);
          cb = null;
        }
        if (isSync) queueMicrotask2(end);
        else end();
      }
      function each(i, err, result) {
        results[i] = result;
        if (--pending === 0 || err) {
          done(err);
        }
      }
      if (!pending) {
        done(null);
      } else if (keys2) {
        keys2.forEach(function(key) {
          tasks[key](function(err, result) {
            each(key, err, result);
          });
        });
      } else {
        tasks.forEach(function(task, i) {
          task(function(err, result) {
            each(i, err, result);
          });
        });
      }
      isSync = false;
    }
  }
});

// node_modules/@nodelib/fs.scandir/out/constants.js
var require_constants5 = __commonJS({
  "node_modules/@nodelib/fs.scandir/out/constants.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
    var NODE_PROCESS_VERSION_PARTS = process.versions.node.split(".");
    if (NODE_PROCESS_VERSION_PARTS[0] === void 0 || NODE_PROCESS_VERSION_PARTS[1] === void 0) {
      throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
    }
    var MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
    var MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
    var SUPPORTED_MAJOR_VERSION = 10;
    var SUPPORTED_MINOR_VERSION = 10;
    var IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
    var IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
    exports2.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
  }
});

// node_modules/@nodelib/fs.scandir/out/utils/fs.js
var require_fs3 = __commonJS({
  "node_modules/@nodelib/fs.scandir/out/utils/fs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createDirentFromStats = void 0;
    var DirentFromStats = class {
      constructor(name28, stats) {
        this.name = name28;
        this.isBlockDevice = stats.isBlockDevice.bind(stats);
        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
        this.isDirectory = stats.isDirectory.bind(stats);
        this.isFIFO = stats.isFIFO.bind(stats);
        this.isFile = stats.isFile.bind(stats);
        this.isSocket = stats.isSocket.bind(stats);
        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
      }
    };
    function createDirentFromStats(name28, stats) {
      return new DirentFromStats(name28, stats);
    }
    exports2.createDirentFromStats = createDirentFromStats;
  }
});

// node_modules/@nodelib/fs.scandir/out/utils/index.js
var require_utils7 = __commonJS({
  "node_modules/@nodelib/fs.scandir/out/utils/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.fs = void 0;
    var fs34 = require_fs3();
    exports2.fs = fs34;
  }
});

// node_modules/@nodelib/fs.scandir/out/providers/common.js
var require_common2 = __commonJS({
  "node_modules/@nodelib/fs.scandir/out/providers/common.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.joinPathSegments = void 0;
    function joinPathSegments(a, b, separator) {
      if (a.endsWith(separator)) {
        return a + b;
      }
      return a + separator + b;
    }
    exports2.joinPathSegments = joinPathSegments;
  }
});

// node_modules/@nodelib/fs.scandir/out/providers/async.js
var require_async2 = __commonJS({
  "node_modules/@nodelib/fs.scandir/out/providers/async.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.readdir = exports2.readdirWithFileTypes = exports2.read = void 0;
    var fsStat = require_out();
    var rpl = require_run_parallel();
    var constants_1 = require_constants5();
    var utils = require_utils7();
    var common = require_common2();
    function read(directory, settings, callback) {
      if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
        readdirWithFileTypes(directory, settings, callback);
        return;
      }
      readdir(directory, settings, callback);
    }
    exports2.read = read;
    function readdirWithFileTypes(directory, settings, callback) {
      settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
        if (readdirError !== null) {
          callFailureCallback(callback, readdirError);
          return;
        }
        const entries = dirents.map((dirent) => ({
          dirent,
          name: dirent.name,
          path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
        }));
        if (!settings.followSymbolicLinks) {
          callSuccessCallback(callback, entries);
          return;
        }
        const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
        rpl(tasks, (rplError, rplEntries) => {
          if (rplError !== null) {
            callFailureCallback(callback, rplError);
            return;
          }
          callSuccessCallback(callback, rplEntries);
        });
      });
    }
    exports2.readdirWithFileTypes = readdirWithFileTypes;
    function makeRplTaskEntry(entry, settings) {
      return (done) => {
        if (!entry.dirent.isSymbolicLink()) {
          done(null, entry);
          return;
        }
        settings.fs.stat(entry.path, (statError, stats) => {
          if (statError !== null) {
            if (settings.throwErrorOnBrokenSymbolicLink) {
              done(statError);
              return;
            }
            done(null, entry);
            return;
          }
          entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
          done(null, entry);
        });
      };
    }
    function readdir(directory, settings, callback) {
      settings.fs.readdir(directory, (readdirError, names) => {
        if (readdirError !== null) {
          callFailureCallback(callback, readdirError);
          return;
        }
        const tasks = names.map((name28) => {
          const path33 = common.joinPathSegments(directory, name28, settings.pathSegmentSeparator);
          return (done) => {
            fsStat.stat(path33, settings.fsStatSettings, (error73, stats) => {
              if (error73 !== null) {
                done(error73);
                return;
              }
              const entry = {
                name: name28,
                path: path33,
                dirent: utils.fs.createDirentFromStats(name28, stats)
              };
              if (settings.stats) {
                entry.stats = stats;
              }
              done(null, entry);
            });
          };
        });
        rpl(tasks, (rplError, entries) => {
          if (rplError !== null) {
            callFailureCallback(callback, rplError);
            return;
          }
          callSuccessCallback(callback, entries);
        });
      });
    }
    exports2.readdir = readdir;
    function callFailureCallback(callback, error73) {
      callback(error73);
    }
    function callSuccessCallback(callback, result) {
      callback(null, result);
    }
  }
});

// node_modules/@nodelib/fs.scandir/out/providers/sync.js
var require_sync2 = __commonJS({
  "node_modules/@nodelib/fs.scandir/out/providers/sync.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.readdir = exports2.readdirWithFileTypes = exports2.read = void 0;
    var fsStat = require_out();
    var constants_1 = require_constants5();
    var utils = require_utils7();
    var common = require_common2();
    function read(directory, settings) {
      if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
        return readdirWithFileTypes(directory, settings);
      }
      return readdir(directory, settings);
    }
    exports2.read = read;
    function readdirWithFileTypes(directory, settings) {
      const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
      return dirents.map((dirent) => {
        const entry = {
          dirent,
          name: dirent.name,
          path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
        };
        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
          try {
            const stats = settings.fs.statSync(entry.path);
            entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
          } catch (error73) {
            if (settings.throwErrorOnBrokenSymbolicLink) {
              throw error73;
            }
          }
        }
        return entry;
      });
    }
    exports2.readdirWithFileTypes = readdirWithFileTypes;
    function readdir(directory, settings) {
      const names = settings.fs.readdirSync(directory);
      return names.map((name28) => {
        const entryPath = common.joinPathSegments(directory, name28, settings.pathSegmentSeparator);
        const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
        const entry = {
          name: name28,
          path: entryPath,
          dirent: utils.fs.createDirentFromStats(name28, stats)
        };
        if (settings.stats) {
          entry.stats = stats;
        }
        return entry;
      });
    }
    exports2.readdir = readdir;
  }
});

// node_modules/@nodelib/fs.scandir/out/adapters/fs.js
var require_fs4 = __commonJS({
  "node_modules/@nodelib/fs.scandir/out/adapters/fs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
    var fs34 = require("fs");
    exports2.FILE_SYSTEM_ADAPTER = {
      lstat: fs34.lstat,
      stat: fs34.stat,
      lstatSync: fs34.lstatSync,
      statSync: fs34.statSync,
      readdir: fs34.readdir,
      readdirSync: fs34.readdirSync
    };
    function createFileSystemAdapter(fsMethods) {
      if (fsMethods === void 0) {
        return exports2.FILE_SYSTEM_ADAPTER;
      }
      return Object.assign(Object.assign({}, exports2.FILE_SYSTEM_ADAPTER), fsMethods);
    }
    exports2.createFileSystemAdapter = createFileSystemAdapter;
  }
});

// node_modules/@nodelib/fs.scandir/out/settings.js
var require_settings2 = __commonJS({
  "node_modules/@nodelib/fs.scandir/out/settings.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var path33 = require("path");
    var fsStat = require_out();
    var fs34 = require_fs4();
    var Settings = class {
      constructor(_options = {}) {
        this._options = _options;
        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
        this.fs = fs34.createFileSystemAdapter(this._options.fs);
        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path33.sep);
        this.stats = this._getValue(this._options.stats, false);
        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
        this.fsStatSettings = new fsStat.Settings({
          followSymbolicLink: this.followSymbolicLinks,
          fs: this.fs,
          throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
        });
      }
      _getValue(option, value) {
        return option !== null && option !== void 0 ? option : value;
      }
    };
    exports2.default = Settings;
  }
});

// node_modules/@nodelib/fs.scandir/out/index.js
var require_out2 = __commonJS({
  "node_modules/@nodelib/fs.scandir/out/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Settings = exports2.scandirSync = exports2.scandir = void 0;
    var async = require_async2();
    var sync = require_sync2();
    var settings_1 = require_settings2();
    exports2.Settings = settings_1.default;
    function scandir(path33, optionsOrSettingsOrCallback, callback) {
      if (typeof optionsOrSettingsOrCallback === "function") {
        async.read(path33, getSettings(), optionsOrSettingsOrCallback);
        return;
      }
      async.read(path33, getSettings(optionsOrSettingsOrCallback), callback);
    }
    exports2.scandir = scandir;
    function scandirSync(path33, optionsOrSettings) {
      const settings = getSettings(optionsOrSettings);
      return sync.read(path33, settings);
    }
    exports2.scandirSync = scandirSync;
    function getSettings(settingsOrOptions = {}) {
      if (settingsOrOptions instanceof settings_1.default) {
        return settingsOrOptions;
      }
      return new settings_1.default(settingsOrOptions);
    }
  }
});

// node_modules/reusify/reusify.js
var require_reusify = __commonJS({
  "node_modules/reusify/reusify.js"(exports2, module2) {
    "use strict";
    function reusify(Constructor) {
      var head = new Constructor();
      var tail = head;
      function get2() {
        var current = head;
        if (current.next) {
          head = current.next;
        } else {
          head = new Constructor();
          tail = head;
        }
        current.next = null;
        return current;
      }
      function release(obj) {
        tail.next = obj;
        tail = obj;
      }
      return {
        get: get2,
        release
      };
    }
    module2.exports = reusify;
  }
});

// node_modules/fastq/queue.js
var require_queue = __commonJS({
  "node_modules/fastq/queue.js"(exports2, module2) {
    "use strict";
    var reusify = require_reusify();
    function fastqueue(context2, worker, _concurrency) {
      if (typeof context2 === "function") {
        _concurrency = worker;
        worker = context2;
        context2 = null;
      }
      if (!(_concurrency >= 1)) {
        throw new Error("fastqueue concurrency must be equal to or greater than 1");
      }
      var cache = reusify(Task);
      var queueHead = null;
      var queueTail = null;
      var _running = 0;
      var errorHandler = null;
      var self2 = {
        push,
        drain: noop4,
        saturated: noop4,
        pause,
        paused: false,
        get concurrency() {
          return _concurrency;
        },
        set concurrency(value) {
          if (!(value >= 1)) {
            throw new Error("fastqueue concurrency must be equal to or greater than 1");
          }
          _concurrency = value;
          if (self2.paused) return;
          for (; queueHead && _running < _concurrency; ) {
            _running++;
            release();
          }
        },
        running,
        resume,
        idle,
        length,
        getQueue,
        unshift,
        empty: noop4,
        kill,
        killAndDrain,
        error: error73,
        abort
      };
      return self2;
      function running() {
        return _running;
      }
      function pause() {
        self2.paused = true;
      }
      function length() {
        var current = queueHead;
        var counter = 0;
        while (current) {
          current = current.next;
          counter++;
        }
        return counter;
      }
      function getQueue() {
        var current = queueHead;
        var tasks = [];
        while (current) {
          tasks.push(current.value);
          current = current.next;
        }
        return tasks;
      }
      function resume() {
        if (!self2.paused) return;
        self2.paused = false;
        if (queueHead === null) {
          _running++;
          release();
          return;
        }
        for (; queueHead && _running < _concurrency; ) {
          _running++;
          release();
        }
      }
      function idle() {
        return _running === 0 && self2.length() === 0;
      }
      function push(value, done) {
        var current = cache.get();
        current.context = context2;
        current.release = release;
        current.value = value;
        current.callback = done || noop4;
        current.errorHandler = errorHandler;
        if (_running >= _concurrency || self2.paused) {
          if (queueTail) {
            queueTail.next = current;
            queueTail = current;
          } else {
            queueHead = current;
            queueTail = current;
            self2.saturated();
          }
        } else {
          _running++;
          worker.call(context2, current.value, current.worked);
        }
      }
      function unshift(value, done) {
        var current = cache.get();
        current.context = context2;
        current.release = release;
        current.value = value;
        current.callback = done || noop4;
        current.errorHandler = errorHandler;
        if (_running >= _concurrency || self2.paused) {
          if (queueHead) {
            current.next = queueHead;
            queueHead = current;
          } else {
            queueHead = current;
            queueTail = current;
            self2.saturated();
          }
        } else {
          _running++;
          worker.call(context2, current.value, current.worked);
        }
      }
      function release(holder) {
        if (holder) {
          cache.release(holder);
        }
        var next = queueHead;
        if (next && _running <= _concurrency) {
          if (!self2.paused) {
            if (queueTail === queueHead) {
              queueTail = null;
            }
            queueHead = next.next;
            next.next = null;
            worker.call(context2, next.value, next.worked);
            if (queueTail === null) {
              self2.empty();
            }
          } else {
            _running--;
          }
        } else if (--_running === 0) {
          self2.drain();
        }
      }
      function kill() {
        queueHead = null;
        queueTail = null;
        self2.drain = noop4;
      }
      function killAndDrain() {
        queueHead = null;
        queueTail = null;
        self2.drain();
        self2.drain = noop4;
      }
      function abort() {
        var current = queueHead;
        queueHead = null;
        queueTail = null;
        while (current) {
          var next = current.next;
          var callback = current.callback;
          var errorHandler2 = current.errorHandler;
          var val = current.value;
          var context3 = current.context;
          current.value = null;
          current.callback = noop4;
          current.errorHandler = null;
          if (errorHandler2) {
            errorHandler2(new Error("abort"), val);
          }
          callback.call(context3, new Error("abort"));
          current.release(current);
          current = next;
        }
        self2.drain = noop4;
      }
      function error73(handler) {
        errorHandler = handler;
      }
    }
    function noop4() {
    }
    function Task() {
      this.value = null;
      this.callback = noop4;
      this.next = null;
      this.release = noop4;
      this.context = null;
      this.errorHandler = null;
      var self2 = this;
      this.worked = function worked(err, result) {
        var callback = self2.callback;
        var errorHandler = self2.errorHandler;
        var val = self2.value;
        self2.value = null;
        self2.callback = noop4;
        if (self2.errorHandler) {
          errorHandler(err, val);
        }
        callback.call(self2.context, err, result);
        self2.release(self2);
      };
    }
    function queueAsPromised(context2, worker, _concurrency) {
      if (typeof context2 === "function") {
        _concurrency = worker;
        worker = context2;
        context2 = null;
      }
      function asyncWrapper(arg, cb) {
        worker.call(this, arg).then(function(res) {
          cb(null, res);
        }, cb);
      }
      var queue = fastqueue(context2, asyncWrapper, _concurrency);
      var pushCb = queue.push;
      var unshiftCb = queue.unshift;
      queue.push = push;
      queue.unshift = unshift;
      queue.drained = drained;
      return queue;
      function push(value) {
        var p3 = new Promise(function(resolve3, reject) {
          pushCb(value, function(err, result) {
            if (err) {
              reject(err);
              return;
            }
            resolve3(result);
          });
        });
        p3.catch(noop4);
        return p3;
      }
      function unshift(value) {
        var p3 = new Promise(function(resolve3, reject) {
          unshiftCb(value, function(err, result) {
            if (err) {
              reject(err);
              return;
            }
            resolve3(result);
          });
        });
        p3.catch(noop4);
        return p3;
      }
      function drained() {
        var p3 = new Promise(function(resolve3) {
          process.nextTick(function() {
            if (queue.idle()) {
              resolve3();
            } else {
              var previousDrain = queue.drain;
              queue.drain = function() {
                if (typeof previousDrain === "function") previousDrain();
                resolve3();
                queue.drain = previousDrain;
              };
            }
          });
        });
        return p3;
      }
    }
    module2.exports = fastqueue;
    module2.exports.promise = queueAsPromised;
  }
});

// node_modules/@nodelib/fs.walk/out/readers/common.js
var require_common3 = __commonJS({
  "node_modules/@nodelib/fs.walk/out/readers/common.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.joinPathSegments = exports2.replacePathSegmentSeparator = exports2.isAppliedFilter = exports2.isFatalError = void 0;
    function isFatalError(settings, error73) {
      if (settings.errorFilter === null) {
        return true;
      }
      return !settings.errorFilter(error73);
    }
    exports2.isFatalError = isFatalError;
    function isAppliedFilter(filter6, value) {
      return filter6 === null || filter6(value);
    }
    exports2.isAppliedFilter = isAppliedFilter;
    function replacePathSegmentSeparator(filepath, separator) {
      return filepath.split(/[/\\]/).join(separator);
    }
    exports2.replacePathSegmentSeparator = replacePathSegmentSeparator;
    function joinPathSegments(a, b, separator) {
      if (a === "") {
        return b;
      }
      if (a.endsWith(separator)) {
        return a + b;
      }
      return a + separator + b;
    }
    exports2.joinPathSegments = joinPathSegments;
  }
});

// node_modules/@nodelib/fs.walk/out/readers/reader.js
var require_reader = __commonJS({
  "node_modules/@nodelib/fs.walk/out/readers/reader.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var common = require_common3();
    var Reader = class {
      constructor(_root, _settings) {
        this._root = _root;
        this._settings = _settings;
        this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
      }
    };
    exports2.default = Reader;
  }
});

// node_modules/@nodelib/fs.walk/out/readers/async.js
var require_async3 = __commonJS({
  "node_modules/@nodelib/fs.walk/out/readers/async.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var events_1 = require("events");
    var fsScandir = require_out2();
    var fastq = require_queue();
    var common = require_common3();
    var reader_1 = require_reader();
    var AsyncReader = class extends reader_1.default {
      constructor(_root, _settings) {
        super(_root, _settings);
        this._settings = _settings;
        this._scandir = fsScandir.scandir;
        this._emitter = new events_1.EventEmitter();
        this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
        this._isFatalError = false;
        this._isDestroyed = false;
        this._queue.drain = () => {
          if (!this._isFatalError) {
            this._emitter.emit("end");
          }
        };
      }
      read() {
        this._isFatalError = false;
        this._isDestroyed = false;
        setImmediate(() => {
          this._pushToQueue(this._root, this._settings.basePath);
        });
        return this._emitter;
      }
      get isDestroyed() {
        return this._isDestroyed;
      }
      destroy() {
        if (this._isDestroyed) {
          throw new Error("The reader is already destroyed");
        }
        this._isDestroyed = true;
        this._queue.killAndDrain();
      }
      onEntry(callback) {
        this._emitter.on("entry", callback);
      }
      onError(callback) {
        this._emitter.once("error", callback);
      }
      onEnd(callback) {
        this._emitter.once("end", callback);
      }
      _pushToQueue(directory, base) {
        const queueItem = { directory, base };
        this._queue.push(queueItem, (error73) => {
          if (error73 !== null) {
            this._handleError(error73);
          }
        });
      }
      _worker(item, done) {
        this._scandir(item.directory, this._settings.fsScandirSettings, (error73, entries) => {
          if (error73 !== null) {
            done(error73, void 0);
            return;
          }
          for (const entry of entries) {
            this._handleEntry(entry, item.base);
          }
          done(null, void 0);
        });
      }
      _handleError(error73) {
        if (this._isDestroyed || !common.isFatalError(this._settings, error73)) {
          return;
        }
        this._isFatalError = true;
        this._isDestroyed = true;
        this._emitter.emit("error", error73);
      }
      _handleEntry(entry, base) {
        if (this._isDestroyed || this._isFatalError) {
          return;
        }
        const fullpath = entry.path;
        if (base !== void 0) {
          entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
        }
        if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
          this._emitEntry(entry);
        }
        if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
          this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
        }
      }
      _emitEntry(entry) {
        this._emitter.emit("entry", entry);
      }
    };
    exports2.default = AsyncReader;
  }
});

// node_modules/@nodelib/fs.walk/out/providers/async.js
var require_async4 = __commonJS({
  "node_modules/@nodelib/fs.walk/out/providers/async.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var async_1 = require_async3();
    var AsyncProvider = class {
      constructor(_root, _settings) {
        this._root = _root;
        this._settings = _settings;
        this._reader = new async_1.default(this._root, this._settings);
        this._storage = [];
      }
      read(callback) {
        this._reader.onError((error73) => {
          callFailureCallback(callback, error73);
        });
        this._reader.onEntry((entry) => {
          this._storage.push(entry);
        });
        this._reader.onEnd(() => {
          callSuccessCallback(callback, this._storage);
        });
        this._reader.read();
      }
    };
    exports2.default = AsyncProvider;
    function callFailureCallback(callback, error73) {
      callback(error73);
    }
    function callSuccessCallback(callback, entries) {
      callback(null, entries);
    }
  }
});

// node_modules/@nodelib/fs.walk/out/providers/stream.js
var require_stream4 = __commonJS({
  "node_modules/@nodelib/fs.walk/out/providers/stream.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var stream_1 = require("stream");
    var async_1 = require_async3();
    var StreamProvider = class {
      constructor(_root, _settings) {
        this._root = _root;
        this._settings = _settings;
        this._reader = new async_1.default(this._root, this._settings);
        this._stream = new stream_1.Readable({
          objectMode: true,
          read: () => {
          },
          destroy: () => {
            if (!this._reader.isDestroyed) {
              this._reader.destroy();
            }
          }
        });
      }
      read() {
        this._reader.onError((error73) => {
          this._stream.emit("error", error73);
        });
        this._reader.onEntry((entry) => {
          this._stream.push(entry);
        });
        this._reader.onEnd(() => {
          this._stream.push(null);
        });
        this._reader.read();
        return this._stream;
      }
    };
    exports2.default = StreamProvider;
  }
});

// node_modules/@nodelib/fs.walk/out/readers/sync.js
var require_sync3 = __commonJS({
  "node_modules/@nodelib/fs.walk/out/readers/sync.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var fsScandir = require_out2();
    var common = require_common3();
    var reader_1 = require_reader();
    var SyncReader = class extends reader_1.default {
      constructor() {
        super(...arguments);
        this._scandir = fsScandir.scandirSync;
        this._storage = [];
        this._queue = /* @__PURE__ */ new Set();
      }
      read() {
        this._pushToQueue(this._root, this._settings.basePath);
        this._handleQueue();
        return this._storage;
      }
      _pushToQueue(directory, base) {
        this._queue.add({ directory, base });
      }
      _handleQueue() {
        for (const item of this._queue.values()) {
          this._handleDirectory(item.directory, item.base);
        }
      }
      _handleDirectory(directory, base) {
        try {
          const entries = this._scandir(directory, this._settings.fsScandirSettings);
          for (const entry of entries) {
            this._handleEntry(entry, base);
          }
        } catch (error73) {
          this._handleError(error73);
        }
      }
      _handleError(error73) {
        if (!common.isFatalError(this._settings, error73)) {
          return;
        }
        throw error73;
      }
      _handleEntry(entry, base) {
        const fullpath = entry.path;
        if (base !== void 0) {
          entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
        }
        if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
          this._pushToStorage(entry);
        }
        if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
          this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
        }
      }
      _pushToStorage(entry) {
        this._storage.push(entry);
      }
    };
    exports2.default = SyncReader;
  }
});

// node_modules/@nodelib/fs.walk/out/providers/sync.js
var require_sync4 = __commonJS({
  "node_modules/@nodelib/fs.walk/out/providers/sync.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var sync_1 = require_sync3();
    var SyncProvider = class {
      constructor(_root, _settings) {
        this._root = _root;
        this._settings = _settings;
        this._reader = new sync_1.default(this._root, this._settings);
      }
      read() {
        return this._reader.read();
      }
    };
    exports2.default = SyncProvider;
  }
});

// node_modules/@nodelib/fs.walk/out/settings.js
var require_settings3 = __commonJS({
  "node_modules/@nodelib/fs.walk/out/settings.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var path33 = require("path");
    var fsScandir = require_out2();
    var Settings = class {
      constructor(_options = {}) {
        this._options = _options;
        this.basePath = this._getValue(this._options.basePath, void 0);
        this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
        this.deepFilter = this._getValue(this._options.deepFilter, null);
        this.entryFilter = this._getValue(this._options.entryFilter, null);
        this.errorFilter = this._getValue(this._options.errorFilter, null);
        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path33.sep);
        this.fsScandirSettings = new fsScandir.Settings({
          followSymbolicLinks: this._options.followSymbolicLinks,
          fs: this._options.fs,
          pathSegmentSeparator: this._options.pathSegmentSeparator,
          stats: this._options.stats,
          throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
        });
      }
      _getValue(option, value) {
        return option !== null && option !== void 0 ? option : value;
      }
    };
    exports2.default = Settings;
  }
});

// node_modules/@nodelib/fs.walk/out/index.js
var require_out3 = __commonJS({
  "node_modules/@nodelib/fs.walk/out/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Settings = exports2.walkStream = exports2.walkSync = exports2.walk = void 0;
    var async_1 = require_async4();
    var stream_1 = require_stream4();
    var sync_1 = require_sync4();
    var settings_1 = require_settings3();
    exports2.Settings = settings_1.default;
    function walk(directory, optionsOrSettingsOrCallback, callback) {
      if (typeof optionsOrSettingsOrCallback === "function") {
        new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
        return;
      }
      new async_1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
    }
    exports2.walk = walk;
    function walkSync(directory, optionsOrSettings) {
      const settings = getSettings(optionsOrSettings);
      const provider = new sync_1.default(directory, settings);
      return provider.read();
    }
    exports2.walkSync = walkSync;
    function walkStream(directory, optionsOrSettings) {
      const settings = getSettings(optionsOrSettings);
      const provider = new stream_1.default(directory, settings);
      return provider.read();
    }
    exports2.walkStream = walkStream;
    function getSettings(settingsOrOptions = {}) {
      if (settingsOrOptions instanceof settings_1.default) {
        return settingsOrOptions;
      }
      return new settings_1.default(settingsOrOptions);
    }
  }
});

// node_modules/fast-glob/out/readers/reader.js
var require_reader2 = __commonJS({
  "node_modules/fast-glob/out/readers/reader.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var path33 = require("path");
    var fsStat = require_out();
    var utils = require_utils6();
    var Reader = class {
      constructor(_settings) {
        this._settings = _settings;
        this._fsStatSettings = new fsStat.Settings({
          followSymbolicLink: this._settings.followSymbolicLinks,
          fs: this._settings.fs,
          throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
        });
      }
      _getFullEntryPath(filepath) {
        return path33.resolve(this._settings.cwd, filepath);
      }
      _makeEntry(stats, pattern) {
        const entry = {
          name: pattern,
          path: pattern,
          dirent: utils.fs.createDirentFromStats(pattern, stats)
        };
        if (this._settings.stats) {
          entry.stats = stats;
        }
        return entry;
      }
      _isFatalError(error73) {
        return !utils.errno.isEnoentCodeError(error73) && !this._settings.suppressErrors;
      }
    };
    exports2.default = Reader;
  }
});

// node_modules/fast-glob/out/readers/stream.js
var require_stream5 = __commonJS({
  "node_modules/fast-glob/out/readers/stream.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var stream_1 = require("stream");
    var fsStat = require_out();
    var fsWalk = require_out3();
    var reader_1 = require_reader2();
    var ReaderStream = class extends reader_1.default {
      constructor() {
        super(...arguments);
        this._walkStream = fsWalk.walkStream;
        this._stat = fsStat.stat;
      }
      dynamic(root2, options) {
        return this._walkStream(root2, options);
      }
      static(patterns, options) {
        const filepaths = patterns.map(this._getFullEntryPath, this);
        const stream4 = new stream_1.PassThrough({ objectMode: true });
        stream4._write = (index, _enc, done) => {
          return this._getEntry(filepaths[index], patterns[index], options).then((entry) => {
            if (entry !== null && options.entryFilter(entry)) {
              stream4.push(entry);
            }
            if (index === filepaths.length - 1) {
              stream4.end();
            }
            done();
          }).catch(done);
        };
        for (let i = 0; i < filepaths.length; i++) {
          stream4.write(i);
        }
        return stream4;
      }
      _getEntry(filepath, pattern, options) {
        return this._getStat(filepath).then((stats) => this._makeEntry(stats, pattern)).catch((error73) => {
          if (options.errorFilter(error73)) {
            return null;
          }
          throw error73;
        });
      }
      _getStat(filepath) {
        return new Promise((resolve3, reject) => {
          this._stat(filepath, this._fsStatSettings, (error73, stats) => {
            return error73 === null ? resolve3(stats) : reject(error73);
          });
        });
      }
    };
    exports2.default = ReaderStream;
  }
});

// node_modules/fast-glob/out/readers/async.js
var require_async5 = __commonJS({
  "node_modules/fast-glob/out/readers/async.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var fsWalk = require_out3();
    var reader_1 = require_reader2();
    var stream_1 = require_stream5();
    var ReaderAsync = class extends reader_1.default {
      constructor() {
        super(...arguments);
        this._walkAsync = fsWalk.walk;
        this._readerStream = new stream_1.default(this._settings);
      }
      dynamic(root2, options) {
        return new Promise((resolve3, reject) => {
          this._walkAsync(root2, options, (error73, entries) => {
            if (error73 === null) {
              resolve3(entries);
            } else {
              reject(error73);
            }
          });
        });
      }
      async static(patterns, options) {
        const entries = [];
        const stream4 = this._readerStream.static(patterns, options);
        return new Promise((resolve3, reject) => {
          stream4.once("error", reject);
          stream4.on("data", (entry) => entries.push(entry));
          stream4.once("end", () => resolve3(entries));
        });
      }
    };
    exports2.default = ReaderAsync;
  }
});

// node_modules/fast-glob/out/providers/matchers/matcher.js
var require_matcher = __commonJS({
  "node_modules/fast-glob/out/providers/matchers/matcher.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var utils = require_utils6();
    var Matcher = class {
      constructor(_patterns, _settings, _micromatchOptions) {
        this._patterns = _patterns;
        this._settings = _settings;
        this._micromatchOptions = _micromatchOptions;
        this._storage = [];
        this._fillStorage();
      }
      _fillStorage() {
        for (const pattern of this._patterns) {
          const segments = this._getPatternSegments(pattern);
          const sections = this._splitSegmentsIntoSections(segments);
          this._storage.push({
            complete: sections.length <= 1,
            pattern,
            segments,
            sections
          });
        }
      }
      _getPatternSegments(pattern) {
        const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
        return parts.map((part) => {
          const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
          if (!dynamic) {
            return {
              dynamic: false,
              pattern: part
            };
          }
          return {
            dynamic: true,
            pattern: part,
            patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
          };
        });
      }
      _splitSegmentsIntoSections(segments) {
        return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
      }
    };
    exports2.default = Matcher;
  }
});

// node_modules/fast-glob/out/providers/matchers/partial.js
var require_partial = __commonJS({
  "node_modules/fast-glob/out/providers/matchers/partial.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var matcher_1 = require_matcher();
    var PartialMatcher = class extends matcher_1.default {
      match(filepath) {
        const parts = filepath.split("/");
        const levels = parts.length;
        const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
        for (const pattern of patterns) {
          const section = pattern.sections[0];
          if (!pattern.complete && levels > section.length) {
            return true;
          }
          const match = parts.every((part, index) => {
            const segment = pattern.segments[index];
            if (segment.dynamic && segment.patternRe.test(part)) {
              return true;
            }
            if (!segment.dynamic && segment.pattern === part) {
              return true;
            }
            return false;
          });
          if (match) {
            return true;
          }
        }
        return false;
      }
    };
    exports2.default = PartialMatcher;
  }
});

// node_modules/fast-glob/out/providers/filters/deep.js
var require_deep = __commonJS({
  "node_modules/fast-glob/out/providers/filters/deep.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var utils = require_utils6();
    var partial_1 = require_partial();
    var DeepFilter = class {
      constructor(_settings, _micromatchOptions) {
        this._settings = _settings;
        this._micromatchOptions = _micromatchOptions;
      }
      getFilter(basePath, positive, negative) {
        const matcher = this._getMatcher(positive);
        const negativeRe = this._getNegativePatternsRe(negative);
        return (entry) => this._filter(basePath, entry, matcher, negativeRe);
      }
      _getMatcher(patterns) {
        return new partial_1.default(patterns, this._settings, this._micromatchOptions);
      }
      _getNegativePatternsRe(patterns) {
        const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
        return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
      }
      _filter(basePath, entry, matcher, negativeRe) {
        if (this._isSkippedByDeep(basePath, entry.path)) {
          return false;
        }
        if (this._isSkippedSymbolicLink(entry)) {
          return false;
        }
        const filepath = utils.path.removeLeadingDotSegment(entry.path);
        if (this._isSkippedByPositivePatterns(filepath, matcher)) {
          return false;
        }
        return this._isSkippedByNegativePatterns(filepath, negativeRe);
      }
      _isSkippedByDeep(basePath, entryPath) {
        if (this._settings.deep === Infinity) {
          return false;
        }
        return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
      }
      _getEntryLevel(basePath, entryPath) {
        const entryPathDepth = entryPath.split("/").length;
        if (basePath === "") {
          return entryPathDepth;
        }
        const basePathDepth = basePath.split("/").length;
        return entryPathDepth - basePathDepth;
      }
      _isSkippedSymbolicLink(entry) {
        return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
      }
      _isSkippedByPositivePatterns(entryPath, matcher) {
        return !this._settings.baseNameMatch && !matcher.match(entryPath);
      }
      _isSkippedByNegativePatterns(entryPath, patternsRe) {
        return !utils.pattern.matchAny(entryPath, patternsRe);
      }
    };
    exports2.default = DeepFilter;
  }
});

// node_modules/fast-glob/out/providers/filters/entry.js
var require_entry = __commonJS({
  "node_modules/fast-glob/out/providers/filters/entry.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var utils = require_utils6();
    var EntryFilter = class {
      constructor(_settings, _micromatchOptions) {
        this._settings = _settings;
        this._micromatchOptions = _micromatchOptions;
        this.index = /* @__PURE__ */ new Map();
      }
      getFilter(positive, negative) {
        const [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative);
        const patterns = {
          positive: {
            all: utils.pattern.convertPatternsToRe(positive, this._micromatchOptions)
          },
          negative: {
            absolute: utils.pattern.convertPatternsToRe(absoluteNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true })),
            relative: utils.pattern.convertPatternsToRe(relativeNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }))
          }
        };
        return (entry) => this._filter(entry, patterns);
      }
      _filter(entry, patterns) {
        const filepath = utils.path.removeLeadingDotSegment(entry.path);
        if (this._settings.unique && this._isDuplicateEntry(filepath)) {
          return false;
        }
        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
          return false;
        }
        const isMatched = this._isMatchToPatternsSet(filepath, patterns, entry.dirent.isDirectory());
        if (this._settings.unique && isMatched) {
          this._createIndexRecord(filepath);
        }
        return isMatched;
      }
      _isDuplicateEntry(filepath) {
        return this.index.has(filepath);
      }
      _createIndexRecord(filepath) {
        this.index.set(filepath, void 0);
      }
      _onlyFileFilter(entry) {
        return this._settings.onlyFiles && !entry.dirent.isFile();
      }
      _onlyDirectoryFilter(entry) {
        return this._settings.onlyDirectories && !entry.dirent.isDirectory();
      }
      _isMatchToPatternsSet(filepath, patterns, isDirectory) {
        const isMatched = this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory);
        if (!isMatched) {
          return false;
        }
        const isMatchedByRelativeNegative = this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory);
        if (isMatchedByRelativeNegative) {
          return false;
        }
        const isMatchedByAbsoluteNegative = this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory);
        if (isMatchedByAbsoluteNegative) {
          return false;
        }
        return true;
      }
      _isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory) {
        if (patternsRe.length === 0) {
          return false;
        }
        const fullpath = utils.path.makeAbsolute(this._settings.cwd, filepath);
        return this._isMatchToPatterns(fullpath, patternsRe, isDirectory);
      }
      _isMatchToPatterns(filepath, patternsRe, isDirectory) {
        if (patternsRe.length === 0) {
          return false;
        }
        const isMatched = utils.pattern.matchAny(filepath, patternsRe);
        if (!isMatched && isDirectory) {
          return utils.pattern.matchAny(filepath + "/", patternsRe);
        }
        return isMatched;
      }
    };
    exports2.default = EntryFilter;
  }
});

// node_modules/fast-glob/out/providers/filters/error.js
var require_error = __commonJS({
  "node_modules/fast-glob/out/providers/filters/error.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var utils = require_utils6();
    var ErrorFilter = class {
      constructor(_settings) {
        this._settings = _settings;
      }
      getFilter() {
        return (error73) => this._isNonFatalError(error73);
      }
      _isNonFatalError(error73) {
        return utils.errno.isEnoentCodeError(error73) || this._settings.suppressErrors;
      }
    };
    exports2.default = ErrorFilter;
  }
});

// node_modules/fast-glob/out/providers/transformers/entry.js
var require_entry2 = __commonJS({
  "node_modules/fast-glob/out/providers/transformers/entry.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var utils = require_utils6();
    var EntryTransformer = class {
      constructor(_settings) {
        this._settings = _settings;
      }
      getTransformer() {
        return (entry) => this._transform(entry);
      }
      _transform(entry) {
        let filepath = entry.path;
        if (this._settings.absolute) {
          filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
          filepath = utils.path.unixify(filepath);
        }
        if (this._settings.markDirectories && entry.dirent.isDirectory()) {
          filepath += "/";
        }
        if (!this._settings.objectMode) {
          return filepath;
        }
        return Object.assign(Object.assign({}, entry), { path: filepath });
      }
    };
    exports2.default = EntryTransformer;
  }
});

// node_modules/fast-glob/out/providers/provider.js
var require_provider = __commonJS({
  "node_modules/fast-glob/out/providers/provider.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var path33 = require("path");
    var deep_1 = require_deep();
    var entry_1 = require_entry();
    var error_1 = require_error();
    var entry_2 = require_entry2();
    var Provider = class {
      constructor(_settings) {
        this._settings = _settings;
        this.errorFilter = new error_1.default(this._settings);
        this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
        this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
        this.entryTransformer = new entry_2.default(this._settings);
      }
      _getRootDirectory(task) {
        return path33.resolve(this._settings.cwd, task.base);
      }
      _getReaderOptions(task) {
        const basePath = task.base === "." ? "" : task.base;
        return {
          basePath,
          pathSegmentSeparator: "/",
          concurrency: this._settings.concurrency,
          deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
          entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
          errorFilter: this.errorFilter.getFilter(),
          followSymbolicLinks: this._settings.followSymbolicLinks,
          fs: this._settings.fs,
          stats: this._settings.stats,
          throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
          transform: this.entryTransformer.getTransformer()
        };
      }
      _getMicromatchOptions() {
        return {
          dot: this._settings.dot,
          matchBase: this._settings.baseNameMatch,
          nobrace: !this._settings.braceExpansion,
          nocase: !this._settings.caseSensitiveMatch,
          noext: !this._settings.extglob,
          noglobstar: !this._settings.globstar,
          posix: true,
          strictSlashes: false
        };
      }
    };
    exports2.default = Provider;
  }
});

// node_modules/fast-glob/out/providers/async.js
var require_async6 = __commonJS({
  "node_modules/fast-glob/out/providers/async.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var async_1 = require_async5();
    var provider_1 = require_provider();
    var ProviderAsync = class extends provider_1.default {
      constructor() {
        super(...arguments);
        this._reader = new async_1.default(this._settings);
      }
      async read(task) {
        const root2 = this._getRootDirectory(task);
        const options = this._getReaderOptions(task);
        const entries = await this.api(root2, task, options);
        return entries.map((entry) => options.transform(entry));
      }
      api(root2, task, options) {
        if (task.dynamic) {
          return this._reader.dynamic(root2, options);
        }
        return this._reader.static(task.patterns, options);
      }
    };
    exports2.default = ProviderAsync;
  }
});

// node_modules/fast-glob/out/providers/stream.js
var require_stream6 = __commonJS({
  "node_modules/fast-glob/out/providers/stream.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var stream_1 = require("stream");
    var stream_2 = require_stream5();
    var provider_1 = require_provider();
    var ProviderStream = class extends provider_1.default {
      constructor() {
        super(...arguments);
        this._reader = new stream_2.default(this._settings);
      }
      read(task) {
        const root2 = this._getRootDirectory(task);
        const options = this._getReaderOptions(task);
        const source = this.api(root2, task, options);
        const destination = new stream_1.Readable({ objectMode: true, read: () => {
        } });
        source.once("error", (error73) => destination.emit("error", error73)).on("data", (entry) => destination.emit("data", options.transform(entry))).once("end", () => destination.emit("end"));
        destination.once("close", () => source.destroy());
        return destination;
      }
      api(root2, task, options) {
        if (task.dynamic) {
          return this._reader.dynamic(root2, options);
        }
        return this._reader.static(task.patterns, options);
      }
    };
    exports2.default = ProviderStream;
  }
});

// node_modules/fast-glob/out/readers/sync.js
var require_sync5 = __commonJS({
  "node_modules/fast-glob/out/readers/sync.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var fsStat = require_out();
    var fsWalk = require_out3();
    var reader_1 = require_reader2();
    var ReaderSync = class extends reader_1.default {
      constructor() {
        super(...arguments);
        this._walkSync = fsWalk.walkSync;
        this._statSync = fsStat.statSync;
      }
      dynamic(root2, options) {
        return this._walkSync(root2, options);
      }
      static(patterns, options) {
        const entries = [];
        for (const pattern of patterns) {
          const filepath = this._getFullEntryPath(pattern);
          const entry = this._getEntry(filepath, pattern, options);
          if (entry === null || !options.entryFilter(entry)) {
            continue;
          }
          entries.push(entry);
        }
        return entries;
      }
      _getEntry(filepath, pattern, options) {
        try {
          const stats = this._getStat(filepath);
          return this._makeEntry(stats, pattern);
        } catch (error73) {
          if (options.errorFilter(error73)) {
            return null;
          }
          throw error73;
        }
      }
      _getStat(filepath) {
        return this._statSync(filepath, this._fsStatSettings);
      }
    };
    exports2.default = ReaderSync;
  }
});

// node_modules/fast-glob/out/providers/sync.js
var require_sync6 = __commonJS({
  "node_modules/fast-glob/out/providers/sync.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var sync_1 = require_sync5();
    var provider_1 = require_provider();
    var ProviderSync = class extends provider_1.default {
      constructor() {
        super(...arguments);
        this._reader = new sync_1.default(this._settings);
      }
      read(task) {
        const root2 = this._getRootDirectory(task);
        const options = this._getReaderOptions(task);
        const entries = this.api(root2, task, options);
        return entries.map(options.transform);
      }
      api(root2, task, options) {
        if (task.dynamic) {
          return this._reader.dynamic(root2, options);
        }
        return this._reader.static(task.patterns, options);
      }
    };
    exports2.default = ProviderSync;
  }
});

// node_modules/fast-glob/out/settings.js
var require_settings4 = __commonJS({
  "node_modules/fast-glob/out/settings.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
    var fs34 = require("fs");
    var os = require("os");
    var CPU_COUNT = Math.max(os.cpus().length, 1);
    exports2.DEFAULT_FILE_SYSTEM_ADAPTER = {
      lstat: fs34.lstat,
      lstatSync: fs34.lstatSync,
      stat: fs34.stat,
      statSync: fs34.statSync,
      readdir: fs34.readdir,
      readdirSync: fs34.readdirSync
    };
    var Settings = class {
      constructor(_options = {}) {
        this._options = _options;
        this.absolute = this._getValue(this._options.absolute, false);
        this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
        this.braceExpansion = this._getValue(this._options.braceExpansion, true);
        this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
        this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
        this.cwd = this._getValue(this._options.cwd, process.cwd());
        this.deep = this._getValue(this._options.deep, Infinity);
        this.dot = this._getValue(this._options.dot, false);
        this.extglob = this._getValue(this._options.extglob, true);
        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
        this.fs = this._getFileSystemMethods(this._options.fs);
        this.globstar = this._getValue(this._options.globstar, true);
        this.ignore = this._getValue(this._options.ignore, []);
        this.markDirectories = this._getValue(this._options.markDirectories, false);
        this.objectMode = this._getValue(this._options.objectMode, false);
        this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
        this.onlyFiles = this._getValue(this._options.onlyFiles, true);
        this.stats = this._getValue(this._options.stats, false);
        this.suppressErrors = this._getValue(this._options.suppressErrors, false);
        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
        this.unique = this._getValue(this._options.unique, true);
        if (this.onlyDirectories) {
          this.onlyFiles = false;
        }
        if (this.stats) {
          this.objectMode = true;
        }
        this.ignore = [].concat(this.ignore);
      }
      _getValue(option, value) {
        return option === void 0 ? value : option;
      }
      _getFileSystemMethods(methods = {}) {
        return Object.assign(Object.assign({}, exports2.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
      }
    };
    exports2.default = Settings;
  }
});

// node_modules/fast-glob/out/index.js
var require_out4 = __commonJS({
  "node_modules/fast-glob/out/index.js"(exports2, module2) {
    "use strict";
    var taskManager = require_tasks();
    var async_1 = require_async6();
    var stream_1 = require_stream6();
    var sync_1 = require_sync6();
    var settings_1 = require_settings4();
    var utils = require_utils6();
    async function FastGlob(source, options) {
      assertPatternsInput(source);
      const works = getWorks(source, async_1.default, options);
      const result = await Promise.all(works);
      return utils.array.flatten(result);
    }
    (function(FastGlob2) {
      FastGlob2.glob = FastGlob2;
      FastGlob2.globSync = sync;
      FastGlob2.globStream = stream4;
      FastGlob2.async = FastGlob2;
      function sync(source, options) {
        assertPatternsInput(source);
        const works = getWorks(source, sync_1.default, options);
        return utils.array.flatten(works);
      }
      FastGlob2.sync = sync;
      function stream4(source, options) {
        assertPatternsInput(source);
        const works = getWorks(source, stream_1.default, options);
        return utils.stream.merge(works);
      }
      FastGlob2.stream = stream4;
      function generateTasks(source, options) {
        assertPatternsInput(source);
        const patterns = [].concat(source);
        const settings = new settings_1.default(options);
        return taskManager.generate(patterns, settings);
      }
      FastGlob2.generateTasks = generateTasks;
      function isDynamicPattern(source, options) {
        assertPatternsInput(source);
        const settings = new settings_1.default(options);
        return utils.pattern.isDynamicPattern(source, settings);
      }
      FastGlob2.isDynamicPattern = isDynamicPattern;
      function escapePath(source) {
        assertPatternsInput(source);
        return utils.path.escape(source);
      }
      FastGlob2.escapePath = escapePath;
      function convertPathToPattern(source) {
        assertPatternsInput(source);
        return utils.path.convertPathToPattern(source);
      }
      FastGlob2.convertPathToPattern = convertPathToPattern;
      let posix;
      (function(posix2) {
        function escapePath2(source) {
          assertPatternsInput(source);
          return utils.path.escapePosixPath(source);
        }
        posix2.escapePath = escapePath2;
        function convertPathToPattern2(source) {
          assertPatternsInput(source);
          return utils.path.convertPosixPathToPattern(source);
        }
        posix2.convertPathToPattern = convertPathToPattern2;
      })(posix = FastGlob2.posix || (FastGlob2.posix = {}));
      let win32;
      (function(win322) {
        function escapePath2(source) {
          assertPatternsInput(source);
          return utils.path.escapeWindowsPath(source);
        }
        win322.escapePath = escapePath2;
        function convertPathToPattern2(source) {
          assertPatternsInput(source);
          return utils.path.convertWindowsPathToPattern(source);
        }
        win322.convertPathToPattern = convertPathToPattern2;
      })(win32 = FastGlob2.win32 || (FastGlob2.win32 = {}));
    })(FastGlob || (FastGlob = {}));
    function getWorks(source, _Provider, options) {
      const patterns = [].concat(source);
      const settings = new settings_1.default(options);
      const tasks = taskManager.generate(patterns, settings);
      const provider = new _Provider(settings);
      return tasks.map(provider.read, provider);
    }
    function assertPatternsInput(input) {
      const source = [].concat(input);
      const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
      if (!isValidSource) {
        throw new TypeError("Patterns must be a string (non empty) or an array of strings");
      }
    }
    module2.exports = FastGlob;
  }
});

// node_modules/is-path-inside/index.js
function isPathInside(childPath, parentPath) {
  const relation = import_node_path.default.relative(parentPath, childPath);
  return Boolean(
    relation && relation !== ".." && !relation.startsWith(`..${import_node_path.default.sep}`) && relation !== import_node_path.default.resolve(childPath)
  );
}
var import_node_path;
var init_is_path_inside = __esm({
  "node_modules/is-path-inside/index.js"() {
    "use strict";
    import_node_path = __toESM(require("node:path"), 1);
  }
});

// src/utils/getPath.ts
function isEletron() {
  if (typeof process.versions?.electron !== "undefined") {
    const { app: app2 } = require("electron");
    return true;
  } else {
    return false;
  }
}
var import_path2, getPath_default;
var init_getPath = __esm({
  "src/utils/getPath.ts"() {
    "use strict";
    import_path2 = __toESM(require("path"));
    init_is_path_inside();
    getPath_default = (fileName) => {
      let basePath;
      if (typeof process.versions?.electron !== "undefined") {
        const { app: app2 } = require("electron");
        const userDataDir = app2.getPath("userData");
        basePath = import_path2.default.join(userDataDir, "data");
      } else {
        basePath = import_path2.default.join(process.cwd(), "data");
      }
      if (fileName) {
        let dbPath2;
        if (Array.isArray(fileName)) {
          dbPath2 = import_path2.default.resolve(basePath, ...fileName);
        } else {
          dbPath2 = import_path2.default.resolve(basePath, fileName);
        }
        if (!isPathInside(dbPath2, basePath) && dbPath2 !== basePath) {
          throw new Error("\u8DEF\u5F84\u9003\u9038\u9519\u8BEF\uFF0C\u8DEF\u5F84\u5FC5\u987B\u5728\u6570\u636E\u76EE\u5F55\u5185");
        }
        return dbPath2;
      }
      return basePath;
    };
  }
});

// node_modules/tarn/dist/TimeoutError.js
var require_TimeoutError = __commonJS({
  "node_modules/tarn/dist/TimeoutError.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var TimeoutError = class extends Error {
    };
    exports2.TimeoutError = TimeoutError;
  }
});

// node_modules/tarn/dist/PromiseInspection.js
var require_PromiseInspection = __commonJS({
  "node_modules/tarn/dist/PromiseInspection.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var PromiseInspection = class {
      constructor(args) {
        this._value = args.value;
        this._error = args.error;
      }
      value() {
        return this._value;
      }
      reason() {
        return this._error;
      }
      isRejected() {
        return !!this._error;
      }
      isFulfilled() {
        return !!this._value;
      }
    };
    exports2.PromiseInspection = PromiseInspection;
  }
});

// node_modules/tarn/dist/utils.js
var require_utils8 = __commonJS({
  "node_modules/tarn/dist/utils.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var PromiseInspection_1 = require_PromiseInspection();
    function defer() {
      let resolve3 = null;
      let reject = null;
      const promise3 = new Promise((resolver, rejecter) => {
        resolve3 = resolver;
        reject = rejecter;
      });
      return {
        promise: promise3,
        resolve: resolve3,
        reject
      };
    }
    exports2.defer = defer;
    function now2() {
      return Date.now();
    }
    exports2.now = now2;
    function duration4(t1, t2) {
      return Math.abs(t2 - t1);
    }
    exports2.duration = duration4;
    function checkOptionalTime(time4) {
      if (typeof time4 === "undefined") {
        return true;
      }
      return checkRequiredTime(time4);
    }
    exports2.checkOptionalTime = checkOptionalTime;
    function checkRequiredTime(time4) {
      return typeof time4 === "number" && time4 === Math.round(time4) && time4 > 0;
    }
    exports2.checkRequiredTime = checkRequiredTime;
    function delay2(millis) {
      return new Promise((resolve3) => setTimeout(resolve3, millis));
    }
    exports2.delay = delay2;
    function reflect(promise3) {
      return promise3.then((value) => {
        return new PromiseInspection_1.PromiseInspection({ value });
      }).catch((error73) => {
        return new PromiseInspection_1.PromiseInspection({ error: error73 });
      });
    }
    exports2.reflect = reflect;
    function tryPromise(cb) {
      try {
        const result = cb();
        return Promise.resolve(result);
      } catch (err) {
        return Promise.reject(err);
      }
    }
    exports2.tryPromise = tryPromise;
  }
});

// node_modules/tarn/dist/PendingOperation.js
var require_PendingOperation = __commonJS({
  "node_modules/tarn/dist/PendingOperation.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var TimeoutError_1 = require_TimeoutError();
    var utils_1 = require_utils8();
    var PendingOperation = class {
      constructor(timeoutMillis) {
        this.timeoutMillis = timeoutMillis;
        this.deferred = utils_1.defer();
        this.possibleTimeoutCause = null;
        this.isRejected = false;
        this.promise = timeout(this.deferred.promise, timeoutMillis).catch((err) => {
          if (err instanceof TimeoutError_1.TimeoutError) {
            if (this.possibleTimeoutCause) {
              err = new TimeoutError_1.TimeoutError(this.possibleTimeoutCause.message);
            } else {
              err = new TimeoutError_1.TimeoutError("operation timed out for an unknown reason");
            }
          }
          this.isRejected = true;
          return Promise.reject(err);
        });
      }
      abort() {
        this.reject(new Error("aborted"));
      }
      reject(err) {
        this.deferred.reject(err);
      }
      resolve(value) {
        this.deferred.resolve(value);
      }
    };
    exports2.PendingOperation = PendingOperation;
    function timeout(promise3, time4) {
      return new Promise((resolve3, reject) => {
        const timeoutHandle = setTimeout(() => reject(new TimeoutError_1.TimeoutError()), time4);
        promise3.then((result) => {
          clearTimeout(timeoutHandle);
          resolve3(result);
        }).catch((err) => {
          clearTimeout(timeoutHandle);
          reject(err);
        });
      });
    }
  }
});

// node_modules/tarn/dist/Resource.js
var require_Resource = __commonJS({
  "node_modules/tarn/dist/Resource.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var utils_1 = require_utils8();
    var Resource = class _Resource {
      constructor(resource) {
        this.resource = resource;
        this.resource = resource;
        this.timestamp = utils_1.now();
        this.deferred = utils_1.defer();
      }
      get promise() {
        return this.deferred.promise;
      }
      resolve() {
        this.deferred.resolve(void 0);
        return new _Resource(this.resource);
      }
    };
    exports2.Resource = Resource;
  }
});

// node_modules/tarn/dist/Pool.js
var require_Pool = __commonJS({
  "node_modules/tarn/dist/Pool.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var PendingOperation_1 = require_PendingOperation();
    var Resource_1 = require_Resource();
    var utils_1 = require_utils8();
    var events_1 = require("events");
    var timers_1 = require("timers");
    var Pool = class {
      constructor(opt) {
        this.destroyed = false;
        this.emitter = new events_1.EventEmitter();
        opt = opt || {};
        if (!opt.create) {
          throw new Error("Tarn: opt.create function most be provided");
        }
        if (!opt.destroy) {
          throw new Error("Tarn: opt.destroy function most be provided");
        }
        if (typeof opt.min !== "number" || opt.min < 0 || opt.min !== Math.round(opt.min)) {
          throw new Error("Tarn: opt.min must be an integer >= 0");
        }
        if (typeof opt.max !== "number" || opt.max <= 0 || opt.max !== Math.round(opt.max)) {
          throw new Error("Tarn: opt.max must be an integer > 0");
        }
        if (opt.min > opt.max) {
          throw new Error("Tarn: opt.max is smaller than opt.min");
        }
        if (!utils_1.checkOptionalTime(opt.acquireTimeoutMillis)) {
          throw new Error("Tarn: invalid opt.acquireTimeoutMillis " + JSON.stringify(opt.acquireTimeoutMillis));
        }
        if (!utils_1.checkOptionalTime(opt.createTimeoutMillis)) {
          throw new Error("Tarn: invalid opt.createTimeoutMillis " + JSON.stringify(opt.createTimeoutMillis));
        }
        if (!utils_1.checkOptionalTime(opt.destroyTimeoutMillis)) {
          throw new Error("Tarn: invalid opt.destroyTimeoutMillis " + JSON.stringify(opt.destroyTimeoutMillis));
        }
        if (!utils_1.checkOptionalTime(opt.idleTimeoutMillis)) {
          throw new Error("Tarn: invalid opt.idleTimeoutMillis " + JSON.stringify(opt.idleTimeoutMillis));
        }
        if (!utils_1.checkOptionalTime(opt.reapIntervalMillis)) {
          throw new Error("Tarn: invalid opt.reapIntervalMillis " + JSON.stringify(opt.reapIntervalMillis));
        }
        if (!utils_1.checkOptionalTime(opt.createRetryIntervalMillis)) {
          throw new Error("Tarn: invalid opt.createRetryIntervalMillis " + JSON.stringify(opt.createRetryIntervalMillis));
        }
        const allowedKeys = {
          create: true,
          validate: true,
          destroy: true,
          log: true,
          min: true,
          max: true,
          acquireTimeoutMillis: true,
          createTimeoutMillis: true,
          destroyTimeoutMillis: true,
          idleTimeoutMillis: true,
          reapIntervalMillis: true,
          createRetryIntervalMillis: true,
          propagateCreateError: true
        };
        for (const key of Object.keys(opt)) {
          if (!allowedKeys[key]) {
            throw new Error(`Tarn: unsupported option opt.${key}`);
          }
        }
        this.creator = opt.create;
        this.destroyer = opt.destroy;
        this.validate = typeof opt.validate === "function" ? opt.validate : () => true;
        this.log = opt.log || (() => {
        });
        this.acquireTimeoutMillis = opt.acquireTimeoutMillis || 3e4;
        this.createTimeoutMillis = opt.createTimeoutMillis || 3e4;
        this.destroyTimeoutMillis = opt.destroyTimeoutMillis || 5e3;
        this.idleTimeoutMillis = opt.idleTimeoutMillis || 3e4;
        this.reapIntervalMillis = opt.reapIntervalMillis || 1e3;
        this.createRetryIntervalMillis = opt.createRetryIntervalMillis || 200;
        this.propagateCreateError = !!opt.propagateCreateError;
        this.min = opt.min;
        this.max = opt.max;
        this.used = [];
        this.free = [];
        this.pendingCreates = [];
        this.pendingAcquires = [];
        this.pendingDestroys = [];
        this.pendingValidations = [];
        this.destroyed = false;
        this.interval = null;
        this.eventId = 1;
      }
      numUsed() {
        return this.used.length;
      }
      numFree() {
        return this.free.length;
      }
      numPendingAcquires() {
        return this.pendingAcquires.length;
      }
      numPendingValidations() {
        return this.pendingValidations.length;
      }
      numPendingCreates() {
        return this.pendingCreates.length;
      }
      acquire() {
        const eventId = this.eventId++;
        this._executeEventHandlers("acquireRequest", eventId);
        const pendingAcquire = new PendingOperation_1.PendingOperation(this.acquireTimeoutMillis);
        this.pendingAcquires.push(pendingAcquire);
        pendingAcquire.promise = pendingAcquire.promise.then((resource) => {
          this._executeEventHandlers("acquireSuccess", eventId, resource);
          return resource;
        }).catch((err) => {
          this._executeEventHandlers("acquireFail", eventId, err);
          remove(this.pendingAcquires, pendingAcquire);
          return Promise.reject(err);
        });
        this._tryAcquireOrCreate();
        return pendingAcquire;
      }
      release(resource) {
        this._executeEventHandlers("release", resource);
        for (let i = 0, l = this.used.length; i < l; ++i) {
          const used = this.used[i];
          if (used.resource === resource) {
            this.used.splice(i, 1);
            this.free.push(used.resolve());
            this._tryAcquireOrCreate();
            return true;
          }
        }
        return false;
      }
      isEmpty() {
        return [
          this.numFree(),
          this.numUsed(),
          this.numPendingAcquires(),
          this.numPendingValidations(),
          this.numPendingCreates()
        ].reduce((total, value) => total + value) === 0;
      }
      /**
       * Reaping cycle.
       */
      check() {
        const timestamp = utils_1.now();
        const newFree = [];
        const minKeep = this.min - this.used.length;
        const maxDestroy = this.free.length - minKeep;
        let numDestroyed = 0;
        this.free.forEach((free) => {
          if (utils_1.duration(timestamp, free.timestamp) >= this.idleTimeoutMillis && numDestroyed < maxDestroy) {
            numDestroyed++;
            this._destroy(free.resource);
          } else {
            newFree.push(free);
          }
        });
        this.free = newFree;
        if (this.isEmpty()) {
          this._stopReaping();
        }
      }
      destroy() {
        const eventId = this.eventId++;
        this._executeEventHandlers("poolDestroyRequest", eventId);
        this._stopReaping();
        this.destroyed = true;
        return utils_1.reflect(Promise.all(this.pendingCreates.map((create) => utils_1.reflect(create.promise))).then(() => {
          return new Promise((resolve3, reject) => {
            if (this.numPendingValidations() === 0) {
              resolve3();
              return;
            }
            const interval = setInterval(() => {
              if (this.numPendingValidations() === 0) {
                timers_1.clearInterval(interval);
                resolve3();
              }
            }, 100);
          });
        }).then(() => {
          return Promise.all(this.used.map((used) => utils_1.reflect(used.promise)));
        }).then(() => {
          return Promise.all(this.pendingAcquires.map((acquire) => {
            acquire.abort();
            return utils_1.reflect(acquire.promise);
          }));
        }).then(() => {
          return Promise.all(this.free.map((free) => utils_1.reflect(this._destroy(free.resource))));
        }).then(() => {
          return Promise.all(this.pendingDestroys.map((pd) => pd.promise));
        }).then(() => {
          this.free = [];
          this.pendingAcquires = [];
        })).then((res) => {
          this._executeEventHandlers("poolDestroySuccess", eventId);
          this.emitter.removeAllListeners();
          return res;
        });
      }
      on(event, listener) {
        this.emitter.on(event, listener);
      }
      removeListener(event, listener) {
        this.emitter.removeListener(event, listener);
      }
      removeAllListeners(event) {
        this.emitter.removeAllListeners(event);
      }
      /**
       * The most important method that is called always when resources
       * are created / destroyed / acquired / released. In other words
       * every time when resources are moved from used to free or vice
       * versa.
       *
       * Either assigns free resources to pendingAcquires or creates new
       * resources if there is room for it in the pool.
       */
      _tryAcquireOrCreate() {
        if (this.destroyed) {
          return;
        }
        if (this._hasFreeResources()) {
          this._doAcquire();
        } else if (this._shouldCreateMoreResources()) {
          this._doCreate();
        }
      }
      _hasFreeResources() {
        return this.free.length > 0;
      }
      _doAcquire() {
        while (this._canAcquire()) {
          const pendingAcquire = this.pendingAcquires.shift();
          const free = this.free.pop();
          if (free === void 0 || pendingAcquire === void 0) {
            const errMessage = "this.free was empty while trying to acquire resource";
            this.log(`Tarn: ${errMessage}`, "warn");
            throw new Error(`Internal error, should never happen. ${errMessage}`);
          }
          this.pendingValidations.push(pendingAcquire);
          this.used.push(free);
          const abortAbleValidation = new PendingOperation_1.PendingOperation(this.acquireTimeoutMillis);
          pendingAcquire.promise.catch((err) => {
            abortAbleValidation.abort();
          });
          abortAbleValidation.promise.catch((err) => {
            this.log("Tarn: resource validator threw an exception " + err.stack, "warn");
            return false;
          }).then((validationSuccess) => {
            try {
              if (validationSuccess && !pendingAcquire.isRejected) {
                this._startReaping();
                pendingAcquire.resolve(free.resource);
              } else {
                remove(this.used, free);
                if (!validationSuccess) {
                  this._destroy(free.resource);
                  setTimeout(() => {
                    this._tryAcquireOrCreate();
                  }, 0);
                } else {
                  this.free.push(free);
                }
                if (!pendingAcquire.isRejected) {
                  this.pendingAcquires.unshift(pendingAcquire);
                }
              }
            } finally {
              remove(this.pendingValidations, pendingAcquire);
            }
          });
          this._validateResource(free.resource).then((validationSuccess) => {
            abortAbleValidation.resolve(validationSuccess);
          }).catch((err) => {
            abortAbleValidation.reject(err);
          });
        }
      }
      _canAcquire() {
        return this.free.length > 0 && this.pendingAcquires.length > 0;
      }
      _validateResource(resource) {
        try {
          return Promise.resolve(this.validate(resource));
        } catch (err) {
          return Promise.reject(err);
        }
      }
      _shouldCreateMoreResources() {
        return this.used.length + this.pendingCreates.length < this.max && this.pendingCreates.length < this.pendingAcquires.length;
      }
      _doCreate() {
        const pendingAcquiresBeforeCreate = this.pendingAcquires.slice();
        const pendingCreate = this._create();
        pendingCreate.promise.then(() => {
          this._tryAcquireOrCreate();
          return null;
        }).catch((err) => {
          if (this.propagateCreateError && this.pendingAcquires.length !== 0) {
            this.pendingAcquires[0].reject(err);
          }
          pendingAcquiresBeforeCreate.forEach((pendingAcquire) => {
            pendingAcquire.possibleTimeoutCause = err;
          });
          utils_1.delay(this.createRetryIntervalMillis).then(() => this._tryAcquireOrCreate());
        });
      }
      _create() {
        const eventId = this.eventId++;
        this._executeEventHandlers("createRequest", eventId);
        const pendingCreate = new PendingOperation_1.PendingOperation(this.createTimeoutMillis);
        pendingCreate.promise = pendingCreate.promise.catch((err) => {
          if (remove(this.pendingCreates, pendingCreate)) {
            this._executeEventHandlers("createFail", eventId, err);
          }
          throw err;
        });
        this.pendingCreates.push(pendingCreate);
        callbackOrPromise(this.creator).then((resource) => {
          if (pendingCreate.isRejected) {
            this.destroyer(resource);
            return null;
          }
          remove(this.pendingCreates, pendingCreate);
          this.free.push(new Resource_1.Resource(resource));
          pendingCreate.resolve(resource);
          this._executeEventHandlers("createSuccess", eventId, resource);
          return null;
        }).catch((err) => {
          if (pendingCreate.isRejected) {
            return null;
          }
          if (remove(this.pendingCreates, pendingCreate)) {
            this._executeEventHandlers("createFail", eventId, err);
          }
          pendingCreate.reject(err);
          return null;
        });
        return pendingCreate;
      }
      _destroy(resource) {
        const eventId = this.eventId++;
        this._executeEventHandlers("destroyRequest", eventId, resource);
        const pendingDestroy = new PendingOperation_1.PendingOperation(this.destroyTimeoutMillis);
        const retVal = Promise.resolve().then(() => this.destroyer(resource));
        retVal.then(() => {
          pendingDestroy.resolve(resource);
        }).catch((err) => {
          pendingDestroy.reject(err);
        });
        this.pendingDestroys.push(pendingDestroy);
        return pendingDestroy.promise.then((res) => {
          this._executeEventHandlers("destroySuccess", eventId, resource);
          return res;
        }).catch((err) => this._logDestroyerError(eventId, resource, err)).then((res) => {
          const index = this.pendingDestroys.findIndex((pd) => pd === pendingDestroy);
          this.pendingDestroys.splice(index, 1);
          return res;
        });
      }
      _logDestroyerError(eventId, resource, err) {
        this._executeEventHandlers("destroyFail", eventId, resource, err);
        this.log("Tarn: resource destroyer threw an exception " + err.stack, "warn");
      }
      _startReaping() {
        if (!this.interval) {
          this._executeEventHandlers("startReaping");
          this.interval = setInterval(() => this.check(), this.reapIntervalMillis);
        }
      }
      _stopReaping() {
        if (this.interval !== null) {
          this._executeEventHandlers("stopReaping");
          timers_1.clearInterval(this.interval);
        }
        this.interval = null;
      }
      _executeEventHandlers(eventName, ...args) {
        const listeners = this.emitter.listeners(eventName);
        listeners.forEach((listener) => {
          try {
            listener(...args);
          } catch (err) {
            this.log(`Tarn: event handler "${eventName}" threw an exception ${err.stack}`, "warn");
          }
        });
      }
    };
    exports2.Pool = Pool;
    function remove(arr, item) {
      const idx = arr.indexOf(item);
      if (idx === -1) {
        return false;
      } else {
        arr.splice(idx, 1);
        return true;
      }
    }
    function callbackOrPromise(func) {
      return new Promise((resolve3, reject) => {
        const callback = (err, resource) => {
          if (err) {
            reject(err);
          } else {
            resolve3(resource);
          }
        };
        utils_1.tryPromise(() => func(callback)).then((res) => {
          if (res) {
            resolve3(res);
          }
        }).catch((err) => {
          reject(err);
        });
      });
    }
  }
});

// node_modules/tarn/dist/tarn.js
var require_tarn = __commonJS({
  "node_modules/tarn/dist/tarn.js"(exports2, module2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var Pool_1 = require_Pool();
    exports2.Pool = Pool_1.Pool;
    var TimeoutError_1 = require_TimeoutError();
    exports2.TimeoutError = TimeoutError_1.TimeoutError;
    module2.exports = {
      Pool: Pool_1.Pool,
      TimeoutError: TimeoutError_1.TimeoutError
    };
  }
});

// node_modules/knex/lib/util/string.js
var require_string2 = __commonJS({
  "node_modules/knex/lib/util/string.js"(exports2, module2) {
    "use strict";
    var charsRegex = /[\0\b\t\n\r\x1a"'\\]/g;
    var charsMap = {
      "\0": "\\0",
      "\b": "\\b",
      "	": "\\t",
      "\n": "\\n",
      "\r": "\\r",
      "": "\\Z",
      '"': '\\"',
      "'": "\\'",
      "\\": "\\\\"
    };
    function wrapEscape(escapeFn) {
      return function finalEscape(val, ctx = {}) {
        return escapeFn(val, finalEscape, ctx);
      };
    }
    function makeEscape(config3 = {}) {
      const finalEscapeDate = config3.escapeDate || dateToString;
      const finalEscapeArray = config3.escapeArray || arrayToList;
      const finalEscapeBuffer = config3.escapeBuffer || bufferToString;
      const finalEscapeString = config3.escapeString || escapeString;
      const finalEscapeObject = config3.escapeObject || escapeObject;
      const finalWrap = config3.wrap || wrapEscape;
      function escapeFn(val, finalEscape, ctx) {
        if (val === void 0 || val === null) {
          return "NULL";
        }
        switch (typeof val) {
          case "boolean":
            return val ? "true" : "false";
          case "number":
            return val + "";
          case "object":
            if (val instanceof Date) {
              val = finalEscapeDate(val, finalEscape, ctx);
            } else if (Array.isArray(val)) {
              return finalEscapeArray(val, finalEscape, ctx);
            } else if (Buffer.isBuffer(val)) {
              return finalEscapeBuffer(val, finalEscape, ctx);
            } else {
              return finalEscapeObject(val, finalEscape, ctx);
            }
        }
        return finalEscapeString(val, finalEscape, ctx);
      }
      return finalWrap ? finalWrap(escapeFn) : escapeFn;
    }
    function escapeObject(val, finalEscape, ctx) {
      if (val && typeof val.toSQL === "function") {
        return val.toSQL(ctx);
      } else {
        return JSON.stringify(val);
      }
    }
    function arrayToList(array4, finalEscape, ctx) {
      let sql = "";
      for (let i = 0; i < array4.length; i++) {
        const val = array4[i];
        if (Array.isArray(val)) {
          sql += (i === 0 ? "" : ", ") + "(" + arrayToList(val, finalEscape, ctx) + ")";
        } else {
          sql += (i === 0 ? "" : ", ") + finalEscape(val, ctx);
        }
      }
      return sql;
    }
    function bufferToString(buffer) {
      return "X" + escapeString(buffer.toString("hex"));
    }
    function escapeString(val, finalEscape, ctx) {
      let chunkIndex = charsRegex.lastIndex = 0;
      let escapedVal = "";
      let match;
      while (match = charsRegex.exec(val)) {
        escapedVal += val.slice(chunkIndex, match.index) + charsMap[match[0]];
        chunkIndex = charsRegex.lastIndex;
      }
      if (chunkIndex === 0) {
        return "'" + val + "'";
      }
      if (chunkIndex < val.length) {
        return "'" + escapedVal + val.slice(chunkIndex) + "'";
      }
      return "'" + escapedVal + "'";
    }
    function dateToString(date6, finalEscape, ctx = {}) {
      const timeZone = ctx.timeZone || "local";
      const dt = new Date(date6);
      let year;
      let month;
      let day;
      let hour;
      let minute;
      let second;
      let millisecond;
      if (timeZone === "local") {
        year = dt.getFullYear();
        month = dt.getMonth() + 1;
        day = dt.getDate();
        hour = dt.getHours();
        minute = dt.getMinutes();
        second = dt.getSeconds();
        millisecond = dt.getMilliseconds();
      } else {
        const tz = convertTimezone(timeZone);
        if (tz !== false && tz !== 0) {
          dt.setTime(dt.getTime() + tz * 6e4);
        }
        year = dt.getUTCFullYear();
        month = dt.getUTCMonth() + 1;
        day = dt.getUTCDate();
        hour = dt.getUTCHours();
        minute = dt.getUTCMinutes();
        second = dt.getUTCSeconds();
        millisecond = dt.getUTCMilliseconds();
      }
      return zeroPad(year, 4) + "-" + zeroPad(month, 2) + "-" + zeroPad(day, 2) + " " + zeroPad(hour, 2) + ":" + zeroPad(minute, 2) + ":" + zeroPad(second, 2) + "." + zeroPad(millisecond, 3);
    }
    function zeroPad(number5, length) {
      number5 = number5.toString();
      while (number5.length < length) {
        number5 = "0" + number5;
      }
      return number5;
    }
    function convertTimezone(tz) {
      if (tz === "Z") {
        return 0;
      }
      const m = tz.match(/([+\-\s])(\d\d):?(\d\d)?/);
      if (m) {
        return (m[1] == "-" ? -1 : 1) * (parseInt(m[2], 10) + (m[3] ? parseInt(m[3], 10) : 0) / 60) * 60;
      }
      return false;
    }
    module2.exports = {
      arrayToList,
      bufferToString,
      dateToString,
      escapeString,
      charsRegex,
      charsMap,
      escapeObject,
      makeEscape
    };
  }
});

// node_modules/lodash/_listCacheClear.js
var require_listCacheClear = __commonJS({
  "node_modules/lodash/_listCacheClear.js"(exports2, module2) {
    "use strict";
    function listCacheClear2() {
      this.__data__ = [];
      this.size = 0;
    }
    module2.exports = listCacheClear2;
  }
});

// node_modules/lodash/eq.js
var require_eq = __commonJS({
  "node_modules/lodash/eq.js"(exports2, module2) {
    "use strict";
    function eq2(value, other) {
      return value === other || value !== value && other !== other;
    }
    module2.exports = eq2;
  }
});

// node_modules/lodash/_assocIndexOf.js
var require_assocIndexOf = __commonJS({
  "node_modules/lodash/_assocIndexOf.js"(exports2, module2) {
    "use strict";
    var eq2 = require_eq();
    function assocIndexOf2(array4, key) {
      var length = array4.length;
      while (length--) {
        if (eq2(array4[length][0], key)) {
          return length;
        }
      }
      return -1;
    }
    module2.exports = assocIndexOf2;
  }
});

// node_modules/lodash/_listCacheDelete.js
var require_listCacheDelete = __commonJS({
  "node_modules/lodash/_listCacheDelete.js"(exports2, module2) {
    "use strict";
    var assocIndexOf2 = require_assocIndexOf();
    var arrayProto2 = Array.prototype;
    var splice2 = arrayProto2.splice;
    function listCacheDelete2(key) {
      var data = this.__data__, index = assocIndexOf2(data, key);
      if (index < 0) {
        return false;
      }
      var lastIndex = data.length - 1;
      if (index == lastIndex) {
        data.pop();
      } else {
        splice2.call(data, index, 1);
      }
      --this.size;
      return true;
    }
    module2.exports = listCacheDelete2;
  }
});

// node_modules/lodash/_listCacheGet.js
var require_listCacheGet = __commonJS({
  "node_modules/lodash/_listCacheGet.js"(exports2, module2) {
    "use strict";
    var assocIndexOf2 = require_assocIndexOf();
    function listCacheGet2(key) {
      var data = this.__data__, index = assocIndexOf2(data, key);
      return index < 0 ? void 0 : data[index][1];
    }
    module2.exports = listCacheGet2;
  }
});

// node_modules/lodash/_listCacheHas.js
var require_listCacheHas = __commonJS({
  "node_modules/lodash/_listCacheHas.js"(exports2, module2) {
    "use strict";
    var assocIndexOf2 = require_assocIndexOf();
    function listCacheHas2(key) {
      return assocIndexOf2(this.__data__, key) > -1;
    }
    module2.exports = listCacheHas2;
  }
});

// node_modules/lodash/_listCacheSet.js
var require_listCacheSet = __commonJS({
  "node_modules/lodash/_listCacheSet.js"(exports2, module2) {
    "use strict";
    var assocIndexOf2 = require_assocIndexOf();
    function listCacheSet2(key, value) {
      var data = this.__data__, index = assocIndexOf2(data, key);
      if (index < 0) {
        ++this.size;
        data.push([key, value]);
      } else {
        data[index][1] = value;
      }
      return this;
    }
    module2.exports = listCacheSet2;
  }
});

// node_modules/lodash/_ListCache.js
var require_ListCache = __commonJS({
  "node_modules/lodash/_ListCache.js"(exports2, module2) {
    "use strict";
    var listCacheClear2 = require_listCacheClear();
    var listCacheDelete2 = require_listCacheDelete();
    var listCacheGet2 = require_listCacheGet();
    var listCacheHas2 = require_listCacheHas();
    var listCacheSet2 = require_listCacheSet();
    function ListCache2(entries) {
      var index = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    ListCache2.prototype.clear = listCacheClear2;
    ListCache2.prototype["delete"] = listCacheDelete2;
    ListCache2.prototype.get = listCacheGet2;
    ListCache2.prototype.has = listCacheHas2;
    ListCache2.prototype.set = listCacheSet2;
    module2.exports = ListCache2;
  }
});

// node_modules/lodash/_stackClear.js
var require_stackClear = __commonJS({
  "node_modules/lodash/_stackClear.js"(exports2, module2) {
    "use strict";
    var ListCache2 = require_ListCache();
    function stackClear2() {
      this.__data__ = new ListCache2();
      this.size = 0;
    }
    module2.exports = stackClear2;
  }
});

// node_modules/lodash/_stackDelete.js
var require_stackDelete = __commonJS({
  "node_modules/lodash/_stackDelete.js"(exports2, module2) {
    "use strict";
    function stackDelete2(key) {
      var data = this.__data__, result = data["delete"](key);
      this.size = data.size;
      return result;
    }
    module2.exports = stackDelete2;
  }
});

// node_modules/lodash/_stackGet.js
var require_stackGet = __commonJS({
  "node_modules/lodash/_stackGet.js"(exports2, module2) {
    "use strict";
    function stackGet2(key) {
      return this.__data__.get(key);
    }
    module2.exports = stackGet2;
  }
});

// node_modules/lodash/_stackHas.js
var require_stackHas = __commonJS({
  "node_modules/lodash/_stackHas.js"(exports2, module2) {
    "use strict";
    function stackHas2(key) {
      return this.__data__.has(key);
    }
    module2.exports = stackHas2;
  }
});

// node_modules/lodash/_freeGlobal.js
var require_freeGlobal = __commonJS({
  "node_modules/lodash/_freeGlobal.js"(exports2, module2) {
    "use strict";
    var freeGlobal2 = typeof global == "object" && global && global.Object === Object && global;
    module2.exports = freeGlobal2;
  }
});

// node_modules/lodash/_root.js
var require_root = __commonJS({
  "node_modules/lodash/_root.js"(exports2, module2) {
    "use strict";
    var freeGlobal2 = require_freeGlobal();
    var freeSelf2 = typeof self == "object" && self && self.Object === Object && self;
    var root2 = freeGlobal2 || freeSelf2 || Function("return this")();
    module2.exports = root2;
  }
});

// node_modules/lodash/_Symbol.js
var require_Symbol = __commonJS({
  "node_modules/lodash/_Symbol.js"(exports2, module2) {
    "use strict";
    var root2 = require_root();
    var Symbol3 = root2.Symbol;
    module2.exports = Symbol3;
  }
});

// node_modules/lodash/_getRawTag.js
var require_getRawTag = __commonJS({
  "node_modules/lodash/_getRawTag.js"(exports2, module2) {
    "use strict";
    var Symbol3 = require_Symbol();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    var nativeObjectToString3 = objectProto13.toString;
    var symToStringTag3 = Symbol3 ? Symbol3.toStringTag : void 0;
    function getRawTag2(value) {
      var isOwn = hasOwnProperty11.call(value, symToStringTag3), tag = value[symToStringTag3];
      try {
        value[symToStringTag3] = void 0;
        var unmasked = true;
      } catch (e) {
      }
      var result = nativeObjectToString3.call(value);
      if (unmasked) {
        if (isOwn) {
          value[symToStringTag3] = tag;
        } else {
          delete value[symToStringTag3];
        }
      }
      return result;
    }
    module2.exports = getRawTag2;
  }
});

// node_modules/lodash/_objectToString.js
var require_objectToString = __commonJS({
  "node_modules/lodash/_objectToString.js"(exports2, module2) {
    "use strict";
    var objectProto13 = Object.prototype;
    var nativeObjectToString3 = objectProto13.toString;
    function objectToString2(value) {
      return nativeObjectToString3.call(value);
    }
    module2.exports = objectToString2;
  }
});

// node_modules/lodash/_baseGetTag.js
var require_baseGetTag = __commonJS({
  "node_modules/lodash/_baseGetTag.js"(exports2, module2) {
    "use strict";
    var Symbol3 = require_Symbol();
    var getRawTag2 = require_getRawTag();
    var objectToString2 = require_objectToString();
    var nullTag2 = "[object Null]";
    var undefinedTag2 = "[object Undefined]";
    var symToStringTag3 = Symbol3 ? Symbol3.toStringTag : void 0;
    function baseGetTag2(value) {
      if (value == null) {
        return value === void 0 ? undefinedTag2 : nullTag2;
      }
      return symToStringTag3 && symToStringTag3 in Object(value) ? getRawTag2(value) : objectToString2(value);
    }
    module2.exports = baseGetTag2;
  }
});

// node_modules/lodash/isObject.js
var require_isObject = __commonJS({
  "node_modules/lodash/isObject.js"(exports2, module2) {
    "use strict";
    function isObject5(value) {
      var type = typeof value;
      return value != null && (type == "object" || type == "function");
    }
    module2.exports = isObject5;
  }
});

// node_modules/lodash/isFunction.js
var require_isFunction = __commonJS({
  "node_modules/lodash/isFunction.js"(exports2, module2) {
    "use strict";
    var baseGetTag2 = require_baseGetTag();
    var isObject5 = require_isObject();
    var asyncTag2 = "[object AsyncFunction]";
    var funcTag3 = "[object Function]";
    var genTag2 = "[object GeneratorFunction]";
    var proxyTag2 = "[object Proxy]";
    function isFunction4(value) {
      if (!isObject5(value)) {
        return false;
      }
      var tag = baseGetTag2(value);
      return tag == funcTag3 || tag == genTag2 || tag == asyncTag2 || tag == proxyTag2;
    }
    module2.exports = isFunction4;
  }
});

// node_modules/lodash/_coreJsData.js
var require_coreJsData = __commonJS({
  "node_modules/lodash/_coreJsData.js"(exports2, module2) {
    "use strict";
    var root2 = require_root();
    var coreJsData2 = root2["__core-js_shared__"];
    module2.exports = coreJsData2;
  }
});

// node_modules/lodash/_isMasked.js
var require_isMasked = __commonJS({
  "node_modules/lodash/_isMasked.js"(exports2, module2) {
    "use strict";
    var coreJsData2 = require_coreJsData();
    var maskSrcKey2 = (function() {
      var uid = /[^.]+$/.exec(coreJsData2 && coreJsData2.keys && coreJsData2.keys.IE_PROTO || "");
      return uid ? "Symbol(src)_1." + uid : "";
    })();
    function isMasked2(func) {
      return !!maskSrcKey2 && maskSrcKey2 in func;
    }
    module2.exports = isMasked2;
  }
});

// node_modules/lodash/_toSource.js
var require_toSource = __commonJS({
  "node_modules/lodash/_toSource.js"(exports2, module2) {
    "use strict";
    var funcProto3 = Function.prototype;
    var funcToString3 = funcProto3.toString;
    function toSource2(func) {
      if (func != null) {
        try {
          return funcToString3.call(func);
        } catch (e) {
        }
        try {
          return func + "";
        } catch (e) {
        }
      }
      return "";
    }
    module2.exports = toSource2;
  }
});

// node_modules/lodash/_baseIsNative.js
var require_baseIsNative = __commonJS({
  "node_modules/lodash/_baseIsNative.js"(exports2, module2) {
    "use strict";
    var isFunction4 = require_isFunction();
    var isMasked2 = require_isMasked();
    var isObject5 = require_isObject();
    var toSource2 = require_toSource();
    var reRegExpChar2 = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor2 = /^\[object .+?Constructor\]$/;
    var funcProto3 = Function.prototype;
    var objectProto13 = Object.prototype;
    var funcToString3 = funcProto3.toString;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    var reIsNative2 = RegExp(
      "^" + funcToString3.call(hasOwnProperty11).replace(reRegExpChar2, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
    );
    function baseIsNative2(value) {
      if (!isObject5(value) || isMasked2(value)) {
        return false;
      }
      var pattern = isFunction4(value) ? reIsNative2 : reIsHostCtor2;
      return pattern.test(toSource2(value));
    }
    module2.exports = baseIsNative2;
  }
});

// node_modules/lodash/_getValue.js
var require_getValue = __commonJS({
  "node_modules/lodash/_getValue.js"(exports2, module2) {
    "use strict";
    function getValue2(object4, key) {
      return object4 == null ? void 0 : object4[key];
    }
    module2.exports = getValue2;
  }
});

// node_modules/lodash/_getNative.js
var require_getNative = __commonJS({
  "node_modules/lodash/_getNative.js"(exports2, module2) {
    "use strict";
    var baseIsNative2 = require_baseIsNative();
    var getValue2 = require_getValue();
    function getNative2(object4, key) {
      var value = getValue2(object4, key);
      return baseIsNative2(value) ? value : void 0;
    }
    module2.exports = getNative2;
  }
});

// node_modules/lodash/_Map.js
var require_Map = __commonJS({
  "node_modules/lodash/_Map.js"(exports2, module2) {
    "use strict";
    var getNative2 = require_getNative();
    var root2 = require_root();
    var Map3 = getNative2(root2, "Map");
    module2.exports = Map3;
  }
});

// node_modules/lodash/_nativeCreate.js
var require_nativeCreate = __commonJS({
  "node_modules/lodash/_nativeCreate.js"(exports2, module2) {
    "use strict";
    var getNative2 = require_getNative();
    var nativeCreate2 = getNative2(Object, "create");
    module2.exports = nativeCreate2;
  }
});

// node_modules/lodash/_hashClear.js
var require_hashClear = __commonJS({
  "node_modules/lodash/_hashClear.js"(exports2, module2) {
    "use strict";
    var nativeCreate2 = require_nativeCreate();
    function hashClear2() {
      this.__data__ = nativeCreate2 ? nativeCreate2(null) : {};
      this.size = 0;
    }
    module2.exports = hashClear2;
  }
});

// node_modules/lodash/_hashDelete.js
var require_hashDelete = __commonJS({
  "node_modules/lodash/_hashDelete.js"(exports2, module2) {
    "use strict";
    function hashDelete2(key) {
      var result = this.has(key) && delete this.__data__[key];
      this.size -= result ? 1 : 0;
      return result;
    }
    module2.exports = hashDelete2;
  }
});

// node_modules/lodash/_hashGet.js
var require_hashGet = __commonJS({
  "node_modules/lodash/_hashGet.js"(exports2, module2) {
    "use strict";
    var nativeCreate2 = require_nativeCreate();
    var HASH_UNDEFINED4 = "__lodash_hash_undefined__";
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function hashGet2(key) {
      var data = this.__data__;
      if (nativeCreate2) {
        var result = data[key];
        return result === HASH_UNDEFINED4 ? void 0 : result;
      }
      return hasOwnProperty11.call(data, key) ? data[key] : void 0;
    }
    module2.exports = hashGet2;
  }
});

// node_modules/lodash/_hashHas.js
var require_hashHas = __commonJS({
  "node_modules/lodash/_hashHas.js"(exports2, module2) {
    "use strict";
    var nativeCreate2 = require_nativeCreate();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function hashHas2(key) {
      var data = this.__data__;
      return nativeCreate2 ? data[key] !== void 0 : hasOwnProperty11.call(data, key);
    }
    module2.exports = hashHas2;
  }
});

// node_modules/lodash/_hashSet.js
var require_hashSet = __commonJS({
  "node_modules/lodash/_hashSet.js"(exports2, module2) {
    "use strict";
    var nativeCreate2 = require_nativeCreate();
    var HASH_UNDEFINED4 = "__lodash_hash_undefined__";
    function hashSet2(key, value) {
      var data = this.__data__;
      this.size += this.has(key) ? 0 : 1;
      data[key] = nativeCreate2 && value === void 0 ? HASH_UNDEFINED4 : value;
      return this;
    }
    module2.exports = hashSet2;
  }
});

// node_modules/lodash/_Hash.js
var require_Hash = __commonJS({
  "node_modules/lodash/_Hash.js"(exports2, module2) {
    "use strict";
    var hashClear2 = require_hashClear();
    var hashDelete2 = require_hashDelete();
    var hashGet2 = require_hashGet();
    var hashHas2 = require_hashHas();
    var hashSet2 = require_hashSet();
    function Hash2(entries) {
      var index = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    Hash2.prototype.clear = hashClear2;
    Hash2.prototype["delete"] = hashDelete2;
    Hash2.prototype.get = hashGet2;
    Hash2.prototype.has = hashHas2;
    Hash2.prototype.set = hashSet2;
    module2.exports = Hash2;
  }
});

// node_modules/lodash/_mapCacheClear.js
var require_mapCacheClear = __commonJS({
  "node_modules/lodash/_mapCacheClear.js"(exports2, module2) {
    "use strict";
    var Hash2 = require_Hash();
    var ListCache2 = require_ListCache();
    var Map3 = require_Map();
    function mapCacheClear2() {
      this.size = 0;
      this.__data__ = {
        "hash": new Hash2(),
        "map": new (Map3 || ListCache2)(),
        "string": new Hash2()
      };
    }
    module2.exports = mapCacheClear2;
  }
});

// node_modules/lodash/_isKeyable.js
var require_isKeyable = __commonJS({
  "node_modules/lodash/_isKeyable.js"(exports2, module2) {
    "use strict";
    function isKeyable2(value) {
      var type = typeof value;
      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
    }
    module2.exports = isKeyable2;
  }
});

// node_modules/lodash/_getMapData.js
var require_getMapData = __commonJS({
  "node_modules/lodash/_getMapData.js"(exports2, module2) {
    "use strict";
    var isKeyable2 = require_isKeyable();
    function getMapData2(map3, key) {
      var data = map3.__data__;
      return isKeyable2(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
    }
    module2.exports = getMapData2;
  }
});

// node_modules/lodash/_mapCacheDelete.js
var require_mapCacheDelete = __commonJS({
  "node_modules/lodash/_mapCacheDelete.js"(exports2, module2) {
    "use strict";
    var getMapData2 = require_getMapData();
    function mapCacheDelete2(key) {
      var result = getMapData2(this, key)["delete"](key);
      this.size -= result ? 1 : 0;
      return result;
    }
    module2.exports = mapCacheDelete2;
  }
});

// node_modules/lodash/_mapCacheGet.js
var require_mapCacheGet = __commonJS({
  "node_modules/lodash/_mapCacheGet.js"(exports2, module2) {
    "use strict";
    var getMapData2 = require_getMapData();
    function mapCacheGet2(key) {
      return getMapData2(this, key).get(key);
    }
    module2.exports = mapCacheGet2;
  }
});

// node_modules/lodash/_mapCacheHas.js
var require_mapCacheHas = __commonJS({
  "node_modules/lodash/_mapCacheHas.js"(exports2, module2) {
    "use strict";
    var getMapData2 = require_getMapData();
    function mapCacheHas2(key) {
      return getMapData2(this, key).has(key);
    }
    module2.exports = mapCacheHas2;
  }
});

// node_modules/lodash/_mapCacheSet.js
var require_mapCacheSet = __commonJS({
  "node_modules/lodash/_mapCacheSet.js"(exports2, module2) {
    "use strict";
    var getMapData2 = require_getMapData();
    function mapCacheSet2(key, value) {
      var data = getMapData2(this, key), size = data.size;
      data.set(key, value);
      this.size += data.size == size ? 0 : 1;
      return this;
    }
    module2.exports = mapCacheSet2;
  }
});

// node_modules/lodash/_MapCache.js
var require_MapCache = __commonJS({
  "node_modules/lodash/_MapCache.js"(exports2, module2) {
    "use strict";
    var mapCacheClear2 = require_mapCacheClear();
    var mapCacheDelete2 = require_mapCacheDelete();
    var mapCacheGet2 = require_mapCacheGet();
    var mapCacheHas2 = require_mapCacheHas();
    var mapCacheSet2 = require_mapCacheSet();
    function MapCache2(entries) {
      var index = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    MapCache2.prototype.clear = mapCacheClear2;
    MapCache2.prototype["delete"] = mapCacheDelete2;
    MapCache2.prototype.get = mapCacheGet2;
    MapCache2.prototype.has = mapCacheHas2;
    MapCache2.prototype.set = mapCacheSet2;
    module2.exports = MapCache2;
  }
});

// node_modules/lodash/_stackSet.js
var require_stackSet = __commonJS({
  "node_modules/lodash/_stackSet.js"(exports2, module2) {
    "use strict";
    var ListCache2 = require_ListCache();
    var Map3 = require_Map();
    var MapCache2 = require_MapCache();
    var LARGE_ARRAY_SIZE3 = 200;
    function stackSet2(key, value) {
      var data = this.__data__;
      if (data instanceof ListCache2) {
        var pairs = data.__data__;
        if (!Map3 || pairs.length < LARGE_ARRAY_SIZE3 - 1) {
          pairs.push([key, value]);
          this.size = ++data.size;
          return this;
        }
        data = this.__data__ = new MapCache2(pairs);
      }
      data.set(key, value);
      this.size = data.size;
      return this;
    }
    module2.exports = stackSet2;
  }
});

// node_modules/lodash/_Stack.js
var require_Stack = __commonJS({
  "node_modules/lodash/_Stack.js"(exports2, module2) {
    "use strict";
    var ListCache2 = require_ListCache();
    var stackClear2 = require_stackClear();
    var stackDelete2 = require_stackDelete();
    var stackGet2 = require_stackGet();
    var stackHas2 = require_stackHas();
    var stackSet2 = require_stackSet();
    function Stack2(entries) {
      var data = this.__data__ = new ListCache2(entries);
      this.size = data.size;
    }
    Stack2.prototype.clear = stackClear2;
    Stack2.prototype["delete"] = stackDelete2;
    Stack2.prototype.get = stackGet2;
    Stack2.prototype.has = stackHas2;
    Stack2.prototype.set = stackSet2;
    module2.exports = Stack2;
  }
});

// node_modules/lodash/_arrayEach.js
var require_arrayEach = __commonJS({
  "node_modules/lodash/_arrayEach.js"(exports2, module2) {
    "use strict";
    function arrayEach(array4, iteratee) {
      var index = -1, length = array4 == null ? 0 : array4.length;
      while (++index < length) {
        if (iteratee(array4[index], index, array4) === false) {
          break;
        }
      }
      return array4;
    }
    module2.exports = arrayEach;
  }
});

// node_modules/lodash/_defineProperty.js
var require_defineProperty = __commonJS({
  "node_modules/lodash/_defineProperty.js"(exports2, module2) {
    "use strict";
    var getNative2 = require_getNative();
    var defineProperty2 = (function() {
      try {
        var func = getNative2(Object, "defineProperty");
        func({}, "", {});
        return func;
      } catch (e) {
      }
    })();
    module2.exports = defineProperty2;
  }
});

// node_modules/lodash/_baseAssignValue.js
var require_baseAssignValue = __commonJS({
  "node_modules/lodash/_baseAssignValue.js"(exports2, module2) {
    "use strict";
    var defineProperty2 = require_defineProperty();
    function baseAssignValue(object4, key, value) {
      if (key == "__proto__" && defineProperty2) {
        defineProperty2(object4, key, {
          "configurable": true,
          "enumerable": true,
          "value": value,
          "writable": true
        });
      } else {
        object4[key] = value;
      }
    }
    module2.exports = baseAssignValue;
  }
});

// node_modules/lodash/_assignValue.js
var require_assignValue = __commonJS({
  "node_modules/lodash/_assignValue.js"(exports2, module2) {
    "use strict";
    var baseAssignValue = require_baseAssignValue();
    var eq2 = require_eq();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function assignValue(object4, key, value) {
      var objValue = object4[key];
      if (!(hasOwnProperty11.call(object4, key) && eq2(objValue, value)) || value === void 0 && !(key in object4)) {
        baseAssignValue(object4, key, value);
      }
    }
    module2.exports = assignValue;
  }
});

// node_modules/lodash/_copyObject.js
var require_copyObject = __commonJS({
  "node_modules/lodash/_copyObject.js"(exports2, module2) {
    "use strict";
    var assignValue = require_assignValue();
    var baseAssignValue = require_baseAssignValue();
    function copyObject(source, props, object4, customizer) {
      var isNew = !object4;
      object4 || (object4 = {});
      var index = -1, length = props.length;
      while (++index < length) {
        var key = props[index];
        var newValue = customizer ? customizer(object4[key], source[key], key, object4, source) : void 0;
        if (newValue === void 0) {
          newValue = source[key];
        }
        if (isNew) {
          baseAssignValue(object4, key, newValue);
        } else {
          assignValue(object4, key, newValue);
        }
      }
      return object4;
    }
    module2.exports = copyObject;
  }
});

// node_modules/lodash/_baseTimes.js
var require_baseTimes = __commonJS({
  "node_modules/lodash/_baseTimes.js"(exports2, module2) {
    "use strict";
    function baseTimes2(n, iteratee) {
      var index = -1, result = Array(n);
      while (++index < n) {
        result[index] = iteratee(index);
      }
      return result;
    }
    module2.exports = baseTimes2;
  }
});

// node_modules/lodash/isObjectLike.js
var require_isObjectLike = __commonJS({
  "node_modules/lodash/isObjectLike.js"(exports2, module2) {
    "use strict";
    function isObjectLike2(value) {
      return value != null && typeof value == "object";
    }
    module2.exports = isObjectLike2;
  }
});

// node_modules/lodash/_baseIsArguments.js
var require_baseIsArguments = __commonJS({
  "node_modules/lodash/_baseIsArguments.js"(exports2, module2) {
    "use strict";
    var baseGetTag2 = require_baseGetTag();
    var isObjectLike2 = require_isObjectLike();
    var argsTag4 = "[object Arguments]";
    function baseIsArguments2(value) {
      return isObjectLike2(value) && baseGetTag2(value) == argsTag4;
    }
    module2.exports = baseIsArguments2;
  }
});

// node_modules/lodash/isArguments.js
var require_isArguments = __commonJS({
  "node_modules/lodash/isArguments.js"(exports2, module2) {
    "use strict";
    var baseIsArguments2 = require_baseIsArguments();
    var isObjectLike2 = require_isObjectLike();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    var propertyIsEnumerable3 = objectProto13.propertyIsEnumerable;
    var isArguments2 = baseIsArguments2(/* @__PURE__ */ (function() {
      return arguments;
    })()) ? baseIsArguments2 : function(value) {
      return isObjectLike2(value) && hasOwnProperty11.call(value, "callee") && !propertyIsEnumerable3.call(value, "callee");
    };
    module2.exports = isArguments2;
  }
});

// node_modules/lodash/isArray.js
var require_isArray = __commonJS({
  "node_modules/lodash/isArray.js"(exports2, module2) {
    "use strict";
    var isArray3 = Array.isArray;
    module2.exports = isArray3;
  }
});

// node_modules/lodash/stubFalse.js
var require_stubFalse = __commonJS({
  "node_modules/lodash/stubFalse.js"(exports2, module2) {
    "use strict";
    function stubFalse2() {
      return false;
    }
    module2.exports = stubFalse2;
  }
});

// node_modules/lodash/isBuffer.js
var require_isBuffer = __commonJS({
  "node_modules/lodash/isBuffer.js"(exports2, module2) {
    "use strict";
    var root2 = require_root();
    var stubFalse2 = require_stubFalse();
    var freeExports3 = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2;
    var freeModule3 = freeExports3 && typeof module2 == "object" && module2 && !module2.nodeType && module2;
    var moduleExports3 = freeModule3 && freeModule3.exports === freeExports3;
    var Buffer3 = moduleExports3 ? root2.Buffer : void 0;
    var nativeIsBuffer2 = Buffer3 ? Buffer3.isBuffer : void 0;
    var isBuffer3 = nativeIsBuffer2 || stubFalse2;
    module2.exports = isBuffer3;
  }
});

// node_modules/lodash/_isIndex.js
var require_isIndex = __commonJS({
  "node_modules/lodash/_isIndex.js"(exports2, module2) {
    "use strict";
    var MAX_SAFE_INTEGER3 = 9007199254740991;
    var reIsUint2 = /^(?:0|[1-9]\d*)$/;
    function isIndex2(value, length) {
      var type = typeof value;
      length = length == null ? MAX_SAFE_INTEGER3 : length;
      return !!length && (type == "number" || type != "symbol" && reIsUint2.test(value)) && (value > -1 && value % 1 == 0 && value < length);
    }
    module2.exports = isIndex2;
  }
});

// node_modules/lodash/isLength.js
var require_isLength = __commonJS({
  "node_modules/lodash/isLength.js"(exports2, module2) {
    "use strict";
    var MAX_SAFE_INTEGER3 = 9007199254740991;
    function isLength2(value) {
      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER3;
    }
    module2.exports = isLength2;
  }
});

// node_modules/lodash/_baseIsTypedArray.js
var require_baseIsTypedArray = __commonJS({
  "node_modules/lodash/_baseIsTypedArray.js"(exports2, module2) {
    "use strict";
    var baseGetTag2 = require_baseGetTag();
    var isLength2 = require_isLength();
    var isObjectLike2 = require_isObjectLike();
    var argsTag4 = "[object Arguments]";
    var arrayTag3 = "[object Array]";
    var boolTag3 = "[object Boolean]";
    var dateTag3 = "[object Date]";
    var errorTag3 = "[object Error]";
    var funcTag3 = "[object Function]";
    var mapTag4 = "[object Map]";
    var numberTag3 = "[object Number]";
    var objectTag4 = "[object Object]";
    var regexpTag3 = "[object RegExp]";
    var setTag4 = "[object Set]";
    var stringTag3 = "[object String]";
    var weakMapTag3 = "[object WeakMap]";
    var arrayBufferTag3 = "[object ArrayBuffer]";
    var dataViewTag4 = "[object DataView]";
    var float32Tag2 = "[object Float32Array]";
    var float64Tag2 = "[object Float64Array]";
    var int8Tag2 = "[object Int8Array]";
    var int16Tag2 = "[object Int16Array]";
    var int32Tag2 = "[object Int32Array]";
    var uint8Tag2 = "[object Uint8Array]";
    var uint8ClampedTag2 = "[object Uint8ClampedArray]";
    var uint16Tag2 = "[object Uint16Array]";
    var uint32Tag2 = "[object Uint32Array]";
    var typedArrayTags2 = {};
    typedArrayTags2[float32Tag2] = typedArrayTags2[float64Tag2] = typedArrayTags2[int8Tag2] = typedArrayTags2[int16Tag2] = typedArrayTags2[int32Tag2] = typedArrayTags2[uint8Tag2] = typedArrayTags2[uint8ClampedTag2] = typedArrayTags2[uint16Tag2] = typedArrayTags2[uint32Tag2] = true;
    typedArrayTags2[argsTag4] = typedArrayTags2[arrayTag3] = typedArrayTags2[arrayBufferTag3] = typedArrayTags2[boolTag3] = typedArrayTags2[dataViewTag4] = typedArrayTags2[dateTag3] = typedArrayTags2[errorTag3] = typedArrayTags2[funcTag3] = typedArrayTags2[mapTag4] = typedArrayTags2[numberTag3] = typedArrayTags2[objectTag4] = typedArrayTags2[regexpTag3] = typedArrayTags2[setTag4] = typedArrayTags2[stringTag3] = typedArrayTags2[weakMapTag3] = false;
    function baseIsTypedArray2(value) {
      return isObjectLike2(value) && isLength2(value.length) && !!typedArrayTags2[baseGetTag2(value)];
    }
    module2.exports = baseIsTypedArray2;
  }
});

// node_modules/lodash/_baseUnary.js
var require_baseUnary = __commonJS({
  "node_modules/lodash/_baseUnary.js"(exports2, module2) {
    "use strict";
    function baseUnary2(func) {
      return function(value) {
        return func(value);
      };
    }
    module2.exports = baseUnary2;
  }
});

// node_modules/lodash/_nodeUtil.js
var require_nodeUtil = __commonJS({
  "node_modules/lodash/_nodeUtil.js"(exports2, module2) {
    "use strict";
    var freeGlobal2 = require_freeGlobal();
    var freeExports3 = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2;
    var freeModule3 = freeExports3 && typeof module2 == "object" && module2 && !module2.nodeType && module2;
    var moduleExports3 = freeModule3 && freeModule3.exports === freeExports3;
    var freeProcess2 = moduleExports3 && freeGlobal2.process;
    var nodeUtil2 = (function() {
      try {
        var types = freeModule3 && freeModule3.require && freeModule3.require("util").types;
        if (types) {
          return types;
        }
        return freeProcess2 && freeProcess2.binding && freeProcess2.binding("util");
      } catch (e) {
      }
    })();
    module2.exports = nodeUtil2;
  }
});

// node_modules/lodash/isTypedArray.js
var require_isTypedArray = __commonJS({
  "node_modules/lodash/isTypedArray.js"(exports2, module2) {
    "use strict";
    var baseIsTypedArray2 = require_baseIsTypedArray();
    var baseUnary2 = require_baseUnary();
    var nodeUtil2 = require_nodeUtil();
    var nodeIsTypedArray2 = nodeUtil2 && nodeUtil2.isTypedArray;
    var isTypedArray3 = nodeIsTypedArray2 ? baseUnary2(nodeIsTypedArray2) : baseIsTypedArray2;
    module2.exports = isTypedArray3;
  }
});

// node_modules/lodash/_arrayLikeKeys.js
var require_arrayLikeKeys = __commonJS({
  "node_modules/lodash/_arrayLikeKeys.js"(exports2, module2) {
    "use strict";
    var baseTimes2 = require_baseTimes();
    var isArguments2 = require_isArguments();
    var isArray3 = require_isArray();
    var isBuffer3 = require_isBuffer();
    var isIndex2 = require_isIndex();
    var isTypedArray3 = require_isTypedArray();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function arrayLikeKeys2(value, inherited) {
      var isArr = isArray3(value), isArg = !isArr && isArguments2(value), isBuff = !isArr && !isArg && isBuffer3(value), isType = !isArr && !isArg && !isBuff && isTypedArray3(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes2(value.length, String) : [], length = result.length;
      for (var key in value) {
        if ((inherited || hasOwnProperty11.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
        isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
        isIndex2(key, length)))) {
          result.push(key);
        }
      }
      return result;
    }
    module2.exports = arrayLikeKeys2;
  }
});

// node_modules/lodash/_isPrototype.js
var require_isPrototype = __commonJS({
  "node_modules/lodash/_isPrototype.js"(exports2, module2) {
    "use strict";
    var objectProto13 = Object.prototype;
    function isPrototype2(value) {
      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto13;
      return value === proto;
    }
    module2.exports = isPrototype2;
  }
});

// node_modules/lodash/_overArg.js
var require_overArg = __commonJS({
  "node_modules/lodash/_overArg.js"(exports2, module2) {
    "use strict";
    function overArg2(func, transform8) {
      return function(arg) {
        return func(transform8(arg));
      };
    }
    module2.exports = overArg2;
  }
});

// node_modules/lodash/_nativeKeys.js
var require_nativeKeys = __commonJS({
  "node_modules/lodash/_nativeKeys.js"(exports2, module2) {
    "use strict";
    var overArg2 = require_overArg();
    var nativeKeys2 = overArg2(Object.keys, Object);
    module2.exports = nativeKeys2;
  }
});

// node_modules/lodash/_baseKeys.js
var require_baseKeys = __commonJS({
  "node_modules/lodash/_baseKeys.js"(exports2, module2) {
    "use strict";
    var isPrototype2 = require_isPrototype();
    var nativeKeys2 = require_nativeKeys();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function baseKeys2(object4) {
      if (!isPrototype2(object4)) {
        return nativeKeys2(object4);
      }
      var result = [];
      for (var key in Object(object4)) {
        if (hasOwnProperty11.call(object4, key) && key != "constructor") {
          result.push(key);
        }
      }
      return result;
    }
    module2.exports = baseKeys2;
  }
});

// node_modules/lodash/isArrayLike.js
var require_isArrayLike = __commonJS({
  "node_modules/lodash/isArrayLike.js"(exports2, module2) {
    "use strict";
    var isFunction4 = require_isFunction();
    var isLength2 = require_isLength();
    function isArrayLike2(value) {
      return value != null && isLength2(value.length) && !isFunction4(value);
    }
    module2.exports = isArrayLike2;
  }
});

// node_modules/lodash/keys.js
var require_keys = __commonJS({
  "node_modules/lodash/keys.js"(exports2, module2) {
    "use strict";
    var arrayLikeKeys2 = require_arrayLikeKeys();
    var baseKeys2 = require_baseKeys();
    var isArrayLike2 = require_isArrayLike();
    function keys2(object4) {
      return isArrayLike2(object4) ? arrayLikeKeys2(object4) : baseKeys2(object4);
    }
    module2.exports = keys2;
  }
});

// node_modules/lodash/_baseAssign.js
var require_baseAssign = __commonJS({
  "node_modules/lodash/_baseAssign.js"(exports2, module2) {
    "use strict";
    var copyObject = require_copyObject();
    var keys2 = require_keys();
    function baseAssign(object4, source) {
      return object4 && copyObject(source, keys2(source), object4);
    }
    module2.exports = baseAssign;
  }
});

// node_modules/lodash/_nativeKeysIn.js
var require_nativeKeysIn = __commonJS({
  "node_modules/lodash/_nativeKeysIn.js"(exports2, module2) {
    "use strict";
    function nativeKeysIn(object4) {
      var result = [];
      if (object4 != null) {
        for (var key in Object(object4)) {
          result.push(key);
        }
      }
      return result;
    }
    module2.exports = nativeKeysIn;
  }
});

// node_modules/lodash/_baseKeysIn.js
var require_baseKeysIn = __commonJS({
  "node_modules/lodash/_baseKeysIn.js"(exports2, module2) {
    "use strict";
    var isObject5 = require_isObject();
    var isPrototype2 = require_isPrototype();
    var nativeKeysIn = require_nativeKeysIn();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function baseKeysIn(object4) {
      if (!isObject5(object4)) {
        return nativeKeysIn(object4);
      }
      var isProto = isPrototype2(object4), result = [];
      for (var key in object4) {
        if (!(key == "constructor" && (isProto || !hasOwnProperty11.call(object4, key)))) {
          result.push(key);
        }
      }
      return result;
    }
    module2.exports = baseKeysIn;
  }
});

// node_modules/lodash/keysIn.js
var require_keysIn = __commonJS({
  "node_modules/lodash/keysIn.js"(exports2, module2) {
    "use strict";
    var arrayLikeKeys2 = require_arrayLikeKeys();
    var baseKeysIn = require_baseKeysIn();
    var isArrayLike2 = require_isArrayLike();
    function keysIn(object4) {
      return isArrayLike2(object4) ? arrayLikeKeys2(object4, true) : baseKeysIn(object4);
    }
    module2.exports = keysIn;
  }
});

// node_modules/lodash/_baseAssignIn.js
var require_baseAssignIn = __commonJS({
  "node_modules/lodash/_baseAssignIn.js"(exports2, module2) {
    "use strict";
    var copyObject = require_copyObject();
    var keysIn = require_keysIn();
    function baseAssignIn(object4, source) {
      return object4 && copyObject(source, keysIn(source), object4);
    }
    module2.exports = baseAssignIn;
  }
});

// node_modules/lodash/_cloneBuffer.js
var require_cloneBuffer = __commonJS({
  "node_modules/lodash/_cloneBuffer.js"(exports2, module2) {
    "use strict";
    var root2 = require_root();
    var freeExports3 = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2;
    var freeModule3 = freeExports3 && typeof module2 == "object" && module2 && !module2.nodeType && module2;
    var moduleExports3 = freeModule3 && freeModule3.exports === freeExports3;
    var Buffer3 = moduleExports3 ? root2.Buffer : void 0;
    var allocUnsafe = Buffer3 ? Buffer3.allocUnsafe : void 0;
    function cloneBuffer(buffer, isDeep) {
      if (isDeep) {
        return buffer.slice();
      }
      var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
      buffer.copy(result);
      return result;
    }
    module2.exports = cloneBuffer;
  }
});

// node_modules/lodash/_copyArray.js
var require_copyArray = __commonJS({
  "node_modules/lodash/_copyArray.js"(exports2, module2) {
    "use strict";
    function copyArray(source, array4) {
      var index = -1, length = source.length;
      array4 || (array4 = Array(length));
      while (++index < length) {
        array4[index] = source[index];
      }
      return array4;
    }
    module2.exports = copyArray;
  }
});

// node_modules/lodash/_arrayFilter.js
var require_arrayFilter = __commonJS({
  "node_modules/lodash/_arrayFilter.js"(exports2, module2) {
    "use strict";
    function arrayFilter2(array4, predicate) {
      var index = -1, length = array4 == null ? 0 : array4.length, resIndex = 0, result = [];
      while (++index < length) {
        var value = array4[index];
        if (predicate(value, index, array4)) {
          result[resIndex++] = value;
        }
      }
      return result;
    }
    module2.exports = arrayFilter2;
  }
});

// node_modules/lodash/stubArray.js
var require_stubArray = __commonJS({
  "node_modules/lodash/stubArray.js"(exports2, module2) {
    "use strict";
    function stubArray2() {
      return [];
    }
    module2.exports = stubArray2;
  }
});

// node_modules/lodash/_getSymbols.js
var require_getSymbols = __commonJS({
  "node_modules/lodash/_getSymbols.js"(exports2, module2) {
    "use strict";
    var arrayFilter2 = require_arrayFilter();
    var stubArray2 = require_stubArray();
    var objectProto13 = Object.prototype;
    var propertyIsEnumerable3 = objectProto13.propertyIsEnumerable;
    var nativeGetSymbols2 = Object.getOwnPropertySymbols;
    var getSymbols2 = !nativeGetSymbols2 ? stubArray2 : function(object4) {
      if (object4 == null) {
        return [];
      }
      object4 = Object(object4);
      return arrayFilter2(nativeGetSymbols2(object4), function(symbol30) {
        return propertyIsEnumerable3.call(object4, symbol30);
      });
    };
    module2.exports = getSymbols2;
  }
});

// node_modules/lodash/_copySymbols.js
var require_copySymbols = __commonJS({
  "node_modules/lodash/_copySymbols.js"(exports2, module2) {
    "use strict";
    var copyObject = require_copyObject();
    var getSymbols2 = require_getSymbols();
    function copySymbols(source, object4) {
      return copyObject(source, getSymbols2(source), object4);
    }
    module2.exports = copySymbols;
  }
});

// node_modules/lodash/_arrayPush.js
var require_arrayPush = __commonJS({
  "node_modules/lodash/_arrayPush.js"(exports2, module2) {
    "use strict";
    function arrayPush2(array4, values) {
      var index = -1, length = values.length, offset = array4.length;
      while (++index < length) {
        array4[offset + index] = values[index];
      }
      return array4;
    }
    module2.exports = arrayPush2;
  }
});

// node_modules/lodash/_getPrototype.js
var require_getPrototype = __commonJS({
  "node_modules/lodash/_getPrototype.js"(exports2, module2) {
    "use strict";
    var overArg2 = require_overArg();
    var getPrototype = overArg2(Object.getPrototypeOf, Object);
    module2.exports = getPrototype;
  }
});

// node_modules/lodash/_getSymbolsIn.js
var require_getSymbolsIn = __commonJS({
  "node_modules/lodash/_getSymbolsIn.js"(exports2, module2) {
    "use strict";
    var arrayPush2 = require_arrayPush();
    var getPrototype = require_getPrototype();
    var getSymbols2 = require_getSymbols();
    var stubArray2 = require_stubArray();
    var nativeGetSymbols2 = Object.getOwnPropertySymbols;
    var getSymbolsIn = !nativeGetSymbols2 ? stubArray2 : function(object4) {
      var result = [];
      while (object4) {
        arrayPush2(result, getSymbols2(object4));
        object4 = getPrototype(object4);
      }
      return result;
    };
    module2.exports = getSymbolsIn;
  }
});

// node_modules/lodash/_copySymbolsIn.js
var require_copySymbolsIn = __commonJS({
  "node_modules/lodash/_copySymbolsIn.js"(exports2, module2) {
    "use strict";
    var copyObject = require_copyObject();
    var getSymbolsIn = require_getSymbolsIn();
    function copySymbolsIn(source, object4) {
      return copyObject(source, getSymbolsIn(source), object4);
    }
    module2.exports = copySymbolsIn;
  }
});

// node_modules/lodash/_baseGetAllKeys.js
var require_baseGetAllKeys = __commonJS({
  "node_modules/lodash/_baseGetAllKeys.js"(exports2, module2) {
    "use strict";
    var arrayPush2 = require_arrayPush();
    var isArray3 = require_isArray();
    function baseGetAllKeys2(object4, keysFunc, symbolsFunc) {
      var result = keysFunc(object4);
      return isArray3(object4) ? result : arrayPush2(result, symbolsFunc(object4));
    }
    module2.exports = baseGetAllKeys2;
  }
});

// node_modules/lodash/_getAllKeys.js
var require_getAllKeys = __commonJS({
  "node_modules/lodash/_getAllKeys.js"(exports2, module2) {
    "use strict";
    var baseGetAllKeys2 = require_baseGetAllKeys();
    var getSymbols2 = require_getSymbols();
    var keys2 = require_keys();
    function getAllKeys2(object4) {
      return baseGetAllKeys2(object4, keys2, getSymbols2);
    }
    module2.exports = getAllKeys2;
  }
});

// node_modules/lodash/_getAllKeysIn.js
var require_getAllKeysIn = __commonJS({
  "node_modules/lodash/_getAllKeysIn.js"(exports2, module2) {
    "use strict";
    var baseGetAllKeys2 = require_baseGetAllKeys();
    var getSymbolsIn = require_getSymbolsIn();
    var keysIn = require_keysIn();
    function getAllKeysIn(object4) {
      return baseGetAllKeys2(object4, keysIn, getSymbolsIn);
    }
    module2.exports = getAllKeysIn;
  }
});

// node_modules/lodash/_DataView.js
var require_DataView = __commonJS({
  "node_modules/lodash/_DataView.js"(exports2, module2) {
    "use strict";
    var getNative2 = require_getNative();
    var root2 = require_root();
    var DataView3 = getNative2(root2, "DataView");
    module2.exports = DataView3;
  }
});

// node_modules/lodash/_Promise.js
var require_Promise = __commonJS({
  "node_modules/lodash/_Promise.js"(exports2, module2) {
    "use strict";
    var getNative2 = require_getNative();
    var root2 = require_root();
    var Promise3 = getNative2(root2, "Promise");
    module2.exports = Promise3;
  }
});

// node_modules/lodash/_Set.js
var require_Set = __commonJS({
  "node_modules/lodash/_Set.js"(exports2, module2) {
    "use strict";
    var getNative2 = require_getNative();
    var root2 = require_root();
    var Set3 = getNative2(root2, "Set");
    module2.exports = Set3;
  }
});

// node_modules/lodash/_WeakMap.js
var require_WeakMap = __commonJS({
  "node_modules/lodash/_WeakMap.js"(exports2, module2) {
    "use strict";
    var getNative2 = require_getNative();
    var root2 = require_root();
    var WeakMap3 = getNative2(root2, "WeakMap");
    module2.exports = WeakMap3;
  }
});

// node_modules/lodash/_getTag.js
var require_getTag = __commonJS({
  "node_modules/lodash/_getTag.js"(exports2, module2) {
    "use strict";
    var DataView3 = require_DataView();
    var Map3 = require_Map();
    var Promise3 = require_Promise();
    var Set3 = require_Set();
    var WeakMap3 = require_WeakMap();
    var baseGetTag2 = require_baseGetTag();
    var toSource2 = require_toSource();
    var mapTag4 = "[object Map]";
    var objectTag4 = "[object Object]";
    var promiseTag2 = "[object Promise]";
    var setTag4 = "[object Set]";
    var weakMapTag3 = "[object WeakMap]";
    var dataViewTag4 = "[object DataView]";
    var dataViewCtorString2 = toSource2(DataView3);
    var mapCtorString2 = toSource2(Map3);
    var promiseCtorString2 = toSource2(Promise3);
    var setCtorString2 = toSource2(Set3);
    var weakMapCtorString2 = toSource2(WeakMap3);
    var getTag2 = baseGetTag2;
    if (DataView3 && getTag2(new DataView3(new ArrayBuffer(1))) != dataViewTag4 || Map3 && getTag2(new Map3()) != mapTag4 || Promise3 && getTag2(Promise3.resolve()) != promiseTag2 || Set3 && getTag2(new Set3()) != setTag4 || WeakMap3 && getTag2(new WeakMap3()) != weakMapTag3) {
      getTag2 = function(value) {
        var result = baseGetTag2(value), Ctor = result == objectTag4 ? value.constructor : void 0, ctorString = Ctor ? toSource2(Ctor) : "";
        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString2:
              return dataViewTag4;
            case mapCtorString2:
              return mapTag4;
            case promiseCtorString2:
              return promiseTag2;
            case setCtorString2:
              return setTag4;
            case weakMapCtorString2:
              return weakMapTag3;
          }
        }
        return result;
      };
    }
    module2.exports = getTag2;
  }
});

// node_modules/lodash/_initCloneArray.js
var require_initCloneArray = __commonJS({
  "node_modules/lodash/_initCloneArray.js"(exports2, module2) {
    "use strict";
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function initCloneArray(array4) {
      var length = array4.length, result = new array4.constructor(length);
      if (length && typeof array4[0] == "string" && hasOwnProperty11.call(array4, "index")) {
        result.index = array4.index;
        result.input = array4.input;
      }
      return result;
    }
    module2.exports = initCloneArray;
  }
});

// node_modules/lodash/_Uint8Array.js
var require_Uint8Array = __commonJS({
  "node_modules/lodash/_Uint8Array.js"(exports2, module2) {
    "use strict";
    var root2 = require_root();
    var Uint8Array3 = root2.Uint8Array;
    module2.exports = Uint8Array3;
  }
});

// node_modules/lodash/_cloneArrayBuffer.js
var require_cloneArrayBuffer = __commonJS({
  "node_modules/lodash/_cloneArrayBuffer.js"(exports2, module2) {
    "use strict";
    var Uint8Array3 = require_Uint8Array();
    function cloneArrayBuffer(arrayBuffer) {
      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
      new Uint8Array3(result).set(new Uint8Array3(arrayBuffer));
      return result;
    }
    module2.exports = cloneArrayBuffer;
  }
});

// node_modules/lodash/_cloneDataView.js
var require_cloneDataView = __commonJS({
  "node_modules/lodash/_cloneDataView.js"(exports2, module2) {
    "use strict";
    var cloneArrayBuffer = require_cloneArrayBuffer();
    function cloneDataView(dataView, isDeep) {
      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
    }
    module2.exports = cloneDataView;
  }
});

// node_modules/lodash/_cloneRegExp.js
var require_cloneRegExp = __commonJS({
  "node_modules/lodash/_cloneRegExp.js"(exports2, module2) {
    "use strict";
    var reFlags = /\w*$/;
    function cloneRegExp(regexp) {
      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
      result.lastIndex = regexp.lastIndex;
      return result;
    }
    module2.exports = cloneRegExp;
  }
});

// node_modules/lodash/_cloneSymbol.js
var require_cloneSymbol = __commonJS({
  "node_modules/lodash/_cloneSymbol.js"(exports2, module2) {
    "use strict";
    var Symbol3 = require_Symbol();
    var symbolProto3 = Symbol3 ? Symbol3.prototype : void 0;
    var symbolValueOf2 = symbolProto3 ? symbolProto3.valueOf : void 0;
    function cloneSymbol(symbol30) {
      return symbolValueOf2 ? Object(symbolValueOf2.call(symbol30)) : {};
    }
    module2.exports = cloneSymbol;
  }
});

// node_modules/lodash/_cloneTypedArray.js
var require_cloneTypedArray = __commonJS({
  "node_modules/lodash/_cloneTypedArray.js"(exports2, module2) {
    "use strict";
    var cloneArrayBuffer = require_cloneArrayBuffer();
    function cloneTypedArray(typedArray, isDeep) {
      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
    }
    module2.exports = cloneTypedArray;
  }
});

// node_modules/lodash/_initCloneByTag.js
var require_initCloneByTag = __commonJS({
  "node_modules/lodash/_initCloneByTag.js"(exports2, module2) {
    "use strict";
    var cloneArrayBuffer = require_cloneArrayBuffer();
    var cloneDataView = require_cloneDataView();
    var cloneRegExp = require_cloneRegExp();
    var cloneSymbol = require_cloneSymbol();
    var cloneTypedArray = require_cloneTypedArray();
    var boolTag3 = "[object Boolean]";
    var dateTag3 = "[object Date]";
    var mapTag4 = "[object Map]";
    var numberTag3 = "[object Number]";
    var regexpTag3 = "[object RegExp]";
    var setTag4 = "[object Set]";
    var stringTag3 = "[object String]";
    var symbolTag3 = "[object Symbol]";
    var arrayBufferTag3 = "[object ArrayBuffer]";
    var dataViewTag4 = "[object DataView]";
    var float32Tag2 = "[object Float32Array]";
    var float64Tag2 = "[object Float64Array]";
    var int8Tag2 = "[object Int8Array]";
    var int16Tag2 = "[object Int16Array]";
    var int32Tag2 = "[object Int32Array]";
    var uint8Tag2 = "[object Uint8Array]";
    var uint8ClampedTag2 = "[object Uint8ClampedArray]";
    var uint16Tag2 = "[object Uint16Array]";
    var uint32Tag2 = "[object Uint32Array]";
    function initCloneByTag(object4, tag, isDeep) {
      var Ctor = object4.constructor;
      switch (tag) {
        case arrayBufferTag3:
          return cloneArrayBuffer(object4);
        case boolTag3:
        case dateTag3:
          return new Ctor(+object4);
        case dataViewTag4:
          return cloneDataView(object4, isDeep);
        case float32Tag2:
        case float64Tag2:
        case int8Tag2:
        case int16Tag2:
        case int32Tag2:
        case uint8Tag2:
        case uint8ClampedTag2:
        case uint16Tag2:
        case uint32Tag2:
          return cloneTypedArray(object4, isDeep);
        case mapTag4:
          return new Ctor();
        case numberTag3:
        case stringTag3:
          return new Ctor(object4);
        case regexpTag3:
          return cloneRegExp(object4);
        case setTag4:
          return new Ctor();
        case symbolTag3:
          return cloneSymbol(object4);
      }
    }
    module2.exports = initCloneByTag;
  }
});

// node_modules/lodash/_baseCreate.js
var require_baseCreate = __commonJS({
  "node_modules/lodash/_baseCreate.js"(exports2, module2) {
    "use strict";
    var isObject5 = require_isObject();
    var objectCreate = Object.create;
    var baseCreate = /* @__PURE__ */ (function() {
      function object4() {
      }
      return function(proto) {
        if (!isObject5(proto)) {
          return {};
        }
        if (objectCreate) {
          return objectCreate(proto);
        }
        object4.prototype = proto;
        var result = new object4();
        object4.prototype = void 0;
        return result;
      };
    })();
    module2.exports = baseCreate;
  }
});

// node_modules/lodash/_initCloneObject.js
var require_initCloneObject = __commonJS({
  "node_modules/lodash/_initCloneObject.js"(exports2, module2) {
    "use strict";
    var baseCreate = require_baseCreate();
    var getPrototype = require_getPrototype();
    var isPrototype2 = require_isPrototype();
    function initCloneObject(object4) {
      return typeof object4.constructor == "function" && !isPrototype2(object4) ? baseCreate(getPrototype(object4)) : {};
    }
    module2.exports = initCloneObject;
  }
});

// node_modules/lodash/_baseIsMap.js
var require_baseIsMap = __commonJS({
  "node_modules/lodash/_baseIsMap.js"(exports2, module2) {
    "use strict";
    var getTag2 = require_getTag();
    var isObjectLike2 = require_isObjectLike();
    var mapTag4 = "[object Map]";
    function baseIsMap(value) {
      return isObjectLike2(value) && getTag2(value) == mapTag4;
    }
    module2.exports = baseIsMap;
  }
});

// node_modules/lodash/isMap.js
var require_isMap = __commonJS({
  "node_modules/lodash/isMap.js"(exports2, module2) {
    "use strict";
    var baseIsMap = require_baseIsMap();
    var baseUnary2 = require_baseUnary();
    var nodeUtil2 = require_nodeUtil();
    var nodeIsMap = nodeUtil2 && nodeUtil2.isMap;
    var isMap = nodeIsMap ? baseUnary2(nodeIsMap) : baseIsMap;
    module2.exports = isMap;
  }
});

// node_modules/lodash/_baseIsSet.js
var require_baseIsSet = __commonJS({
  "node_modules/lodash/_baseIsSet.js"(exports2, module2) {
    "use strict";
    var getTag2 = require_getTag();
    var isObjectLike2 = require_isObjectLike();
    var setTag4 = "[object Set]";
    function baseIsSet(value) {
      return isObjectLike2(value) && getTag2(value) == setTag4;
    }
    module2.exports = baseIsSet;
  }
});

// node_modules/lodash/isSet.js
var require_isSet = __commonJS({
  "node_modules/lodash/isSet.js"(exports2, module2) {
    "use strict";
    var baseIsSet = require_baseIsSet();
    var baseUnary2 = require_baseUnary();
    var nodeUtil2 = require_nodeUtil();
    var nodeIsSet = nodeUtil2 && nodeUtil2.isSet;
    var isSet = nodeIsSet ? baseUnary2(nodeIsSet) : baseIsSet;
    module2.exports = isSet;
  }
});

// node_modules/lodash/_baseClone.js
var require_baseClone = __commonJS({
  "node_modules/lodash/_baseClone.js"(exports2, module2) {
    "use strict";
    var Stack2 = require_Stack();
    var arrayEach = require_arrayEach();
    var assignValue = require_assignValue();
    var baseAssign = require_baseAssign();
    var baseAssignIn = require_baseAssignIn();
    var cloneBuffer = require_cloneBuffer();
    var copyArray = require_copyArray();
    var copySymbols = require_copySymbols();
    var copySymbolsIn = require_copySymbolsIn();
    var getAllKeys2 = require_getAllKeys();
    var getAllKeysIn = require_getAllKeysIn();
    var getTag2 = require_getTag();
    var initCloneArray = require_initCloneArray();
    var initCloneByTag = require_initCloneByTag();
    var initCloneObject = require_initCloneObject();
    var isArray3 = require_isArray();
    var isBuffer3 = require_isBuffer();
    var isMap = require_isMap();
    var isObject5 = require_isObject();
    var isSet = require_isSet();
    var keys2 = require_keys();
    var keysIn = require_keysIn();
    var CLONE_DEEP_FLAG = 1;
    var CLONE_FLAT_FLAG = 2;
    var CLONE_SYMBOLS_FLAG = 4;
    var argsTag4 = "[object Arguments]";
    var arrayTag3 = "[object Array]";
    var boolTag3 = "[object Boolean]";
    var dateTag3 = "[object Date]";
    var errorTag3 = "[object Error]";
    var funcTag3 = "[object Function]";
    var genTag2 = "[object GeneratorFunction]";
    var mapTag4 = "[object Map]";
    var numberTag3 = "[object Number]";
    var objectTag4 = "[object Object]";
    var regexpTag3 = "[object RegExp]";
    var setTag4 = "[object Set]";
    var stringTag3 = "[object String]";
    var symbolTag3 = "[object Symbol]";
    var weakMapTag3 = "[object WeakMap]";
    var arrayBufferTag3 = "[object ArrayBuffer]";
    var dataViewTag4 = "[object DataView]";
    var float32Tag2 = "[object Float32Array]";
    var float64Tag2 = "[object Float64Array]";
    var int8Tag2 = "[object Int8Array]";
    var int16Tag2 = "[object Int16Array]";
    var int32Tag2 = "[object Int32Array]";
    var uint8Tag2 = "[object Uint8Array]";
    var uint8ClampedTag2 = "[object Uint8ClampedArray]";
    var uint16Tag2 = "[object Uint16Array]";
    var uint32Tag2 = "[object Uint32Array]";
    var cloneableTags = {};
    cloneableTags[argsTag4] = cloneableTags[arrayTag3] = cloneableTags[arrayBufferTag3] = cloneableTags[dataViewTag4] = cloneableTags[boolTag3] = cloneableTags[dateTag3] = cloneableTags[float32Tag2] = cloneableTags[float64Tag2] = cloneableTags[int8Tag2] = cloneableTags[int16Tag2] = cloneableTags[int32Tag2] = cloneableTags[mapTag4] = cloneableTags[numberTag3] = cloneableTags[objectTag4] = cloneableTags[regexpTag3] = cloneableTags[setTag4] = cloneableTags[stringTag3] = cloneableTags[symbolTag3] = cloneableTags[uint8Tag2] = cloneableTags[uint8ClampedTag2] = cloneableTags[uint16Tag2] = cloneableTags[uint32Tag2] = true;
    cloneableTags[errorTag3] = cloneableTags[funcTag3] = cloneableTags[weakMapTag3] = false;
    function baseClone(value, bitmask, customizer, key, object4, stack) {
      var result, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
      if (customizer) {
        result = object4 ? customizer(value, key, object4, stack) : customizer(value);
      }
      if (result !== void 0) {
        return result;
      }
      if (!isObject5(value)) {
        return value;
      }
      var isArr = isArray3(value);
      if (isArr) {
        result = initCloneArray(value);
        if (!isDeep) {
          return copyArray(value, result);
        }
      } else {
        var tag = getTag2(value), isFunc = tag == funcTag3 || tag == genTag2;
        if (isBuffer3(value)) {
          return cloneBuffer(value, isDeep);
        }
        if (tag == objectTag4 || tag == argsTag4 || isFunc && !object4) {
          result = isFlat || isFunc ? {} : initCloneObject(value);
          if (!isDeep) {
            return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
          }
        } else {
          if (!cloneableTags[tag]) {
            return object4 ? value : {};
          }
          result = initCloneByTag(value, tag, isDeep);
        }
      }
      stack || (stack = new Stack2());
      var stacked = stack.get(value);
      if (stacked) {
        return stacked;
      }
      stack.set(value, result);
      if (isSet(value)) {
        value.forEach(function(subValue) {
          result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
        });
      } else if (isMap(value)) {
        value.forEach(function(subValue, key2) {
          result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
        });
      }
      var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys2 : isFlat ? keysIn : keys2;
      var props = isArr ? void 0 : keysFunc(value);
      arrayEach(props || value, function(subValue, key2) {
        if (props) {
          key2 = subValue;
          subValue = value[key2];
        }
        assignValue(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
      });
      return result;
    }
    module2.exports = baseClone;
  }
});

// node_modules/lodash/cloneDeep.js
var require_cloneDeep = __commonJS({
  "node_modules/lodash/cloneDeep.js"(exports2, module2) {
    "use strict";
    var baseClone = require_baseClone();
    var CLONE_DEEP_FLAG = 1;
    var CLONE_SYMBOLS_FLAG = 4;
    function cloneDeep(value) {
      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
    }
    module2.exports = cloneDeep;
  }
});

// node_modules/lodash/identity.js
var require_identity = __commonJS({
  "node_modules/lodash/identity.js"(exports2, module2) {
    "use strict";
    function identity2(value) {
      return value;
    }
    module2.exports = identity2;
  }
});

// node_modules/lodash/_apply.js
var require_apply = __commonJS({
  "node_modules/lodash/_apply.js"(exports2, module2) {
    "use strict";
    function apply(func, thisArg, args) {
      switch (args.length) {
        case 0:
          return func.call(thisArg);
        case 1:
          return func.call(thisArg, args[0]);
        case 2:
          return func.call(thisArg, args[0], args[1]);
        case 3:
          return func.call(thisArg, args[0], args[1], args[2]);
      }
      return func.apply(thisArg, args);
    }
    module2.exports = apply;
  }
});

// node_modules/lodash/_overRest.js
var require_overRest = __commonJS({
  "node_modules/lodash/_overRest.js"(exports2, module2) {
    "use strict";
    var apply = require_apply();
    var nativeMax = Math.max;
    function overRest(func, start, transform8) {
      start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
      return function() {
        var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array4 = Array(length);
        while (++index < length) {
          array4[index] = args[start + index];
        }
        index = -1;
        var otherArgs = Array(start + 1);
        while (++index < start) {
          otherArgs[index] = args[index];
        }
        otherArgs[start] = transform8(array4);
        return apply(func, this, otherArgs);
      };
    }
    module2.exports = overRest;
  }
});

// node_modules/lodash/constant.js
var require_constant = __commonJS({
  "node_modules/lodash/constant.js"(exports2, module2) {
    "use strict";
    function constant(value) {
      return function() {
        return value;
      };
    }
    module2.exports = constant;
  }
});

// node_modules/lodash/_baseSetToString.js
var require_baseSetToString = __commonJS({
  "node_modules/lodash/_baseSetToString.js"(exports2, module2) {
    "use strict";
    var constant = require_constant();
    var defineProperty2 = require_defineProperty();
    var identity2 = require_identity();
    var baseSetToString = !defineProperty2 ? identity2 : function(func, string5) {
      return defineProperty2(func, "toString", {
        "configurable": true,
        "enumerable": false,
        "value": constant(string5),
        "writable": true
      });
    };
    module2.exports = baseSetToString;
  }
});

// node_modules/lodash/_shortOut.js
var require_shortOut = __commonJS({
  "node_modules/lodash/_shortOut.js"(exports2, module2) {
    "use strict";
    var HOT_COUNT = 800;
    var HOT_SPAN = 16;
    var nativeNow = Date.now;
    function shortOut(func) {
      var count = 0, lastCalled = 0;
      return function() {
        var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
        lastCalled = stamp;
        if (remaining > 0) {
          if (++count >= HOT_COUNT) {
            return arguments[0];
          }
        } else {
          count = 0;
        }
        return func.apply(void 0, arguments);
      };
    }
    module2.exports = shortOut;
  }
});

// node_modules/lodash/_setToString.js
var require_setToString = __commonJS({
  "node_modules/lodash/_setToString.js"(exports2, module2) {
    "use strict";
    var baseSetToString = require_baseSetToString();
    var shortOut = require_shortOut();
    var setToString = shortOut(baseSetToString);
    module2.exports = setToString;
  }
});

// node_modules/lodash/_baseRest.js
var require_baseRest = __commonJS({
  "node_modules/lodash/_baseRest.js"(exports2, module2) {
    "use strict";
    var identity2 = require_identity();
    var overRest = require_overRest();
    var setToString = require_setToString();
    function baseRest(func, start) {
      return setToString(overRest(func, start, identity2), func + "");
    }
    module2.exports = baseRest;
  }
});

// node_modules/lodash/_isIterateeCall.js
var require_isIterateeCall = __commonJS({
  "node_modules/lodash/_isIterateeCall.js"(exports2, module2) {
    "use strict";
    var eq2 = require_eq();
    var isArrayLike2 = require_isArrayLike();
    var isIndex2 = require_isIndex();
    var isObject5 = require_isObject();
    function isIterateeCall(value, index, object4) {
      if (!isObject5(object4)) {
        return false;
      }
      var type = typeof index;
      if (type == "number" ? isArrayLike2(object4) && isIndex2(index, object4.length) : type == "string" && index in object4) {
        return eq2(object4[index], value);
      }
      return false;
    }
    module2.exports = isIterateeCall;
  }
});

// node_modules/lodash/defaults.js
var require_defaults = __commonJS({
  "node_modules/lodash/defaults.js"(exports2, module2) {
    "use strict";
    var baseRest = require_baseRest();
    var eq2 = require_eq();
    var isIterateeCall = require_isIterateeCall();
    var keysIn = require_keysIn();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    var defaults2 = baseRest(function(object4, sources) {
      object4 = Object(object4);
      var index = -1;
      var length = sources.length;
      var guard = length > 2 ? sources[2] : void 0;
      if (guard && isIterateeCall(sources[0], sources[1], guard)) {
        length = 1;
      }
      while (++index < length) {
        var source = sources[index];
        var props = keysIn(source);
        var propsIndex = -1;
        var propsLength = props.length;
        while (++propsIndex < propsLength) {
          var key = props[propsIndex];
          var value = object4[key];
          if (value === void 0 || eq2(value, objectProto13[key]) && !hasOwnProperty11.call(object4, key)) {
            object4[key] = source[key];
          }
        }
      }
      return object4;
    });
    module2.exports = defaults2;
  }
});

// node_modules/lodash/_arrayMap.js
var require_arrayMap = __commonJS({
  "node_modules/lodash/_arrayMap.js"(exports2, module2) {
    "use strict";
    function arrayMap2(array4, iteratee) {
      var index = -1, length = array4 == null ? 0 : array4.length, result = Array(length);
      while (++index < length) {
        result[index] = iteratee(array4[index], index, array4);
      }
      return result;
    }
    module2.exports = arrayMap2;
  }
});

// node_modules/lodash/isSymbol.js
var require_isSymbol = __commonJS({
  "node_modules/lodash/isSymbol.js"(exports2, module2) {
    "use strict";
    var baseGetTag2 = require_baseGetTag();
    var isObjectLike2 = require_isObjectLike();
    var symbolTag3 = "[object Symbol]";
    function isSymbol2(value) {
      return typeof value == "symbol" || isObjectLike2(value) && baseGetTag2(value) == symbolTag3;
    }
    module2.exports = isSymbol2;
  }
});

// node_modules/lodash/_baseToString.js
var require_baseToString = __commonJS({
  "node_modules/lodash/_baseToString.js"(exports2, module2) {
    "use strict";
    var Symbol3 = require_Symbol();
    var arrayMap2 = require_arrayMap();
    var isArray3 = require_isArray();
    var isSymbol2 = require_isSymbol();
    var INFINITY4 = 1 / 0;
    var symbolProto3 = Symbol3 ? Symbol3.prototype : void 0;
    var symbolToString2 = symbolProto3 ? symbolProto3.toString : void 0;
    function baseToString2(value) {
      if (typeof value == "string") {
        return value;
      }
      if (isArray3(value)) {
        return arrayMap2(value, baseToString2) + "";
      }
      if (isSymbol2(value)) {
        return symbolToString2 ? symbolToString2.call(value) : "";
      }
      var result = value + "";
      return result == "0" && 1 / value == -INFINITY4 ? "-0" : result;
    }
    module2.exports = baseToString2;
  }
});

// node_modules/lodash/toString.js
var require_toString = __commonJS({
  "node_modules/lodash/toString.js"(exports2, module2) {
    "use strict";
    var baseToString2 = require_baseToString();
    function toString4(value) {
      return value == null ? "" : baseToString2(value);
    }
    module2.exports = toString4;
  }
});

// node_modules/lodash/uniqueId.js
var require_uniqueId = __commonJS({
  "node_modules/lodash/uniqueId.js"(exports2, module2) {
    "use strict";
    var toString4 = require_toString();
    var idCounter = 0;
    function uniqueId(prefix) {
      var id = ++idCounter;
      return toString4(prefix) + id;
    }
    module2.exports = uniqueId;
  }
});

// node_modules/knex/lib/util/timeout.js
var require_timeout = __commonJS({
  "node_modules/knex/lib/util/timeout.js"(exports2, module2) {
    "use strict";
    var KnexTimeoutError = class extends Error {
      constructor(message) {
        super(message);
        this.name = "KnexTimeoutError";
      }
    };
    function timeout(promise3, ms) {
      return new Promise(function(resolve3, reject) {
        const id = setTimeout(function() {
          reject(new KnexTimeoutError("operation timed out"));
        }, ms);
        function wrappedResolve(value) {
          clearTimeout(id);
          resolve3(value);
        }
        function wrappedReject(err) {
          clearTimeout(id);
          reject(err);
        }
        promise3.then(wrappedResolve, wrappedReject);
      });
    }
    module2.exports.KnexTimeoutError = KnexTimeoutError;
    module2.exports.timeout = timeout;
  }
});

// node_modules/knex/lib/execution/internal/ensure-connection-callback.js
var require_ensure_connection_callback = __commonJS({
  "node_modules/knex/lib/execution/internal/ensure-connection-callback.js"(exports2, module2) {
    "use strict";
    function ensureConnectionCallback(runner) {
      runner.client.emit("start", runner.builder);
      runner.builder.emit("start", runner.builder);
      const sql = runner.builder.toSQL();
      if (runner.builder._debug) {
        runner.client.logger.debug(sql);
      }
      if (Array.isArray(sql)) {
        return runner.queryArray(sql);
      }
      return runner.query(sql);
    }
    function ensureConnectionStreamCallback(runner, params) {
      try {
        const sql = runner.builder.toSQL();
        if (Array.isArray(sql) && params.hasHandler) {
          throw new Error(
            "The stream may only be used with a single query statement."
          );
        }
        return runner.client.stream(
          runner.connection,
          sql,
          params.stream,
          params.options
        );
      } catch (e) {
        params.stream.emit("error", e);
        throw e;
      }
    }
    module2.exports = {
      ensureConnectionCallback,
      ensureConnectionStreamCallback
    };
  }
});

// node_modules/knex/lib/execution/runner.js
var require_runner = __commonJS({
  "node_modules/knex/lib/execution/runner.js"(exports2, module2) {
    "use strict";
    var { KnexTimeoutError } = require_timeout();
    var { timeout } = require_timeout();
    var {
      ensureConnectionCallback,
      ensureConnectionStreamCallback
    } = require_ensure_connection_callback();
    var Transform;
    var Runner = class _Runner {
      constructor(client, builder) {
        this.client = client;
        this.builder = builder;
        this.queries = [];
        this.connection = void 0;
      }
      // "Run" the target, calling "toSQL" on the builder, returning
      // an object or array of queries to run, each of which are run on
      // a single connection.
      async run() {
        const runner = this;
        try {
          const res = await this.ensureConnection(ensureConnectionCallback);
          runner.builder.emit("end");
          return res;
        } catch (err) {
          if (runner.builder._events && runner.builder._events.error) {
            runner.builder.emit("error", err);
          }
          throw err;
        }
      }
      // Stream the result set, by passing through to the dialect's streaming
      // capabilities. If the options are
      stream(optionsOrHandler, handlerOrNil) {
        const firstOptionIsHandler = typeof optionsOrHandler === "function" && arguments.length === 1;
        const options = firstOptionIsHandler ? {} : optionsOrHandler;
        const handler = firstOptionIsHandler ? optionsOrHandler : handlerOrNil;
        const hasHandler = typeof handler === "function";
        Transform = Transform || require("stream").Transform;
        const queryContext = this.builder.queryContext();
        const stream4 = new Transform({
          objectMode: true,
          transform: (chunk, _, callback) => {
            callback(null, this.client.postProcessResponse(chunk, queryContext));
          }
        });
        stream4.on("close", () => {
          this.client.releaseConnection(this.connection);
        });
        stream4.on("pipe", (sourceStream) => {
          const cleanSourceStream = () => {
            if (!sourceStream.closed) {
              sourceStream.destroy();
            }
          };
          if (stream4.closed) {
            cleanSourceStream();
          } else {
            stream4.on("close", cleanSourceStream);
          }
        });
        const connectionAcquirePromise = this.ensureConnection(
          ensureConnectionStreamCallback,
          {
            options,
            hasHandler,
            stream: stream4
          }
        ).catch((err) => {
          if (!this.connection) {
            stream4.emit("error", err);
          }
        });
        if (hasHandler) {
          handler(stream4);
          return connectionAcquirePromise;
        }
        return stream4;
      }
      // Allow you to pipe the stream to a writable stream.
      pipe(writable, options) {
        return this.stream(options).pipe(writable);
      }
      // "Runs" a query, returning a promise. All queries specified by the builder are guaranteed
      // to run in sequence, and on the same connection, especially helpful when schema building
      // and dealing with foreign key constraints, etc.
      async query(obj) {
        const { __knexUid, __knexTxId } = this.connection;
        this.builder.emit("query", Object.assign({ __knexUid, __knexTxId }, obj));
        const runner = this;
        const queryContext = this.builder.queryContext();
        if (obj !== null && typeof obj === "object") {
          obj.queryContext = queryContext;
        }
        let queryPromise = this.client.query(this.connection, obj);
        if (obj.timeout) {
          queryPromise = timeout(queryPromise, obj.timeout);
        }
        return queryPromise.then((resp) => this.client.processResponse(resp, runner)).then((processedResponse) => {
          const postProcessedResponse = this.client.postProcessResponse(
            processedResponse,
            queryContext
          );
          this.builder.emit(
            "query-response",
            postProcessedResponse,
            Object.assign({ __knexUid, __knexTxId }, obj),
            this.builder
          );
          this.client.emit(
            "query-response",
            postProcessedResponse,
            Object.assign({ __knexUid, __knexTxId }, obj),
            this.builder
          );
          return postProcessedResponse;
        }).catch((error73) => {
          if (!(error73 instanceof KnexTimeoutError)) {
            return Promise.reject(error73);
          }
          const { timeout: timeout2, sql, bindings } = obj;
          let cancelQuery;
          if (obj.cancelOnTimeout) {
            cancelQuery = this.client.cancelQuery(this.connection);
          } else {
            this.connection.__knex__disposed = error73;
            cancelQuery = Promise.resolve();
          }
          return cancelQuery.catch((cancelError) => {
            this.connection.__knex__disposed = error73;
            throw Object.assign(cancelError, {
              message: `After query timeout of ${timeout2}ms exceeded, cancelling of query failed.`,
              sql,
              bindings,
              timeout: timeout2
            });
          }).then(() => {
            throw Object.assign(error73, {
              message: `Defined query timeout of ${timeout2}ms exceeded when running query.`,
              sql,
              bindings,
              timeout: timeout2
            });
          });
        }).catch((error73) => {
          this.builder.emit(
            "query-error",
            error73,
            Object.assign({ __knexUid, __knexTxId, queryContext }, obj)
          );
          throw error73;
        });
      }
      // In the case of the "schema builder" we call `queryArray`, which runs each
      // of the queries in sequence.
      async queryArray(queries) {
        if (queries.length === 1) {
          const query = queries[0];
          if (!query.statementsProducer) {
            return this.query(query);
          }
          const statements = await query.statementsProducer(
            void 0,
            this.connection
          );
          const sqlQueryObjects = statements.sql.map((statement) => ({
            sql: statement,
            bindings: query.bindings
          }));
          const preQueryObjects = statements.pre.map((statement) => ({
            sql: statement,
            bindings: query.bindings
          }));
          const postQueryObjects = statements.post.map((statement) => ({
            sql: statement,
            bindings: query.bindings
          }));
          let results2 = [];
          await this.queryArray(preQueryObjects);
          try {
            await this.client.transaction(
              async (trx) => {
                const transactionRunner = new _Runner(trx.client, this.builder);
                transactionRunner.connection = this.connection;
                results2 = await transactionRunner.queryArray(sqlQueryObjects);
                if (statements.check) {
                  const foreignViolations = await trx.raw(statements.check);
                  if (foreignViolations.length > 0) {
                    throw new Error("FOREIGN KEY constraint failed");
                  }
                }
              },
              { connection: this.connection }
            );
          } finally {
            await this.queryArray(postQueryObjects);
          }
          return results2;
        }
        const results = [];
        for (const query of queries) {
          results.push(await this.queryArray([query]));
        }
        return results;
      }
      // Check whether there's a transaction flag, and that it has a connection.
      async ensureConnection(cb, cbParams) {
        if (this.builder._connection) {
          this.connection = this.builder._connection;
        }
        if (this.connection) {
          return cb(this, cbParams);
        }
        let acquiredConnection;
        try {
          acquiredConnection = await this.client.acquireConnection();
        } catch (error73) {
          if (!(error73 instanceof KnexTimeoutError)) {
            return Promise.reject(error73);
          }
          if (this.builder) {
            error73.sql = this.builder.sql;
            error73.bindings = this.builder.bindings;
          }
          throw error73;
        }
        try {
          this.connection = acquiredConnection;
          return await cb(this, cbParams);
        } finally {
          await this.client.releaseConnection(acquiredConnection);
        }
      }
    };
    module2.exports = Runner;
  }
});

// node_modules/knex/node_modules/ms/index.js
var require_ms3 = __commonJS({
  "node_modules/knex/node_modules/ms/index.js"(exports2, module2) {
    "use strict";
    var s = 1e3;
    var m = s * 60;
    var h = m * 60;
    var d = h * 24;
    var w = d * 7;
    var y = d * 365.25;
    module2.exports = function(val, options) {
      options = options || {};
      var type = typeof val;
      if (type === "string" && val.length > 0) {
        return parse4(val);
      } else if (type === "number" && isFinite(val)) {
        return options.long ? fmtLong(val) : fmtShort(val);
      }
      throw new Error(
        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
      );
    };
    function parse4(str) {
      str = String(str);
      if (str.length > 100) {
        return;
      }
      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
        str
      );
      if (!match) {
        return;
      }
      var n = parseFloat(match[1]);
      var type = (match[2] || "ms").toLowerCase();
      switch (type) {
        case "years":
        case "year":
        case "yrs":
        case "yr":
        case "y":
          return n * y;
        case "weeks":
        case "week":
        case "w":
          return n * w;
        case "days":
        case "day":
        case "d":
          return n * d;
        case "hours":
        case "hour":
        case "hrs":
        case "hr":
        case "h":
          return n * h;
        case "minutes":
        case "minute":
        case "mins":
        case "min":
        case "m":
          return n * m;
        case "seconds":
        case "second":
        case "secs":
        case "sec":
        case "s":
          return n * s;
        case "milliseconds":
        case "millisecond":
        case "msecs":
        case "msec":
        case "ms":
          return n;
        default:
          return void 0;
      }
    }
    function fmtShort(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d) {
        return Math.round(ms / d) + "d";
      }
      if (msAbs >= h) {
        return Math.round(ms / h) + "h";
      }
      if (msAbs >= m) {
        return Math.round(ms / m) + "m";
      }
      if (msAbs >= s) {
        return Math.round(ms / s) + "s";
      }
      return ms + "ms";
    }
    function fmtLong(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d) {
        return plural(ms, msAbs, d, "day");
      }
      if (msAbs >= h) {
        return plural(ms, msAbs, h, "hour");
      }
      if (msAbs >= m) {
        return plural(ms, msAbs, m, "minute");
      }
      if (msAbs >= s) {
        return plural(ms, msAbs, s, "second");
      }
      return ms + " ms";
    }
    function plural(ms, msAbs, n, name28) {
      var isPlural = msAbs >= n * 1.5;
      return Math.round(ms / n) + " " + name28 + (isPlural ? "s" : "");
    }
  }
});

// node_modules/knex/node_modules/debug/src/common.js
var require_common4 = __commonJS({
  "node_modules/knex/node_modules/debug/src/common.js"(exports2, module2) {
    "use strict";
    function setup(env2) {
      createDebug.debug = createDebug;
      createDebug.default = createDebug;
      createDebug.coerce = coerce;
      createDebug.disable = disable;
      createDebug.enable = enable;
      createDebug.enabled = enabled;
      createDebug.humanize = require_ms3();
      createDebug.destroy = destroy;
      Object.keys(env2).forEach((key) => {
        createDebug[key] = env2[key];
      });
      createDebug.names = [];
      createDebug.skips = [];
      createDebug.formatters = {};
      function selectColor(namespace) {
        let hash3 = 0;
        for (let i = 0; i < namespace.length; i++) {
          hash3 = (hash3 << 5) - hash3 + namespace.charCodeAt(i);
          hash3 |= 0;
        }
        return createDebug.colors[Math.abs(hash3) % createDebug.colors.length];
      }
      createDebug.selectColor = selectColor;
      function createDebug(namespace) {
        let prevTime;
        let enableOverride = null;
        let namespacesCache;
        let enabledCache;
        function debug(...args) {
          if (!debug.enabled) {
            return;
          }
          const self2 = debug;
          const curr = Number(/* @__PURE__ */ new Date());
          const ms = curr - (prevTime || curr);
          self2.diff = ms;
          self2.prev = prevTime;
          self2.curr = curr;
          prevTime = curr;
          args[0] = createDebug.coerce(args[0]);
          if (typeof args[0] !== "string") {
            args.unshift("%O");
          }
          let index = 0;
          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
            if (match === "%%") {
              return "%";
            }
            index++;
            const formatter = createDebug.formatters[format];
            if (typeof formatter === "function") {
              const val = args[index];
              match = formatter.call(self2, val);
              args.splice(index, 1);
              index--;
            }
            return match;
          });
          createDebug.formatArgs.call(self2, args);
          const logFn = self2.log || createDebug.log;
          logFn.apply(self2, args);
        }
        debug.namespace = namespace;
        debug.useColors = createDebug.useColors();
        debug.color = createDebug.selectColor(namespace);
        debug.extend = extend4;
        debug.destroy = createDebug.destroy;
        Object.defineProperty(debug, "enabled", {
          enumerable: true,
          configurable: false,
          get: () => {
            if (enableOverride !== null) {
              return enableOverride;
            }
            if (namespacesCache !== createDebug.namespaces) {
              namespacesCache = createDebug.namespaces;
              enabledCache = createDebug.enabled(namespace);
            }
            return enabledCache;
          },
          set: (v) => {
            enableOverride = v;
          }
        });
        if (typeof createDebug.init === "function") {
          createDebug.init(debug);
        }
        return debug;
      }
      function extend4(namespace, delimiter) {
        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
        newDebug.log = this.log;
        return newDebug;
      }
      function enable(namespaces) {
        createDebug.save(namespaces);
        createDebug.namespaces = namespaces;
        createDebug.names = [];
        createDebug.skips = [];
        let i;
        const split2 = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
        const len = split2.length;
        for (i = 0; i < len; i++) {
          if (!split2[i]) {
            continue;
          }
          namespaces = split2[i].replace(/\*/g, ".*?");
          if (namespaces[0] === "-") {
            createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
          } else {
            createDebug.names.push(new RegExp("^" + namespaces + "$"));
          }
        }
      }
      function disable() {
        const namespaces = [
          ...createDebug.names.map(toNamespace),
          ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
        ].join(",");
        createDebug.enable("");
        return namespaces;
      }
      function enabled(name28) {
        if (name28[name28.length - 1] === "*") {
          return true;
        }
        let i;
        let len;
        for (i = 0, len = createDebug.skips.length; i < len; i++) {
          if (createDebug.skips[i].test(name28)) {
            return false;
          }
        }
        for (i = 0, len = createDebug.names.length; i < len; i++) {
          if (createDebug.names[i].test(name28)) {
            return true;
          }
        }
        return false;
      }
      function toNamespace(regexp) {
        return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
      }
      function coerce(val) {
        if (val instanceof Error) {
          return val.stack || val.message;
        }
        return val;
      }
      function destroy() {
        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
      }
      createDebug.enable(createDebug.load());
      return createDebug;
    }
    module2.exports = setup;
  }
});

// node_modules/knex/node_modules/debug/src/browser.js
var require_browser3 = __commonJS({
  "node_modules/knex/node_modules/debug/src/browser.js"(exports2, module2) {
    "use strict";
    exports2.formatArgs = formatArgs;
    exports2.save = save;
    exports2.load = load;
    exports2.useColors = useColors;
    exports2.storage = localstorage();
    exports2.destroy = /* @__PURE__ */ (() => {
      let warned = false;
      return () => {
        if (!warned) {
          warned = true;
          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
        }
      };
    })();
    exports2.colors = [
      "#0000CC",
      "#0000FF",
      "#0033CC",
      "#0033FF",
      "#0066CC",
      "#0066FF",
      "#0099CC",
      "#0099FF",
      "#00CC00",
      "#00CC33",
      "#00CC66",
      "#00CC99",
      "#00CCCC",
      "#00CCFF",
      "#3300CC",
      "#3300FF",
      "#3333CC",
      "#3333FF",
      "#3366CC",
      "#3366FF",
      "#3399CC",
      "#3399FF",
      "#33CC00",
      "#33CC33",
      "#33CC66",
      "#33CC99",
      "#33CCCC",
      "#33CCFF",
      "#6600CC",
      "#6600FF",
      "#6633CC",
      "#6633FF",
      "#66CC00",
      "#66CC33",
      "#9900CC",
      "#9900FF",
      "#9933CC",
      "#9933FF",
      "#99CC00",
      "#99CC33",
      "#CC0000",
      "#CC0033",
      "#CC0066",
      "#CC0099",
      "#CC00CC",
      "#CC00FF",
      "#CC3300",
      "#CC3333",
      "#CC3366",
      "#CC3399",
      "#CC33CC",
      "#CC33FF",
      "#CC6600",
      "#CC6633",
      "#CC9900",
      "#CC9933",
      "#CCCC00",
      "#CCCC33",
      "#FF0000",
      "#FF0033",
      "#FF0066",
      "#FF0099",
      "#FF00CC",
      "#FF00FF",
      "#FF3300",
      "#FF3333",
      "#FF3366",
      "#FF3399",
      "#FF33CC",
      "#FF33FF",
      "#FF6600",
      "#FF6633",
      "#FF9900",
      "#FF9933",
      "#FFCC00",
      "#FFCC33"
    ];
    function useColors() {
      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
        return true;
      }
      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
        return false;
      }
      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
    }
    function formatArgs(args) {
      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
      if (!this.useColors) {
        return;
      }
      const c = "color: " + this.color;
      args.splice(1, 0, c, "color: inherit");
      let index = 0;
      let lastC = 0;
      args[0].replace(/%[a-zA-Z%]/g, (match) => {
        if (match === "%%") {
          return;
        }
        index++;
        if (match === "%c") {
          lastC = index;
        }
      });
      args.splice(lastC, 0, c);
    }
    exports2.log = console.debug || console.log || (() => {
    });
    function save(namespaces) {
      try {
        if (namespaces) {
          exports2.storage.setItem("debug", namespaces);
        } else {
          exports2.storage.removeItem("debug");
        }
      } catch (error73) {
      }
    }
    function load() {
      let r;
      try {
        r = exports2.storage.getItem("debug");
      } catch (error73) {
      }
      if (!r && typeof process !== "undefined" && "env" in process) {
        r = process.env.DEBUG;
      }
      return r;
    }
    function localstorage() {
      try {
        return localStorage;
      } catch (error73) {
      }
    }
    module2.exports = require_common4()(exports2);
    var { formatters } = module2.exports;
    formatters.j = function(v) {
      try {
        return JSON.stringify(v);
      } catch (error73) {
        return "[UnexpectedJSONParseError]: " + error73.message;
      }
    };
  }
});

// node_modules/knex/node_modules/debug/src/node.js
var require_node3 = __commonJS({
  "node_modules/knex/node_modules/debug/src/node.js"(exports2, module2) {
    "use strict";
    var tty = require("tty");
    var util4 = require("util");
    exports2.init = init;
    exports2.log = log;
    exports2.formatArgs = formatArgs;
    exports2.save = save;
    exports2.load = load;
    exports2.useColors = useColors;
    exports2.destroy = util4.deprecate(
      () => {
      },
      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
    );
    exports2.colors = [6, 2, 3, 4, 5, 1];
    try {
      const supportsColor = require_supports_color();
      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
        exports2.colors = [
          20,
          21,
          26,
          27,
          32,
          33,
          38,
          39,
          40,
          41,
          42,
          43,
          44,
          45,
          56,
          57,
          62,
          63,
          68,
          69,
          74,
          75,
          76,
          77,
          78,
          79,
          80,
          81,
          92,
          93,
          98,
          99,
          112,
          113,
          128,
          129,
          134,
          135,
          148,
          149,
          160,
          161,
          162,
          163,
          164,
          165,
          166,
          167,
          168,
          169,
          170,
          171,
          172,
          173,
          178,
          179,
          184,
          185,
          196,
          197,
          198,
          199,
          200,
          201,
          202,
          203,
          204,
          205,
          206,
          207,
          208,
          209,
          214,
          215,
          220,
          221
        ];
      }
    } catch (error73) {
    }
    exports2.inspectOpts = Object.keys(process.env).filter((key) => {
      return /^debug_/i.test(key);
    }).reduce((obj, key) => {
      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
        return k.toUpperCase();
      });
      let val = process.env[key];
      if (/^(yes|on|true|enabled)$/i.test(val)) {
        val = true;
      } else if (/^(no|off|false|disabled)$/i.test(val)) {
        val = false;
      } else if (val === "null") {
        val = null;
      } else {
        val = Number(val);
      }
      obj[prop] = val;
      return obj;
    }, {});
    function useColors() {
      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(process.stderr.fd);
    }
    function formatArgs(args) {
      const { namespace: name28, useColors: useColors2 } = this;
      if (useColors2) {
        const c = this.color;
        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
        const prefix = `  ${colorCode};1m${name28} \x1B[0m`;
        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
        args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
      } else {
        args[0] = getDate() + name28 + " " + args[0];
      }
    }
    function getDate() {
      if (exports2.inspectOpts.hideDate) {
        return "";
      }
      return (/* @__PURE__ */ new Date()).toISOString() + " ";
    }
    function log(...args) {
      return process.stderr.write(util4.format(...args) + "\n");
    }
    function save(namespaces) {
      if (namespaces) {
        process.env.DEBUG = namespaces;
      } else {
        delete process.env.DEBUG;
      }
    }
    function load() {
      return process.env.DEBUG;
    }
    function init(debug) {
      debug.inspectOpts = {};
      const keys2 = Object.keys(exports2.inspectOpts);
      for (let i = 0; i < keys2.length; i++) {
        debug.inspectOpts[keys2[i]] = exports2.inspectOpts[keys2[i]];
      }
    }
    module2.exports = require_common4()(exports2);
    var { formatters } = module2.exports;
    formatters.o = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
    };
    formatters.O = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v, this.inspectOpts);
    };
  }
});

// node_modules/knex/node_modules/debug/src/index.js
var require_src3 = __commonJS({
  "node_modules/knex/node_modules/debug/src/index.js"(exports2, module2) {
    "use strict";
    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
      module2.exports = require_browser3();
    } else {
      module2.exports = require_node3();
    }
  }
});

// node_modules/lodash/_setCacheAdd.js
var require_setCacheAdd = __commonJS({
  "node_modules/lodash/_setCacheAdd.js"(exports2, module2) {
    "use strict";
    var HASH_UNDEFINED4 = "__lodash_hash_undefined__";
    function setCacheAdd2(value) {
      this.__data__.set(value, HASH_UNDEFINED4);
      return this;
    }
    module2.exports = setCacheAdd2;
  }
});

// node_modules/lodash/_setCacheHas.js
var require_setCacheHas = __commonJS({
  "node_modules/lodash/_setCacheHas.js"(exports2, module2) {
    "use strict";
    function setCacheHas2(value) {
      return this.__data__.has(value);
    }
    module2.exports = setCacheHas2;
  }
});

// node_modules/lodash/_SetCache.js
var require_SetCache = __commonJS({
  "node_modules/lodash/_SetCache.js"(exports2, module2) {
    "use strict";
    var MapCache2 = require_MapCache();
    var setCacheAdd2 = require_setCacheAdd();
    var setCacheHas2 = require_setCacheHas();
    function SetCache2(values) {
      var index = -1, length = values == null ? 0 : values.length;
      this.__data__ = new MapCache2();
      while (++index < length) {
        this.add(values[index]);
      }
    }
    SetCache2.prototype.add = SetCache2.prototype.push = setCacheAdd2;
    SetCache2.prototype.has = setCacheHas2;
    module2.exports = SetCache2;
  }
});

// node_modules/lodash/_baseFindIndex.js
var require_baseFindIndex = __commonJS({
  "node_modules/lodash/_baseFindIndex.js"(exports2, module2) {
    "use strict";
    function baseFindIndex2(array4, predicate, fromIndex, fromRight) {
      var length = array4.length, index = fromIndex + (fromRight ? 1 : -1);
      while (fromRight ? index-- : ++index < length) {
        if (predicate(array4[index], index, array4)) {
          return index;
        }
      }
      return -1;
    }
    module2.exports = baseFindIndex2;
  }
});

// node_modules/lodash/_baseIsNaN.js
var require_baseIsNaN = __commonJS({
  "node_modules/lodash/_baseIsNaN.js"(exports2, module2) {
    "use strict";
    function baseIsNaN2(value) {
      return value !== value;
    }
    module2.exports = baseIsNaN2;
  }
});

// node_modules/lodash/_strictIndexOf.js
var require_strictIndexOf = __commonJS({
  "node_modules/lodash/_strictIndexOf.js"(exports2, module2) {
    "use strict";
    function strictIndexOf2(array4, value, fromIndex) {
      var index = fromIndex - 1, length = array4.length;
      while (++index < length) {
        if (array4[index] === value) {
          return index;
        }
      }
      return -1;
    }
    module2.exports = strictIndexOf2;
  }
});

// node_modules/lodash/_baseIndexOf.js
var require_baseIndexOf = __commonJS({
  "node_modules/lodash/_baseIndexOf.js"(exports2, module2) {
    "use strict";
    var baseFindIndex2 = require_baseFindIndex();
    var baseIsNaN2 = require_baseIsNaN();
    var strictIndexOf2 = require_strictIndexOf();
    function baseIndexOf2(array4, value, fromIndex) {
      return value === value ? strictIndexOf2(array4, value, fromIndex) : baseFindIndex2(array4, baseIsNaN2, fromIndex);
    }
    module2.exports = baseIndexOf2;
  }
});

// node_modules/lodash/_arrayIncludes.js
var require_arrayIncludes = __commonJS({
  "node_modules/lodash/_arrayIncludes.js"(exports2, module2) {
    "use strict";
    var baseIndexOf2 = require_baseIndexOf();
    function arrayIncludes2(array4, value) {
      var length = array4 == null ? 0 : array4.length;
      return !!length && baseIndexOf2(array4, value, 0) > -1;
    }
    module2.exports = arrayIncludes2;
  }
});

// node_modules/lodash/_arrayIncludesWith.js
var require_arrayIncludesWith = __commonJS({
  "node_modules/lodash/_arrayIncludesWith.js"(exports2, module2) {
    "use strict";
    function arrayIncludesWith2(array4, value, comparator) {
      var index = -1, length = array4 == null ? 0 : array4.length;
      while (++index < length) {
        if (comparator(value, array4[index])) {
          return true;
        }
      }
      return false;
    }
    module2.exports = arrayIncludesWith2;
  }
});

// node_modules/lodash/_cacheHas.js
var require_cacheHas = __commonJS({
  "node_modules/lodash/_cacheHas.js"(exports2, module2) {
    "use strict";
    function cacheHas2(cache, key) {
      return cache.has(key);
    }
    module2.exports = cacheHas2;
  }
});

// node_modules/lodash/_baseDifference.js
var require_baseDifference = __commonJS({
  "node_modules/lodash/_baseDifference.js"(exports2, module2) {
    "use strict";
    var SetCache2 = require_SetCache();
    var arrayIncludes2 = require_arrayIncludes();
    var arrayIncludesWith2 = require_arrayIncludesWith();
    var arrayMap2 = require_arrayMap();
    var baseUnary2 = require_baseUnary();
    var cacheHas2 = require_cacheHas();
    var LARGE_ARRAY_SIZE3 = 200;
    function baseDifference(array4, values, iteratee, comparator) {
      var index = -1, includes = arrayIncludes2, isCommon = true, length = array4.length, result = [], valuesLength = values.length;
      if (!length) {
        return result;
      }
      if (iteratee) {
        values = arrayMap2(values, baseUnary2(iteratee));
      }
      if (comparator) {
        includes = arrayIncludesWith2;
        isCommon = false;
      } else if (values.length >= LARGE_ARRAY_SIZE3) {
        includes = cacheHas2;
        isCommon = false;
        values = new SetCache2(values);
      }
      outer:
        while (++index < length) {
          var value = array4[index], computed = iteratee == null ? value : iteratee(value);
          value = comparator || value !== 0 ? value : 0;
          if (isCommon && computed === computed) {
            var valuesIndex = valuesLength;
            while (valuesIndex--) {
              if (values[valuesIndex] === computed) {
                continue outer;
              }
            }
            result.push(value);
          } else if (!includes(values, computed, comparator)) {
            result.push(value);
          }
        }
      return result;
    }
    module2.exports = baseDifference;
  }
});

// node_modules/lodash/_isFlattenable.js
var require_isFlattenable = __commonJS({
  "node_modules/lodash/_isFlattenable.js"(exports2, module2) {
    "use strict";
    var Symbol3 = require_Symbol();
    var isArguments2 = require_isArguments();
    var isArray3 = require_isArray();
    var spreadableSymbol = Symbol3 ? Symbol3.isConcatSpreadable : void 0;
    function isFlattenable(value) {
      return isArray3(value) || isArguments2(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
    }
    module2.exports = isFlattenable;
  }
});

// node_modules/lodash/_baseFlatten.js
var require_baseFlatten = __commonJS({
  "node_modules/lodash/_baseFlatten.js"(exports2, module2) {
    "use strict";
    var arrayPush2 = require_arrayPush();
    var isFlattenable = require_isFlattenable();
    function baseFlatten(array4, depth, predicate, isStrict, result) {
      var index = -1, length = array4.length;
      predicate || (predicate = isFlattenable);
      result || (result = []);
      while (++index < length) {
        var value = array4[index];
        if (depth > 0 && predicate(value)) {
          if (depth > 1) {
            baseFlatten(value, depth - 1, predicate, isStrict, result);
          } else {
            arrayPush2(result, value);
          }
        } else if (!isStrict) {
          result[result.length] = value;
        }
      }
      return result;
    }
    module2.exports = baseFlatten;
  }
});

// node_modules/lodash/isArrayLikeObject.js
var require_isArrayLikeObject = __commonJS({
  "node_modules/lodash/isArrayLikeObject.js"(exports2, module2) {
    "use strict";
    var isArrayLike2 = require_isArrayLike();
    var isObjectLike2 = require_isObjectLike();
    function isArrayLikeObject(value) {
      return isObjectLike2(value) && isArrayLike2(value);
    }
    module2.exports = isArrayLikeObject;
  }
});

// node_modules/lodash/last.js
var require_last = __commonJS({
  "node_modules/lodash/last.js"(exports2, module2) {
    "use strict";
    function last(array4) {
      var length = array4 == null ? 0 : array4.length;
      return length ? array4[length - 1] : void 0;
    }
    module2.exports = last;
  }
});

// node_modules/lodash/differenceWith.js
var require_differenceWith = __commonJS({
  "node_modules/lodash/differenceWith.js"(exports2, module2) {
    "use strict";
    var baseDifference = require_baseDifference();
    var baseFlatten = require_baseFlatten();
    var baseRest = require_baseRest();
    var isArrayLikeObject = require_isArrayLikeObject();
    var last = require_last();
    var differenceWith = baseRest(function(array4, values) {
      var comparator = last(values);
      if (isArrayLikeObject(comparator)) {
        comparator = void 0;
      }
      return isArrayLikeObject(array4) ? baseDifference(array4, baseFlatten(values, 1, isArrayLikeObject, true), void 0, comparator) : [];
    });
    module2.exports = differenceWith;
  }
});

// node_modules/lodash/_isKey.js
var require_isKey = __commonJS({
  "node_modules/lodash/_isKey.js"(exports2, module2) {
    "use strict";
    var isArray3 = require_isArray();
    var isSymbol2 = require_isSymbol();
    var reIsDeepProp2 = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
    var reIsPlainProp2 = /^\w*$/;
    function isKey2(value, object4) {
      if (isArray3(value)) {
        return false;
      }
      var type = typeof value;
      if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol2(value)) {
        return true;
      }
      return reIsPlainProp2.test(value) || !reIsDeepProp2.test(value) || object4 != null && value in Object(object4);
    }
    module2.exports = isKey2;
  }
});

// node_modules/lodash/memoize.js
var require_memoize = __commonJS({
  "node_modules/lodash/memoize.js"(exports2, module2) {
    "use strict";
    var MapCache2 = require_MapCache();
    var FUNC_ERROR_TEXT2 = "Expected a function";
    function memoize2(func, resolver) {
      if (typeof func != "function" || resolver != null && typeof resolver != "function") {
        throw new TypeError(FUNC_ERROR_TEXT2);
      }
      var memoized = function() {
        var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
        if (cache.has(key)) {
          return cache.get(key);
        }
        var result = func.apply(this, args);
        memoized.cache = cache.set(key, result) || cache;
        return result;
      };
      memoized.cache = new (memoize2.Cache || MapCache2)();
      return memoized;
    }
    memoize2.Cache = MapCache2;
    module2.exports = memoize2;
  }
});

// node_modules/lodash/_memoizeCapped.js
var require_memoizeCapped = __commonJS({
  "node_modules/lodash/_memoizeCapped.js"(exports2, module2) {
    "use strict";
    var memoize2 = require_memoize();
    var MAX_MEMOIZE_SIZE2 = 500;
    function memoizeCapped2(func) {
      var result = memoize2(func, function(key) {
        if (cache.size === MAX_MEMOIZE_SIZE2) {
          cache.clear();
        }
        return key;
      });
      var cache = result.cache;
      return result;
    }
    module2.exports = memoizeCapped2;
  }
});

// node_modules/lodash/_stringToPath.js
var require_stringToPath = __commonJS({
  "node_modules/lodash/_stringToPath.js"(exports2, module2) {
    "use strict";
    var memoizeCapped2 = require_memoizeCapped();
    var rePropName2 = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
    var reEscapeChar2 = /\\(\\)?/g;
    var stringToPath2 = memoizeCapped2(function(string5) {
      var result = [];
      if (string5.charCodeAt(0) === 46) {
        result.push("");
      }
      string5.replace(rePropName2, function(match, number5, quote, subString) {
        result.push(quote ? subString.replace(reEscapeChar2, "$1") : number5 || match);
      });
      return result;
    });
    module2.exports = stringToPath2;
  }
});

// node_modules/lodash/_castPath.js
var require_castPath = __commonJS({
  "node_modules/lodash/_castPath.js"(exports2, module2) {
    "use strict";
    var isArray3 = require_isArray();
    var isKey2 = require_isKey();
    var stringToPath2 = require_stringToPath();
    var toString4 = require_toString();
    function castPath2(value, object4) {
      if (isArray3(value)) {
        return value;
      }
      return isKey2(value, object4) ? [value] : stringToPath2(toString4(value));
    }
    module2.exports = castPath2;
  }
});

// node_modules/lodash/_toKey.js
var require_toKey = __commonJS({
  "node_modules/lodash/_toKey.js"(exports2, module2) {
    "use strict";
    var isSymbol2 = require_isSymbol();
    var INFINITY4 = 1 / 0;
    function toKey2(value) {
      if (typeof value == "string" || isSymbol2(value)) {
        return value;
      }
      var result = value + "";
      return result == "0" && 1 / value == -INFINITY4 ? "-0" : result;
    }
    module2.exports = toKey2;
  }
});

// node_modules/lodash/_baseGet.js
var require_baseGet = __commonJS({
  "node_modules/lodash/_baseGet.js"(exports2, module2) {
    "use strict";
    var castPath2 = require_castPath();
    var toKey2 = require_toKey();
    function baseGet2(object4, path33) {
      path33 = castPath2(path33, object4);
      var index = 0, length = path33.length;
      while (object4 != null && index < length) {
        object4 = object4[toKey2(path33[index++])];
      }
      return index && index == length ? object4 : void 0;
    }
    module2.exports = baseGet2;
  }
});

// node_modules/lodash/get.js
var require_get2 = __commonJS({
  "node_modules/lodash/get.js"(exports2, module2) {
    "use strict";
    var baseGet2 = require_baseGet();
    function get2(object4, path33, defaultValue) {
      var result = object4 == null ? void 0 : baseGet2(object4, path33);
      return result === void 0 ? defaultValue : result;
    }
    module2.exports = get2;
  }
});

// node_modules/lodash/isEmpty.js
var require_isEmpty = __commonJS({
  "node_modules/lodash/isEmpty.js"(exports2, module2) {
    "use strict";
    var baseKeys2 = require_baseKeys();
    var getTag2 = require_getTag();
    var isArguments2 = require_isArguments();
    var isArray3 = require_isArray();
    var isArrayLike2 = require_isArrayLike();
    var isBuffer3 = require_isBuffer();
    var isPrototype2 = require_isPrototype();
    var isTypedArray3 = require_isTypedArray();
    var mapTag4 = "[object Map]";
    var setTag4 = "[object Set]";
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function isEmpty(value) {
      if (value == null) {
        return true;
      }
      if (isArrayLike2(value) && (isArray3(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer3(value) || isTypedArray3(value) || isArguments2(value))) {
        return !value.length;
      }
      var tag = getTag2(value);
      if (tag == mapTag4 || tag == setTag4) {
        return !value.size;
      }
      if (isPrototype2(value)) {
        return !baseKeys2(value).length;
      }
      for (var key in value) {
        if (hasOwnProperty11.call(value, key)) {
          return false;
        }
      }
      return true;
    }
    module2.exports = isEmpty;
  }
});

// node_modules/lodash/_baseExtremum.js
var require_baseExtremum = __commonJS({
  "node_modules/lodash/_baseExtremum.js"(exports2, module2) {
    "use strict";
    var isSymbol2 = require_isSymbol();
    function baseExtremum(array4, iteratee, comparator) {
      var index = -1, length = array4.length;
      while (++index < length) {
        var value = array4[index], current = iteratee(value);
        if (current != null && (computed === void 0 ? current === current && !isSymbol2(current) : comparator(current, computed))) {
          var computed = current, result = value;
        }
      }
      return result;
    }
    module2.exports = baseExtremum;
  }
});

// node_modules/lodash/_baseGt.js
var require_baseGt = __commonJS({
  "node_modules/lodash/_baseGt.js"(exports2, module2) {
    "use strict";
    function baseGt(value, other) {
      return value > other;
    }
    module2.exports = baseGt;
  }
});

// node_modules/lodash/max.js
var require_max2 = __commonJS({
  "node_modules/lodash/max.js"(exports2, module2) {
    "use strict";
    var baseExtremum = require_baseExtremum();
    var baseGt = require_baseGt();
    var identity2 = require_identity();
    function max(array4) {
      return array4 && array4.length ? baseExtremum(array4, identity2, baseGt) : void 0;
    }
    module2.exports = max;
  }
});

// node_modules/knex/lib/migrations/migrate/table-resolver.js
var require_table_resolver = __commonJS({
  "node_modules/knex/lib/migrations/migrate/table-resolver.js"(exports2, module2) {
    "use strict";
    function getTableName(tableName, schemaName) {
      return schemaName ? `${schemaName}.${tableName}` : tableName;
    }
    function getTable(trxOrKnex, tableName, schemaName) {
      return schemaName ? trxOrKnex(tableName).withSchema(schemaName) : trxOrKnex(tableName);
    }
    function getLockTableName(tableName) {
      return tableName + "_lock";
    }
    function getLockTableNameWithSchema(tableName, schemaName) {
      return schemaName ? schemaName + "." + getLockTableName(tableName) : getLockTableName(tableName);
    }
    module2.exports = {
      getLockTableName,
      getLockTableNameWithSchema,
      getTable,
      getTableName
    };
  }
});

// node_modules/knex/lib/migrations/migrate/table-creator.js
var require_table_creator = __commonJS({
  "node_modules/knex/lib/migrations/migrate/table-creator.js"(exports2, module2) {
    "use strict";
    var {
      getTable,
      getLockTableName,
      getLockTableNameWithSchema,
      getTableName
    } = require_table_resolver();
    function ensureTable(tableName, schemaName, trxOrKnex) {
      const lockTable = getLockTableName(tableName);
      return getSchemaBuilder(trxOrKnex, schemaName).hasTable(tableName).then((exists) => {
        return !exists && _createMigrationTable(tableName, schemaName, trxOrKnex);
      }).then(() => {
        return getSchemaBuilder(trxOrKnex, schemaName).hasTable(lockTable);
      }).then((exists) => {
        return !exists && _createMigrationLockTable(lockTable, schemaName, trxOrKnex);
      }).then(() => {
        return getTable(trxOrKnex, lockTable, schemaName).select("*");
      }).then((data) => {
        return !data.length && _insertLockRowIfNeeded(tableName, schemaName, trxOrKnex);
      });
    }
    function _createMigrationTable(tableName, schemaName, trxOrKnex) {
      return getSchemaBuilder(trxOrKnex, schemaName).createTable(
        getTableName(tableName),
        function(t) {
          t.increments();
          t.string("name");
          t.integer("batch");
          t.timestamp("migration_time");
        }
      );
    }
    function _createMigrationLockTable(tableName, schemaName, trxOrKnex) {
      return getSchemaBuilder(trxOrKnex, schemaName).createTable(
        tableName,
        function(t) {
          t.increments("index").primary();
          t.integer("is_locked");
        }
      );
    }
    function _insertLockRowIfNeeded(tableName, schemaName, trxOrKnex) {
      const lockTableWithSchema = getLockTableNameWithSchema(tableName, schemaName);
      return trxOrKnex.select("*").from(lockTableWithSchema).then((data) => {
        return !data.length ? trxOrKnex.from(lockTableWithSchema).insert({ is_locked: 0 }) : null;
      });
    }
    function getSchemaBuilder(trxOrKnex, schemaName) {
      return schemaName ? trxOrKnex.schema.withSchema(schemaName) : trxOrKnex.schema;
    }
    module2.exports = {
      ensureTable,
      getSchemaBuilder
    };
  }
});

// node_modules/knex/lib/migrations/migrate/migration-list-resolver.js
var require_migration_list_resolver = __commonJS({
  "node_modules/knex/lib/migrations/migrate/migration-list-resolver.js"(exports2, module2) {
    "use strict";
    var { getTableName } = require_table_resolver();
    var { ensureTable } = require_table_creator();
    function listAll(migrationSource, loadExtensions) {
      return migrationSource.getMigrations(loadExtensions);
    }
    async function listCompleted(tableName, schemaName, trxOrKnex) {
      await ensureTable(tableName, schemaName, trxOrKnex);
      return await trxOrKnex.from(getTableName(tableName, schemaName)).orderBy("id").select("name");
    }
    function listAllAndCompleted(config3, trxOrKnex) {
      return Promise.all([
        listAll(config3.migrationSource, config3.loadExtensions),
        listCompleted(config3.tableName, config3.schemaName, trxOrKnex)
      ]);
    }
    module2.exports = {
      listAll,
      listAllAndCompleted,
      listCompleted
    };
  }
});

// node_modules/lodash/_createAssigner.js
var require_createAssigner = __commonJS({
  "node_modules/lodash/_createAssigner.js"(exports2, module2) {
    "use strict";
    var baseRest = require_baseRest();
    var isIterateeCall = require_isIterateeCall();
    function createAssigner(assigner) {
      return baseRest(function(object4, sources) {
        var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
        customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
          customizer = length < 3 ? void 0 : customizer;
          length = 1;
        }
        object4 = Object(object4);
        while (++index < length) {
          var source = sources[index];
          if (source) {
            assigner(object4, source, index, customizer);
          }
        }
        return object4;
      });
    }
    module2.exports = createAssigner;
  }
});

// node_modules/lodash/assignInWith.js
var require_assignInWith = __commonJS({
  "node_modules/lodash/assignInWith.js"(exports2, module2) {
    "use strict";
    var copyObject = require_copyObject();
    var createAssigner = require_createAssigner();
    var keysIn = require_keysIn();
    var assignInWith = createAssigner(function(object4, source, srcIndex, customizer) {
      copyObject(source, keysIn(source), object4, customizer);
    });
    module2.exports = assignInWith;
  }
});

// node_modules/lodash/isPlainObject.js
var require_isPlainObject = __commonJS({
  "node_modules/lodash/isPlainObject.js"(exports2, module2) {
    "use strict";
    var baseGetTag2 = require_baseGetTag();
    var getPrototype = require_getPrototype();
    var isObjectLike2 = require_isObjectLike();
    var objectTag4 = "[object Object]";
    var funcProto3 = Function.prototype;
    var objectProto13 = Object.prototype;
    var funcToString3 = funcProto3.toString;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    var objectCtorString = funcToString3.call(Object);
    function isPlainObject4(value) {
      if (!isObjectLike2(value) || baseGetTag2(value) != objectTag4) {
        return false;
      }
      var proto = getPrototype(value);
      if (proto === null) {
        return true;
      }
      var Ctor = hasOwnProperty11.call(proto, "constructor") && proto.constructor;
      return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString3.call(Ctor) == objectCtorString;
    }
    module2.exports = isPlainObject4;
  }
});

// node_modules/lodash/isError.js
var require_isError = __commonJS({
  "node_modules/lodash/isError.js"(exports2, module2) {
    "use strict";
    var baseGetTag2 = require_baseGetTag();
    var isObjectLike2 = require_isObjectLike();
    var isPlainObject4 = require_isPlainObject();
    var domExcTag = "[object DOMException]";
    var errorTag3 = "[object Error]";
    function isError(value) {
      if (!isObjectLike2(value)) {
        return false;
      }
      var tag = baseGetTag2(value);
      return tag == errorTag3 || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject4(value);
    }
    module2.exports = isError;
  }
});

// node_modules/lodash/attempt.js
var require_attempt = __commonJS({
  "node_modules/lodash/attempt.js"(exports2, module2) {
    "use strict";
    var apply = require_apply();
    var baseRest = require_baseRest();
    var isError = require_isError();
    var attempt = baseRest(function(func, args) {
      try {
        return apply(func, void 0, args);
      } catch (e) {
        return isError(e) ? e : new Error(e);
      }
    });
    module2.exports = attempt;
  }
});

// node_modules/lodash/_baseValues.js
var require_baseValues = __commonJS({
  "node_modules/lodash/_baseValues.js"(exports2, module2) {
    "use strict";
    var arrayMap2 = require_arrayMap();
    function baseValues(object4, props) {
      return arrayMap2(props, function(key) {
        return object4[key];
      });
    }
    module2.exports = baseValues;
  }
});

// node_modules/lodash/_customDefaultsAssignIn.js
var require_customDefaultsAssignIn = __commonJS({
  "node_modules/lodash/_customDefaultsAssignIn.js"(exports2, module2) {
    "use strict";
    var eq2 = require_eq();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function customDefaultsAssignIn(objValue, srcValue, key, object4) {
      if (objValue === void 0 || eq2(objValue, objectProto13[key]) && !hasOwnProperty11.call(object4, key)) {
        return srcValue;
      }
      return objValue;
    }
    module2.exports = customDefaultsAssignIn;
  }
});

// node_modules/lodash/_escapeStringChar.js
var require_escapeStringChar = __commonJS({
  "node_modules/lodash/_escapeStringChar.js"(exports2, module2) {
    "use strict";
    var stringEscapes = {
      "\\": "\\",
      "'": "'",
      "\n": "n",
      "\r": "r",
      "\u2028": "u2028",
      "\u2029": "u2029"
    };
    function escapeStringChar(chr) {
      return "\\" + stringEscapes[chr];
    }
    module2.exports = escapeStringChar;
  }
});

// node_modules/lodash/_reInterpolate.js
var require_reInterpolate = __commonJS({
  "node_modules/lodash/_reInterpolate.js"(exports2, module2) {
    "use strict";
    var reInterpolate = /<%=([\s\S]+?)%>/g;
    module2.exports = reInterpolate;
  }
});

// node_modules/lodash/_basePropertyOf.js
var require_basePropertyOf = __commonJS({
  "node_modules/lodash/_basePropertyOf.js"(exports2, module2) {
    "use strict";
    function basePropertyOf(object4) {
      return function(key) {
        return object4 == null ? void 0 : object4[key];
      };
    }
    module2.exports = basePropertyOf;
  }
});

// node_modules/lodash/_escapeHtmlChar.js
var require_escapeHtmlChar = __commonJS({
  "node_modules/lodash/_escapeHtmlChar.js"(exports2, module2) {
    "use strict";
    var basePropertyOf = require_basePropertyOf();
    var htmlEscapes = {
      "&": "&amp;",
      "<": "&lt;",
      ">": "&gt;",
      '"': "&quot;",
      "'": "&#39;"
    };
    var escapeHtmlChar = basePropertyOf(htmlEscapes);
    module2.exports = escapeHtmlChar;
  }
});

// node_modules/lodash/escape.js
var require_escape = __commonJS({
  "node_modules/lodash/escape.js"(exports2, module2) {
    "use strict";
    var escapeHtmlChar = require_escapeHtmlChar();
    var toString4 = require_toString();
    var reUnescapedHtml = /[&<>"']/g;
    var reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
    function escape2(string5) {
      string5 = toString4(string5);
      return string5 && reHasUnescapedHtml.test(string5) ? string5.replace(reUnescapedHtml, escapeHtmlChar) : string5;
    }
    module2.exports = escape2;
  }
});

// node_modules/lodash/_reEscape.js
var require_reEscape = __commonJS({
  "node_modules/lodash/_reEscape.js"(exports2, module2) {
    "use strict";
    var reEscape = /<%-([\s\S]+?)%>/g;
    module2.exports = reEscape;
  }
});

// node_modules/lodash/_reEvaluate.js
var require_reEvaluate = __commonJS({
  "node_modules/lodash/_reEvaluate.js"(exports2, module2) {
    "use strict";
    var reEvaluate = /<%([\s\S]+?)%>/g;
    module2.exports = reEvaluate;
  }
});

// node_modules/lodash/templateSettings.js
var require_templateSettings = __commonJS({
  "node_modules/lodash/templateSettings.js"(exports2, module2) {
    "use strict";
    var escape2 = require_escape();
    var reEscape = require_reEscape();
    var reEvaluate = require_reEvaluate();
    var reInterpolate = require_reInterpolate();
    var templateSettings = {
      /**
       * Used to detect `data` property values to be HTML-escaped.
       *
       * @memberOf _.templateSettings
       * @type {RegExp}
       */
      "escape": reEscape,
      /**
       * Used to detect code to be evaluated.
       *
       * @memberOf _.templateSettings
       * @type {RegExp}
       */
      "evaluate": reEvaluate,
      /**
       * Used to detect `data` property values to inject.
       *
       * @memberOf _.templateSettings
       * @type {RegExp}
       */
      "interpolate": reInterpolate,
      /**
       * Used to reference the data object in the template text.
       *
       * @memberOf _.templateSettings
       * @type {string}
       */
      "variable": "",
      /**
       * Used to import variables into the compiled template.
       *
       * @memberOf _.templateSettings
       * @type {Object}
       */
      "imports": {
        /**
         * A reference to the `lodash` function.
         *
         * @memberOf _.templateSettings.imports
         * @type {Function}
         */
        "_": { "escape": escape2 }
      }
    };
    module2.exports = templateSettings;
  }
});

// node_modules/lodash/template.js
var require_template = __commonJS({
  "node_modules/lodash/template.js"(exports2, module2) {
    "use strict";
    var assignInWith = require_assignInWith();
    var attempt = require_attempt();
    var baseValues = require_baseValues();
    var customDefaultsAssignIn = require_customDefaultsAssignIn();
    var escapeStringChar = require_escapeStringChar();
    var isError = require_isError();
    var isIterateeCall = require_isIterateeCall();
    var keys2 = require_keys();
    var reInterpolate = require_reInterpolate();
    var templateSettings = require_templateSettings();
    var toString4 = require_toString();
    var INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
    var reEmptyStringLeading = /\b__p \+= '';/g;
    var reEmptyStringMiddle = /\b(__p \+=) '' \+/g;
    var reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
    var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
    var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
    var reNoMatch = /($^)/;
    var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function template(string5, options, guard) {
      var settings = templateSettings.imports._.templateSettings || templateSettings;
      if (guard && isIterateeCall(string5, options, guard)) {
        options = void 0;
      }
      string5 = toString4(string5);
      options = assignInWith({}, options, settings, customDefaultsAssignIn);
      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys2(imports), importsValues = baseValues(imports, importsKeys);
      var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '";
      var reDelimiters = RegExp(
        (options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$",
        "g"
      );
      var sourceURL = hasOwnProperty11.call(options, "sourceURL") ? "//# sourceURL=" + (options.sourceURL + "").replace(/\s/g, " ") + "\n" : "";
      string5.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
        interpolateValue || (interpolateValue = esTemplateValue);
        source += string5.slice(index, offset).replace(reUnescapedString, escapeStringChar);
        if (escapeValue) {
          isEscaping = true;
          source += "' +\n__e(" + escapeValue + ") +\n'";
        }
        if (evaluateValue) {
          isEvaluating = true;
          source += "';\n" + evaluateValue + ";\n__p += '";
        }
        if (interpolateValue) {
          source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
        }
        index = offset + match.length;
        return match;
      });
      source += "';\n";
      var variable = hasOwnProperty11.call(options, "variable") && options.variable;
      if (!variable) {
        source = "with (obj) {\n" + source + "\n}\n";
      } else if (reForbiddenIdentifierChars.test(variable)) {
        throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);
      }
      source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;");
      source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}";
      var result = attempt(function() {
        return Function(importsKeys, sourceURL + "return " + source).apply(void 0, importsValues);
      });
      result.source = source;
      if (isError(result)) {
        throw result;
      }
      return result;
    }
    module2.exports = template;
  }
});

// node_modules/lodash/flatten.js
var require_flatten = __commonJS({
  "node_modules/lodash/flatten.js"(exports2, module2) {
    "use strict";
    var baseFlatten = require_baseFlatten();
    function flatten(array4) {
      var length = array4 == null ? 0 : array4.length;
      return length ? baseFlatten(array4, 1) : [];
    }
    module2.exports = flatten;
  }
});

// node_modules/knex/lib/migrations/util/fs.js
var require_fs5 = __commonJS({
  "node_modules/knex/lib/migrations/util/fs.js"(exports2, module2) {
    "use strict";
    var fs34 = require("fs");
    var flatten = require_flatten();
    var os = require("os");
    var path33 = require("path");
    var { promisify: promisify2 } = require("util");
    var stat = promisify2(fs34.stat);
    var readFile3 = promisify2(fs34.readFile);
    var writeFile3 = promisify2(fs34.writeFile);
    var readdir = promisify2(fs34.readdir);
    var mkdir = promisify2(fs34.mkdir);
    function existsSync4(path34) {
      try {
        fs34.accessSync(path34);
        return true;
      } catch (e) {
        return false;
      }
    }
    function createTemp() {
      return promisify2(fs34.mkdtemp)(`${os.tmpdir()}${path33.sep}`);
    }
    function ensureDirectoryExists(dir) {
      return stat(dir).catch(() => mkdir(dir, { recursive: true }));
    }
    async function getFilepathsInFolder(dir, recursive = false) {
      const pathsList = await readdir(dir);
      return flatten(
        await Promise.all(
          pathsList.sort().map(async (currentPath) => {
            const currentFile = path33.resolve(dir, currentPath);
            const statFile = await stat(currentFile);
            if (statFile && statFile.isDirectory()) {
              if (recursive) {
                return await getFilepathsInFolder(currentFile, true);
              }
              return [];
            }
            return [currentFile];
          })
        )
      );
    }
    module2.exports = {
      existsSync: existsSync4,
      stat,
      readdir,
      readFile: readFile3,
      writeFile: writeFile3,
      createTemp,
      ensureDirectoryExists,
      getFilepathsInFolder
    };
  }
});

// node_modules/knex/lib/migrations/util/template.js
var require_template2 = __commonJS({
  "node_modules/knex/lib/migrations/util/template.js"(exports2, module2) {
    "use strict";
    var template = require_template();
    var { readFile: readFile3, writeFile: writeFile3 } = require_fs5();
    var jsSourceTemplate = (content, options) => template(content, {
      interpolate: /<%=([\s\S]+?)%>/g,
      ...options
    });
    var jsFileTemplate = async (filePath, options) => {
      const contentBuffer = await readFile3(filePath);
      return jsSourceTemplate(contentBuffer.toString(), options);
    };
    var writeJsFileUsingTemplate = async (targetFilePath, sourceFilePath, options, variables) => writeFile3(
      targetFilePath,
      (await jsFileTemplate(sourceFilePath, options))(variables)
    );
    module2.exports = {
      jsSourceTemplate,
      jsFileTemplate,
      writeJsFileUsingTemplate
    };
  }
});

// node_modules/lodash/_arraySome.js
var require_arraySome = __commonJS({
  "node_modules/lodash/_arraySome.js"(exports2, module2) {
    "use strict";
    function arraySome2(array4, predicate) {
      var index = -1, length = array4 == null ? 0 : array4.length;
      while (++index < length) {
        if (predicate(array4[index], index, array4)) {
          return true;
        }
      }
      return false;
    }
    module2.exports = arraySome2;
  }
});

// node_modules/lodash/_equalArrays.js
var require_equalArrays = __commonJS({
  "node_modules/lodash/_equalArrays.js"(exports2, module2) {
    "use strict";
    var SetCache2 = require_SetCache();
    var arraySome2 = require_arraySome();
    var cacheHas2 = require_cacheHas();
    var COMPARE_PARTIAL_FLAG7 = 1;
    var COMPARE_UNORDERED_FLAG5 = 2;
    function equalArrays2(array4, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG7, arrLength = array4.length, othLength = other.length;
      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
        return false;
      }
      var arrStacked = stack.get(array4);
      var othStacked = stack.get(other);
      if (arrStacked && othStacked) {
        return arrStacked == other && othStacked == array4;
      }
      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG5 ? new SetCache2() : void 0;
      stack.set(array4, other);
      stack.set(other, array4);
      while (++index < arrLength) {
        var arrValue = array4[index], othValue = other[index];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, arrValue, index, other, array4, stack) : customizer(arrValue, othValue, index, array4, other, stack);
        }
        if (compared !== void 0) {
          if (compared) {
            continue;
          }
          result = false;
          break;
        }
        if (seen) {
          if (!arraySome2(other, function(othValue2, othIndex) {
            if (!cacheHas2(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
              return seen.push(othIndex);
            }
          })) {
            result = false;
            break;
          }
        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
          result = false;
          break;
        }
      }
      stack["delete"](array4);
      stack["delete"](other);
      return result;
    }
    module2.exports = equalArrays2;
  }
});

// node_modules/lodash/_mapToArray.js
var require_mapToArray = __commonJS({
  "node_modules/lodash/_mapToArray.js"(exports2, module2) {
    "use strict";
    function mapToArray2(map3) {
      var index = -1, result = Array(map3.size);
      map3.forEach(function(value, key) {
        result[++index] = [key, value];
      });
      return result;
    }
    module2.exports = mapToArray2;
  }
});

// node_modules/lodash/_setToArray.js
var require_setToArray = __commonJS({
  "node_modules/lodash/_setToArray.js"(exports2, module2) {
    "use strict";
    function setToArray2(set3) {
      var index = -1, result = Array(set3.size);
      set3.forEach(function(value) {
        result[++index] = value;
      });
      return result;
    }
    module2.exports = setToArray2;
  }
});

// node_modules/lodash/_equalByTag.js
var require_equalByTag = __commonJS({
  "node_modules/lodash/_equalByTag.js"(exports2, module2) {
    "use strict";
    var Symbol3 = require_Symbol();
    var Uint8Array3 = require_Uint8Array();
    var eq2 = require_eq();
    var equalArrays2 = require_equalArrays();
    var mapToArray2 = require_mapToArray();
    var setToArray2 = require_setToArray();
    var COMPARE_PARTIAL_FLAG7 = 1;
    var COMPARE_UNORDERED_FLAG5 = 2;
    var boolTag3 = "[object Boolean]";
    var dateTag3 = "[object Date]";
    var errorTag3 = "[object Error]";
    var mapTag4 = "[object Map]";
    var numberTag3 = "[object Number]";
    var regexpTag3 = "[object RegExp]";
    var setTag4 = "[object Set]";
    var stringTag3 = "[object String]";
    var symbolTag3 = "[object Symbol]";
    var arrayBufferTag3 = "[object ArrayBuffer]";
    var dataViewTag4 = "[object DataView]";
    var symbolProto3 = Symbol3 ? Symbol3.prototype : void 0;
    var symbolValueOf2 = symbolProto3 ? symbolProto3.valueOf : void 0;
    function equalByTag2(object4, other, tag, bitmask, customizer, equalFunc, stack) {
      switch (tag) {
        case dataViewTag4:
          if (object4.byteLength != other.byteLength || object4.byteOffset != other.byteOffset) {
            return false;
          }
          object4 = object4.buffer;
          other = other.buffer;
        case arrayBufferTag3:
          if (object4.byteLength != other.byteLength || !equalFunc(new Uint8Array3(object4), new Uint8Array3(other))) {
            return false;
          }
          return true;
        case boolTag3:
        case dateTag3:
        case numberTag3:
          return eq2(+object4, +other);
        case errorTag3:
          return object4.name == other.name && object4.message == other.message;
        case regexpTag3:
        case stringTag3:
          return object4 == other + "";
        case mapTag4:
          var convert = mapToArray2;
        case setTag4:
          var isPartial = bitmask & COMPARE_PARTIAL_FLAG7;
          convert || (convert = setToArray2);
          if (object4.size != other.size && !isPartial) {
            return false;
          }
          var stacked = stack.get(object4);
          if (stacked) {
            return stacked == other;
          }
          bitmask |= COMPARE_UNORDERED_FLAG5;
          stack.set(object4, other);
          var result = equalArrays2(convert(object4), convert(other), bitmask, customizer, equalFunc, stack);
          stack["delete"](object4);
          return result;
        case symbolTag3:
          if (symbolValueOf2) {
            return symbolValueOf2.call(object4) == symbolValueOf2.call(other);
          }
      }
      return false;
    }
    module2.exports = equalByTag2;
  }
});

// node_modules/lodash/_equalObjects.js
var require_equalObjects = __commonJS({
  "node_modules/lodash/_equalObjects.js"(exports2, module2) {
    "use strict";
    var getAllKeys2 = require_getAllKeys();
    var COMPARE_PARTIAL_FLAG7 = 1;
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function equalObjects2(object4, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG7, objProps = getAllKeys2(object4), objLength = objProps.length, othProps = getAllKeys2(other), othLength = othProps.length;
      if (objLength != othLength && !isPartial) {
        return false;
      }
      var index = objLength;
      while (index--) {
        var key = objProps[index];
        if (!(isPartial ? key in other : hasOwnProperty11.call(other, key))) {
          return false;
        }
      }
      var objStacked = stack.get(object4);
      var othStacked = stack.get(other);
      if (objStacked && othStacked) {
        return objStacked == other && othStacked == object4;
      }
      var result = true;
      stack.set(object4, other);
      stack.set(other, object4);
      var skipCtor = isPartial;
      while (++index < objLength) {
        key = objProps[index];
        var objValue = object4[key], othValue = other[key];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, objValue, key, other, object4, stack) : customizer(objValue, othValue, key, object4, other, stack);
        }
        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
          result = false;
          break;
        }
        skipCtor || (skipCtor = key == "constructor");
      }
      if (result && !skipCtor) {
        var objCtor = object4.constructor, othCtor = other.constructor;
        if (objCtor != othCtor && ("constructor" in object4 && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
          result = false;
        }
      }
      stack["delete"](object4);
      stack["delete"](other);
      return result;
    }
    module2.exports = equalObjects2;
  }
});

// node_modules/lodash/_baseIsEqualDeep.js
var require_baseIsEqualDeep = __commonJS({
  "node_modules/lodash/_baseIsEqualDeep.js"(exports2, module2) {
    "use strict";
    var Stack2 = require_Stack();
    var equalArrays2 = require_equalArrays();
    var equalByTag2 = require_equalByTag();
    var equalObjects2 = require_equalObjects();
    var getTag2 = require_getTag();
    var isArray3 = require_isArray();
    var isBuffer3 = require_isBuffer();
    var isTypedArray3 = require_isTypedArray();
    var COMPARE_PARTIAL_FLAG7 = 1;
    var argsTag4 = "[object Arguments]";
    var arrayTag3 = "[object Array]";
    var objectTag4 = "[object Object]";
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function baseIsEqualDeep2(object4, other, bitmask, customizer, equalFunc, stack) {
      var objIsArr = isArray3(object4), othIsArr = isArray3(other), objTag = objIsArr ? arrayTag3 : getTag2(object4), othTag = othIsArr ? arrayTag3 : getTag2(other);
      objTag = objTag == argsTag4 ? objectTag4 : objTag;
      othTag = othTag == argsTag4 ? objectTag4 : othTag;
      var objIsObj = objTag == objectTag4, othIsObj = othTag == objectTag4, isSameTag = objTag == othTag;
      if (isSameTag && isBuffer3(object4)) {
        if (!isBuffer3(other)) {
          return false;
        }
        objIsArr = true;
        objIsObj = false;
      }
      if (isSameTag && !objIsObj) {
        stack || (stack = new Stack2());
        return objIsArr || isTypedArray3(object4) ? equalArrays2(object4, other, bitmask, customizer, equalFunc, stack) : equalByTag2(object4, other, objTag, bitmask, customizer, equalFunc, stack);
      }
      if (!(bitmask & COMPARE_PARTIAL_FLAG7)) {
        var objIsWrapped = objIsObj && hasOwnProperty11.call(object4, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty11.call(other, "__wrapped__");
        if (objIsWrapped || othIsWrapped) {
          var objUnwrapped = objIsWrapped ? object4.value() : object4, othUnwrapped = othIsWrapped ? other.value() : other;
          stack || (stack = new Stack2());
          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
        }
      }
      if (!isSameTag) {
        return false;
      }
      stack || (stack = new Stack2());
      return equalObjects2(object4, other, bitmask, customizer, equalFunc, stack);
    }
    module2.exports = baseIsEqualDeep2;
  }
});

// node_modules/lodash/_baseIsEqual.js
var require_baseIsEqual = __commonJS({
  "node_modules/lodash/_baseIsEqual.js"(exports2, module2) {
    "use strict";
    var baseIsEqualDeep2 = require_baseIsEqualDeep();
    var isObjectLike2 = require_isObjectLike();
    function baseIsEqual2(value, other, bitmask, customizer, stack) {
      if (value === other) {
        return true;
      }
      if (value == null || other == null || !isObjectLike2(value) && !isObjectLike2(other)) {
        return value !== value && other !== other;
      }
      return baseIsEqualDeep2(value, other, bitmask, customizer, baseIsEqual2, stack);
    }
    module2.exports = baseIsEqual2;
  }
});

// node_modules/lodash/_baseIsMatch.js
var require_baseIsMatch = __commonJS({
  "node_modules/lodash/_baseIsMatch.js"(exports2, module2) {
    "use strict";
    var Stack2 = require_Stack();
    var baseIsEqual2 = require_baseIsEqual();
    var COMPARE_PARTIAL_FLAG7 = 1;
    var COMPARE_UNORDERED_FLAG5 = 2;
    function baseIsMatch2(object4, source, matchData, customizer) {
      var index = matchData.length, length = index, noCustomizer = !customizer;
      if (object4 == null) {
        return !length;
      }
      object4 = Object(object4);
      while (index--) {
        var data = matchData[index];
        if (noCustomizer && data[2] ? data[1] !== object4[data[0]] : !(data[0] in object4)) {
          return false;
        }
      }
      while (++index < length) {
        data = matchData[index];
        var key = data[0], objValue = object4[key], srcValue = data[1];
        if (noCustomizer && data[2]) {
          if (objValue === void 0 && !(key in object4)) {
            return false;
          }
        } else {
          var stack = new Stack2();
          if (customizer) {
            var result = customizer(objValue, srcValue, key, object4, source, stack);
          }
          if (!(result === void 0 ? baseIsEqual2(srcValue, objValue, COMPARE_PARTIAL_FLAG7 | COMPARE_UNORDERED_FLAG5, customizer, stack) : result)) {
            return false;
          }
        }
      }
      return true;
    }
    module2.exports = baseIsMatch2;
  }
});

// node_modules/lodash/_isStrictComparable.js
var require_isStrictComparable = __commonJS({
  "node_modules/lodash/_isStrictComparable.js"(exports2, module2) {
    "use strict";
    var isObject5 = require_isObject();
    function isStrictComparable2(value) {
      return value === value && !isObject5(value);
    }
    module2.exports = isStrictComparable2;
  }
});

// node_modules/lodash/_getMatchData.js
var require_getMatchData = __commonJS({
  "node_modules/lodash/_getMatchData.js"(exports2, module2) {
    "use strict";
    var isStrictComparable2 = require_isStrictComparable();
    var keys2 = require_keys();
    function getMatchData2(object4) {
      var result = keys2(object4), length = result.length;
      while (length--) {
        var key = result[length], value = object4[key];
        result[length] = [key, value, isStrictComparable2(value)];
      }
      return result;
    }
    module2.exports = getMatchData2;
  }
});

// node_modules/lodash/_matchesStrictComparable.js
var require_matchesStrictComparable = __commonJS({
  "node_modules/lodash/_matchesStrictComparable.js"(exports2, module2) {
    "use strict";
    function matchesStrictComparable2(key, srcValue) {
      return function(object4) {
        if (object4 == null) {
          return false;
        }
        return object4[key] === srcValue && (srcValue !== void 0 || key in Object(object4));
      };
    }
    module2.exports = matchesStrictComparable2;
  }
});

// node_modules/lodash/_baseMatches.js
var require_baseMatches = __commonJS({
  "node_modules/lodash/_baseMatches.js"(exports2, module2) {
    "use strict";
    var baseIsMatch2 = require_baseIsMatch();
    var getMatchData2 = require_getMatchData();
    var matchesStrictComparable2 = require_matchesStrictComparable();
    function baseMatches2(source) {
      var matchData = getMatchData2(source);
      if (matchData.length == 1 && matchData[0][2]) {
        return matchesStrictComparable2(matchData[0][0], matchData[0][1]);
      }
      return function(object4) {
        return object4 === source || baseIsMatch2(object4, source, matchData);
      };
    }
    module2.exports = baseMatches2;
  }
});

// node_modules/lodash/_baseHasIn.js
var require_baseHasIn = __commonJS({
  "node_modules/lodash/_baseHasIn.js"(exports2, module2) {
    "use strict";
    function baseHasIn2(object4, key) {
      return object4 != null && key in Object(object4);
    }
    module2.exports = baseHasIn2;
  }
});

// node_modules/lodash/_hasPath.js
var require_hasPath = __commonJS({
  "node_modules/lodash/_hasPath.js"(exports2, module2) {
    "use strict";
    var castPath2 = require_castPath();
    var isArguments2 = require_isArguments();
    var isArray3 = require_isArray();
    var isIndex2 = require_isIndex();
    var isLength2 = require_isLength();
    var toKey2 = require_toKey();
    function hasPath2(object4, path33, hasFunc) {
      path33 = castPath2(path33, object4);
      var index = -1, length = path33.length, result = false;
      while (++index < length) {
        var key = toKey2(path33[index]);
        if (!(result = object4 != null && hasFunc(object4, key))) {
          break;
        }
        object4 = object4[key];
      }
      if (result || ++index != length) {
        return result;
      }
      length = object4 == null ? 0 : object4.length;
      return !!length && isLength2(length) && isIndex2(key, length) && (isArray3(object4) || isArguments2(object4));
    }
    module2.exports = hasPath2;
  }
});

// node_modules/lodash/hasIn.js
var require_hasIn = __commonJS({
  "node_modules/lodash/hasIn.js"(exports2, module2) {
    "use strict";
    var baseHasIn2 = require_baseHasIn();
    var hasPath2 = require_hasPath();
    function hasIn2(object4, path33) {
      return object4 != null && hasPath2(object4, path33, baseHasIn2);
    }
    module2.exports = hasIn2;
  }
});

// node_modules/lodash/_baseMatchesProperty.js
var require_baseMatchesProperty = __commonJS({
  "node_modules/lodash/_baseMatchesProperty.js"(exports2, module2) {
    "use strict";
    var baseIsEqual2 = require_baseIsEqual();
    var get2 = require_get2();
    var hasIn2 = require_hasIn();
    var isKey2 = require_isKey();
    var isStrictComparable2 = require_isStrictComparable();
    var matchesStrictComparable2 = require_matchesStrictComparable();
    var toKey2 = require_toKey();
    var COMPARE_PARTIAL_FLAG7 = 1;
    var COMPARE_UNORDERED_FLAG5 = 2;
    function baseMatchesProperty2(path33, srcValue) {
      if (isKey2(path33) && isStrictComparable2(srcValue)) {
        return matchesStrictComparable2(toKey2(path33), srcValue);
      }
      return function(object4) {
        var objValue = get2(object4, path33);
        return objValue === void 0 && objValue === srcValue ? hasIn2(object4, path33) : baseIsEqual2(srcValue, objValue, COMPARE_PARTIAL_FLAG7 | COMPARE_UNORDERED_FLAG5);
      };
    }
    module2.exports = baseMatchesProperty2;
  }
});

// node_modules/lodash/_baseProperty.js
var require_baseProperty = __commonJS({
  "node_modules/lodash/_baseProperty.js"(exports2, module2) {
    "use strict";
    function baseProperty2(key) {
      return function(object4) {
        return object4 == null ? void 0 : object4[key];
      };
    }
    module2.exports = baseProperty2;
  }
});

// node_modules/lodash/_basePropertyDeep.js
var require_basePropertyDeep = __commonJS({
  "node_modules/lodash/_basePropertyDeep.js"(exports2, module2) {
    "use strict";
    var baseGet2 = require_baseGet();
    function basePropertyDeep2(path33) {
      return function(object4) {
        return baseGet2(object4, path33);
      };
    }
    module2.exports = basePropertyDeep2;
  }
});

// node_modules/lodash/property.js
var require_property = __commonJS({
  "node_modules/lodash/property.js"(exports2, module2) {
    "use strict";
    var baseProperty2 = require_baseProperty();
    var basePropertyDeep2 = require_basePropertyDeep();
    var isKey2 = require_isKey();
    var toKey2 = require_toKey();
    function property2(path33) {
      return isKey2(path33) ? baseProperty2(toKey2(path33)) : basePropertyDeep2(path33);
    }
    module2.exports = property2;
  }
});

// node_modules/lodash/_baseIteratee.js
var require_baseIteratee = __commonJS({
  "node_modules/lodash/_baseIteratee.js"(exports2, module2) {
    "use strict";
    var baseMatches2 = require_baseMatches();
    var baseMatchesProperty2 = require_baseMatchesProperty();
    var identity2 = require_identity();
    var isArray3 = require_isArray();
    var property2 = require_property();
    function baseIteratee2(value) {
      if (typeof value == "function") {
        return value;
      }
      if (value == null) {
        return identity2;
      }
      if (typeof value == "object") {
        return isArray3(value) ? baseMatchesProperty2(value[0], value[1]) : baseMatches2(value);
      }
      return property2(value);
    }
    module2.exports = baseIteratee2;
  }
});

// node_modules/lodash/_createBaseFor.js
var require_createBaseFor = __commonJS({
  "node_modules/lodash/_createBaseFor.js"(exports2, module2) {
    "use strict";
    function createBaseFor(fromRight) {
      return function(object4, iteratee, keysFunc) {
        var index = -1, iterable = Object(object4), props = keysFunc(object4), length = props.length;
        while (length--) {
          var key = props[fromRight ? length : ++index];
          if (iteratee(iterable[key], key, iterable) === false) {
            break;
          }
        }
        return object4;
      };
    }
    module2.exports = createBaseFor;
  }
});

// node_modules/lodash/_baseFor.js
var require_baseFor = __commonJS({
  "node_modules/lodash/_baseFor.js"(exports2, module2) {
    "use strict";
    var createBaseFor = require_createBaseFor();
    var baseFor = createBaseFor();
    module2.exports = baseFor;
  }
});

// node_modules/lodash/_baseForOwn.js
var require_baseForOwn = __commonJS({
  "node_modules/lodash/_baseForOwn.js"(exports2, module2) {
    "use strict";
    var baseFor = require_baseFor();
    var keys2 = require_keys();
    function baseForOwn(object4, iteratee) {
      return object4 && baseFor(object4, iteratee, keys2);
    }
    module2.exports = baseForOwn;
  }
});

// node_modules/lodash/_createBaseEach.js
var require_createBaseEach = __commonJS({
  "node_modules/lodash/_createBaseEach.js"(exports2, module2) {
    "use strict";
    var isArrayLike2 = require_isArrayLike();
    function createBaseEach(eachFunc, fromRight) {
      return function(collection, iteratee) {
        if (collection == null) {
          return collection;
        }
        if (!isArrayLike2(collection)) {
          return eachFunc(collection, iteratee);
        }
        var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
        while (fromRight ? index-- : ++index < length) {
          if (iteratee(iterable[index], index, iterable) === false) {
            break;
          }
        }
        return collection;
      };
    }
    module2.exports = createBaseEach;
  }
});

// node_modules/lodash/_baseEach.js
var require_baseEach = __commonJS({
  "node_modules/lodash/_baseEach.js"(exports2, module2) {
    "use strict";
    var baseForOwn = require_baseForOwn();
    var createBaseEach = require_createBaseEach();
    var baseEach = createBaseEach(baseForOwn);
    module2.exports = baseEach;
  }
});

// node_modules/lodash/_baseMap.js
var require_baseMap = __commonJS({
  "node_modules/lodash/_baseMap.js"(exports2, module2) {
    "use strict";
    var baseEach = require_baseEach();
    var isArrayLike2 = require_isArrayLike();
    function baseMap(collection, iteratee) {
      var index = -1, result = isArrayLike2(collection) ? Array(collection.length) : [];
      baseEach(collection, function(value, key, collection2) {
        result[++index] = iteratee(value, key, collection2);
      });
      return result;
    }
    module2.exports = baseMap;
  }
});

// node_modules/lodash/_baseSortBy.js
var require_baseSortBy = __commonJS({
  "node_modules/lodash/_baseSortBy.js"(exports2, module2) {
    "use strict";
    function baseSortBy(array4, comparer) {
      var length = array4.length;
      array4.sort(comparer);
      while (length--) {
        array4[length] = array4[length].value;
      }
      return array4;
    }
    module2.exports = baseSortBy;
  }
});

// node_modules/lodash/_compareAscending.js
var require_compareAscending = __commonJS({
  "node_modules/lodash/_compareAscending.js"(exports2, module2) {
    "use strict";
    var isSymbol2 = require_isSymbol();
    function compareAscending(value, other) {
      if (value !== other) {
        var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol2(value);
        var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol2(other);
        if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
          return 1;
        }
        if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
          return -1;
        }
      }
      return 0;
    }
    module2.exports = compareAscending;
  }
});

// node_modules/lodash/_compareMultiple.js
var require_compareMultiple = __commonJS({
  "node_modules/lodash/_compareMultiple.js"(exports2, module2) {
    "use strict";
    var compareAscending = require_compareAscending();
    function compareMultiple(object4, other, orders) {
      var index = -1, objCriteria = object4.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
      while (++index < length) {
        var result = compareAscending(objCriteria[index], othCriteria[index]);
        if (result) {
          if (index >= ordersLength) {
            return result;
          }
          var order = orders[index];
          return result * (order == "desc" ? -1 : 1);
        }
      }
      return object4.index - other.index;
    }
    module2.exports = compareMultiple;
  }
});

// node_modules/lodash/_baseOrderBy.js
var require_baseOrderBy = __commonJS({
  "node_modules/lodash/_baseOrderBy.js"(exports2, module2) {
    "use strict";
    var arrayMap2 = require_arrayMap();
    var baseGet2 = require_baseGet();
    var baseIteratee2 = require_baseIteratee();
    var baseMap = require_baseMap();
    var baseSortBy = require_baseSortBy();
    var baseUnary2 = require_baseUnary();
    var compareMultiple = require_compareMultiple();
    var identity2 = require_identity();
    var isArray3 = require_isArray();
    function baseOrderBy(collection, iteratees, orders) {
      if (iteratees.length) {
        iteratees = arrayMap2(iteratees, function(iteratee) {
          if (isArray3(iteratee)) {
            return function(value) {
              return baseGet2(value, iteratee.length === 1 ? iteratee[0] : iteratee);
            };
          }
          return iteratee;
        });
      } else {
        iteratees = [identity2];
      }
      var index = -1;
      iteratees = arrayMap2(iteratees, baseUnary2(baseIteratee2));
      var result = baseMap(collection, function(value, key, collection2) {
        var criteria = arrayMap2(iteratees, function(iteratee) {
          return iteratee(value);
        });
        return { "criteria": criteria, "index": ++index, "value": value };
      });
      return baseSortBy(result, function(object4, other) {
        return compareMultiple(object4, other, orders);
      });
    }
    module2.exports = baseOrderBy;
  }
});

// node_modules/lodash/sortBy.js
var require_sortBy = __commonJS({
  "node_modules/lodash/sortBy.js"(exports2, module2) {
    "use strict";
    var baseFlatten = require_baseFlatten();
    var baseOrderBy = require_baseOrderBy();
    var baseRest = require_baseRest();
    var isIterateeCall = require_isIterateeCall();
    var sortBy = baseRest(function(collection, iteratees) {
      if (collection == null) {
        return [];
      }
      var length = iteratees.length;
      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
        iteratees = [];
      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
        iteratees = [iteratees[0]];
      }
      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
    });
    module2.exports = sortBy;
  }
});

// node_modules/get-package-type/is-node-modules.cjs
var require_is_node_modules = __commonJS({
  "node_modules/get-package-type/is-node-modules.cjs"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    function isNodeModules(directory) {
      let basename = path33.basename(directory);
      if (path33.sep === "\\") {
        basename = basename.toLowerCase();
      }
      return basename === "node_modules";
    }
    module2.exports = isNodeModules;
  }
});

// node_modules/get-package-type/cache.cjs
var require_cache = __commonJS({
  "node_modules/get-package-type/cache.cjs"(exports2, module2) {
    "use strict";
    module2.exports = /* @__PURE__ */ new Map();
  }
});

// node_modules/get-package-type/async.cjs
var require_async7 = __commonJS({
  "node_modules/get-package-type/async.cjs"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var { promisify: promisify2 } = require("util");
    var readFile3 = promisify2(require("fs").readFile);
    var isNodeModules = require_is_node_modules();
    var resultsCache = require_cache();
    var promiseCache = /* @__PURE__ */ new Map();
    async function getDirectoryTypeActual(directory) {
      if (isNodeModules(directory)) {
        return "commonjs";
      }
      try {
        return JSON.parse(await readFile3(path33.resolve(directory, "package.json"))).type || "commonjs";
      } catch (_) {
      }
      const parent = path33.dirname(directory);
      if (parent === directory) {
        return "commonjs";
      }
      return getDirectoryType(parent);
    }
    async function getDirectoryType(directory) {
      if (resultsCache.has(directory)) {
        return resultsCache.get(directory);
      }
      if (promiseCache.has(directory)) {
        return promiseCache.get(directory);
      }
      const promise3 = getDirectoryTypeActual(directory);
      promiseCache.set(directory, promise3);
      const result = await promise3;
      resultsCache.set(directory, result);
      promiseCache.delete(directory);
      return result;
    }
    function getPackageType(filename) {
      return getDirectoryType(path33.resolve(path33.dirname(filename)));
    }
    module2.exports = getPackageType;
  }
});

// node_modules/get-package-type/sync.cjs
var require_sync7 = __commonJS({
  "node_modules/get-package-type/sync.cjs"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var { readFileSync: readFileSync2 } = require("fs");
    var isNodeModules = require_is_node_modules();
    var resultsCache = require_cache();
    function getDirectoryTypeActual(directory) {
      if (isNodeModules(directory)) {
        return "commonjs";
      }
      try {
        return JSON.parse(readFileSync2(path33.resolve(directory, "package.json"))).type || "commonjs";
      } catch (_) {
      }
      const parent = path33.dirname(directory);
      if (parent === directory) {
        return "commonjs";
      }
      return getDirectoryType(parent);
    }
    function getDirectoryType(directory) {
      if (resultsCache.has(directory)) {
        return resultsCache.get(directory);
      }
      const result = getDirectoryTypeActual(directory);
      resultsCache.set(directory, result);
      return result;
    }
    function getPackageTypeSync(filename) {
      return getDirectoryType(path33.resolve(path33.dirname(filename)));
    }
    module2.exports = getPackageTypeSync;
  }
});

// node_modules/get-package-type/index.cjs
var require_get_package_type = __commonJS({
  "node_modules/get-package-type/index.cjs"(exports2, module2) {
    "use strict";
    var getPackageType = require_async7();
    var getPackageTypeSync = require_sync7();
    module2.exports = (filename) => getPackageType(filename);
    module2.exports.sync = getPackageTypeSync;
  }
});

// node_modules/knex/lib/migrations/util/is-module-type.js
var require_is_module_type = __commonJS({
  "node_modules/knex/lib/migrations/util/is-module-type.js"(exports2, module2) {
    "use strict";
    var getPackageType = require_get_package_type();
    module2.exports = async function isModuleType(filepath) {
      return filepath.endsWith(".mjs") || !filepath.endsWith(".cjs") && await getPackageType(filepath) === "module";
    };
  }
});

// node_modules/knex/lib/migrations/util/import-file.js
var require_import_file = __commonJS({
  "node_modules/knex/lib/migrations/util/import-file.js"(exports2, module2) {
    "use strict";
    var isModuleType = require_is_module_type();
    module2.exports = async function importFile(filepath) {
      return await isModuleType(filepath) ? import(require("url").pathToFileURL(filepath)) : require(filepath);
    };
  }
});

// node_modules/knex/lib/migrations/common/MigrationsLoader.js
var require_MigrationsLoader = __commonJS({
  "node_modules/knex/lib/migrations/common/MigrationsLoader.js"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var DEFAULT_LOAD_EXTENSIONS = Object.freeze([
      ".co",
      ".coffee",
      ".eg",
      ".iced",
      ".js",
      ".cjs",
      ".litcoffee",
      ".ls",
      ".ts"
    ]);
    var AbstractMigrationsLoader = class {
      constructor(migrationDirectories, sortDirsSeparately, loadExtensions) {
        this.sortDirsSeparately = sortDirsSeparately;
        if (!Array.isArray(migrationDirectories)) {
          migrationDirectories = [migrationDirectories];
        }
        this.migrationsPaths = migrationDirectories;
        this.loadExtensions = loadExtensions || DEFAULT_LOAD_EXTENSIONS;
      }
      getFile(migrationsInfo) {
        const absoluteDir = path33.resolve(process.cwd(), migrationsInfo.directory);
        const _path = path33.join(absoluteDir, migrationsInfo.file);
        const importFile = require_import_file();
        return importFile(_path);
      }
    };
    module2.exports = {
      DEFAULT_LOAD_EXTENSIONS,
      AbstractMigrationsLoader
    };
  }
});

// node_modules/knex/lib/migrations/migrate/sources/fs-migrations.js
var require_fs_migrations = __commonJS({
  "node_modules/knex/lib/migrations/migrate/sources/fs-migrations.js"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var sortBy = require_sortBy();
    var { readdir } = require_fs5();
    var { AbstractMigrationsLoader } = require_MigrationsLoader();
    var FsMigrations = class extends AbstractMigrationsLoader {
      /**
       * Gets the migration names
       * @returns Promise<string[]>
       */
      getMigrations(loadExtensions) {
        const readMigrationsPromises = this.migrationsPaths.map((configDir) => {
          const absoluteDir = path33.resolve(process.cwd(), configDir);
          return readdir(absoluteDir).then((files) => ({
            files,
            configDir,
            absoluteDir
          }));
        });
        return Promise.all(readMigrationsPromises).then((allMigrations) => {
          const migrations = allMigrations.reduce((acc, migrationDirectory) => {
            if (this.sortDirsSeparately) {
              migrationDirectory.files = migrationDirectory.files.sort();
            }
            migrationDirectory.files.forEach(
              (file3) => acc.push({ file: file3, directory: migrationDirectory.configDir })
            );
            return acc;
          }, []);
          if (this.sortDirsSeparately) {
            return filterMigrations(
              this,
              migrations,
              loadExtensions || this.loadExtensions
            );
          }
          return filterMigrations(
            this,
            sortBy(migrations, "file"),
            loadExtensions || this.loadExtensions
          );
        });
      }
      getMigrationName(migration) {
        return migration.file;
      }
      getMigration(migrationInfo) {
        return this.getFile(migrationInfo);
      }
    };
    function filterMigrations(migrationSource, migrations, loadExtensions) {
      return migrations.filter((migration) => {
        const migrationName = migrationSource.getMigrationName(migration);
        const extension = path33.extname(migrationName);
        return loadExtensions.includes(extension);
      });
    }
    module2.exports = {
      FsMigrations
    };
  }
});

// node_modules/colorette/index.cjs
var require_colorette = __commonJS({
  "node_modules/colorette/index.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var tty = require("tty");
    function _interopNamespace(e) {
      if (e && e.__esModule) return e;
      var n = /* @__PURE__ */ Object.create(null);
      if (e) {
        Object.keys(e).forEach(function(k) {
          if (k !== "default") {
            var d = Object.getOwnPropertyDescriptor(e, k);
            Object.defineProperty(n, k, d.get ? d : {
              enumerable: true,
              get: function() {
                return e[k];
              }
            });
          }
        });
      }
      n["default"] = e;
      return Object.freeze(n);
    }
    var tty__namespace = /* @__PURE__ */ _interopNamespace(tty);
    var {
      env: env2 = {},
      argv = [],
      platform = ""
    } = typeof process === "undefined" ? {} : process;
    var isDisabled = "NO_COLOR" in env2 || argv.includes("--no-color");
    var isForced = "FORCE_COLOR" in env2 || argv.includes("--color");
    var isWindows = platform === "win32";
    var isDumbTerminal = env2.TERM === "dumb";
    var isCompatibleTerminal = tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env2.TERM && !isDumbTerminal;
    var isCI = "CI" in env2 && ("GITHUB_ACTIONS" in env2 || "GITLAB_CI" in env2 || "CIRCLECI" in env2);
    var isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
    var replaceClose = (index, string5, close, replace, head = string5.substring(0, index) + replace, tail = string5.substring(index + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
    var clearBleed = (index, string5, open, close, replace) => index < 0 ? open + string5 + close : open + replaceClose(index, string5, close, replace) + close;
    var filterEmpty = (open, close, replace = open, at = open.length + 1) => (string5) => string5 || !(string5 === "" || string5 === void 0) ? clearBleed(
      ("" + string5).indexOf(close, at),
      string5,
      open,
      close,
      replace
    ) : "";
    var init = (open, close, replace) => filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
    var colors = {
      reset: init(0, 0),
      bold: init(1, 22, "\x1B[22m\x1B[1m"),
      dim: init(2, 22, "\x1B[22m\x1B[2m"),
      italic: init(3, 23),
      underline: init(4, 24),
      inverse: init(7, 27),
      hidden: init(8, 28),
      strikethrough: init(9, 29),
      black: init(30, 39),
      red: init(31, 39),
      green: init(32, 39),
      yellow: init(33, 39),
      blue: init(34, 39),
      magenta: init(35, 39),
      cyan: init(36, 39),
      white: init(37, 39),
      gray: init(90, 39),
      bgBlack: init(40, 49),
      bgRed: init(41, 49),
      bgGreen: init(42, 49),
      bgYellow: init(43, 49),
      bgBlue: init(44, 49),
      bgMagenta: init(45, 49),
      bgCyan: init(46, 49),
      bgWhite: init(47, 49),
      blackBright: init(90, 39),
      redBright: init(91, 39),
      greenBright: init(92, 39),
      yellowBright: init(93, 39),
      blueBright: init(94, 39),
      magentaBright: init(95, 39),
      cyanBright: init(96, 39),
      whiteBright: init(97, 39),
      bgBlackBright: init(100, 49),
      bgRedBright: init(101, 49),
      bgGreenBright: init(102, 49),
      bgYellowBright: init(103, 49),
      bgBlueBright: init(104, 49),
      bgMagentaBright: init(105, 49),
      bgCyanBright: init(106, 49),
      bgWhiteBright: init(107, 49)
    };
    var createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors : Object.keys(colors).reduce(
      (colors2, key) => ({ ...colors2, [key]: String }),
      {}
    );
    var {
      reset,
      bold,
      dim,
      italic,
      underline,
      inverse,
      hidden,
      strikethrough,
      black,
      red,
      green,
      yellow,
      blue,
      magenta,
      cyan,
      white,
      gray,
      bgBlack,
      bgRed,
      bgGreen,
      bgYellow,
      bgBlue,
      bgMagenta,
      bgCyan,
      bgWhite,
      blackBright,
      redBright,
      greenBright,
      yellowBright,
      blueBright,
      magentaBright,
      cyanBright,
      whiteBright,
      bgBlackBright,
      bgRedBright,
      bgGreenBright,
      bgYellowBright,
      bgBlueBright,
      bgMagentaBright,
      bgCyanBright,
      bgWhiteBright
    } = createColors();
    exports2.bgBlack = bgBlack;
    exports2.bgBlackBright = bgBlackBright;
    exports2.bgBlue = bgBlue;
    exports2.bgBlueBright = bgBlueBright;
    exports2.bgCyan = bgCyan;
    exports2.bgCyanBright = bgCyanBright;
    exports2.bgGreen = bgGreen;
    exports2.bgGreenBright = bgGreenBright;
    exports2.bgMagenta = bgMagenta;
    exports2.bgMagentaBright = bgMagentaBright;
    exports2.bgRed = bgRed;
    exports2.bgRedBright = bgRedBright;
    exports2.bgWhite = bgWhite;
    exports2.bgWhiteBright = bgWhiteBright;
    exports2.bgYellow = bgYellow;
    exports2.bgYellowBright = bgYellowBright;
    exports2.black = black;
    exports2.blackBright = blackBright;
    exports2.blue = blue;
    exports2.blueBright = blueBright;
    exports2.bold = bold;
    exports2.createColors = createColors;
    exports2.cyan = cyan;
    exports2.cyanBright = cyanBright;
    exports2.dim = dim;
    exports2.gray = gray;
    exports2.green = green;
    exports2.greenBright = greenBright;
    exports2.hidden = hidden;
    exports2.inverse = inverse;
    exports2.isColorSupported = isColorSupported;
    exports2.italic = italic;
    exports2.magenta = magenta;
    exports2.magentaBright = magentaBright;
    exports2.red = red;
    exports2.redBright = redBright;
    exports2.reset = reset;
    exports2.strikethrough = strikethrough;
    exports2.underline = underline;
    exports2.white = white;
    exports2.whiteBright = whiteBright;
    exports2.yellow = yellow;
    exports2.yellowBright = yellowBright;
  }
});

// node_modules/knex/lib/util/is.js
var require_is = __commonJS({
  "node_modules/knex/lib/util/is.js"(exports2, module2) {
    "use strict";
    function isString2(value) {
      return typeof value === "string";
    }
    function isNumber2(value) {
      return typeof value === "number";
    }
    function isBoolean2(value) {
      return typeof value === "boolean";
    }
    function isUndefined2(value) {
      return typeof value === "undefined";
    }
    function isObject5(value) {
      return typeof value === "object" && value !== null;
    }
    function isFunction4(value) {
      return typeof value === "function";
    }
    module2.exports = {
      isString: isString2,
      isNumber: isNumber2,
      isBoolean: isBoolean2,
      isUndefined: isUndefined2,
      isObject: isObject5,
      isFunction: isFunction4
    };
  }
});

// node_modules/knex/lib/logger.js
var require_logger = __commonJS({
  "node_modules/knex/lib/logger.js"(exports2, module2) {
    "use strict";
    var color = require_colorette();
    var { inspect } = require("util");
    var { isString: isString2, isFunction: isFunction4 } = require_is();
    var Logger = class {
      constructor(config3 = {}) {
        const {
          log: {
            debug,
            warn,
            error: error73,
            deprecate,
            inspectionDepth,
            enableColors
          } = {}
        } = config3;
        this._inspectionDepth = inspectionDepth || 5;
        this._enableColors = resolveIsEnabledColors(enableColors);
        this._debug = debug;
        this._warn = warn;
        this._error = error73;
        this._deprecate = deprecate;
      }
      _log(message, userFn, colorFn) {
        if (userFn != null && !isFunction4(userFn)) {
          throw new TypeError("Extensions to knex logger must be functions!");
        }
        if (isFunction4(userFn)) {
          userFn(message);
          return;
        }
        if (!isString2(message)) {
          message = inspect(message, {
            depth: this._inspectionDepth,
            colors: this._enableColors
          });
        }
        console.log(colorFn ? colorFn(message) : message);
      }
      debug(message) {
        this._log(message, this._debug);
      }
      warn(message) {
        this._log(message, this._warn, color.yellow);
      }
      error(message) {
        this._log(message, this._error, color.red);
      }
      deprecate(method, alternative) {
        const message = `${method} is deprecated, please use ${alternative}`;
        this._log(message, this._deprecate, color.yellow);
      }
    };
    function resolveIsEnabledColors(enableColorsParam) {
      if (enableColorsParam != null) {
        return enableColorsParam;
      }
      if (process && process.stdout) {
        return process.stdout.isTTY;
      }
      return false;
    }
    module2.exports = Logger;
  }
});

// node_modules/knex/lib/migrations/migrate/migrator-configuration-merger.js
var require_migrator_configuration_merger = __commonJS({
  "node_modules/knex/lib/migrations/migrate/migrator-configuration-merger.js"(exports2, module2) {
    "use strict";
    var { FsMigrations } = require_fs_migrations();
    var Logger = require_logger();
    var { DEFAULT_LOAD_EXTENSIONS } = require_MigrationsLoader();
    var defaultLogger = new Logger();
    var CONFIG_DEFAULT = Object.freeze({
      extension: "js",
      loadExtensions: DEFAULT_LOAD_EXTENSIONS,
      tableName: "knex_migrations",
      schemaName: null,
      directory: "./migrations",
      disableTransactions: false,
      disableMigrationsListValidation: false,
      sortDirsSeparately: false
    });
    function getMergedConfig(config3, currentConfig, logger3 = defaultLogger) {
      const mergedConfig = Object.assign(
        {},
        CONFIG_DEFAULT,
        currentConfig || {},
        config3
      );
      if (config3 && // If user specifies any FS related config,
      // clear specified migrationSource to avoid ambiguity
      (config3.directory || config3.sortDirsSeparately !== void 0 || config3.loadExtensions)) {
        if (config3.migrationSource) {
          logger3.warn(
            "FS-related option specified for migration configuration. This resets migrationSource to default FsMigrations"
          );
        }
        mergedConfig.migrationSource = null;
      }
      if (!mergedConfig.migrationSource) {
        mergedConfig.migrationSource = new FsMigrations(
          mergedConfig.directory,
          mergedConfig.sortDirsSeparately,
          mergedConfig.loadExtensions
        );
      }
      return mergedConfig;
    }
    module2.exports = {
      getMergedConfig
    };
  }
});

// node_modules/knex/lib/migrations/util/timestamp.js
var require_timestamp = __commonJS({
  "node_modules/knex/lib/migrations/util/timestamp.js"(exports2, module2) {
    "use strict";
    function yyyymmddhhmmss() {
      const now2 = /* @__PURE__ */ new Date();
      return now2.getUTCFullYear().toString() + (now2.getUTCMonth() + 1).toString().padStart(2, "0") + now2.getUTCDate().toString().padStart(2, "0") + now2.getUTCHours().toString().padStart(2, "0") + now2.getUTCMinutes().toString().padStart(2, "0") + now2.getUTCSeconds().toString().padStart(2, "0");
    }
    module2.exports = { yyyymmddhhmmss };
  }
});

// node_modules/knex/lib/migrations/migrate/MigrationGenerator.js
var require_MigrationGenerator = __commonJS({
  "node_modules/knex/lib/migrations/migrate/MigrationGenerator.js"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var { writeJsFileUsingTemplate } = require_template2();
    var { getMergedConfig } = require_migrator_configuration_merger();
    var { ensureDirectoryExists } = require_fs5();
    var { yyyymmddhhmmss } = require_timestamp();
    var MigrationGenerator = class {
      constructor(migrationConfig, logger3) {
        this.config = getMergedConfig(migrationConfig, void 0, logger3);
      }
      // Creates a new migration, with a given name.
      async make(name28, config3, logger3) {
        this.config = getMergedConfig(config3, this.config, logger3);
        if (!name28) {
          return Promise.reject(
            new Error("A name must be specified for the generated migration")
          );
        }
        await this._ensureFolder();
        const createdMigrationFilePath = await this._writeNewMigration(name28);
        return createdMigrationFilePath;
      }
      // Ensures a folder for the migrations exist, dependent on the migration
      // config settings.
      _ensureFolder() {
        const dirs = this._absoluteConfigDirs();
        const promises6 = dirs.map(ensureDirectoryExists);
        return Promise.all(promises6);
      }
      _getStubPath() {
        return this.config.stub || path33.join(__dirname, "stub", this.config.extension + ".stub");
      }
      _getNewMigrationName(name28) {
        if (name28[0] === "-") name28 = name28.slice(1);
        return yyyymmddhhmmss() + "_" + name28 + "." + this.config.extension.split("-")[0];
      }
      _getNewMigrationPath(name28) {
        const fileName = this._getNewMigrationName(name28);
        const dirs = this._absoluteConfigDirs();
        const dir = dirs.slice(-1)[0];
        return path33.join(dir, fileName);
      }
      // Write a new migration to disk, using the config and generated filename,
      // passing any `variables` given in the config to the template.
      async _writeNewMigration(name28) {
        const migrationPath = this._getNewMigrationPath(name28);
        await writeJsFileUsingTemplate(
          migrationPath,
          this._getStubPath(),
          { variable: "d" },
          this.config.variables || {}
        );
        return migrationPath;
      }
      _absoluteConfigDirs() {
        const directories = Array.isArray(this.config.directory) ? this.config.directory : [this.config.directory];
        return directories.map((directory) => {
          if (!directory) {
            console.warn(
              "Failed to resolve config file, knex cannot determine where to generate migrations"
            );
          }
          return path33.resolve(process.cwd(), directory);
        });
      }
    };
    module2.exports = MigrationGenerator;
  }
});

// node_modules/knex/lib/migrations/migrate/Migrator.js
var require_Migrator = __commonJS({
  "node_modules/knex/lib/migrations/migrate/Migrator.js"(exports2, module2) {
    "use strict";
    var differenceWith = require_differenceWith();
    var get2 = require_get2();
    var isEmpty = require_isEmpty();
    var max = require_max2();
    var {
      getLockTableName,
      getTable,
      getTableName
    } = require_table_resolver();
    var { getSchemaBuilder } = require_table_creator();
    var migrationListResolver = require_migration_list_resolver();
    var MigrationGenerator = require_MigrationGenerator();
    var { getMergedConfig } = require_migrator_configuration_merger();
    var { isBoolean: isBoolean2, isFunction: isFunction4 } = require_is();
    var LockError = class extends Error {
      constructor(msg) {
        super(msg);
        this.name = "MigrationLocked";
      }
    };
    var Migrator = class {
      constructor(knex3) {
        if (isFunction4(knex3)) {
          if (!knex3.isTransaction) {
            this.knex = knex3.withUserParams({
              ...knex3.userParams
            });
          } else {
            this.knex = knex3;
          }
        } else {
          this.knex = Object.assign({}, knex3);
          this.knex.userParams = this.knex.userParams || {};
        }
        this.config = getMergedConfig(
          this.knex.client.config.migrations,
          void 0,
          this.knex.client.logger
        );
        this.generator = new MigrationGenerator(
          this.knex.client.config.migrations,
          this.knex.client.logger
        );
        this._activeMigration = {
          fileName: null
        };
      }
      // Migrators to the latest configuration.
      async latest(config3) {
        this._disableProcessing();
        this.config = getMergedConfig(config3, this.config, this.knex.client.logger);
        const allAndCompleted = await migrationListResolver.listAllAndCompleted(
          this.config,
          this.knex
        );
        if (!this.config.disableMigrationsListValidation) {
          validateMigrationList(this.config.migrationSource, allAndCompleted);
        }
        const [all3, completed] = allAndCompleted;
        const migrations = getNewMigrations(
          this.config.migrationSource,
          all3,
          completed
        );
        const transactionForAll = !this.config.disableTransactions && !(await Promise.all(
          migrations.map(async (migration) => {
            const migrationContents = await this.config.migrationSource.getMigration(migration);
            return !this._useTransaction(migrationContents);
          })
        )).some((isTransactionUsed) => isTransactionUsed);
        if (transactionForAll) {
          return this.knex.transaction((trx) => {
            return this._runBatch(migrations, "up", trx);
          });
        } else {
          return this._runBatch(migrations, "up");
        }
      }
      // Runs the next migration that has not yet been run
      async up(config3) {
        this._disableProcessing();
        this.config = getMergedConfig(config3, this.config, this.knex.client.logger);
        const allAndCompleted = await migrationListResolver.listAllAndCompleted(
          this.config,
          this.knex
        );
        if (!this.config.disableMigrationsListValidation) {
          validateMigrationList(this.config.migrationSource, allAndCompleted);
        }
        const [all3, completed] = allAndCompleted;
        const newMigrations = getNewMigrations(
          this.config.migrationSource,
          all3,
          completed
        );
        let migrationToRun;
        const name28 = this.config.name;
        if (name28) {
          if (!completed.map((m) => m.name).includes(name28)) {
            migrationToRun = newMigrations.find((migration) => {
              return this.config.migrationSource.getMigrationName(migration) === name28;
            });
            if (!migrationToRun) {
              throw new Error(`Migration "${name28}" not found.`);
            }
          }
        } else {
          migrationToRun = newMigrations[0];
        }
        const useTransaction = !migrationToRun || this._useTransaction(
          await this.config.migrationSource.getMigration(migrationToRun)
        );
        const migrationsToRun = [];
        if (migrationToRun) {
          migrationsToRun.push(migrationToRun);
        }
        const transactionForAll = !this.config.disableTransactions && (!migrationToRun || useTransaction);
        if (transactionForAll) {
          return await this.knex.transaction((trx) => {
            return this._runBatch(migrationsToRun, "up", trx);
          });
        } else {
          return await this._runBatch(migrationsToRun, "up");
        }
      }
      // Rollback the last "batch", or all, of migrations that were run.
      rollback(config3, all3 = false) {
        this._disableProcessing();
        return new Promise((resolve3, reject) => {
          try {
            this.config = getMergedConfig(
              config3,
              this.config,
              this.knex.client.logger
            );
          } catch (e) {
            reject(e);
          }
          migrationListResolver.listAllAndCompleted(this.config, this.knex).then((value) => {
            if (!this.config.disableMigrationsListValidation) {
              validateMigrationList(this.config.migrationSource, value);
            }
            return value;
          }).then((val) => {
            const [allMigrations, completedMigrations] = val;
            return all3 ? allMigrations.filter((migration) => {
              return completedMigrations.map((migration2) => migration2.name).includes(
                this.config.migrationSource.getMigrationName(migration)
              );
            }).reverse() : this._getLastBatch(val);
          }).then((migrations) => {
            return this._runBatch(migrations, "down");
          }).then(resolve3, reject);
        });
      }
      down(config3) {
        this._disableProcessing();
        this.config = getMergedConfig(config3, this.config, this.knex.client.logger);
        return migrationListResolver.listAllAndCompleted(this.config, this.knex).then((value) => {
          if (!this.config.disableMigrationsListValidation) {
            validateMigrationList(this.config.migrationSource, value);
          }
          return value;
        }).then(([all3, completed]) => {
          const completedMigrations = all3.filter((migration) => {
            return completed.map((migration2) => migration2.name).includes(this.config.migrationSource.getMigrationName(migration));
          });
          let migrationToRun;
          const name28 = this.config.name;
          if (name28) {
            migrationToRun = completedMigrations.find((migration) => {
              return this.config.migrationSource.getMigrationName(migration) === name28;
            });
            if (!migrationToRun) {
              throw new Error(`Migration "${name28}" was not run.`);
            }
          } else {
            migrationToRun = completedMigrations[completedMigrations.length - 1];
          }
          const migrationsToRun = [];
          if (migrationToRun) {
            migrationsToRun.push(migrationToRun);
          }
          return this._runBatch(migrationsToRun, "down");
        });
      }
      status(config3) {
        this._disableProcessing();
        this.config = getMergedConfig(config3, this.config, this.knex.client.logger);
        return Promise.all([
          getTable(this.knex, this.config.tableName, this.config.schemaName).select(
            "*"
          ),
          migrationListResolver.listAll(this.config.migrationSource)
        ]).then(([db2, code]) => db2.length - code.length);
      }
      // Retrieves and returns the current migration version we're on, as a promise.
      // If no migrations have been run yet, return "none".
      currentVersion(config3) {
        this._disableProcessing();
        this.config = getMergedConfig(config3, this.config, this.knex.client.logger);
        return migrationListResolver.listCompleted(this.config.tableName, this.config.schemaName, this.knex).then((completed) => {
          const val = max(completed.map((value) => value.name.split("_")[0]));
          return val === void 0 ? "none" : val;
        });
      }
      // list all migrations
      async list(config3) {
        this._disableProcessing();
        this.config = getMergedConfig(config3, this.config, this.knex.client.logger);
        const [all3, completed] = await migrationListResolver.listAllAndCompleted(
          this.config,
          this.knex
        );
        if (!this.config.disableMigrationsListValidation) {
          validateMigrationList(this.config.migrationSource, [all3, completed]);
        }
        const newMigrations = getNewMigrations(
          this.config.migrationSource,
          all3,
          completed
        );
        return [completed, newMigrations];
      }
      async forceFreeMigrationsLock(config3) {
        this._disableProcessing();
        this.config = getMergedConfig(config3, this.config, this.knex.client.logger);
        const { schemaName, tableName } = this.config;
        const lockTableName = getLockTableName(tableName);
        const { knex: knex3 } = this;
        const getLockTable = () => getTable(knex3, lockTableName, schemaName);
        const tableExists = await getSchemaBuilder(knex3, schemaName).hasTable(
          lockTableName
        );
        if (tableExists) {
          await getLockTable().del();
          await getLockTable().insert({
            is_locked: 0
          });
        }
      }
      // Creates a new migration, with a given name.
      make(name28, config3) {
        return this.generator.make(name28, config3, this.knex.client.logger);
      }
      _disableProcessing() {
        if (this.knex.disableProcessing) {
          this.knex.disableProcessing();
        }
      }
      _lockMigrations(trx) {
        const tableName = getLockTableName(this.config.tableName);
        return getTable(this.knex, tableName, this.config.schemaName).transacting(trx).where("is_locked", "=", 0).update({ is_locked: 1 }).then((rowCount) => {
          if (rowCount !== 1) {
            throw new Error("Migration table is already locked");
          }
        });
      }
      _getLock(trx) {
        const transact = trx ? (fn) => fn(trx) : (fn) => this.knex.transaction(fn);
        return transact((trx2) => {
          return this._lockMigrations(trx2);
        }).catch((err) => {
          throw new LockError(err.message);
        });
      }
      _freeLock(trx = this.knex) {
        const tableName = getLockTableName(this.config.tableName);
        return getTable(trx, tableName, this.config.schemaName).update({
          is_locked: 0
        });
      }
      // Run a batch of current migrations, in sequence.
      async _runBatch(migrations, direction, trx) {
        const canGetLockInTransaction = this.knex.client.driverName !== "cockroachdb";
        try {
          await this._getLock(canGetLockInTransaction ? trx : void 0);
          const completed = trx ? await migrationListResolver.listCompleted(
            this.config.tableName,
            this.config.schemaName,
            trx
          ) : [];
          migrations = getNewMigrations(
            this.config.migrationSource,
            migrations,
            completed
          );
          await Promise.all(
            migrations.map(this._validateMigrationStructure.bind(this))
          );
          let batchNo = await this._latestBatchNumber(trx);
          const beforeAll = this.config.beforeAll || (() => {
          });
          const afterAll = this.config.afterAll || (() => {
          });
          let res = [batchNo, []];
          if (migrations.length > 0) {
            if (direction === "up") batchNo++;
            await beforeAll(trx || this.knex, migrations);
            res = await this._waterfallBatch(batchNo, migrations, direction, trx);
            await afterAll(trx || this.knex, migrations);
          }
          await this._freeLock(canGetLockInTransaction ? trx : void 0);
          return res;
        } catch (error73) {
          let cleanupReady = Promise.resolve();
          if (error73 instanceof LockError) {
            this.knex.client.logger.warn(
              `Can't take lock to run migrations: ${error73.message}`
            );
            this.knex.client.logger.warn(
              "If you are sure migrations are not running you can release the lock manually by running 'knex migrate:unlock'"
            );
          } else {
            if (this._activeMigration.fileName) {
              this.knex.client.logger.warn(
                `migration file "${this._activeMigration.fileName}" failed`
              );
            }
            this.knex.client.logger.warn(
              `migration failed with error: ${error73.message}`
            );
            cleanupReady = this._freeLock(
              canGetLockInTransaction ? trx : void 0
            );
          }
          try {
            await cleanupReady;
          } catch (e) {
          }
          throw error73;
        }
      }
      // Validates some migrations by requiring and checking for an `up` and `down`
      // function.
      async _validateMigrationStructure(migration) {
        const migrationName = this.config.migrationSource.getMigrationName(migration);
        const migrationContent = await this.config.migrationSource.getMigration(
          migration
        );
        if (typeof migrationContent.up !== "function" || typeof migrationContent.down !== "function") {
          throw new Error(
            `Invalid migration: ${migrationName} must have both an up and down function`
          );
        }
        return migration;
      }
      // Get the last batch of migrations, by name, ordered by insert id in reverse
      // order.
      async _getLastBatch([allMigrations]) {
        const { tableName, schemaName } = this.config;
        const migrationNames = await getTable(this.knex, tableName, schemaName).where("batch", function(qb) {
          qb.max("batch").from(getTableName(tableName, schemaName));
        }).orderBy("id", "desc");
        const lastBatchMigrations = migrationNames.map((migration) => {
          return allMigrations.find((entry) => {
            return this.config.migrationSource.getMigrationName(entry) === migration.name;
          });
        });
        return Promise.all(lastBatchMigrations);
      }
      // Returns the latest batch number.
      _latestBatchNumber(trx = this.knex) {
        return trx.from(getTableName(this.config.tableName, this.config.schemaName)).max("batch as max_batch").then((obj) => obj[0].max_batch || 0);
      }
      // If transaction config for a single migration is defined, use that.
      // Otherwise, rely on the common config. This allows enabling/disabling
      // transaction for a single migration at will, regardless of the common
      // config.
      _useTransaction(migrationContent, allTransactionsDisabled) {
        const singleTransactionValue = get2(migrationContent, "config.transaction");
        const useTransaction = isBoolean2(singleTransactionValue) ? singleTransactionValue : !allTransactionsDisabled;
        return useTransaction;
      }
      // Runs a batch of `migrations` in a specified `direction`, saving the
      // appropriate database information as the migrations are run.
      _waterfallBatch(batchNo, migrations, direction, trx) {
        const trxOrKnex = trx || this.knex;
        const { tableName, schemaName, disableTransactions } = this.config;
        let current = Promise.resolve();
        const log = [];
        migrations.forEach((migration) => {
          const name28 = this.config.migrationSource.getMigrationName(migration);
          this._activeMigration.fileName = name28;
          const migrationContent = this.config.migrationSource.getMigration(migration);
          const beforeEach = this.config.beforeEach || (() => {
          });
          const afterEach = this.config.afterEach || (() => {
          });
          current = current.then(async () => await migrationContent).then(async (migrationContent2) => {
            this._activeMigration.fileName = name28;
            if (!trx && this._useTransaction(migrationContent2, disableTransactions)) {
              this.knex.enableProcessing();
              return await this.knex.transaction(async (trx2) => {
                await beforeEach(trx2, [migration]);
                const migrationResult2 = await checkPromise(
                  this.knex.client.logger,
                  migrationContent2[direction](trx2),
                  name28
                );
                await afterEach(trx2, [migration]);
                return migrationResult2;
              });
            }
            trxOrKnex.enableProcessing();
            await beforeEach(trxOrKnex, [migration]);
            const migrationResult = await checkPromise(
              this.knex.client.logger,
              migrationContent2[direction](trxOrKnex),
              name28
            );
            await afterEach(trxOrKnex, [migration]);
            return migrationResult;
          }).then(() => {
            trxOrKnex.disableProcessing();
            this.knex.disableProcessing();
            log.push(name28);
            if (direction === "up") {
              return trxOrKnex.into(getTableName(tableName, schemaName)).insert({
                name: name28,
                batch: batchNo,
                migration_time: /* @__PURE__ */ new Date()
              });
            }
            if (direction === "down") {
              return trxOrKnex.from(getTableName(tableName, schemaName)).where({ name: name28 }).del();
            }
          });
        });
        return current.then(() => [batchNo, log]);
      }
      _transaction(knex3, migrationContent, direction, name28) {
        return knex3.transaction((trx) => {
          return checkPromise(
            knex3.client.logger,
            migrationContent[direction](trx),
            name28,
            () => {
              trx.commit();
            }
          );
        });
      }
    };
    function validateMigrationList(migrationSource, migrations) {
      const [all3, completed] = migrations;
      const diff = getMissingMigrations(migrationSource, completed, all3);
      if (!isEmpty(diff)) {
        const names = diff.map((d) => d.name);
        throw new Error(
          `The migration directory is corrupt, the following files are missing: ${names.join(
            ", "
          )}`
        );
      }
    }
    function getMissingMigrations(migrationSource, completed, all3) {
      return differenceWith(completed, all3, (c, a) => {
        return c.name === migrationSource.getMigrationName(a);
      });
    }
    function getNewMigrations(migrationSource, all3, completed) {
      return differenceWith(all3, completed, (a, c) => {
        return c.name === migrationSource.getMigrationName(a);
      });
    }
    function checkPromise(logger3, migrationPromise, name28) {
      if (!migrationPromise || typeof migrationPromise.then !== "function") {
        logger3.warn(`migration ${name28} did not return a promise`);
      }
      return migrationPromise;
    }
    module2.exports = {
      Migrator
    };
  }
});

// node_modules/lodash/isString.js
var require_isString = __commonJS({
  "node_modules/lodash/isString.js"(exports2, module2) {
    "use strict";
    var baseGetTag2 = require_baseGetTag();
    var isArray3 = require_isArray();
    var isObjectLike2 = require_isObjectLike();
    var stringTag3 = "[object String]";
    function isString2(value) {
      return typeof value == "string" || !isArray3(value) && isObjectLike2(value) && baseGetTag2(value) == stringTag3;
    }
    module2.exports = isString2;
  }
});

// node_modules/lodash/_trimmedEndIndex.js
var require_trimmedEndIndex = __commonJS({
  "node_modules/lodash/_trimmedEndIndex.js"(exports2, module2) {
    "use strict";
    var reWhitespace = /\s/;
    function trimmedEndIndex(string5) {
      var index = string5.length;
      while (index-- && reWhitespace.test(string5.charAt(index))) {
      }
      return index;
    }
    module2.exports = trimmedEndIndex;
  }
});

// node_modules/lodash/_baseTrim.js
var require_baseTrim = __commonJS({
  "node_modules/lodash/_baseTrim.js"(exports2, module2) {
    "use strict";
    var trimmedEndIndex = require_trimmedEndIndex();
    var reTrimStart = /^\s+/;
    function baseTrim(string5) {
      return string5 ? string5.slice(0, trimmedEndIndex(string5) + 1).replace(reTrimStart, "") : string5;
    }
    module2.exports = baseTrim;
  }
});

// node_modules/lodash/toNumber.js
var require_toNumber = __commonJS({
  "node_modules/lodash/toNumber.js"(exports2, module2) {
    "use strict";
    var baseTrim = require_baseTrim();
    var isObject5 = require_isObject();
    var isSymbol2 = require_isSymbol();
    var NAN = 0 / 0;
    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
    var reIsBinary = /^0b[01]+$/i;
    var reIsOctal = /^0o[0-7]+$/i;
    var freeParseInt = parseInt;
    function toNumber2(value) {
      if (typeof value == "number") {
        return value;
      }
      if (isSymbol2(value)) {
        return NAN;
      }
      if (isObject5(value)) {
        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
        value = isObject5(other) ? other + "" : other;
      }
      if (typeof value != "string") {
        return value === 0 ? value : +value;
      }
      value = baseTrim(value);
      var isBinary = reIsBinary.test(value);
      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
    }
    module2.exports = toNumber2;
  }
});

// node_modules/lodash/toFinite.js
var require_toFinite = __commonJS({
  "node_modules/lodash/toFinite.js"(exports2, module2) {
    "use strict";
    var toNumber2 = require_toNumber();
    var INFINITY4 = 1 / 0;
    var MAX_INTEGER = 17976931348623157e292;
    function toFinite(value) {
      if (!value) {
        return value === 0 ? value : 0;
      }
      value = toNumber2(value);
      if (value === INFINITY4 || value === -INFINITY4) {
        var sign = value < 0 ? -1 : 1;
        return sign * MAX_INTEGER;
      }
      return value === value ? value : 0;
    }
    module2.exports = toFinite;
  }
});

// node_modules/lodash/toInteger.js
var require_toInteger = __commonJS({
  "node_modules/lodash/toInteger.js"(exports2, module2) {
    "use strict";
    var toFinite = require_toFinite();
    function toInteger(value) {
      var result = toFinite(value), remainder = result % 1;
      return result === result ? remainder ? result - remainder : result : 0;
    }
    module2.exports = toInteger;
  }
});

// node_modules/lodash/values.js
var require_values = __commonJS({
  "node_modules/lodash/values.js"(exports2, module2) {
    "use strict";
    var baseValues = require_baseValues();
    var keys2 = require_keys();
    function values(object4) {
      return object4 == null ? [] : baseValues(object4, keys2(object4));
    }
    module2.exports = values;
  }
});

// node_modules/lodash/includes.js
var require_includes = __commonJS({
  "node_modules/lodash/includes.js"(exports2, module2) {
    "use strict";
    var baseIndexOf2 = require_baseIndexOf();
    var isArrayLike2 = require_isArrayLike();
    var isString2 = require_isString();
    var toInteger = require_toInteger();
    var values = require_values();
    var nativeMax = Math.max;
    function includes(collection, value, fromIndex, guard) {
      collection = isArrayLike2(collection) ? collection : values(collection);
      fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
      var length = collection.length;
      if (fromIndex < 0) {
        fromIndex = nativeMax(length + fromIndex, 0);
      }
      return isString2(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf2(collection, value, fromIndex) > -1;
    }
    module2.exports = includes;
  }
});

// node_modules/knex/lib/migrations/seed/sources/fs-seeds.js
var require_fs_seeds = __commonJS({
  "node_modules/knex/lib/migrations/seed/sources/fs-seeds.js"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var flatten = require_flatten();
    var includes = require_includes();
    var { AbstractMigrationsLoader } = require_MigrationsLoader();
    var { getFilepathsInFolder } = require_fs5();
    var filterByLoadExtensions = (extensions) => (value) => {
      const extension = path33.extname(value);
      return includes(extensions, extension);
    };
    var FsSeeds = class extends AbstractMigrationsLoader {
      _getConfigDirectories(logger3) {
        const directories = this.migrationsPaths;
        return directories.map((directory) => {
          if (!directory) {
            logger3.warn(
              "Empty value passed as a directory for Seeder, this is not supported."
            );
          }
          return path33.resolve(process.cwd(), directory);
        });
      }
      async getSeeds(config3) {
        const { loadExtensions, recursive, specific } = config3;
        const seeds = flatten(
          await Promise.all(
            this._getConfigDirectories(config3.logger).map(
              (d) => getFilepathsInFolder(d, recursive)
            )
          )
        );
        let files = seeds.filter(filterByLoadExtensions(loadExtensions));
        if (!this.sortDirsSeparately) {
          files.sort();
        }
        if (specific) {
          files = files.filter((file3) => path33.basename(file3) === specific);
          if (files.length === 0) {
            throw new Error(
              `Invalid argument provided: the specific seed "${specific}" does not exist.`
            );
          }
        }
        return files;
      }
      async getSeed(filepath) {
        const importFile = require_import_file();
        const seed = await importFile(filepath);
        return seed;
      }
    };
    module2.exports = {
      FsSeeds
    };
  }
});

// node_modules/knex/lib/migrations/seed/seeder-configuration-merger.js
var require_seeder_configuration_merger = __commonJS({
  "node_modules/knex/lib/migrations/seed/seeder-configuration-merger.js"(exports2, module2) {
    "use strict";
    var { FsSeeds } = require_fs_seeds();
    var Logger = require_logger();
    var { DEFAULT_LOAD_EXTENSIONS } = require_MigrationsLoader();
    var defaultLogger = new Logger();
    var CONFIG_DEFAULT = Object.freeze({
      extension: "js",
      directory: "./seeds",
      loadExtensions: DEFAULT_LOAD_EXTENSIONS,
      specific: null,
      timestampFilenamePrefix: false,
      recursive: false,
      sortDirsSeparately: false
    });
    function getMergedConfig(config3, currentConfig, logger3 = defaultLogger) {
      const mergedConfig = Object.assign(
        {},
        CONFIG_DEFAULT,
        currentConfig || {},
        config3,
        {
          logger: logger3
        }
      );
      if (config3 && // If user specifies any FS related config,
      // clear specified migrationSource to avoid ambiguity
      (config3.directory || config3.sortDirsSeparately !== void 0 || config3.loadExtensions)) {
        if (config3.seedSource) {
          logger3.warn(
            "FS-related option specified for seed configuration. This resets seedSource to default FsMigrations"
          );
        }
        mergedConfig.seedSource = null;
      }
      if (!mergedConfig.seedSource) {
        mergedConfig.seedSource = new FsSeeds(
          mergedConfig.directory,
          mergedConfig.sortDirsSeparately,
          mergedConfig.loadExtensions
        );
      }
      return mergedConfig;
    }
    module2.exports = {
      getMergedConfig
    };
  }
});

// node_modules/knex/lib/migrations/seed/Seeder.js
var require_Seeder = __commonJS({
  "node_modules/knex/lib/migrations/seed/Seeder.js"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var { ensureDirectoryExists } = require_fs5();
    var { writeJsFileUsingTemplate } = require_template2();
    var { yyyymmddhhmmss } = require_timestamp();
    var { getMergedConfig } = require_seeder_configuration_merger();
    var Seeder = class {
      constructor(knex3) {
        this.knex = knex3;
        this.config = this.resolveConfig(knex3.client.config.seeds);
      }
      // Runs seed files for the given environment.
      async run(config3) {
        this.config = this.resolveConfig(config3);
        const files = await this.config.seedSource.getSeeds(this.config);
        return this._runSeeds(files);
      }
      // Creates a new seed file, with a given name.
      async make(name28, config3) {
        this.config = this.resolveConfig(config3);
        if (!name28)
          throw new Error("A name must be specified for the generated seed");
        await this._ensureFolder(config3);
        const seedPath = await this._writeNewSeed(name28);
        return seedPath;
      }
      // Ensures a folder for the seeds exist, dependent on the
      // seed config settings.
      _ensureFolder() {
        const dirs = this.config.seedSource._getConfigDirectories(
          this.config.logger
        );
        const promises6 = dirs.map(ensureDirectoryExists);
        return Promise.all(promises6);
      }
      // Run seed files, in sequence.
      async _runSeeds(seeds) {
        for (const seed of seeds) {
          await this._validateSeedStructure(seed);
        }
        return this._waterfallBatch(seeds);
      }
      async _validateSeedStructure(filepath) {
        const seed = await this.config.seedSource.getSeed(filepath);
        if (typeof seed.seed !== "function") {
          throw new Error(
            `Invalid seed file: ${filepath} must have a seed function`
          );
        }
        return filepath;
      }
      _getStubPath() {
        return this.config.stub || path33.join(__dirname, "stub", this.config.extension + ".stub");
      }
      _getNewStubFileName(name28) {
        if (name28[0] === "-") name28 = name28.slice(1);
        if (this.config.timestampFilenamePrefix === true) {
          name28 = `${yyyymmddhhmmss()}_${name28}`;
        }
        return `${name28}.${this.config.extension}`;
      }
      _getNewStubFilePath(name28) {
        const fileName = this._getNewStubFileName(name28);
        const dirs = this.config.seedSource._getConfigDirectories(
          this.config.logger
        );
        const dir = dirs.slice(-1)[0];
        return path33.join(dir, fileName);
      }
      // Write a new seed to disk, using the config and generated filename,
      // passing any `variables` given in the config to the template.
      async _writeNewSeed(name28) {
        const seedPath = this._getNewStubFilePath(name28);
        await writeJsFileUsingTemplate(
          seedPath,
          this._getStubPath(),
          { variable: "d" },
          this.config.variables || {}
        );
        return seedPath;
      }
      async _listAll(config3) {
        this.config = this.resolveConfig(config3);
        return this.config.seedSource.getSeeds(this.config);
      }
      // Runs a batch of seed files.
      async _waterfallBatch(seeds) {
        const { knex: knex3 } = this;
        const log = [];
        for (const seedPath of seeds) {
          const seed = await this.config.seedSource.getSeed(seedPath);
          try {
            await seed.seed(knex3);
            log.push(seedPath);
          } catch (originalError) {
            const error73 = new Error(
              `Error while executing "${seedPath}" seed: ${originalError.message}`
            );
            error73.original = originalError;
            error73.stack = error73.stack.split("\n").slice(0, 2).join("\n") + "\n" + originalError.stack;
            throw error73;
          }
        }
        return [log];
      }
      resolveConfig(config3) {
        return getMergedConfig(config3, this.config, this.knex.client.logger);
      }
    };
    module2.exports = Seeder;
  }
});

// node_modules/knex/lib/knex-builder/FunctionHelper.js
var require_FunctionHelper = __commonJS({
  "node_modules/knex/lib/knex-builder/FunctionHelper.js"(exports2, module2) {
    "use strict";
    var FunctionHelper = class {
      constructor(client) {
        this.client = client;
      }
      now(precision) {
        if (typeof precision === "number") {
          return this.client.raw(`CURRENT_TIMESTAMP(${precision})`);
        }
        return this.client.raw("CURRENT_TIMESTAMP");
      }
      uuid() {
        switch (this.client.driverName) {
          case "sqlite3":
          case "better-sqlite3":
            return this.client.raw(
              "(lower(hex(randomblob(4))) || '-' || lower(hex(randomblob(2))) || '-4' || substr(lower(hex(randomblob(2))),2) || '-' || substr('89ab',abs(random()) % 4 + 1, 1) || substr(lower(hex(randomblob(2))),2) || '-' || lower(hex(randomblob(6))))"
            );
          case "mssql":
            return this.client.raw("(NEWID())");
          case "pg":
          case "pgnative":
          case "cockroachdb":
            return this.client.raw("(gen_random_uuid())");
          case "oracle":
          case "oracledb":
            return this.client.raw("(random_uuid())");
          case "mysql":
          case "mysql2":
            return this.client.raw("(UUID())");
          default:
            throw new Error(
              `${this.client.driverName} does not have a uuid function`
            );
        }
      }
      uuidToBin(uuid5, ordered = true) {
        const buf = Buffer.from(uuid5.replace(/-/g, ""), "hex");
        return ordered ? Buffer.concat([
          buf.slice(6, 8),
          buf.slice(4, 6),
          buf.slice(0, 4),
          buf.slice(8, 16)
        ]) : Buffer.concat([
          buf.slice(0, 4),
          buf.slice(4, 6),
          buf.slice(6, 8),
          buf.slice(8, 16)
        ]);
      }
      binToUuid(bin, ordered = true) {
        const buf = Buffer.from(bin, "hex");
        return ordered ? [
          buf.toString("hex", 4, 8),
          buf.toString("hex", 2, 4),
          buf.toString("hex", 0, 2),
          buf.toString("hex", 8, 10),
          buf.toString("hex", 10, 16)
        ].join("-") : [
          buf.toString("hex", 0, 4),
          buf.toString("hex", 4, 6),
          buf.toString("hex", 6, 8),
          buf.toString("hex", 8, 10),
          buf.toString("hex", 10, 16)
        ].join("-");
      }
    };
    module2.exports = FunctionHelper;
  }
});

// node_modules/knex/lib/query/method-constants.js
var require_method_constants = __commonJS({
  "node_modules/knex/lib/query/method-constants.js"(exports2, module2) {
    "use strict";
    module2.exports = [
      "with",
      "withRecursive",
      "withMaterialized",
      "withNotMaterialized",
      "select",
      "as",
      "columns",
      "column",
      "from",
      "fromJS",
      "fromRaw",
      "into",
      "withSchema",
      "table",
      "distinct",
      "join",
      "joinRaw",
      "innerJoin",
      "leftJoin",
      "leftOuterJoin",
      "rightJoin",
      "rightOuterJoin",
      "outerJoin",
      "fullOuterJoin",
      "crossJoin",
      "where",
      "andWhere",
      "orWhere",
      "whereNot",
      "orWhereNot",
      "whereLike",
      "andWhereLike",
      "orWhereLike",
      "whereILike",
      "andWhereILike",
      "orWhereILike",
      "whereRaw",
      "whereWrapped",
      "havingWrapped",
      "orWhereRaw",
      "whereExists",
      "orWhereExists",
      "whereNotExists",
      "orWhereNotExists",
      "whereIn",
      "orWhereIn",
      "whereNotIn",
      "orWhereNotIn",
      "whereNull",
      "orWhereNull",
      "whereNotNull",
      "orWhereNotNull",
      "whereBetween",
      "whereNotBetween",
      "andWhereBetween",
      "andWhereNotBetween",
      "orWhereBetween",
      "orWhereNotBetween",
      "groupBy",
      "groupByRaw",
      "orderBy",
      "orderByRaw",
      "union",
      "unionAll",
      "intersect",
      "except",
      "having",
      "havingRaw",
      "orHaving",
      "orHavingRaw",
      "offset",
      "limit",
      "count",
      "countDistinct",
      "min",
      "max",
      "sum",
      "sumDistinct",
      "avg",
      "avgDistinct",
      "increment",
      "decrement",
      "first",
      "debug",
      "pluck",
      "clearSelect",
      "clearWhere",
      "clearGroup",
      "clearOrder",
      "clearHaving",
      "insert",
      "update",
      "returning",
      "del",
      "delete",
      "truncate",
      "transacting",
      "connection",
      // JSON methods
      // Json manipulation functions
      "jsonExtract",
      "jsonSet",
      "jsonInsert",
      "jsonRemove",
      // Wheres Json
      "whereJsonObject",
      "orWhereJsonObject",
      "andWhereJsonObject",
      "whereNotJsonObject",
      "orWhereNotJsonObject",
      "andWhereNotJsonObject",
      "whereJsonPath",
      "orWhereJsonPath",
      "andWhereJsonPath",
      "whereJsonSupersetOf",
      "orWhereJsonSupersetOf",
      "andWhereJsonSupersetOf",
      "whereJsonNotSupersetOf",
      "orWhereJsonNotSupersetOf",
      "andWhereJsonNotSupersetOf",
      "whereJsonSubsetOf",
      "orWhereJsonSubsetOf",
      "andWhereJsonSubsetOf",
      "whereJsonNotSubsetOf",
      "orWhereJsonNotSubsetOf",
      "andWhereJsonNotSubsetOf"
    ];
  }
});

// node_modules/lodash/_assignMergeValue.js
var require_assignMergeValue = __commonJS({
  "node_modules/lodash/_assignMergeValue.js"(exports2, module2) {
    "use strict";
    var baseAssignValue = require_baseAssignValue();
    var eq2 = require_eq();
    function assignMergeValue(object4, key, value) {
      if (value !== void 0 && !eq2(object4[key], value) || value === void 0 && !(key in object4)) {
        baseAssignValue(object4, key, value);
      }
    }
    module2.exports = assignMergeValue;
  }
});

// node_modules/lodash/_safeGet.js
var require_safeGet = __commonJS({
  "node_modules/lodash/_safeGet.js"(exports2, module2) {
    "use strict";
    function safeGet(object4, key) {
      if (key === "constructor" && typeof object4[key] === "function") {
        return;
      }
      if (key == "__proto__") {
        return;
      }
      return object4[key];
    }
    module2.exports = safeGet;
  }
});

// node_modules/lodash/toPlainObject.js
var require_toPlainObject = __commonJS({
  "node_modules/lodash/toPlainObject.js"(exports2, module2) {
    "use strict";
    var copyObject = require_copyObject();
    var keysIn = require_keysIn();
    function toPlainObject(value) {
      return copyObject(value, keysIn(value));
    }
    module2.exports = toPlainObject;
  }
});

// node_modules/lodash/_baseMergeDeep.js
var require_baseMergeDeep = __commonJS({
  "node_modules/lodash/_baseMergeDeep.js"(exports2, module2) {
    "use strict";
    var assignMergeValue = require_assignMergeValue();
    var cloneBuffer = require_cloneBuffer();
    var cloneTypedArray = require_cloneTypedArray();
    var copyArray = require_copyArray();
    var initCloneObject = require_initCloneObject();
    var isArguments2 = require_isArguments();
    var isArray3 = require_isArray();
    var isArrayLikeObject = require_isArrayLikeObject();
    var isBuffer3 = require_isBuffer();
    var isFunction4 = require_isFunction();
    var isObject5 = require_isObject();
    var isPlainObject4 = require_isPlainObject();
    var isTypedArray3 = require_isTypedArray();
    var safeGet = require_safeGet();
    var toPlainObject = require_toPlainObject();
    function baseMergeDeep(object4, source, key, srcIndex, mergeFunc, customizer, stack) {
      var objValue = safeGet(object4, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
      if (stacked) {
        assignMergeValue(object4, key, stacked);
        return;
      }
      var newValue = customizer ? customizer(objValue, srcValue, key + "", object4, source, stack) : void 0;
      var isCommon = newValue === void 0;
      if (isCommon) {
        var isArr = isArray3(srcValue), isBuff = !isArr && isBuffer3(srcValue), isTyped = !isArr && !isBuff && isTypedArray3(srcValue);
        newValue = srcValue;
        if (isArr || isBuff || isTyped) {
          if (isArray3(objValue)) {
            newValue = objValue;
          } else if (isArrayLikeObject(objValue)) {
            newValue = copyArray(objValue);
          } else if (isBuff) {
            isCommon = false;
            newValue = cloneBuffer(srcValue, true);
          } else if (isTyped) {
            isCommon = false;
            newValue = cloneTypedArray(srcValue, true);
          } else {
            newValue = [];
          }
        } else if (isPlainObject4(srcValue) || isArguments2(srcValue)) {
          newValue = objValue;
          if (isArguments2(objValue)) {
            newValue = toPlainObject(objValue);
          } else if (!isObject5(objValue) || isFunction4(objValue)) {
            newValue = initCloneObject(srcValue);
          }
        } else {
          isCommon = false;
        }
      }
      if (isCommon) {
        stack.set(srcValue, newValue);
        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
        stack["delete"](srcValue);
      }
      assignMergeValue(object4, key, newValue);
    }
    module2.exports = baseMergeDeep;
  }
});

// node_modules/lodash/_baseMerge.js
var require_baseMerge = __commonJS({
  "node_modules/lodash/_baseMerge.js"(exports2, module2) {
    "use strict";
    var Stack2 = require_Stack();
    var assignMergeValue = require_assignMergeValue();
    var baseFor = require_baseFor();
    var baseMergeDeep = require_baseMergeDeep();
    var isObject5 = require_isObject();
    var keysIn = require_keysIn();
    var safeGet = require_safeGet();
    function baseMerge(object4, source, srcIndex, customizer, stack) {
      if (object4 === source) {
        return;
      }
      baseFor(source, function(srcValue, key) {
        stack || (stack = new Stack2());
        if (isObject5(srcValue)) {
          baseMergeDeep(object4, source, key, srcIndex, baseMerge, customizer, stack);
        } else {
          var newValue = customizer ? customizer(safeGet(object4, key), srcValue, key + "", object4, source, stack) : void 0;
          if (newValue === void 0) {
            newValue = srcValue;
          }
          assignMergeValue(object4, key, newValue);
        }
      }, keysIn);
    }
    module2.exports = baseMerge;
  }
});

// node_modules/lodash/merge.js
var require_merge = __commonJS({
  "node_modules/lodash/merge.js"(exports2, module2) {
    "use strict";
    var baseMerge = require_baseMerge();
    var createAssigner = require_createAssigner();
    var merge4 = createAssigner(function(object4, source, srcIndex) {
      baseMerge(object4, source, srcIndex);
    });
    module2.exports = merge4;
  }
});

// node_modules/lodash/_baseSlice.js
var require_baseSlice = __commonJS({
  "node_modules/lodash/_baseSlice.js"(exports2, module2) {
    "use strict";
    function baseSlice(array4, start, end) {
      var index = -1, length = array4.length;
      if (start < 0) {
        start = -start > length ? 0 : length + start;
      }
      end = end > length ? length : end;
      if (end < 0) {
        end += length;
      }
      length = start > end ? 0 : end - start >>> 0;
      start >>>= 0;
      var result = Array(length);
      while (++index < length) {
        result[index] = array4[index + start];
      }
      return result;
    }
    module2.exports = baseSlice;
  }
});

// node_modules/lodash/chunk.js
var require_chunk = __commonJS({
  "node_modules/lodash/chunk.js"(exports2, module2) {
    "use strict";
    var baseSlice = require_baseSlice();
    var isIterateeCall = require_isIterateeCall();
    var toInteger = require_toInteger();
    var nativeCeil = Math.ceil;
    var nativeMax = Math.max;
    function chunk(array4, size, guard) {
      if (guard ? isIterateeCall(array4, size, guard) : size === void 0) {
        size = 1;
      } else {
        size = nativeMax(toInteger(size), 0);
      }
      var length = array4 == null ? 0 : array4.length;
      if (!length || size < 1) {
        return [];
      }
      var index = 0, resIndex = 0, result = Array(nativeCeil(length / size));
      while (index < length) {
        result[resIndex++] = baseSlice(array4, index, index += size);
      }
      return result;
    }
    module2.exports = chunk;
  }
});

// node_modules/knex/lib/execution/internal/delay.js
var require_delay = __commonJS({
  "node_modules/knex/lib/execution/internal/delay.js"(exports2, module2) {
    "use strict";
    module2.exports = (delay2) => new Promise((resolve3) => setTimeout(resolve3, delay2));
  }
});

// node_modules/knex/lib/execution/batch-insert.js
var require_batch_insert = __commonJS({
  "node_modules/knex/lib/execution/batch-insert.js"(exports2, module2) {
    "use strict";
    var chunk = require_chunk();
    var flatten = require_flatten();
    var delay2 = require_delay();
    var { isNumber: isNumber2 } = require_is();
    function batchInsert(client, tableName, batch, chunkSize = 1e3) {
      let returning = void 0;
      let transaction = null;
      if (!isNumber2(chunkSize) || chunkSize < 1) {
        throw new TypeError(`Invalid chunkSize: ${chunkSize}`);
      }
      if (!Array.isArray(batch)) {
        throw new TypeError(`Invalid batch: Expected array, got ${typeof batch}`);
      }
      const chunks = chunk(batch, chunkSize);
      const runInTransaction = (cb) => {
        if (transaction) {
          return cb(transaction);
        }
        return client.transaction(cb);
      };
      return Object.assign(
        Promise.resolve().then(async () => {
          await delay2(1);
          return runInTransaction(async (tr) => {
            const chunksResults = [];
            for (const items of chunks) {
              chunksResults.push(await tr(tableName).insert(items, returning));
            }
            return flatten(chunksResults);
          });
        }),
        {
          returning(columns) {
            returning = columns;
            return this;
          },
          transacting(tr) {
            transaction = tr;
            return this;
          }
        }
      );
    }
    module2.exports = batchInsert;
  }
});

// node_modules/knex/lib/util/security.js
var require_security = __commonJS({
  "node_modules/knex/lib/util/security.js"(exports2, module2) {
    "use strict";
    function setHiddenProperty(target, source, propertyName = "password") {
      if (!source) {
        source = target;
      }
      Object.defineProperty(target, propertyName, {
        enumerable: false,
        value: source[propertyName]
      });
    }
    var hasOwn = /* @__PURE__ */ (() => {
      const hasOwnProperty11 = Object.prototype.hasOwnProperty;
      return (obj, key) => hasOwnProperty11.call(obj, key);
    })();
    module2.exports = {
      setHiddenProperty,
      hasOwn
    };
  }
});

// node_modules/knex/lib/knex-builder/make-knex.js
var require_make_knex = __commonJS({
  "node_modules/knex/lib/knex-builder/make-knex.js"(exports2, module2) {
    "use strict";
    var { EventEmitter: EventEmitter3 } = require("events");
    var { Migrator } = require_Migrator();
    var Seeder = require_Seeder();
    var FunctionHelper = require_FunctionHelper();
    var QueryInterface = require_method_constants();
    var merge4 = require_merge();
    var batchInsert = require_batch_insert();
    var { isObject: isObject5 } = require_is();
    var { setHiddenProperty } = require_security();
    var KNEX_PROPERTY_DEFINITIONS = {
      client: {
        get() {
          return this.context.client;
        },
        set(client) {
          this.context.client = client;
        },
        configurable: true
      },
      userParams: {
        get() {
          return this.context.userParams;
        },
        set(userParams) {
          this.context.userParams = userParams;
        },
        configurable: true
      },
      schema: {
        get() {
          return this.client.schemaBuilder();
        },
        configurable: true
      },
      migrate: {
        get() {
          return new Migrator(this);
        },
        configurable: true
      },
      seed: {
        get() {
          return new Seeder(this);
        },
        configurable: true
      },
      fn: {
        get() {
          return new FunctionHelper(this.client);
        },
        configurable: true
      }
    };
    var CONTEXT_METHODS = [
      "raw",
      "batchInsert",
      "transaction",
      "transactionProvider",
      "initialize",
      "destroy",
      "ref",
      "withUserParams",
      "queryBuilder",
      "disableProcessing",
      "enableProcessing"
    ];
    for (const m of CONTEXT_METHODS) {
      KNEX_PROPERTY_DEFINITIONS[m] = {
        value: function(...args) {
          return this.context[m](...args);
        },
        configurable: true
      };
    }
    function makeKnex(client) {
      function knex3(tableName, options) {
        return createQueryBuilder(knex3.context, tableName, options);
      }
      redefineProperties(knex3, client);
      return knex3;
    }
    function initContext(knexFn) {
      const knexContext = knexFn.context || {};
      Object.assign(knexContext, {
        queryBuilder() {
          return this.client.queryBuilder();
        },
        raw() {
          return this.client.raw.apply(this.client, arguments);
        },
        batchInsert(table, batch, chunkSize = 1e3) {
          return batchInsert(this, table, batch, chunkSize);
        },
        // Creates a new transaction.
        // If container is provided, returns a promise for when the transaction is resolved.
        // If container is not provided, returns a promise with a transaction that is resolved
        // when transaction is ready to be used.
        transaction(container, _config) {
          if (!_config && isObject5(container)) {
            _config = container;
            container = null;
          }
          const config3 = Object.assign({}, _config);
          config3.userParams = this.userParams || {};
          if (config3.doNotRejectOnRollback === void 0) {
            config3.doNotRejectOnRollback = true;
          }
          return this._transaction(container, config3);
        },
        // Internal method that actually establishes the Transaction.  It makes no assumptions
        // about the `config` or `outerTx`, and expects the caller to handle these details.
        _transaction(container, config3, outerTx = null) {
          if (container) {
            const trx = this.client.transaction(container, config3, outerTx);
            return trx;
          } else {
            return new Promise((resolve3, reject) => {
              this.client.transaction(resolve3, config3, outerTx).catch(reject);
            });
          }
        },
        transactionProvider(config3) {
          let trx;
          return () => {
            if (!trx) {
              trx = this.transaction(void 0, config3);
            }
            return trx;
          };
        },
        // Typically never needed, initializes the pool for a knex client.
        initialize(config3) {
          return this.client.initializePool(config3);
        },
        // Convenience method for tearing down the pool.
        destroy(callback) {
          return this.client.destroy(callback);
        },
        ref(ref) {
          return this.client.ref(ref);
        },
        // Do not document this as public API until naming and API is improved for general consumption
        // This method exists to disable processing of internal queries in migrations
        disableProcessing() {
          if (this.userParams.isProcessingDisabled) {
            return;
          }
          this.userParams.wrapIdentifier = this.client.config.wrapIdentifier;
          this.userParams.postProcessResponse = this.client.config.postProcessResponse;
          this.client.config.wrapIdentifier = null;
          this.client.config.postProcessResponse = null;
          this.userParams.isProcessingDisabled = true;
        },
        // Do not document this as public API until naming and API is improved for general consumption
        // This method exists to enable execution of non-internal queries with consistent identifier naming in migrations
        enableProcessing() {
          if (!this.userParams.isProcessingDisabled) {
            return;
          }
          this.client.config.wrapIdentifier = this.userParams.wrapIdentifier;
          this.client.config.postProcessResponse = this.userParams.postProcessResponse;
          this.userParams.isProcessingDisabled = false;
        },
        withUserParams(params) {
          const knexClone = shallowCloneFunction(knexFn);
          if (this.client) {
            knexClone.client = Object.create(this.client.constructor.prototype);
            merge4(knexClone.client, this.client);
            knexClone.client.config = Object.assign({}, this.client.config);
            if (this.client.config.password) {
              setHiddenProperty(knexClone.client.config, this.client.config);
            }
          }
          redefineProperties(knexClone, knexClone.client);
          _copyEventListeners("query", knexFn, knexClone);
          _copyEventListeners("query-error", knexFn, knexClone);
          _copyEventListeners("query-response", knexFn, knexClone);
          _copyEventListeners("start", knexFn, knexClone);
          knexClone.userParams = params;
          return knexClone;
        }
      });
      if (!knexFn.context) {
        knexFn.context = knexContext;
      }
    }
    function _copyEventListeners(eventName, sourceKnex, targetKnex) {
      const listeners = sourceKnex.listeners(eventName);
      listeners.forEach((listener) => {
        targetKnex.on(eventName, listener);
      });
    }
    function redefineProperties(knex3, client) {
      for (let i = 0; i < QueryInterface.length; i++) {
        const method = QueryInterface[i];
        knex3[method] = function() {
          const builder = this.queryBuilder();
          return builder[method].apply(builder, arguments);
        };
      }
      Object.defineProperties(knex3, KNEX_PROPERTY_DEFINITIONS);
      initContext(knex3);
      knex3.client = client;
      knex3.userParams = {};
      const ee = new EventEmitter3();
      for (const key in ee) {
        knex3[key] = ee[key];
      }
      if (knex3._internalListeners) {
        knex3._internalListeners.forEach(({ eventName, listener }) => {
          knex3.client.removeListener(eventName, listener);
        });
      }
      knex3._internalListeners = [];
      _addInternalListener(knex3, "start", (obj) => {
        knex3.emit("start", obj);
      });
      _addInternalListener(knex3, "query", (obj) => {
        knex3.emit("query", obj);
      });
      _addInternalListener(knex3, "query-error", (err, obj) => {
        knex3.emit("query-error", err, obj);
      });
      _addInternalListener(knex3, "query-response", (response, obj, builder) => {
        knex3.emit("query-response", response, obj, builder);
      });
    }
    function _addInternalListener(knex3, eventName, listener) {
      knex3.client.on(eventName, listener);
      knex3._internalListeners.push({
        eventName,
        listener
      });
    }
    function createQueryBuilder(knexContext, tableName, options) {
      const qb = knexContext.queryBuilder();
      if (!tableName)
        knexContext.client.logger.warn(
          "calling knex without a tableName is deprecated. Use knex.queryBuilder() instead."
        );
      return tableName ? qb.table(tableName, options) : qb;
    }
    function shallowCloneFunction(originalFunction) {
      const fnContext = Object.create(
        Object.getPrototypeOf(originalFunction),
        Object.getOwnPropertyDescriptors(originalFunction)
      );
      const knexContext = {};
      const knexFnWrapper = (tableName, options) => {
        return createQueryBuilder(knexContext, tableName, options);
      };
      const clonedFunction = knexFnWrapper.bind(fnContext);
      Object.assign(clonedFunction, originalFunction);
      clonedFunction.context = knexContext;
      return clonedFunction;
    }
    module2.exports = makeKnex;
  }
});

// node_modules/knex/lib/util/noop.js
var require_noop = __commonJS({
  "node_modules/knex/lib/util/noop.js"(exports2, module2) {
    "use strict";
    module2.exports = function() {
    };
  }
});

// node_modules/knex/lib/util/finally-mixin.js
var require_finally_mixin = __commonJS({
  "node_modules/knex/lib/util/finally-mixin.js"(exports2, module2) {
    "use strict";
    var noop4 = require_noop();
    var finallyMixin = (prototype2) => Object.assign(prototype2, {
      finally(onFinally) {
        return this.then().finally(onFinally);
      }
    });
    module2.exports = Promise.prototype.finally ? finallyMixin : noop4;
  }
});

// node_modules/knex/lib/execution/transaction.js
var require_transaction = __commonJS({
  "node_modules/knex/lib/execution/transaction.js"(exports2, module2) {
    "use strict";
    var { EventEmitter: EventEmitter3 } = require("events");
    var Debug = require_src3();
    var uniqueId = require_uniqueId();
    var { callbackify: callbackify2 } = require("util");
    var makeKnex = require_make_knex();
    var { timeout, KnexTimeoutError } = require_timeout();
    var finallyMixin = require_finally_mixin();
    var debug = Debug("knex:tx");
    function DEFAULT_CONFIG() {
      return {
        userParams: {},
        doNotRejectOnRollback: true
      };
    }
    var validIsolationLevels = [
      // Doesn't really work in postgres, it treats it as read committed
      "read uncommitted",
      "read committed",
      "snapshot",
      // snapshot and repeatable read are basically the same, most "repeatable
      // read" implementations are actually "snapshot" also known as Multi Version
      // Concurrency Control (MVCC). Mssql's repeatable read doesn't stop
      // repeated reads for inserts as it uses a pessimistic locking system so
      // you should probably use 'snapshot' to stop read skew.
      "repeatable read",
      // mysql pretends to have serializable, but it is not
      "serializable"
    ];
    var Transaction = class extends EventEmitter3 {
      constructor(client, container, config3 = DEFAULT_CONFIG(), outerTx = null) {
        super();
        this.userParams = config3.userParams;
        this.doNotRejectOnRollback = config3.doNotRejectOnRollback;
        const txid = this.txid = uniqueId("trx");
        this.client = client;
        this.logger = client.logger;
        this.outerTx = outerTx;
        this.trxClient = void 0;
        this._completed = false;
        this._debug = client.config && client.config.debug;
        this.readOnly = config3.readOnly;
        if (config3.isolationLevel) {
          this.setIsolationLevel(config3.isolationLevel);
        }
        debug(
          "%s: Starting %s transaction",
          txid,
          outerTx ? "nested" : "top level"
        );
        this._lastChild = Promise.resolve();
        const _previousSibling = outerTx ? outerTx._lastChild : Promise.resolve();
        const basePromise = _previousSibling.then(
          () => this._evaluateContainer(config3, container)
        );
        this._promise = basePromise.then((x) => x);
        if (outerTx) {
          outerTx._lastChild = basePromise.catch(() => {
          });
        }
      }
      isCompleted() {
        return this._completed || this.outerTx && this.outerTx.isCompleted() || false;
      }
      begin(conn) {
        const trxMode = [
          this.isolationLevel ? `ISOLATION LEVEL ${this.isolationLevel}` : "",
          this.readOnly ? "READ ONLY" : ""
        ].join(" ").trim();
        if (trxMode.length === 0) {
          return this.query(conn, "BEGIN;");
        }
        return this.query(conn, `SET TRANSACTION ${trxMode};`).then(
          () => this.query(conn, "BEGIN;")
        );
      }
      savepoint(conn) {
        return this.query(conn, `SAVEPOINT ${this.txid};`);
      }
      commit(conn, value) {
        return this.query(conn, "COMMIT;", 1, value);
      }
      release(conn, value) {
        return this.query(conn, `RELEASE SAVEPOINT ${this.txid};`, 1, value);
      }
      setIsolationLevel(isolationLevel) {
        if (!validIsolationLevels.includes(isolationLevel)) {
          throw new Error(
            `Invalid isolationLevel, supported isolation levels are: ${JSON.stringify(
              validIsolationLevels
            )}`
          );
        }
        this.isolationLevel = isolationLevel;
        return this;
      }
      rollback(conn, error73) {
        return timeout(this.query(conn, "ROLLBACK", 2, error73), 5e3).catch(
          (err) => {
            if (!(err instanceof KnexTimeoutError)) {
              return Promise.reject(err);
            }
            this._rejecter(error73);
          }
        );
      }
      rollbackTo(conn, error73) {
        return timeout(
          this.query(conn, `ROLLBACK TO SAVEPOINT ${this.txid}`, 2, error73),
          5e3
        ).catch((err) => {
          if (!(err instanceof KnexTimeoutError)) {
            return Promise.reject(err);
          }
          this._rejecter(error73);
        });
      }
      query(conn, sql, status, value) {
        const q = this.trxClient.query(conn, sql).catch((err) => {
          status = 2;
          value = err;
          this._completed = true;
          debug("%s error running transaction query", this.txid);
        }).then((res) => {
          if (status === 1) {
            this._resolver(value);
          }
          if (status === 2) {
            if (value === void 0) {
              if (this.doNotRejectOnRollback && /^ROLLBACK\b/i.test(sql)) {
                this._resolver();
                return;
              }
              value = new Error(`Transaction rejected with non-error: ${value}`);
            }
            this._rejecter(value);
          }
          return res;
        });
        if (status === 1 || status === 2) {
          this._completed = true;
        }
        return q;
      }
      debug(enabled) {
        this._debug = arguments.length ? enabled : true;
        return this;
      }
      async _onAcquire(container, connection) {
        const trxClient = this.trxClient = makeTxClient(
          this,
          this.client,
          connection
        );
        const init = this.client.transacting ? this.savepoint(connection) : this.begin(connection);
        const executionPromise = new Promise((resolver, rejecter) => {
          this._resolver = resolver;
          this._rejecter = rejecter;
        });
        init.then(() => {
          return makeTransactor(this, connection, trxClient);
        }).then((transactor) => {
          this.transactor = transactor;
          if (this.outerTx) {
            transactor.parentTransaction = this.outerTx.transactor;
          }
          transactor.executionPromise = executionPromise;
          let result;
          try {
            result = container(transactor);
          } catch (err) {
            result = Promise.reject(err);
          }
          if (result && result.then && typeof result.then === "function") {
            result.then((val) => {
              return transactor.commit(val);
            }).catch((err) => {
              return transactor.rollback(err);
            });
          }
          return null;
        }).catch((e) => {
          return this._rejecter(e);
        });
        return executionPromise;
      }
      _evaluateContainer(config3, container) {
        return this.acquireConnection(
          config3,
          (connection) => this._onAcquire(container, connection)
        );
      }
      // Acquire a connection and create a disposer - either using the one passed
      // via config or getting one off the client. The disposer will be called once
      // the original promise is marked completed.
      async acquireConnection(config3, cb) {
        const configConnection = config3 && config3.connection;
        const connection = configConnection || await this.client.acquireConnection();
        try {
          connection.__knexTxId = this.txid;
          return await cb(connection);
        } finally {
          if (!configConnection) {
            debug("%s: releasing connection", this.txid);
            delete connection.__knexTxId;
            this.client.releaseConnection(connection);
          } else {
            debug("%s: not releasing external connection", this.txid);
          }
        }
      }
      then(onResolve, onReject) {
        return this._promise.then(onResolve, onReject);
      }
      catch(...args) {
        return this._promise.catch(...args);
      }
      asCallback(cb) {
        callbackify2(() => this._promise)(cb);
        return this._promise;
      }
    };
    finallyMixin(Transaction.prototype);
    function makeTransactor(trx, connection, trxClient) {
      const transactor = makeKnex(trxClient);
      transactor.context.withUserParams = () => {
        throw new Error(
          "Cannot set user params on a transaction - it can only inherit params from main knex instance"
        );
      };
      transactor.isTransaction = true;
      transactor.userParams = trx.userParams || {};
      transactor.context.transaction = function(container, options) {
        if (!options) {
          options = { doNotRejectOnRollback: true };
        } else if (options.doNotRejectOnRollback === void 0) {
          options.doNotRejectOnRollback = true;
        }
        return this._transaction(container, options, trx);
      };
      transactor.savepoint = function(container, options) {
        return transactor.transaction(container, options);
      };
      if (trx.client.transacting) {
        transactor.commit = (value) => trx.release(connection, value);
        transactor.rollback = (error73) => trx.rollbackTo(connection, error73);
      } else {
        transactor.commit = (value) => trx.commit(connection, value);
        transactor.rollback = (error73) => trx.rollback(connection, error73);
      }
      transactor.isCompleted = () => trx.isCompleted();
      return transactor;
    }
    function makeTxClient(trx, client, connection) {
      const trxClient = Object.create(client.constructor.prototype);
      trxClient.version = client.version;
      trxClient.config = client.config;
      trxClient.driver = client.driver;
      trxClient.connectionSettings = client.connectionSettings;
      trxClient.transacting = true;
      trxClient.valueForUndefined = client.valueForUndefined;
      trxClient.logger = client.logger;
      trxClient.on("start", function(arg) {
        trx.emit("start", arg);
        client.emit("start", arg);
      });
      trxClient.on("query", function(arg) {
        trx.emit("query", arg);
        client.emit("query", arg);
      });
      trxClient.on("query-error", function(err, obj) {
        trx.emit("query-error", err, obj);
        client.emit("query-error", err, obj);
      });
      trxClient.on("query-response", function(response, obj, builder) {
        trx.emit("query-response", response, obj, builder);
        client.emit("query-response", response, obj, builder);
      });
      const _query = trxClient.query;
      trxClient.query = function(conn, obj) {
        const completed = trx.isCompleted();
        return new Promise(function(resolve3, reject) {
          try {
            if (conn !== connection)
              throw new Error("Invalid connection for transaction query.");
            if (completed) completedError(trx, obj);
            resolve3(_query.call(trxClient, conn, obj));
          } catch (e) {
            reject(e);
          }
        });
      };
      const _stream = trxClient.stream;
      trxClient.stream = function(conn, obj, stream4, options) {
        const completed = trx.isCompleted();
        return new Promise(function(resolve3, reject) {
          try {
            if (conn !== connection)
              throw new Error("Invalid connection for transaction query.");
            if (completed) completedError(trx, obj);
            resolve3(_stream.call(trxClient, conn, obj, stream4, options));
          } catch (e) {
            reject(e);
          }
        });
      };
      trxClient.acquireConnection = function() {
        return Promise.resolve(connection);
      };
      trxClient.releaseConnection = function() {
        return Promise.resolve();
      };
      return trxClient;
    }
    function completedError(trx, obj) {
      const sql = typeof obj === "string" ? obj : obj && obj.sql;
      debug("%s: Transaction completed: %s", trx.txid, sql);
      throw new Error(
        "Transaction query already complete, run with DEBUG=knex:tx for more info"
      );
    }
    module2.exports = Transaction;
  }
});

// node_modules/knex/lib/execution/internal/query-executioner.js
var require_query_executioner = __commonJS({
  "node_modules/knex/lib/execution/internal/query-executioner.js"(exports2, module2) {
    "use strict";
    var _debugQuery = require_src3()("knex:query");
    var debugBindings = require_src3()("knex:bindings");
    var debugQuery = (sql, txId) => _debugQuery(sql.replace(/%/g, "%%"), txId);
    var { isString: isString2 } = require_is();
    function formatQuery(sql, bindings, timeZone, client) {
      bindings = bindings == null ? [] : [].concat(bindings);
      let index = 0;
      return sql.replace(/\\?\?/g, (match) => {
        if (match === "\\?") {
          return "?";
        }
        if (index === bindings.length) {
          return match;
        }
        const value = bindings[index++];
        return client._escapeBinding(value, { timeZone });
      });
    }
    function enrichQueryObject(connection, queryParam, client) {
      const queryObject = isString2(queryParam) ? { sql: queryParam } : queryParam;
      queryObject.bindings = client.prepBindings(queryObject.bindings);
      queryObject.sql = client.positionBindings(queryObject.sql);
      const { __knexUid, __knexTxId } = connection;
      client.emit("query", Object.assign({ __knexUid, __knexTxId }, queryObject));
      debugQuery(queryObject.sql, __knexTxId);
      debugBindings(queryObject.bindings, __knexTxId);
      return queryObject;
    }
    function executeQuery(connection, queryObject, client) {
      return client._query(connection, queryObject).catch((err) => {
        if (client.config && client.config.compileSqlOnError === false) {
          err.message = queryObject.sql + " - " + err.message;
        } else {
          err.message = formatQuery(queryObject.sql, queryObject.bindings, void 0, client) + " - " + err.message;
        }
        client.emit(
          "query-error",
          err,
          Object.assign(
            { __knexUid: connection.__knexUid, __knexTxId: connection.__knexTxId },
            queryObject
          )
        );
        throw err;
      });
    }
    module2.exports = {
      enrichQueryObject,
      executeQuery,
      formatQuery
    };
  }
});

// node_modules/lodash/assign.js
var require_assign = __commonJS({
  "node_modules/lodash/assign.js"(exports2, module2) {
    "use strict";
    var assignValue = require_assignValue();
    var copyObject = require_copyObject();
    var createAssigner = require_createAssigner();
    var isArrayLike2 = require_isArrayLike();
    var isPrototype2 = require_isPrototype();
    var keys2 = require_keys();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    var assign = createAssigner(function(object4, source) {
      if (isPrototype2(source) || isArrayLike2(source)) {
        copyObject(source, keys2(source), object4);
        return;
      }
      for (var key in source) {
        if (hasOwnProperty11.call(source, key)) {
          assignValue(object4, key, source[key]);
        }
      }
    });
    module2.exports = assign;
  }
});

// node_modules/lodash/clone.js
var require_clone = __commonJS({
  "node_modules/lodash/clone.js"(exports2, module2) {
    "use strict";
    var baseClone = require_baseClone();
    var CLONE_SYMBOLS_FLAG = 4;
    function clone3(value) {
      return baseClone(value, CLONE_SYMBOLS_FLAG);
    }
    module2.exports = clone3;
  }
});

// node_modules/lodash/_castFunction.js
var require_castFunction = __commonJS({
  "node_modules/lodash/_castFunction.js"(exports2, module2) {
    "use strict";
    var identity2 = require_identity();
    function castFunction(value) {
      return typeof value == "function" ? value : identity2;
    }
    module2.exports = castFunction;
  }
});

// node_modules/lodash/forEach.js
var require_forEach = __commonJS({
  "node_modules/lodash/forEach.js"(exports2, module2) {
    "use strict";
    var arrayEach = require_arrayEach();
    var baseEach = require_baseEach();
    var castFunction = require_castFunction();
    var isArray3 = require_isArray();
    function forEach2(collection, iteratee) {
      var func = isArray3(collection) ? arrayEach : baseEach;
      return func(collection, castFunction(iteratee));
    }
    module2.exports = forEach2;
  }
});

// node_modules/lodash/each.js
var require_each = __commonJS({
  "node_modules/lodash/each.js"(exports2, module2) {
    "use strict";
    module2.exports = require_forEach();
  }
});

// node_modules/lodash/_baseFilter.js
var require_baseFilter = __commonJS({
  "node_modules/lodash/_baseFilter.js"(exports2, module2) {
    "use strict";
    var baseEach = require_baseEach();
    function baseFilter(collection, predicate) {
      var result = [];
      baseEach(collection, function(value, index, collection2) {
        if (predicate(value, index, collection2)) {
          result.push(value);
        }
      });
      return result;
    }
    module2.exports = baseFilter;
  }
});

// node_modules/lodash/negate.js
var require_negate = __commonJS({
  "node_modules/lodash/negate.js"(exports2, module2) {
    "use strict";
    var FUNC_ERROR_TEXT2 = "Expected a function";
    function negate(predicate) {
      if (typeof predicate != "function") {
        throw new TypeError(FUNC_ERROR_TEXT2);
      }
      return function() {
        var args = arguments;
        switch (args.length) {
          case 0:
            return !predicate.call(this);
          case 1:
            return !predicate.call(this, args[0]);
          case 2:
            return !predicate.call(this, args[0], args[1]);
          case 3:
            return !predicate.call(this, args[0], args[1], args[2]);
        }
        return !predicate.apply(this, args);
      };
    }
    module2.exports = negate;
  }
});

// node_modules/lodash/reject.js
var require_reject = __commonJS({
  "node_modules/lodash/reject.js"(exports2, module2) {
    "use strict";
    var arrayFilter2 = require_arrayFilter();
    var baseFilter = require_baseFilter();
    var baseIteratee2 = require_baseIteratee();
    var isArray3 = require_isArray();
    var negate = require_negate();
    function reject(collection, predicate) {
      var func = isArray3(collection) ? arrayFilter2 : baseFilter;
      return func(collection, negate(baseIteratee2(predicate, 3)));
    }
    module2.exports = reject;
  }
});

// node_modules/lodash/tail.js
var require_tail = __commonJS({
  "node_modules/lodash/tail.js"(exports2, module2) {
    "use strict";
    var baseSlice = require_baseSlice();
    function tail(array4) {
      var length = array4 == null ? 0 : array4.length;
      return length ? baseSlice(array4, 1, length) : [];
    }
    module2.exports = tail;
  }
});

// node_modules/lodash/_iteratorToArray.js
var require_iteratorToArray = __commonJS({
  "node_modules/lodash/_iteratorToArray.js"(exports2, module2) {
    "use strict";
    function iteratorToArray(iterator2) {
      var data, result = [];
      while (!(data = iterator2.next()).done) {
        result.push(data.value);
      }
      return result;
    }
    module2.exports = iteratorToArray;
  }
});

// node_modules/lodash/_asciiToArray.js
var require_asciiToArray = __commonJS({
  "node_modules/lodash/_asciiToArray.js"(exports2, module2) {
    "use strict";
    function asciiToArray(string5) {
      return string5.split("");
    }
    module2.exports = asciiToArray;
  }
});

// node_modules/lodash/_hasUnicode.js
var require_hasUnicode = __commonJS({
  "node_modules/lodash/_hasUnicode.js"(exports2, module2) {
    "use strict";
    var rsAstralRange = "\\ud800-\\udfff";
    var rsComboMarksRange = "\\u0300-\\u036f";
    var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange = "\\u20d0-\\u20ff";
    var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
    var rsVarRange = "\\ufe0e\\ufe0f";
    var rsZWJ = "\\u200d";
    var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
    function hasUnicode(string5) {
      return reHasUnicode.test(string5);
    }
    module2.exports = hasUnicode;
  }
});

// node_modules/lodash/_unicodeToArray.js
var require_unicodeToArray = __commonJS({
  "node_modules/lodash/_unicodeToArray.js"(exports2, module2) {
    "use strict";
    var rsAstralRange = "\\ud800-\\udfff";
    var rsComboMarksRange = "\\u0300-\\u036f";
    var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange = "\\u20d0-\\u20ff";
    var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
    var rsVarRange = "\\ufe0e\\ufe0f";
    var rsAstral = "[" + rsAstralRange + "]";
    var rsCombo = "[" + rsComboRange + "]";
    var rsFitz = "\\ud83c[\\udffb-\\udfff]";
    var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
    var rsNonAstral = "[^" + rsAstralRange + "]";
    var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
    var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
    var rsZWJ = "\\u200d";
    var reOptMod = rsModifier + "?";
    var rsOptVar = "[" + rsVarRange + "]?";
    var rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
    var rsSeq = rsOptVar + reOptMod + rsOptJoin;
    var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
    var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
    function unicodeToArray(string5) {
      return string5.match(reUnicode) || [];
    }
    module2.exports = unicodeToArray;
  }
});

// node_modules/lodash/_stringToArray.js
var require_stringToArray = __commonJS({
  "node_modules/lodash/_stringToArray.js"(exports2, module2) {
    "use strict";
    var asciiToArray = require_asciiToArray();
    var hasUnicode = require_hasUnicode();
    var unicodeToArray = require_unicodeToArray();
    function stringToArray(string5) {
      return hasUnicode(string5) ? unicodeToArray(string5) : asciiToArray(string5);
    }
    module2.exports = stringToArray;
  }
});

// node_modules/lodash/toArray.js
var require_toArray = __commonJS({
  "node_modules/lodash/toArray.js"(exports2, module2) {
    "use strict";
    var Symbol3 = require_Symbol();
    var copyArray = require_copyArray();
    var getTag2 = require_getTag();
    var isArrayLike2 = require_isArrayLike();
    var isString2 = require_isString();
    var iteratorToArray = require_iteratorToArray();
    var mapToArray2 = require_mapToArray();
    var setToArray2 = require_setToArray();
    var stringToArray = require_stringToArray();
    var values = require_values();
    var mapTag4 = "[object Map]";
    var setTag4 = "[object Set]";
    var symIterator = Symbol3 ? Symbol3.iterator : void 0;
    function toArray2(value) {
      if (!value) {
        return [];
      }
      if (isArrayLike2(value)) {
        return isString2(value) ? stringToArray(value) : copyArray(value);
      }
      if (symIterator && value[symIterator]) {
        return iteratorToArray(value[symIterator]());
      }
      var tag = getTag2(value), func = tag == mapTag4 ? mapToArray2 : tag == setTag4 ? setToArray2 : values;
      return func(value);
    }
    module2.exports = toArray2;
  }
});

// node_modules/knex/lib/constants.js
var require_constants6 = __commonJS({
  "node_modules/knex/lib/constants.js"(exports2, module2) {
    "use strict";
    var CLIENT_ALIASES = Object.freeze({
      pg: "postgres",
      postgresql: "postgres",
      sqlite: "sqlite3"
    });
    var SUPPORTED_CLIENTS = Object.freeze(
      [
        "mssql",
        "mysql",
        "mysql2",
        "oracledb",
        "postgres",
        "pgnative",
        "redshift",
        "sqlite3",
        "cockroachdb",
        "better-sqlite3"
      ].concat(Object.keys(CLIENT_ALIASES))
    );
    var DRIVER_NAMES = Object.freeze({
      MsSQL: "mssql",
      MySQL: "mysql",
      MySQL2: "mysql2",
      Oracle: "oracledb",
      PostgreSQL: "pg",
      PgNative: "pgnative",
      Redshift: "pg-redshift",
      SQLite: "sqlite3",
      CockroachDB: "cockroachdb",
      BetterSQLite3: "better-sqlite3"
    });
    var POOL_CONFIG_OPTIONS = Object.freeze([
      "maxWaitingClients",
      "testOnBorrow",
      "fifo",
      "priorityRange",
      "autostart",
      "evictionRunIntervalMillis",
      "numTestsPerRun",
      "softIdleTimeoutMillis",
      "Promise"
    ]);
    var COMMA_NO_PAREN_REGEX = /,[\s](?![^(]*\))/g;
    module2.exports = {
      CLIENT_ALIASES,
      SUPPORTED_CLIENTS,
      POOL_CONFIG_OPTIONS,
      COMMA_NO_PAREN_REGEX,
      DRIVER_NAMES
    };
  }
});

// node_modules/knex/lib/util/helpers.js
var require_helpers = __commonJS({
  "node_modules/knex/lib/util/helpers.js"(exports2, module2) {
    "use strict";
    var isPlainObject4 = require_isPlainObject();
    var isTypedArray3 = require_isTypedArray();
    var { CLIENT_ALIASES } = require_constants6();
    var { isFunction: isFunction4 } = require_is();
    function normalizeArr(...args) {
      if (Array.isArray(args[0])) {
        return args[0];
      }
      return args;
    }
    function containsUndefined(mixed) {
      let argContainsUndefined = false;
      if (isTypedArray3(mixed)) return false;
      if (mixed && isFunction4(mixed.toSQL)) {
        return argContainsUndefined;
      }
      if (Array.isArray(mixed)) {
        for (let i = 0; i < mixed.length; i++) {
          if (argContainsUndefined) break;
          argContainsUndefined = containsUndefined(mixed[i]);
        }
      } else if (isPlainObject4(mixed)) {
        Object.keys(mixed).forEach((key) => {
          if (!argContainsUndefined) {
            argContainsUndefined = containsUndefined(mixed[key]);
          }
        });
      } else {
        argContainsUndefined = mixed === void 0;
      }
      return argContainsUndefined;
    }
    function getUndefinedIndices(mixed) {
      const indices = [];
      if (Array.isArray(mixed)) {
        mixed.forEach((item, index) => {
          if (containsUndefined(item)) {
            indices.push(index);
          }
        });
      } else if (isPlainObject4(mixed)) {
        Object.keys(mixed).forEach((key) => {
          if (containsUndefined(mixed[key])) {
            indices.push(key);
          }
        });
      } else {
        indices.push(0);
      }
      return indices;
    }
    function addQueryContext(Target) {
      Target.prototype.queryContext = function(context2) {
        if (context2 === void 0) {
          return this._queryContext;
        }
        this._queryContext = context2;
        return this;
      };
    }
    function resolveClientNameWithAliases(clientName) {
      return CLIENT_ALIASES[clientName] || clientName;
    }
    function toNumber2(val, fallback) {
      if (val === void 0 || val === null) return fallback;
      const number5 = parseInt(val, 10);
      return isNaN(number5) ? fallback : number5;
    }
    module2.exports = {
      addQueryContext,
      containsUndefined,
      getUndefinedIndices,
      normalizeArr,
      resolveClientNameWithAliases,
      toNumber: toNumber2
    };
  }
});

// node_modules/knex/lib/query/joinclause.js
var require_joinclause = __commonJS({
  "node_modules/knex/lib/query/joinclause.js"(exports2, module2) {
    "use strict";
    var assert3 = require("assert");
    function getClauseFromArguments(compilerType, bool, first, operator, second) {
      if (typeof first === "function") {
        return {
          type: "onWrapped",
          value: first,
          bool
        };
      }
      switch (arguments.length) {
        case 3:
          return { type: "onRaw", value: first, bool };
        case 4:
          return {
            type: compilerType,
            column: first,
            operator: "=",
            value: operator,
            bool
          };
        default:
          return {
            type: compilerType,
            column: first,
            operator,
            value: second,
            bool
          };
      }
    }
    var JoinClause = class {
      constructor(table, type, schema) {
        this.schema = schema;
        this.table = table;
        this.joinType = type;
        this.and = this;
        this.clauses = [];
      }
      get or() {
        return this._bool("or");
      }
      // Adds an "on" clause to the current join object.
      on(first) {
        if (typeof first === "object" && typeof first.toSQL !== "function") {
          const keys2 = Object.keys(first);
          let i = -1;
          const method = this._bool() === "or" ? "orOn" : "on";
          while (++i < keys2.length) {
            this[method](keys2[i], first[keys2[i]]);
          }
          return this;
        }
        const data = getClauseFromArguments("onBasic", this._bool(), ...arguments);
        if (data) {
          this.clauses.push(data);
        }
        return this;
      }
      // Adds an "or on" clause to the current join object.
      orOn(first, operator, second) {
        return this._bool("or").on.apply(this, arguments);
      }
      onJsonPathEquals(columnFirst, jsonPathFirst, columnSecond, jsonPathSecond) {
        this.clauses.push({
          type: "onJsonPathEquals",
          columnFirst,
          jsonPathFirst,
          columnSecond,
          jsonPathSecond,
          bool: this._bool(),
          not: this._not()
        });
        return this;
      }
      orOnJsonPathEquals(columnFirst, jsonPathFirst, columnSecond, jsonPathSecond) {
        return this._bool("or").onJsonPathEquals.apply(this, arguments);
      }
      // Adds a "using" clause to the current join.
      using(column) {
        return this.clauses.push({ type: "onUsing", column, bool: this._bool() });
      }
      onVal(first) {
        if (typeof first === "object" && typeof first.toSQL !== "function") {
          const keys2 = Object.keys(first);
          let i = -1;
          const method = this._bool() === "or" ? "orOnVal" : "onVal";
          while (++i < keys2.length) {
            this[method](keys2[i], first[keys2[i]]);
          }
          return this;
        }
        const data = getClauseFromArguments("onVal", this._bool(), ...arguments);
        if (data) {
          this.clauses.push(data);
        }
        return this;
      }
      andOnVal() {
        return this.onVal(...arguments);
      }
      orOnVal() {
        return this._bool("or").onVal(...arguments);
      }
      onBetween(column, values) {
        assert3(
          Array.isArray(values),
          "The second argument to onBetween must be an array."
        );
        assert3(
          values.length === 2,
          "You must specify 2 values for the onBetween clause"
        );
        this.clauses.push({
          type: "onBetween",
          column,
          value: values,
          bool: this._bool(),
          not: this._not()
        });
        return this;
      }
      onNotBetween(column, values) {
        return this._not(true).onBetween(column, values);
      }
      orOnBetween(column, values) {
        return this._bool("or").onBetween(column, values);
      }
      orOnNotBetween(column, values) {
        return this._bool("or")._not(true).onBetween(column, values);
      }
      onIn(column, values) {
        if (Array.isArray(values) && values.length === 0) return this.on(1, "=", 0);
        this.clauses.push({
          type: "onIn",
          column,
          value: values,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      onNotIn(column, values) {
        return this._not(true).onIn(column, values);
      }
      orOnIn(column, values) {
        return this._bool("or").onIn(column, values);
      }
      orOnNotIn(column, values) {
        return this._bool("or")._not(true).onIn(column, values);
      }
      onNull(column) {
        this.clauses.push({
          type: "onNull",
          column,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      orOnNull(callback) {
        return this._bool("or").onNull(callback);
      }
      onNotNull(callback) {
        return this._not(true).onNull(callback);
      }
      orOnNotNull(callback) {
        return this._not(true)._bool("or").onNull(callback);
      }
      onExists(callback) {
        this.clauses.push({
          type: "onExists",
          value: callback,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      orOnExists(callback) {
        return this._bool("or").onExists(callback);
      }
      onNotExists(callback) {
        return this._not(true).onExists(callback);
      }
      orOnNotExists(callback) {
        return this._not(true)._bool("or").onExists(callback);
      }
      // Explicitly set the type of join, useful within a function when creating a grouped join.
      type(type) {
        this.joinType = type;
        return this;
      }
      _bool(bool) {
        if (arguments.length === 1) {
          this._boolFlag = bool;
          return this;
        }
        const ret = this._boolFlag || "and";
        this._boolFlag = "and";
        return ret;
      }
      _not(val) {
        if (arguments.length === 1) {
          this._notFlag = val;
          return this;
        }
        const ret = this._notFlag;
        this._notFlag = false;
        return ret;
      }
    };
    Object.assign(JoinClause.prototype, {
      grouping: "join"
    });
    JoinClause.prototype.andOn = JoinClause.prototype.on;
    JoinClause.prototype.andOnIn = JoinClause.prototype.onIn;
    JoinClause.prototype.andOnNotIn = JoinClause.prototype.onNotIn;
    JoinClause.prototype.andOnNull = JoinClause.prototype.onNull;
    JoinClause.prototype.andOnNotNull = JoinClause.prototype.onNotNull;
    JoinClause.prototype.andOnExists = JoinClause.prototype.onExists;
    JoinClause.prototype.andOnNotExists = JoinClause.prototype.onNotExists;
    JoinClause.prototype.andOnBetween = JoinClause.prototype.onBetween;
    JoinClause.prototype.andOnNotBetween = JoinClause.prototype.onNotBetween;
    JoinClause.prototype.andOnJsonPathEquals = JoinClause.prototype.onJsonPathEquals;
    module2.exports = JoinClause;
  }
});

// node_modules/knex/lib/query/analytic.js
var require_analytic = __commonJS({
  "node_modules/knex/lib/query/analytic.js"(exports2, module2) {
    "use strict";
    var assert3 = require("assert");
    var Analytic = class {
      constructor(method, schema, alias, orderBy, partitions) {
        this.schema = schema;
        this.type = "analytic";
        this.method = method;
        this.order = orderBy || [];
        this.partitions = partitions || [];
        this.alias = alias;
        this.and = this;
        this.grouping = "columns";
      }
      partitionBy(column, direction) {
        assert3(
          Array.isArray(column) || typeof column === "string",
          `The argument to an analytic partitionBy function must be either a string
            or an array of string.`
        );
        if (Array.isArray(column)) {
          this.partitions = this.partitions.concat(column);
        } else {
          this.partitions.push({ column, order: direction });
        }
        return this;
      }
      orderBy(column, direction) {
        assert3(
          Array.isArray(column) || typeof column === "string",
          `The argument to an analytic orderBy function must be either a string
            or an array of string.`
        );
        if (Array.isArray(column)) {
          this.order = this.order.concat(column);
        } else {
          this.order.push({ column, order: direction });
        }
        return this;
      }
    };
    module2.exports = Analytic;
  }
});

// node_modules/knex/lib/util/save-async-stack.js
var require_save_async_stack = __commonJS({
  "node_modules/knex/lib/util/save-async-stack.js"(exports2, module2) {
    "use strict";
    module2.exports = function saveAsyncStack(instance, lines) {
      if (instance.client.config.asyncStackTraces) {
        instance._asyncStack = {
          error: new Error(),
          lines
        };
      }
    };
  }
});

// node_modules/knex/lib/query/constants.js
var require_constants7 = __commonJS({
  "node_modules/knex/lib/query/constants.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      lockMode: {
        forShare: "forShare",
        forUpdate: "forUpdate",
        forNoKeyUpdate: "forNoKeyUpdate",
        forKeyShare: "forKeyShare"
      },
      waitMode: {
        skipLocked: "skipLocked",
        noWait: "noWait"
      }
    };
  }
});

// node_modules/knex/lib/builder-interface-augmenter.js
var require_builder_interface_augmenter = __commonJS({
  "node_modules/knex/lib/builder-interface-augmenter.js"(exports2, module2) {
    "use strict";
    var clone3 = require_clone();
    var isEmpty = require_isEmpty();
    var { callbackify: callbackify2 } = require("util");
    var finallyMixin = require_finally_mixin();
    var { formatQuery } = require_query_executioner();
    function augmentWithBuilderInterface(Target) {
      Target.prototype.toQuery = function(tz) {
        let data = this.toSQL(this._method, tz);
        if (!Array.isArray(data)) data = [data];
        if (!data.length) {
          return "";
        }
        return data.map((statement) => {
          return formatQuery(statement.sql, statement.bindings, tz, this.client);
        }).reduce((a, c) => a.concat(a.endsWith(";") ? "\n" : ";\n", c));
      };
      Target.prototype.then = function() {
        let result = this.client.runner(this).run();
        if (this.client.config.asyncStackTraces) {
          result = result.catch((err) => {
            err.originalStack = err.stack;
            const firstLine = err.stack.split("\n")[0];
            const { error: error73, lines } = this._asyncStack;
            const stackByLines = error73.stack.split("\n");
            const asyncStack = stackByLines.slice(lines);
            asyncStack.unshift(firstLine);
            err.stack = asyncStack.join("\n");
            throw err;
          });
        }
        return result.then.apply(result, arguments);
      };
      Target.prototype.options = function(opts) {
        this._options = this._options || [];
        this._options.push(clone3(opts) || {});
        return this;
      };
      Target.prototype.connection = function(connection) {
        this._connection = connection;
        this.client.processPassedConnection(connection);
        return this;
      };
      Target.prototype.debug = function(enabled) {
        this._debug = arguments.length ? enabled : true;
        return this;
      };
      Target.prototype.transacting = function(transaction) {
        if (transaction && transaction.client) {
          if (!transaction.client.transacting) {
            transaction.client.logger.warn(
              `Invalid transaction value: ${transaction.client}`
            );
          } else {
            this.client = transaction.client;
          }
        }
        if (isEmpty(transaction)) {
          this.client.logger.error(
            "Invalid value on transacting call, potential bug"
          );
          throw Error(
            "Invalid transacting value (null, undefined or empty object)"
          );
        }
        return this;
      };
      Target.prototype.stream = function(options) {
        return this.client.runner(this).stream(options);
      };
      Target.prototype.pipe = function(writable, options) {
        return this.client.runner(this).pipe(writable, options);
      };
      Target.prototype.asCallback = function(cb) {
        const promise3 = this.then();
        callbackify2(() => promise3)(cb);
        return promise3;
      };
      Target.prototype.catch = function(onReject) {
        return this.then().catch(onReject);
      };
      Object.defineProperty(Target.prototype, Symbol.toStringTag, {
        get: () => "object"
      });
      finallyMixin(Target.prototype);
    }
    module2.exports = {
      augmentWithBuilderInterface
    };
  }
});

// node_modules/knex/lib/query/querybuilder.js
var require_querybuilder = __commonJS({
  "node_modules/knex/lib/query/querybuilder.js"(exports2, module2) {
    "use strict";
    var assert3 = require("assert");
    var { EventEmitter: EventEmitter3 } = require("events");
    var assign = require_assign();
    var clone3 = require_clone();
    var each = require_each();
    var isEmpty = require_isEmpty();
    var isPlainObject4 = require_isPlainObject();
    var last = require_last();
    var reject = require_reject();
    var tail = require_tail();
    var toArray2 = require_toArray();
    var { addQueryContext, normalizeArr } = require_helpers();
    var JoinClause = require_joinclause();
    var Analytic = require_analytic();
    var saveAsyncStack = require_save_async_stack();
    var {
      isBoolean: isBoolean2,
      isNumber: isNumber2,
      isObject: isObject5,
      isString: isString2,
      isFunction: isFunction4
    } = require_is();
    var { lockMode, waitMode } = require_constants7();
    var {
      augmentWithBuilderInterface
    } = require_builder_interface_augmenter();
    var SELECT_COMMANDS = /* @__PURE__ */ new Set(["pluck", "first", "select"]);
    var CLEARABLE_STATEMENTS = /* @__PURE__ */ new Set([
      "with",
      "select",
      "columns",
      "hintComments",
      "where",
      "union",
      "join",
      "group",
      "order",
      "having",
      "limit",
      "offset",
      "counter",
      "counters"
    ]);
    var LOCK_MODES = /* @__PURE__ */ new Set([
      lockMode.forShare,
      lockMode.forUpdate,
      lockMode.forNoKeyUpdate,
      lockMode.forKeyShare
    ]);
    var Builder = class _Builder extends EventEmitter3 {
      constructor(client) {
        super();
        this.client = client;
        this.and = this;
        this._single = {};
        this._comments = [];
        this._statements = [];
        this._method = "select";
        if (client.config) {
          saveAsyncStack(this, 5);
          this._debug = client.config.debug;
        }
        this._joinFlag = "inner";
        this._boolFlag = "and";
        this._notFlag = false;
        this._asColumnFlag = false;
      }
      toString() {
        return this.toQuery();
      }
      // Convert the current query "toSQL"
      toSQL(method, tz) {
        return this.client.queryCompiler(this).toSQL(method || this._method, tz);
      }
      // Create a shallow clone of the current query builder.
      clone() {
        const cloned = new this.constructor(this.client);
        cloned._method = this._method;
        cloned._single = clone3(this._single);
        cloned._comments = clone3(this._comments);
        cloned._statements = clone3(this._statements);
        cloned._debug = this._debug;
        if (this._options !== void 0) {
          cloned._options = clone3(this._options);
        }
        if (this._queryContext !== void 0) {
          cloned._queryContext = clone3(this._queryContext);
        }
        if (this._connection !== void 0) {
          cloned._connection = this._connection;
        }
        return cloned;
      }
      timeout(ms, { cancel } = {}) {
        if (isNumber2(ms) && ms > 0) {
          this._timeout = ms;
          if (cancel) {
            this.client.assertCanCancelQuery();
            this._cancelOnTimeout = true;
          }
        }
        return this;
      }
      // With
      // ------
      isValidStatementArg(statement) {
        return typeof statement === "function" || statement instanceof _Builder || statement && statement.isRawInstance;
      }
      _validateWithArgs(alias, statementOrColumnList, nothingOrStatement, method) {
        const [query, columnList] = typeof nothingOrStatement === "undefined" ? [statementOrColumnList, void 0] : [nothingOrStatement, statementOrColumnList];
        if (typeof alias !== "string") {
          throw new Error(`${method}() first argument must be a string`);
        }
        if (this.isValidStatementArg(query) && typeof columnList === "undefined") {
          return;
        }
        const isNonEmptyNameList = Array.isArray(columnList) && columnList.length > 0 && columnList.every((it) => typeof it === "string");
        if (!isNonEmptyNameList) {
          throw new Error(
            `${method}() second argument must be a statement or non-empty column name list.`
          );
        }
        if (this.isValidStatementArg(query)) {
          return;
        }
        throw new Error(
          `${method}() third argument must be a function / QueryBuilder or a raw when its second argument is a column name list`
        );
      }
      with(alias, statementOrColumnList, nothingOrStatement) {
        this._validateWithArgs(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          "with"
        );
        return this.withWrapped(alias, statementOrColumnList, nothingOrStatement);
      }
      withMaterialized(alias, statementOrColumnList, nothingOrStatement) {
        throw new Error("With materialized is not supported by this dialect");
      }
      withNotMaterialized(alias, statementOrColumnList, nothingOrStatement) {
        throw new Error("With materialized is not supported by this dialect");
      }
      // Helper for compiling any advanced `with` queries.
      withWrapped(alias, statementOrColumnList, nothingOrStatement, materialized) {
        const [query, columnList] = typeof nothingOrStatement === "undefined" ? [statementOrColumnList, void 0] : [nothingOrStatement, statementOrColumnList];
        const statement = {
          grouping: "with",
          type: "withWrapped",
          alias,
          columnList,
          value: query
        };
        if (materialized !== void 0) {
          statement.materialized = materialized;
        }
        this._statements.push(statement);
        return this;
      }
      // With Recursive
      // ------
      withRecursive(alias, statementOrColumnList, nothingOrStatement) {
        this._validateWithArgs(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          "withRecursive"
        );
        return this.withRecursiveWrapped(
          alias,
          statementOrColumnList,
          nothingOrStatement
        );
      }
      // Helper for compiling any advanced `withRecursive` queries.
      withRecursiveWrapped(alias, statementOrColumnList, nothingOrStatement) {
        this.withWrapped(alias, statementOrColumnList, nothingOrStatement);
        this._statements[this._statements.length - 1].recursive = true;
        return this;
      }
      // Select
      // ------
      // Adds a column or columns to the list of "columns"
      // being selected on the query.
      columns(column) {
        if (!column && column !== 0) return this;
        this._statements.push({
          grouping: "columns",
          value: normalizeArr(...arguments)
        });
        return this;
      }
      // Adds a comment to the query
      comment(txt) {
        if (!isString2(txt)) {
          throw new Error("Comment must be a string");
        }
        const forbiddenChars = ["/*", "*/", "?"];
        if (forbiddenChars.some((chars) => txt.includes(chars))) {
          throw new Error(`Cannot include ${forbiddenChars.join(", ")} in comment`);
        }
        this._comments.push({
          comment: txt
        });
        return this;
      }
      // Allow for a sub-select to be explicitly aliased as a column,
      // without needing to compile the query in a where.
      as(column) {
        this._single.as = column;
        return this;
      }
      // Adds a single hint or an array of hits to the list of "hintComments" on the query.
      hintComment(hints) {
        hints = Array.isArray(hints) ? hints : [hints];
        if (hints.some((hint) => !isString2(hint))) {
          throw new Error("Hint comment must be a string");
        }
        if (hints.some((hint) => hint.includes("/*") || hint.includes("*/"))) {
          throw new Error('Hint comment cannot include "/*" or "*/"');
        }
        if (hints.some((hint) => hint.includes("?"))) {
          throw new Error('Hint comment cannot include "?"');
        }
        this._statements.push({
          grouping: "hintComments",
          value: hints
        });
        return this;
      }
      // Prepends the `schemaName` on `tableName` defined by `.table` and `.join`.
      withSchema(schemaName) {
        this._single.schema = schemaName;
        return this;
      }
      // Sets the `tableName` on the query.
      // Alias to "from" for select and "into" for insert statements
      // e.g. builder.insert({a: value}).into('tableName')
      // `options`: options object containing keys:
      //   - `only`: whether the query should use SQL's ONLY to not return
      //           inheriting table data. Defaults to false.
      table(tableName, options = {}) {
        this._single.table = tableName;
        this._single.only = options.only === true;
        return this;
      }
      // Adds a `distinct` clause to the query.
      distinct(...args) {
        this._statements.push({
          grouping: "columns",
          value: normalizeArr(...args),
          distinct: true
        });
        return this;
      }
      distinctOn(...args) {
        if (isEmpty(args)) {
          throw new Error("distinctOn requires at least on argument");
        }
        this._statements.push({
          grouping: "columns",
          value: normalizeArr(...args),
          distinctOn: true
        });
        return this;
      }
      // Adds a join clause to the query, allowing for advanced joins
      // with an anonymous function as the second argument.
      join(table, first, ...args) {
        let join2;
        const schema = table instanceof _Builder || typeof table === "function" ? void 0 : this._single.schema;
        const joinType = this._joinType();
        if (typeof first === "function") {
          join2 = new JoinClause(table, joinType, schema);
          first.call(join2, join2);
        } else if (joinType === "raw") {
          join2 = new JoinClause(this.client.raw(table, first), "raw");
        } else {
          join2 = new JoinClause(table, joinType, schema);
          if (first) {
            join2.on(first, ...args);
          }
        }
        this._statements.push(join2);
        return this;
      }
      using(tables) {
        throw new Error(
          "'using' function is only available in PostgreSQL dialect with Delete statements."
        );
      }
      // JOIN blocks:
      innerJoin(...args) {
        return this._joinType("inner").join(...args);
      }
      leftJoin(...args) {
        return this._joinType("left").join(...args);
      }
      leftOuterJoin(...args) {
        return this._joinType("left outer").join(...args);
      }
      rightJoin(...args) {
        return this._joinType("right").join(...args);
      }
      rightOuterJoin(...args) {
        return this._joinType("right outer").join(...args);
      }
      outerJoin(...args) {
        return this._joinType("outer").join(...args);
      }
      fullOuterJoin(...args) {
        return this._joinType("full outer").join(...args);
      }
      crossJoin(...args) {
        return this._joinType("cross").join(...args);
      }
      joinRaw(...args) {
        return this._joinType("raw").join(...args);
      }
      // Where modifiers:
      get or() {
        return this._bool("or");
      }
      get not() {
        return this._not(true);
      }
      // The where function can be used in several ways:
      // The most basic is `where(key, value)`, which expands to
      // where key = value.
      where(column, operator, value) {
        const argsLength = arguments.length;
        if (column === false || column === true) {
          return this.where(1, "=", column ? 1 : 0);
        }
        if (typeof column === "function") {
          return this.whereWrapped(column);
        }
        if (isObject5(column) && !column.isRawInstance)
          return this._objectWhere(column);
        if (column && column.isRawInstance && argsLength === 1)
          return this.whereRaw(column);
        if (argsLength === 2) {
          value = operator;
          operator = "=";
          if (value === null) {
            return this.whereNull(column);
          }
        }
        const checkOperator = `${operator}`.toLowerCase().trim();
        if (argsLength === 3) {
          if (checkOperator === "in" || checkOperator === "not in") {
            return this._not(checkOperator === "not in").whereIn(column, value);
          }
          if (checkOperator === "between" || checkOperator === "not between") {
            return this._not(checkOperator === "not between").whereBetween(
              column,
              value
            );
          }
        }
        if (value === null) {
          if (checkOperator === "is" || checkOperator === "is not") {
            return this._not(checkOperator === "is not").whereNull(column);
          }
        }
        this._statements.push({
          grouping: "where",
          type: "whereBasic",
          column,
          operator,
          value,
          not: this._not(),
          bool: this._bool(),
          asColumn: this._asColumnFlag
        });
        return this;
      }
      whereColumn(...args) {
        this._asColumnFlag = true;
        this.where(...args);
        this._asColumnFlag = false;
        return this;
      }
      // Adds an `or where` clause to the query.
      orWhere(column, ...args) {
        this._bool("or");
        const obj = column;
        if (isObject5(obj) && !obj.isRawInstance) {
          return this.whereWrapped(function() {
            for (const key in obj) {
              this.andWhere(key, obj[key]);
            }
          });
        }
        return this.where(column, ...args);
      }
      orWhereColumn(column, ...args) {
        this._bool("or");
        const obj = column;
        if (isObject5(obj) && !obj.isRawInstance) {
          return this.whereWrapped(function() {
            for (const key in obj) {
              this.andWhereColumn(key, "=", obj[key]);
            }
          });
        }
        return this.whereColumn(column, ...args);
      }
      // Adds an `not where` clause to the query.
      whereNot(column, ...args) {
        if (args.length >= 2) {
          if (args[0] === "in" || args[0] === "between") {
            this.client.logger.warn(
              'whereNot is not suitable for "in" and "between" type subqueries. You should use "not in" and "not between" instead.'
            );
          }
        }
        return this._not(true).where(column, ...args);
      }
      whereNotColumn(...args) {
        return this._not(true).whereColumn(...args);
      }
      // Adds an `or not where` clause to the query.
      orWhereNot(...args) {
        return this._bool("or").whereNot(...args);
      }
      orWhereNotColumn(...args) {
        return this._bool("or").whereNotColumn(...args);
      }
      // Processes an object literal provided in a "where" clause.
      _objectWhere(obj) {
        const boolVal = this._bool();
        const notVal = this._not() ? "Not" : "";
        for (const key in obj) {
          this[boolVal + "Where" + notVal](key, obj[key]);
        }
        return this;
      }
      // Adds a raw `where` clause to the query.
      whereRaw(sql, bindings) {
        const raw = sql.isRawInstance ? sql : this.client.raw(sql, bindings);
        this._statements.push({
          grouping: "where",
          type: "whereRaw",
          value: raw,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      orWhereRaw(sql, bindings) {
        return this._bool("or").whereRaw(sql, bindings);
      }
      // Helper for compiling any advanced `where` queries.
      whereWrapped(callback) {
        this._statements.push({
          grouping: "where",
          type: "whereWrapped",
          value: callback,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      // Adds a `where exists` clause to the query.
      whereExists(callback) {
        this._statements.push({
          grouping: "where",
          type: "whereExists",
          value: callback,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      // Adds an `or where exists` clause to the query.
      orWhereExists(callback) {
        return this._bool("or").whereExists(callback);
      }
      // Adds a `where not exists` clause to the query.
      whereNotExists(callback) {
        return this._not(true).whereExists(callback);
      }
      // Adds a `or where not exists` clause to the query.
      orWhereNotExists(callback) {
        return this._bool("or").whereNotExists(callback);
      }
      // Adds a `where in` clause to the query.
      whereIn(column, values) {
        if (Array.isArray(values) && isEmpty(values))
          return this.where(this._not());
        this._statements.push({
          grouping: "where",
          type: "whereIn",
          column,
          value: values,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      // Adds a `or where in` clause to the query.
      orWhereIn(column, values) {
        return this._bool("or").whereIn(column, values);
      }
      // Adds a `where not in` clause to the query.
      whereNotIn(column, values) {
        return this._not(true).whereIn(column, values);
      }
      // Adds a `or where not in` clause to the query.
      orWhereNotIn(column, values) {
        return this._bool("or")._not(true).whereIn(column, values);
      }
      // Adds a `where null` clause to the query.
      whereNull(column) {
        this._statements.push({
          grouping: "where",
          type: "whereNull",
          column,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      // Adds a `or where null` clause to the query.
      orWhereNull(column) {
        return this._bool("or").whereNull(column);
      }
      // Adds a `where not null` clause to the query.
      whereNotNull(column) {
        return this._not(true).whereNull(column);
      }
      // Adds a `or where not null` clause to the query.
      orWhereNotNull(column) {
        return this._bool("or").whereNotNull(column);
      }
      // Adds a `where between` clause to the query.
      whereBetween(column, values) {
        assert3(
          Array.isArray(values),
          "The second argument to whereBetween must be an array."
        );
        assert3(
          values.length === 2,
          "You must specify 2 values for the whereBetween clause"
        );
        this._statements.push({
          grouping: "where",
          type: "whereBetween",
          column,
          value: values,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      // Adds a `where not between` clause to the query.
      whereNotBetween(column, values) {
        return this._not(true).whereBetween(column, values);
      }
      // Adds a `or where between` clause to the query.
      orWhereBetween(column, values) {
        return this._bool("or").whereBetween(column, values);
      }
      // Adds a `or where not between` clause to the query.
      orWhereNotBetween(column, values) {
        return this._bool("or").whereNotBetween(column, values);
      }
      _whereLike(type, column, value) {
        this._statements.push({
          grouping: "where",
          type,
          column,
          value,
          not: this._not(),
          bool: this._bool(),
          asColumn: this._asColumnFlag
        });
        return this;
      }
      // Adds a `where like` clause to the query.
      whereLike(column, value) {
        return this._whereLike("whereLike", column, value);
      }
      // Adds a `or where like` clause to the query.
      orWhereLike(column, value) {
        return this._bool("or")._whereLike("whereLike", column, value);
      }
      // Adds a `where ilike` clause to the query.
      whereILike(column, value) {
        return this._whereLike("whereILike", column, value);
      }
      // Adds a `or where ilike` clause to the query.
      orWhereILike(column, value) {
        return this._bool("or")._whereLike("whereILike", column, value);
      }
      // Adds a `group by` clause to the query.
      groupBy(item) {
        if (item && item.isRawInstance) {
          return this.groupByRaw.apply(this, arguments);
        }
        this._statements.push({
          grouping: "group",
          type: "groupByBasic",
          value: normalizeArr(...arguments)
        });
        return this;
      }
      // Adds a raw `group by` clause to the query.
      groupByRaw(sql, bindings) {
        const raw = sql.isRawInstance ? sql : this.client.raw(sql, bindings);
        this._statements.push({
          grouping: "group",
          type: "groupByRaw",
          value: raw
        });
        return this;
      }
      // Adds a `order by` clause to the query.
      orderBy(column, direction, nulls = "") {
        if (Array.isArray(column)) {
          return this._orderByArray(column);
        }
        this._statements.push({
          grouping: "order",
          type: "orderByBasic",
          value: column,
          direction,
          nulls
        });
        return this;
      }
      // Adds a `order by` with multiple columns to the query.
      _orderByArray(columnDefs) {
        for (let i = 0; i < columnDefs.length; i++) {
          const columnInfo = columnDefs[i];
          if (isObject5(columnInfo)) {
            this._statements.push({
              grouping: "order",
              type: "orderByBasic",
              value: columnInfo["column"],
              direction: columnInfo["order"],
              nulls: columnInfo["nulls"]
            });
          } else if (isString2(columnInfo) || isNumber2(columnInfo)) {
            this._statements.push({
              grouping: "order",
              type: "orderByBasic",
              value: columnInfo
            });
          }
        }
        return this;
      }
      // Add a raw `order by` clause to the query.
      orderByRaw(sql, bindings) {
        const raw = sql.isRawInstance ? sql : this.client.raw(sql, bindings);
        this._statements.push({
          grouping: "order",
          type: "orderByRaw",
          value: raw
        });
        return this;
      }
      _union(clause, args) {
        let callbacks = args[0];
        let wrap = args[1];
        if (args.length === 1 || args.length === 2 && isBoolean2(wrap)) {
          if (!Array.isArray(callbacks)) {
            callbacks = [callbacks];
          }
          for (let i = 0, l = callbacks.length; i < l; i++) {
            this._statements.push({
              grouping: "union",
              clause,
              value: callbacks[i],
              wrap: wrap || false
            });
          }
        } else {
          callbacks = toArray2(args).slice(0, args.length - 1);
          wrap = args[args.length - 1];
          if (!isBoolean2(wrap)) {
            callbacks.push(wrap);
            wrap = false;
          }
          this._union(clause, [callbacks, wrap]);
        }
        return this;
      }
      // Add a union statement to the query.
      union(...args) {
        return this._union("union", args);
      }
      // Adds a union all statement to the query.
      unionAll(...args) {
        return this._union("union all", args);
      }
      intersect(...args) {
        return this._union("intersect", args);
      }
      except(...args) {
        return this._union("except", args);
      }
      // Adds a `having` clause to the query.
      having(column, operator, value) {
        if (column.isRawInstance && arguments.length === 1) {
          return this.havingRaw(column);
        }
        if (typeof column === "function") {
          return this.havingWrapped(column);
        }
        this._statements.push({
          grouping: "having",
          type: "havingBasic",
          column,
          operator,
          value,
          bool: this._bool(),
          not: this._not()
        });
        return this;
      }
      orHaving(column, ...args) {
        this._bool("or");
        const obj = column;
        if (isObject5(obj) && !obj.isRawInstance) {
          return this.havingWrapped(function() {
            for (const key in obj) {
              this.andHaving(key, obj[key]);
            }
          });
        }
        return this.having(column, ...args);
      }
      // Helper for compiling any advanced `having` queries.
      havingWrapped(callback) {
        this._statements.push({
          grouping: "having",
          type: "havingWrapped",
          value: callback,
          bool: this._bool(),
          not: this._not()
        });
        return this;
      }
      havingNull(column) {
        this._statements.push({
          grouping: "having",
          type: "havingNull",
          column,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      orHavingNull(callback) {
        return this._bool("or").havingNull(callback);
      }
      havingNotNull(callback) {
        return this._not(true).havingNull(callback);
      }
      orHavingNotNull(callback) {
        return this._not(true)._bool("or").havingNull(callback);
      }
      havingExists(callback) {
        this._statements.push({
          grouping: "having",
          type: "havingExists",
          value: callback,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      orHavingExists(callback) {
        return this._bool("or").havingExists(callback);
      }
      havingNotExists(callback) {
        return this._not(true).havingExists(callback);
      }
      orHavingNotExists(callback) {
        return this._not(true)._bool("or").havingExists(callback);
      }
      havingBetween(column, values) {
        assert3(
          Array.isArray(values),
          "The second argument to havingBetween must be an array."
        );
        assert3(
          values.length === 2,
          "You must specify 2 values for the havingBetween clause"
        );
        this._statements.push({
          grouping: "having",
          type: "havingBetween",
          column,
          value: values,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      orHavingBetween(column, values) {
        return this._bool("or").havingBetween(column, values);
      }
      havingNotBetween(column, values) {
        return this._not(true).havingBetween(column, values);
      }
      orHavingNotBetween(column, values) {
        return this._not(true)._bool("or").havingBetween(column, values);
      }
      havingIn(column, values) {
        if (Array.isArray(values) && isEmpty(values))
          return this.where(this._not());
        this._statements.push({
          grouping: "having",
          type: "havingIn",
          column,
          value: values,
          not: this._not(),
          bool: this._bool()
        });
        return this;
      }
      // Adds a `or where in` clause to the query.
      orHavingIn(column, values) {
        return this._bool("or").havingIn(column, values);
      }
      // Adds a `where not in` clause to the query.
      havingNotIn(column, values) {
        return this._not(true).havingIn(column, values);
      }
      // Adds a `or where not in` clause to the query.
      orHavingNotIn(column, values) {
        return this._bool("or")._not(true).havingIn(column, values);
      }
      // Adds a raw `having` clause to the query.
      havingRaw(sql, bindings) {
        const raw = sql.isRawInstance ? sql : this.client.raw(sql, bindings);
        this._statements.push({
          grouping: "having",
          type: "havingRaw",
          value: raw,
          bool: this._bool(),
          not: this._not()
        });
        return this;
      }
      orHavingRaw(sql, bindings) {
        return this._bool("or").havingRaw(sql, bindings);
      }
      // set the skip binding parameter (= insert the raw value in the query) for an attribute.
      _setSkipBinding(attribute, options) {
        let skipBinding = options;
        if (isObject5(options)) {
          skipBinding = options.skipBinding;
        }
        this._single.skipBinding = this._single.skipBinding || {};
        this._single.skipBinding[attribute] = skipBinding;
      }
      // Only allow a single "offset" to be set for the current query.
      offset(value, options) {
        if (value == null || value.isRawInstance || value instanceof _Builder) {
          this._single.offset = value;
        } else {
          const val = parseInt(value, 10);
          if (isNaN(val)) {
            this.client.logger.warn("A valid integer must be provided to offset");
          } else if (val < 0) {
            throw new Error(`A non-negative integer must be provided to offset.`);
          } else {
            this._single.offset = val;
          }
        }
        this._setSkipBinding("offset", options);
        return this;
      }
      // Only allow a single "limit" to be set for the current query.
      limit(value, options) {
        const val = parseInt(value, 10);
        if (isNaN(val)) {
          this.client.logger.warn("A valid integer must be provided to limit");
        } else {
          this._single.limit = val;
          this._setSkipBinding("limit", options);
        }
        return this;
      }
      // Retrieve the "count" result of the query.
      count(column, options) {
        return this._aggregate("count", column || "*", options);
      }
      // Retrieve the minimum value of a given column.
      min(column, options) {
        return this._aggregate("min", column, options);
      }
      // Retrieve the maximum value of a given column.
      max(column, options) {
        return this._aggregate("max", column, options);
      }
      // Retrieve the sum of the values of a given column.
      sum(column, options) {
        return this._aggregate("sum", column, options);
      }
      // Retrieve the average of the values of a given column.
      avg(column, options) {
        return this._aggregate("avg", column, options);
      }
      // Retrieve the "count" of the distinct results of the query.
      countDistinct(...columns) {
        let options;
        if (columns.length > 1 && isPlainObject4(last(columns))) {
          [options] = columns.splice(columns.length - 1, 1);
        }
        if (!columns.length) {
          columns = "*";
        } else if (columns.length === 1) {
          columns = columns[0];
        }
        return this._aggregate("count", columns, { ...options, distinct: true });
      }
      // Retrieve the sum of the distinct values of a given column.
      sumDistinct(column, options) {
        return this._aggregate("sum", column, { ...options, distinct: true });
      }
      // Retrieve the vg of the distinct results of the query.
      avgDistinct(column, options) {
        return this._aggregate("avg", column, { ...options, distinct: true });
      }
      // Increments a column's value by the specified amount.
      increment(column, amount = 1) {
        if (isObject5(column)) {
          for (const key in column) {
            this._counter(key, column[key]);
          }
          return this;
        }
        return this._counter(column, amount);
      }
      // Decrements a column's value by the specified amount.
      decrement(column, amount = 1) {
        if (isObject5(column)) {
          for (const key in column) {
            this._counter(key, -column[key]);
          }
          return this;
        }
        return this._counter(column, -amount);
      }
      // Clears increments/decrements
      clearCounters() {
        this._single.counter = {};
        return this;
      }
      // Sets the values for a `select` query, informing that only the first
      // row should be returned (limit 1).
      first(...args) {
        if (this._method && this._method !== "select") {
          throw new Error(`Cannot chain .first() on "${this._method}" query`);
        }
        this.select(normalizeArr(...args));
        this._method = "first";
        this.limit(1);
        return this;
      }
      // Use existing connection to execute the query
      // Same value that client.acquireConnection() for an according client returns should be passed
      connection(_connection) {
        this._connection = _connection;
        this.client.processPassedConnection(_connection);
        return this;
      }
      // Pluck a column from a query.
      pluck(column) {
        if (this._method && this._method !== "select") {
          throw new Error(`Cannot chain .pluck() on "${this._method}" query`);
        }
        this._method = "pluck";
        this._single.pluck = column;
        this._statements.push({
          grouping: "columns",
          type: "pluck",
          value: column
        });
        return this;
      }
      // Deprecated. Remove everything from select clause
      clearSelect() {
        this._clearGrouping("columns");
        return this;
      }
      // Deprecated. Remove everything from where clause
      clearWhere() {
        this._clearGrouping("where");
        return this;
      }
      // Deprecated. Remove everything from group clause
      clearGroup() {
        this._clearGrouping("group");
        return this;
      }
      // Deprecated. Remove everything from order clause
      clearOrder() {
        this._clearGrouping("order");
        return this;
      }
      // Deprecated. Remove everything from having clause
      clearHaving() {
        this._clearGrouping("having");
        return this;
      }
      // Remove everything from statement clause
      clear(statement) {
        if (!CLEARABLE_STATEMENTS.has(statement))
          throw new Error(`Knex Error: unknown statement '${statement}'`);
        if (statement.startsWith("counter")) return this.clearCounters();
        if (statement === "select") {
          statement = "columns";
        }
        this._clearGrouping(statement);
        return this;
      }
      // Insert & Update
      // ------
      // Sets the values for an `insert` query.
      insert(values, returning, options) {
        this._method = "insert";
        if (!isEmpty(returning)) this.returning(returning, options);
        this._single.insert = values;
        return this;
      }
      // Sets the values for an `update`, allowing for both
      // `.update(key, value, [returning])` and `.update(obj, [returning])` syntaxes.
      update(values, returning, options) {
        let ret;
        const obj = this._single.update || {};
        this._method = "update";
        if (isString2(values)) {
          if (isPlainObject4(returning)) {
            obj[values] = JSON.stringify(returning);
          } else {
            obj[values] = returning;
          }
          if (arguments.length > 2) {
            ret = arguments[2];
          }
        } else {
          const keys2 = Object.keys(values);
          if (this._single.update) {
            this.client.logger.warn("Update called multiple times with objects.");
          }
          let i = -1;
          while (++i < keys2.length) {
            obj[keys2[i]] = values[keys2[i]];
          }
          ret = arguments[1];
        }
        if (!isEmpty(ret)) this.returning(ret, options);
        this._single.update = obj;
        return this;
      }
      // Sets the returning value for the query.
      returning(returning, options) {
        this._single.returning = returning;
        this._single.options = options;
        return this;
      }
      onConflict(columns) {
        if (typeof columns === "string") {
          columns = [columns];
        }
        return new OnConflictBuilder(this, columns || true);
      }
      // Delete
      // ------
      // Executes a delete statement on the query;
      delete(ret, options) {
        this._method = "del";
        if (!isEmpty(ret)) this.returning(ret, options);
        return this;
      }
      // Truncates a table, ends the query chain.
      truncate(tableName) {
        this._method = "truncate";
        if (tableName) {
          this._single.table = tableName;
        }
        return this;
      }
      // Retrieves columns for the table specified by `knex(tableName)`
      columnInfo(column) {
        this._method = "columnInfo";
        this._single.columnInfo = column;
        return this;
      }
      // Set a lock for update constraint.
      forUpdate(...tables) {
        this._single.lock = lockMode.forUpdate;
        if (tables.length === 1 && Array.isArray(tables[0])) {
          this._single.lockTables = tables[0];
        } else {
          this._single.lockTables = tables;
        }
        return this;
      }
      // Set a lock for share constraint.
      forShare(...tables) {
        this._single.lock = lockMode.forShare;
        this._single.lockTables = tables;
        return this;
      }
      // Set a lock for no key update constraint.
      forNoKeyUpdate(...tables) {
        this._single.lock = lockMode.forNoKeyUpdate;
        this._single.lockTables = tables;
        return this;
      }
      // Set a lock for key share constraint.
      forKeyShare(...tables) {
        this._single.lock = lockMode.forKeyShare;
        this._single.lockTables = tables;
        return this;
      }
      // Skips locked rows when using a lock constraint.
      skipLocked() {
        if (!this._isSelectQuery()) {
          throw new Error(`Cannot chain .skipLocked() on "${this._method}" query!`);
        }
        if (!this._hasLockMode()) {
          throw new Error(
            ".skipLocked() can only be used after a call to .forShare() or .forUpdate()!"
          );
        }
        if (this._single.waitMode === waitMode.noWait) {
          throw new Error(".skipLocked() cannot be used together with .noWait()!");
        }
        this._single.waitMode = waitMode.skipLocked;
        return this;
      }
      // Causes error when acessing a locked row instead of waiting for it to be released.
      noWait() {
        if (!this._isSelectQuery()) {
          throw new Error(`Cannot chain .noWait() on "${this._method}" query!`);
        }
        if (!this._hasLockMode()) {
          throw new Error(
            ".noWait() can only be used after a call to .forShare() or .forUpdate()!"
          );
        }
        if (this._single.waitMode === waitMode.skipLocked) {
          throw new Error(".noWait() cannot be used together with .skipLocked()!");
        }
        this._single.waitMode = waitMode.noWait;
        return this;
      }
      // Takes a JS object of methods to call and calls them
      fromJS(obj) {
        each(obj, (val, key) => {
          if (typeof this[key] !== "function") {
            this.client.logger.warn(`Knex Error: unknown key ${key}`);
          }
          if (Array.isArray(val)) {
            this[key].apply(this, val);
          } else {
            this[key](val);
          }
        });
        return this;
      }
      fromRaw(sql, bindings) {
        const raw = sql.isRawInstance ? sql : this.client.raw(sql, bindings);
        return this.from(raw);
      }
      // Passes query to provided callback function, useful for e.g. composing
      // domain-specific helpers
      modify(callback) {
        callback.apply(this, [this].concat(tail(arguments)));
        return this;
      }
      upsert(values, returning, options) {
        throw new Error(
          `Upsert is not yet supported for dialect ${this.client.dialect}`
        );
      }
      // JSON support functions
      _json(nameFunction, params) {
        this._statements.push({
          grouping: "columns",
          type: "json",
          method: nameFunction,
          params
        });
        return this;
      }
      jsonExtract() {
        const column = arguments[0];
        let path33;
        let alias;
        let singleValue = true;
        if (arguments.length >= 2) {
          path33 = arguments[1];
        }
        if (arguments.length >= 3) {
          alias = arguments[2];
        }
        if (arguments.length === 4) {
          singleValue = arguments[3];
        }
        if (arguments.length === 2 && Array.isArray(arguments[0]) && isBoolean2(arguments[1])) {
          singleValue = arguments[1];
        }
        return this._json("jsonExtract", {
          column,
          path: path33,
          alias,
          singleValue
          // boolean used only in MSSQL to use function for extract value instead of object/array.
        });
      }
      jsonSet(column, path33, value, alias) {
        return this._json("jsonSet", {
          column,
          path: path33,
          value,
          alias
        });
      }
      jsonInsert(column, path33, value, alias) {
        return this._json("jsonInsert", {
          column,
          path: path33,
          value,
          alias
        });
      }
      jsonRemove(column, path33, alias) {
        return this._json("jsonRemove", {
          column,
          path: path33,
          alias
        });
      }
      // Wheres for JSON
      _isJsonObject(jsonValue) {
        return isObject5(jsonValue) && !(jsonValue instanceof _Builder);
      }
      _whereJsonWrappedValue(type, column, value) {
        const whereJsonClause = {
          grouping: "where",
          type,
          column,
          value,
          not: this._not(),
          bool: this._bool(),
          asColumn: this._asColumnFlag
        };
        if (arguments[3]) {
          whereJsonClause.operator = arguments[3];
        }
        if (arguments[4]) {
          whereJsonClause.jsonPath = arguments[4];
        }
        this._statements.push(whereJsonClause);
      }
      whereJsonObject(column, value) {
        this._whereJsonWrappedValue("whereJsonObject", column, value);
        return this;
      }
      orWhereJsonObject(column, value) {
        return this._bool("or").whereJsonObject(column, value);
      }
      whereNotJsonObject(column, value) {
        return this._not(true).whereJsonObject(column, value);
      }
      orWhereNotJsonObject(column, value) {
        return this._bool("or").whereNotJsonObject(column, value);
      }
      whereJsonPath(column, path33, operator, value) {
        this._whereJsonWrappedValue("whereJsonPath", column, value, operator, path33);
        return this;
      }
      orWhereJsonPath(column, path33, operator, value) {
        return this._bool("or").whereJsonPath(column, path33, operator, value);
      }
      // Json superset wheres
      whereJsonSupersetOf(column, value) {
        this._whereJsonWrappedValue("whereJsonSupersetOf", column, value);
        return this;
      }
      whereJsonNotSupersetOf(column, value) {
        return this._not(true).whereJsonSupersetOf(column, value);
      }
      orWhereJsonSupersetOf(column, value) {
        return this._bool("or").whereJsonSupersetOf(column, value);
      }
      orWhereJsonNotSupersetOf(column, value) {
        return this._bool("or").whereJsonNotSupersetOf(column, value);
      }
      // Json subset wheres
      whereJsonSubsetOf(column, value) {
        this._whereJsonWrappedValue("whereJsonSubsetOf", column, value);
        return this;
      }
      whereJsonNotSubsetOf(column, value) {
        return this._not(true).whereJsonSubsetOf(column, value);
      }
      orWhereJsonSubsetOf(column, value) {
        return this._bool("or").whereJsonSubsetOf(column, value);
      }
      orWhereJsonNotSubsetOf(column, value) {
        return this._bool("or").whereJsonNotSubsetOf(column, value);
      }
      whereJsonHasNone(column, values) {
        this._not(true).whereJsonHasAll(column, values);
        return this;
      }
      // end of wheres for JSON
      _analytic(alias, second, third) {
        let analytic;
        const { schema } = this._single;
        const method = this._analyticMethod();
        alias = typeof alias === "string" ? alias : null;
        assert3(
          typeof second === "function" || second.isRawInstance || Array.isArray(second) || typeof second === "string" || typeof second === "object",
          `The second argument to an analytic function must be either a function, a raw,
       an array of string or object, an object or a single string.`
        );
        if (third) {
          assert3(
            Array.isArray(third) || typeof third === "string" || typeof third === "object",
            "The third argument to an analytic function must be either a string, an array of string or object or an object."
          );
        }
        if (isFunction4(second)) {
          analytic = new Analytic(method, schema, alias);
          second.call(analytic, analytic);
        } else if (second.isRawInstance) {
          const raw = second;
          analytic = {
            grouping: "columns",
            type: "analytic",
            method,
            raw,
            alias
          };
        } else {
          const order = !Array.isArray(second) ? [second] : second;
          let partitions = third || [];
          partitions = !Array.isArray(partitions) ? [partitions] : partitions;
          analytic = {
            grouping: "columns",
            type: "analytic",
            method,
            order,
            alias,
            partitions
          };
        }
        this._statements.push(analytic);
        return this;
      }
      rank(...args) {
        return this._analyticMethod("rank")._analytic(...args);
      }
      denseRank(...args) {
        return this._analyticMethod("dense_rank")._analytic(...args);
      }
      rowNumber(...args) {
        return this._analyticMethod("row_number")._analytic(...args);
      }
      // ----------------------------------------------------------------------
      // Helper for the incrementing/decrementing queries.
      _counter(column, amount) {
        amount = parseFloat(amount);
        this._method = "update";
        this._single.counter = this._single.counter || {};
        this._single.counter[column] = amount;
        return this;
      }
      // Helper to get or set the "boolFlag" value.
      _bool(val) {
        if (arguments.length === 1) {
          this._boolFlag = val;
          return this;
        }
        const ret = this._boolFlag;
        this._boolFlag = "and";
        return ret;
      }
      // Helper to get or set the "notFlag" value.
      _not(val) {
        if (arguments.length === 1) {
          this._notFlag = val;
          return this;
        }
        const ret = this._notFlag;
        this._notFlag = false;
        return ret;
      }
      // Helper to get or set the "joinFlag" value.
      _joinType(val) {
        if (arguments.length === 1) {
          this._joinFlag = val;
          return this;
        }
        const ret = this._joinFlag || "inner";
        this._joinFlag = "inner";
        return ret;
      }
      _analyticMethod(val) {
        if (arguments.length === 1) {
          this._analyticFlag = val;
          return this;
        }
        return this._analyticFlag || "row_number";
      }
      // Helper for compiling any aggregate queries.
      _aggregate(method, column, options = {}) {
        this._statements.push({
          grouping: "columns",
          type: column.isRawInstance ? "aggregateRaw" : "aggregate",
          method,
          value: column,
          aggregateDistinct: options.distinct || false,
          alias: options.as
        });
        return this;
      }
      // Helper function for clearing or reseting a grouping type from the builder
      _clearGrouping(grouping) {
        if (grouping in this._single) {
          this._single[grouping] = void 0;
        } else {
          this._statements = reject(this._statements, { grouping });
        }
      }
      // Helper function that checks if the builder will emit a select query
      _isSelectQuery() {
        return SELECT_COMMANDS.has(this._method);
      }
      // Helper function that checks if the query has a lock mode set
      _hasLockMode() {
        return LOCK_MODES.has(this._single.lock);
      }
    };
    Builder.prototype.select = Builder.prototype.columns;
    Builder.prototype.column = Builder.prototype.columns;
    Builder.prototype.andWhereNot = Builder.prototype.whereNot;
    Builder.prototype.andWhereNotColumn = Builder.prototype.whereNotColumn;
    Builder.prototype.andWhere = Builder.prototype.where;
    Builder.prototype.andWhereColumn = Builder.prototype.whereColumn;
    Builder.prototype.andWhereRaw = Builder.prototype.whereRaw;
    Builder.prototype.andWhereBetween = Builder.prototype.whereBetween;
    Builder.prototype.andWhereNotBetween = Builder.prototype.whereNotBetween;
    Builder.prototype.andWhereJsonObject = Builder.prototype.whereJsonObject;
    Builder.prototype.andWhereNotJsonObject = Builder.prototype.whereNotJsonObject;
    Builder.prototype.andWhereJsonPath = Builder.prototype.whereJsonPath;
    Builder.prototype.andWhereLike = Builder.prototype.whereLike;
    Builder.prototype.andWhereILike = Builder.prototype.whereILike;
    Builder.prototype.andHaving = Builder.prototype.having;
    Builder.prototype.andHavingIn = Builder.prototype.havingIn;
    Builder.prototype.andHavingNotIn = Builder.prototype.havingNotIn;
    Builder.prototype.andHavingNull = Builder.prototype.havingNull;
    Builder.prototype.andHavingNotNull = Builder.prototype.havingNotNull;
    Builder.prototype.andHavingExists = Builder.prototype.havingExists;
    Builder.prototype.andHavingNotExists = Builder.prototype.havingNotExists;
    Builder.prototype.andHavingBetween = Builder.prototype.havingBetween;
    Builder.prototype.andHavingNotBetween = Builder.prototype.havingNotBetween;
    Builder.prototype.from = Builder.prototype.table;
    Builder.prototype.into = Builder.prototype.table;
    Builder.prototype.del = Builder.prototype.delete;
    augmentWithBuilderInterface(Builder);
    addQueryContext(Builder);
    Builder.extend = (methodName, fn) => {
      if (Object.prototype.hasOwnProperty.call(Builder.prototype, methodName)) {
        throw new Error(
          `Can't extend QueryBuilder with existing method ('${methodName}').`
        );
      }
      assign(Builder.prototype, { [methodName]: fn });
    };
    var OnConflictBuilder = class {
      constructor(builder, columns) {
        this.builder = builder;
        this._columns = columns;
      }
      // Sets insert query to ignore conflicts
      ignore() {
        this.builder._single.onConflict = this._columns;
        this.builder._single.ignore = true;
        return this.builder;
      }
      // Sets insert query to update on conflict
      merge(updates) {
        this.builder._single.onConflict = this._columns;
        this.builder._single.merge = { updates };
        return this.builder;
      }
      // Prevent
      then() {
        throw new Error(
          "Incomplete onConflict clause. .onConflict() must be directly followed by either .merge() or .ignore()"
        );
      }
    };
    module2.exports = Builder;
  }
});

// node_modules/lodash/_arrayReduce.js
var require_arrayReduce = __commonJS({
  "node_modules/lodash/_arrayReduce.js"(exports2, module2) {
    "use strict";
    function arrayReduce(array4, iteratee, accumulator, initAccum) {
      var index = -1, length = array4 == null ? 0 : array4.length;
      if (initAccum && length) {
        accumulator = array4[++index];
      }
      while (++index < length) {
        accumulator = iteratee(accumulator, array4[index], index, array4);
      }
      return accumulator;
    }
    module2.exports = arrayReduce;
  }
});

// node_modules/lodash/_baseReduce.js
var require_baseReduce = __commonJS({
  "node_modules/lodash/_baseReduce.js"(exports2, module2) {
    "use strict";
    function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
      eachFunc(collection, function(value, index, collection2) {
        accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2);
      });
      return accumulator;
    }
    module2.exports = baseReduce;
  }
});

// node_modules/lodash/reduce.js
var require_reduce = __commonJS({
  "node_modules/lodash/reduce.js"(exports2, module2) {
    "use strict";
    var arrayReduce = require_arrayReduce();
    var baseEach = require_baseEach();
    var baseIteratee2 = require_baseIteratee();
    var baseReduce = require_baseReduce();
    var isArray3 = require_isArray();
    function reduce(collection, iteratee, accumulator) {
      var func = isArray3(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;
      return func(collection, baseIteratee2(iteratee, 4), accumulator, initAccum, baseEach);
    }
    module2.exports = reduce;
  }
});

// node_modules/lodash/transform.js
var require_transform = __commonJS({
  "node_modules/lodash/transform.js"(exports2, module2) {
    "use strict";
    var arrayEach = require_arrayEach();
    var baseCreate = require_baseCreate();
    var baseForOwn = require_baseForOwn();
    var baseIteratee2 = require_baseIteratee();
    var getPrototype = require_getPrototype();
    var isArray3 = require_isArray();
    var isBuffer3 = require_isBuffer();
    var isFunction4 = require_isFunction();
    var isObject5 = require_isObject();
    var isTypedArray3 = require_isTypedArray();
    function transform8(object4, iteratee, accumulator) {
      var isArr = isArray3(object4), isArrLike = isArr || isBuffer3(object4) || isTypedArray3(object4);
      iteratee = baseIteratee2(iteratee, 4);
      if (accumulator == null) {
        var Ctor = object4 && object4.constructor;
        if (isArrLike) {
          accumulator = isArr ? new Ctor() : [];
        } else if (isObject5(object4)) {
          accumulator = isFunction4(Ctor) ? baseCreate(getPrototype(object4)) : {};
        } else {
          accumulator = {};
        }
      }
      (isArrLike ? arrayEach : baseForOwn)(object4, function(value, index, object5) {
        return iteratee(accumulator, value, index, object5);
      });
      return accumulator;
    }
    module2.exports = transform8;
  }
});

// node_modules/knex/lib/formatter/formatterUtils.js
var require_formatterUtils = __commonJS({
  "node_modules/knex/lib/formatter/formatterUtils.js"(exports2, module2) {
    "use strict";
    var { isObject: isObject5 } = require_is();
    function compileCallback(callback, method, client, bindingsHolder) {
      const builder = client.queryBuilder();
      callback.call(builder, builder);
      const compiler = client.queryCompiler(builder, bindingsHolder.bindings);
      return compiler.toSQL(method || builder._method || "select");
    }
    function wrapAsIdentifier(value, builder, client) {
      const queryContext = builder.queryContext();
      return client.wrapIdentifier((value || "").trim(), queryContext);
    }
    function formatDefault(value, type, client) {
      if (value === void 0) {
        return "";
      } else if (value === null) {
        return "null";
      } else if (value && value.isRawInstance) {
        return value.toQuery();
      } else if (type === "bool") {
        if (value === "false") value = 0;
        return `'${value ? 1 : 0}'`;
      } else if ((type === "json" || type === "jsonb") && isObject5(value)) {
        return `'${JSON.stringify(value)}'`;
      } else {
        return client._escapeBinding(value.toString());
      }
    }
    module2.exports = {
      compileCallback,
      wrapAsIdentifier,
      formatDefault
    };
  }
});

// node_modules/knex/lib/formatter/wrappingFormatter.js
var require_wrappingFormatter = __commonJS({
  "node_modules/knex/lib/formatter/wrappingFormatter.js"(exports2, module2) {
    "use strict";
    var transform8 = require_transform();
    var QueryBuilder = require_querybuilder();
    var { compileCallback, wrapAsIdentifier } = require_formatterUtils();
    var orderBys = ["asc", "desc"];
    var operators = transform8(
      [
        "=",
        "<",
        ">",
        "<=",
        "<=>",
        ">=",
        "<>",
        "!=",
        "like",
        "not like",
        "between",
        "not between",
        "ilike",
        "not ilike",
        "exists",
        "not exist",
        "rlike",
        "not rlike",
        "regexp",
        "not regexp",
        "match",
        "similar to",
        "not similar to",
        "&",
        "|",
        "^",
        "<<",
        ">>",
        "~",
        "~=",
        "~*",
        "!~",
        "!~*",
        "#",
        "&&",
        "@>",
        "<@",
        "||",
        "&<",
        "&>",
        "-|-",
        "@@",
        "!!",
        ["?", "\\?"],
        ["?|", "\\?|"],
        ["?&", "\\?&"]
      ],
      (result, key) => {
        if (Array.isArray(key)) {
          result[key[0]] = key[1];
        } else {
          result[key] = key;
        }
      },
      {}
    );
    function columnize(target, builder, client, bindingHolder) {
      const columns = Array.isArray(target) ? target : [target];
      let str = "", i = -1;
      while (++i < columns.length) {
        if (i > 0) str += ", ";
        str += wrap(columns[i], void 0, builder, client, bindingHolder);
      }
      return str;
    }
    function wrap(value, isParameter, builder, client, bindingHolder) {
      const raw = unwrapRaw(value, isParameter, builder, client, bindingHolder);
      if (raw) return raw;
      switch (typeof value) {
        case "function":
          return outputQuery(
            compileCallback(value, void 0, client, bindingHolder),
            true,
            builder,
            client
          );
        case "object":
          return parseObject(value, builder, client, bindingHolder);
        case "number":
          return value;
        default:
          return wrapString(value + "", builder, client);
      }
    }
    function unwrapRaw(value, isParameter, builder, client, bindingsHolder) {
      let query;
      if (value instanceof QueryBuilder) {
        query = client.queryCompiler(value).toSQL();
        if (query.bindings) {
          bindingsHolder.bindings.push(...query.bindings);
        }
        return outputQuery(query, isParameter, builder, client);
      }
      if (value && value.isRawInstance) {
        value.client = client;
        if (builder._queryContext) {
          value.queryContext = () => {
            return builder._queryContext;
          };
        }
        query = value.toSQL();
        if (query.bindings) {
          bindingsHolder.bindings.push(...query.bindings);
        }
        return query.sql;
      }
      if (isParameter) {
        bindingsHolder.bindings.push(value);
      }
    }
    function operator(value, builder, client, bindingsHolder) {
      const raw = unwrapRaw(value, void 0, builder, client, bindingsHolder);
      if (raw) return raw;
      const operator2 = operators[(value || "").toLowerCase()];
      if (!operator2) {
        throw new TypeError(`The operator "${value}" is not permitted`);
      }
      return operator2;
    }
    function wrapString(value, builder, client) {
      const asIndex = value.toLowerCase().indexOf(" as ");
      if (asIndex !== -1) {
        const first = value.slice(0, asIndex);
        const second = value.slice(asIndex + 4);
        return client.alias(
          wrapString(first, builder, client),
          wrapAsIdentifier(second, builder, client)
        );
      }
      const wrapped = [];
      let i = -1;
      const segments = value.split(".");
      while (++i < segments.length) {
        value = segments[i];
        if (i === 0 && segments.length > 1) {
          wrapped.push(wrapString((value || "").trim(), builder, client));
        } else {
          wrapped.push(wrapAsIdentifier(value, builder, client));
        }
      }
      return wrapped.join(".");
    }
    function parseObject(obj, builder, client, formatter) {
      const ret = [];
      for (const alias in obj) {
        const queryOrIdentifier = obj[alias];
        if (typeof queryOrIdentifier === "function") {
          const compiled = compileCallback(
            queryOrIdentifier,
            void 0,
            client,
            formatter
          );
          compiled.as = alias;
          ret.push(outputQuery(compiled, true, builder, client));
        } else if (queryOrIdentifier instanceof QueryBuilder) {
          ret.push(
            client.alias(
              `(${wrap(queryOrIdentifier, void 0, builder, client, formatter)})`,
              wrapAsIdentifier(alias, builder, client)
            )
          );
        } else {
          ret.push(
            client.alias(
              wrap(queryOrIdentifier, void 0, builder, client, formatter),
              wrapAsIdentifier(alias, builder, client)
            )
          );
        }
      }
      return ret.join(", ");
    }
    function outputQuery(compiled, isParameter, builder, client) {
      let sql = compiled.sql || "";
      if (sql) {
        if ((compiled.method === "select" || compiled.method === "first") && (isParameter || compiled.as)) {
          sql = `(${sql})`;
          if (compiled.as)
            return client.alias(sql, wrapString(compiled.as, builder, client));
        }
      }
      return sql;
    }
    function rawOrFn(value, method, builder, client, bindingHolder) {
      if (typeof value === "function") {
        return outputQuery(
          compileCallback(value, method, client, bindingHolder),
          void 0,
          builder,
          client
        );
      }
      return unwrapRaw(value, void 0, builder, client, bindingHolder) || "";
    }
    function direction(value, builder, client, bindingsHolder) {
      const raw = unwrapRaw(value, void 0, builder, client, bindingsHolder);
      if (raw) return raw;
      return orderBys.indexOf((value || "").toLowerCase()) !== -1 ? value : "asc";
    }
    module2.exports = {
      columnize,
      direction,
      operator,
      outputQuery,
      rawOrFn,
      unwrapRaw,
      wrap,
      wrapString
    };
  }
});

// node_modules/knex/lib/formatter/rawFormatter.js
var require_rawFormatter = __commonJS({
  "node_modules/knex/lib/formatter/rawFormatter.js"(exports2, module2) {
    "use strict";
    var { columnize } = require_wrappingFormatter();
    function replaceRawArrBindings(raw, client) {
      const bindingsHolder = {
        bindings: []
      };
      const builder = raw;
      const expectedBindings = raw.bindings.length;
      const values = raw.bindings;
      let index = 0;
      const sql = raw.sql.replace(/\\?\?\??/g, function(match) {
        if (match === "\\?") {
          return match;
        }
        const value = values[index++];
        if (match === "??") {
          return columnize(value, builder, client, bindingsHolder);
        }
        return client.parameter(value, builder, bindingsHolder);
      });
      if (expectedBindings !== index) {
        throw new Error(`Expected ${expectedBindings} bindings, saw ${index}`);
      }
      return {
        method: "raw",
        sql,
        bindings: bindingsHolder.bindings
      };
    }
    function replaceKeyBindings(raw, client) {
      const bindingsHolder = {
        bindings: []
      };
      const builder = raw;
      const values = raw.bindings;
      const regex = /\\?(:(\w+):(?=::)|:(\w+):(?!:)|:(\w+))/g;
      const sql = raw.sql.replace(regex, function(match, p1, p22, p3, p4) {
        if (match !== p1) {
          return p1;
        }
        const part = p22 || p3 || p4;
        const key = match.trim();
        const isIdentifier = key[key.length - 1] === ":";
        const value = values[part];
        if (value === void 0) {
          if (Object.prototype.hasOwnProperty.call(values, part)) {
            bindingsHolder.bindings.push(value);
          }
          return match;
        }
        if (isIdentifier) {
          return match.replace(
            p1,
            columnize(value, builder, client, bindingsHolder)
          );
        }
        return match.replace(p1, client.parameter(value, builder, bindingsHolder));
      });
      return {
        method: "raw",
        sql,
        bindings: bindingsHolder.bindings
      };
    }
    module2.exports = {
      replaceKeyBindings,
      replaceRawArrBindings
    };
  }
});

// node_modules/knex/lib/util/nanoid.js
var require_nanoid = __commonJS({
  "node_modules/knex/lib/util/nanoid.js"(exports2, module2) {
    "use strict";
    var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
    var numberAlphabet = "0123456789";
    function nanoid4(size = 21) {
      let id = "";
      let i = size;
      while (i--) {
        id += urlAlphabet[Math.random() * 64 | 0];
      }
      return id;
    }
    function nanonum(size = 21) {
      let id = "";
      let i = size;
      while (i--) {
        id += numberAlphabet[Math.random() * 10 | 0];
      }
      return id;
    }
    module2.exports = { nanoid: nanoid4, nanonum };
  }
});

// node_modules/knex/lib/raw.js
var require_raw2 = __commonJS({
  "node_modules/knex/lib/raw.js"(exports2, module2) {
    "use strict";
    var { EventEmitter: EventEmitter3 } = require("events");
    var debug = require_src3();
    var assign = require_assign();
    var isPlainObject4 = require_isPlainObject();
    var reduce = require_reduce();
    var {
      replaceRawArrBindings,
      replaceKeyBindings
    } = require_rawFormatter();
    var helpers = require_helpers();
    var saveAsyncStack = require_save_async_stack();
    var { nanoid: nanoid4 } = require_nanoid();
    var { isNumber: isNumber2, isObject: isObject5 } = require_is();
    var {
      augmentWithBuilderInterface
    } = require_builder_interface_augmenter();
    var debugBindings = debug("knex:bindings");
    var Raw = class extends EventEmitter3 {
      constructor(client) {
        super();
        this.client = client;
        this.sql = "";
        this.bindings = [];
        this._wrappedBefore = void 0;
        this._wrappedAfter = void 0;
        if (client && client.config) {
          this._debug = client.config.debug;
          saveAsyncStack(this, 4);
        }
      }
      set(sql, bindings) {
        this.sql = sql;
        this.bindings = isObject5(bindings) && !bindings.toSQL || bindings === void 0 ? bindings : [bindings];
        return this;
      }
      timeout(ms, { cancel } = {}) {
        if (isNumber2(ms) && ms > 0) {
          this._timeout = ms;
          if (cancel) {
            this.client.assertCanCancelQuery();
            this._cancelOnTimeout = true;
          }
        }
        return this;
      }
      // Wraps the current sql with `before` and `after`.
      wrap(before, after) {
        this._wrappedBefore = before;
        this._wrappedAfter = after;
        return this;
      }
      // Calls `toString` on the Knex object.
      toString() {
        return this.toQuery();
      }
      // Returns the raw sql for the query.
      toSQL(method, tz) {
        let obj;
        if (Array.isArray(this.bindings)) {
          obj = replaceRawArrBindings(this, this.client);
        } else if (this.bindings && isPlainObject4(this.bindings)) {
          obj = replaceKeyBindings(this, this.client);
        } else {
          obj = {
            method: "raw",
            sql: this.sql,
            bindings: this.bindings === void 0 ? [] : [this.bindings]
          };
        }
        if (this._wrappedBefore) {
          obj.sql = this._wrappedBefore + obj.sql;
        }
        if (this._wrappedAfter) {
          obj.sql = obj.sql + this._wrappedAfter;
        }
        obj.options = reduce(this._options, assign, {});
        if (this._timeout) {
          obj.timeout = this._timeout;
          if (this._cancelOnTimeout) {
            obj.cancelOnTimeout = this._cancelOnTimeout;
          }
        }
        obj.bindings = obj.bindings || [];
        if (helpers.containsUndefined(obj.bindings)) {
          const undefinedBindingIndices = helpers.getUndefinedIndices(
            this.bindings
          );
          debugBindings(obj.bindings);
          throw new Error(
            `Undefined binding(s) detected for keys [${undefinedBindingIndices}] when compiling RAW query: ${obj.sql}`
          );
        }
        obj.__knexQueryUid = nanoid4();
        Object.defineProperties(obj, {
          toNative: {
            value: () => ({
              sql: this.client.positionBindings(obj.sql),
              bindings: this.client.prepBindings(obj.bindings)
            }),
            enumerable: false
          }
        });
        return obj;
      }
    };
    Raw.prototype.isRawInstance = true;
    augmentWithBuilderInterface(Raw);
    helpers.addQueryContext(Raw);
    module2.exports = Raw;
  }
});

// node_modules/lodash/compact.js
var require_compact = __commonJS({
  "node_modules/lodash/compact.js"(exports2, module2) {
    "use strict";
    function compact(array4) {
      var index = -1, length = array4 == null ? 0 : array4.length, resIndex = 0, result = [];
      while (++index < length) {
        var value = array4[index];
        if (value) {
          result[resIndex++] = value;
        }
      }
      return result;
    }
    module2.exports = compact;
  }
});

// node_modules/lodash/_arrayAggregator.js
var require_arrayAggregator = __commonJS({
  "node_modules/lodash/_arrayAggregator.js"(exports2, module2) {
    "use strict";
    function arrayAggregator(array4, setter, iteratee, accumulator) {
      var index = -1, length = array4 == null ? 0 : array4.length;
      while (++index < length) {
        var value = array4[index];
        setter(accumulator, value, iteratee(value), array4);
      }
      return accumulator;
    }
    module2.exports = arrayAggregator;
  }
});

// node_modules/lodash/_baseAggregator.js
var require_baseAggregator = __commonJS({
  "node_modules/lodash/_baseAggregator.js"(exports2, module2) {
    "use strict";
    var baseEach = require_baseEach();
    function baseAggregator(collection, setter, iteratee, accumulator) {
      baseEach(collection, function(value, key, collection2) {
        setter(accumulator, value, iteratee(value), collection2);
      });
      return accumulator;
    }
    module2.exports = baseAggregator;
  }
});

// node_modules/lodash/_createAggregator.js
var require_createAggregator = __commonJS({
  "node_modules/lodash/_createAggregator.js"(exports2, module2) {
    "use strict";
    var arrayAggregator = require_arrayAggregator();
    var baseAggregator = require_baseAggregator();
    var baseIteratee2 = require_baseIteratee();
    var isArray3 = require_isArray();
    function createAggregator(setter, initializer4) {
      return function(collection, iteratee) {
        var func = isArray3(collection) ? arrayAggregator : baseAggregator, accumulator = initializer4 ? initializer4() : {};
        return func(collection, setter, baseIteratee2(iteratee, 2), accumulator);
      };
    }
    module2.exports = createAggregator;
  }
});

// node_modules/lodash/groupBy.js
var require_groupBy = __commonJS({
  "node_modules/lodash/groupBy.js"(exports2, module2) {
    "use strict";
    var baseAssignValue = require_baseAssignValue();
    var createAggregator = require_createAggregator();
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    var groupBy = createAggregator(function(result, value, key) {
      if (hasOwnProperty11.call(result, key)) {
        result[key].push(value);
      } else {
        baseAssignValue(result, key, [value]);
      }
    });
    module2.exports = groupBy;
  }
});

// node_modules/lodash/_baseHas.js
var require_baseHas = __commonJS({
  "node_modules/lodash/_baseHas.js"(exports2, module2) {
    "use strict";
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    function baseHas(object4, key) {
      return object4 != null && hasOwnProperty11.call(object4, key);
    }
    module2.exports = baseHas;
  }
});

// node_modules/lodash/has.js
var require_has = __commonJS({
  "node_modules/lodash/has.js"(exports2, module2) {
    "use strict";
    var baseHas = require_baseHas();
    var hasPath2 = require_hasPath();
    function has(object4, path33) {
      return object4 != null && hasPath2(object4, path33, baseHas);
    }
    module2.exports = has;
  }
});

// node_modules/lodash/map.js
var require_map = __commonJS({
  "node_modules/lodash/map.js"(exports2, module2) {
    "use strict";
    var arrayMap2 = require_arrayMap();
    var baseIteratee2 = require_baseIteratee();
    var baseMap = require_baseMap();
    var isArray3 = require_isArray();
    function map3(collection, iteratee) {
      var func = isArray3(collection) ? arrayMap2 : baseMap;
      return func(collection, baseIteratee2(iteratee, 3));
    }
    module2.exports = map3;
  }
});

// node_modules/lodash/_baseSet.js
var require_baseSet = __commonJS({
  "node_modules/lodash/_baseSet.js"(exports2, module2) {
    "use strict";
    var assignValue = require_assignValue();
    var castPath2 = require_castPath();
    var isIndex2 = require_isIndex();
    var isObject5 = require_isObject();
    var toKey2 = require_toKey();
    function baseSet(object4, path33, value, customizer) {
      if (!isObject5(object4)) {
        return object4;
      }
      path33 = castPath2(path33, object4);
      var index = -1, length = path33.length, lastIndex = length - 1, nested = object4;
      while (nested != null && ++index < length) {
        var key = toKey2(path33[index]), newValue = value;
        if (key === "__proto__" || key === "constructor" || key === "prototype") {
          return object4;
        }
        if (index != lastIndex) {
          var objValue = nested[key];
          newValue = customizer ? customizer(objValue, key, nested) : void 0;
          if (newValue === void 0) {
            newValue = isObject5(objValue) ? objValue : isIndex2(path33[index + 1]) ? [] : {};
          }
        }
        assignValue(nested, key, newValue);
        nested = nested[key];
      }
      return object4;
    }
    module2.exports = baseSet;
  }
});

// node_modules/lodash/_basePickBy.js
var require_basePickBy = __commonJS({
  "node_modules/lodash/_basePickBy.js"(exports2, module2) {
    "use strict";
    var baseGet2 = require_baseGet();
    var baseSet = require_baseSet();
    var castPath2 = require_castPath();
    function basePickBy(object4, paths, predicate) {
      var index = -1, length = paths.length, result = {};
      while (++index < length) {
        var path33 = paths[index], value = baseGet2(object4, path33);
        if (predicate(value, path33)) {
          baseSet(result, castPath2(path33, object4), value);
        }
      }
      return result;
    }
    module2.exports = basePickBy;
  }
});

// node_modules/lodash/pickBy.js
var require_pickBy = __commonJS({
  "node_modules/lodash/pickBy.js"(exports2, module2) {
    "use strict";
    var arrayMap2 = require_arrayMap();
    var baseIteratee2 = require_baseIteratee();
    var basePickBy = require_basePickBy();
    var getAllKeysIn = require_getAllKeysIn();
    function pickBy(object4, predicate) {
      if (object4 == null) {
        return {};
      }
      var props = arrayMap2(getAllKeysIn(object4), function(prop) {
        return [prop];
      });
      predicate = baseIteratee2(predicate);
      return basePickBy(object4, props, function(value, path33) {
        return predicate(value, path33[0]);
      });
    }
    module2.exports = pickBy;
  }
});

// node_modules/lodash/omitBy.js
var require_omitBy = __commonJS({
  "node_modules/lodash/omitBy.js"(exports2, module2) {
    "use strict";
    var baseIteratee2 = require_baseIteratee();
    var negate = require_negate();
    var pickBy = require_pickBy();
    function omitBy(object4, predicate) {
      return pickBy(object4, negate(baseIteratee2(predicate)));
    }
    module2.exports = omitBy;
  }
});

// node_modules/knex/lib/query/querycompiler.js
var require_querycompiler = __commonJS({
  "node_modules/knex/lib/query/querycompiler.js"(exports2, module2) {
    "use strict";
    var helpers = require_helpers();
    var { hasOwn } = require_security();
    var Raw = require_raw2();
    var QueryBuilder = require_querybuilder();
    var JoinClause = require_joinclause();
    var debug = require_src3();
    var assign = require_assign();
    var compact = require_compact();
    var groupBy = require_groupBy();
    var has = require_has();
    var isEmpty = require_isEmpty();
    var map3 = require_map();
    var omitBy = require_omitBy();
    var reduce = require_reduce();
    var { nanoid: nanoid4 } = require_nanoid();
    var { isString: isString2, isUndefined: isUndefined2 } = require_is();
    var {
      columnize: columnize_,
      direction: direction_,
      operator: operator_,
      wrap: wrap_,
      unwrapRaw: unwrapRaw_,
      rawOrFn: rawOrFn_
    } = require_wrappingFormatter();
    var debugBindings = debug("knex:bindings");
    var components = [
      "comments",
      "columns",
      "join",
      "where",
      "union",
      "group",
      "having",
      "order",
      "limit",
      "offset",
      "lock",
      "waitMode"
    ];
    var methodAliases = {
      del: "delete",
      first: "select",
      pluck: "select"
    };
    var invalidClauses = {
      delete: ["having", "limit"],
      truncate: ["where", "having", "limit"]
    };
    var QueryCompiler = class {
      constructor(client, builder, bindings) {
        this.client = client;
        this.method = builder._method || "select";
        this.options = builder._options;
        this.single = builder._single;
        this.queryComments = builder._comments;
        this.timeout = builder._timeout || false;
        this.cancelOnTimeout = builder._cancelOnTimeout || false;
        this.grouped = groupBy(builder._statements, "grouping");
        this.formatter = client.formatter(builder);
        this._emptyInsertValue = "default values";
        this.first = this.select;
        this.bindings = bindings || [];
        this.formatter.bindings = this.bindings;
        this.bindingsHolder = this;
        this.builder = this.formatter.builder;
      }
      // Categorically refuse to execute certain queries that have defined certain clause groups
      // For example, if a "having" clause is defined but we're executing a "delete" query, that
      // is never valid in any of the supported dialects.
      _preValidate() {
        const method = this.method;
        const verb = hasOwn(methodAliases, method) ? methodAliases[method] : method;
        if (!hasOwn(invalidClauses, verb)) return;
        const invalid = invalidClauses[verb];
        for (let i = 0; i < invalid.length; i++) {
          const clause = invalid[i];
          const hasNonEmptyGrouped = hasOwn(this.grouped, clause) && this.grouped[clause].length > 0;
          const hasNonEmptySingle = hasOwn(this.single, clause) && this.single[clause] != null;
          if (hasNonEmptyGrouped || hasNonEmptySingle) {
            throw new Error(
              `Aborted query compilation: \`${clause}\` has no effect on a \`${verb}\` statement`
            );
          }
        }
      }
      // Collapse the builder into a single object
      toSQL(method, tz) {
        this._preValidate();
        this._undefinedInWhereClause = false;
        this.undefinedBindingsInfo = [];
        method = method || this.method;
        const val = this[method]() || "";
        const query = {
          method,
          options: reduce(this.options, assign, {}),
          timeout: this.timeout,
          cancelOnTimeout: this.cancelOnTimeout,
          bindings: this.bindingsHolder.bindings || [],
          __knexQueryUid: nanoid4()
        };
        Object.defineProperties(query, {
          toNative: {
            value: () => {
              return {
                sql: this.client.positionBindings(query.sql),
                bindings: this.client.prepBindings(query.bindings)
              };
            },
            enumerable: false
          }
        });
        if (isString2(val)) {
          query.sql = val;
        } else {
          assign(query, val);
        }
        if (method === "select" || method === "first") {
          if (this.single.as) {
            query.as = this.single.as;
          }
        }
        if (this._undefinedInWhereClause) {
          debugBindings(query.bindings);
          throw new Error(
            `Undefined binding(s) detected when compiling ${method.toUpperCase()}. Undefined column(s): [${this.undefinedBindingsInfo.join(
              ", "
            )}] query: ${query.sql}`
          );
        }
        return query;
      }
      // Compiles the `select` statement, or nested sub-selects by calling each of
      // the component compilers, trimming out the empties, and returning a
      // generated query string.
      select() {
        let sql = this.with();
        let unionStatement = "";
        const firstStatements = [];
        const endStatements = [];
        components.forEach((component) => {
          const statement = this[component](this);
          switch (component) {
            case "union":
              unionStatement = statement;
              break;
            case "comments":
            case "columns":
            case "join":
            case "where":
              firstStatements.push(statement);
              break;
            default:
              endStatements.push(statement);
              break;
          }
        });
        const wrapMainQuery = this.grouped.union && this.grouped.union.map((u) => u.wrap).some((u) => u);
        if (this.onlyUnions()) {
          const statements = compact(firstStatements.concat(endStatements)).join(
            " "
          );
          sql += unionStatement + (statements ? " " + statements : "");
        } else {
          const allStatements = (wrapMainQuery ? "(" : "") + compact(firstStatements).join(" ") + (wrapMainQuery ? ")" : "");
          const endStat = compact(endStatements).join(" ");
          sql += allStatements + (unionStatement ? " " + unionStatement : "") + (endStat ? " " + endStat : endStat);
        }
        return sql;
      }
      pluck() {
        let toPluck = this.single.pluck;
        if (toPluck.indexOf(".") !== -1) {
          toPluck = toPluck.split(".").slice(-1)[0];
        }
        return {
          sql: this.select(),
          pluck: toPluck
        };
      }
      // Compiles an "insert" query, allowing for multiple
      // inserts using a single query statement.
      insert() {
        const insertValues = this.single.insert || [];
        const sql = this.with() + `insert into ${this.tableName} `;
        const body = this._insertBody(insertValues);
        return body === "" ? "" : sql + body;
      }
      _onConflictClause(columns) {
        return columns instanceof Raw ? this.formatter.wrap(columns) : `(${this.formatter.columnize(columns)})`;
      }
      _buildInsertValues(insertData) {
        let sql = "";
        let i = -1;
        while (++i < insertData.values.length) {
          if (i !== 0) sql += "), (";
          sql += this.client.parameterize(
            insertData.values[i],
            this.client.valueForUndefined,
            this.builder,
            this.bindingsHolder
          );
        }
        return sql;
      }
      _insertBody(insertValues) {
        let sql = "";
        if (Array.isArray(insertValues)) {
          if (insertValues.length === 0) {
            return "";
          }
        } else if (typeof insertValues === "object" && isEmpty(insertValues)) {
          return sql + this._emptyInsertValue;
        }
        const insertData = this._prepInsert(insertValues);
        if (typeof insertData === "string") {
          sql += insertData;
        } else {
          if (insertData.columns.length) {
            sql += `(${columnize_(
              insertData.columns,
              this.builder,
              this.client,
              this.bindingsHolder
            )}`;
            sql += ") values (" + this._buildInsertValues(insertData) + ")";
          } else if (insertValues.length === 1 && insertValues[0]) {
            sql += this._emptyInsertValue;
          } else {
            sql = "";
          }
        }
        return sql;
      }
      // Compiles the "update" query.
      update() {
        const withSQL = this.with();
        const { tableName } = this;
        const updateData = this._prepUpdate(this.single.update);
        const wheres = this.where();
        return withSQL + `update ${this.single.only ? "only " : ""}${tableName} set ` + updateData.join(", ") + (wheres ? ` ${wheres}` : "");
      }
      _hintComments() {
        let hints = this.grouped.hintComments || [];
        hints = hints.map((hint) => compact(hint.value).join(" "));
        hints = compact(hints).join(" ");
        return hints ? `/*+ ${hints} */ ` : "";
      }
      // Compiles the columns in the query, specifying if an item was distinct.
      columns() {
        let distinctClause = "";
        if (this.onlyUnions()) return "";
        const hints = this._hintComments();
        const columns = this.grouped.columns || [];
        let i = -1, sql = [];
        if (columns) {
          while (++i < columns.length) {
            const stmt = columns[i];
            if (stmt.distinct) distinctClause = "distinct ";
            if (stmt.distinctOn) {
              distinctClause = this.distinctOn(stmt.value);
              continue;
            }
            if (stmt.type === "aggregate") {
              sql.push(...this.aggregate(stmt));
            } else if (stmt.type === "aggregateRaw") {
              sql.push(this.aggregateRaw(stmt));
            } else if (stmt.type === "analytic") {
              sql.push(this.analytic(stmt));
            } else if (stmt.type === "json") {
              sql.push(this.json(stmt));
            } else if (stmt.value && stmt.value.length > 0) {
              sql.push(
                columnize_(
                  stmt.value,
                  this.builder,
                  this.client,
                  this.bindingsHolder
                )
              );
            }
          }
        }
        if (sql.length === 0) sql = ["*"];
        const select = this.onlyJson() ? "" : "select ";
        return `${select}${hints}${distinctClause}` + sql.join(", ") + (this.tableName ? ` from ${this.single.only ? "only " : ""}${this.tableName}` : "");
      }
      // Add comments to the query
      comments() {
        if (!this.queryComments.length) return "";
        return this.queryComments.map((comment) => `/* ${comment.comment} */`).join(" ");
      }
      _aggregate(stmt, { aliasSeparator = " as ", distinctParentheses } = {}) {
        const value = stmt.value;
        const method = stmt.method;
        const distinct = stmt.aggregateDistinct ? "distinct " : "";
        const wrap = (identifier) => wrap_(
          identifier,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        );
        const addAlias = (value2, alias2) => {
          if (alias2) {
            return value2 + aliasSeparator + wrap(alias2);
          }
          return value2;
        };
        const aggregateArray = (value2, alias2) => {
          let columns = value2.map(wrap).join(", ");
          if (distinct) {
            const openParen = distinctParentheses ? "(" : " ";
            const closeParen = distinctParentheses ? ")" : "";
            columns = distinct.trim() + openParen + columns + closeParen;
          }
          const aggregated = `${method}(${columns})`;
          return addAlias(aggregated, alias2);
        };
        const aggregateString = (value2, alias2) => {
          const aggregated = `${method}(${distinct + wrap(value2)})`;
          return addAlias(aggregated, alias2);
        };
        if (Array.isArray(value)) {
          return [aggregateArray(value)];
        }
        if (typeof value === "object") {
          if (stmt.alias) {
            throw new Error("When using an object explicit alias can not be used");
          }
          return Object.entries(value).map(([alias2, column2]) => {
            if (Array.isArray(column2)) {
              return aggregateArray(column2, alias2);
            }
            return aggregateString(column2, alias2);
          });
        }
        const splitOn = value.toLowerCase().indexOf(" as ");
        let column = value;
        let { alias } = stmt;
        if (splitOn !== -1) {
          column = value.slice(0, splitOn);
          if (alias) {
            throw new Error(`Found multiple aliases for same column: ${column}`);
          }
          alias = value.slice(splitOn + 4);
        }
        return [aggregateString(column, alias)];
      }
      aggregate(stmt) {
        return this._aggregate(stmt);
      }
      aggregateRaw(stmt) {
        const distinct = stmt.aggregateDistinct ? "distinct " : "";
        return `${stmt.method}(${distinct + unwrapRaw_(
          stmt.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        )})`;
      }
      _joinTable(join2) {
        return join2.schema && !(join2.table instanceof Raw) ? `${join2.schema}.${join2.table}` : join2.table;
      }
      // Compiles all each of the `join` clauses on the query,
      // including any nested join queries.
      join() {
        let sql = "";
        let i = -1;
        const joins = this.grouped.join;
        if (!joins) return "";
        while (++i < joins.length) {
          const join2 = joins[i];
          const table = this._joinTable(join2);
          if (i > 0) sql += " ";
          if (join2.joinType === "raw") {
            sql += unwrapRaw_(
              join2.table,
              void 0,
              this.builder,
              this.client,
              this.bindingsHolder
            );
          } else {
            sql += join2.joinType + " join " + wrap_(
              table,
              void 0,
              this.builder,
              this.client,
              this.bindingsHolder
            );
            let ii = -1;
            while (++ii < join2.clauses.length) {
              const clause = join2.clauses[ii];
              if (ii > 0) {
                sql += ` ${clause.bool} `;
              } else {
                sql += ` ${clause.type === "onUsing" ? "using" : "on"} `;
              }
              const val = this[clause.type](clause);
              if (val) {
                sql += val;
              }
            }
          }
        }
        return sql;
      }
      onBetween(statement) {
        return wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + this._not(statement, "between") + " " + statement.value.map(
          (value) => this.client.parameter(value, this.builder, this.bindingsHolder)
        ).join(" and ");
      }
      onNull(statement) {
        return wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " is " + this._not(statement, "null");
      }
      onExists(statement) {
        return this._not(statement, "exists") + " (" + rawOrFn_(
          statement.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + ")";
      }
      onIn(statement) {
        if (Array.isArray(statement.column)) return this.multiOnIn(statement);
        let values;
        if (statement.value instanceof Raw) {
          values = this.client.parameter(
            statement.value,
            this.builder,
            this.formatter
          );
        } else {
          values = this.client.parameterize(
            statement.value,
            void 0,
            this.builder,
            this.bindingsHolder
          );
        }
        return wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + this._not(statement, "in ") + this.wrap(values);
      }
      multiOnIn(statement) {
        let i = -1, sql = `(${columnize_(
          statement.column,
          this.builder,
          this.client,
          this.bindingsHolder
        )}) `;
        sql += this._not(statement, "in ") + "((";
        while (++i < statement.value.length) {
          if (i !== 0) sql += "),(";
          sql += this.client.parameterize(
            statement.value[i],
            void 0,
            this.builder,
            this.bindingsHolder
          );
        }
        return sql + "))";
      }
      // Compiles all `where` statements on the query.
      where() {
        const wheres = this.grouped.where;
        if (!wheres) return;
        const sql = [];
        let i = -1;
        while (++i < wheres.length) {
          const stmt = wheres[i];
          if (Object.prototype.hasOwnProperty.call(stmt, "value") && helpers.containsUndefined(stmt.value)) {
            this.undefinedBindingsInfo.push(stmt.column);
            this._undefinedInWhereClause = true;
          }
          const val = this[stmt.type](stmt);
          if (val) {
            if (sql.length === 0) {
              sql[0] = "where";
            } else {
              sql.push(stmt.bool);
            }
            sql.push(val);
          }
        }
        return sql.length > 1 ? sql.join(" ") : "";
      }
      group() {
        return this._groupsOrders("group");
      }
      order() {
        return this._groupsOrders("order");
      }
      // Compiles the `having` statements.
      having() {
        const havings = this.grouped.having;
        if (!havings) return "";
        const sql = ["having"];
        for (let i = 0, l = havings.length; i < l; i++) {
          const s = havings[i];
          const val = this[s.type](s);
          if (val) {
            if (sql.length === 0) {
              sql[0] = "where";
            }
            if (sql.length > 1 || sql.length === 1 && sql[0] !== "having") {
              sql.push(s.bool);
            }
            sql.push(val);
          }
        }
        return sql.length > 1 ? sql.join(" ") : "";
      }
      havingRaw(statement) {
        return this._not(statement, "") + unwrapRaw_(
          statement.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        );
      }
      havingWrapped(statement) {
        const val = rawOrFn_(
          statement.value,
          "where",
          this.builder,
          this.client,
          this.bindingsHolder
        );
        return val && this._not(statement, "") + "(" + val.slice(6) + ")" || "";
      }
      havingBasic(statement) {
        return this._not(statement, "") + wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + operator_(
          statement.operator,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + this.client.parameter(statement.value, this.builder, this.bindingsHolder);
      }
      havingNull(statement) {
        return wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " is " + this._not(statement, "null");
      }
      havingExists(statement) {
        return this._not(statement, "exists") + " (" + rawOrFn_(
          statement.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + ")";
      }
      havingBetween(statement) {
        return wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + this._not(statement, "between") + " " + statement.value.map(
          (value) => this.client.parameter(value, this.builder, this.bindingsHolder)
        ).join(" and ");
      }
      havingIn(statement) {
        if (Array.isArray(statement.column)) return this.multiHavingIn(statement);
        return wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + this._not(statement, "in ") + this.wrap(
          this.client.parameterize(
            statement.value,
            void 0,
            this.builder,
            this.bindingsHolder
          )
        );
      }
      multiHavingIn(statement) {
        return this.multiOnIn(statement);
      }
      // Compile the "union" queries attached to the main query.
      union() {
        const onlyUnions = this.onlyUnions();
        const unions = this.grouped.union;
        if (!unions) return "";
        let sql = "";
        for (let i = 0, l = unions.length; i < l; i++) {
          const union3 = unions[i];
          if (i > 0) sql += " ";
          if (i > 0 || !onlyUnions) sql += union3.clause + " ";
          const statement = rawOrFn_(
            union3.value,
            void 0,
            this.builder,
            this.client,
            this.bindingsHolder
          );
          if (statement) {
            const wrap = union3.wrap;
            if (wrap) sql += "(";
            sql += statement;
            if (wrap) sql += ")";
          }
        }
        return sql;
      }
      // If we haven't specified any columns or a `tableName`, we're assuming this
      // is only being used for unions.
      onlyUnions() {
        return (!this.grouped.columns || !!this.grouped.columns[0].value) && this.grouped.union && !this.tableName;
      }
      _getValueOrParameterFromAttribute(attribute, rawValue) {
        if (this.single.skipBinding[attribute] === true) {
          return rawValue !== void 0 && rawValue !== null ? rawValue : this.single[attribute];
        }
        return this.client.parameter(
          this.single[attribute],
          this.builder,
          this.bindingsHolder
        );
      }
      onlyJson() {
        return !this.tableName && this.grouped.columns && this.grouped.columns.length === 1 && this.grouped.columns[0].type === "json";
      }
      limit() {
        const noLimit = !this.single.limit && this.single.limit !== 0;
        if (noLimit) return "";
        return `limit ${this._getValueOrParameterFromAttribute("limit")}`;
      }
      offset() {
        if (!this.single.offset) return "";
        return `offset ${this._getValueOrParameterFromAttribute("offset")}`;
      }
      // Compiles a `delete` query.
      del() {
        const { tableName } = this;
        const withSQL = this.with();
        const joins = this.join();
        const wheres = this.where();
        const deleteSelector = joins ? tableName + " " : "";
        return withSQL + `delete ${deleteSelector}from ${this.single.only ? "only " : ""}${tableName}` + (joins ? ` ${joins}` : "") + (wheres ? ` ${wheres}` : "");
      }
      // Compiles a `truncate` query.
      truncate() {
        return `truncate ${this.tableName}`;
      }
      // Compiles the "locks".
      lock() {
        if (this.single.lock) {
          return this[this.single.lock]();
        }
      }
      // Compiles the wait mode on the locks.
      waitMode() {
        if (this.single.waitMode) {
          return this[this.single.waitMode]();
        }
      }
      // Fail on unsupported databases
      skipLocked() {
        throw new Error(
          ".skipLocked() is currently only supported on MySQL 8.0+ and PostgreSQL 9.5+"
        );
      }
      // Fail on unsupported databases
      noWait() {
        throw new Error(
          ".noWait() is currently only supported on MySQL 8.0+, MariaDB 10.3.0+ and PostgreSQL 9.5+"
        );
      }
      distinctOn(value) {
        throw new Error(".distinctOn() is currently only supported on PostgreSQL");
      }
      // On Clause
      // ------
      onWrapped(clause) {
        const self2 = this;
        const wrapJoin = new JoinClause();
        clause.value.call(wrapJoin, wrapJoin);
        let sql = "";
        for (let ii = 0; ii < wrapJoin.clauses.length; ii++) {
          const wrapClause = wrapJoin.clauses[ii];
          if (ii > 0) {
            sql += ` ${wrapClause.bool} `;
          }
          const val = self2[wrapClause.type](wrapClause);
          if (val) {
            sql += val;
          }
        }
        if (sql.length) {
          return `(${sql})`;
        }
        return "";
      }
      onBasic(clause) {
        const toWrap = clause.value instanceof QueryBuilder;
        return wrap_(
          clause.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + operator_(
          clause.operator,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + (toWrap ? "(" : "") + wrap_(
          clause.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + (toWrap ? ")" : "");
      }
      onVal(clause) {
        return wrap_(
          clause.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + operator_(
          clause.operator,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + this.client.parameter(clause.value, this.builder, this.bindingsHolder);
      }
      onRaw(clause) {
        return unwrapRaw_(
          clause.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        );
      }
      onUsing(clause) {
        return "(" + columnize_(
          clause.column,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + ")";
      }
      // Where Clause
      // ------
      _valueClause(statement) {
        return statement.asColumn ? wrap_(
          statement.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) : this.client.parameter(
          statement.value,
          this.builder,
          this.bindingsHolder
        );
      }
      _columnClause(statement) {
        let columns;
        if (Array.isArray(statement.column)) {
          columns = `(${columnize_(
            statement.column,
            this.builder,
            this.client,
            this.bindingsHolder
          )})`;
        } else {
          columns = wrap_(
            statement.column,
            void 0,
            this.builder,
            this.client,
            this.bindingsHolder
          );
        }
        return columns;
      }
      whereIn(statement) {
        const columns = this._columnClause(statement);
        const values = this.client.values(
          statement.value,
          this.builder,
          this.bindingsHolder
        );
        return `${columns} ${this._not(statement, "in ")}${values}`;
      }
      whereLike(statement) {
        return `${this._columnClause(statement)} ${this._not(
          statement,
          "like "
        )}${this._valueClause(statement)}`;
      }
      whereILike(statement) {
        return `${this._columnClause(statement)} ${this._not(
          statement,
          "ilike "
        )}${this._valueClause(statement)}`;
      }
      whereNull(statement) {
        return wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " is " + this._not(statement, "null");
      }
      // Compiles a basic "where" clause.
      whereBasic(statement) {
        return this._not(statement, "") + wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + operator_(
          statement.operator,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + this._valueClause(statement);
      }
      whereExists(statement) {
        return this._not(statement, "exists") + " (" + rawOrFn_(
          statement.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + ")";
      }
      whereWrapped(statement) {
        const val = rawOrFn_(
          statement.value,
          "where",
          this.builder,
          this.client,
          this.bindingsHolder
        );
        return val && this._not(statement, "") + "(" + val.slice(6) + ")" || "";
      }
      whereBetween(statement) {
        return wrap_(
          statement.column,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + " " + this._not(statement, "between") + " " + statement.value.map(
          (value) => this.client.parameter(value, this.builder, this.bindingsHolder)
        ).join(" and ");
      }
      // Compiles a "whereRaw" query.
      whereRaw(statement) {
        return this._not(statement, "") + unwrapRaw_(
          statement.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        );
      }
      _jsonWrapValue(jsonValue) {
        if (!this.builder._isJsonObject(jsonValue)) {
          try {
            return JSON.stringify(JSON.parse(jsonValue.replace(/\n|\t/g, "")));
          } catch (e) {
            return jsonValue;
          }
        }
        return JSON.stringify(jsonValue);
      }
      _jsonValueClause(statement) {
        statement.value = this._jsonWrapValue(statement.value);
        return this._valueClause(statement);
      }
      whereJsonObject(statement) {
        return `${this._columnClause(statement)} ${statement.not ? "!=" : "="} ${this._jsonValueClause(statement)}`;
      }
      wrap(str) {
        if (str.charAt(0) !== "(") return `(${str})`;
        return str;
      }
      json(stmt) {
        return this[stmt.method](stmt.params);
      }
      analytic(stmt) {
        let sql = "";
        const self2 = this;
        sql += stmt.method + "() over (";
        if (stmt.raw) {
          sql += stmt.raw;
        } else {
          if (stmt.partitions.length) {
            sql += "partition by ";
            sql += map3(stmt.partitions, function(partition) {
              if (isString2(partition)) {
                return self2.formatter.columnize(partition);
              } else return self2.formatter.columnize(partition.column) + (partition.order ? " " + partition.order : "");
            }).join(", ") + " ";
          }
          sql += "order by ";
          sql += map3(stmt.order, function(order) {
            if (isString2(order)) {
              return self2.formatter.columnize(order);
            } else return self2.formatter.columnize(order.column) + (order.order ? " " + order.order : "");
          }).join(", ");
        }
        sql += ")";
        if (stmt.alias) {
          sql += " as " + stmt.alias;
        }
        return sql;
      }
      // Compiles all `with` statements on the query.
      with() {
        if (!this.grouped.with || !this.grouped.with.length) {
          return "";
        }
        const withs = this.grouped.with;
        if (!withs) return;
        const sql = [];
        let i = -1;
        let isRecursive = false;
        while (++i < withs.length) {
          const stmt = withs[i];
          if (stmt.recursive) {
            isRecursive = true;
          }
          const val = this[stmt.type](stmt);
          sql.push(val);
        }
        return `with ${isRecursive ? "recursive " : ""}${sql.join(", ")} `;
      }
      withWrapped(statement) {
        const val = rawOrFn_(
          statement.value,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        );
        const columnList = statement.columnList ? "(" + columnize_(
          statement.columnList,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + ")" : "";
        const materialized = statement.materialized === void 0 ? "" : statement.materialized ? "materialized " : "not materialized ";
        return val && columnize_(
          statement.alias,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + columnList + " as " + materialized + "(" + val + ")" || "";
      }
      // Determines whether to add a "not" prefix to the where clause.
      _not(statement, str) {
        if (statement.not) return `not ${str}`;
        return str;
      }
      _prepInsert(data) {
        const isRaw = rawOrFn_(
          data,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        );
        if (isRaw) return isRaw;
        let columns = [];
        const values = [];
        if (!Array.isArray(data)) data = data ? [data] : [];
        let i = -1;
        while (++i < data.length) {
          if (data[i] == null) break;
          if (i === 0) columns = Object.keys(data[i]).sort();
          const row = new Array(columns.length);
          const keys2 = Object.keys(data[i]);
          let j = -1;
          while (++j < keys2.length) {
            const key = keys2[j];
            let idx = columns.indexOf(key);
            if (idx === -1) {
              columns = columns.concat(key).sort();
              idx = columns.indexOf(key);
              let k = -1;
              while (++k < values.length) {
                values[k].splice(idx, 0, void 0);
              }
              row.splice(idx, 0, void 0);
            }
            row[idx] = data[i][key];
          }
          values.push(row);
        }
        return {
          columns,
          values
        };
      }
      // "Preps" the update.
      _prepUpdate(data = {}) {
        const { counter = {} } = this.single;
        for (const column of Object.keys(counter)) {
          if (has(data, column)) {
            this.client.logger.warn(
              `increment/decrement called for a column that has already been specified in main .update() call. Ignoring increment/decrement and using value from .update() call.`
            );
            continue;
          }
          let value = counter[column];
          const symbol30 = value < 0 ? "-" : "+";
          if (symbol30 === "-") {
            value = -value;
          }
          data[column] = this.client.raw(`?? ${symbol30} ?`, [column, value]);
        }
        data = omitBy(data, isUndefined2);
        const vals = [];
        const columns = Object.keys(data);
        let i = -1;
        while (++i < columns.length) {
          vals.push(
            wrap_(
              columns[i],
              void 0,
              this.builder,
              this.client,
              this.bindingsHolder
            ) + " = " + this.client.parameter(
              data[columns[i]],
              this.builder,
              this.bindingsHolder
            )
          );
        }
        if (isEmpty(vals)) {
          throw new Error(
            [
              "Empty .update() call detected!",
              "Update data does not contain any values to update.",
              "This will result in a faulty query.",
              this.single.table ? `Table: ${this.single.table}.` : "",
              this.single.update ? `Columns: ${Object.keys(this.single.update)}.` : ""
            ].join(" ")
          );
        }
        return vals;
      }
      _formatGroupsItemValue(value, nulls) {
        const { formatter } = this;
        let nullOrder = "";
        if (nulls === "last") {
          nullOrder = " is null";
        } else if (nulls === "first") {
          nullOrder = " is not null";
        }
        let groupOrder;
        if (value instanceof Raw) {
          groupOrder = unwrapRaw_(
            value,
            void 0,
            this.builder,
            this.client,
            this.bindingsHolder
          );
        } else if (value instanceof QueryBuilder || nulls) {
          groupOrder = "(" + formatter.columnize(value) + nullOrder + ")";
        } else {
          groupOrder = formatter.columnize(value);
        }
        return groupOrder;
      }
      _basicGroupOrder(item, type) {
        const column = this._formatGroupsItemValue(item.value, item.nulls);
        const direction = type === "order" && item.type !== "orderByRaw" ? ` ${direction_(
          item.direction,
          this.builder,
          this.client,
          this.bindingsHolder
        )}` : "";
        return column + direction;
      }
      _groupOrder(item, type) {
        return this._basicGroupOrder(item, type);
      }
      _groupOrderNulls(item, type) {
        const column = this._formatGroupsItemValue(item.value);
        const direction = type === "order" && item.type !== "orderByRaw" ? ` ${direction_(
          item.direction,
          this.builder,
          this.client,
          this.bindingsHolder
        )}` : "";
        if (item.nulls && !(item.value instanceof Raw)) {
          return `${column}${direction ? direction : ""} nulls ${item.nulls}`;
        }
        return column + direction;
      }
      // Compiles the `order by` statements.
      _groupsOrders(type) {
        const items = this.grouped[type];
        if (!items) return "";
        const sql = items.map((item) => {
          return this._groupOrder(item, type);
        });
        return sql.length ? type + " by " + sql.join(", ") : "";
      }
      // Get the table name, wrapping it if necessary.
      // Implemented as a property to prevent ordering issues as described in #704.
      get tableName() {
        if (!this._tableName) {
          let tableName = this.single.table;
          const schemaName = this.single.schema;
          if (tableName && schemaName) {
            const isQueryBuilder = tableName instanceof QueryBuilder;
            const isRawQuery = tableName instanceof Raw;
            const isFunction4 = typeof tableName === "function";
            if (!isQueryBuilder && !isRawQuery && !isFunction4) {
              tableName = `${schemaName}.${tableName}`;
            }
          }
          this._tableName = tableName ? (
            // Wrap subQuery with parenthesis, #3485
            wrap_(
              tableName,
              tableName instanceof QueryBuilder,
              this.builder,
              this.client,
              this.bindingsHolder
            )
          ) : "";
        }
        return this._tableName;
      }
      _jsonPathWrap(extraction) {
        return this.client.parameter(
          extraction.path || extraction[1],
          this.builder,
          this.bindingsHolder
        );
      }
      // Json common functions
      _jsonExtract(nameFunction, params) {
        let extractions;
        if (Array.isArray(params.column)) {
          extractions = params.column;
        } else {
          extractions = [params];
        }
        if (!Array.isArray(nameFunction)) {
          nameFunction = [nameFunction];
        }
        return extractions.map((extraction) => {
          let jsonCol = `${columnize_(
            extraction.column || extraction[0],
            this.builder,
            this.client,
            this.bindingsHolder
          )}, ${this._jsonPathWrap(extraction)}`;
          nameFunction.forEach((f) => {
            jsonCol = f + "(" + jsonCol + ")";
          });
          const alias = extraction.alias || extraction[2];
          return alias ? this.client.alias(jsonCol, this.formatter.wrap(alias)) : jsonCol;
        }).join(", ");
      }
      _jsonSet(nameFunction, params) {
        const jsonSet = `${nameFunction}(${columnize_(
          params.column,
          this.builder,
          this.client,
          this.bindingsHolder
        )}, ${this.client.parameter(
          params.path,
          this.builder,
          this.bindingsHolder
        )}, ${this.client.parameter(
          params.value,
          this.builder,
          this.bindingsHolder
        )})`;
        return params.alias ? this.client.alias(jsonSet, this.formatter.wrap(params.alias)) : jsonSet;
      }
      _whereJsonPath(nameFunction, statement) {
        return `${nameFunction}(${this._columnClause(
          statement
        )}, ${this._jsonPathWrap({ path: statement.jsonPath })}) ${operator_(
          statement.operator,
          this.builder,
          this.client,
          this.bindingsHolder
        )} ${this._jsonValueClause(statement)}`;
      }
      _onJsonPathEquals(nameJoinFunction, clause) {
        return nameJoinFunction + "(" + wrap_(
          clause.columnFirst,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + ", " + this.client.parameter(
          clause.jsonPathFirst,
          this.builder,
          this.bindingsHolder
        ) + ") = " + nameJoinFunction + "(" + wrap_(
          clause.columnSecond,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + ", " + this.client.parameter(
          clause.jsonPathSecond,
          this.builder,
          this.bindingsHolder
        ) + ")";
      }
    };
    module2.exports = QueryCompiler;
  }
});

// node_modules/knex/lib/schema/builder.js
var require_builder = __commonJS({
  "node_modules/knex/lib/schema/builder.js"(exports2, module2) {
    "use strict";
    var { EventEmitter: EventEmitter3 } = require("events");
    var toArray2 = require_toArray();
    var assign = require_assign();
    var { addQueryContext } = require_helpers();
    var saveAsyncStack = require_save_async_stack();
    var {
      augmentWithBuilderInterface
    } = require_builder_interface_augmenter();
    var SchemaBuilder = class extends EventEmitter3 {
      constructor(client) {
        super();
        this.client = client;
        this._sequence = [];
        if (client.config) {
          this._debug = client.config.debug;
          saveAsyncStack(this, 4);
        }
      }
      withSchema(schemaName) {
        this._schema = schemaName;
        return this;
      }
      toString() {
        return this.toQuery();
      }
      toSQL() {
        return this.client.schemaCompiler(this).toSQL();
      }
      async generateDdlCommands() {
        return await this.client.schemaCompiler(this).generateDdlCommands();
      }
    };
    [
      "createTable",
      "createTableIfNotExists",
      "createTableLike",
      "createView",
      "createViewOrReplace",
      "createMaterializedView",
      "refreshMaterializedView",
      "dropView",
      "dropViewIfExists",
      "dropMaterializedView",
      "dropMaterializedViewIfExists",
      "createSchema",
      "createSchemaIfNotExists",
      "dropSchema",
      "dropSchemaIfExists",
      "createExtension",
      "createExtensionIfNotExists",
      "dropExtension",
      "dropExtensionIfExists",
      "table",
      "alterTable",
      "view",
      "alterView",
      "hasTable",
      "hasColumn",
      "dropTable",
      "renameTable",
      "renameView",
      "dropTableIfExists",
      "raw"
    ].forEach(function(method) {
      SchemaBuilder.prototype[method] = function() {
        if (method === "createTableIfNotExists") {
          this.client.logger.warn(
            [
              "Use async .hasTable to check if table exists and then use plain .createTable. Since ",
              '.createTableIfNotExists actually just generates plain "CREATE TABLE IF NOT EXIST..." ',
              "query it will not work correctly if there are any alter table queries generated for ",
              "columns afterwards. To not break old migrations this function is left untouched for now",
              ", but it should not be used when writing new code and it is removed from documentation."
            ].join("")
          );
        }
        if (method === "table") method = "alterTable";
        if (method === "view") method = "alterView";
        this._sequence.push({
          method,
          args: toArray2(arguments)
        });
        return this;
      };
    });
    SchemaBuilder.extend = (methodName, fn) => {
      if (Object.prototype.hasOwnProperty.call(SchemaBuilder.prototype, methodName)) {
        throw new Error(
          `Can't extend SchemaBuilder with existing method ('${methodName}').`
        );
      }
      assign(SchemaBuilder.prototype, { [methodName]: fn });
    };
    augmentWithBuilderInterface(SchemaBuilder);
    addQueryContext(SchemaBuilder);
    module2.exports = SchemaBuilder;
  }
});

// node_modules/knex/lib/schema/internal/helpers.js
var require_helpers2 = __commonJS({
  "node_modules/knex/lib/schema/internal/helpers.js"(exports2, module2) {
    "use strict";
    var tail = require_tail();
    var { isString: isString2 } = require_is();
    function pushQuery(query) {
      if (!query) return;
      if (isString2(query)) {
        query = { sql: query };
      }
      if (!query.bindings) {
        query.bindings = this.bindingsHolder.bindings;
      }
      this.sequence.push(query);
      this.formatter = this.client.formatter(this._commonBuilder);
      this.bindings = [];
      this.formatter.bindings = this.bindings;
    }
    function pushAdditional(fn) {
      const child = new this.constructor(
        this.client,
        this.tableCompiler,
        this.columnBuilder
      );
      fn.call(child, tail(arguments));
      this.sequence.additional = (this.sequence.additional || []).concat(
        child.sequence
      );
    }
    function unshiftQuery(query) {
      if (!query) return;
      if (isString2(query)) {
        query = { sql: query };
      }
      if (!query.bindings) {
        query.bindings = this.bindingsHolder.bindings;
      }
      this.sequence.unshift(query);
      this.formatter = this.client.formatter(this._commonBuilder);
      this.bindings = [];
      this.formatter.bindings = this.bindings;
    }
    module2.exports = {
      pushAdditional,
      pushQuery,
      unshiftQuery
    };
  }
});

// node_modules/knex/lib/schema/compiler.js
var require_compiler = __commonJS({
  "node_modules/knex/lib/schema/compiler.js"(exports2, module2) {
    "use strict";
    var {
      pushQuery,
      pushAdditional,
      unshiftQuery
    } = require_helpers2();
    var SchemaCompiler = class {
      constructor(client, builder) {
        this.builder = builder;
        this._commonBuilder = this.builder;
        this.client = client;
        this.schema = builder._schema;
        this.bindings = [];
        this.bindingsHolder = this;
        this.formatter = client.formatter(builder);
        this.formatter.bindings = this.bindings;
        this.sequence = [];
      }
      createSchema() {
        throwOnlyPGError("createSchema");
      }
      createSchemaIfNotExists() {
        throwOnlyPGError("createSchemaIfNotExists");
      }
      dropSchema() {
        throwOnlyPGError("dropSchema");
      }
      dropSchemaIfExists() {
        throwOnlyPGError("dropSchemaIfExists");
      }
      dropTable(tableName) {
        this.pushQuery(
          this.dropTablePrefix + this.formatter.wrap(prefixedTableName(this.schema, tableName))
        );
      }
      dropTableIfExists(tableName) {
        this.pushQuery(
          this.dropTablePrefix + "if exists " + this.formatter.wrap(prefixedTableName(this.schema, tableName))
        );
      }
      dropView(viewName) {
        this._dropView(viewName, false, false);
      }
      dropViewIfExists(viewName) {
        this._dropView(viewName, true, false);
      }
      dropMaterializedView(viewName) {
        throw new Error("materialized views are not supported by this dialect.");
      }
      dropMaterializedViewIfExists(viewName) {
        throw new Error("materialized views are not supported by this dialect.");
      }
      renameView(from, to) {
        throw new Error(
          "rename view is not supported by this dialect (instead drop then create another view)."
        );
      }
      refreshMaterializedView() {
        throw new Error("materialized views are not supported by this dialect.");
      }
      _dropView(viewName, ifExists, materialized) {
        this.pushQuery(
          (materialized ? this.dropMaterializedViewPrefix : this.dropViewPrefix) + (ifExists ? "if exists " : "") + this.formatter.wrap(prefixedTableName(this.schema, viewName))
        );
      }
      raw(sql, bindings) {
        this.sequence.push(this.client.raw(sql, bindings).toSQL());
      }
      toSQL() {
        const sequence = this.builder._sequence;
        for (let i = 0, l = sequence.length; i < l; i++) {
          const query = sequence[i];
          this[query.method].apply(this, query.args);
        }
        return this.sequence;
      }
      async generateDdlCommands() {
        const generatedCommands = this.toSQL();
        return {
          pre: [],
          sql: Array.isArray(generatedCommands) ? generatedCommands : [generatedCommands],
          check: null,
          post: []
        };
      }
    };
    SchemaCompiler.prototype.dropTablePrefix = "drop table ";
    SchemaCompiler.prototype.dropViewPrefix = "drop view ";
    SchemaCompiler.prototype.dropMaterializedViewPrefix = "drop materialized view ";
    SchemaCompiler.prototype.alterViewPrefix = "alter view ";
    SchemaCompiler.prototype.alterTable = buildTable("alter");
    SchemaCompiler.prototype.createTable = buildTable("create");
    SchemaCompiler.prototype.createTableIfNotExists = buildTable("createIfNot");
    SchemaCompiler.prototype.createTableLike = buildTable("createLike");
    SchemaCompiler.prototype.createView = buildView("create");
    SchemaCompiler.prototype.createViewOrReplace = buildView("createOrReplace");
    SchemaCompiler.prototype.createMaterializedView = buildView(
      "createMaterializedView"
    );
    SchemaCompiler.prototype.alterView = buildView("alter");
    SchemaCompiler.prototype.pushQuery = pushQuery;
    SchemaCompiler.prototype.pushAdditional = pushAdditional;
    SchemaCompiler.prototype.unshiftQuery = unshiftQuery;
    function build(builder) {
      const queryContext = this.builder.queryContext();
      if (queryContext !== void 0 && builder.queryContext() === void 0) {
        builder.queryContext(queryContext);
      }
      builder.setSchema(this.schema);
      const sql = builder.toSQL();
      for (let i = 0, l = sql.length; i < l; i++) {
        this.sequence.push(sql[i]);
      }
    }
    function buildTable(type) {
      if (type === "createLike") {
        return function(tableName, tableNameLike, fn) {
          const builder = this.client.tableBuilder(
            type,
            tableName,
            tableNameLike,
            fn
          );
          build.call(this, builder);
        };
      } else {
        return function(tableName, fn) {
          const builder = this.client.tableBuilder(type, tableName, null, fn);
          build.call(this, builder);
        };
      }
    }
    function buildView(type) {
      return function(viewName, fn) {
        const builder = this.client.viewBuilder(type, viewName, fn);
        build.call(this, builder);
      };
    }
    function prefixedTableName(prefix, table) {
      return prefix ? `${prefix}.${table}` : table;
    }
    function throwOnlyPGError(operationName) {
      throw new Error(
        `${operationName} is not supported for this dialect (only PostgreSQL supports it currently).`
      );
    }
    module2.exports = SchemaCompiler;
  }
});

// node_modules/lodash/assignIn.js
var require_assignIn = __commonJS({
  "node_modules/lodash/assignIn.js"(exports2, module2) {
    "use strict";
    var copyObject = require_copyObject();
    var createAssigner = require_createAssigner();
    var keysIn = require_keysIn();
    var assignIn = createAssigner(function(object4, source) {
      copyObject(source, keysIn(source), object4);
    });
    module2.exports = assignIn;
  }
});

// node_modules/lodash/extend.js
var require_extend = __commonJS({
  "node_modules/lodash/extend.js"(exports2, module2) {
    "use strict";
    module2.exports = require_assignIn();
  }
});

// node_modules/knex/lib/schema/tablebuilder.js
var require_tablebuilder = __commonJS({
  "node_modules/knex/lib/schema/tablebuilder.js"(exports2, module2) {
    "use strict";
    var each = require_each();
    var extend4 = require_extend();
    var assign = require_assign();
    var toArray2 = require_toArray();
    var helpers = require_helpers();
    var { isString: isString2, isFunction: isFunction4, isObject: isObject5 } = require_is();
    var TableBuilder = class {
      constructor(client, method, tableName, tableNameLike, fn) {
        this.client = client;
        this._fn = fn;
        this._method = method;
        this._schemaName = void 0;
        this._tableName = tableName;
        this._tableNameLike = tableNameLike;
        this._statements = [];
        this._single = {};
        if (!tableNameLike && !isFunction4(this._fn)) {
          throw new TypeError(
            "A callback function must be supplied to calls against `.createTable` and `.table`"
          );
        }
      }
      setSchema(schemaName) {
        this._schemaName = schemaName;
      }
      // Convert the current tableBuilder object "toSQL"
      // giving us additional methods if we're altering
      // rather than creating the table.
      toSQL() {
        if (this._method === "alter") {
          extend4(this, AlterMethods);
        }
        if (this._fn) {
          this._fn.call(this, this);
        }
        return this.client.tableCompiler(this).toSQL();
      }
      // The "timestamps" call is really just sets the `created_at` and `updated_at` columns.
      timestamps(useTimestamps, defaultToNow, useCamelCase) {
        if (isObject5(useTimestamps)) {
          ({ useTimestamps, defaultToNow, useCamelCase } = useTimestamps);
        }
        const method = useTimestamps === true ? "timestamp" : "datetime";
        const createdAt = this[method](useCamelCase ? "createdAt" : "created_at");
        const updatedAt = this[method](useCamelCase ? "updatedAt" : "updated_at");
        if (defaultToNow === true) {
          const now2 = this.client.raw("CURRENT_TIMESTAMP");
          createdAt.notNullable().defaultTo(now2);
          updatedAt.notNullable().defaultTo(now2);
        }
      }
      // Set the comment value for a table, they're only allowed to be called
      // once per table.
      comment(value) {
        if (typeof value !== "string") {
          throw new TypeError("Table comment must be string");
        }
        this._single.comment = value;
      }
      // Set a foreign key on the table, calling
      // `table.foreign('column_name').references('column').on('table').onDelete()...
      // Also called from the ColumnBuilder context when chaining.
      foreign(column, keyName) {
        const foreignData = { column, keyName };
        this._statements.push({
          grouping: "alterTable",
          method: "foreign",
          args: [foreignData]
        });
        let returnObj = {
          references(tableColumn) {
            let pieces;
            if (isString2(tableColumn)) {
              pieces = tableColumn.split(".");
            }
            if (!pieces || pieces.length === 1) {
              foreignData.references = pieces ? pieces[0] : tableColumn;
              return {
                on(tableName) {
                  if (typeof tableName !== "string") {
                    throw new TypeError(
                      `Expected tableName to be a string, got: ${typeof tableName}`
                    );
                  }
                  foreignData.inTable = tableName;
                  return returnObj;
                },
                inTable() {
                  return this.on.apply(this, arguments);
                }
              };
            }
            foreignData.inTable = pieces[0];
            foreignData.references = pieces[1];
            return returnObj;
          },
          withKeyName(keyName2) {
            foreignData.keyName = keyName2;
            return returnObj;
          },
          onUpdate(statement) {
            foreignData.onUpdate = statement;
            return returnObj;
          },
          onDelete(statement) {
            foreignData.onDelete = statement;
            return returnObj;
          },
          deferrable: (type) => {
            const unSupported = [
              "mysql",
              "mssql",
              "redshift",
              "mysql2",
              "oracledb"
            ];
            if (unSupported.indexOf(this.client.dialect) !== -1) {
              throw new Error(`${this.client.dialect} does not support deferrable`);
            }
            foreignData.deferrable = type;
            return returnObj;
          },
          _columnBuilder(builder) {
            extend4(builder, returnObj);
            returnObj = builder;
            return builder;
          }
        };
        return returnObj;
      }
      check(checkPredicate, bindings, constraintName) {
        this._statements.push({
          grouping: "checks",
          args: [checkPredicate, bindings, constraintName]
        });
        return this;
      }
    };
    [
      // Each of the index methods can be called individually, with the
      // column name to be used, e.g. table.unique('column').
      "index",
      "primary",
      "unique",
      // Key specific
      "dropPrimary",
      "dropPrimaryIfExists",
      "dropUnique",
      "dropUniqueIfExists",
      "dropIndex",
      "dropForeign",
      "dropForeignIfExists"
    ].forEach((method) => {
      TableBuilder.prototype[method] = function() {
        this._statements.push({
          grouping: "alterTable",
          method,
          args: toArray2(arguments)
        });
        return this;
      };
    });
    var specialMethods = {
      mysql: ["engine", "charset", "collate"],
      postgresql: ["inherits"]
    };
    each(specialMethods, function(methods, dialect) {
      methods.forEach(function(method) {
        TableBuilder.prototype[method] = function(value) {
          if (this.client.dialect !== dialect) {
            throw new Error(
              `Knex only supports ${method} statement with ${dialect}.`
            );
          }
          if (this._method === "alter") {
            throw new Error(
              `Knex does not support altering the ${method} outside of create table, please use knex.raw statement.`
            );
          }
          this._single[method] = value;
        };
      });
    });
    helpers.addQueryContext(TableBuilder);
    var columnTypes = [
      // Numeric
      "tinyint",
      "smallint",
      "mediumint",
      "int",
      "bigint",
      "decimal",
      "float",
      "double",
      "real",
      "bit",
      "boolean",
      "serial",
      // Date / Time
      "date",
      "datetime",
      "timestamp",
      "time",
      "year",
      // Geometry
      "geometry",
      "geography",
      "point",
      // String
      "char",
      "varchar",
      "tinytext",
      "tinyText",
      "text",
      "mediumtext",
      "mediumText",
      "longtext",
      "longText",
      "binary",
      "varbinary",
      "tinyblob",
      "tinyBlob",
      "mediumblob",
      "mediumBlob",
      "blob",
      "longblob",
      "longBlob",
      "enum",
      "set",
      // Increments, Aliases, and Additional
      "bool",
      "dateTime",
      "increments",
      "bigincrements",
      "bigIncrements",
      "integer",
      "biginteger",
      "bigInteger",
      "string",
      "json",
      "jsonb",
      "uuid",
      "enu",
      "specificType"
    ];
    columnTypes.forEach((type) => {
      TableBuilder.prototype[type] = function() {
        const args = toArray2(arguments);
        const builder = this.client.columnBuilder(this, type, args);
        this._statements.push({
          grouping: "columns",
          builder
        });
        return builder;
      };
    });
    var AlterMethods = {
      // Renames the current column `from` the current
      // TODO: this.column(from).rename(to)
      renameColumn(from, to) {
        this._statements.push({
          grouping: "alterTable",
          method: "renameColumn",
          args: [from, to]
        });
        return this;
      },
      dropTimestamps() {
        return this.dropColumns(
          arguments[0] === true ? ["createdAt", "updatedAt"] : ["created_at", "updated_at"]
        );
      },
      setNullable(column) {
        this._statements.push({
          grouping: "alterTable",
          method: "setNullable",
          args: [column]
        });
        return this;
      },
      check(checkPredicate, bindings, constraintName) {
        this._statements.push({
          grouping: "alterTable",
          method: "check",
          args: [checkPredicate, bindings, constraintName]
        });
      },
      dropChecks() {
        this._statements.push({
          grouping: "alterTable",
          method: "dropChecks",
          args: toArray2(arguments)
        });
      },
      dropNullable(column) {
        this._statements.push({
          grouping: "alterTable",
          method: "dropNullable",
          args: [column]
        });
        return this;
      }
      // TODO: changeType
    };
    AlterMethods.dropColumn = AlterMethods.dropColumns = function() {
      this._statements.push({
        grouping: "alterTable",
        method: "dropColumn",
        args: toArray2(arguments)
      });
      return this;
    };
    TableBuilder.extend = (methodName, fn) => {
      if (Object.prototype.hasOwnProperty.call(TableBuilder.prototype, methodName)) {
        throw new Error(
          `Can't extend TableBuilder with existing method ('${methodName}').`
        );
      }
      assign(TableBuilder.prototype, { [methodName]: fn });
    };
    module2.exports = TableBuilder;
  }
});

// node_modules/lodash/indexOf.js
var require_indexOf = __commonJS({
  "node_modules/lodash/indexOf.js"(exports2, module2) {
    "use strict";
    var baseIndexOf2 = require_baseIndexOf();
    var toInteger = require_toInteger();
    var nativeMax = Math.max;
    function indexOf(array4, value, fromIndex) {
      var length = array4 == null ? 0 : array4.length;
      if (!length) {
        return -1;
      }
      var index = fromIndex == null ? 0 : toInteger(fromIndex);
      if (index < 0) {
        index = nativeMax(length + index, 0);
      }
      return baseIndexOf2(array4, value, index);
    }
    module2.exports = indexOf;
  }
});

// node_modules/knex/lib/schema/tablecompiler.js
var require_tablecompiler = __commonJS({
  "node_modules/knex/lib/schema/tablecompiler.js"(exports2, module2) {
    "use strict";
    var {
      pushAdditional,
      pushQuery,
      unshiftQuery
    } = require_helpers2();
    var helpers = require_helpers();
    var groupBy = require_groupBy();
    var indexOf = require_indexOf();
    var isEmpty = require_isEmpty();
    var tail = require_tail();
    var { normalizeArr } = require_helpers();
    var TableCompiler = class {
      constructor(client, tableBuilder) {
        this.client = client;
        this.tableBuilder = tableBuilder;
        this._commonBuilder = this.tableBuilder;
        this.method = tableBuilder._method;
        this.schemaNameRaw = tableBuilder._schemaName;
        this.tableNameRaw = tableBuilder._tableName;
        this.tableNameLikeRaw = tableBuilder._tableNameLike;
        this.single = tableBuilder._single;
        this.grouped = groupBy(tableBuilder._statements, "grouping");
        this.formatter = client.formatter(tableBuilder);
        this.bindings = [];
        this.formatter.bindings = this.bindings;
        this.bindingsHolder = this;
        this.sequence = [];
        this._formatting = client.config && client.config.formatting;
        this.checksCount = 0;
      }
      // Convert the tableCompiler toSQL
      toSQL() {
        this[this.method]();
        return this.sequence;
      }
      // Column Compilation
      // -------
      // If this is a table "creation", we need to first run through all
      // of the columns to build them into a single string,
      // and then run through anything else and push it to the query sequence.
      create(ifNot, like) {
        const columnBuilders = this.getColumns();
        const columns = columnBuilders.map((col) => col.toSQL());
        const columnTypes = this.getColumnTypes(columns);
        if (this.createAlterTableMethods) {
          this.alterTableForCreate(columnTypes);
        }
        this.createQuery(columnTypes, ifNot, like);
        this.columnQueries(columns);
        delete this.single.comment;
        this.alterTable();
      }
      // Only create the table if it doesn't exist.
      createIfNot() {
        this.create(true);
      }
      createLike() {
        this.create(false, true);
      }
      createLikeIfNot() {
        this.create(true, true);
      }
      // If we're altering the table, we need to one-by-one
      // go through and handle each of the queries associated
      // with altering the table's schema.
      alter() {
        const addColBuilders = this.getColumns();
        const addColumns = addColBuilders.map((col) => col.toSQL());
        const alterColBuilders = this.getColumns("alter");
        const alterColumns = alterColBuilders.map((col) => col.toSQL());
        const addColumnTypes = this.getColumnTypes(addColumns);
        const alterColumnTypes = this.getColumnTypes(alterColumns);
        this.addColumns(addColumnTypes);
        this.alterColumns(alterColumnTypes, alterColBuilders);
        this.columnQueries(addColumns);
        this.columnQueries(alterColumns);
        this.alterTable();
      }
      foreign(foreignData) {
        if (foreignData.inTable && foreignData.references) {
          const keyName = foreignData.keyName ? this.formatter.wrap(foreignData.keyName) : this._indexCommand("foreign", this.tableNameRaw, foreignData.column);
          const column = this.formatter.columnize(foreignData.column);
          const references = this.formatter.columnize(foreignData.references);
          const inTable = this.formatter.wrap(foreignData.inTable);
          const onUpdate = foreignData.onUpdate ? (this.lowerCase ? " on update " : " ON UPDATE ") + foreignData.onUpdate : "";
          const onDelete = foreignData.onDelete ? (this.lowerCase ? " on delete " : " ON DELETE ") + foreignData.onDelete : "";
          const deferrable = foreignData.deferrable ? this.lowerCase ? ` deferrable initially ${foreignData.deferrable.toLowerCase()} ` : ` DEFERRABLE INITIALLY ${foreignData.deferrable.toUpperCase()} ` : "";
          if (this.lowerCase) {
            this.pushQuery(
              (!this.forCreate ? `alter table ${this.tableName()} add ` : "") + "constraint " + keyName + " foreign key (" + column + ") references " + inTable + " (" + references + ")" + onUpdate + onDelete + deferrable
            );
          } else {
            this.pushQuery(
              (!this.forCreate ? `ALTER TABLE ${this.tableName()} ADD ` : "") + "CONSTRAINT " + keyName + " FOREIGN KEY (" + column + ") REFERENCES " + inTable + " (" + references + ")" + onUpdate + onDelete + deferrable
            );
          }
        }
      }
      // Get all of the column sql & bindings individually for building the table queries.
      getColumnTypes(columns) {
        return columns.reduce(
          function(memo, columnSQL) {
            const column = columnSQL[0];
            memo.sql.push(column.sql);
            memo.bindings.concat(column.bindings);
            return memo;
          },
          { sql: [], bindings: [] }
        );
      }
      // Adds all of the additional queries from the "column"
      columnQueries(columns) {
        const queries = columns.reduce(function(memo, columnSQL) {
          const column = tail(columnSQL);
          if (!isEmpty(column)) return memo.concat(column);
          return memo;
        }, []);
        for (const q of queries) {
          this.pushQuery(q);
        }
      }
      // All of the columns to "add" for the query
      addColumns(columns, prefix) {
        prefix = prefix || this.addColumnsPrefix;
        if (columns.sql.length > 0) {
          const columnSql = columns.sql.map((column) => {
            return prefix + column;
          });
          this.pushQuery({
            sql: (this.lowerCase ? "alter table " : "ALTER TABLE ") + this.tableName() + " " + columnSql.join(", "),
            bindings: columns.bindings
          });
        }
      }
      alterColumns(columns, colBuilders) {
        if (columns.sql.length > 0) {
          this.addColumns(columns, this.alterColumnsPrefix, colBuilders);
        }
      }
      // Compile the columns as needed for the current create or alter table
      getColumns(method) {
        const columns = this.grouped.columns || [];
        method = method || "add";
        const queryContext = this.tableBuilder.queryContext();
        return columns.filter((column) => column.builder._method === method).map((column) => {
          if (queryContext !== void 0 && column.builder.queryContext() === void 0) {
            column.builder.queryContext(queryContext);
          }
          return this.client.columnCompiler(this, column.builder);
        });
      }
      tableName() {
        const name28 = this.schemaNameRaw ? `${this.schemaNameRaw}.${this.tableNameRaw}` : this.tableNameRaw;
        return this.formatter.wrap(name28);
      }
      tableNameLike() {
        const name28 = this.schemaNameRaw ? `${this.schemaNameRaw}.${this.tableNameLikeRaw}` : this.tableNameLikeRaw;
        return this.formatter.wrap(name28);
      }
      // Generate all of the alter column statements necessary for the query.
      alterTable() {
        const alterTable = this.grouped.alterTable || [];
        for (let i = 0, l = alterTable.length; i < l; i++) {
          const statement = alterTable[i];
          if (this[statement.method]) {
            this[statement.method].apply(this, statement.args);
          } else {
            this.client.logger.error(`Debug: ${statement.method} does not exist`);
          }
        }
        for (const item in this.single) {
          if (typeof this[item] === "function") this[item](this.single[item]);
        }
      }
      alterTableForCreate(columnTypes) {
        this.forCreate = true;
        const savedSequence = this.sequence;
        const alterTable = this.grouped.alterTable || [];
        this.grouped.alterTable = [];
        for (let i = 0, l = alterTable.length; i < l; i++) {
          const statement = alterTable[i];
          if (indexOf(this.createAlterTableMethods, statement.method) < 0) {
            this.grouped.alterTable.push(statement);
            continue;
          }
          if (this[statement.method]) {
            this.sequence = [];
            this[statement.method].apply(this, statement.args);
            columnTypes.sql.push(this.sequence[0].sql);
          } else {
            this.client.logger.error(`Debug: ${statement.method} does not exist`);
          }
        }
        this.sequence = savedSequence;
        this.forCreate = false;
      }
      // Drop the index on the current table.
      dropIndex(value) {
        this.pushQuery(`drop index${value}`);
      }
      dropUnique() {
        throw new Error("Method implemented in the dialect driver");
      }
      dropUniqueIfExists() {
        throw new Error("Method implemented in the dialect driver");
      }
      dropForeign() {
        throw new Error("Method implemented in the dialect driver");
      }
      dropForeignIfExists() {
        throw new Error("Method implemented in the dialect driver");
      }
      dropPrimaryIfExists() {
        throw new Error("Method implemented in the dialect driver");
      }
      dropColumn() {
        const columns = helpers.normalizeArr.apply(null, arguments);
        const drops = (Array.isArray(columns) ? columns : [columns]).map(
          (column) => {
            return this.dropColumnPrefix + this.formatter.wrap(column);
          }
        );
        this.pushQuery(
          (this.lowerCase ? "alter table " : "ALTER TABLE ") + this.tableName() + " " + drops.join(", ")
        );
      }
      //Default implementation of setNullable. Overwrite on dialect-specific tablecompiler when needed
      //(See postgres/mssql for reference)
      _setNullableState(column, nullable3) {
        const tableName = this.tableName();
        const columnName = this.formatter.columnize(column);
        const alterColumnPrefix = this.alterColumnsPrefix;
        return this.pushQuery({
          sql: "SELECT 1",
          output: () => {
            return this.client.queryBuilder().from(this.tableNameRaw).columnInfo(column).then((columnInfo) => {
              if (isEmpty(columnInfo)) {
                throw new Error(
                  `.setNullable: Column ${columnName} does not exist in table ${tableName}.`
                );
              }
              const nullableType2 = nullable3 ? "null" : "not null";
              const columnType = columnInfo.type + (columnInfo.maxLength ? `(${columnInfo.maxLength})` : "");
              const defaultValue = columnInfo.defaultValue !== null && columnInfo.defaultValue !== void 0 ? `default '${columnInfo.defaultValue}'` : "";
              const sql = `alter table ${tableName} ${alterColumnPrefix} ${columnName} ${columnType} ${nullableType2} ${defaultValue}`;
              return this.client.raw(sql);
            });
          }
        });
      }
      setNullable(column) {
        return this._setNullableState(column, true);
      }
      dropNullable(column) {
        return this._setNullableState(column, false);
      }
      dropChecks(checkConstraintNames) {
        if (checkConstraintNames === void 0) return "";
        checkConstraintNames = normalizeArr(checkConstraintNames);
        const tableName = this.tableName();
        const sql = `alter table ${tableName} ${checkConstraintNames.map((constraint) => `drop constraint ${constraint}`).join(", ")}`;
        this.pushQuery(sql);
      }
      check(checkPredicate, bindings, constraintName) {
        const tableName = this.tableName();
        let checkConstraint = constraintName;
        if (!checkConstraint) {
          this.checksCount++;
          checkConstraint = tableName + "_" + this.checksCount;
        }
        const sql = `alter table ${tableName} add constraint ${checkConstraint} check(${checkPredicate})`;
        this.pushQuery(sql);
      }
      _addChecks() {
        if (this.grouped.checks) {
          return ", " + this.grouped.checks.map((c) => {
            return `${c.args[2] ? "constraint " + c.args[2] + " " : ""}check (${this.client.raw(c.args[0], c.args[1])})`;
          }).join(", ");
        }
        return "";
      }
      // If no name was specified for this index, we will create one using a basic
      // convention of the table name, followed by the columns, followed by an
      // index type, such as primary or index, which makes the index unique.
      _indexCommand(type, tableName, columns) {
        if (!Array.isArray(columns)) columns = columns ? [columns] : [];
        const table = tableName.replace(/\.|-/g, "_");
        const indexName = (table + "_" + columns.join("_") + "_" + type).toLowerCase();
        return this.formatter.wrap(indexName);
      }
      _getPrimaryKeys() {
        return (this.grouped.alterTable || []).filter((a) => a.method === "primary").flatMap((a) => a.args).flat();
      }
      _canBeAddPrimaryKey(options) {
        return options.primaryKey && this._getPrimaryKeys().length === 0;
      }
      _getIncrementsColumnNames() {
        return this.grouped.columns.filter((c) => c.builder._type === "increments").map((c) => c.builder._args[0]);
      }
      _getBigIncrementsColumnNames() {
        return this.grouped.columns.filter((c) => c.builder._type === "bigincrements").map((c) => c.builder._args[0]);
      }
    };
    TableCompiler.prototype.pushQuery = pushQuery;
    TableCompiler.prototype.pushAdditional = pushAdditional;
    TableCompiler.prototype.unshiftQuery = unshiftQuery;
    TableCompiler.prototype.lowerCase = true;
    TableCompiler.prototype.createAlterTableMethods = null;
    TableCompiler.prototype.addColumnsPrefix = "add column ";
    TableCompiler.prototype.alterColumnsPrefix = "alter column ";
    TableCompiler.prototype.modifyColumnPrefix = "modify column ";
    TableCompiler.prototype.dropColumnPrefix = "drop column ";
    module2.exports = TableCompiler;
  }
});

// node_modules/knex/lib/schema/columnbuilder.js
var require_columnbuilder = __commonJS({
  "node_modules/knex/lib/schema/columnbuilder.js"(exports2, module2) {
    "use strict";
    var extend4 = require_extend();
    var assign = require_assign();
    var toArray2 = require_toArray();
    var { addQueryContext } = require_helpers();
    var ColumnBuilder = class {
      constructor(client, tableBuilder, type, args) {
        this.client = client;
        this._method = "add";
        this._single = {};
        this._modifiers = {};
        this._statements = [];
        this._type = columnAlias[type] || type;
        this._args = args;
        this._tableBuilder = tableBuilder;
        if (tableBuilder._method === "alter") {
          extend4(this, AlterMethods);
        }
      }
      // Specify that the current column "references" a column,
      // which may be tableName.column or just "column"
      references(value) {
        return this._tableBuilder.foreign.call(this._tableBuilder, this._args[0], void 0, this)._columnBuilder(this).references(value);
      }
    };
    var modifiers = [
      "default",
      "defaultsTo",
      "defaultTo",
      "unsigned",
      "nullable",
      "first",
      "after",
      "comment",
      "collate",
      "check",
      "checkPositive",
      "checkNegative",
      "checkIn",
      "checkNotIn",
      "checkBetween",
      "checkLength",
      "checkRegex"
    ];
    var aliasMethod = {
      default: "defaultTo",
      defaultsTo: "defaultTo"
    };
    modifiers.forEach(function(method) {
      const key = aliasMethod[method] || method;
      ColumnBuilder.prototype[method] = function() {
        this._modifiers[key] = toArray2(arguments);
        return this;
      };
    });
    addQueryContext(ColumnBuilder);
    ColumnBuilder.prototype.notNull = ColumnBuilder.prototype.notNullable = function notNullable() {
      return this.nullable(false);
    };
    ["index", "primary", "unique"].forEach(function(method) {
      ColumnBuilder.prototype[method] = function() {
        if (this._type.toLowerCase().indexOf("increments") === -1) {
          this._tableBuilder[method].apply(
            this._tableBuilder,
            [this._args[0]].concat(toArray2(arguments))
          );
        }
        return this;
      };
    });
    ColumnBuilder.extend = (methodName, fn) => {
      if (Object.prototype.hasOwnProperty.call(ColumnBuilder.prototype, methodName)) {
        throw new Error(
          `Can't extend ColumnBuilder with existing method ('${methodName}').`
        );
      }
      assign(ColumnBuilder.prototype, { [methodName]: fn });
    };
    var AlterMethods = {};
    AlterMethods.drop = function() {
      this._single.drop = true;
      return this;
    };
    AlterMethods.alterType = function(type) {
      this._statements.push({
        grouping: "alterType",
        value: type
      });
      return this;
    };
    AlterMethods.alter = function({
      alterNullable = true,
      alterType = true
    } = {}) {
      this._method = "alter";
      this.alterNullable = alterNullable;
      this.alterType = alterType;
      return this;
    };
    var columnAlias = {
      float: "floating",
      enum: "enu",
      boolean: "bool",
      string: "varchar",
      bigint: "bigInteger"
    };
    module2.exports = ColumnBuilder;
  }
});

// node_modules/lodash/head.js
var require_head = __commonJS({
  "node_modules/lodash/head.js"(exports2, module2) {
    "use strict";
    function head(array4) {
      return array4 && array4.length ? array4[0] : void 0;
    }
    module2.exports = head;
  }
});

// node_modules/lodash/first.js
var require_first = __commonJS({
  "node_modules/lodash/first.js"(exports2, module2) {
    "use strict";
    module2.exports = require_head();
  }
});

// node_modules/knex/lib/schema/columncompiler.js
var require_columncompiler = __commonJS({
  "node_modules/knex/lib/schema/columncompiler.js"(exports2, module2) {
    "use strict";
    var helpers = require_helpers2();
    var groupBy = require_groupBy();
    var first = require_first();
    var has = require_has();
    var tail = require_tail();
    var { toNumber: toNumber2 } = require_helpers();
    var { formatDefault } = require_formatterUtils();
    var { operator: operator_ } = require_wrappingFormatter();
    var ColumnCompiler = class {
      constructor(client, tableCompiler, columnBuilder) {
        this.client = client;
        this.tableCompiler = tableCompiler;
        this.columnBuilder = columnBuilder;
        this._commonBuilder = this.columnBuilder;
        this.args = columnBuilder._args;
        this.type = columnBuilder._type.toLowerCase();
        this.grouped = groupBy(columnBuilder._statements, "grouping");
        this.modified = columnBuilder._modifiers;
        this.isIncrements = this.type.indexOf("increments") !== -1;
        this.formatter = client.formatter(columnBuilder);
        this.bindings = [];
        this.formatter.bindings = this.bindings;
        this.bindingsHolder = this;
        this.sequence = [];
        this.modifiers = [];
        this.checksCount = 0;
      }
      _addCheckModifiers() {
        this.modifiers.push(
          "check",
          "checkPositive",
          "checkNegative",
          "checkIn",
          "checkNotIn",
          "checkBetween",
          "checkLength",
          "checkRegex"
        );
      }
      defaults(label) {
        if (Object.prototype.hasOwnProperty.call(this._defaultMap, label)) {
          return this._defaultMap[label].bind(this)();
        } else {
          throw new Error(
            `There is no default for the specified identifier ${label}`
          );
        }
      }
      // To convert to sql, we first go through and build the
      // column as it would be in the insert statement
      toSQL() {
        this.pushQuery(this.compileColumn());
        if (this.sequence.additional) {
          this.sequence = this.sequence.concat(this.sequence.additional);
        }
        return this.sequence;
      }
      // Compiles a column.
      compileColumn() {
        return this.formatter.wrap(this.getColumnName()) + " " + this.getColumnType() + this.getModifiers();
      }
      // Assumes the autoincrementing key is named `id` if not otherwise specified.
      getColumnName() {
        const value = first(this.args);
        return value || this.defaults("columnName");
      }
      getColumnType() {
        if (!this._columnType) {
          const type = this[this.type];
          this._columnType = typeof type === "function" ? type.apply(this, tail(this.args)) : type;
        }
        return this._columnType;
      }
      getModifiers() {
        const modifiers = [];
        for (let i = 0, l = this.modifiers.length; i < l; i++) {
          const modifier = this.modifiers[i];
          if (!this.isIncrements || this.isIncrements && modifier === "comment") {
            if (has(this.modified, modifier)) {
              const val = this[modifier].apply(this, this.modified[modifier]);
              if (val) modifiers.push(val);
            }
          }
        }
        return modifiers.length > 0 ? ` ${modifiers.join(" ")}` : "";
      }
      // Types
      // ------
      varchar(length) {
        return `varchar(${toNumber2(length, 255)})`;
      }
      floating(precision, scale) {
        return `float(${toNumber2(precision, 8)}, ${toNumber2(scale, 2)})`;
      }
      decimal(precision, scale) {
        if (precision === null) {
          throw new Error(
            "Specifying no precision on decimal columns is not supported for that SQL dialect."
          );
        }
        return `decimal(${toNumber2(precision, 8)}, ${toNumber2(scale, 2)})`;
      }
      // Used to support custom types
      specifictype(type) {
        return type;
      }
      // Modifiers
      // -------
      nullable(nullable3) {
        return nullable3 === false ? "not null" : "null";
      }
      notNullable() {
        return this.nullable(false);
      }
      defaultTo(value) {
        return `default ${formatDefault(value, this.type, this.client)}`;
      }
      increments(options = { primaryKey: true }) {
        return "integer not null" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "") + " autoincrement";
      }
      bigincrements(options = { primaryKey: true }) {
        return this.increments(options);
      }
      _pushAlterCheckQuery(checkPredicate, constraintName) {
        let checkName = constraintName;
        if (!checkName) {
          this.checksCount++;
          checkName = this.tableCompiler.tableNameRaw + "_" + this.getColumnName() + "_" + this.checksCount;
        }
        this.pushAdditional(function() {
          this.pushQuery(
            `alter table ${this.tableCompiler.tableName()} add constraint ${checkName} check(${checkPredicate})`
          );
        });
      }
      _checkConstraintName(constraintName) {
        return constraintName ? `constraint ${constraintName} ` : "";
      }
      _check(checkPredicate, constraintName) {
        if (this.columnBuilder._method === "alter") {
          this._pushAlterCheckQuery(checkPredicate, constraintName);
          return "";
        }
        return `${this._checkConstraintName(
          constraintName
        )}check (${checkPredicate})`;
      }
      checkPositive(constraintName) {
        return this._check(
          `${this.formatter.wrap(this.getColumnName())} ${operator_(
            ">",
            this.columnBuilder,
            this.bindingsHolder
          )} 0`,
          constraintName
        );
      }
      checkNegative(constraintName) {
        return this._check(
          `${this.formatter.wrap(this.getColumnName())} ${operator_(
            "<",
            this.columnBuilder,
            this.bindingsHolder
          )} 0`,
          constraintName
        );
      }
      _checkIn(values, constraintName, not) {
        return this._check(
          `${this.formatter.wrap(this.getColumnName())} ${not ? "not " : ""}in (${values.map((v) => this.client._escapeBinding(v)).join(",")})`,
          constraintName
        );
      }
      checkIn(values, constraintName) {
        return this._checkIn(values, constraintName);
      }
      checkNotIn(values, constraintName) {
        return this._checkIn(values, constraintName, true);
      }
      checkBetween(intervals, constraintName) {
        if (intervals.length === 2 && !Array.isArray(intervals[0]) && !Array.isArray(intervals[1])) {
          intervals = [intervals];
        }
        const intervalChecks = intervals.map((interval) => {
          return `${this.formatter.wrap(
            this.getColumnName()
          )} between ${this.client._escapeBinding(
            interval[0]
          )} and ${this.client._escapeBinding(interval[1])}`;
        }).join(" or ");
        return this._check(intervalChecks, constraintName);
      }
      checkLength(operator, length, constraintName) {
        return this._check(
          `length(${this.formatter.wrap(this.getColumnName())}) ${operator_(
            operator,
            this.columnBuilder,
            this.bindingsHolder
          )} ${toNumber2(length)}`,
          constraintName
        );
      }
    };
    ColumnCompiler.prototype.binary = "blob";
    ColumnCompiler.prototype.bool = "boolean";
    ColumnCompiler.prototype.date = "date";
    ColumnCompiler.prototype.datetime = "datetime";
    ColumnCompiler.prototype.time = "time";
    ColumnCompiler.prototype.timestamp = "timestamp";
    ColumnCompiler.prototype.geometry = "geometry";
    ColumnCompiler.prototype.geography = "geography";
    ColumnCompiler.prototype.point = "point";
    ColumnCompiler.prototype.enu = "varchar";
    ColumnCompiler.prototype.bit = ColumnCompiler.prototype.json = "text";
    ColumnCompiler.prototype.uuid = ({
      useBinaryUuid = false,
      primaryKey = false
    } = {}) => useBinaryUuid ? "binary(16)" : "char(36)";
    ColumnCompiler.prototype.integer = ColumnCompiler.prototype.smallint = ColumnCompiler.prototype.mediumint = "integer";
    ColumnCompiler.prototype.biginteger = "bigint";
    ColumnCompiler.prototype.text = "text";
    ColumnCompiler.prototype.tinyint = "tinyint";
    ColumnCompiler.prototype.pushQuery = helpers.pushQuery;
    ColumnCompiler.prototype.pushAdditional = helpers.pushAdditional;
    ColumnCompiler.prototype.unshiftQuery = helpers.unshiftQuery;
    ColumnCompiler.prototype._defaultMap = {
      columnName: function() {
        if (!this.isIncrements) {
          throw new Error(
            `You did not specify a column name for the ${this.type} column.`
          );
        }
        return "id";
      }
    };
    module2.exports = ColumnCompiler;
  }
});

// node_modules/knex/lib/ref.js
var require_ref2 = __commonJS({
  "node_modules/knex/lib/ref.js"(exports2, module2) {
    "use strict";
    var Raw = require_raw2();
    var Ref = class extends Raw {
      constructor(client, ref) {
        super(client);
        this.ref = ref;
        this._schema = null;
        this._alias = null;
      }
      withSchema(schema) {
        this._schema = schema;
        return this;
      }
      as(alias) {
        this._alias = alias;
        return this;
      }
      toSQL() {
        const string5 = this._schema ? `${this._schema}.${this.ref}` : this.ref;
        const formatter = this.client.formatter(this);
        const ref = formatter.columnize(string5);
        const sql = this._alias ? `${ref} as ${formatter.wrap(this._alias)}` : ref;
        this.set(sql, []);
        return super.toSQL(...arguments);
      }
    };
    module2.exports = Ref;
  }
});

// node_modules/knex/lib/formatter.js
var require_formatter = __commonJS({
  "node_modules/knex/lib/formatter.js"(exports2, module2) {
    "use strict";
    var {
      columnize: columnize_,
      wrap: wrap_
    } = require_wrappingFormatter();
    var Formatter = class {
      constructor(client, builder) {
        this.client = client;
        this.builder = builder;
        this.bindings = [];
      }
      // Accepts a string or array of columns to wrap as appropriate.
      columnize(target) {
        return columnize_(target, this.builder, this.client, this);
      }
      // Puts the appropriate wrapper around a value depending on the database
      // engine, unless it's a knex.raw value, in which case it's left alone.
      wrap(value, isParameter) {
        return wrap_(value, isParameter, this.builder, this.client, this);
      }
    };
    module2.exports = Formatter;
  }
});

// node_modules/knex/lib/schema/viewbuilder.js
var require_viewbuilder = __commonJS({
  "node_modules/knex/lib/schema/viewbuilder.js"(exports2, module2) {
    "use strict";
    var helpers = require_helpers();
    var extend4 = require_extend();
    var assign = require_assign();
    var ViewBuilder = class {
      constructor(client, method, viewName, fn) {
        this.client = client;
        this._method = method;
        this._schemaName = void 0;
        this._columns = void 0;
        this._fn = fn;
        this._viewName = viewName;
        this._statements = [];
        this._single = {};
      }
      setSchema(schemaName) {
        this._schemaName = schemaName;
      }
      columns(columns) {
        this._columns = columns;
      }
      as(selectQuery) {
        this._selectQuery = selectQuery;
      }
      checkOption() {
        throw new Error(
          "check option definition is not supported by this dialect."
        );
      }
      localCheckOption() {
        throw new Error(
          "check option definition is not supported by this dialect."
        );
      }
      cascadedCheckOption() {
        throw new Error(
          "check option definition is not supported by this dialect."
        );
      }
      toSQL() {
        if (this._method === "alter") {
          extend4(this, AlterMethods);
        }
        this._fn.call(this, this);
        return this.client.viewCompiler(this).toSQL();
      }
    };
    var AlterMethods = {
      column(column) {
        const self2 = this;
        return {
          rename: function(newName) {
            self2._statements.push({
              grouping: "alterView",
              method: "renameColumn",
              args: [column, newName]
            });
            return this;
          },
          defaultTo: function(defaultValue) {
            self2._statements.push({
              grouping: "alterView",
              method: "defaultTo",
              args: [column, defaultValue]
            });
            return this;
          }
        };
      }
    };
    helpers.addQueryContext(ViewBuilder);
    ViewBuilder.extend = (methodName, fn) => {
      if (Object.prototype.hasOwnProperty.call(ViewBuilder.prototype, methodName)) {
        throw new Error(
          `Can't extend ViewBuilder with existing method ('${methodName}').`
        );
      }
      assign(ViewBuilder.prototype, { [methodName]: fn });
    };
    module2.exports = ViewBuilder;
  }
});

// node_modules/knex/lib/schema/viewcompiler.js
var require_viewcompiler = __commonJS({
  "node_modules/knex/lib/schema/viewcompiler.js"(exports2, module2) {
    "use strict";
    var { pushQuery } = require_helpers2();
    var groupBy = require_groupBy();
    var { columnize: columnize_ } = require_wrappingFormatter();
    var ViewCompiler = class {
      constructor(client, viewBuilder) {
        this.client = client;
        this.viewBuilder = viewBuilder;
        this._commonBuilder = this.viewBuilder;
        this.method = viewBuilder._method;
        this.schemaNameRaw = viewBuilder._schemaName;
        this.viewNameRaw = viewBuilder._viewName;
        this.single = viewBuilder._single;
        this.selectQuery = viewBuilder._selectQuery;
        this.columns = viewBuilder._columns;
        this.grouped = groupBy(viewBuilder._statements, "grouping");
        this.formatter = client.formatter(viewBuilder);
        this.bindings = [];
        this.formatter.bindings = this.bindings;
        this.bindingsHolder = this;
        this.sequence = [];
      }
      // Convert the tableCompiler toSQL
      toSQL() {
        this[this.method]();
        return this.sequence;
      }
      // Column Compilation
      // -------
      create() {
        this.createQuery(this.columns, this.selectQuery);
      }
      createOrReplace() {
        throw new Error("replace views is not supported by this dialect.");
      }
      createMaterializedView() {
        throw new Error("materialized views are not supported by this dialect.");
      }
      createQuery(columns, selectQuery, materialized, replace) {
        const createStatement = "create " + (materialized ? "materialized " : "") + (replace ? "or replace " : "") + "view ";
        const columnList = columns ? " (" + columnize_(
          columns,
          this.viewBuilder,
          this.client,
          this.bindingsHolder
        ) + ")" : "";
        let sql = createStatement + this.viewName() + columnList;
        sql += " as ";
        sql += selectQuery.toString();
        switch (this.single.checkOption) {
          case "default_option":
            sql += " with check option";
            break;
          case "local":
            sql += " with local check option";
            break;
          case "cascaded":
            sql += " with cascaded check option";
            break;
          default:
            break;
        }
        this.pushQuery({
          sql
        });
      }
      renameView(from, to) {
        throw new Error(
          "rename view is not supported by this dialect (instead drop, then create another view)."
        );
      }
      refreshMaterializedView() {
        throw new Error("materialized views are not supported by this dialect.");
      }
      alter() {
        this.alterView();
      }
      alterView() {
        const alterView = this.grouped.alterView || [];
        for (let i = 0, l = alterView.length; i < l; i++) {
          const statement = alterView[i];
          if (this[statement.method]) {
            this[statement.method].apply(this, statement.args);
          } else {
            this.client.logger.error(`Debug: ${statement.method} does not exist`);
          }
        }
        for (const item in this.single) {
          if (typeof this[item] === "function") this[item](this.single[item]);
        }
      }
      renameColumn(from, to) {
        throw new Error("rename column of views is not supported by this dialect.");
      }
      defaultTo(column, defaultValue) {
        throw new Error(
          "change default values of views is not supported by this dialect."
        );
      }
      viewName() {
        const name28 = this.schemaNameRaw ? `${this.schemaNameRaw}.${this.viewNameRaw}` : this.viewNameRaw;
        return this.formatter.wrap(name28);
      }
    };
    ViewCompiler.prototype.pushQuery = pushQuery;
    module2.exports = ViewCompiler;
  }
});

// node_modules/knex/lib/client.js
var require_client2 = __commonJS({
  "node_modules/knex/lib/client.js"(exports2, module2) {
    "use strict";
    var { Pool, TimeoutError } = require_tarn();
    var { EventEmitter: EventEmitter3 } = require("events");
    var { promisify: promisify2 } = require("util");
    var { makeEscape } = require_string2();
    var cloneDeep = require_cloneDeep();
    var defaults2 = require_defaults();
    var uniqueId = require_uniqueId();
    var Runner = require_runner();
    var Transaction = require_transaction();
    var {
      executeQuery,
      enrichQueryObject
    } = require_query_executioner();
    var QueryBuilder = require_querybuilder();
    var QueryCompiler = require_querycompiler();
    var SchemaBuilder = require_builder();
    var SchemaCompiler = require_compiler();
    var TableBuilder = require_tablebuilder();
    var TableCompiler = require_tablecompiler();
    var ColumnBuilder = require_columnbuilder();
    var ColumnCompiler = require_columncompiler();
    var { KnexTimeoutError } = require_timeout();
    var { outputQuery, unwrapRaw } = require_wrappingFormatter();
    var { compileCallback } = require_formatterUtils();
    var Raw = require_raw2();
    var Ref = require_ref2();
    var Formatter = require_formatter();
    var Logger = require_logger();
    var { POOL_CONFIG_OPTIONS } = require_constants6();
    var ViewBuilder = require_viewbuilder();
    var ViewCompiler = require_viewcompiler();
    var isPlainObject4 = require_isPlainObject();
    var { setHiddenProperty } = require_security();
    var debug = require_src3()("knex:client");
    var Client2 = class extends EventEmitter3 {
      constructor(config3 = {}) {
        super();
        this.config = { ...config3 };
        if (config3.connection && typeof config3.connection === "object") {
          this.config.connection = { ...config3.connection };
        }
        this.logger = new Logger(this.config);
        if (this.config.connection && config3.connection.password) {
          setHiddenProperty(this.config.connection, config3.connection);
        }
        if (this.dialect && !this.config.client) {
          this.logger.warn(
            `Using 'this.dialect' to identify the client is deprecated and support for it will be removed in the future. Please use configuration option 'client' instead.`
          );
        }
        const dbClient2 = this.config.client || this.dialect;
        if (!dbClient2) {
          throw new Error(
            `knex: Required configuration option 'client' is missing.`
          );
        }
        if (config3.version) {
          this.version = config3.version;
        }
        if (config3.connection && config3.connection instanceof Function) {
          this.connectionConfigProvider = this.config.connection;
          this.connectionConfigExpirationChecker = () => true;
        } else {
          this.connectionSettings = cloneDeep(this.config.connection || {});
          if (config3.connection && config3.connection.password) {
            setHiddenProperty(this.connectionSettings, this.config.connection);
          }
          this.connectionConfigExpirationChecker = null;
        }
        if (this.driverName && config3.connection) {
          this.initializeDriver();
          if (!config3.pool || config3.pool && config3.pool.max !== 0) {
            this.initializePool(this.config);
          }
        }
        this.valueForUndefined = this.raw("DEFAULT");
        if (config3.useNullAsDefault) {
          this.valueForUndefined = null;
        }
      }
      formatter(builder) {
        return new Formatter(this, builder);
      }
      queryBuilder() {
        return new QueryBuilder(this);
      }
      queryCompiler(builder, formatter) {
        return new QueryCompiler(this, builder, formatter);
      }
      schemaBuilder() {
        return new SchemaBuilder(this);
      }
      schemaCompiler(builder) {
        return new SchemaCompiler(this, builder);
      }
      tableBuilder(type, tableName, tableNameLike, fn) {
        return new TableBuilder(this, type, tableName, tableNameLike, fn);
      }
      viewBuilder(type, viewBuilder, fn) {
        return new ViewBuilder(this, type, viewBuilder, fn);
      }
      tableCompiler(tableBuilder) {
        return new TableCompiler(this, tableBuilder);
      }
      viewCompiler(viewCompiler) {
        return new ViewCompiler(this, viewCompiler);
      }
      columnBuilder(tableBuilder, type, args) {
        return new ColumnBuilder(this, tableBuilder, type, args);
      }
      columnCompiler(tableBuilder, columnBuilder) {
        return new ColumnCompiler(this, tableBuilder, columnBuilder);
      }
      runner(builder) {
        return new Runner(this, builder);
      }
      transaction(container, config3, outerTx) {
        return new Transaction(this, container, config3, outerTx);
      }
      raw() {
        return new Raw(this).set(...arguments);
      }
      ref() {
        return new Ref(this, ...arguments);
      }
      query(connection, queryParam) {
        const queryObject = enrichQueryObject(connection, queryParam, this);
        return executeQuery(connection, queryObject, this);
      }
      stream(connection, queryParam, stream4, options) {
        const queryObject = enrichQueryObject(connection, queryParam, this);
        return this._stream(connection, queryObject, stream4, options);
      }
      prepBindings(bindings) {
        return bindings;
      }
      positionBindings(sql) {
        return sql;
      }
      postProcessResponse(resp, queryContext) {
        if (this.config.postProcessResponse) {
          return this.config.postProcessResponse(resp, queryContext);
        }
        return resp;
      }
      wrapIdentifier(value, queryContext) {
        return this.customWrapIdentifier(
          value,
          this.wrapIdentifierImpl,
          queryContext
        );
      }
      customWrapIdentifier(value, origImpl, queryContext) {
        if (this.config.wrapIdentifier) {
          return this.config.wrapIdentifier(value, origImpl, queryContext);
        }
        return origImpl(value);
      }
      wrapIdentifierImpl(value) {
        return value !== "*" ? `"${value.replace(/"/g, '""')}"` : "*";
      }
      initializeDriver() {
        try {
          this.driver = this._driver();
        } catch (e) {
          const message = `Knex: run
$ npm install ${this.driverName} --save`;
          this.logger.error(`${message}
${e.message}
${e.stack}`);
          throw new Error(`${message}
${e.message}`);
        }
      }
      poolDefaults() {
        return { min: 2, max: 10, propagateCreateError: true };
      }
      getPoolSettings(poolConfig) {
        const {
          afterCreate: userAfterCreate,
          validate: userValidate,
          maxConnectionLifetimeMillis,
          maxConnectionLifetimeJitterMillis,
          ...tarnOptions
        } = defaults2({}, poolConfig, this.poolDefaults());
        POOL_CONFIG_OPTIONS.forEach((option) => {
          if (option in tarnOptions) {
            this.logger.warn(
              [
                `Pool config option "${option}" is no longer supported.`,
                `See https://github.com/Vincit/tarn.js for possible pool config options.`
              ].join(" ")
            );
          }
        });
        const DEFAULT_ACQUIRE_TIMEOUT = 6e4;
        const timeouts = [
          this.config.acquireConnectionTimeout,
          tarnOptions.acquireTimeoutMillis
        ].filter((timeout) => timeout !== void 0);
        if (!timeouts.length) {
          timeouts.push(DEFAULT_ACQUIRE_TIMEOUT);
        }
        const acquireTimeoutMillis = Math.min(...timeouts);
        const hasMaxConnectionLifetime = typeof maxConnectionLifetimeMillis === "number" && Number.isFinite(maxConnectionLifetimeMillis) && maxConnectionLifetimeMillis > 0;
        const generateLifetimeLimit = () => {
          if (!hasMaxConnectionLifetime) {
            return null;
          }
          const jitter = typeof maxConnectionLifetimeJitterMillis === "number" && maxConnectionLifetimeJitterMillis > 0 ? Math.floor(Math.random() * maxConnectionLifetimeJitterMillis) : 0;
          return performance.now() + maxConnectionLifetimeMillis + jitter;
        };
        const updatePoolConnectionSettingsFromProvider = async (forceRefresh = false) => {
          if (!this.connectionConfigProvider) {
            return;
          }
          if (!forceRefresh && (!this.connectionConfigExpirationChecker || !this.connectionConfigExpirationChecker())) {
            return;
          }
          const providerResult = await this.connectionConfigProvider();
          if (providerResult.expirationChecker) {
            this.connectionConfigExpirationChecker = providerResult.expirationChecker;
            delete providerResult.expirationChecker;
          } else {
            this.connectionConfigExpirationChecker = null;
          }
          this.connectionSettings = providerResult;
        };
        const connectionIsDisposed = (connection) => {
          if (connection.__knex__disposed) {
            this.logger.warn(`Connection Error: ${connection.__knex__disposed}`);
            return true;
          }
          return false;
        };
        const connectionIsOverLifetime = (connection) => {
          if (!hasMaxConnectionLifetime) {
            return false;
          }
          if (!connection.__knexLifetimeLimit) {
            connection.__knexLifetimeLimit = generateLifetimeLimit();
          }
          return connection.__knexLifetimeLimit && performance.now() > connection.__knexLifetimeLimit;
        };
        const configWasRefreshed = async () => {
          if (!this.connectionConfigExpirationChecker) {
            return false;
          }
          if (!this.connectionConfigExpirationChecker()) {
            return false;
          }
          await updatePoolConnectionSettingsFromProvider(true);
          if (this.connectionConfigExpirationChecker && this.connectionConfigExpirationChecker()) {
            throw new Error(
              "Connection configuration still reported expired after refresh"
            );
          }
          return true;
        };
        const tarnPoolConfig = {
          ...tarnOptions,
          acquireTimeoutMillis,
          create: async () => {
            await updatePoolConnectionSettingsFromProvider();
            const connection = await this.acquireRawConnection();
            connection.__knexUid = uniqueId("__knexUid");
            if (hasMaxConnectionLifetime) {
              connection.__knexLifetimeLimit = generateLifetimeLimit();
            }
            if (userAfterCreate) {
              await promisify2(userAfterCreate)(connection);
            }
            return connection;
          },
          destroy: (connection) => {
            if (connection !== void 0) {
              return this.destroyRawConnection(connection);
            }
          },
          validate: async (connection) => {
            if (connectionIsDisposed(connection)) {
              return false;
            }
            if (connectionIsOverLifetime(connection)) {
              return false;
            }
            if (await configWasRefreshed()) {
              return false;
            }
            if (userValidate) {
              try {
                const validationResult = await userValidate(connection);
                if (!validationResult) {
                  return false;
                }
              } catch (validationError) {
                this.logger.warn(
                  `Pool validate threw an error: ${validationError.message}`
                );
                return false;
              }
            }
            return this.validateConnection(connection);
          }
        };
        if (tarnPoolConfig.afterCreate) {
          delete tarnPoolConfig.afterCreate;
        }
        return tarnPoolConfig;
      }
      initializePool(config3 = this.config) {
        if (this.pool) {
          this.logger.warn("The pool has already been initialized");
          return;
        }
        this.pool = new Pool(this.getPoolSettings(config3.pool));
      }
      validateConnection(connection) {
        return true;
      }
      // Acquire a connection from the pool.
      async acquireConnection() {
        if (!this.pool) {
          throw new Error("Unable to acquire a connection");
        }
        try {
          const connection = await this.pool.acquire().promise;
          debug("acquired connection from pool: %s", connection.__knexUid);
          if (connection.config) {
            if (connection.config.password) {
              setHiddenProperty(connection.config);
            }
            if (connection.config.authentication && connection.config.authentication.options && connection.config.authentication.options.password) {
              setHiddenProperty(connection.config.authentication.options);
            }
          }
          return connection;
        } catch (error73) {
          let convertedError = error73;
          if (error73 instanceof TimeoutError) {
            convertedError = new KnexTimeoutError(
              "Knex: Timeout acquiring a connection. The pool is probably full. Are you missing a .transacting(trx) call?"
            );
          }
          throw convertedError;
        }
      }
      // Releases a connection back to the connection pool,
      // returning a promise resolved when the connection is released.
      releaseConnection(connection) {
        debug("releasing connection to pool: %s", connection.__knexUid);
        const didRelease = this.pool.release(connection);
        if (!didRelease) {
          debug("pool refused connection: %s", connection.__knexUid);
        }
        return Promise.resolve();
      }
      // Destroy the current connection pool for the client.
      async destroy(callback) {
        try {
          if (this.pool && this.pool.destroy) {
            await this.pool.destroy();
          }
          this.pool = void 0;
          if (typeof callback === "function") {
            callback();
          }
        } catch (err) {
          if (typeof callback === "function") {
            return callback(err);
          }
          throw err;
        }
      }
      // Return the database being used by this client.
      database() {
        return this.connectionSettings.database;
      }
      toString() {
        return "[object KnexClient]";
      }
      assertCanCancelQuery() {
        if (!this.canCancelQuery) {
          throw new Error("Query cancelling not supported for this dialect");
        }
      }
      cancelQuery() {
        throw new Error("Query cancelling not supported for this dialect");
      }
      // Formatter part
      alias(first, second) {
        return first + " as " + second;
      }
      // Checks whether a value is a function... if it is, we compile it
      // otherwise we check whether it's a raw
      parameter(value, builder, bindingsHolder) {
        if (typeof value === "function") {
          return outputQuery(
            compileCallback(value, void 0, this, bindingsHolder),
            true,
            builder,
            this
          );
        }
        return unwrapRaw(value, true, builder, this, bindingsHolder) || "?";
      }
      // Turns a list of values into a list of ?'s, joining them with commas unless
      // a "joining" value is specified (e.g. ' and ')
      parameterize(values, notSetValue, builder, bindingsHolder) {
        if (typeof values === "function")
          return this.parameter(values, builder, bindingsHolder);
        values = Array.isArray(values) ? values : [values];
        let str = "", i = -1;
        while (++i < values.length) {
          if (i > 0) str += ", ";
          let value = values[i];
          if (isPlainObject4(value)) {
            value = JSON.stringify(value);
          }
          str += this.parameter(
            value === void 0 ? notSetValue : value,
            builder,
            bindingsHolder
          );
        }
        return str;
      }
      // Formats `values` into a parenthesized list of parameters for a `VALUES`
      // clause.
      //
      // [1, 2]                  -> '(?, ?)'
      // [[1, 2], [3, 4]]        -> '((?, ?), (?, ?))'
      // knex('table')           -> '(select * from "table")'
      // knex.raw('select ?', 1) -> '(select ?)'
      //
      values(values, builder, bindingsHolder) {
        if (Array.isArray(values)) {
          if (Array.isArray(values[0])) {
            return `(${values.map(
              (value) => `(${this.parameterize(
                value,
                void 0,
                builder,
                bindingsHolder
              )})`
            ).join(", ")})`;
          }
          return `(${this.parameterize(
            values,
            void 0,
            builder,
            bindingsHolder
          )})`;
        }
        if (values && values.isRawInstance) {
          return `(${this.parameter(values, builder, bindingsHolder)})`;
        }
        return this.parameter(values, builder, bindingsHolder);
      }
      processPassedConnection(connection) {
      }
      toPathForJson(jsonPath) {
        return jsonPath;
      }
    };
    Object.assign(Client2.prototype, {
      _escapeBinding: makeEscape({
        escapeString(str) {
          return `'${str.replace(/'/g, "''")}'`;
        }
      }),
      canCancelQuery: false
    });
    module2.exports = Client2;
  }
});

// node_modules/pg-connection-string/index.js
var require_pg_connection_string = __commonJS({
  "node_modules/pg-connection-string/index.js"(exports2, module2) {
    "use strict";
    function parse4(str) {
      if (str.charAt(0) === "/") {
        const config4 = str.split(" ");
        return { host: config4[0], database: config4[1] };
      }
      const config3 = {};
      let result;
      let dummyHost = false;
      if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str)) {
        str = encodeURI(str).replace(/\%25(\d\d)/g, "%$1");
      }
      try {
        result = new URL(str, "postgres://base");
      } catch (e) {
        result = new URL(str.replace("@/", "@___DUMMY___/"), "postgres://base");
        dummyHost = true;
      }
      for (const entry of result.searchParams.entries()) {
        config3[entry[0]] = entry[1];
      }
      config3.user = config3.user || decodeURIComponent(result.username);
      config3.password = config3.password || decodeURIComponent(result.password);
      if (result.protocol == "socket:") {
        config3.host = decodeURI(result.pathname);
        config3.database = result.searchParams.get("db");
        config3.client_encoding = result.searchParams.get("encoding");
        return config3;
      }
      const hostname4 = dummyHost ? "" : result.hostname;
      if (!config3.host) {
        config3.host = decodeURIComponent(hostname4);
      } else if (hostname4 && /^%2f/i.test(hostname4)) {
        result.pathname = hostname4 + result.pathname;
      }
      if (!config3.port) {
        config3.port = result.port;
      }
      const pathname = result.pathname.slice(1) || null;
      config3.database = pathname ? decodeURI(pathname) : null;
      if (config3.ssl === "true" || config3.ssl === "1") {
        config3.ssl = true;
      }
      if (config3.ssl === "0") {
        config3.ssl = false;
      }
      if (config3.sslcert || config3.sslkey || config3.sslrootcert || config3.sslmode) {
        config3.ssl = {};
      }
      const fs34 = config3.sslcert || config3.sslkey || config3.sslrootcert ? require("fs") : null;
      if (config3.sslcert) {
        config3.ssl.cert = fs34.readFileSync(config3.sslcert).toString();
      }
      if (config3.sslkey) {
        config3.ssl.key = fs34.readFileSync(config3.sslkey).toString();
      }
      if (config3.sslrootcert) {
        config3.ssl.ca = fs34.readFileSync(config3.sslrootcert).toString();
      }
      switch (config3.sslmode) {
        case "disable": {
          config3.ssl = false;
          break;
        }
        case "prefer":
        case "require":
        case "verify-ca":
        case "verify-full": {
          break;
        }
        case "no-verify": {
          config3.ssl.rejectUnauthorized = false;
          break;
        }
      }
      return config3;
    }
    module2.exports = parse4;
    parse4.parse = parse4;
  }
});

// node_modules/knex/lib/knex-builder/internal/parse-connection.js
var require_parse_connection = __commonJS({
  "node_modules/knex/lib/knex-builder/internal/parse-connection.js"(exports2, module2) {
    "use strict";
    var { parse: parse4 } = require_pg_connection_string();
    var parsePG = parse4;
    var isWindows = process && process.platform && process.platform === "win32";
    function tryParse(str) {
      try {
        return new URL(str);
      } catch (e) {
        return null;
      }
    }
    module2.exports = function parseConnectionString(str) {
      const parsed = tryParse(str);
      const isDriveLetter = isWindows && parsed && parsed.protocol.length === 2;
      if (!parsed || isDriveLetter) {
        return {
          client: "sqlite3",
          connection: {
            filename: str
          }
        };
      }
      let { protocol } = parsed;
      if (protocol.slice(-1) === ":") {
        protocol = protocol.slice(0, -1);
      }
      const isPG = ["postgresql", "postgres"].includes(protocol);
      return {
        client: protocol,
        connection: isPG ? parsePG(str) : connectionObject(parsed)
      };
    };
    function connectionObject(parsed) {
      const connection = {};
      let db2 = parsed.pathname;
      if (db2[0] === "/") {
        db2 = db2.slice(1);
      }
      connection.database = db2;
      if (parsed.hostname) {
        if (parsed.protocol.indexOf("mssql") === 0) {
          connection.server = parsed.hostname;
        } else {
          connection.host = parsed.hostname;
        }
      }
      if (parsed.port) {
        connection.port = parsed.port;
      }
      if (parsed.username || parsed.password) {
        connection.user = decodeURIComponent(parsed.username);
      }
      if (parsed.password) {
        connection.password = decodeURIComponent(parsed.password);
      }
      if (parsed.searchParams) {
        for (const [key, value] of parsed.searchParams.entries()) {
          const isNestedConfigSupported = ["mysql:", "mariadb:", "mssql:"].includes(
            parsed.protocol
          );
          if (isNestedConfigSupported) {
            try {
              connection[key] = JSON.parse(value);
            } catch (err) {
              connection[key] = value;
            }
          } else {
            connection[key] = value;
          }
        }
      }
      return connection;
    }
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/internal/sqlite-ddl-operations.js
var require_sqlite_ddl_operations = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/internal/sqlite-ddl-operations.js"(exports2, module2) {
    "use strict";
    function copyData(sourceTable, targetTable, columns) {
      return `INSERT INTO "${targetTable}" SELECT ${columns === void 0 ? "*" : columns.map((column) => `"${column}"`).join(", ")} FROM "${sourceTable}";`;
    }
    function dropOriginal(tableName) {
      return `DROP TABLE "${tableName}"`;
    }
    function renameTable(tableName, alteredName) {
      return `ALTER TABLE "${tableName}" RENAME TO "${alteredName}"`;
    }
    function getTableSql(tableName) {
      return `SELECT type, sql FROM sqlite_master WHERE (type='table' OR (type='index' AND sql IS NOT NULL)) AND lower(tbl_name)='${tableName.toLowerCase()}'`;
    }
    function isForeignCheckEnabled() {
      return `PRAGMA foreign_keys`;
    }
    function setForeignCheck(enable) {
      return `PRAGMA foreign_keys = ${enable ? "ON" : "OFF"}`;
    }
    function executeForeignCheck() {
      return `PRAGMA foreign_key_check`;
    }
    module2.exports = {
      copyData,
      dropOriginal,
      renameTable,
      getTableSql,
      isForeignCheckEnabled,
      setForeignCheck,
      executeForeignCheck
    };
  }
});

// node_modules/knex/lib/dialects/sqlite3/execution/sqlite-transaction.js
var require_sqlite_transaction = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/execution/sqlite-transaction.js"(exports2, module2) {
    "use strict";
    var Transaction = require_transaction();
    var {
      isForeignCheckEnabled,
      setForeignCheck,
      executeForeignCheck
    } = require_sqlite_ddl_operations();
    var Transaction_Sqlite = class extends Transaction {
      // Change the `foreign_keys` pragma if it doesn't match what we want it to be.
      // Return what it should be set to (if anything) when the transaction completes.
      async _setForeignCheck(conn, enforce) {
        if (enforce == null) return null;
        const result = await this.client.raw(isForeignCheckEnabled()).connection(conn);
        const isEnabled = result[0].foreign_keys === 1;
        if (enforce === isEnabled) return null;
        await this.client.raw(setForeignCheck(enforce)).connection(conn);
        return isEnabled;
      }
      // When a boolean is supplied, unconditionally set the `foreign_keys` pragma to
      // the given value. Otherwise do nothing.
      async _restoreForeignCheck(conn, enable) {
        if (typeof enable !== "boolean") return;
        await this.client.raw(setForeignCheck(enable)).connection(conn);
      }
      // Override Transaction's behavior. Sqlite3 will not error on a `pragma foreign_keys = <value>` statement
      // inside of a transaction; it will just silently not take effect: https://sqlite.org/pragma.html#pragma_foreign_keys
      // To deal with this, we introduce a config option "enforceForeignCheck". When set to a value, Transaction_Sqlite
      // ensures that the transaction received by the caller has this pragma enabled or disabled, and puts it back
      // when the transaction is done.
      async _evaluateContainer(config3, container) {
        const hasOuterTransaction = this.client.transacting;
        const strictForeignKeyPragma = this.client.strictForeignKeyPragma;
        const enforceForeignCheck = config3.enforceForeignCheck;
        if (strictForeignKeyPragma === true && enforceForeignCheck === void 0) {
          throw new Error(
            "Refusing to create an unsafe transaction: client.strictForeignKeyPragma is true, but check.enforceForeignCheck is unspecified"
          );
        }
        return this.acquireConnection(config3, async (conn) => {
          let restoreForeignCheck = void 0;
          try {
            restoreForeignCheck = await this._setForeignCheck(
              conn,
              enforceForeignCheck
            );
          } catch (e) {
            const error73 = new Error(
              `Refusing to create transaction: failed to set \`foreign_keys\` pragma to the required value of ${enforceForeignCheck}`
            );
            error73.cause = e;
            throw error73;
          }
          if (strictForeignKeyPragma && hasOuterTransaction && restoreForeignCheck != null) {
            throw new Error(
              `Refusing to create transaction: unable to change \`foreign_keys\` pragma inside a nested transaction`
            );
          }
          let maybeWrappedContainer = container;
          if (restoreForeignCheck === true) {
            maybeWrappedContainer = async (trx) => {
              const res = await container(trx);
              const foreignViolations = await this.client.raw(executeForeignCheck()).connection(conn);
              if (foreignViolations.length > 0) {
                throw new Error(
                  `Transaction concluded with ${foreignViolations.length} foreign key violations`
                );
              }
              return res;
            };
          }
          try {
            return await this._onAcquire(maybeWrappedContainer, conn);
          } finally {
            this._restoreForeignCheck(conn, restoreForeignCheck).catch((e) => {
              this._logAndDispose(
                conn,
                "Failed to restore foreign check to expected state",
                e
              );
            });
          }
        });
      }
      _logAndDispose(conn, message, cause) {
        const error73 = new Error(message);
        error73.cause = cause;
        conn.__knex__disposed = error73;
        this.client.logger.warn(
          `Transaction_Sqlite: ${message}:
${cause instanceof Error ? cause.message : String(cause)}`
        );
      }
      begin(conn) {
        if (this.isolationLevel) {
          this.client.logger.warn(
            "sqlite3 only supports serializable transactions, ignoring the isolation level param"
          );
        }
        if (this.readOnly) {
          this.client.logger.warn(
            "sqlite3 implicitly handles read vs write transactions"
          );
        }
        return this.query(conn, "BEGIN;");
      }
    };
    module2.exports = Transaction_Sqlite;
  }
});

// node_modules/knex/lib/dialects/sqlite3/query/sqlite-querycompiler.js
var require_sqlite_querycompiler = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/query/sqlite-querycompiler.js"(exports2, module2) {
    "use strict";
    var constant = require_constant();
    var each = require_each();
    var identity2 = require_identity();
    var isEmpty = require_isEmpty();
    var reduce = require_reduce();
    var QueryCompiler = require_querycompiler();
    var noop4 = require_noop();
    var { isString: isString2 } = require_is();
    var {
      wrapString,
      columnize: columnize_
    } = require_wrappingFormatter();
    var emptyStr = constant("");
    var QueryCompiler_SQLite3 = class extends QueryCompiler {
      constructor(client, builder, formatter) {
        super(client, builder, formatter);
        this.forShare = emptyStr;
        this.forKeyShare = emptyStr;
        this.forUpdate = emptyStr;
        this.forNoKeyUpdate = emptyStr;
      }
      // SQLite requires us to build the multi-row insert as a listing of select with
      // unions joining them together. So we'll build out this list of columns and
      // then join them all together with select unions to complete the queries.
      insert() {
        const insertValues = this.single.insert || [];
        let sql = this.with() + `insert into ${this.tableName} `;
        if (Array.isArray(insertValues)) {
          if (insertValues.length === 0) {
            return "";
          } else if (insertValues.length === 1 && insertValues[0] && isEmpty(insertValues[0])) {
            return {
              sql: sql + this._emptyInsertValue
            };
          }
        } else if (typeof insertValues === "object" && isEmpty(insertValues)) {
          return {
            sql: sql + this._emptyInsertValue
          };
        }
        const insertData = this._prepInsert(insertValues);
        if (isString2(insertData)) {
          return {
            sql: sql + insertData
          };
        }
        if (insertData.columns.length === 0) {
          return {
            sql: ""
          };
        }
        sql += `(${this.formatter.columnize(insertData.columns)})`;
        if (this.client.valueForUndefined !== null) {
          insertData.values.forEach((bindings) => {
            each(bindings, (binding) => {
              if (binding === void 0)
                throw new TypeError(
                  "`sqlite` does not support inserting default values. Specify values explicitly or use the `useNullAsDefault` config flag. (see docs https://knexjs.org/guide/query-builder.html#insert)."
                );
            });
          });
        }
        if (insertData.values.length === 1) {
          const parameters = this.client.parameterize(
            insertData.values[0],
            this.client.valueForUndefined,
            this.builder,
            this.bindingsHolder
          );
          sql += ` values (${parameters})`;
          const { onConflict: onConflict2, ignore: ignore2, merge: merge5 } = this.single;
          if (onConflict2 && ignore2) sql += this._ignore(onConflict2);
          else if (onConflict2 && merge5) {
            sql += this._merge(merge5.updates, onConflict2, insertValues);
            const wheres = this.where();
            if (wheres) sql += ` ${wheres}`;
          }
          const { returning: returning2 } = this.single;
          if (returning2) {
            sql += this._returning(returning2);
          }
          return {
            sql,
            returning: returning2
          };
        }
        const blocks = [];
        let i = -1;
        while (++i < insertData.values.length) {
          let i2 = -1;
          const block = blocks[i] = [];
          let current = insertData.values[i];
          current = current === void 0 ? this.client.valueForUndefined : current;
          while (++i2 < insertData.columns.length) {
            block.push(
              this.client.alias(
                this.client.parameter(
                  current[i2],
                  this.builder,
                  this.bindingsHolder
                ),
                this.formatter.wrap(insertData.columns[i2])
              )
            );
          }
          blocks[i] = block.join(", ");
        }
        sql += " select " + blocks.join(" union all select ");
        const { onConflict, ignore, merge: merge4 } = this.single;
        if (onConflict && ignore) sql += " where true" + this._ignore(onConflict);
        else if (onConflict && merge4) {
          sql += " where true" + this._merge(merge4.updates, onConflict, insertValues);
        }
        const { returning } = this.single;
        if (returning) sql += this._returning(returning);
        return {
          sql,
          returning
        };
      }
      // Compiles an `update` query, allowing for a return value.
      update() {
        const withSQL = this.with();
        const updateData = this._prepUpdate(this.single.update);
        const wheres = this.where();
        const { returning } = this.single;
        return {
          sql: withSQL + `update ${this.single.only ? "only " : ""}${this.tableName} set ${updateData.join(", ")}` + (wheres ? ` ${wheres}` : "") + this._returning(returning),
          returning
        };
      }
      _ignore(columns) {
        if (columns === true) {
          return " on conflict do nothing";
        }
        return ` on conflict ${this._onConflictClause(columns)} do nothing`;
      }
      _merge(updates, columns, insert) {
        let sql = ` on conflict ${this._onConflictClause(columns)} do update set `;
        if (updates && Array.isArray(updates)) {
          sql += updates.map(
            (column) => wrapString(
              column.split(".").pop(),
              this.formatter.builder,
              this.client,
              this.formatter
            )
          ).map((column) => `${column} = excluded.${column}`).join(", ");
          return sql;
        } else if (updates && typeof updates === "object") {
          const updateData = this._prepUpdate(updates);
          if (typeof updateData === "string") {
            sql += updateData;
          } else {
            sql += updateData.join(",");
          }
          return sql;
        } else {
          const insertData = this._prepInsert(insert);
          if (typeof insertData === "string") {
            throw new Error(
              "If using merge with a raw insert query, then updates must be provided"
            );
          }
          sql += insertData.columns.map(
            (column) => wrapString(column.split(".").pop(), this.builder, this.client)
          ).map((column) => `${column} = excluded.${column}`).join(", ");
          return sql;
        }
      }
      _returning(value) {
        return value ? ` returning ${this.formatter.columnize(value)}` : "";
      }
      // Compile a truncate table statement into SQL.
      truncate() {
        const { table } = this.single;
        return {
          sql: `delete from ${this.tableName}`,
          output() {
            return this.query({
              sql: `delete from sqlite_sequence where name = '${table}'`
            }).catch(noop4);
          }
        };
      }
      // Compiles a `columnInfo` query
      columnInfo() {
        const column = this.single.columnInfo;
        const table = this.client.customWrapIdentifier(this.single.table, identity2);
        return {
          sql: `PRAGMA table_info(\`${table}\`)`,
          output(resp) {
            const maxLengthRegex = /.*\((\d+)\)/;
            const out = reduce(
              resp,
              function(columns, val) {
                let { type } = val;
                let maxLength = type.match(maxLengthRegex);
                if (maxLength) {
                  maxLength = maxLength[1];
                }
                type = maxLength ? type.split("(")[0] : type;
                columns[val.name] = {
                  type: type.toLowerCase(),
                  maxLength,
                  nullable: !val.notnull,
                  defaultValue: val.dflt_value
                };
                return columns;
              },
              {}
            );
            return column && out[column] || out;
          }
        };
      }
      limit() {
        const noLimit = !this.single.limit && this.single.limit !== 0;
        if (noLimit && !this.single.offset) return "";
        this.single.limit = noLimit ? -1 : this.single.limit;
        return `limit ${this._getValueOrParameterFromAttribute("limit")}`;
      }
      // Json functions
      jsonExtract(params) {
        return this._jsonExtract("json_extract", params);
      }
      jsonSet(params) {
        return this._jsonSet("json_set", params);
      }
      jsonInsert(params) {
        return this._jsonSet("json_insert", params);
      }
      jsonRemove(params) {
        const jsonCol = `json_remove(${columnize_(
          params.column,
          this.builder,
          this.client,
          this.bindingsHolder
        )},${this.client.parameter(
          params.path,
          this.builder,
          this.bindingsHolder
        )})`;
        return params.alias ? this.client.alias(jsonCol, this.formatter.wrap(params.alias)) : jsonCol;
      }
      whereJsonPath(statement) {
        return this._whereJsonPath("json_extract", statement);
      }
      whereJsonSupersetOf(statement) {
        throw new Error(
          "Json superset where clause not actually supported by SQLite"
        );
      }
      whereJsonSubsetOf(statement) {
        throw new Error(
          "Json subset where clause not actually supported by SQLite"
        );
      }
      onJsonPathEquals(clause) {
        return this._onJsonPathEquals("json_extract", clause);
      }
      whereILike(statement) {
        return `${this._columnClause(statement)} ${this._not(
          statement,
          "like "
        )}${this._valueClause(statement)}`;
      }
    };
    module2.exports = QueryCompiler_SQLite3;
  }
});

// node_modules/lodash/_baseSome.js
var require_baseSome = __commonJS({
  "node_modules/lodash/_baseSome.js"(exports2, module2) {
    "use strict";
    var baseEach = require_baseEach();
    function baseSome(collection, predicate) {
      var result;
      baseEach(collection, function(value, index, collection2) {
        result = predicate(value, index, collection2);
        return !result;
      });
      return !!result;
    }
    module2.exports = baseSome;
  }
});

// node_modules/lodash/some.js
var require_some = __commonJS({
  "node_modules/lodash/some.js"(exports2, module2) {
    "use strict";
    var arraySome2 = require_arraySome();
    var baseIteratee2 = require_baseIteratee();
    var baseSome = require_baseSome();
    var isArray3 = require_isArray();
    var isIterateeCall = require_isIterateeCall();
    function some(collection, predicate, guard) {
      var func = isArray3(collection) ? arraySome2 : baseSome;
      if (guard && isIterateeCall(collection, predicate, guard)) {
        predicate = void 0;
      }
      return func(collection, baseIteratee2(predicate, 3));
    }
    module2.exports = some;
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/sqlite-compiler.js
var require_sqlite_compiler = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/sqlite-compiler.js"(exports2, module2) {
    "use strict";
    var SchemaCompiler = require_compiler();
    var some = require_some();
    var SchemaCompiler_SQLite3 = class extends SchemaCompiler {
      constructor(client, builder) {
        super(client, builder);
      }
      // Compile the query to determine if a table exists.
      hasTable(tableName) {
        const sql = `select * from sqlite_master where type = 'table' and name = ${this.client.parameter(
          this.formatter.wrap(tableName).replace(/`/g, ""),
          this.builder,
          this.bindingsHolder
        )}`;
        this.pushQuery({ sql, output: (resp) => resp.length > 0 });
      }
      // Compile the query to determine if a column exists.
      hasColumn(tableName, column) {
        this.pushQuery({
          sql: `PRAGMA table_info(${this.formatter.wrap(tableName)})`,
          output(resp) {
            return some(resp, (col) => {
              return this.client.wrapIdentifier(col.name.toLowerCase()) === this.client.wrapIdentifier(column.toLowerCase());
            });
          }
        });
      }
      // Compile a rename table command.
      renameTable(from, to) {
        this.pushQuery(
          `alter table ${this.formatter.wrap(from)} rename to ${this.formatter.wrap(
            to
          )}`
        );
      }
      async generateDdlCommands() {
        const sequence = this.builder._sequence;
        for (let i = 0, l = sequence.length; i < l; i++) {
          const query = sequence[i];
          this[query.method].apply(this, query.args);
        }
        const commandSources = this.sequence;
        if (commandSources.length === 1 && commandSources[0].statementsProducer) {
          return commandSources[0].statementsProducer();
        } else {
          const result = [];
          for (const commandSource of commandSources) {
            const command = commandSource.sql;
            if (Array.isArray(command)) {
              result.push(...command);
            } else {
              result.push(command);
            }
          }
          return { pre: [], sql: result, check: null, post: [] };
        }
      }
    };
    module2.exports = SchemaCompiler_SQLite3;
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/sqlite-columncompiler.js
var require_sqlite_columncompiler = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/sqlite-columncompiler.js"(exports2, module2) {
    "use strict";
    var ColumnCompiler = require_columncompiler();
    var ColumnCompiler_SQLite3 = class extends ColumnCompiler {
      constructor() {
        super(...arguments);
        this.modifiers = ["nullable", "defaultTo"];
        this._addCheckModifiers();
      }
      // Types
      // -------
      enu(allowed) {
        return `text check (${this.formatter.wrap(
          this.args[0]
        )} in ('${allowed.join("', '")}'))`;
      }
      _pushAlterCheckQuery(checkPredicate, constraintName) {
        throw new Error(
          `Alter table with to add constraints is not permitted in SQLite`
        );
      }
      checkRegex(regexes, constraintName) {
        return this._check(
          `${this.formatter.wrap(
            this.getColumnName()
          )} REGEXP ${this.client._escapeBinding(regexes)}`,
          constraintName
        );
      }
    };
    ColumnCompiler_SQLite3.prototype.json = "json";
    ColumnCompiler_SQLite3.prototype.jsonb = "json";
    ColumnCompiler_SQLite3.prototype.double = ColumnCompiler_SQLite3.prototype.decimal = ColumnCompiler_SQLite3.prototype.floating = "float";
    ColumnCompiler_SQLite3.prototype.timestamp = "datetime";
    ColumnCompiler_SQLite3.prototype.increments = ColumnCompiler_SQLite3.prototype.bigincrements = "integer not null primary key autoincrement";
    module2.exports = ColumnCompiler_SQLite3;
  }
});

// node_modules/lodash/filter.js
var require_filter = __commonJS({
  "node_modules/lodash/filter.js"(exports2, module2) {
    "use strict";
    var arrayFilter2 = require_arrayFilter();
    var baseFilter = require_baseFilter();
    var baseIteratee2 = require_baseIteratee();
    var isArray3 = require_isArray();
    function filter6(collection, predicate) {
      var func = isArray3(collection) ? arrayFilter2 : baseFilter;
      return func(collection, baseIteratee2(predicate, 3));
    }
    module2.exports = filter6;
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/sqlite-tablecompiler.js
var require_sqlite_tablecompiler = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/sqlite-tablecompiler.js"(exports2, module2) {
    "use strict";
    var filter6 = require_filter();
    var identity2 = require_identity();
    var { isObject: isObject5 } = require_is();
    var { normalizeArr } = require_helpers();
    var TableCompiler = require_tablecompiler();
    var { formatDefault } = require_formatterUtils();
    var TableCompiler_SQLite3 = class extends TableCompiler {
      constructor() {
        super(...arguments);
      }
      // Create a new table.
      createQuery(columns, ifNot, like) {
        const createStatement = ifNot ? "create table if not exists " : "create table ";
        let sql = createStatement + this.tableName();
        if (like && this.tableNameLike()) {
          sql += " as select * from " + this.tableNameLike() + " where 0=1";
        } else {
          sql += " (" + columns.sql.join(", ");
          sql += this.foreignKeys() || "";
          sql += this.primaryKeys() || "";
          sql += this._addChecks();
          sql += ")";
        }
        this.pushQuery(sql);
        if (like) {
          this.addColumns(columns, this.addColumnsPrefix);
        }
      }
      addColumns(columns, prefix, colCompilers) {
        if (prefix === this.alterColumnsPrefix) {
          const compiler = this;
          const columnsInfo = colCompilers.map((col) => {
            const name28 = this.client.customWrapIdentifier(
              col.getColumnName(),
              identity2,
              col.columnBuilder.queryContext()
            );
            const type = col.getColumnType();
            const defaultTo = col.modified["defaultTo"] ? formatDefault(col.modified["defaultTo"][0], col.type, this.client) : null;
            const notNull = col.modified["nullable"] && col.modified["nullable"][0] === false;
            return { name: name28, type, defaultTo, notNull };
          });
          this.pushQuery({
            sql: `PRAGMA table_info(${this.tableName()})`,
            statementsProducer(pragma, connection) {
              return compiler.client.ddl(compiler, pragma, connection).alterColumn(columnsInfo);
            }
          });
        } else {
          for (let i = 0, l = columns.sql.length; i < l; i++) {
            this.pushQuery({
              sql: `alter table ${this.tableName()} add column ${columns.sql[i]}`,
              bindings: columns.bindings[i]
            });
          }
        }
      }
      // Compile a drop unique key command.
      dropUnique(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        this.pushQuery(`drop index ${indexName}`);
      }
      // Compile a drop unique key command if one exists.
      dropUniqueIfExists(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        this.pushQuery(`drop index if exists ${indexName}`);
      }
      // Compile a drop foreign key command.
      dropForeign(columns, indexName) {
        const compiler = this;
        columns = Array.isArray(columns) ? columns : [columns];
        columns = columns.map(
          (column) => this.client.customWrapIdentifier(column, identity2)
        );
        indexName = this.client.customWrapIdentifier(indexName, identity2);
        this.pushQuery({
          sql: `PRAGMA table_info(${this.tableName()})`,
          output(pragma) {
            return compiler.client.ddl(compiler, pragma, this.connection).dropForeign(columns, indexName);
          }
        });
      }
      dropForeignIfExists() {
        throw new Error(".dropForeignIfExists is not supported for sqlite3");
      }
      // Compile a drop primary key command.
      dropPrimary(constraintName) {
        const compiler = this;
        constraintName = this.client.customWrapIdentifier(constraintName, identity2);
        this.pushQuery({
          sql: `PRAGMA table_info(${this.tableName()})`,
          output(pragma) {
            return compiler.client.ddl(compiler, pragma, this.connection).dropPrimary(constraintName);
          }
        });
      }
      dropPrimaryIfExists() {
        throw new Error(".dropPrimaryIfExists is not supported for sqlite3");
      }
      dropIndex(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        this.pushQuery(`drop index ${indexName}`);
      }
      // Compile a unique key command.
      unique(columns, indexName) {
        let deferrable;
        let predicate;
        if (isObject5(indexName)) {
          ({ indexName, deferrable, predicate } = indexName);
        }
        if (deferrable && deferrable !== "not deferrable") {
          this.client.logger.warn(
            `sqlite3: unique index \`${indexName}\` will not be deferrable ${deferrable} because sqlite3 does not support deferred constraints.`
          );
        }
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        columns = this.formatter.columnize(columns);
        const predicateQuery = predicate ? " " + this.client.queryCompiler(predicate).where() : "";
        this.pushQuery(
          `create unique index ${indexName} on ${this.tableName()} (${columns})${predicateQuery}`
        );
      }
      // Compile a plain index key command.
      index(columns, indexName, options) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        columns = this.formatter.columnize(columns);
        let predicate;
        if (isObject5(options)) {
          ({ predicate } = options);
        }
        const predicateQuery = predicate ? " " + this.client.queryCompiler(predicate).where() : "";
        this.pushQuery(
          `create index ${indexName} on ${this.tableName()} (${columns})${predicateQuery}`
        );
      }
      /**
       * Add a primary key to an existing table.
       *
       * @NOTE The `createQuery` method above handles table creation. Don't do anything regarding table
       *       creation in this method
       *
       * @param {string | string[]} columns - Column name(s) to assign as primary keys
       * @param {string} [constraintName] - Custom name for the PK constraint
       */
      primary(columns, constraintName) {
        const compiler = this;
        columns = Array.isArray(columns) ? columns : [columns];
        columns = columns.map(
          (column) => this.client.customWrapIdentifier(column, identity2)
        );
        let deferrable;
        if (isObject5(constraintName)) {
          ({ constraintName, deferrable } = constraintName);
        }
        if (deferrable && deferrable !== "not deferrable") {
          this.client.logger.warn(
            `sqlite3: primary key constraint \`${constraintName}\` will not be deferrable ${deferrable} because sqlite3 does not support deferred constraints.`
          );
        }
        constraintName = this.client.customWrapIdentifier(constraintName, identity2);
        if (this.method !== "create" && this.method !== "createIfNot") {
          this.pushQuery({
            sql: `PRAGMA table_info(${this.tableName()})`,
            output(pragma) {
              return compiler.client.ddl(compiler, pragma, this.connection).primary(columns, constraintName);
            }
          });
        }
      }
      /**
       * Add a foreign key constraint to an existing table
       *
       * @NOTE The `createQuery` method above handles foreign key constraints on table creation. Don't do
       *       anything regarding table creation in this method
       *
       * @param {object} foreignInfo - Information about the current column foreign setup
       * @param {string | string[]} [foreignInfo.column] - Column in the current constraint
       * @param {string | undefined} foreignInfo.keyName - Name of the foreign key constraint
       * @param {string | string[]} foreignInfo.references - What column it references in the other table
       * @param {string} foreignInfo.inTable - What table is referenced in this constraint
       * @param {string} [foreignInfo.onUpdate] - What to do on updates
       * @param {string} [foreignInfo.onDelete] - What to do on deletions
       */
      foreign(foreignInfo) {
        const compiler = this;
        if (this.method !== "create" && this.method !== "createIfNot") {
          foreignInfo.column = Array.isArray(foreignInfo.column) ? foreignInfo.column : [foreignInfo.column];
          foreignInfo.column = foreignInfo.column.map(
            (column) => this.client.customWrapIdentifier(column, identity2)
          );
          foreignInfo.inTable = this.client.customWrapIdentifier(
            foreignInfo.inTable,
            identity2
          );
          foreignInfo.references = Array.isArray(foreignInfo.references) ? foreignInfo.references : [foreignInfo.references];
          foreignInfo.references = foreignInfo.references.map(
            (column) => this.client.customWrapIdentifier(column, identity2)
          );
          this.pushQuery({
            sql: `PRAGMA table_info(${this.tableName()})`,
            statementsProducer(pragma, connection) {
              return compiler.client.ddl(compiler, pragma, connection).foreign(foreignInfo);
            }
          });
        }
      }
      primaryKeys() {
        const pks = filter6(this.grouped.alterTable || [], { method: "primary" });
        if (pks.length > 0 && pks[0].args.length > 0) {
          const columns = pks[0].args[0];
          let constraintName = pks[0].args[1] || "";
          if (constraintName) {
            constraintName = " constraint " + this.formatter.wrap(constraintName);
          }
          const needUniqueCols = this.grouped.columns.filter((t) => t.builder._type === "increments").length > 0;
          return `,${constraintName} ${needUniqueCols ? "unique" : "primary key"} (${this.formatter.columnize(columns)})`;
        }
      }
      foreignKeys() {
        let sql = "";
        const foreignKeys = filter6(this.grouped.alterTable || [], {
          method: "foreign"
        });
        for (let i = 0, l = foreignKeys.length; i < l; i++) {
          const foreign = foreignKeys[i].args[0];
          const column = this.formatter.columnize(foreign.column);
          const references = this.formatter.columnize(foreign.references);
          const foreignTable = this.formatter.wrap(foreign.inTable);
          let constraintName = foreign.keyName || "";
          if (constraintName) {
            constraintName = " constraint " + this.formatter.wrap(constraintName);
          }
          sql += `,${constraintName} foreign key(${column}) references ${foreignTable}(${references})`;
          if (foreign.onDelete) sql += ` on delete ${foreign.onDelete}`;
          if (foreign.onUpdate) sql += ` on update ${foreign.onUpdate}`;
        }
        return sql;
      }
      createTableBlock() {
        return this.getColumns().concat().join(",");
      }
      renameColumn(from, to) {
        this.pushQuery({
          sql: `alter table ${this.tableName()} rename ${this.formatter.wrap(
            from
          )} to ${this.formatter.wrap(to)}`
        });
      }
      _setNullableState(column, isNullable) {
        const compiler = this;
        this.pushQuery({
          sql: `PRAGMA table_info(${this.tableName()})`,
          statementsProducer(pragma, connection) {
            return compiler.client.ddl(compiler, pragma, connection).setNullable(column, isNullable);
          }
        });
      }
      dropColumn() {
        const compiler = this;
        const columns = normalizeArr(...arguments);
        const columnsWrapped = columns.map(
          (column) => this.client.customWrapIdentifier(column, identity2)
        );
        this.pushQuery({
          sql: `PRAGMA table_info(${this.tableName()})`,
          output(pragma) {
            return compiler.client.ddl(compiler, pragma, this.connection).dropColumn(columnsWrapped);
          }
        });
      }
    };
    module2.exports = TableCompiler_SQLite3;
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/sqlite-viewcompiler.js
var require_sqlite_viewcompiler = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/sqlite-viewcompiler.js"(exports2, module2) {
    "use strict";
    var ViewCompiler = require_viewcompiler();
    var {
      columnize: columnize_
    } = require_wrappingFormatter();
    var ViewCompiler_SQLite3 = class extends ViewCompiler {
      constructor(client, viewCompiler) {
        super(client, viewCompiler);
      }
      createOrReplace() {
        const columns = this.columns;
        const selectQuery = this.selectQuery.toString();
        const viewName = this.viewName();
        const columnList = columns ? " (" + columnize_(
          columns,
          this.viewBuilder,
          this.client,
          this.bindingsHolder
        ) + ")" : "";
        const dropSql = `drop view if exists ${viewName}`;
        const createSql = `create view ${viewName}${columnList} as ${selectQuery}`;
        this.pushQuery({
          sql: dropSql
        });
        this.pushQuery({
          sql: createSql
        });
      }
    };
    module2.exports = ViewCompiler_SQLite3;
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/internal/tokenizer.js
var require_tokenizer = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/internal/tokenizer.js"(exports2, module2) {
    "use strict";
    function tokenize(text2, tokens) {
      const compiledRegex = new RegExp(
        Object.entries(tokens).map(([type, regex]) => `(?<${type}>${regex.source})`).join("|"),
        "yi"
      );
      let index = 0;
      const ast = [];
      while (index < text2.length) {
        compiledRegex.lastIndex = index;
        const result = text2.match(compiledRegex);
        if (result !== null) {
          const [type, text3] = Object.entries(result.groups).find(
            ([name28, group]) => group !== void 0
          );
          index += text3.length;
          if (!type.startsWith("_")) {
            ast.push({ type, text: text3 });
          }
        } else {
          throw new Error(
            `No matching tokenizer rule found at: [${text2.substring(index)}]`
          );
        }
      }
      return ast;
    }
    module2.exports = {
      tokenize
    };
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/internal/parser-combinator.js
var require_parser_combinator = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/internal/parser-combinator.js"(exports2, module2) {
    "use strict";
    function s(sequence, post = (v) => v) {
      return function({ index = 0, input }) {
        let position = index;
        const ast = [];
        for (const parser of sequence) {
          const result = parser({ index: position, input });
          if (result.success) {
            position = result.index;
            ast.push(result.ast);
          } else {
            return result;
          }
        }
        return { success: true, ast: post(ast), index: position, input };
      };
    }
    function a(alternative, post = (v) => v) {
      return function({ index = 0, input }) {
        for (const parser of alternative) {
          const result = parser({ index, input });
          if (result.success) {
            return {
              success: true,
              ast: post(result.ast),
              index: result.index,
              input
            };
          }
        }
        return { success: false, ast: null, index, input };
      };
    }
    function m(many, post = (v) => v) {
      return function({ index = 0, input }) {
        let result = {};
        let position = index;
        const ast = [];
        do {
          result = many({ index: position, input });
          if (result.success) {
            position = result.index;
            ast.push(result.ast);
          }
        } while (result.success);
        if (ast.length > 0) {
          return { success: true, ast: post(ast), index: position, input };
        } else {
          return { success: false, ast: null, index: position, input };
        }
      };
    }
    function o(optional3, post = (v) => v) {
      return function({ index = 0, input }) {
        const result = optional3({ index, input });
        if (result.success) {
          return {
            success: true,
            ast: post(result.ast),
            index: result.index,
            input
          };
        } else {
          return { success: true, ast: post(null), index, input };
        }
      };
    }
    function l(lookahead, post = (v) => v) {
      return function({ index = 0, input }) {
        const result = lookahead.do({ index, input });
        if (result.success) {
          const resultNext = lookahead.next({ index: result.index, input });
          if (resultNext.success) {
            return {
              success: true,
              ast: post(result.ast),
              index: result.index,
              input
            };
          }
        }
        return { success: false, ast: null, index, input };
      };
    }
    function n(negative, post = (v) => v) {
      return function({ index = 0, input }) {
        const result = negative.do({ index, input });
        if (result.success) {
          const resultNot = negative.not({ index, input });
          if (!resultNot.success) {
            return {
              success: true,
              ast: post(result.ast),
              index: result.index,
              input
            };
          }
        }
        return { success: false, ast: null, index, input };
      };
    }
    function t(token, post = (v) => v.text) {
      return function({ index = 0, input }) {
        const result = input[index];
        if (result !== void 0 && (token.type === void 0 || token.type === result.type) && (token.text === void 0 || token.text.toUpperCase() === result.text.toUpperCase())) {
          return {
            success: true,
            ast: post(result),
            index: index + 1,
            input
          };
        } else {
          return { success: false, ast: null, index, input };
        }
      };
    }
    var e = function({ index = 0, input }) {
      return { success: true, ast: null, index, input };
    };
    var f = function({ index = 0, input }) {
      return { success: index === input.length, ast: null, index, input };
    };
    module2.exports = { s, a, m, o, l, n, t, e, f };
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/internal/parser.js
var require_parser = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/internal/parser.js"(exports2, module2) {
    "use strict";
    var { tokenize } = require_tokenizer();
    var { s, a, m, o, l, n, t, e, f } = require_parser_combinator();
    var TOKENS = {
      keyword: /(?:ABORT|ACTION|ADD|AFTER|ALL|ALTER|ALWAYS|ANALYZE|AND|AS|ASC|ATTACH|AUTOINCREMENT|BEFORE|BEGIN|BETWEEN|BY|CASCADE|CASE|CAST|CHECK|COLLATE|COLUMN|COMMIT|CONFLICT|CONSTRAINT|CREATE|CROSS|CURRENT|CURRENT_DATE|CURRENT_TIME|CURRENT_TIMESTAMP|DATABASE|DEFAULT|DEFERRED|DEFERRABLE|DELETE|DESC|DETACH|DISTINCT|DO|DROP|END|EACH|ELSE|ESCAPE|EXCEPT|EXCLUSIVE|EXCLUDE|EXISTS|EXPLAIN|FAIL|FILTER|FIRST|FOLLOWING|FOR|FOREIGN|FROM|FULL|GENERATED|GLOB|GROUP|GROUPS|HAVING|IF|IGNORE|IMMEDIATE|IN|INDEX|INDEXED|INITIALLY|INNER|INSERT|INSTEAD|INTERSECT|INTO|IS|ISNULL|JOIN|KEY|LAST|LEFT|LIKE|LIMIT|MATCH|MATERIALIZED|NATURAL|NO|NOT|NOTHING|NOTNULL|NULL|NULLS|OF|OFFSET|ON|OR|ORDER|OTHERS|OUTER|OVER|PARTITION|PLAN|PRAGMA|PRECEDING|PRIMARY|QUERY|RAISE|RANGE|RECURSIVE|REFERENCES|REGEXP|REINDEX|RELEASE|RENAME|REPLACE|RESTRICT|RETURNING|RIGHT|ROLLBACK|ROW|ROWS|SAVEPOINT|SELECT|SET|TABLE|TEMP|TEMPORARY|THEN|TIES|TO|TRANSACTION|TRIGGER|UNBOUNDED|UNION|UNIQUE|UPDATE|USING|VACUUM|VALUES|VIEW|VIRTUAL|WHEN|WHERE|WINDOW|WITH|WITHOUT)(?=\s+|-|\(|\)|;|\+|\*|\/|%|==|=|<=|<>|<<|<|>=|>>|>|!=|,|&|~|\|\||\||\.)/,
      id: /"[^"]*(?:""[^"]*)*"|`[^`]*(?:``[^`]*)*`|\[[^[\]]*\]|[a-z_][a-z0-9_$]*/,
      string: /'[^']*(?:''[^']*)*'/,
      blob: /x'(?:[0-9a-f][0-9a-f])+'/,
      numeric: /(?:\d+(?:\.\d*)?|\.\d+)(?:e(?:\+|-)?\d+)?|0x[0-9a-f]+/,
      variable: /\?\d*|[@$:][a-z0-9_$]+/,
      operator: /-|\(|\)|;|\+|\*|\/|%|==|=|<=|<>|<<|<|>=|>>|>|!=|,|&|~|\|\||\||\./,
      _ws: /\s+/
    };
    function parseCreateTable(sql) {
      const result = createTable({ input: tokenize(sql, TOKENS) });
      if (!result.success) {
        throw new Error(
          `Parsing CREATE TABLE failed at [${result.input.slice(result.index).map((t2) => t2.text).join(" ")}] of "${sql}"`
        );
      }
      return result.ast;
    }
    function parseCreateIndex(sql) {
      const result = createIndex({ input: tokenize(sql, TOKENS) });
      if (!result.success) {
        throw new Error(
          `Parsing CREATE INDEX failed at [${result.input.slice(result.index).map((t2) => t2.text).join(" ")}] of "${sql}"`
        );
      }
      return result.ast;
    }
    function createTable(ctx) {
      return s(
        [
          t({ text: "CREATE" }, (v) => null),
          temporary,
          t({ text: "TABLE" }, (v) => null),
          exists,
          schema,
          table,
          t({ text: "(" }, (v) => null),
          columnDefinitionList,
          tableConstraintList,
          t({ text: ")" }, (v) => null),
          rowid,
          f
        ],
        (v) => Object.assign({}, ...v.filter((x) => x !== null))
      )(ctx);
    }
    function temporary(ctx) {
      return a([t({ text: "TEMP" }), t({ text: "TEMPORARY" }), e], (v) => ({
        temporary: v !== null
      }))(ctx);
    }
    function rowid(ctx) {
      return o(s([t({ text: "WITHOUT" }), t({ text: "ROWID" })]), (v) => ({
        rowid: v !== null
      }))(ctx);
    }
    function columnDefinitionList(ctx) {
      return a([
        s([columnDefinition, t({ text: "," }), columnDefinitionList], (v) => ({
          columns: [v[0]].concat(v[2].columns)
        })),
        s([columnDefinition], (v) => ({ columns: [v[0]] }))
      ])(ctx);
    }
    function columnDefinition(ctx) {
      return s(
        [s([identifier], (v) => ({ name: v[0] })), typeName, columnConstraintList],
        (v) => Object.assign({}, ...v)
      )(ctx);
    }
    function typeName(ctx) {
      return o(
        s(
          [
            m(t({ type: "id" })),
            a([
              s(
                [
                  t({ text: "(" }),
                  signedNumber,
                  t({ text: "," }),
                  signedNumber,
                  t({ text: ")" })
                ],
                (v) => `(${v[1]}, ${v[3]})`
              ),
              s(
                [t({ text: "(" }), signedNumber, t({ text: ")" })],
                (v) => `(${v[1]})`
              ),
              e
            ])
          ],
          (v) => `${v[0].join(" ")}${v[1] || ""}`
        ),
        (v) => ({ type: v })
      )(ctx);
    }
    function columnConstraintList(ctx) {
      return o(m(columnConstraint), (v) => ({
        constraints: Object.assign(
          {
            primary: null,
            notnull: null,
            null: null,
            unique: null,
            check: null,
            default: null,
            collate: null,
            references: null,
            as: null
          },
          ...v || []
        )
      }))(ctx);
    }
    function columnConstraint(ctx) {
      return a([
        primaryColumnConstraint,
        notnullColumnConstraint,
        nullColumnConstraint,
        uniqueColumnConstraint,
        checkColumnConstraint,
        defaultColumnConstraint,
        collateColumnConstraint,
        referencesColumnConstraint,
        asColumnConstraint
      ])(ctx);
    }
    function primaryColumnConstraint(ctx) {
      return s(
        [
          constraintName,
          t({ text: "PRIMARY" }, (v) => null),
          t({ text: "KEY" }, (v) => null),
          order,
          conflictClause,
          autoincrement
        ],
        (v) => ({ primary: Object.assign({}, ...v.filter((x) => x !== null)) })
      )(ctx);
    }
    function autoincrement(ctx) {
      return o(t({ text: "AUTOINCREMENT" }), (v) => ({
        autoincrement: v !== null
      }))(ctx);
    }
    function notnullColumnConstraint(ctx) {
      return s(
        [
          constraintName,
          t({ text: "NOT" }, (v) => null),
          t({ text: "NULL" }, (v) => null),
          conflictClause
        ],
        (v) => ({ notnull: Object.assign({}, ...v.filter((x) => x !== null)) })
      )(ctx);
    }
    function nullColumnConstraint(ctx) {
      return s(
        [constraintName, t({ text: "NULL" }, (v) => null), conflictClause],
        (v) => ({ null: Object.assign({}, ...v.filter((x) => x !== null)) })
      )(ctx);
    }
    function uniqueColumnConstraint(ctx) {
      return s(
        [constraintName, t({ text: "UNIQUE" }, (v) => null), conflictClause],
        (v) => ({ unique: Object.assign({}, ...v.filter((x) => x !== null)) })
      )(ctx);
    }
    function checkColumnConstraint(ctx) {
      return s(
        [
          constraintName,
          t({ text: "CHECK" }, (v) => null),
          t({ text: "(" }, (v) => null),
          s([expression], (v) => ({ expression: v[0] })),
          t({ text: ")" }, (v) => null)
        ],
        (v) => ({ check: Object.assign({}, ...v.filter((x) => x !== null)) })
      )(ctx);
    }
    function defaultColumnConstraint(ctx) {
      return s(
        [
          constraintName,
          t({ text: "DEFAULT" }, (v) => null),
          a([
            s([t({ text: "(" }), expression, t({ text: ")" })], (v) => ({
              value: v[1],
              expression: true
            })),
            s([literalValue], (v) => ({ value: v[0], expression: false })),
            s([signedNumber], (v) => ({ value: v[0], expression: false }))
          ])
        ],
        (v) => ({ default: Object.assign({}, ...v.filter((x) => x !== null)) })
      )(ctx);
    }
    function collateColumnConstraint(ctx) {
      return s(
        [
          constraintName,
          t({ text: "COLLATE" }, (v) => null),
          t({ type: "id" }, (v) => ({ collation: v.text }))
        ],
        (v) => ({ collate: Object.assign({}, ...v.filter((x) => x !== null)) })
      )(ctx);
    }
    function referencesColumnConstraint(ctx) {
      return s(
        [constraintName, s([foreignKeyClause], (v) => v[0].references)],
        (v) => ({
          references: Object.assign({}, ...v.filter((x) => x !== null))
        })
      )(ctx);
    }
    function asColumnConstraint(ctx) {
      return s(
        [
          constraintName,
          o(s([t({ text: "GENERATED" }), t({ text: "ALWAYS" })]), (v) => ({
            generated: v !== null
          })),
          t({ text: "AS" }, (v) => null),
          t({ text: "(" }, (v) => null),
          s([expression], (v) => ({ expression: v[0] })),
          t({ text: ")" }, (v) => null),
          a([t({ text: "STORED" }), t({ text: "VIRTUAL" }), e], (v) => ({
            mode: v ? v.toUpperCase() : null
          }))
        ],
        (v) => ({ as: Object.assign({}, ...v.filter((x) => x !== null)) })
      )(ctx);
    }
    function tableConstraintList(ctx) {
      return o(m(s([t({ text: "," }), tableConstraint], (v) => v[1])), (v) => ({
        constraints: v || []
      }))(ctx);
    }
    function tableConstraint(ctx) {
      return a([
        primaryTableConstraint,
        uniqueTableConstraint,
        checkTableConstraint,
        foreignTableConstraint
      ])(ctx);
    }
    function primaryTableConstraint(ctx) {
      return s(
        [
          constraintName,
          t({ text: "PRIMARY" }, (v) => null),
          t({ text: "KEY" }, (v) => null),
          t({ text: "(" }, (v) => null),
          indexedColumnList,
          t({ text: ")" }, (v) => null),
          conflictClause
        ],
        (v) => Object.assign({ type: "PRIMARY KEY" }, ...v.filter((x) => x !== null))
      )(ctx);
    }
    function uniqueTableConstraint(ctx) {
      return s(
        [
          constraintName,
          t({ text: "UNIQUE" }, (v) => null),
          t({ text: "(" }, (v) => null),
          indexedColumnList,
          t({ text: ")" }, (v) => null),
          conflictClause
        ],
        (v) => Object.assign({ type: "UNIQUE" }, ...v.filter((x) => x !== null))
      )(ctx);
    }
    function conflictClause(ctx) {
      return o(
        s(
          [
            t({ text: "ON" }),
            t({ text: "CONFLICT" }),
            a([
              t({ text: "ROLLBACK" }),
              t({ text: "ABORT" }),
              t({ text: "FAIL" }),
              t({ text: "IGNORE" }),
              t({ text: "REPLACE" })
            ])
          ],
          (v) => v[2]
        ),
        (v) => ({ conflict: v ? v.toUpperCase() : null })
      )(ctx);
    }
    function checkTableConstraint(ctx) {
      return s(
        [
          constraintName,
          t({ text: "CHECK" }, (v) => null),
          t({ text: "(" }, (v) => null),
          s([expression], (v) => ({ expression: v[0] })),
          t({ text: ")" }, (v) => null)
        ],
        (v) => Object.assign({ type: "CHECK" }, ...v.filter((x) => x !== null))
      )(ctx);
    }
    function foreignTableConstraint(ctx) {
      return s(
        [
          constraintName,
          t({ text: "FOREIGN" }, (v) => null),
          t({ text: "KEY" }, (v) => null),
          t({ text: "(" }, (v) => null),
          columnNameList,
          t({ text: ")" }, (v) => null),
          foreignKeyClause
        ],
        (v) => Object.assign({ type: "FOREIGN KEY" }, ...v.filter((x) => x !== null))
      )(ctx);
    }
    function foreignKeyClause(ctx) {
      return s(
        [
          t({ text: "REFERENCES" }, (v) => null),
          table,
          columnNameListOptional,
          o(
            m(a([deleteReference, updateReference, matchReference])),
            (v) => Object.assign({ delete: null, update: null, match: null }, ...v || [])
          ),
          deferrable
        ],
        (v) => ({ references: Object.assign({}, ...v.filter((x) => x !== null)) })
      )(ctx);
    }
    function columnNameListOptional(ctx) {
      return o(
        s([t({ text: "(" }), columnNameList, t({ text: ")" })], (v) => v[1]),
        (v) => ({ columns: v ? v.columns : [] })
      )(ctx);
    }
    function columnNameList(ctx) {
      return s(
        [
          o(
            m(s([identifier, t({ text: "," })], (v) => v[0])),
            (v) => v !== null ? v : []
          ),
          identifier
        ],
        (v) => ({ columns: v[0].concat([v[1]]) })
      )(ctx);
    }
    function deleteReference(ctx) {
      return s([t({ text: "ON" }), t({ text: "DELETE" }), onAction], (v) => ({
        delete: v[2]
      }))(ctx);
    }
    function updateReference(ctx) {
      return s([t({ text: "ON" }), t({ text: "UPDATE" }), onAction], (v) => ({
        update: v[2]
      }))(ctx);
    }
    function matchReference(ctx) {
      return s(
        [t({ text: "MATCH" }), a([t({ type: "keyword" }), t({ type: "id" })])],
        (v) => ({ match: v[1] })
      )(ctx);
    }
    function deferrable(ctx) {
      return o(
        s([
          o(t({ text: "NOT" })),
          t({ text: "DEFERRABLE" }),
          o(
            s(
              [
                t({ text: "INITIALLY" }),
                a([t({ text: "DEFERRED" }), t({ text: "IMMEDIATE" })])
              ],
              (v) => v[1].toUpperCase()
            )
          )
        ]),
        (v) => ({ deferrable: v ? { not: v[0] !== null, initially: v[2] } : null })
      )(ctx);
    }
    function constraintName(ctx) {
      return o(
        s([t({ text: "CONSTRAINT" }), identifier], (v) => v[1]),
        (v) => ({ name: v })
      )(ctx);
    }
    function createIndex(ctx) {
      return s(
        [
          t({ text: "CREATE" }, (v) => null),
          unique,
          t({ text: "INDEX" }, (v) => null),
          exists,
          schema,
          index,
          t({ text: "ON" }, (v) => null),
          table,
          t({ text: "(" }, (v) => null),
          indexedColumnList,
          t({ text: ")" }, (v) => null),
          where,
          f
        ],
        (v) => Object.assign({}, ...v.filter((x) => x !== null))
      )(ctx);
    }
    function unique(ctx) {
      return o(t({ text: "UNIQUE" }), (v) => ({ unique: v !== null }))(ctx);
    }
    function exists(ctx) {
      return o(
        s([t({ text: "IF" }), t({ text: "NOT" }), t({ text: "EXISTS" })]),
        (v) => ({ exists: v !== null })
      )(ctx);
    }
    function schema(ctx) {
      return o(
        s([identifier, t({ text: "." })], (v) => v[0]),
        (v) => ({ schema: v })
      )(ctx);
    }
    function index(ctx) {
      return s([identifier], (v) => ({ index: v[0] }))(ctx);
    }
    function table(ctx) {
      return s([identifier], (v) => ({ table: v[0] }))(ctx);
    }
    function where(ctx) {
      return o(
        s([t({ text: "WHERE" }), expression], (v) => v[1]),
        (v) => ({ where: v })
      )(ctx);
    }
    function indexedColumnList(ctx) {
      return a([
        s([indexedColumn, t({ text: "," }), indexedColumnList], (v) => ({
          columns: [v[0]].concat(v[2].columns)
        })),
        s([indexedColumnExpression, t({ text: "," }), indexedColumnList], (v) => ({
          columns: [v[0]].concat(v[2].columns)
        })),
        l({ do: indexedColumn, next: t({ text: ")" }) }, (v) => ({
          columns: [v]
        })),
        l({ do: indexedColumnExpression, next: t({ text: ")" }) }, (v) => ({
          columns: [v]
        }))
      ])(ctx);
    }
    function indexedColumn(ctx) {
      return s(
        [
          s([identifier], (v) => ({ name: v[0], expression: false })),
          collation,
          order
        ],
        (v) => Object.assign({}, ...v.filter((x) => x !== null))
      )(ctx);
    }
    function indexedColumnExpression(ctx) {
      return s(
        [
          s([indexedExpression], (v) => ({ name: v[0], expression: true })),
          collation,
          order
        ],
        (v) => Object.assign({}, ...v.filter((x) => x !== null))
      )(ctx);
    }
    function collation(ctx) {
      return o(
        s([t({ text: "COLLATE" }), t({ type: "id" })], (v) => v[1]),
        (v) => ({ collation: v })
      )(ctx);
    }
    function order(ctx) {
      return a([t({ text: "ASC" }), t({ text: "DESC" }), e], (v) => ({
        order: v ? v.toUpperCase() : null
      }))(ctx);
    }
    function indexedExpression(ctx) {
      return m(
        a([
          n({
            do: t({ type: "keyword" }),
            not: a([
              t({ text: "COLLATE" }),
              t({ text: "ASC" }),
              t({ text: "DESC" })
            ])
          }),
          t({ type: "id" }),
          t({ type: "string" }),
          t({ type: "blob" }),
          t({ type: "numeric" }),
          t({ type: "variable" }),
          n({
            do: t({ type: "operator" }),
            not: a([t({ text: "(" }), t({ text: ")" }), t({ text: "," })])
          }),
          s([t({ text: "(" }), o(expression), t({ text: ")" })], (v) => v[1] || [])
        ])
      )(ctx);
    }
    function expression(ctx) {
      return m(
        a([
          t({ type: "keyword" }),
          t({ type: "id" }),
          t({ type: "string" }),
          t({ type: "blob" }),
          t({ type: "numeric" }),
          t({ type: "variable" }),
          n({
            do: t({ type: "operator" }),
            not: a([t({ text: "(" }), t({ text: ")" })])
          }),
          s([t({ text: "(" }), o(expression), t({ text: ")" })], (v) => v[1] || [])
        ])
      )(ctx);
    }
    function identifier(ctx) {
      return a(
        [t({ type: "id" }), t({ type: "string" })],
        (v) => /^["`['][^]*["`\]']$/.test(v) ? v.substring(1, v.length - 1) : v
      )(ctx);
    }
    function onAction(ctx) {
      return a(
        [
          s([t({ text: "SET" }), t({ text: "NULL" })], (v) => `${v[0]} ${v[1]}`),
          s([t({ text: "SET" }), t({ text: "DEFAULT" })], (v) => `${v[0]} ${v[1]}`),
          t({ text: "CASCADE" }),
          t({ text: "RESTRICT" }),
          s([t({ text: "NO" }), t({ text: "ACTION" })], (v) => `${v[0]} ${v[1]}`)
        ],
        (v) => v.toUpperCase()
      )(ctx);
    }
    function literalValue(ctx) {
      return a([
        t({ type: "numeric" }),
        t({ type: "string" }),
        t({ type: "id" }),
        t({ type: "blob" }),
        t({ text: "NULL" }),
        t({ text: "TRUE" }),
        t({ text: "FALSE" }),
        t({ text: "CURRENT_TIME" }),
        t({ text: "CURRENT_DATE" }),
        t({ text: "CURRENT_TIMESTAMP" })
      ])(ctx);
    }
    function signedNumber(ctx) {
      return s(
        [a([t({ text: "+" }), t({ text: "-" }), e]), t({ type: "numeric" })],
        (v) => `${v[0] || ""}${v[1]}`
      )(ctx);
    }
    module2.exports = {
      parseCreateTable,
      parseCreateIndex
    };
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/internal/compiler.js
var require_compiler2 = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/internal/compiler.js"(exports2, module2) {
    "use strict";
    function compileCreateTable(ast, wrap = (v) => v) {
      return createTable(ast, wrap);
    }
    function compileCreateIndex(ast, wrap = (v) => v) {
      return createIndex(ast, wrap);
    }
    function createTable(ast, wrap) {
      return `CREATE${temporary(ast, wrap)} TABLE${exists(ast, wrap)} ${schema(
        ast,
        wrap
      )}${table(ast, wrap)} (${columnDefinitionList(
        ast,
        wrap
      )}${tableConstraintList(ast, wrap)})${rowid(ast, wrap)}`;
    }
    function temporary(ast, wrap) {
      return ast.temporary ? " TEMP" : "";
    }
    function rowid(ast, wrap) {
      return ast.rowid ? " WITHOUT ROWID" : "";
    }
    function columnDefinitionList(ast, wrap) {
      return ast.columns.map((column) => columnDefinition(column, wrap)).join(", ");
    }
    function columnDefinition(ast, wrap) {
      return `${identifier(ast.name, wrap)}${typeName(
        ast,
        wrap
      )}${columnConstraintList(ast.constraints, wrap)}`;
    }
    function typeName(ast, wrap) {
      return ast.type !== null ? ` ${ast.type}` : "";
    }
    function columnConstraintList(ast, wrap) {
      return `${primaryColumnConstraint(ast, wrap)}${notnullColumnConstraint(
        ast,
        wrap
      )}${nullColumnConstraint(ast, wrap)}${uniqueColumnConstraint(
        ast,
        wrap
      )}${checkColumnConstraint(ast, wrap)}${defaultColumnConstraint(
        ast,
        wrap
      )}${collateColumnConstraint(ast, wrap)}${referencesColumnConstraint(
        ast,
        wrap
      )}${asColumnConstraint(ast, wrap)}`;
    }
    function primaryColumnConstraint(ast, wrap) {
      return ast.primary !== null ? ` ${constraintName(ast.primary, wrap)}PRIMARY KEY${order(
        ast.primary,
        wrap
      )}${conflictClause(ast.primary, wrap)}${autoincrement(ast.primary, wrap)}` : "";
    }
    function autoincrement(ast, wrap) {
      return ast.autoincrement ? " AUTOINCREMENT" : "";
    }
    function notnullColumnConstraint(ast, wrap) {
      return ast.notnull !== null ? ` ${constraintName(ast.notnull, wrap)}NOT NULL${conflictClause(
        ast.notnull,
        wrap
      )}` : "";
    }
    function nullColumnConstraint(ast, wrap) {
      return ast.null !== null ? ` ${constraintName(ast.null, wrap)}NULL${conflictClause(ast.null, wrap)}` : "";
    }
    function uniqueColumnConstraint(ast, wrap) {
      return ast.unique !== null ? ` ${constraintName(ast.unique, wrap)}UNIQUE${conflictClause(
        ast.unique,
        wrap
      )}` : "";
    }
    function checkColumnConstraint(ast, wrap) {
      return ast.check !== null ? ` ${constraintName(ast.check, wrap)}CHECK (${expression(
        ast.check.expression,
        wrap
      )})` : "";
    }
    function defaultColumnConstraint(ast, wrap) {
      return ast.default !== null ? ` ${constraintName(ast.default, wrap)}DEFAULT ${!ast.default.expression ? ast.default.value : `(${expression(ast.default.value, wrap)})`}` : "";
    }
    function collateColumnConstraint(ast, wrap) {
      return ast.collate !== null ? ` ${constraintName(ast.collate, wrap)}COLLATE ${ast.collate.collation}` : "";
    }
    function referencesColumnConstraint(ast, wrap) {
      return ast.references !== null ? ` ${constraintName(ast.references, wrap)}${foreignKeyClause(
        ast.references,
        wrap
      )}` : "";
    }
    function asColumnConstraint(ast, wrap) {
      return ast.as !== null ? ` ${constraintName(ast.as, wrap)}${ast.as.generated ? "GENERATED ALWAYS " : ""}AS (${expression(ast.as.expression, wrap)})${ast.as.mode !== null ? ` ${ast.as.mode}` : ""}` : "";
    }
    function tableConstraintList(ast, wrap) {
      return ast.constraints.reduce(
        (constraintList, constraint) => `${constraintList}, ${tableConstraint(constraint, wrap)}`,
        ""
      );
    }
    function tableConstraint(ast, wrap) {
      switch (ast.type) {
        case "PRIMARY KEY":
          return primaryTableConstraint(ast, wrap);
        case "UNIQUE":
          return uniqueTableConstraint(ast, wrap);
        case "CHECK":
          return checkTableConstraint(ast, wrap);
        case "FOREIGN KEY":
          return foreignTableConstraint(ast, wrap);
      }
    }
    function primaryTableConstraint(ast, wrap) {
      return `${constraintName(ast, wrap)}PRIMARY KEY (${indexedColumnList(
        ast,
        wrap
      )})${conflictClause(ast, wrap)}`;
    }
    function uniqueTableConstraint(ast, wrap) {
      return `${constraintName(ast, wrap)}UNIQUE (${indexedColumnList(
        ast,
        wrap
      )})${conflictClause(ast, wrap)}`;
    }
    function conflictClause(ast, wrap) {
      return ast.conflict !== null ? ` ON CONFLICT ${ast.conflict}` : "";
    }
    function checkTableConstraint(ast, wrap) {
      return `${constraintName(ast, wrap)}CHECK (${expression(
        ast.expression,
        wrap
      )})`;
    }
    function foreignTableConstraint(ast, wrap) {
      return `${constraintName(ast, wrap)}FOREIGN KEY (${columnNameList(
        ast,
        wrap
      )}) ${foreignKeyClause(ast.references, wrap)}`;
    }
    function foreignKeyClause(ast, wrap) {
      return `REFERENCES ${table(ast, wrap)}${columnNameListOptional(
        ast,
        wrap
      )}${deleteUpdateMatchList(ast, wrap)}${deferrable(ast.deferrable, wrap)}`;
    }
    function columnNameListOptional(ast, wrap) {
      return ast.columns.length > 0 ? ` (${columnNameList(ast, wrap)})` : "";
    }
    function columnNameList(ast, wrap) {
      return ast.columns.map((column) => identifier(column, wrap)).join(", ");
    }
    function deleteUpdateMatchList(ast, wrap) {
      return `${deleteReference(ast, wrap)}${updateReference(
        ast,
        wrap
      )}${matchReference(ast, wrap)}`;
    }
    function deleteReference(ast, wrap) {
      return ast.delete !== null ? ` ON DELETE ${ast.delete}` : "";
    }
    function updateReference(ast, wrap) {
      return ast.update !== null ? ` ON UPDATE ${ast.update}` : "";
    }
    function matchReference(ast, wrap) {
      return ast.match !== null ? ` MATCH ${ast.match}` : "";
    }
    function deferrable(ast, wrap) {
      return ast !== null ? ` ${ast.not ? "NOT " : ""}DEFERRABLE${ast.initially !== null ? ` INITIALLY ${ast.initially}` : ""}` : "";
    }
    function constraintName(ast, wrap) {
      return ast.name !== null ? `CONSTRAINT ${identifier(ast.name, wrap)} ` : "";
    }
    function createIndex(ast, wrap) {
      return `CREATE${unique(ast, wrap)} INDEX${exists(ast, wrap)} ${schema(
        ast,
        wrap
      )}${index(ast, wrap)} on ${table(ast, wrap)} (${indexedColumnList(
        ast,
        wrap
      )})${where(ast, wrap)}`;
    }
    function unique(ast, wrap) {
      return ast.unique ? " UNIQUE" : "";
    }
    function exists(ast, wrap) {
      return ast.exists ? " IF NOT EXISTS" : "";
    }
    function schema(ast, wrap) {
      return ast.schema !== null ? `${identifier(ast.schema, wrap)}.` : "";
    }
    function index(ast, wrap) {
      return identifier(ast.index, wrap);
    }
    function table(ast, wrap) {
      return identifier(ast.table, wrap);
    }
    function where(ast, wrap) {
      return ast.where !== null ? ` where ${expression(ast.where)}` : "";
    }
    function indexedColumnList(ast, wrap) {
      return ast.columns.map(
        (column) => !column.expression ? indexedColumn(column, wrap) : indexedColumnExpression(column, wrap)
      ).join(", ");
    }
    function indexedColumn(ast, wrap) {
      return `${identifier(ast.name, wrap)}${collation(ast, wrap)}${order(
        ast,
        wrap
      )}`;
    }
    function indexedColumnExpression(ast, wrap) {
      return `${indexedExpression(ast.name, wrap)}${collation(ast, wrap)}${order(
        ast,
        wrap
      )}`;
    }
    function collation(ast, wrap) {
      return ast.collation !== null ? ` COLLATE ${ast.collation}` : "";
    }
    function order(ast, wrap) {
      return ast.order !== null ? ` ${ast.order}` : "";
    }
    function indexedExpression(ast, wrap) {
      return expression(ast, wrap);
    }
    function expression(ast, wrap) {
      return ast.reduce(
        (expr, e) => Array.isArray(e) ? `${expr}(${expression(e)})` : !expr ? e : `${expr} ${e}`,
        ""
      );
    }
    function identifier(ast, wrap) {
      return wrap(ast);
    }
    module2.exports = {
      compileCreateTable,
      compileCreateIndex
    };
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/internal/utils.js
var require_utils9 = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/internal/utils.js"(exports2, module2) {
    "use strict";
    function isEqualId(first, second) {
      return first.toLowerCase() === second.toLowerCase();
    }
    function includesId(list2, id) {
      return list2.some((item) => isEqualId(item, id));
    }
    module2.exports = {
      isEqualId,
      includesId
    };
  }
});

// node_modules/knex/lib/dialects/sqlite3/schema/ddl.js
var require_ddl = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/schema/ddl.js"(exports2, module2) {
    "use strict";
    var identity2 = require_identity();
    var { nanonum } = require_nanoid();
    var {
      copyData,
      dropOriginal,
      renameTable,
      getTableSql,
      isForeignCheckEnabled,
      setForeignCheck,
      executeForeignCheck
    } = require_sqlite_ddl_operations();
    var { parseCreateTable, parseCreateIndex } = require_parser();
    var {
      compileCreateTable,
      compileCreateIndex
    } = require_compiler2();
    var { isEqualId, includesId } = require_utils9();
    var SQLite3_DDL = class {
      constructor(client, tableCompiler, pragma, connection) {
        this.client = client;
        this.tableCompiler = tableCompiler;
        this.pragma = pragma;
        this.tableNameRaw = this.tableCompiler.tableNameRaw;
        this.alteredName = `_knex_temp_alter${nanonum(3)}`;
        this.connection = connection;
        this.formatter = (value) => this.client.customWrapIdentifier(value, identity2);
        this.wrap = (value) => this.client.wrapIdentifierImpl(value);
      }
      tableName() {
        return this.formatter(this.tableNameRaw);
      }
      getTableSql() {
        const tableName = this.tableName();
        return this.client.transaction(
          async (trx) => {
            trx.disableProcessing();
            const result = await trx.raw(getTableSql(tableName));
            trx.enableProcessing();
            return {
              createTable: result.filter((create) => create.type === "table")[0].sql,
              createIndices: result.filter((create) => create.type === "index").map((create) => create.sql)
            };
          },
          { connection: this.connection, enforceForeignCheck: null }
        );
      }
      async isForeignCheckEnabled() {
        const result = await this.client.raw(isForeignCheckEnabled()).connection(this.connection);
        return result[0].foreign_keys === 1;
      }
      async setForeignCheck(enable) {
        await this.client.raw(setForeignCheck(enable)).connection(this.connection);
      }
      renameTable(trx) {
        return trx.raw(renameTable(this.alteredName, this.tableName()));
      }
      dropOriginal(trx) {
        return trx.raw(dropOriginal(this.tableName()));
      }
      copyData(trx, columns) {
        return trx.raw(copyData(this.tableName(), this.alteredName, columns));
      }
      async alterColumn(columns) {
        const { createTable, createIndices } = await this.getTableSql();
        const parsedTable = parseCreateTable(createTable);
        parsedTable.table = this.alteredName;
        parsedTable.columns = parsedTable.columns.map((column) => {
          const newColumnInfo = columns.find((c) => isEqualId(c.name, column.name));
          if (newColumnInfo) {
            column.type = newColumnInfo.type;
            column.constraints.default = newColumnInfo.defaultTo !== null ? {
              name: null,
              value: newColumnInfo.defaultTo,
              expression: false
            } : null;
            column.constraints.notnull = newColumnInfo.notNull ? { name: null, conflict: null } : null;
            column.constraints.null = newColumnInfo.notNull ? null : column.constraints.null;
          }
          return column;
        });
        const newTable = compileCreateTable(parsedTable, this.wrap);
        return this.generateAlterCommands(newTable, createIndices);
      }
      async dropColumn(columns) {
        const { createTable, createIndices } = await this.getTableSql();
        const parsedTable = parseCreateTable(createTable);
        parsedTable.table = this.alteredName;
        parsedTable.columns = parsedTable.columns.filter(
          (parsedColumn) => parsedColumn.expression || !includesId(columns, parsedColumn.name)
        );
        if (parsedTable.columns.length === 0) {
          throw new Error("Unable to drop last column from table");
        }
        parsedTable.constraints = parsedTable.constraints.filter((constraint) => {
          if (constraint.type === "PRIMARY KEY" || constraint.type === "UNIQUE") {
            return constraint.columns.every(
              (constraintColumn) => constraintColumn.expression || !includesId(columns, constraintColumn.name)
            );
          } else if (constraint.type === "FOREIGN KEY") {
            return constraint.columns.every(
              (constraintColumnName) => !includesId(columns, constraintColumnName)
            ) && (constraint.references.table !== parsedTable.table || constraint.references.columns.every(
              (referenceColumnName) => !includesId(columns, referenceColumnName)
            ));
          } else {
            return true;
          }
        });
        const newColumns = parsedTable.columns.map((column) => column.name);
        const newTable = compileCreateTable(parsedTable, this.wrap);
        const newIndices = [];
        for (const createIndex of createIndices) {
          const parsedIndex = parseCreateIndex(createIndex);
          parsedIndex.columns = parsedIndex.columns.filter(
            (parsedColumn) => parsedColumn.expression || !includesId(columns, parsedColumn.name)
          );
          if (parsedIndex.columns.length > 0) {
            newIndices.push(compileCreateIndex(parsedIndex, this.wrap));
          }
        }
        return this.alter(newTable, newIndices, newColumns);
      }
      async dropForeign(columns, foreignKeyName) {
        const { createTable, createIndices } = await this.getTableSql();
        const parsedTable = parseCreateTable(createTable);
        parsedTable.table = this.alteredName;
        if (!foreignKeyName) {
          parsedTable.columns = parsedTable.columns.map((column) => ({
            ...column,
            references: includesId(columns, column.name) ? null : column.references
          }));
        }
        parsedTable.constraints = parsedTable.constraints.filter((constraint) => {
          if (constraint.type === "FOREIGN KEY") {
            if (foreignKeyName) {
              return !constraint.name || !isEqualId(constraint.name, foreignKeyName);
            }
            return constraint.columns.every(
              (constraintColumnName) => !includesId(columns, constraintColumnName)
            );
          } else {
            return true;
          }
        });
        const newTable = compileCreateTable(parsedTable, this.wrap);
        return this.alter(newTable, createIndices);
      }
      async dropPrimary(constraintName) {
        const { createTable, createIndices } = await this.getTableSql();
        const parsedTable = parseCreateTable(createTable);
        parsedTable.table = this.alteredName;
        parsedTable.columns = parsedTable.columns.map((column) => ({
          ...column,
          primary: null
        }));
        parsedTable.constraints = parsedTable.constraints.filter((constraint) => {
          if (constraint.type === "PRIMARY KEY") {
            if (constraintName) {
              return !constraint.name || !isEqualId(constraint.name, constraintName);
            } else {
              return false;
            }
          } else {
            return true;
          }
        });
        const newTable = compileCreateTable(parsedTable, this.wrap);
        return this.alter(newTable, createIndices);
      }
      async primary(columns, constraintName) {
        const { createTable, createIndices } = await this.getTableSql();
        const parsedTable = parseCreateTable(createTable);
        parsedTable.table = this.alteredName;
        parsedTable.columns = parsedTable.columns.map((column) => ({
          ...column,
          primary: null
        }));
        parsedTable.constraints = parsedTable.constraints.filter(
          (constraint) => constraint.type !== "PRIMARY KEY"
        );
        parsedTable.constraints.push({
          type: "PRIMARY KEY",
          name: constraintName || null,
          columns: columns.map((column) => ({
            name: column,
            expression: false,
            collation: null,
            order: null
          })),
          conflict: null
        });
        const newTable = compileCreateTable(parsedTable, this.wrap);
        return this.alter(newTable, createIndices);
      }
      async foreign(foreignInfo) {
        const { createTable, createIndices } = await this.getTableSql();
        const parsedTable = parseCreateTable(createTable);
        parsedTable.table = this.alteredName;
        parsedTable.constraints.push({
          type: "FOREIGN KEY",
          name: foreignInfo.keyName || null,
          columns: foreignInfo.column,
          references: {
            table: foreignInfo.inTable,
            columns: foreignInfo.references,
            delete: foreignInfo.onDelete || null,
            update: foreignInfo.onUpdate || null,
            match: null,
            deferrable: null
          }
        });
        const newTable = compileCreateTable(parsedTable, this.wrap);
        return this.generateAlterCommands(newTable, createIndices);
      }
      async setNullable(column, isNullable) {
        const { createTable, createIndices } = await this.getTableSql();
        const parsedTable = parseCreateTable(createTable);
        parsedTable.table = this.alteredName;
        const parsedColumn = parsedTable.columns.find(
          (c) => isEqualId(column, c.name)
        );
        if (!parsedColumn) {
          throw new Error(
            `.setNullable: Column ${column} does not exist in table ${this.tableName()}.`
          );
        }
        parsedColumn.constraints.notnull = isNullable ? null : { name: null, conflict: null };
        parsedColumn.constraints.null = isNullable ? parsedColumn.constraints.null : null;
        const newTable = compileCreateTable(parsedTable, this.wrap);
        return this.generateAlterCommands(newTable, createIndices);
      }
      async alter(newSql, createIndices, columns) {
        const enforceForeignCheck = this.client.transacting ? null : false;
        await this.client.transaction(
          async (trx) => {
            await trx.raw(newSql);
            await this.copyData(trx, columns);
            await this.dropOriginal(trx);
            await this.renameTable(trx);
            for (const createIndex of createIndices) {
              await trx.raw(createIndex);
            }
          },
          { connection: this.connection, enforceForeignCheck }
        );
      }
      async generateAlterCommands(newSql, createIndices, columns) {
        const sql = [];
        const pre = [];
        const post = [];
        let check3 = null;
        sql.push(newSql);
        sql.push(copyData(this.tableName(), this.alteredName, columns));
        sql.push(dropOriginal(this.tableName()));
        sql.push(renameTable(this.alteredName, this.tableName()));
        for (const createIndex of createIndices) {
          sql.push(createIndex);
        }
        const isForeignCheckEnabled2 = await this.isForeignCheckEnabled();
        if (isForeignCheckEnabled2) {
          pre.push(setForeignCheck(false));
          post.push(setForeignCheck(true));
          check3 = executeForeignCheck();
        }
        return { pre, sql, check: check3, post };
      }
    };
    module2.exports = SQLite3_DDL;
  }
});

// node_modules/knex/lib/dialects/sqlite3/query/sqlite-querybuilder.js
var require_sqlite_querybuilder = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/query/sqlite-querybuilder.js"(exports2, module2) {
    "use strict";
    var QueryBuilder = require_querybuilder();
    module2.exports = class QueryBuilder_SQLite3 extends QueryBuilder {
      withMaterialized(alias, statementOrColumnList, nothingOrStatement) {
        this._validateWithArgs(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          "with"
        );
        return this.withWrapped(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          true
        );
      }
      withNotMaterialized(alias, statementOrColumnList, nothingOrStatement) {
        this._validateWithArgs(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          "with"
        );
        return this.withWrapped(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          false
        );
      }
    };
  }
});

// node_modules/knex/lib/dialects/sqlite3/index.js
var require_sqlite3 = __commonJS({
  "node_modules/knex/lib/dialects/sqlite3/index.js"(exports2, module2) {
    "use strict";
    var defaults2 = require_defaults();
    var map3 = require_map();
    var { promisify: promisify2 } = require("util");
    var Client2 = require_client2();
    var Raw = require_raw2();
    var Transaction_Sqlite = require_sqlite_transaction();
    var SqliteQueryCompiler = require_sqlite_querycompiler();
    var SchemaCompiler = require_sqlite_compiler();
    var ColumnCompiler = require_sqlite_columncompiler();
    var TableCompiler = require_sqlite_tablecompiler();
    var ViewCompiler = require_sqlite_viewcompiler();
    var SQLite3_DDL = require_ddl();
    var Formatter = require_formatter();
    var QueryBuilder = require_sqlite_querybuilder();
    var Client_SQLite3 = class extends Client2 {
      constructor(config3) {
        super(config3);
        if (config3.connection && config3.connection.filename === void 0) {
          this.logger.warn(
            "Could not find `connection.filename` in config. Please specify the database path and name to avoid errors. (see docs https://knexjs.org/guide/#configuration-options)"
          );
        }
        if (config3.useNullAsDefault === void 0) {
          this.logger.warn(
            "sqlite does not support inserting default values. Set the `useNullAsDefault` flag to hide this warning. (see docs https://knexjs.org/guide/query-builder.html#insert)."
          );
        }
        this.strictForeignKeyPragma = false;
      }
      _driver() {
        return require("sqlite3");
      }
      /** @returns {Client_SQLite3 & {strictForeignKeyPragma: true}} */
      _strict() {
        const strictClient = Object.create(this);
        strictClient.strictForeignKeyPragma = true;
        strictClient.transaction = strictClient.transaction.bind(strictClient);
        return strictClient;
      }
      schemaCompiler() {
        return new SchemaCompiler(this, ...arguments);
      }
      transaction() {
        return new Transaction_Sqlite(this, ...arguments);
      }
      queryCompiler(builder, formatter) {
        return new SqliteQueryCompiler(this, builder, formatter);
      }
      queryBuilder() {
        return new QueryBuilder(this);
      }
      viewCompiler(builder, formatter) {
        return new ViewCompiler(this, builder, formatter);
      }
      columnCompiler() {
        return new ColumnCompiler(this, ...arguments);
      }
      tableCompiler() {
        return new TableCompiler(this, ...arguments);
      }
      ddl(compiler, pragma, connection) {
        return new SQLite3_DDL(this._strict(), compiler, pragma, connection);
      }
      wrapIdentifierImpl(value) {
        return value !== "*" ? `\`${value.replace(/`/g, "``")}\`` : "*";
      }
      // Get a raw connection from the database, returning a promise with the connection object.
      acquireRawConnection() {
        return new Promise((resolve3, reject) => {
          let flags = this.driver.OPEN_READWRITE | this.driver.OPEN_CREATE;
          if (this.connectionSettings.flags) {
            if (!Array.isArray(this.connectionSettings.flags)) {
              throw new Error(`flags must be an array of strings`);
            }
            this.connectionSettings.flags.forEach((_flag) => {
              if (!_flag.startsWith("OPEN_") || !this.driver[_flag]) {
                throw new Error(`flag ${_flag} not supported by node-sqlite3`);
              }
              flags = flags | this.driver[_flag];
            });
          }
          const db2 = new this.driver.Database(
            this.connectionSettings.filename,
            flags,
            (err) => {
              if (err) {
                return reject(err);
              }
              resolve3(db2);
            }
          );
        });
      }
      // Used to explicitly close a connection, called internally by the pool when
      // a connection times out or the pool is shutdown.
      async destroyRawConnection(connection) {
        const close = promisify2((cb) => connection.close(cb));
        return close();
      }
      // Runs the query on the specified connection, providing the bindings and any
      // other necessary prep work.
      _query(connection, obj) {
        if (!obj.sql) throw new Error("The query is empty");
        const { method } = obj;
        let callMethod;
        switch (method) {
          case "insert":
          case "update":
            callMethod = obj.returning ? "all" : "run";
            break;
          case "counter":
          case "del":
            callMethod = "run";
            break;
          default:
            callMethod = "all";
        }
        return new Promise(function(resolver, rejecter) {
          if (!connection || !connection[callMethod]) {
            return rejecter(
              new Error(`Error calling ${callMethod} on connection.`)
            );
          }
          connection[callMethod](obj.sql, obj.bindings, function(err, response) {
            if (err) return rejecter(err);
            obj.response = response;
            obj.context = this;
            return resolver(obj);
          });
        });
      }
      _stream(connection, obj, stream4) {
        if (!obj.sql) throw new Error("The query is empty");
        const client = this;
        return new Promise(function(resolver, rejecter) {
          stream4.on("error", rejecter);
          stream4.on("end", resolver);
          return client._query(connection, obj).then((obj2) => obj2.response).then((rows) => rows.forEach((row) => stream4.write(row))).catch(function(err) {
            stream4.emit("error", err);
          }).then(function() {
            stream4.end();
          });
        });
      }
      // Ensures the response is returned in the same format as other clients.
      processResponse(obj, runner) {
        const ctx = obj.context;
        const { response, returning } = obj;
        if (obj.output) return obj.output.call(runner, response);
        switch (obj.method) {
          case "select":
            return response;
          case "first":
            return response[0];
          case "pluck":
            return map3(response, obj.pluck);
          case "insert": {
            if (returning) {
              if (response) {
                return response;
              }
            }
            return [ctx.lastID];
          }
          case "update": {
            if (returning) {
              if (response) {
                return response;
              }
            }
            return ctx.changes;
          }
          case "del":
          case "counter":
            return ctx.changes;
          default: {
            return response;
          }
        }
      }
      poolDefaults() {
        return defaults2({ min: 1, max: 1 }, super.poolDefaults());
      }
      formatter(builder) {
        return new Formatter(this, builder);
      }
      values(values, builder, formatter) {
        if (Array.isArray(values)) {
          if (Array.isArray(values[0])) {
            return `( values ${values.map(
              (value) => `(${this.parameterize(value, void 0, builder, formatter)})`
            ).join(", ")})`;
          }
          return `(${this.parameterize(values, void 0, builder, formatter)})`;
        }
        if (values instanceof Raw) {
          return `(${this.parameter(values, builder, formatter)})`;
        }
        return this.parameter(values, builder, formatter);
      }
    };
    Object.assign(Client_SQLite3.prototype, {
      dialect: "sqlite3",
      driverName: "sqlite3"
    });
    module2.exports = Client_SQLite3;
  }
});

// node_modules/knex/lib/dialects/better-sqlite3/index.js
var require_better_sqlite3 = __commonJS({
  "node_modules/knex/lib/dialects/better-sqlite3/index.js"(exports2, module2) {
    "use strict";
    var Client_SQLite3 = require_sqlite3();
    var Client_BetterSQLite3 = class extends Client_SQLite3 {
      _driver() {
        return require("better-sqlite3");
      }
      // Get a raw connection from the database, returning a promise with the connection object.
      async acquireRawConnection() {
        const options = this.connectionSettings.options || {};
        const db2 = new this.driver(this.connectionSettings.filename, {
          nativeBinding: options.nativeBinding,
          readonly: !!options.readonly
        });
        const safeIntegers = this._optSafeIntegers(options);
        if (safeIntegers !== void 0) {
          db2.defaultSafeIntegers(safeIntegers);
        }
        return db2;
      }
      // Used to explicitly close a connection, called internally by the pool when
      // a connection times out or the pool is shutdown.
      async destroyRawConnection(connection) {
        return connection.close();
      }
      // Runs the query on the specified connection, providing the bindings and any
      // other necessary prep work.
      async _query(connection, obj) {
        if (!obj.sql) throw new Error("The query is empty");
        if (!connection) {
          throw new Error("No connection provided");
        }
        const statement = connection.prepare(obj.sql);
        const safeIntegers = this._optSafeIntegers(obj.options);
        if (safeIntegers !== void 0) {
          statement.safeIntegers(safeIntegers);
        }
        const bindings = this._formatBindings(obj.bindings);
        if (statement.reader) {
          const response2 = await statement.all(bindings);
          obj.response = response2;
          return obj;
        }
        const response = await statement.run(bindings);
        obj.response = response;
        obj.context = {
          lastID: response.lastInsertRowid,
          changes: response.changes
        };
        return obj;
      }
      _formatBindings(bindings) {
        if (!bindings) {
          return [];
        }
        return bindings.map((binding) => {
          if (binding instanceof Date) {
            return binding.valueOf();
          }
          if (typeof binding === "boolean") {
            return Number(binding);
          }
          return binding;
        });
      }
      _optSafeIntegers(options) {
        if (options && typeof options === "object" && typeof options.safeIntegers === "boolean") {
          return options.safeIntegers;
        }
        return void 0;
      }
    };
    Object.assign(Client_BetterSQLite3.prototype, {
      // The "dialect", for reference .
      driverName: "better-sqlite3"
    });
    module2.exports = Client_BetterSQLite3;
  }
});

// node_modules/knex/lib/dialects/postgres/execution/pg-transaction.js
var require_pg_transaction = __commonJS({
  "node_modules/knex/lib/dialects/postgres/execution/pg-transaction.js"(exports2, module2) {
    "use strict";
    var Transaction = require_transaction();
    var Transaction_PG = class extends Transaction {
      begin(conn) {
        const trxMode = [
          this.isolationLevel ? `ISOLATION LEVEL ${this.isolationLevel}` : "",
          this.readOnly ? "READ ONLY" : ""
        ].join(" ").trim();
        if (trxMode.length === 0) {
          return this.query(conn, "BEGIN;");
        }
        return this.query(conn, `BEGIN TRANSACTION ${trxMode};`);
      }
    };
    module2.exports = Transaction_PG;
  }
});

// node_modules/knex/lib/dialects/postgres/query/pg-querycompiler.js
var require_pg_querycompiler = __commonJS({
  "node_modules/knex/lib/dialects/postgres/query/pg-querycompiler.js"(exports2, module2) {
    "use strict";
    var identity2 = require_identity();
    var reduce = require_reduce();
    var QueryCompiler = require_querycompiler();
    var {
      wrapString,
      columnize: columnize_,
      operator: operator_,
      wrap: wrap_
    } = require_wrappingFormatter();
    var QueryCompiler_PG = class extends QueryCompiler {
      constructor(client, builder, formatter) {
        super(client, builder, formatter);
        this._defaultInsertValue = "default";
      }
      // Compiles a truncate query.
      truncate() {
        return `truncate ${this.tableName} restart identity`;
      }
      // is used if the an array with multiple empty values supplied
      // Compiles an `insert` query, allowing for multiple
      // inserts using a single query statement.
      insert() {
        let sql = super.insert();
        if (sql === "") return sql;
        const { returning, onConflict, ignore, merge: merge4, insert } = this.single;
        if (onConflict && ignore) sql += this._ignore(onConflict);
        if (onConflict && merge4) {
          sql += this._merge(merge4.updates, onConflict, insert);
          const wheres = this.where();
          if (wheres) sql += ` ${wheres}`;
        }
        if (returning) sql += this._returning(returning);
        return {
          sql,
          returning
        };
      }
      // Compiles an `update` query, allowing for a return value.
      update() {
        const withSQL = this.with();
        const updateData = this._prepUpdate(this.single.update);
        const wheres = this.where();
        const { returning, updateFrom } = this.single;
        return {
          sql: withSQL + `update ${this.single.only ? "only " : ""}${this.tableName} set ${updateData.join(", ")}` + this._updateFrom(updateFrom) + (wheres ? ` ${wheres}` : "") + this._returning(returning),
          returning
        };
      }
      using() {
        const usingTables = this.single.using;
        if (!usingTables) return;
        let sql = "using ";
        if (Array.isArray(usingTables)) {
          sql += usingTables.map((table) => {
            return this.formatter.wrap(table);
          }).join(",");
        } else {
          sql += this.formatter.wrap(usingTables);
        }
        return sql;
      }
      // Compiles an `delete` query, allowing for a return value.
      del() {
        const { tableName } = this;
        const withSQL = this.with();
        let wheres = this.where() || "";
        let using = this.using() || "";
        const joins = this.grouped.join;
        const tableJoins = [];
        if (Array.isArray(joins)) {
          for (const join2 of joins) {
            tableJoins.push(
              wrap_(
                this._joinTable(join2),
                void 0,
                this.builder,
                this.client,
                this.bindingsHolder
              )
            );
            const joinWheres = [];
            for (const clause of join2.clauses) {
              joinWheres.push(
                this.whereBasic({
                  column: clause.column,
                  operator: "=",
                  value: clause.value,
                  asColumn: true
                })
              );
            }
            if (joinWheres.length > 0) {
              wheres += (wheres ? " and " : "where ") + joinWheres.join(" and ");
            }
          }
          if (tableJoins.length > 0) {
            using += (using ? "," : "using ") + tableJoins.join(",");
          }
        }
        const sql = withSQL + `delete from ${this.single.only ? "only " : ""}${tableName}` + (using ? ` ${using}` : "") + (wheres ? ` ${wheres}` : "");
        const { returning } = this.single;
        return {
          sql: sql + this._returning(returning),
          returning
        };
      }
      aggregate(stmt) {
        return this._aggregate(stmt, { distinctParentheses: true });
      }
      _returning(value) {
        return value ? ` returning ${this.formatter.columnize(value)}` : "";
      }
      _updateFrom(name28) {
        return name28 ? ` from ${this.formatter.wrap(name28)}` : "";
      }
      _ignore(columns) {
        if (columns === true) {
          return " on conflict do nothing";
        }
        return ` on conflict ${this._onConflictClause(columns)} do nothing`;
      }
      _merge(updates, columns, insert) {
        let sql = ` on conflict ${this._onConflictClause(columns)} do update set `;
        if (updates && Array.isArray(updates)) {
          sql += updates.map(
            (column) => wrapString(
              column.split(".").pop(),
              this.formatter.builder,
              this.client,
              this.formatter
            )
          ).map((column) => `${column} = excluded.${column}`).join(", ");
          return sql;
        } else if (updates && typeof updates === "object") {
          const updateData = this._prepUpdate(updates);
          if (typeof updateData === "string") {
            sql += updateData;
          } else {
            sql += updateData.join(",");
          }
          return sql;
        } else {
          const insertData = this._prepInsert(insert);
          if (typeof insertData === "string") {
            throw new Error(
              "If using merge with a raw insert query, then updates must be provided"
            );
          }
          sql += insertData.columns.map(
            (column) => wrapString(column.split(".").pop(), this.builder, this.client)
          ).map((column) => `${column} = excluded.${column}`).join(", ");
          return sql;
        }
      }
      // Join array of table names and apply default schema.
      _tableNames(tables) {
        const schemaName = this.single.schema;
        const sql = [];
        for (let i = 0; i < tables.length; i++) {
          let tableName = tables[i];
          if (tableName) {
            if (schemaName) {
              tableName = `${schemaName}.${tableName}`;
            }
            sql.push(this.formatter.wrap(tableName));
          }
        }
        return sql.join(", ");
      }
      _lockingClause(lockMode) {
        const tables = this.single.lockTables || [];
        return lockMode + (tables.length ? " of " + this._tableNames(tables) : "");
      }
      _groupOrder(item, type) {
        return super._groupOrderNulls(item, type);
      }
      forUpdate() {
        return this._lockingClause("for update");
      }
      forShare() {
        return this._lockingClause("for share");
      }
      forNoKeyUpdate() {
        return this._lockingClause("for no key update");
      }
      forKeyShare() {
        return this._lockingClause("for key share");
      }
      skipLocked() {
        return "skip locked";
      }
      noWait() {
        return "nowait";
      }
      // Compiles a columnInfo query
      columnInfo() {
        const column = this.single.columnInfo;
        let schema = this.single.schema;
        const table = this.client.customWrapIdentifier(this.single.table, identity2);
        if (schema) {
          schema = this.client.customWrapIdentifier(schema, identity2);
        }
        const sql = "select * from information_schema.columns where table_name = ? and table_catalog = current_database()";
        const bindings = [table];
        return this._buildColumnInfoQuery(schema, sql, bindings, column);
      }
      _buildColumnInfoQuery(schema, sql, bindings, column) {
        if (schema) {
          sql += " and table_schema = ?";
          bindings.push(schema);
        } else {
          sql += " and table_schema = current_schema()";
        }
        return {
          sql,
          bindings,
          output(resp) {
            const out = reduce(
              resp.rows,
              function(columns, val) {
                columns[val.column_name] = {
                  type: val.data_type,
                  maxLength: val.character_maximum_length,
                  nullable: val.is_nullable === "YES",
                  defaultValue: val.column_default
                };
                return columns;
              },
              {}
            );
            return column && out[column] || out;
          }
        };
      }
      distinctOn(value) {
        return "distinct on (" + this.formatter.columnize(value) + ") ";
      }
      // Json functions
      jsonExtract(params) {
        return this._jsonExtract("jsonb_path_query", params);
      }
      jsonSet(params) {
        return this._jsonSet(
          "jsonb_set",
          Object.assign({}, params, {
            path: this.client.toPathForJson(params.path)
          })
        );
      }
      jsonInsert(params) {
        return this._jsonSet(
          "jsonb_insert",
          Object.assign({}, params, {
            path: this.client.toPathForJson(params.path)
          })
        );
      }
      jsonRemove(params) {
        const jsonCol = `${columnize_(
          params.column,
          this.builder,
          this.client,
          this.bindingsHolder
        )} #- ${this.client.parameter(
          this.client.toPathForJson(params.path),
          this.builder,
          this.bindingsHolder
        )}`;
        return params.alias ? this.client.alias(jsonCol, this.formatter.wrap(params.alias)) : jsonCol;
      }
      whereJsonPath(statement) {
        let castValue = "";
        if (!isNaN(statement.value) && parseInt(statement.value)) {
          castValue = "::int";
        } else if (!isNaN(statement.value) && parseFloat(statement.value)) {
          castValue = "::float";
        } else {
          castValue = " #>> '{}'";
        }
        return `jsonb_path_query_first(${this._columnClause(
          statement
        )}, ${this.client.parameter(
          statement.jsonPath,
          this.builder,
          this.bindingsHolder
        )})${castValue} ${operator_(
          statement.operator,
          this.builder,
          this.client,
          this.bindingsHolder
        )} ${this._jsonValueClause(statement)}`;
      }
      whereJsonSupersetOf(statement) {
        return this._not(
          statement,
          `${wrap_(
            statement.column,
            void 0,
            this.builder,
            this.client,
            this.bindingsHolder
          )} @> ${this._jsonValueClause(statement)}`
        );
      }
      whereJsonSubsetOf(statement) {
        return this._not(
          statement,
          `${columnize_(
            statement.column,
            this.builder,
            this.client,
            this.bindingsHolder
          )} <@ ${this._jsonValueClause(statement)}`
        );
      }
      onJsonPathEquals(clause) {
        return this._onJsonPathEquals("jsonb_path_query_first", clause);
      }
    };
    module2.exports = QueryCompiler_PG;
  }
});

// node_modules/knex/lib/dialects/postgres/query/pg-querybuilder.js
var require_pg_querybuilder = __commonJS({
  "node_modules/knex/lib/dialects/postgres/query/pg-querybuilder.js"(exports2, module2) {
    "use strict";
    var QueryBuilder = require_querybuilder();
    module2.exports = class QueryBuilder_PostgreSQL extends QueryBuilder {
      updateFrom(name28) {
        this._single.updateFrom = name28;
        return this;
      }
      using(tables) {
        this._single.using = tables;
        return this;
      }
      withMaterialized(alias, statementOrColumnList, nothingOrStatement) {
        this._validateWithArgs(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          "with"
        );
        return this.withWrapped(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          true
        );
      }
      withNotMaterialized(alias, statementOrColumnList, nothingOrStatement) {
        this._validateWithArgs(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          "with"
        );
        return this.withWrapped(
          alias,
          statementOrColumnList,
          nothingOrStatement,
          false
        );
      }
    };
  }
});

// node_modules/knex/lib/dialects/postgres/schema/pg-columncompiler.js
var require_pg_columncompiler = __commonJS({
  "node_modules/knex/lib/dialects/postgres/schema/pg-columncompiler.js"(exports2, module2) {
    "use strict";
    var ColumnCompiler = require_columncompiler();
    var { isObject: isObject5, isNumber: isNumber2 } = require_is();
    var { toNumber: toNumber2 } = require_helpers();
    var commentEscapeRegex = /(?<!')'(?!')/g;
    var ColumnCompiler_PG = class extends ColumnCompiler {
      constructor(client, tableCompiler, columnBuilder) {
        super(client, tableCompiler, columnBuilder);
        this.modifiers = ["nullable", "defaultTo", "comment"];
        this._addCheckModifiers();
      }
      // Types
      // ------
      bit(column) {
        return column.length !== false ? `bit(${column.length})` : "bit";
      }
      // Create the column definition for an enum type.
      // Using method "2" here: http://stackoverflow.com/a/10984951/525714
      enu(allowed, options) {
        options = options || {};
        const values = options.useNative && options.existingType ? void 0 : allowed.join("', '");
        if (options.useNative) {
          let enumName = "";
          const schemaName = options.schemaName || this.tableCompiler.schemaNameRaw;
          if (schemaName) {
            enumName += `"${schemaName}".`;
          }
          enumName += `"${options.enumName}"`;
          if (!options.existingType) {
            this.tableCompiler.unshiftQuery(
              `create type ${enumName} as enum ('${values}')`
            );
          }
          return enumName;
        }
        return `text check (${this.formatter.wrap(this.args[0])} in ('${values}'))`;
      }
      decimal(precision, scale) {
        if (precision === null) return "decimal";
        return `decimal(${toNumber2(precision, 8)}, ${toNumber2(scale, 2)})`;
      }
      json(jsonb) {
        if (jsonb) this.client.logger.deprecate("json(true)", "jsonb()");
        return jsonColumn(this.client, jsonb);
      }
      jsonb() {
        return jsonColumn(this.client, true);
      }
      checkRegex(regex, constraintName) {
        return this._check(
          `${this.formatter.wrap(
            this.getColumnName()
          )} ~ ${this.client._escapeBinding(regex)}`,
          constraintName
        );
      }
      datetime(withoutTz = false, precision) {
        const defaultPrecision = isNumber2(
          this.client.config.defaultDateTimePrecision
        ) ? `(${this.client.config.defaultDateTimePrecision})` : "";
        let useTz;
        if (isObject5(withoutTz)) {
          ({ useTz, precision } = withoutTz);
        } else {
          useTz = !withoutTz;
        }
        useTz = typeof useTz === "boolean" ? useTz : true;
        precision = precision !== void 0 && precision !== null ? "(" + precision + ")" : defaultPrecision;
        return `${useTz ? "timestamptz" : "timestamp"}${precision}`;
      }
      timestamp(withoutTz = false, precision) {
        return this.datetime(withoutTz, precision);
      }
      // Modifiers:
      // ------
      comment(comment) {
        const columnName = this.args[0] || this.defaults("columnName");
        const escapedComment = comment ? `'${comment.replace(commentEscapeRegex, "''")}'` : "NULL";
        this.pushAdditional(function() {
          this.pushQuery(
            `comment on column ${this.tableCompiler.tableName()}.` + this.formatter.wrap(columnName) + ` is ${escapedComment}`
          );
        }, comment);
      }
      increments(options = { primaryKey: true }) {
        return "serial" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
      }
      bigincrements(options = { primaryKey: true }) {
        return "bigserial" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
      }
      uuid(options = { primaryKey: false }) {
        return "uuid" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
      }
    };
    ColumnCompiler_PG.prototype.bigint = "bigint";
    ColumnCompiler_PG.prototype.binary = "bytea";
    ColumnCompiler_PG.prototype.bool = "boolean";
    ColumnCompiler_PG.prototype.double = "double precision";
    ColumnCompiler_PG.prototype.floating = "real";
    ColumnCompiler_PG.prototype.smallint = "smallint";
    ColumnCompiler_PG.prototype.tinyint = "smallint";
    function jsonColumn(client, jsonb) {
      if (!client.version || client.config.client === "cockroachdb" || client.config.jsonbSupport === true || parseFloat(client.version) >= 9.2) {
        return jsonb ? "jsonb" : "json";
      }
      return "text";
    }
    module2.exports = ColumnCompiler_PG;
  }
});

// node_modules/knex/lib/dialects/postgres/schema/pg-tablecompiler.js
var require_pg_tablecompiler = __commonJS({
  "node_modules/knex/lib/dialects/postgres/schema/pg-tablecompiler.js"(exports2, module2) {
    "use strict";
    var has = require_has();
    var TableCompiler = require_tablecompiler();
    var { isObject: isObject5, isString: isString2 } = require_is();
    var TableCompiler_PG = class extends TableCompiler {
      constructor(client, tableBuilder) {
        super(client, tableBuilder);
      }
      // Compile a rename column command.
      renameColumn(from, to) {
        return this.pushQuery({
          sql: `alter table ${this.tableName()} rename ${this.formatter.wrap(
            from
          )} to ${this.formatter.wrap(to)}`
        });
      }
      _setNullableState(column, isNullable) {
        const constraintAction = isNullable ? "drop not null" : "set not null";
        const sql = `alter table ${this.tableName()} alter column ${this.formatter.wrap(
          column
        )} ${constraintAction}`;
        return this.pushQuery({
          sql
        });
      }
      compileAdd(builder) {
        const table = this.formatter.wrap(builder);
        const columns = this.prefixArray("add column", this.getColumns(builder));
        return this.pushQuery({
          sql: `alter table ${table} ${columns.join(", ")}`
        });
      }
      // Adds the "create" query to the query sequence.
      createQuery(columns, ifNot, like) {
        const createStatement = ifNot ? "create table if not exists " : "create table ";
        const columnsSql = ` (${columns.sql.join(", ")}${this.primaryKeys() || ""}${this._addChecks()})`;
        let sql = createStatement + this.tableName() + (like && this.tableNameLike() ? " (like " + this.tableNameLike() + " including all" + (columns.sql.length ? ", " + columns.sql.join(", ") : "") + ")" : columnsSql);
        if (this.single.inherits)
          sql += ` inherits (${this.formatter.wrap(this.single.inherits)})`;
        this.pushQuery({
          sql,
          bindings: columns.bindings
        });
        const hasComment = has(this.single, "comment");
        if (hasComment) this.comment(this.single.comment);
      }
      primaryKeys() {
        const pks = (this.grouped.alterTable || []).filter(
          (k) => k.method === "primary"
        );
        if (pks.length > 0 && pks[0].args.length > 0) {
          const columns = pks[0].args[0];
          let constraintName = pks[0].args[1] || "";
          let deferrable;
          if (isObject5(constraintName)) {
            ({ constraintName, deferrable } = constraintName);
          }
          deferrable = deferrable ? ` deferrable initially ${deferrable}` : "";
          constraintName = constraintName ? this.formatter.wrap(constraintName) : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
          return `, constraint ${constraintName} primary key (${this.formatter.columnize(
            columns
          )})${deferrable}`;
        }
      }
      addColumns(columns, prefix, colCompilers) {
        if (prefix === this.alterColumnsPrefix) {
          for (const col of colCompilers) {
            this._addColumn(col);
          }
        } else {
          super.addColumns(columns, prefix);
        }
      }
      _addColumn(col) {
        const quotedTableName = this.tableName();
        const type = col.getColumnType();
        const colName = this.client.wrapIdentifier(
          col.getColumnName(),
          col.columnBuilder.queryContext()
        );
        const isEnum = col.type === "enu";
        this.pushQuery({
          sql: `alter table ${quotedTableName} alter column ${colName} drop default`,
          bindings: []
        });
        const alterNullable = col.columnBuilder.alterNullable;
        if (alterNullable) {
          this.pushQuery({
            sql: `alter table ${quotedTableName} alter column ${colName} drop not null`,
            bindings: []
          });
        }
        const alterType = col.columnBuilder.alterType;
        if (alterType) {
          this.pushQuery({
            sql: `alter table ${quotedTableName} alter column ${colName} type ${type} using (${colName}${isEnum ? "::text::" : "::"}${type})`,
            bindings: []
          });
        }
        const defaultTo = col.modified["defaultTo"];
        if (defaultTo) {
          const modifier = col.defaultTo.apply(col, defaultTo);
          this.pushQuery({
            sql: `alter table ${quotedTableName} alter column ${colName} set ${modifier}`,
            bindings: []
          });
        }
        if (alterNullable) {
          const nullable3 = col.modified["nullable"];
          if (nullable3 && nullable3[0] === false) {
            this.pushQuery({
              sql: `alter table ${quotedTableName} alter column ${colName} set not null`,
              bindings: []
            });
          }
        }
      }
      // Compiles the comment on the table.
      comment(comment) {
        this.pushQuery(
          `comment on table ${this.tableName()} is '${this.single.comment}'`
        );
      }
      // Indexes:
      // -------
      primary(columns, constraintName) {
        let deferrable;
        if (isObject5(constraintName)) {
          ({ constraintName, deferrable } = constraintName);
        }
        deferrable = deferrable ? ` deferrable initially ${deferrable}` : "";
        constraintName = constraintName ? this.formatter.wrap(constraintName) : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
        if (this.method !== "create" && this.method !== "createIfNot") {
          this.pushQuery(
            `alter table ${this.tableName()} add constraint ${constraintName} primary key (${this.formatter.columnize(
              columns
            )})${deferrable}`
          );
        }
      }
      unique(columns, indexName) {
        let deferrable;
        let useConstraint = true;
        let predicate;
        if (isObject5(indexName)) {
          ({ indexName, deferrable, useConstraint, predicate } = indexName);
          if (useConstraint === void 0) {
            useConstraint = !!deferrable || !predicate;
          }
        }
        if (!useConstraint && deferrable && deferrable !== "not deferrable") {
          throw new Error("postgres cannot create deferrable index");
        }
        if (useConstraint && predicate) {
          throw new Error("postgres cannot create constraint with predicate");
        }
        deferrable = deferrable ? ` deferrable initially ${deferrable}` : "";
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        if (useConstraint) {
          this.pushQuery(
            `alter table ${this.tableName()} add constraint ${indexName} unique (` + this.formatter.columnize(columns) + ")" + deferrable
          );
        } else {
          const predicateQuery = predicate ? " " + this.client.queryCompiler(predicate).where() : "";
          this.pushQuery(
            `create unique index ${indexName} on ${this.tableName()} (${this.formatter.columnize(
              columns
            )})${predicateQuery}`
          );
        }
      }
      index(columns, indexName, options) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        let predicate;
        let storageEngineIndexType;
        let indexType;
        if (isString2(options)) {
          storageEngineIndexType = options;
        } else if (isObject5(options)) {
          ({ indexType, storageEngineIndexType, predicate } = options);
        }
        const predicateQuery = predicate ? " " + this.client.queryCompiler(predicate).where() : "";
        this.pushQuery(
          `create${typeof indexType === "string" && indexType.toLowerCase() === "unique" ? " unique" : ""} index ${indexName} on ${this.tableName()}${storageEngineIndexType && ` using ${storageEngineIndexType}` || ""} (` + this.formatter.columnize(columns) + `)${predicateQuery}`
        );
      }
      dropPrimary(constraintName) {
        constraintName = constraintName ? this.formatter.wrap(constraintName) : this.formatter.wrap(this.tableNameRaw + "_pkey");
        this.pushQuery(
          `alter table ${this.tableName()} drop constraint ${constraintName}`
        );
      }
      dropPrimaryIfExists(constraintName) {
        constraintName = constraintName ? this.formatter.wrap(constraintName) : this.formatter.wrap(this.tableNameRaw + "_pkey");
        this.pushQuery(
          `alter table ${this.tableName()} drop constraint if exists ${constraintName}`
        );
      }
      dropIndex(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        indexName = this.schemaNameRaw ? `${this.formatter.wrap(this.schemaNameRaw)}.${indexName}` : indexName;
        this.pushQuery(`drop index ${indexName}`);
      }
      dropUnique(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        this.pushQuery(
          `alter table ${this.tableName()} drop constraint ${indexName}`
        );
      }
      dropUniqueIfExists(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        this.pushQuery(
          `alter table ${this.tableName()} drop constraint if exists ${indexName}`
        );
      }
      dropForeign(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("foreign", this.tableNameRaw, columns);
        this.pushQuery(
          `alter table ${this.tableName()} drop constraint ${indexName}`
        );
      }
      dropForeignIfExists(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("foreign", this.tableNameRaw, columns);
        this.pushQuery(
          `alter table ${this.tableName()} drop constraint if exists ${indexName}`
        );
      }
    };
    module2.exports = TableCompiler_PG;
  }
});

// node_modules/knex/lib/dialects/postgres/schema/pg-viewcompiler.js
var require_pg_viewcompiler = __commonJS({
  "node_modules/knex/lib/dialects/postgres/schema/pg-viewcompiler.js"(exports2, module2) {
    "use strict";
    var ViewCompiler = require_viewcompiler();
    var ViewCompiler_PG = class extends ViewCompiler {
      constructor(client, viewCompiler) {
        super(client, viewCompiler);
      }
      renameColumn(from, to) {
        return this.pushQuery({
          sql: `alter view ${this.viewName()} rename ${this.formatter.wrap(
            from
          )} to ${this.formatter.wrap(to)}`
        });
      }
      defaultTo(column, defaultValue) {
        return this.pushQuery({
          sql: `alter view ${this.viewName()} alter ${this.formatter.wrap(
            column
          )} set default ${defaultValue}`
        });
      }
      createOrReplace() {
        this.createQuery(this.columns, this.selectQuery, false, true);
      }
      createMaterializedView() {
        this.createQuery(this.columns, this.selectQuery, true);
      }
    };
    module2.exports = ViewCompiler_PG;
  }
});

// node_modules/knex/lib/dialects/postgres/schema/pg-viewbuilder.js
var require_pg_viewbuilder = __commonJS({
  "node_modules/knex/lib/dialects/postgres/schema/pg-viewbuilder.js"(exports2, module2) {
    "use strict";
    var ViewBuilder = require_viewbuilder();
    var ViewBuilder_PG = class extends ViewBuilder {
      constructor() {
        super(...arguments);
      }
      checkOption() {
        this._single.checkOption = "default_option";
      }
      localCheckOption() {
        this._single.checkOption = "local";
      }
      cascadedCheckOption() {
        this._single.checkOption = "cascaded";
      }
    };
    module2.exports = ViewBuilder_PG;
  }
});

// node_modules/knex/lib/dialects/postgres/schema/pg-compiler.js
var require_pg_compiler = __commonJS({
  "node_modules/knex/lib/dialects/postgres/schema/pg-compiler.js"(exports2, module2) {
    "use strict";
    var SchemaCompiler = require_compiler();
    var SchemaCompiler_PG = class extends SchemaCompiler {
      constructor(client, builder) {
        super(client, builder);
      }
      // Check whether the current table
      hasTable(tableName) {
        let sql = "select * from information_schema.tables where table_name = ?";
        const bindings = [tableName];
        if (this.schema) {
          sql += " and table_schema = ?";
          bindings.push(this.schema);
        } else {
          sql += " and table_schema = current_schema()";
        }
        this.pushQuery({
          sql,
          bindings,
          output(resp) {
            return resp.rows.length > 0;
          }
        });
      }
      // Compile the query to determine if a column exists in a table.
      hasColumn(tableName, columnName) {
        let sql = "select * from information_schema.columns where table_name = ? and column_name = ?";
        const bindings = [tableName, columnName];
        if (this.schema) {
          sql += " and table_schema = ?";
          bindings.push(this.schema);
        } else {
          sql += " and table_schema = current_schema()";
        }
        this.pushQuery({
          sql,
          bindings,
          output(resp) {
            return resp.rows.length > 0;
          }
        });
      }
      qualifiedTableName(tableName) {
        const name28 = this.schema ? `${this.schema}.${tableName}` : tableName;
        return this.formatter.wrap(name28);
      }
      // Compile a rename table command.
      renameTable(from, to) {
        this.pushQuery(
          `alter table ${this.qualifiedTableName(
            from
          )} rename to ${this.formatter.wrap(to)}`
        );
      }
      createSchema(schemaName) {
        this.pushQuery(`create schema ${this.formatter.wrap(schemaName)}`);
      }
      createSchemaIfNotExists(schemaName) {
        this.pushQuery(
          `create schema if not exists ${this.formatter.wrap(schemaName)}`
        );
      }
      dropSchema(schemaName, cascade = false) {
        this.pushQuery(
          `drop schema ${this.formatter.wrap(schemaName)}${cascade ? " cascade" : ""}`
        );
      }
      dropSchemaIfExists(schemaName, cascade = false) {
        this.pushQuery(
          `drop schema if exists ${this.formatter.wrap(schemaName)}${cascade ? " cascade" : ""}`
        );
      }
      dropExtension(extensionName) {
        this.pushQuery(`drop extension ${this.formatter.wrap(extensionName)}`);
      }
      dropExtensionIfExists(extensionName) {
        this.pushQuery(
          `drop extension if exists ${this.formatter.wrap(extensionName)}`
        );
      }
      createExtension(extensionName) {
        this.pushQuery(`create extension ${this.formatter.wrap(extensionName)}`);
      }
      createExtensionIfNotExists(extensionName) {
        this.pushQuery(
          `create extension if not exists ${this.formatter.wrap(extensionName)}`
        );
      }
      renameView(from, to) {
        this.pushQuery(
          this.alterViewPrefix + `${this.formatter.wrap(from)} rename to ${this.formatter.wrap(to)}`
        );
      }
      refreshMaterializedView(viewName, concurrently = false) {
        this.pushQuery({
          sql: `refresh materialized view${concurrently ? " concurrently" : ""} ${this.formatter.wrap(viewName)}`
        });
      }
      dropMaterializedView(viewName) {
        this._dropView(viewName, false, true);
      }
      dropMaterializedViewIfExists(viewName) {
        this._dropView(viewName, true, true);
      }
    };
    module2.exports = SchemaCompiler_PG;
  }
});

// node_modules/knex/lib/dialects/postgres/index.js
var require_postgres = __commonJS({
  "node_modules/knex/lib/dialects/postgres/index.js"(exports2, module2) {
    "use strict";
    var extend4 = require_extend();
    var map3 = require_map();
    var { promisify: promisify2 } = require("util");
    var Client2 = require_client2();
    var Transaction = require_pg_transaction();
    var QueryCompiler = require_pg_querycompiler();
    var QueryBuilder = require_pg_querybuilder();
    var ColumnCompiler = require_pg_columncompiler();
    var TableCompiler = require_pg_tablecompiler();
    var ViewCompiler = require_pg_viewcompiler();
    var ViewBuilder = require_pg_viewbuilder();
    var SchemaCompiler = require_pg_compiler();
    var { makeEscape } = require_string2();
    var { isString: isString2 } = require_is();
    var Client_PG = class extends Client2 {
      constructor(config3) {
        super(config3);
        if (config3.returning) {
          this.defaultReturning = config3.returning;
        }
        if (config3.searchPath) {
          this.searchPath = config3.searchPath;
        }
      }
      transaction() {
        return new Transaction(this, ...arguments);
      }
      queryBuilder() {
        return new QueryBuilder(this);
      }
      queryCompiler(builder, formatter) {
        return new QueryCompiler(this, builder, formatter);
      }
      columnCompiler() {
        return new ColumnCompiler(this, ...arguments);
      }
      schemaCompiler() {
        return new SchemaCompiler(this, ...arguments);
      }
      tableCompiler() {
        return new TableCompiler(this, ...arguments);
      }
      viewCompiler() {
        return new ViewCompiler(this, ...arguments);
      }
      viewBuilder() {
        return new ViewBuilder(this, ...arguments);
      }
      _driver() {
        return require("pg");
      }
      wrapIdentifierImpl(value) {
        if (value === "*") return value;
        let arrayAccessor = "";
        const arrayAccessorMatch = value.match(/(.*?)(\[[0-9]+\])/);
        if (arrayAccessorMatch) {
          value = arrayAccessorMatch[1];
          arrayAccessor = arrayAccessorMatch[2];
        }
        return `"${value.replace(/"/g, '""')}"${arrayAccessor}`;
      }
      _acquireOnlyConnection() {
        const connection = new this.driver.Client(this.connectionSettings);
        connection.on("error", (err) => {
          connection.__knex__disposed = err;
        });
        connection.on("end", (err) => {
          connection.__knex__disposed = err || "Connection ended unexpectedly";
        });
        return connection.connect().then(() => connection);
      }
      // Get a raw connection, called by the `pool` whenever a new
      // connection needs to be added to the pool.
      acquireRawConnection() {
        const client = this;
        return this._acquireOnlyConnection().then(function(connection) {
          if (!client.version) {
            return client.checkVersion(connection).then(function(version3) {
              client.version = version3;
              return connection;
            });
          }
          return connection;
        }).then(async function setSearchPath(connection) {
          await client.setSchemaSearchPath(connection);
          return connection;
        });
      }
      // Used to explicitly close a connection, called internally by the pool
      // when a connection times out or the pool is shutdown.
      async destroyRawConnection(connection) {
        const end = promisify2((cb) => connection.end(cb));
        return end();
      }
      // In PostgreSQL, we need to do a version check to do some feature
      // checking on the database.
      checkVersion(connection) {
        return new Promise((resolve3, reject) => {
          connection.query("select version();", (err, resp) => {
            if (err) return reject(err);
            resolve3(this._parseVersion(resp.rows[0].version));
          });
        });
      }
      _parseVersion(versionString) {
        return /^PostgreSQL (.*?)( |$)/.exec(versionString)[1];
      }
      // Position the bindings for the query. The escape sequence for question mark
      // is \? (e.g. knex.raw("\\?") since javascript requires '\' to be escaped too...)
      positionBindings(sql) {
        let questionCount = 0;
        return sql.replace(/(\\*)(\?)/g, function(match, escapes) {
          if (escapes.length % 2) {
            return "?";
          } else {
            questionCount++;
            return `$${questionCount}`;
          }
        });
      }
      setSchemaSearchPath(connection, searchPath) {
        let path33 = searchPath || this.searchPath;
        if (!path33) return Promise.resolve(true);
        if (!Array.isArray(path33) && !isString2(path33)) {
          throw new TypeError(
            `knex: Expected searchPath to be Array/String, got: ${typeof path33}`
          );
        }
        if (isString2(path33)) {
          if (path33.includes(",")) {
            const parts = path33.split(",");
            const arraySyntax = `[${parts.map((searchPath2) => `'${searchPath2}'`).join(", ")}]`;
            this.logger.warn(
              `Detected comma in searchPath "${path33}".If you are trying to specify multiple schemas, use Array syntax: ${arraySyntax}`
            );
          }
          path33 = [path33];
        }
        path33 = path33.map((schemaName) => `"${schemaName}"`).join(",");
        return new Promise(function(resolver, rejecter) {
          connection.query(`set search_path to ${path33}`, function(err) {
            if (err) return rejecter(err);
            resolver(true);
          });
        });
      }
      _stream(connection, obj, stream4, options) {
        if (!obj.sql) throw new Error("The query is empty");
        let PGQueryStream;
        if (process.browser) {
          PGQueryStream = void 0;
        } else {
          try {
            PGQueryStream = require("pg-query-stream");
          } catch (e) {
            if (e instanceof Error && e.code === "MODULE_NOT_FOUND" && e.message.includes("pg-query-stream")) {
              throw new Error(
                "knex PostgreSQL query streaming requires the 'pg-query-stream' package. Please install it (e.g. `npm i pg-query-stream`)."
              );
            }
            throw e;
          }
        }
        const sql = obj.sql;
        return new Promise(function(resolver, rejecter) {
          const queryStream = connection.query(
            new PGQueryStream(sql, obj.bindings, options)
          );
          queryStream.on("error", function(error73) {
            rejecter(error73);
            stream4.emit("error", error73);
          });
          queryStream.on("end", resolver);
          queryStream.pipe(stream4);
        });
      }
      // Runs the query on the specified connection, providing the bindings
      // and any other necessary prep work.
      _query(connection, obj) {
        if (!obj.sql) throw new Error("The query is empty");
        let queryConfig = {
          text: obj.sql,
          values: obj.bindings || []
        };
        if (obj.options) {
          queryConfig = extend4(queryConfig, obj.options);
        }
        return new Promise(function(resolver, rejecter) {
          connection.query(queryConfig, function(err, response) {
            if (err) return rejecter(err);
            obj.response = response;
            resolver(obj);
          });
        });
      }
      // Ensures the response is returned in the same format as other clients.
      processResponse(obj, runner) {
        const resp = obj.response;
        if (obj.output) return obj.output.call(runner, resp);
        if (obj.method === "raw") return resp;
        const { returning } = obj;
        if (resp.command === "SELECT") {
          if (obj.method === "first") return resp.rows[0];
          if (obj.method === "pluck") return map3(resp.rows, obj.pluck);
          return resp.rows;
        }
        if (returning) {
          const returns = [];
          for (let i = 0, l = resp.rows.length; i < l; i++) {
            const row = resp.rows[i];
            returns[i] = row;
          }
          return returns;
        }
        if (resp.command === "UPDATE" || resp.command === "DELETE") {
          return resp.rowCount;
        }
        return resp;
      }
      async cancelQuery(connectionToKill) {
        const conn = await this.acquireRawConnection();
        try {
          return await this._wrappedCancelQueryCall(conn, connectionToKill);
        } finally {
          await this.destroyRawConnection(conn).catch((err) => {
            this.logger.warn(`Connection Error: ${err}`);
          });
        }
      }
      _wrappedCancelQueryCall(conn, connectionToKill) {
        return this._query(conn, {
          sql: "SELECT pg_cancel_backend($1);",
          bindings: [connectionToKill.processID],
          options: {}
        });
      }
      toPathForJson(jsonPath) {
        const PG_PATH_REGEX = /^{.*}$/;
        if (jsonPath.match(PG_PATH_REGEX)) {
          return jsonPath;
        }
        return "{" + jsonPath.replace(/^(\$\.)/, "").replace(".", ",").replace(/\[([0-9]+)]/, ",$1") + // transform [number] to ,number
        "}";
      }
    };
    Object.assign(Client_PG.prototype, {
      dialect: "postgresql",
      driverName: "pg",
      canCancelQuery: true,
      _escapeBinding: makeEscape({
        escapeArray(val, esc3) {
          return esc3(arrayString(val, esc3));
        },
        escapeString(str) {
          let hasBackslash = false;
          let escaped = "'";
          for (let i = 0; i < str.length; i++) {
            const c = str[i];
            if (c === "'") {
              escaped += c + c;
            } else if (c === "\\") {
              escaped += c + c;
              hasBackslash = true;
            } else {
              escaped += c;
            }
          }
          escaped += "'";
          if (hasBackslash === true) {
            escaped = "E" + escaped;
          }
          return escaped;
        },
        escapeObject(val, prepareValue, timezone, seen = []) {
          if (val && typeof val.toPostgres === "function") {
            seen = seen || [];
            if (seen.indexOf(val) !== -1) {
              throw new Error(
                `circular reference detected while preparing "${val}" for query`
              );
            }
            seen.push(val);
            return prepareValue(val.toPostgres(prepareValue), seen);
          }
          return JSON.stringify(val);
        }
      })
    });
    function arrayString(arr, esc3) {
      let result = "{";
      for (let i = 0; i < arr.length; i++) {
        if (i > 0) result += ",";
        const val = arr[i];
        if (val === null || typeof val === "undefined") {
          result += "NULL";
        } else if (Array.isArray(val)) {
          result += arrayString(val, esc3);
        } else if (typeof val === "number") {
          result += val;
        } else {
          result += JSON.stringify(typeof val === "string" ? val : esc3(val));
        }
      }
      return result + "}";
    }
    module2.exports = Client_PG;
  }
});

// node_modules/knex/lib/dialects/cockroachdb/crdb-querycompiler.js
var require_crdb_querycompiler = __commonJS({
  "node_modules/knex/lib/dialects/cockroachdb/crdb-querycompiler.js"(exports2, module2) {
    "use strict";
    var QueryCompiler_PG = require_pg_querycompiler();
    var {
      columnize: columnize_,
      wrap: wrap_,
      operator: operator_
    } = require_wrappingFormatter();
    var QueryCompiler_CRDB = class extends QueryCompiler_PG {
      truncate() {
        return `truncate ${this.tableName}`;
      }
      upsert() {
        let sql = this._upsert();
        if (sql === "") return sql;
        const { returning } = this.single;
        if (returning) sql += this._returning(returning);
        return {
          sql,
          returning
        };
      }
      _upsert() {
        const upsertValues = this.single.upsert || [];
        const sql = this.with() + `upsert into ${this.tableName} `;
        const body = this._insertBody(upsertValues);
        return body === "" ? "" : sql + body;
      }
      _groupOrder(item, type) {
        return this._basicGroupOrder(item, type);
      }
      whereJsonPath(statement) {
        let castValue = "";
        if (!isNaN(statement.value) && parseInt(statement.value)) {
          castValue = "::int";
        } else if (!isNaN(statement.value) && parseFloat(statement.value)) {
          castValue = "::float";
        } else {
          castValue = " #>> '{}'";
        }
        return `json_extract_path(${this._columnClause(
          statement
        )}, ${this.client.toArrayPathFromJsonPath(
          statement.jsonPath,
          this.builder,
          this.bindingsHolder
        )})${castValue} ${operator_(
          statement.operator,
          this.builder,
          this.client,
          this.bindingsHolder
        )} ${this._jsonValueClause(statement)}`;
      }
      // Json common functions
      _jsonExtract(nameFunction, params) {
        let extractions;
        if (Array.isArray(params.column)) {
          extractions = params.column;
        } else {
          extractions = [params];
        }
        return extractions.map((extraction) => {
          const jsonCol = `json_extract_path(${columnize_(
            extraction.column || extraction[0],
            this.builder,
            this.client,
            this.bindingsHolder
          )}, ${this.client.toArrayPathFromJsonPath(
            extraction.path || extraction[1],
            this.builder,
            this.bindingsHolder
          )})`;
          const alias = extraction.alias || extraction[2];
          return alias ? this.client.alias(jsonCol, this.formatter.wrap(alias)) : jsonCol;
        }).join(", ");
      }
      _onJsonPathEquals(nameJoinFunction, clause) {
        return "json_extract_path(" + wrap_(
          clause.columnFirst,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + ", " + this.client.toArrayPathFromJsonPath(
          clause.jsonPathFirst,
          this.builder,
          this.bindingsHolder
        ) + ") = json_extract_path(" + wrap_(
          clause.columnSecond,
          void 0,
          this.builder,
          this.client,
          this.bindingsHolder
        ) + ", " + this.client.toArrayPathFromJsonPath(
          clause.jsonPathSecond,
          this.builder,
          this.bindingsHolder
        ) + ")";
      }
    };
    module2.exports = QueryCompiler_CRDB;
  }
});

// node_modules/knex/lib/dialects/cockroachdb/crdb-columncompiler.js
var require_crdb_columncompiler = __commonJS({
  "node_modules/knex/lib/dialects/cockroachdb/crdb-columncompiler.js"(exports2, module2) {
    "use strict";
    var ColumnCompiler_PG = require_pg_columncompiler();
    var ColumnCompiler_CRDB = class extends ColumnCompiler_PG {
      uuid(options = { primaryKey: false }) {
        return "uuid" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key default gen_random_uuid()" : "");
      }
    };
    module2.exports = ColumnCompiler_CRDB;
  }
});

// node_modules/knex/lib/dialects/cockroachdb/crdb-tablecompiler.js
var require_crdb_tablecompiler = __commonJS({
  "node_modules/knex/lib/dialects/cockroachdb/crdb-tablecompiler.js"(exports2, module2) {
    "use strict";
    var TableCompiler = require_pg_tablecompiler();
    var TableCompiler_CRDB = class extends TableCompiler {
      constructor(client, tableBuilder) {
        super(client, tableBuilder);
      }
      addColumns(columns, prefix, colCompilers) {
        if (prefix === this.alterColumnsPrefix) {
          for (const col of colCompilers) {
            this.client.logger.warn(
              "Experimental alter column in use, see issue: https://github.com/cockroachdb/cockroach/issues/49329"
            );
            this.pushQuery({
              sql: "SET enable_experimental_alter_column_type_general = true",
              bindings: []
            });
            super._addColumn(col);
          }
        } else {
          super.addColumns(columns, prefix);
        }
      }
      dropUnique(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        this.pushQuery(`drop index ${this.tableName()}@${indexName} cascade`);
      }
      dropUniqueIfExists(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        this.pushQuery(
          `drop index if exists ${this.tableName()}@${indexName} cascade`
        );
      }
    };
    module2.exports = TableCompiler_CRDB;
  }
});

// node_modules/knex/lib/dialects/cockroachdb/crdb-viewcompiler.js
var require_crdb_viewcompiler = __commonJS({
  "node_modules/knex/lib/dialects/cockroachdb/crdb-viewcompiler.js"(exports2, module2) {
    "use strict";
    var ViewCompiler_PG = require_pg_viewcompiler();
    var ViewCompiler_CRDB = class extends ViewCompiler_PG {
      renameColumn(from, to) {
        throw new Error("rename column of views is not supported by this dialect.");
      }
      defaultTo(column, defaultValue) {
        throw new Error(
          "change default values of views is not supported by this dialect."
        );
      }
    };
    module2.exports = ViewCompiler_CRDB;
  }
});

// node_modules/knex/lib/dialects/cockroachdb/crdb-querybuilder.js
var require_crdb_querybuilder = __commonJS({
  "node_modules/knex/lib/dialects/cockroachdb/crdb-querybuilder.js"(exports2, module2) {
    "use strict";
    var QueryBuilder = require_querybuilder();
    var isEmpty = require_isEmpty();
    module2.exports = class QueryBuilder_CockroachDB extends QueryBuilder {
      upsert(values, returning, options) {
        this._method = "upsert";
        if (!isEmpty(returning)) this.returning(returning, options);
        this._single.upsert = values;
        return this;
      }
    };
  }
});

// node_modules/knex/lib/dialects/cockroachdb/index.js
var require_cockroachdb = __commonJS({
  "node_modules/knex/lib/dialects/cockroachdb/index.js"(exports2, module2) {
    "use strict";
    var Client_PostgreSQL = require_postgres();
    var Transaction = require_pg_transaction();
    var QueryCompiler = require_crdb_querycompiler();
    var ColumnCompiler = require_crdb_columncompiler();
    var TableCompiler = require_crdb_tablecompiler();
    var ViewCompiler = require_crdb_viewcompiler();
    var QueryBuilder = require_crdb_querybuilder();
    var Client_CockroachDB = class extends Client_PostgreSQL {
      transaction() {
        return new Transaction(this, ...arguments);
      }
      queryCompiler(builder, formatter) {
        return new QueryCompiler(this, builder, formatter);
      }
      columnCompiler() {
        return new ColumnCompiler(this, ...arguments);
      }
      tableCompiler() {
        return new TableCompiler(this, ...arguments);
      }
      viewCompiler() {
        return new ViewCompiler(this, ...arguments);
      }
      queryBuilder() {
        return new QueryBuilder(this);
      }
      _parseVersion(versionString) {
        return versionString.split(" ")[2];
      }
      async cancelQuery(connectionToKill) {
        try {
          return await this._wrappedCancelQueryCall(null, connectionToKill);
        } catch (err) {
          this.logger.warn(`Connection Error: ${err}`);
          throw err;
        }
      }
      _wrappedCancelQueryCall(emptyConnection, connectionToKill) {
        if (connectionToKill.activeQuery.processID === 0 && connectionToKill.activeQuery.secretKey === 0) {
          return;
        }
        return connectionToKill.cancel(
          connectionToKill,
          connectionToKill.activeQuery
        );
      }
      toArrayPathFromJsonPath(jsonPath, builder, bindingsHolder) {
        return jsonPath.replace(/^(\$\.)/, "").replace(/\[([0-9]+)]/, ".$1").split(".").map(
          function(v) {
            return this.parameter(v, builder, bindingsHolder);
          }.bind(this)
        ).join(", ");
      }
    };
    Object.assign(Client_CockroachDB.prototype, {
      // The "dialect", for reference elsewhere.
      driverName: "cockroachdb"
    });
    module2.exports = Client_CockroachDB;
  }
});

// node_modules/lodash/isNil.js
var require_isNil = __commonJS({
  "node_modules/lodash/isNil.js"(exports2, module2) {
    "use strict";
    function isNil(value) {
      return value == null;
    }
    module2.exports = isNil;
  }
});

// node_modules/knex/lib/dialects/mssql/mssql-formatter.js
var require_mssql_formatter = __commonJS({
  "node_modules/knex/lib/dialects/mssql/mssql-formatter.js"(exports2, module2) {
    "use strict";
    var Formatter = require_formatter();
    var MSSQL_Formatter = class extends Formatter {
      // Accepts a string or array of columns to wrap as appropriate.
      columnizeWithPrefix(prefix, target) {
        const columns = typeof target === "string" ? [target] : target;
        let str = "", i = -1;
        while (++i < columns.length) {
          if (i > 0) str += ", ";
          str += prefix + this.wrap(columns[i]);
        }
        return str;
      }
      /**
       * Returns its argument with single quotes escaped, so it can be included into a single-quoted string.
       *
       * For example, it converts "has'quote" to "has''quote".
       *
       * This assumes QUOTED_IDENTIFIER ON so it is only ' that need escaping,
       * never ", because " cannot be used to quote a string when that's on;
       * otherwise we'd need to be aware of whether the string is quoted with " or '.
       *
       * This assumption is consistent with the SQL Knex generates.
       * @param {string} string
       * @returns {string}
       */
      escapingStringDelimiters(string5) {
        return (string5 || "").replace(/'/g, "''");
      }
    };
    module2.exports = MSSQL_Formatter;
  }
});

// node_modules/knex/lib/dialects/mssql/transaction.js
var require_transaction2 = __commonJS({
  "node_modules/knex/lib/dialects/mssql/transaction.js"(exports2, module2) {
    "use strict";
    var Transaction = require_transaction();
    var debug = require_src3()("knex:tx");
    var Transaction_MSSQL = class extends Transaction {
      begin(conn) {
        debug("transaction::begin id=%s", this.txid);
        return new Promise((resolve3, reject) => {
          conn.beginTransaction(
            (err) => {
              if (err) {
                debug(
                  "transaction::begin error id=%s message=%s",
                  this.txid,
                  err.message
                );
                return reject(err);
              }
              resolve3();
            },
            this.outerTx ? this.txid : void 0,
            nameToIsolationLevelEnum(this.isolationLevel)
          );
        }).then(this._resolver, this._rejecter);
      }
      savepoint(conn) {
        debug("transaction::savepoint id=%s", this.txid);
        return new Promise((resolve3, reject) => {
          conn.saveTransaction(
            (err) => {
              if (err) {
                debug(
                  "transaction::savepoint id=%s message=%s",
                  this.txid,
                  err.message
                );
                return reject(err);
              }
              this.trxClient.emit("query", {
                __knexUid: this.trxClient.__knexUid,
                __knexTxId: this.trxClient.__knexTxId,
                autogenerated: true,
                sql: this.outerTx ? `SAVE TRANSACTION [${this.txid}]` : `SAVE TRANSACTION`
              });
              resolve3();
            },
            this.outerTx ? this.txid : void 0
          );
        });
      }
      commit(conn, value) {
        debug("transaction::commit id=%s", this.txid);
        return new Promise((resolve3, reject) => {
          conn.commitTransaction(
            (err) => {
              if (err) {
                debug(
                  "transaction::commit error id=%s message=%s",
                  this.txid,
                  err.message
                );
                return reject(err);
              }
              this._completed = true;
              resolve3(value);
            },
            this.outerTx ? this.txid : void 0
          );
        }).then(() => this._resolver(value), this._rejecter);
      }
      release(conn, value) {
        return this._resolver(value);
      }
      rollback(conn, error73) {
        this._completed = true;
        debug("transaction::rollback id=%s", this.txid);
        return new Promise((_resolve, reject) => {
          if (!conn.inTransaction) {
            return reject(
              error73 || new Error("Transaction rejected with non-error: undefined")
            );
          }
          if (conn.state.name !== "LoggedIn") {
            return reject(
              new Error(
                "Can't rollback transaction. There is a request in progress"
              )
            );
          }
          conn.rollbackTransaction(
            (err) => {
              if (err) {
                debug(
                  "transaction::rollback error id=%s message=%s",
                  this.txid,
                  err.message
                );
              }
              reject(
                err || error73 || new Error("Transaction rejected with non-error: undefined")
              );
            },
            this.outerTx ? this.txid : void 0
          );
        }).catch((err) => {
          if (!error73 && this.doNotRejectOnRollback) {
            this._resolver();
            return;
          }
          if (error73) {
            try {
              err.originalError = error73;
            } catch (_err) {
            }
          }
          this._rejecter(err);
        });
      }
      rollbackTo(conn, error73) {
        return this.rollback(conn, error73).then(
          () => void this.trxClient.emit("query", {
            __knexUid: this.trxClient.__knexUid,
            __knexTxId: this.trxClient.__knexTxId,
            autogenerated: true,
            sql: `ROLLBACK TRANSACTION`
          })
        );
      }
    };
    module2.exports = Transaction_MSSQL;
    function nameToIsolationLevelEnum(level) {
      if (!level) return;
      level = level.toUpperCase().replace(" ", "_");
      const knownEnum = isolationEnum[level];
      if (!knownEnum) {
        throw new Error(
          `Unknown Isolation level, was expecting one of: ${JSON.stringify(
            humanReadableKeys
          )}`
        );
      }
      return knownEnum;
    }
    var isolationEnum = {
      READ_UNCOMMITTED: 1,
      READ_COMMITTED: 2,
      REPEATABLE_READ: 3,
      SERIALIZABLE: 4,
      SNAPSHOT: 5
    };
    var humanReadableKeys = Object.keys(isolationEnum).map(
      (key) => key.toLowerCase().replace("_", " ")
    );
  }
});

// node_modules/knex/lib/dialects/mssql/query/mssql-querycompiler.js
var require_mssql_querycompiler = __commonJS({
  "node_modules/knex/lib/dialects/mssql/query/mssql-querycompiler.js"(exports2, module2) {
    "use strict";
    var QueryCompiler = require_querycompiler();
    var compact = require_compact();
    var identity2 = require_identity();
    var isEmpty = require_isEmpty();
    var Raw = require_raw2();
    var {
      columnize: columnize_
    } = require_wrappingFormatter();
    var components = [
      "comments",
      "columns",
      "join",
      "lock",
      "where",
      "union",
      "group",
      "having",
      "order",
      "limit",
      "offset"
    ];
    var QueryCompiler_MSSQL = class extends QueryCompiler {
      constructor(client, builder, formatter) {
        super(client, builder, formatter);
        const { onConflict } = this.single;
        if (onConflict) {
          throw new Error(".onConflict() is not supported for mssql.");
        }
        this._emptyInsertValue = "default values";
      }
      with() {
        const undoList = [];
        if (this.grouped.with) {
          for (const stmt of this.grouped.with) {
            if (stmt.recursive) {
              undoList.push(stmt);
              stmt.recursive = false;
            }
          }
        }
        const result = super.with();
        for (const stmt of undoList) {
          stmt.recursive = true;
        }
        return result;
      }
      select() {
        const sql = this.with();
        const statements = components.map((component) => this[component](this));
        return sql + compact(statements).join(" ");
      }
      //#region Insert
      // Compiles an "insert" query, allowing for multiple
      // inserts using a single query statement.
      insert() {
        if (this.single.options && this.single.options.includeTriggerModifications) {
          return this.insertWithTriggers();
        } else {
          return this.standardInsert();
        }
      }
      insertWithTriggers() {
        const insertValues = this.single.insert || [];
        const { returning } = this.single;
        let sql = this.with() + `${this._buildTempTable(returning)}insert into ${this.tableName} `;
        const returningSql = returning ? this._returning("insert", returning, true) + " " : "";
        if (Array.isArray(insertValues)) {
          if (insertValues.length === 0) {
            return "";
          }
        } else if (typeof insertValues === "object" && isEmpty(insertValues)) {
          return {
            sql: sql + returningSql + this._emptyInsertValue + this._buildReturningSelect(returning),
            returning
          };
        }
        sql += this._buildInsertData(insertValues, returningSql);
        if (returning) {
          sql += this._buildReturningSelect(returning);
        }
        return {
          sql,
          returning
        };
      }
      _buildInsertData(insertValues, returningSql) {
        let sql = "";
        const insertData = this._prepInsert(insertValues);
        if (typeof insertData === "string") {
          sql += insertData;
        } else {
          if (insertData.columns.length) {
            sql += `(${this.formatter.columnize(insertData.columns)}`;
            sql += `) ${returningSql}values (` + this._buildInsertValues(insertData) + ")";
          } else if (insertValues.length === 1 && insertValues[0]) {
            sql += returningSql + this._emptyInsertValue;
          } else {
            return "";
          }
        }
        return sql;
      }
      standardInsert() {
        const insertValues = this.single.insert || [];
        let sql = this.with() + `insert into ${this.tableName} `;
        const { returning } = this.single;
        const returningSql = returning ? this._returning("insert", returning) + " " : "";
        if (Array.isArray(insertValues)) {
          if (insertValues.length === 0) {
            return "";
          }
        } else if (typeof insertValues === "object" && isEmpty(insertValues)) {
          return {
            sql: sql + returningSql + this._emptyInsertValue,
            returning
          };
        }
        sql += this._buildInsertData(insertValues, returningSql);
        return {
          sql,
          returning
        };
      }
      //#endregion
      //#region Update
      // Compiles an `update` query, allowing for a return value.
      update() {
        if (this.single.options && this.single.options.includeTriggerModifications) {
          return this.updateWithTriggers();
        } else {
          return this.standardUpdate();
        }
      }
      updateWithTriggers() {
        const top = this.top();
        const withSQL = this.with();
        const updates = this._prepUpdate(this.single.update);
        const join2 = this.join();
        const where = this.where();
        const order = this.order();
        const { returning } = this.single;
        const declaredTemp = this._buildTempTable(returning);
        return {
          sql: withSQL + declaredTemp + `update ${top ? top + " " : ""}${this.tableName} set ` + updates.join(", ") + (returning ? ` ${this._returning("update", returning, true)}` : "") + (join2 ? ` from ${this.tableName} ${join2}` : "") + (where ? ` ${where}` : "") + (order ? ` ${order}` : "") + (!returning ? this._returning("rowcount", "@@rowcount") : this._buildReturningSelect(returning)),
          returning: returning || "@@rowcount"
        };
      }
      _formatGroupsItemValue(value, nulls) {
        const column = super._formatGroupsItemValue(value);
        if (nulls && !(value instanceof Raw)) {
          const collNulls = `IIF(${column} is null,`;
          if (nulls === "first") {
            return `${collNulls}0,1)`;
          } else if (nulls === "last") {
            return `${collNulls}1,0)`;
          }
        }
        return column;
      }
      standardUpdate() {
        const top = this.top();
        const withSQL = this.with();
        const updates = this._prepUpdate(this.single.update);
        const join2 = this.join();
        const where = this.where();
        const order = this.order();
        const { returning } = this.single;
        return {
          sql: withSQL + `update ${top ? top + " " : ""}${this.tableName} set ` + updates.join(", ") + (returning ? ` ${this._returning("update", returning)}` : "") + (join2 ? ` from ${this.tableName} ${join2}` : "") + (where ? ` ${where}` : "") + (order ? ` ${order}` : "") + (!returning ? this._returning("rowcount", "@@rowcount") : ""),
          returning: returning || "@@rowcount"
        };
      }
      //#endregion
      //#region Delete
      // Compiles a `delete` query.
      del() {
        if (this.single.options && this.single.options.includeTriggerModifications) {
          return this.deleteWithTriggers();
        } else {
          return this.standardDelete();
        }
      }
      deleteWithTriggers() {
        const withSQL = this.with();
        const { tableName } = this;
        const wheres = this.where();
        const joins = this.join();
        const { returning } = this.single;
        const returningStr = returning ? ` ${this._returning("del", returning, true)}` : "";
        const deleteSelector = joins ? `${tableName}${returningStr} ` : "";
        return {
          sql: withSQL + `${this._buildTempTable(
            returning
          )}delete ${deleteSelector}from ${tableName}` + (!joins ? returningStr : "") + (joins ? ` ${joins}` : "") + (wheres ? ` ${wheres}` : "") + (!returning ? this._returning("rowcount", "@@rowcount") : this._buildReturningSelect(returning)),
          returning: returning || "@@rowcount"
        };
      }
      standardDelete() {
        const withSQL = this.with();
        const { tableName } = this;
        const wheres = this.where();
        const joins = this.join();
        const { returning } = this.single;
        const returningStr = returning ? ` ${this._returning("del", returning)}` : "";
        const deleteSelector = joins ? `${tableName}${returningStr} ` : "";
        return {
          sql: withSQL + `delete ${deleteSelector}from ${tableName}` + (!joins ? returningStr : "") + (joins ? ` ${joins}` : "") + (wheres ? ` ${wheres}` : "") + (!returning ? this._returning("rowcount", "@@rowcount") : ""),
          returning: returning || "@@rowcount"
        };
      }
      //#endregion
      // Compiles the columns in the query, specifying if an item was distinct.
      columns() {
        let distinctClause = "";
        if (this.onlyUnions()) return "";
        const top = this.top();
        const hints = this._hintComments();
        const columns = this.grouped.columns || [];
        let i = -1, sql = [];
        if (columns) {
          while (++i < columns.length) {
            const stmt = columns[i];
            if (stmt.distinct) distinctClause = "distinct ";
            if (stmt.distinctOn) {
              distinctClause = this.distinctOn(stmt.value);
              continue;
            }
            if (stmt.type === "aggregate") {
              sql.push(...this.aggregate(stmt));
            } else if (stmt.type === "aggregateRaw") {
              sql.push(this.aggregateRaw(stmt));
            } else if (stmt.type === "analytic") {
              sql.push(this.analytic(stmt));
            } else if (stmt.type === "json") {
              sql.push(this.json(stmt));
            } else if (stmt.value && stmt.value.length > 0) {
              sql.push(this.formatter.columnize(stmt.value));
            }
          }
        }
        if (sql.length === 0) sql = ["*"];
        const select = this.onlyJson() ? "" : "select ";
        return `${select}${hints}${distinctClause}` + (top ? top + " " : "") + sql.join(", ") + (this.tableName ? ` from ${this.tableName}` : "");
      }
      _returning(method, value, withTrigger) {
        switch (method) {
          case "update":
          case "insert":
            return value ? `output ${this.formatter.columnizeWithPrefix("inserted.", value)}${withTrigger ? " into #out" : ""}` : "";
          case "del":
            return value ? `output ${this.formatter.columnizeWithPrefix("deleted.", value)}${withTrigger ? " into #out" : ""}` : "";
          case "rowcount":
            return value ? ";select @@rowcount" : "";
        }
      }
      _buildTempTable(values) {
        if (values && values.length > 0) {
          let selections = "";
          if (Array.isArray(values)) {
            selections = values.map((value) => `[t].${this.formatter.columnize(value)}`).join(",");
          } else {
            selections = `[t].${this.formatter.columnize(values)}`;
          }
          let sql = `select top(0) ${selections} into #out `;
          sql += `from ${this.tableName} as t `;
          sql += `left join ${this.tableName} on 0=1;`;
          return sql;
        }
        return "";
      }
      _buildReturningSelect(values) {
        if (values && values.length > 0) {
          let selections = "";
          if (Array.isArray(values)) {
            selections = values.map((value) => `${this.formatter.columnize(value)}`).join(",");
          } else {
            selections = this.formatter.columnize(values);
          }
          let sql = `; select ${selections} from #out; `;
          sql += `drop table #out;`;
          return sql;
        }
        return "";
      }
      // Compiles a `truncate` query.
      truncate() {
        return `truncate table ${this.tableName}`;
      }
      forUpdate() {
        return "with (UPDLOCK)";
      }
      forShare() {
        return "with (HOLDLOCK)";
      }
      // Compiles a `columnInfo` query.
      columnInfo() {
        const column = this.single.columnInfo;
        let schema = this.single.schema;
        const table = this.client.customWrapIdentifier(this.single.table, identity2);
        if (schema) {
          schema = this.client.customWrapIdentifier(schema, identity2);
        }
        let sql = `select [COLUMN_NAME], [COLUMN_DEFAULT], [DATA_TYPE], [CHARACTER_MAXIMUM_LENGTH], [IS_NULLABLE] from INFORMATION_SCHEMA.COLUMNS where table_name = ? and table_catalog = ?`;
        const bindings = [table, this.client.database()];
        if (schema) {
          sql += " and table_schema = ?";
          bindings.push(schema);
        } else {
          sql += ` and table_schema = 'dbo'`;
        }
        return {
          sql,
          bindings,
          output(resp) {
            const out = resp.reduce((columns, val) => {
              columns[val[0].value] = {
                defaultValue: val[1].value,
                type: val[2].value,
                maxLength: val[3].value,
                nullable: val[4].value === "YES"
              };
              return columns;
            }, {});
            return column && out[column] || out;
          }
        };
      }
      top() {
        const noLimit = !this.single.limit && this.single.limit !== 0;
        const noOffset = !this.single.offset;
        if (noLimit || !noOffset) return "";
        return `top (${this._getValueOrParameterFromAttribute("limit")})`;
      }
      limit() {
        return "";
      }
      offset() {
        const noLimit = !this.single.limit && this.single.limit !== 0;
        const noOffset = !this.single.offset;
        if (noOffset) return "";
        let offset = `offset ${noOffset ? "0" : this._getValueOrParameterFromAttribute("offset")} rows`;
        if (!noLimit) {
          offset += ` fetch next ${this._getValueOrParameterFromAttribute(
            "limit"
          )} rows only`;
        }
        return offset;
      }
      whereLike(statement) {
        return `${this._columnClause(
          statement
        )} collate SQL_Latin1_General_CP1_CS_AS ${this._not(
          statement,
          "like "
        )}${this._valueClause(statement)}`;
      }
      whereILike(statement) {
        return `${this._columnClause(
          statement
        )} collate SQL_Latin1_General_CP1_CI_AS ${this._not(
          statement,
          "like "
        )}${this._valueClause(statement)}`;
      }
      jsonExtract(params) {
        return this._jsonExtract(
          params.singleValue ? "JSON_VALUE" : "JSON_QUERY",
          params
        );
      }
      jsonSet(params) {
        return this._jsonSet("JSON_MODIFY", params);
      }
      jsonInsert(params) {
        return this._jsonSet("JSON_MODIFY", params);
      }
      jsonRemove(params) {
        const jsonCol = `JSON_MODIFY(${columnize_(
          params.column,
          this.builder,
          this.client,
          this.bindingsHolder
        )},${this.client.parameter(
          params.path,
          this.builder,
          this.bindingsHolder
        )}, NULL)`;
        return params.alias ? this.client.alias(jsonCol, this.formatter.wrap(params.alias)) : jsonCol;
      }
      whereJsonPath(statement) {
        return this._whereJsonPath("JSON_VALUE", statement);
      }
      whereJsonSupersetOf(statement) {
        throw new Error(
          "Json superset where clause not actually supported by MSSQL"
        );
      }
      whereJsonSubsetOf(statement) {
        throw new Error("Json subset where clause not actually supported by MSSQL");
      }
      _getExtracts(statement, operator) {
        const column = columnize_(
          statement.column,
          this.builder,
          this.client,
          this.bindingsHolder
        );
        return (Array.isArray(statement.values) ? statement.values : [statement.values]).map(function(value) {
          return "JSON_VALUE(" + column + "," + this.client.parameter(value, this.builder, this.bindingsHolder) + ")";
        }, this).join(operator);
      }
      onJsonPathEquals(clause) {
        return this._onJsonPathEquals("JSON_VALUE", clause);
      }
    };
    module2.exports = QueryCompiler_MSSQL;
  }
});

// node_modules/knex/lib/dialects/mssql/schema/mssql-compiler.js
var require_mssql_compiler = __commonJS({
  "node_modules/knex/lib/dialects/mssql/schema/mssql-compiler.js"(exports2, module2) {
    "use strict";
    var SchemaCompiler = require_compiler();
    var SchemaCompiler_MSSQL = class extends SchemaCompiler {
      constructor(client, builder) {
        super(client, builder);
      }
      dropTableIfExists(tableName) {
        const name28 = this.formatter.wrap(prefixedTableName(this.schema, tableName));
        this.pushQuery(
          `if object_id('${name28}', 'U') is not null DROP TABLE ${name28}`
        );
      }
      dropViewIfExists(viewName) {
        const name28 = this.formatter.wrap(prefixedTableName(this.schema, viewName));
        this.pushQuery(
          `if object_id('${name28}', 'V') is not null DROP VIEW ${name28}`
        );
      }
      // Rename a table on the schema.
      renameTable(tableName, to) {
        this.pushQuery(
          `exec sp_rename ${this.client.parameter(
            prefixedTableName(this.schema, tableName),
            this.builder,
            this.bindingsHolder
          )}, ${this.client.parameter(to, this.builder, this.bindingsHolder)}`
        );
      }
      renameView(viewTable, to) {
        this.pushQuery(
          `exec sp_rename ${this.client.parameter(
            prefixedTableName(this.schema, viewTable),
            this.builder,
            this.bindingsHolder
          )}, ${this.client.parameter(to, this.builder, this.bindingsHolder)}`
        );
      }
      // Check whether a table exists on the query.
      hasTable(tableName) {
        const formattedTable = this.client.parameter(
          prefixedTableName(this.schema, tableName),
          this.builder,
          this.bindingsHolder
        );
        const bindings = [tableName];
        let sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = ${formattedTable}`;
        if (this.schema) {
          sql += " AND TABLE_SCHEMA = ?";
          bindings.push(this.schema);
        }
        this.pushQuery({ sql, bindings, output: (resp) => resp.length > 0 });
      }
      // Check whether a column exists on the schema.
      hasColumn(tableName, column) {
        const formattedColumn = this.client.parameter(
          column,
          this.builder,
          this.bindingsHolder
        );
        const formattedTable = this.client.parameter(
          this.formatter.wrap(prefixedTableName(this.schema, tableName)),
          this.builder,
          this.bindingsHolder
        );
        const sql = `select object_id from sys.columns where name = ${formattedColumn} and object_id = object_id(${formattedTable})`;
        this.pushQuery({ sql, output: (resp) => resp.length > 0 });
      }
    };
    SchemaCompiler_MSSQL.prototype.dropTablePrefix = "DROP TABLE ";
    function prefixedTableName(prefix, table) {
      return prefix ? `${prefix}.${table}` : table;
    }
    module2.exports = SchemaCompiler_MSSQL;
  }
});

// node_modules/knex/lib/dialects/mssql/schema/mssql-tablecompiler.js
var require_mssql_tablecompiler = __commonJS({
  "node_modules/knex/lib/dialects/mssql/schema/mssql-tablecompiler.js"(exports2, module2) {
    "use strict";
    var TableCompiler = require_tablecompiler();
    var helpers = require_helpers();
    var { isObject: isObject5 } = require_is();
    var TableCompiler_MSSQL = class extends TableCompiler {
      constructor(client, tableBuilder) {
        super(client, tableBuilder);
      }
      createQuery(columns, ifNot, like) {
        let createStatement = ifNot ? `if object_id('${this.tableName()}', 'U') is null ` : "";
        if (like) {
          createStatement += `SELECT * INTO ${this.tableName()} FROM ${this.tableNameLike()} WHERE 0=1`;
        } else {
          createStatement += "CREATE TABLE " + this.tableName() + (this._formatting ? " (\n    " : " (") + columns.sql.join(this._formatting ? ",\n    " : ", ") + this._addChecks() + ")";
        }
        this.pushQuery(createStatement);
        if (this.single.comment) {
          this.comment(this.single.comment);
        }
        if (like) {
          this.addColumns(columns, this.addColumnsPrefix);
        }
      }
      comment(comment) {
        if (!comment) {
          return;
        }
        if (comment.length > 7500 / 2) {
          this.client.logger.warn(
            "Your comment might be longer than the max comment length for MSSQL of 7,500 bytes."
          );
        }
        const value = this.formatter.escapingStringDelimiters(comment);
        const level0name = this.formatter.escapingStringDelimiters(
          this.schemaNameRaw || "dbo"
        );
        const level1name = this.formatter.escapingStringDelimiters(
          this.tableNameRaw
        );
        const args = `N'MS_Description', N'${value}', N'Schema', N'${level0name}', N'Table', N'${level1name}'`;
        const isAlreadyDefined = `EXISTS(SELECT * FROM sys.fn_listextendedproperty(N'MS_Description', N'Schema', N'${level0name}', N'Table', N'${level1name}', NULL, NULL))`;
        this.pushQuery(
          `IF ${isAlreadyDefined}
  EXEC sys.sp_updateextendedproperty ${args}
ELSE
  EXEC sys.sp_addextendedproperty ${args}`
        );
      }
      // Compiles column add.  Multiple columns need only one ADD clause (not one ADD per column) so core addColumns doesn't work.  #1348
      addColumns(columns, prefix) {
        prefix = prefix || this.addColumnsPrefix;
        if (columns.sql.length > 0) {
          this.pushQuery({
            sql: (this.lowerCase ? "alter table " : "ALTER TABLE ") + this.tableName() + " " + prefix + columns.sql.join(", "),
            bindings: columns.bindings
          });
        }
      }
      alterColumns(columns, colBuilder) {
        for (let i = 0, l = colBuilder.length; i < l; i++) {
          const builder = colBuilder[i];
          if (builder.modified.defaultTo) {
            const schema = this.schemaNameRaw || "dbo";
            const baseQuery = `
              DECLARE @constraint varchar(100) = (SELECT default_constraints.name
                                                  FROM sys.all_columns
                                                  INNER JOIN sys.tables
                                                    ON all_columns.object_id = tables.object_id
                                                  INNER JOIN sys.schemas
                                                    ON tables.schema_id = schemas.schema_id
                                                  INNER JOIN sys.default_constraints
                                                    ON all_columns.default_object_id = default_constraints.object_id
                                                  WHERE schemas.name = '${schema}'
                                                  AND tables.name = '${this.tableNameRaw}'
                                                  AND all_columns.name = '${builder.getColumnName()}')

              IF @constraint IS NOT NULL EXEC('ALTER TABLE ${this.tableNameRaw} DROP CONSTRAINT ' + @constraint)`;
            this.pushQuery(baseQuery);
          }
        }
        columns.sql.forEach((sql) => {
          this.pushQuery({
            sql: (this.lowerCase ? "alter table " : "ALTER TABLE ") + this.tableName() + " " + (this.lowerCase ? this.alterColumnPrefix.toLowerCase() : this.alterColumnPrefix) + sql,
            bindings: columns.bindings
          });
        });
      }
      // Compiles column drop.  Multiple columns need only one DROP clause (not one DROP per column) so core dropColumn doesn't work.  #1348
      dropColumn() {
        const _this2 = this;
        const columns = helpers.normalizeArr.apply(null, arguments);
        const columnsArray = Array.isArray(columns) ? columns : [columns];
        const drops = columnsArray.map((column) => _this2.formatter.wrap(column));
        const schema = this.schemaNameRaw || "dbo";
        for (const column of columns) {
          const baseQuery = `
              DECLARE @constraint varchar(100) = (SELECT default_constraints.name
                                                  FROM sys.all_columns
                                                  INNER JOIN sys.tables
                                                    ON all_columns.object_id = tables.object_id
                                                  INNER JOIN sys.schemas
                                                    ON tables.schema_id = schemas.schema_id
                                                  INNER JOIN sys.default_constraints
                                                    ON all_columns.default_object_id = default_constraints.object_id
                                                  WHERE schemas.name = '${schema}'
                                                  AND tables.name = '${this.tableNameRaw}'
                                                  AND all_columns.name = '${column}')

              IF @constraint IS NOT NULL EXEC('ALTER TABLE ${this.tableNameRaw} DROP CONSTRAINT ' + @constraint)`;
          this.pushQuery(baseQuery);
        }
        this.pushQuery(
          (this.lowerCase ? "alter table " : "ALTER TABLE ") + this.tableName() + " " + this.dropColumnPrefix + drops.join(", ")
        );
      }
      changeType() {
      }
      // Renames a column on the table.
      renameColumn(from, to) {
        this.pushQuery(
          `exec sp_rename ${this.client.parameter(
            this.tableName() + "." + from,
            this.tableBuilder,
            this.bindingsHolder
          )}, ${this.client.parameter(
            to,
            this.tableBuilder,
            this.bindingsHolder
          )}, 'COLUMN'`
        );
      }
      dropFKRefs(runner, refs) {
        const formatter = this.client.formatter(this.tableBuilder);
        return Promise.all(
          refs.map(function(ref) {
            const constraintName = formatter.wrap(ref.CONSTRAINT_NAME);
            const tableName = formatter.wrap(ref.TABLE_NAME);
            return runner.query({
              sql: `ALTER TABLE ${tableName} DROP CONSTRAINT ${constraintName}`
            });
          })
        );
      }
      createFKRefs(runner, refs) {
        const formatter = this.client.formatter(this.tableBuilder);
        return Promise.all(
          refs.map(function(ref) {
            const tableName = formatter.wrap(ref.TABLE_NAME);
            const keyName = formatter.wrap(ref.CONSTRAINT_NAME);
            const column = formatter.columnize(ref.COLUMN_NAME);
            const references = formatter.columnize(ref.REFERENCED_COLUMN_NAME);
            const inTable = formatter.wrap(ref.REFERENCED_TABLE_NAME);
            const onUpdate = ` ON UPDATE ${ref.UPDATE_RULE}`;
            const onDelete = ` ON DELETE ${ref.DELETE_RULE}`;
            return runner.query({
              sql: `ALTER TABLE ${tableName} ADD CONSTRAINT ${keyName} FOREIGN KEY (` + column + ") REFERENCES " + inTable + " (" + references + ")" + onUpdate + onDelete
            });
          })
        );
      }
      index(columns, indexName, options) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        let predicate;
        if (isObject5(options)) {
          ({ predicate } = options);
        }
        const predicateQuery = predicate ? " " + this.client.queryCompiler(predicate).where() : "";
        this.pushQuery(
          `CREATE INDEX ${indexName} ON ${this.tableName()} (${this.formatter.columnize(
            columns
          )})${predicateQuery}`
        );
      }
      /**
       * Create a primary key.
       *
       * @param {undefined | string | string[]} columns
       * @param {string | {constraintName: string, deferrable?: 'not deferrable'|'deferred'|'immediate' }} constraintName
       */
      primary(columns, constraintName) {
        let deferrable;
        if (isObject5(constraintName)) {
          ({ constraintName, deferrable } = constraintName);
        }
        if (deferrable && deferrable !== "not deferrable") {
          this.client.logger.warn(
            `mssql: primary key constraint [${constraintName}] will not be deferrable ${deferrable} because mssql does not support deferred constraints.`
          );
        }
        constraintName = constraintName ? this.formatter.wrap(constraintName) : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
        if (!this.forCreate) {
          this.pushQuery(
            `ALTER TABLE ${this.tableName()} ADD CONSTRAINT ${constraintName} PRIMARY KEY (${this.formatter.columnize(
              columns
            )})`
          );
        } else {
          this.pushQuery(
            `CONSTRAINT ${constraintName} PRIMARY KEY (${this.formatter.columnize(
              columns
            )})`
          );
        }
      }
      /**
       * Create a unique index.
       *
       * @param {string | string[]} columns
       * @param {string | {indexName: undefined | string, deferrable?: 'not deferrable'|'deferred'|'immediate', useConstraint?: true|false, predicate?: QueryBuilder }} indexName
       */
      unique(columns, indexName) {
        let deferrable;
        let useConstraint = false;
        let predicate;
        if (isObject5(indexName)) {
          ({ indexName, deferrable, useConstraint, predicate } = indexName);
        }
        if (deferrable && deferrable !== "not deferrable") {
          this.client.logger.warn(
            `mssql: unique index [${indexName}] will not be deferrable ${deferrable} because mssql does not support deferred constraints.`
          );
        }
        if (useConstraint && predicate) {
          throw new Error("mssql cannot create constraint with predicate");
        }
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        if (!Array.isArray(columns)) {
          columns = [columns];
        }
        if (useConstraint) {
          this.pushQuery(
            `ALTER TABLE ${this.tableName()} ADD CONSTRAINT ${indexName} UNIQUE (${this.formatter.columnize(
              columns
            )})`
          );
        } else {
          const predicateQuery = predicate ? " " + this.client.queryCompiler(predicate).where() : " WHERE " + columns.map((column) => this.formatter.columnize(column) + " IS NOT NULL").join(" AND ");
          this.pushQuery(
            `CREATE UNIQUE INDEX ${indexName} ON ${this.tableName()} (${this.formatter.columnize(
              columns
            )})${predicateQuery}`
          );
        }
      }
      // Compile a drop index command.
      dropIndex(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        this.pushQuery(`DROP INDEX ${indexName} ON ${this.tableName()}`);
      }
      // Compile a drop foreign key command.
      dropForeign(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("foreign", this.tableNameRaw, columns);
        this.pushQuery(
          `ALTER TABLE ${this.tableName()} DROP CONSTRAINT ${indexName}`
        );
      }
      dropForeignIfExists() {
        throw new Error(".dropForeignIfExists is not supported for mssql.");
      }
      // Compile a drop primary key command.
      dropPrimary(constraintName) {
        constraintName = constraintName ? this.formatter.wrap(constraintName) : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
        this.pushQuery(
          `ALTER TABLE ${this.tableName()} DROP CONSTRAINT ${constraintName}`
        );
      }
      dropPrimaryIfExists() {
        throw new Error(".dropPrimaryIfExists is not supported for mssql.");
      }
      // Compile a drop unique key command.
      dropUnique(column, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, column);
        this.pushQuery(`DROP INDEX ${indexName} ON ${this.tableName()}`);
      }
      dropUniqueIfExists(column, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, column);
        this.pushQuery(`DROP INDEX IF EXISTS ${indexName} ON ${this.tableName()}`);
      }
    };
    TableCompiler_MSSQL.prototype.createAlterTableMethods = ["foreign", "primary"];
    TableCompiler_MSSQL.prototype.lowerCase = false;
    TableCompiler_MSSQL.prototype.addColumnsPrefix = "ADD ";
    TableCompiler_MSSQL.prototype.dropColumnPrefix = "DROP COLUMN ";
    TableCompiler_MSSQL.prototype.alterColumnPrefix = "ALTER COLUMN ";
    module2.exports = TableCompiler_MSSQL;
  }
});

// node_modules/knex/lib/dialects/mssql/schema/mssql-viewcompiler.js
var require_mssql_viewcompiler = __commonJS({
  "node_modules/knex/lib/dialects/mssql/schema/mssql-viewcompiler.js"(exports2, module2) {
    "use strict";
    var ViewCompiler = require_viewcompiler();
    var {
      columnize: columnize_
    } = require_wrappingFormatter();
    var ViewCompiler_MSSQL = class extends ViewCompiler {
      constructor(client, viewCompiler) {
        super(client, viewCompiler);
      }
      createQuery(columns, selectQuery, materialized, replace) {
        const createStatement = "CREATE " + (replace ? "OR ALTER " : "") + "VIEW ";
        let sql = createStatement + this.viewName();
        const columnList = columns ? " (" + columnize_(
          columns,
          this.viewBuilder,
          this.client,
          this.bindingsHolder
        ) + ")" : "";
        sql += columnList;
        sql += " AS ";
        sql += selectQuery.toString();
        this.pushQuery({
          sql
        });
      }
      renameColumn(from, to) {
        this.pushQuery(
          `exec sp_rename ${this.client.parameter(
            this.viewName() + "." + from,
            this.viewBuilder,
            this.bindingsHolder
          )}, ${this.client.parameter(
            to,
            this.viewBuilder,
            this.bindingsHolder
          )}, 'COLUMN'`
        );
      }
      createOrReplace() {
        this.createQuery(this.columns, this.selectQuery, false, true);
      }
    };
    module2.exports = ViewCompiler_MSSQL;
  }
});

// node_modules/knex/lib/dialects/mssql/schema/mssql-columncompiler.js
var require_mssql_columncompiler = __commonJS({
  "node_modules/knex/lib/dialects/mssql/schema/mssql-columncompiler.js"(exports2, module2) {
    "use strict";
    var ColumnCompiler = require_columncompiler();
    var { toNumber: toNumber2 } = require_helpers();
    var { formatDefault } = require_formatterUtils();
    var { operator: operator_ } = require_wrappingFormatter();
    var ColumnCompiler_MSSQL = class extends ColumnCompiler {
      constructor(client, tableCompiler, columnBuilder) {
        super(client, tableCompiler, columnBuilder);
        this.modifiers = ["nullable", "defaultTo", "first", "after", "comment"];
        this._addCheckModifiers();
      }
      // Types
      // ------
      double(precision, scale) {
        return "float";
      }
      floating(precision, scale) {
        return `float`;
      }
      integer() {
        return "int";
      }
      tinyint() {
        return "tinyint";
      }
      varchar(length) {
        return `nvarchar(${toNumber2(length, 255)})`;
      }
      timestamp({ useTz = false } = {}) {
        return useTz ? "datetimeoffset" : "datetime2";
      }
      bit(length) {
        if (length > 1) {
          this.client.logger.warn("Bit field is exactly 1 bit length for MSSQL");
        }
        return "bit";
      }
      binary(length) {
        return length ? `varbinary(${toNumber2(length)})` : "varbinary(max)";
      }
      // Modifiers
      // ------
      first() {
        this.client.logger.warn("Column first modifier not available for MSSQL");
        return "";
      }
      after(column) {
        this.client.logger.warn("Column after modifier not available for MSSQL");
        return "";
      }
      defaultTo(value, { constraintName } = {}) {
        const formattedValue = formatDefault(value, this.type, this.client);
        constraintName = typeof constraintName !== "undefined" ? constraintName : `${this.tableCompiler.tableNameRaw}_${this.getColumnName()}_default`.toLowerCase();
        if (this.columnBuilder._method === "alter") {
          this.pushAdditional(function() {
            this.pushQuery(
              `ALTER TABLE ${this.tableCompiler.tableName()} ADD CONSTRAINT ${this.formatter.wrap(
                constraintName
              )} DEFAULT ${formattedValue} FOR ${this.formatter.wrap(
                this.getColumnName()
              )}`
            );
          });
          return "";
        }
        if (!constraintName) {
          return `DEFAULT ${formattedValue}`;
        }
        return `CONSTRAINT ${this.formatter.wrap(
          constraintName
        )} DEFAULT ${formattedValue}`;
      }
      comment(comment) {
        if (!comment) {
          return;
        }
        if (comment && comment.length > 7500 / 2) {
          this.client.logger.warn(
            "Your comment might be longer than the max comment length for MSSQL of 7,500 bytes."
          );
        }
        const value = this.formatter.escapingStringDelimiters(comment);
        const level0name = this.tableCompiler.schemaNameRaw || "dbo";
        const level1name = this.formatter.escapingStringDelimiters(
          this.tableCompiler.tableNameRaw
        );
        const level2name = this.formatter.escapingStringDelimiters(
          this.args[0] || this.defaults("columnName")
        );
        const args = `N'MS_Description', N'${value}', N'Schema', N'${level0name}', N'Table', N'${level1name}', N'Column', N'${level2name}'`;
        this.pushAdditional(function() {
          const isAlreadyDefined = `EXISTS(SELECT * FROM sys.fn_listextendedproperty(N'MS_Description', N'Schema', N'${level0name}', N'Table', N'${level1name}', N'Column', N'${level2name}'))`;
          this.pushQuery(
            `IF ${isAlreadyDefined}
  EXEC sys.sp_updateextendedproperty ${args}
ELSE
  EXEC sys.sp_addextendedproperty ${args}`
          );
        });
        return "";
      }
      checkLength(operator, length, constraintName) {
        return this._check(
          `LEN(${this.formatter.wrap(this.getColumnName())}) ${operator_(
            operator,
            this.columnBuilder,
            this.bindingsHolder
          )} ${toNumber2(length)}`,
          constraintName
        );
      }
      checkRegex(regex, constraintName) {
        return this._check(
          `${this.formatter.wrap(
            this.getColumnName()
          )} LIKE ${this.client._escapeBinding("%" + regex + "%")}`,
          constraintName
        );
      }
      increments(options = { primaryKey: true }) {
        return "int identity(1,1) not null" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
      }
      bigincrements(options = { primaryKey: true }) {
        return "bigint identity(1,1) not null" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
      }
    };
    ColumnCompiler_MSSQL.prototype.bigint = "bigint";
    ColumnCompiler_MSSQL.prototype.mediumint = "int";
    ColumnCompiler_MSSQL.prototype.smallint = "smallint";
    ColumnCompiler_MSSQL.prototype.text = "nvarchar(max)";
    ColumnCompiler_MSSQL.prototype.mediumtext = "nvarchar(max)";
    ColumnCompiler_MSSQL.prototype.longtext = "nvarchar(max)";
    ColumnCompiler_MSSQL.prototype.json = ColumnCompiler_MSSQL.prototype.jsonb = "nvarchar(max)";
    ColumnCompiler_MSSQL.prototype.enu = "nvarchar(100)";
    ColumnCompiler_MSSQL.prototype.uuid = ({ useBinaryUuid = false } = {}) => useBinaryUuid ? "binary(16)" : "uniqueidentifier";
    ColumnCompiler_MSSQL.prototype.datetime = "datetime2";
    ColumnCompiler_MSSQL.prototype.bool = "bit";
    module2.exports = ColumnCompiler_MSSQL;
  }
});

// node_modules/knex/lib/dialects/mssql/index.js
var require_mssql = __commonJS({
  "node_modules/knex/lib/dialects/mssql/index.js"(exports2, module2) {
    "use strict";
    var map3 = require_map();
    var isNil = require_isNil();
    var Client2 = require_client2();
    var MSSQL_Formatter = require_mssql_formatter();
    var Transaction = require_transaction2();
    var QueryCompiler = require_mssql_querycompiler();
    var SchemaCompiler = require_mssql_compiler();
    var TableCompiler = require_mssql_tablecompiler();
    var ViewCompiler = require_mssql_viewcompiler();
    var ColumnCompiler = require_mssql_columncompiler();
    var QueryBuilder = require_querybuilder();
    var { setHiddenProperty } = require_security();
    var debug = require_src3()("knex:mssql");
    var SQL_INT4 = { MIN: -2147483648, MAX: 2147483647 };
    var SQL_BIGINT_SAFE = { MIN: -9007199254740991, MAX: 9007199254740991 };
    var Client_MSSQL = class extends Client2 {
      constructor(config3 = {}) {
        super(config3);
      }
      /**
       * @param {import('knex').Config} options
       */
      _generateConnection() {
        const settings = this.connectionSettings;
        settings.options = settings.options || {};
        const cfg = {
          authentication: {
            type: settings.type || "default",
            options: {
              userName: settings.userName || settings.user,
              password: settings.password,
              domain: settings.domain,
              token: settings.token,
              clientId: settings.clientId,
              clientSecret: settings.clientSecret,
              tenantId: settings.tenantId,
              msiEndpoint: settings.msiEndpoint
            }
          },
          server: settings.server || settings.host,
          options: {
            database: settings.database,
            encrypt: settings.encrypt || false,
            port: settings.port || 1433,
            connectTimeout: settings.connectionTimeout || settings.timeout || 15e3,
            requestTimeout: !isNil(settings.requestTimeout) ? settings.requestTimeout : 15e3,
            rowCollectionOnDone: false,
            rowCollectionOnRequestCompletion: false,
            useColumnNames: false,
            tdsVersion: settings.options.tdsVersion || "7_4",
            appName: settings.options.appName || "knex",
            trustServerCertificate: false,
            ...settings.options
          }
        };
        if (cfg.authentication.options.password) {
          setHiddenProperty(cfg.authentication.options);
        }
        if (cfg.options.instanceName) delete cfg.options.port;
        if (isNaN(cfg.options.requestTimeout)) cfg.options.requestTimeout = 15e3;
        if (cfg.options.requestTimeout === Infinity) cfg.options.requestTimeout = 0;
        if (cfg.options.requestTimeout < 0) cfg.options.requestTimeout = 0;
        if (settings.debug) {
          cfg.options.debug = {
            packet: true,
            token: true,
            data: true,
            payload: true
          };
        }
        return cfg;
      }
      _driver() {
        const tds = require("tedious");
        return tds;
      }
      formatter() {
        return new MSSQL_Formatter(this, ...arguments);
      }
      transaction() {
        return new Transaction(this, ...arguments);
      }
      queryCompiler() {
        return new QueryCompiler(this, ...arguments);
      }
      schemaCompiler() {
        return new SchemaCompiler(this, ...arguments);
      }
      tableCompiler() {
        return new TableCompiler(this, ...arguments);
      }
      viewCompiler() {
        return new ViewCompiler(this, ...arguments);
      }
      queryBuilder() {
        const b = new QueryBuilder(this);
        return b;
      }
      columnCompiler() {
        return new ColumnCompiler(this, ...arguments);
      }
      wrapIdentifierImpl(value) {
        if (value === "*") {
          return "*";
        }
        return `[${value.replace(/[[\]]+/g, "")}]`;
      }
      // Get a raw connection, called by the `pool` whenever a new
      // connection needs to be added to the pool.
      acquireRawConnection() {
        return new Promise((resolver, rejecter) => {
          debug("connection::connection new connection requested");
          const Driver = this._driver();
          const settings = Object.assign({}, this._generateConnection());
          const connection = new Driver.Connection(settings);
          connection.connect((err) => {
            if (err) {
              debug("connection::connect error: %s", err.message);
              return rejecter(err);
            }
            debug("connection::connect connected to server");
            connection.connected = true;
            connection.on("error", (e) => {
              debug("connection::error message=%s", e.message);
              connection.__knex__disposed = e;
              connection.connected = false;
            });
            connection.once("end", () => {
              connection.connected = false;
              connection.__knex__disposed = "Connection to server was terminated.";
              debug("connection::end connection ended.");
            });
            return resolver(connection);
          });
        });
      }
      validateConnection(connection) {
        return connection && connection.connected;
      }
      // Used to explicitly close a connection, called internally by the pool
      // when a connection times out or the pool is shutdown.
      destroyRawConnection(connection) {
        debug("connection::destroy");
        return new Promise((resolve3) => {
          connection.once("end", () => {
            resolve3();
          });
          connection.close();
        });
      }
      // Position the bindings for the query.
      positionBindings(sql) {
        let questionCount = -1;
        return sql.replace(/\\?\?/g, (match) => {
          if (match === "\\?") {
            return "?";
          }
          questionCount += 1;
          return `@p${questionCount}`;
        });
      }
      _chomp(connection) {
        if (connection.state.name === "LoggedIn") {
          const nextRequest = this.requestQueue.pop();
          if (nextRequest) {
            debug(
              "connection::query executing query, %d more in queue",
              this.requestQueue.length
            );
            connection.execSql(nextRequest);
          }
        }
      }
      _enqueueRequest(request, connection) {
        this.requestQueue.push(request);
        this._chomp(connection);
      }
      _makeRequest(query, callback) {
        const Driver = this._driver();
        const sql = typeof query === "string" ? query : query.sql;
        let rowCount = 0;
        if (!sql) throw new Error("The query is empty");
        debug("request::request sql=%s", sql);
        const request = new Driver.Request(sql, (err, remoteRowCount) => {
          if (err) {
            debug("request::error message=%s", err.message);
            return callback(err);
          }
          rowCount = remoteRowCount;
          debug("request::callback rowCount=%d", rowCount);
        });
        request.on("prepared", () => {
          debug("request %s::request prepared", this.id);
        });
        request.on("done", (rowCount2, more) => {
          debug("request::done rowCount=%d more=%s", rowCount2, more);
        });
        request.on("doneProc", (rowCount2, more) => {
          debug(
            "request::doneProc id=%s rowCount=%d more=%s",
            request.id,
            rowCount2,
            more
          );
        });
        request.on("doneInProc", (rowCount2, more) => {
          debug(
            "request::doneInProc id=%s rowCount=%d more=%s",
            request.id,
            rowCount2,
            more
          );
        });
        request.once("requestCompleted", () => {
          debug("request::completed id=%s", request.id);
          return callback(null, rowCount);
        });
        request.on("error", (err) => {
          debug("request::error id=%s message=%s", request.id, err.message);
          return callback(err);
        });
        return request;
      }
      // Grab a connection, run the query via the MSSQL streaming interface,
      // and pass that through to the stream we've sent back to the client.
      _stream(connection, query, stream4) {
        return new Promise((resolve3, reject) => {
          const request = this._makeRequest(query, (err) => {
            if (err) {
              stream4.emit("error", err);
              return reject(err);
            }
            resolve3();
          });
          request.on("row", (row) => {
            stream4.write(
              row.reduce((prev, curr) => {
                prev[curr.metadata.colName] = curr.value;
                return prev;
              }, {})
            );
          });
          request.on("error", (err) => {
            stream4.emit("error", err);
            reject(err);
          });
          request.once("requestCompleted", () => {
            stream4.end();
            resolve3();
          });
          this._assignBindings(request, query.bindings);
          this._enqueueRequest(request, connection);
        });
      }
      _assignBindings(request, bindings) {
        if (Array.isArray(bindings)) {
          for (let i = 0; i < bindings.length; i++) {
            const binding = bindings[i];
            this._setReqInput(request, i, binding);
          }
        }
      }
      _scaleForBinding(binding) {
        if (binding % 1 === 0) {
          throw new Error(`The binding value ${binding} must be a decimal number.`);
        }
        return { scale: 10 };
      }
      _typeForBinding(binding) {
        const Driver = this._driver();
        if (this.connectionSettings.options && this.connectionSettings.options.mapBinding) {
          const result = this.connectionSettings.options.mapBinding(binding);
          if (result) {
            return [result.value, result.type];
          }
        }
        switch (typeof binding) {
          case "string":
            return [binding, Driver.TYPES.NVarChar];
          case "boolean":
            return [binding, Driver.TYPES.Bit];
          case "number": {
            if (binding % 1 !== 0) {
              return [binding, Driver.TYPES.Float];
            }
            if (binding < SQL_INT4.MIN || binding > SQL_INT4.MAX) {
              if (binding < SQL_BIGINT_SAFE.MIN || binding > SQL_BIGINT_SAFE.MAX) {
                throw new Error(
                  `Bigint must be safe integer or must be passed as string, saw ${binding}`
                );
              }
              return [binding, Driver.TYPES.BigInt];
            }
            return [binding, Driver.TYPES.Int];
          }
          default: {
            if (binding instanceof Date) {
              return [binding, Driver.TYPES.DateTime];
            }
            if (binding instanceof Buffer) {
              return [binding, Driver.TYPES.VarBinary];
            }
            return [binding, Driver.TYPES.NVarChar];
          }
        }
      }
      // Runs the query on the specified connection, providing the bindings
      // and any other necessary prep work.
      _query(connection, query) {
        return new Promise((resolve3, reject) => {
          const rows = [];
          const request = this._makeRequest(query, (err, count) => {
            if (err) {
              return reject(err);
            }
            query.response = rows;
            process.nextTick(() => this._chomp(connection));
            resolve3(query);
          });
          request.on("row", (row) => {
            debug("request::row");
            rows.push(row);
          });
          this._assignBindings(request, query.bindings);
          this._enqueueRequest(request, connection);
        });
      }
      // sets a request input parameter. Detects bigints and decimals and sets type appropriately.
      _setReqInput(req, i, inputBinding) {
        const [binding, tediousType] = this._typeForBinding(inputBinding);
        const bindingName = "p".concat(i);
        let options;
        if (typeof binding === "number" && binding % 1 !== 0) {
          options = this._scaleForBinding(binding);
        }
        debug(
          "request::binding pos=%d type=%s value=%s",
          i,
          tediousType.name,
          binding
        );
        if (Buffer.isBuffer(binding)) {
          options = {
            length: "max"
          };
        }
        req.addParameter(bindingName, tediousType, binding, options);
      }
      // Process the response as returned from the query.
      processResponse(query, runner) {
        if (query == null) return;
        let { response } = query;
        const { method } = query;
        if (query.output) {
          return query.output.call(runner, response);
        }
        response = response.map(
          (row) => row.reduce((columns, r) => {
            const colName = r.metadata.colName;
            if (columns[colName]) {
              if (!Array.isArray(columns[colName])) {
                columns[colName] = [columns[colName]];
              }
              columns[colName].push(r.value);
            } else {
              columns[colName] = r.value;
            }
            return columns;
          }, {})
        );
        if (query.output) return query.output.call(runner, response);
        switch (method) {
          case "select":
            return response;
          case "first":
            return response[0];
          case "pluck":
            return map3(response, query.pluck);
          case "insert":
          case "del":
          case "update":
          case "counter":
            if (query.returning) {
              if (query.returning === "@@rowcount") {
                return response[0][""];
              }
            }
            return response;
          default:
            return response;
        }
      }
    };
    Object.assign(Client_MSSQL.prototype, {
      requestQueue: [],
      dialect: "mssql",
      driverName: "mssql"
    });
    module2.exports = Client_MSSQL;
  }
});

// node_modules/lodash/_baseDelay.js
var require_baseDelay = __commonJS({
  "node_modules/lodash/_baseDelay.js"(exports2, module2) {
    "use strict";
    var FUNC_ERROR_TEXT2 = "Expected a function";
    function baseDelay(func, wait, args) {
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT2);
      }
      return setTimeout(function() {
        func.apply(void 0, args);
      }, wait);
    }
    module2.exports = baseDelay;
  }
});

// node_modules/lodash/defer.js
var require_defer = __commonJS({
  "node_modules/lodash/defer.js"(exports2, module2) {
    "use strict";
    var baseDelay = require_baseDelay();
    var baseRest = require_baseRest();
    var defer = baseRest(function(func, args) {
      return baseDelay(func, 1, args);
    });
    module2.exports = defer;
  }
});

// node_modules/knex/lib/dialects/mysql/transaction.js
var require_transaction3 = __commonJS({
  "node_modules/knex/lib/dialects/mysql/transaction.js"(exports2, module2) {
    "use strict";
    var Transaction = require_transaction();
    var Debug = require_src3();
    var debug = Debug("knex:tx");
    var Transaction_MySQL = class extends Transaction {
      query(conn, sql, status, value) {
        const t = this;
        const q = this.trxClient.query(conn, sql).catch((err) => {
          if (err.errno === 1305) {
            this.trxClient.logger.warn(
              "Transaction was implicitly committed, do not mix transactions and DDL with MySQL (#805)"
            );
            return;
          }
          status = 2;
          value = err;
          t._completed = true;
          debug("%s error running transaction query", t.txid);
        }).then(function(res) {
          if (status === 1) t._resolver(value);
          if (status === 2) {
            if (value === void 0) {
              if (t.doNotRejectOnRollback && /^ROLLBACK\b/i.test(sql)) {
                t._resolver();
                return;
              }
              value = new Error(`Transaction rejected with non-error: ${value}`);
            }
            t._rejecter(value);
          }
          return res;
        });
        if (status === 1 || status === 2) {
          t._completed = true;
        }
        return q;
      }
    };
    module2.exports = Transaction_MySQL;
  }
});

// node_modules/knex/lib/dialects/mysql/query/mysql-querybuilder.js
var require_mysql_querybuilder = __commonJS({
  "node_modules/knex/lib/dialects/mysql/query/mysql-querybuilder.js"(exports2, module2) {
    "use strict";
    var QueryBuilder = require_querybuilder();
    var isEmpty = require_isEmpty();
    module2.exports = class QueryBuilder_MySQL extends QueryBuilder {
      upsert(values, returning, options) {
        this._method = "upsert";
        if (!isEmpty(returning)) {
          this.returning(returning, options);
        }
        this._single.upsert = values;
        return this;
      }
    };
  }
});

// node_modules/knex/lib/dialects/mysql/query/mysql-querycompiler.js
var require_mysql_querycompiler = __commonJS({
  "node_modules/knex/lib/dialects/mysql/query/mysql-querycompiler.js"(exports2, module2) {
    "use strict";
    var assert3 = require("assert");
    var identity2 = require_identity();
    var isPlainObject4 = require_isPlainObject();
    var isEmpty = require_isEmpty();
    var QueryCompiler = require_querycompiler();
    var { wrapAsIdentifier } = require_formatterUtils();
    var {
      columnize: columnize_,
      wrap: wrap_
    } = require_wrappingFormatter();
    var isPlainObjectOrArray = (value) => isPlainObject4(value) || Array.isArray(value);
    var QueryCompiler_MySQL = class extends QueryCompiler {
      constructor(client, builder, formatter) {
        super(client, builder, formatter);
        const { returning } = this.single;
        if (returning) {
          this.client.logger.warn(
            ".returning() is not supported by mysql and will not have any effect."
          );
        }
        this._emptyInsertValue = "() values ()";
      }
      // Compiles an `delete` allowing comments
      del() {
        const sql = super.del();
        if (sql === "") return sql;
        const comments = this.comments();
        return (comments === "" ? "" : comments + " ") + sql;
      }
      // Compiles an `insert` query, allowing for multiple
      // inserts using a single query statement.
      insert() {
        let sql = super.insert();
        if (sql === "") return sql;
        const comments = this.comments();
        sql = (comments === "" ? "" : comments + " ") + sql;
        const { ignore, merge: merge4, insert } = this.single;
        if (ignore) sql = sql.replace("insert into", "insert ignore into");
        if (merge4) {
          sql += this._merge(merge4.updates, insert);
          const wheres = this.where();
          if (wheres) {
            throw new Error(
              ".onConflict().merge().where() is not supported for mysql"
            );
          }
        }
        return sql;
      }
      upsert() {
        const upsertValues = this.single.upsert || [];
        const sql = this.with() + `replace into ${this.tableName} `;
        const body = this._insertBody(upsertValues);
        return body === "" ? "" : sql + body;
      }
      // Compiles merge for onConflict, allowing for different merge strategies
      _merge(updates, insert) {
        const sql = " on duplicate key update ";
        if (updates && Array.isArray(updates)) {
          return sql + updates.map(
            (column) => wrapAsIdentifier(column, this.formatter.builder, this.client)
          ).map((column) => `${column} = values(${column})`).join(", ");
        } else if (updates && typeof updates === "object") {
          const updateData = this._prepUpdate(updates);
          return sql + updateData.join(",");
        } else {
          const insertData = this._prepInsert(insert);
          if (typeof insertData === "string") {
            throw new Error(
              "If using merge with a raw insert query, then updates must be provided"
            );
          }
          return sql + insertData.columns.map((column) => wrapAsIdentifier(column, this.builder, this.client)).map((column) => `${column} = values(${column})`).join(", ");
        }
      }
      // Update method, including joins, wheres, order & limits.
      update() {
        const comments = this.comments();
        const withSQL = this.with();
        const join2 = this.join();
        const updates = this._prepUpdate(this.single.update);
        const where = this.where();
        const order = this.order();
        const limit = this.limit();
        return (comments === "" ? "" : comments + " ") + withSQL + `update ${this.tableName}` + (join2 ? ` ${join2}` : "") + " set " + updates.join(", ") + (where ? ` ${where}` : "") + (order ? ` ${order}` : "") + (limit ? ` ${limit}` : "");
      }
      forUpdate() {
        return "for update";
      }
      forShare() {
        return "lock in share mode";
      }
      // Only supported on MySQL 8.0+
      skipLocked() {
        return "skip locked";
      }
      // Supported on MySQL 8.0+ and MariaDB 10.3.0+
      noWait() {
        return "nowait";
      }
      // Compiles a `columnInfo` query.
      columnInfo() {
        const column = this.single.columnInfo;
        const table = this.client.customWrapIdentifier(this.single.table, identity2);
        return {
          sql: "select * from information_schema.columns where table_name = ? and table_schema = ?",
          bindings: [table, this.client.database()],
          output(resp) {
            const out = resp.reduce(function(columns, val) {
              columns[val.COLUMN_NAME] = {
                defaultValue: val.COLUMN_DEFAULT === "NULL" ? null : val.COLUMN_DEFAULT,
                type: val.DATA_TYPE,
                maxLength: val.CHARACTER_MAXIMUM_LENGTH,
                nullable: val.IS_NULLABLE === "YES"
              };
              return columns;
            }, {});
            return column && out[column] || out;
          }
        };
      }
      limit() {
        const noLimit = !this.single.limit && this.single.limit !== 0;
        if (noLimit && !this.single.offset) return "";
        const limit = this.single.offset && noLimit ? "18446744073709551615" : this._getValueOrParameterFromAttribute("limit");
        return `limit ${limit}`;
      }
      whereBasic(statement) {
        assert3(
          !isPlainObjectOrArray(statement.value),
          "The values in where clause must not be object or array."
        );
        return super.whereBasic(statement);
      }
      whereRaw(statement) {
        assert3(
          isEmpty(statement.value.bindings) || !Object.values(statement.value.bindings).some(isPlainObjectOrArray),
          "The values in where clause must not be object or array."
        );
        return super.whereRaw(statement);
      }
      whereLike(statement) {
        return `${this._columnClause(statement)} ${this._not(
          statement,
          "like "
        )}${this._valueClause(statement)} COLLATE utf8_bin`;
      }
      whereILike(statement) {
        return `${this._columnClause(statement)} ${this._not(
          statement,
          "like "
        )}${this._valueClause(statement)}`;
      }
      // Json functions
      jsonExtract(params) {
        return this._jsonExtract(["json_extract", "json_unquote"], params);
      }
      jsonSet(params) {
        return this._jsonSet("json_set", params);
      }
      jsonInsert(params) {
        return this._jsonSet("json_insert", params);
      }
      jsonRemove(params) {
        const jsonCol = `json_remove(${columnize_(
          params.column,
          this.builder,
          this.client,
          this.bindingsHolder
        )},${this.client.parameter(
          params.path,
          this.builder,
          this.bindingsHolder
        )})`;
        return params.alias ? this.client.alias(jsonCol, this.formatter.wrap(params.alias)) : jsonCol;
      }
      whereJsonObject(statement) {
        return this._not(
          statement,
          `json_contains(${this._columnClause(statement)}, ${this._jsonValueClause(
            statement
          )})`
        );
      }
      whereJsonPath(statement) {
        return this._whereJsonPath("json_extract", statement);
      }
      whereJsonSupersetOf(statement) {
        return this._not(
          statement,
          `json_contains(${wrap_(
            statement.column,
            void 0,
            this.builder,
            this.client,
            this.bindingsHolder
          )},${this._jsonValueClause(statement)})`
        );
      }
      whereJsonSubsetOf(statement) {
        return this._not(
          statement,
          `json_contains(${this._jsonValueClause(statement)},${wrap_(
            statement.column,
            void 0,
            this.builder,
            this.client,
            this.bindingsHolder
          )})`
        );
      }
      onJsonPathEquals(clause) {
        return this._onJsonPathEquals("json_extract", clause);
      }
    };
    module2.exports = QueryCompiler_MySQL;
  }
});

// node_modules/knex/lib/dialects/mysql/schema/mysql-compiler.js
var require_mysql_compiler = __commonJS({
  "node_modules/knex/lib/dialects/mysql/schema/mysql-compiler.js"(exports2, module2) {
    "use strict";
    var SchemaCompiler = require_compiler();
    var SchemaCompiler_MySQL = class extends SchemaCompiler {
      constructor(client, builder) {
        super(client, builder);
      }
      // Rename a table on the schema.
      renameTable(tableName, to) {
        this.pushQuery(
          `rename table ${this.formatter.wrap(tableName)} to ${this.formatter.wrap(
            to
          )}`
        );
      }
      renameView(from, to) {
        this.renameTable(from, to);
      }
      // Check whether a table exists on the query.
      hasTable(tableName) {
        let sql = "select * from information_schema.tables where table_name = ?";
        const bindings = [tableName];
        if (this.schema) {
          sql += " and table_schema = ?";
          bindings.push(this.schema);
        } else {
          sql += " and table_schema = database()";
        }
        this.pushQuery({
          sql,
          bindings,
          output: function output(resp) {
            return resp.length > 0;
          }
        });
      }
      // Check whether a column exists on the schema.
      hasColumn(tableName, column) {
        this.pushQuery({
          sql: `show columns from ${this.formatter.wrap(tableName)}`,
          output(resp) {
            return resp.some((row) => {
              return this.client.wrapIdentifier(row.Field.toLowerCase()) === this.client.wrapIdentifier(column.toLowerCase());
            });
          }
        });
      }
    };
    module2.exports = SchemaCompiler_MySQL;
  }
});

// node_modules/knex/lib/dialects/mysql/schema/mysql-tablecompiler.js
var require_mysql_tablecompiler = __commonJS({
  "node_modules/knex/lib/dialects/mysql/schema/mysql-tablecompiler.js"(exports2, module2) {
    "use strict";
    var TableCompiler = require_tablecompiler();
    var { isObject: isObject5, isString: isString2 } = require_is();
    var TableCompiler_MySQL = class extends TableCompiler {
      constructor(client, tableBuilder) {
        super(client, tableBuilder);
      }
      createQuery(columns, ifNot, like) {
        const createStatement = ifNot ? "create table if not exists " : "create table ";
        const { client } = this;
        let conn = {};
        let columnsSql = " (" + columns.sql.join(", ");
        columnsSql += this.primaryKeys() || "";
        columnsSql += this._addChecks();
        columnsSql += ")";
        let sql = createStatement + this.tableName() + (like && this.tableNameLike() ? " like " + this.tableNameLike() : columnsSql);
        if (client.connectionSettings) {
          conn = client.connectionSettings;
        }
        const charset = this.single.charset || conn.charset || "";
        const collation = this.single.collate || conn.collate || "";
        const engine = this.single.engine || "";
        if (charset && !like) sql += ` default character set ${charset}`;
        if (collation) sql += ` collate ${collation}`;
        if (engine) sql += ` engine = ${engine}`;
        if (this.single.comment) {
          const comment = this.single.comment || "";
          const MAX_COMMENT_LENGTH = 1024;
          if (comment.length > MAX_COMMENT_LENGTH)
            this.client.logger.warn(
              `The max length for a table comment is ${MAX_COMMENT_LENGTH} characters`
            );
          sql += ` comment = '${comment}'`;
        }
        this.pushQuery(sql);
        if (like) {
          this.addColumns(columns, this.addColumnsPrefix);
        }
      }
      // Compiles the comment on the table.
      comment(comment) {
        this.pushQuery(`alter table ${this.tableName()} comment = '${comment}'`);
      }
      changeType() {
      }
      // Renames a column on the table.
      renameColumn(from, to) {
        const compiler = this;
        const table = this.tableName();
        const wrapped = this.formatter.wrap(from) + " " + this.formatter.wrap(to);
        this.pushQuery({
          sql: `show full fields from ${table} where field = ` + this.client.parameter(from, this.tableBuilder, this.bindingsHolder),
          output(resp) {
            const column = resp[0];
            const runner = this;
            return compiler.getFKRefs(runner).then(
              ([refs]) => new Promise((resolve3, reject) => {
                try {
                  if (!refs.length) {
                    resolve3();
                  }
                  resolve3(compiler.dropFKRefs(runner, refs));
                } catch (e) {
                  reject(e);
                }
              }).then(function() {
                let sql = `alter table ${table} change ${wrapped} ${column.Type}`;
                if (String(column.Null).toUpperCase() !== "YES") {
                  sql += ` NOT NULL`;
                } else {
                  sql += ` NULL`;
                }
                if (column.Default !== void 0 && column.Default !== null) {
                  sql += ` DEFAULT '${column.Default}'`;
                }
                if (column.Collation !== void 0 && column.Collation !== null) {
                  sql += ` COLLATE '${column.Collation}'`;
                }
                if (column.Extra == "auto_increment") {
                  sql += ` AUTO_INCREMENT`;
                }
                return runner.query({
                  sql
                });
              }).then(function() {
                if (!refs.length) {
                  return;
                }
                return compiler.createFKRefs(
                  runner,
                  refs.map(function(ref) {
                    const refColKey = ref.REFERENCED_COLUMN_NAME !== void 0 ? "REFERENCED_COLUMN_NAME" : "referenced_column_name";
                    const colKey = ref.COLUMN_NAME !== void 0 ? "COLUMN_NAME" : "column_name";
                    if (ref[refColKey] === from) {
                      ref[refColKey] = to;
                    }
                    if (ref[colKey] === from) {
                      ref[colKey] = to;
                    }
                    return ref;
                  })
                );
              })
            );
          }
        });
      }
      primaryKeys() {
        const pks = (this.grouped.alterTable || []).filter(
          (k) => k.method === "primary"
        );
        if (pks.length > 0 && pks[0].args.length > 0) {
          const columns = pks[0].args[0];
          let constraintName = pks[0].args[1] || "";
          if (constraintName) {
            constraintName = " constraint " + this.formatter.wrap(constraintName);
          }
          if (this.grouped.columns) {
            const incrementsCols = this._getIncrementsColumnNames();
            if (incrementsCols.length) {
              incrementsCols.forEach((c) => {
                if (!columns.includes(c)) {
                  columns.unshift(c);
                }
              });
            }
            const bigIncrementsCols = this._getBigIncrementsColumnNames();
            if (bigIncrementsCols.length) {
              bigIncrementsCols.forEach((c) => {
                if (!columns.includes(c)) {
                  columns.unshift(c);
                }
              });
            }
          }
          return `,${constraintName} primary key (${this.formatter.columnize(
            columns
          )})`;
        }
      }
      getFKRefs(runner) {
        const bindingsHolder = {
          bindings: []
        };
        const sql = "SELECT KCU.CONSTRAINT_NAME, KCU.TABLE_NAME, KCU.COLUMN_NAME,        KCU.REFERENCED_TABLE_NAME, KCU.REFERENCED_COLUMN_NAME,        RC.UPDATE_RULE, RC.DELETE_RULE FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS RC        USING(CONSTRAINT_NAME) WHERE KCU.REFERENCED_TABLE_NAME = " + this.client.parameter(
          this.tableNameRaw,
          this.tableBuilder,
          bindingsHolder
        ) + "   AND KCU.CONSTRAINT_SCHEMA = " + this.client.parameter(
          this.client.database(),
          this.tableBuilder,
          bindingsHolder
        ) + "   AND RC.CONSTRAINT_SCHEMA = " + this.client.parameter(
          this.client.database(),
          this.tableBuilder,
          bindingsHolder
        );
        return runner.query({
          sql,
          bindings: bindingsHolder.bindings
        });
      }
      dropFKRefs(runner, refs) {
        const formatter = this.client.formatter(this.tableBuilder);
        return Promise.all(
          refs.map(function(ref) {
            const constraintName = formatter.wrap(
              ref.CONSTRAINT_NAME || ref.constraint_name
            );
            const tableName = formatter.wrap(ref.TABLE_NAME || ref.table_name);
            return runner.query({
              sql: `alter table ${tableName} drop foreign key ${constraintName}`
            });
          })
        );
      }
      createFKRefs(runner, refs) {
        const formatter = this.client.formatter(this.tableBuilder);
        return Promise.all(
          refs.map(function(ref) {
            const tableName = formatter.wrap(ref.TABLE_NAME || ref.table_name);
            const keyName = formatter.wrap(
              ref.CONSTRAINT_NAME || ref.constraint_name
            );
            const column = formatter.columnize(ref.COLUMN_NAME || ref.column_name);
            const references = formatter.columnize(
              ref.REFERENCED_COLUMN_NAME || ref.referenced_column_name
            );
            const inTable = formatter.wrap(
              ref.REFERENCED_TABLE_NAME || ref.referenced_table_name
            );
            const onUpdate = ` ON UPDATE ${ref.UPDATE_RULE || ref.update_rule}`;
            const onDelete = ` ON DELETE ${ref.DELETE_RULE || ref.delete_rule}`;
            return runner.query({
              sql: `alter table ${tableName} add constraint ${keyName} foreign key (` + column + ") references " + inTable + " (" + references + ")" + onUpdate + onDelete
            });
          })
        );
      }
      index(columns, indexName, options) {
        let storageEngineIndexType;
        let indexType;
        if (isString2(options)) {
          indexType = options;
        } else if (isObject5(options)) {
          ({ indexType, storageEngineIndexType } = options);
        }
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        storageEngineIndexType = storageEngineIndexType ? ` using ${storageEngineIndexType}` : "";
        this.pushQuery(
          `alter table ${this.tableName()} add${indexType ? ` ${indexType}` : ""} index ${indexName}(${this.formatter.columnize(
            columns
          )})${storageEngineIndexType}`
        );
      }
      primary(columns, constraintName) {
        let deferrable;
        if (isObject5(constraintName)) {
          ({ constraintName, deferrable } = constraintName);
        }
        if (deferrable && deferrable !== "not deferrable") {
          this.client.logger.warn(
            `mysql: primary key constraint \`${constraintName}\` will not be deferrable ${deferrable} because mysql does not support deferred constraints.`
          );
        }
        constraintName = constraintName ? this.formatter.wrap(constraintName) : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
        const primaryCols = columns;
        let incrementsCols = [];
        let bigIncrementsCols = [];
        if (this.grouped.columns) {
          incrementsCols = this._getIncrementsColumnNames();
          if (incrementsCols) {
            incrementsCols.forEach((c) => {
              if (!primaryCols.includes(c)) {
                primaryCols.unshift(c);
              }
            });
          }
          bigIncrementsCols = this._getBigIncrementsColumnNames();
          if (bigIncrementsCols) {
            bigIncrementsCols.forEach((c) => {
              if (!primaryCols.includes(c)) {
                primaryCols.unshift(c);
              }
            });
          }
        }
        if (this.method !== "create" && this.method !== "createIfNot") {
          this.pushQuery(
            `alter table ${this.tableName()} add primary key ${constraintName}(${this.formatter.columnize(
              primaryCols
            )})`
          );
        }
        if (incrementsCols.length) {
          this.pushQuery(
            `alter table ${this.tableName()} modify column ${this.formatter.columnize(
              incrementsCols
            )} int unsigned not null auto_increment`
          );
        }
        if (bigIncrementsCols.length) {
          this.pushQuery(
            `alter table ${this.tableName()} modify column ${this.formatter.columnize(
              bigIncrementsCols
            )} bigint unsigned not null auto_increment`
          );
        }
      }
      unique(columns, indexName) {
        let storageEngineIndexType;
        let deferrable;
        if (isObject5(indexName)) {
          ({ indexName, deferrable, storageEngineIndexType } = indexName);
        }
        if (deferrable && deferrable !== "not deferrable") {
          this.client.logger.warn(
            `mysql: unique index \`${indexName}\` will not be deferrable ${deferrable} because mysql does not support deferred constraints.`
          );
        }
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        storageEngineIndexType = storageEngineIndexType ? ` using ${storageEngineIndexType}` : "";
        this.pushQuery(
          `alter table ${this.tableName()} add unique ${indexName}(${this.formatter.columnize(
            columns
          )})${storageEngineIndexType}`
        );
      }
      // Compile a drop index command.
      dropIndex(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        this.pushQuery(`alter table ${this.tableName()} drop index ${indexName}`);
      }
      // Compile a drop foreign key command.
      dropForeign(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("foreign", this.tableNameRaw, columns);
        this.pushQuery(
          `alter table ${this.tableName()} drop foreign key ${indexName}`
        );
      }
      dropForeignIfExists() {
        throw new Error(".dropForeignIfExists is not supported for mysql.");
      }
      // Compile a drop primary key command.
      dropPrimary() {
        this.pushQuery(`alter table ${this.tableName()} drop primary key`);
      }
      dropPrimaryIfExists() {
        throw new Error(".dropPrimaryIfExists is not supported for mysql.");
      }
      // Compile a drop unique key command.
      dropUnique(column, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, column);
        this.pushQuery(`alter table ${this.tableName()} drop index ${indexName}`);
      }
      dropUniqueIfExists(column, indexName) {
        if (this.client.isMariaDB) {
          indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, column);
          this.pushQuery(
            `alter table ${this.tableName()} drop index if exists ${indexName}`
          );
          return;
        }
        throw new Error(".dropUniqueIfExists is not supported for mysql.");
      }
    };
    TableCompiler_MySQL.prototype.addColumnsPrefix = "add ";
    TableCompiler_MySQL.prototype.alterColumnsPrefix = "modify ";
    TableCompiler_MySQL.prototype.dropColumnPrefix = "drop ";
    module2.exports = TableCompiler_MySQL;
  }
});

// node_modules/knex/lib/dialects/mysql/schema/mysql-columncompiler.js
var require_mysql_columncompiler = __commonJS({
  "node_modules/knex/lib/dialects/mysql/schema/mysql-columncompiler.js"(exports2, module2) {
    "use strict";
    var ColumnCompiler = require_columncompiler();
    var { isObject: isObject5 } = require_is();
    var { toNumber: toNumber2 } = require_helpers();
    var commentEscapeRegex = /(?<!\\)'/g;
    var ColumnCompiler_MySQL = class extends ColumnCompiler {
      constructor(client, tableCompiler, columnBuilder) {
        super(client, tableCompiler, columnBuilder);
        this.modifiers = [
          "unsigned",
          "nullable",
          "defaultTo",
          "comment",
          "collate",
          "first",
          "after"
        ];
        this._addCheckModifiers();
      }
      // Types
      // ------
      double(precision, scale) {
        if (!precision) return "double";
        return `double(${toNumber2(precision, 8)}, ${toNumber2(scale, 2)})`;
      }
      integer(length) {
        length = length ? `(${toNumber2(length, 11)})` : "";
        return `int${length}`;
      }
      tinyint(length) {
        length = length ? `(${toNumber2(length, 1)})` : "";
        return `tinyint${length}`;
      }
      text(column) {
        switch (column) {
          case "medium":
          case "mediumtext":
            return "mediumtext";
          case "long":
          case "longtext":
            return "longtext";
          default:
            return "text";
        }
      }
      mediumtext() {
        return this.text("medium");
      }
      longtext() {
        return this.text("long");
      }
      enu(allowed) {
        return `enum('${allowed.join("', '")}')`;
      }
      datetime(precision) {
        if (isObject5(precision)) {
          ({ precision } = precision);
        }
        return typeof precision === "number" ? `datetime(${precision})` : "datetime";
      }
      timestamp(precision) {
        if (isObject5(precision)) {
          ({ precision } = precision);
        }
        return typeof precision === "number" ? `timestamp(${precision})` : "timestamp";
      }
      time(precision) {
        if (isObject5(precision)) {
          ({ precision } = precision);
        }
        return typeof precision === "number" ? `time(${precision})` : "time";
      }
      bit(length) {
        return length ? `bit(${toNumber2(length)})` : "bit";
      }
      binary(length) {
        return length ? `varbinary(${toNumber2(length)})` : "blob";
      }
      json() {
        return "json";
      }
      jsonb() {
        return "json";
      }
      // Modifiers
      // ------
      defaultTo(value) {
        if (value === null || value === void 0) {
          return;
        }
        if ((this.type === "json" || this.type === "jsonb") && isObject5(value)) {
          return `default ('${JSON.stringify(value)}')`;
        }
        const defaultVal = super.defaultTo.apply(this, arguments);
        if (this.type !== "blob" && this.type.indexOf("text") === -1) {
          return defaultVal;
        }
        return "";
      }
      unsigned() {
        return "unsigned";
      }
      comment(comment) {
        if (comment && comment.length > 255) {
          this.client.logger.warn(
            "Your comment is longer than the max comment length for MySQL"
          );
        }
        return comment && `comment '${comment.replace(commentEscapeRegex, "\\'")}'`;
      }
      first() {
        return "first";
      }
      after(column) {
        return `after ${this.formatter.wrap(column)}`;
      }
      collate(collation) {
        return collation && `collate '${collation}'`;
      }
      checkRegex(regex, constraintName) {
        return this._check(
          `${this.formatter.wrap(
            this.getColumnName()
          )} REGEXP ${this.client._escapeBinding(regex)}`,
          constraintName
        );
      }
      increments(options = { primaryKey: true }) {
        return "int unsigned not null" + // In MySQL autoincrement are always a primary key. If you already have a primary key, we
        // initialize this column as classic int column then modify it later in table compiler
        (this.tableCompiler._canBeAddPrimaryKey(options) ? " auto_increment primary key" : "");
      }
      bigincrements(options = { primaryKey: true }) {
        return "bigint unsigned not null" + // In MySQL autoincrement are always a primary key. If you already have a primary key, we
        // initialize this column as classic int column then modify it later in table compiler
        (this.tableCompiler._canBeAddPrimaryKey(options) ? " auto_increment primary key" : "");
      }
    };
    ColumnCompiler_MySQL.prototype.bigint = "bigint";
    ColumnCompiler_MySQL.prototype.mediumint = "mediumint";
    ColumnCompiler_MySQL.prototype.smallint = "smallint";
    module2.exports = ColumnCompiler_MySQL;
  }
});

// node_modules/knex/lib/dialects/mysql/schema/mysql-viewcompiler.js
var require_mysql_viewcompiler = __commonJS({
  "node_modules/knex/lib/dialects/mysql/schema/mysql-viewcompiler.js"(exports2, module2) {
    "use strict";
    var ViewCompiler = require_viewcompiler();
    var ViewCompiler_MySQL = class extends ViewCompiler {
      constructor(client, viewCompiler) {
        super(client, viewCompiler);
      }
      createOrReplace() {
        this.createQuery(this.columns, this.selectQuery, false, true);
      }
    };
    module2.exports = ViewCompiler_MySQL;
  }
});

// node_modules/knex/lib/dialects/mysql/schema/mysql-viewbuilder.js
var require_mysql_viewbuilder = __commonJS({
  "node_modules/knex/lib/dialects/mysql/schema/mysql-viewbuilder.js"(exports2, module2) {
    "use strict";
    var ViewBuilder = require_viewbuilder();
    var ViewBuilder_MySQL = class extends ViewBuilder {
      constructor() {
        super(...arguments);
      }
      checkOption() {
        this._single.checkOption = "default_option";
      }
      localCheckOption() {
        this._single.checkOption = "local";
      }
      cascadedCheckOption() {
        this._single.checkOption = "cascaded";
      }
    };
    module2.exports = ViewBuilder_MySQL;
  }
});

// node_modules/knex/lib/dialects/mysql/index.js
var require_mysql = __commonJS({
  "node_modules/knex/lib/dialects/mysql/index.js"(exports2, module2) {
    "use strict";
    var defer = require_defer();
    var map3 = require_map();
    var { promisify: promisify2 } = require("util");
    var Client2 = require_client2();
    var Transaction = require_transaction3();
    var QueryBuilder = require_mysql_querybuilder();
    var QueryCompiler = require_mysql_querycompiler();
    var SchemaCompiler = require_mysql_compiler();
    var TableCompiler = require_mysql_tablecompiler();
    var ColumnCompiler = require_mysql_columncompiler();
    var { makeEscape } = require_string2();
    var ViewCompiler = require_mysql_viewcompiler();
    var ViewBuilder = require_mysql_viewbuilder();
    var Client_MySQL = class extends Client2 {
      _driver() {
        return require("mysql");
      }
      queryBuilder() {
        return new QueryBuilder(this);
      }
      queryCompiler(builder, formatter) {
        return new QueryCompiler(this, builder, formatter);
      }
      schemaCompiler() {
        return new SchemaCompiler(this, ...arguments);
      }
      tableCompiler() {
        return new TableCompiler(this, ...arguments);
      }
      viewCompiler() {
        return new ViewCompiler(this, ...arguments);
      }
      viewBuilder() {
        return new ViewBuilder(this, ...arguments);
      }
      columnCompiler() {
        return new ColumnCompiler(this, ...arguments);
      }
      transaction() {
        return new Transaction(this, ...arguments);
      }
      wrapIdentifierImpl(value) {
        return value !== "*" ? `\`${value.replace(/`/g, "``")}\`` : "*";
      }
      // Get a raw connection, called by the `pool` whenever a new
      // connection needs to be added to the pool.
      acquireRawConnection() {
        return new Promise((resolver, rejecter) => {
          const connection = this.driver.createConnection(this.connectionSettings);
          connection.on("error", (err) => {
            connection.__knex__disposed = err;
          });
          connection.connect(async (err) => {
            if (err) {
              connection.removeAllListeners();
              return rejecter(err);
            }
            try {
              await this.checkVersion(connection);
            } catch (versionError) {
              const suffix = versionError?.message ? ` (${versionError.message})` : "";
              this.logger.warn(
                `Knex: Unable to detect MySQL/MariaDB version${suffix}. Assuming latest version.`
              );
            }
            resolver(connection);
          });
        });
      }
      // Used to explicitly close a connection, called internally by the pool
      // when a connection times out or the pool is shutdown.
      async destroyRawConnection(connection) {
        try {
          const end = promisify2((cb) => connection.end(cb));
          return await end();
        } catch (err) {
          connection.__knex__disposed = err;
        } finally {
          defer(() => connection.removeAllListeners());
        }
      }
      validateConnection(connection) {
        return connection.state === "connected" || connection.state === "authenticated";
      }
      // Grab a connection, run the query via the MySQL streaming interface,
      // and pass that through to the stream we've sent back to the client.
      _stream(connection, obj, stream4, options) {
        if (!obj.sql) throw new Error("The query is empty");
        options = options || {};
        const queryOptions = Object.assign({ sql: obj.sql }, obj.options);
        return new Promise((resolver, rejecter) => {
          stream4.on("error", rejecter);
          stream4.on("end", resolver);
          const queryStream = connection.query(queryOptions, obj.bindings).stream(options);
          queryStream.on("error", (err) => {
            rejecter(err);
            stream4.emit("error", err);
          });
          queryStream.pipe(stream4);
        });
      }
      // Runs the query on the specified connection, providing the bindings
      // and any other necessary prep work.
      _query(connection, obj) {
        if (!obj || typeof obj === "string") obj = { sql: obj };
        if (!obj.sql) throw new Error("The query is empty");
        return new Promise(function(resolver, rejecter) {
          if (!obj.sql) {
            resolver();
            return;
          }
          const queryOptions = Object.assign({ sql: obj.sql }, obj.options);
          connection.query(
            queryOptions,
            obj.bindings,
            function(err, rows, fields) {
              if (err) return rejecter(err);
              obj.response = [rows, fields];
              resolver(obj);
            }
          );
        });
      }
      // Process the response as returned from the query.
      processResponse(obj, runner) {
        if (obj == null) return;
        const { response } = obj;
        const { method } = obj;
        const rows = response[0];
        const fields = response[1];
        if (obj.output) return obj.output.call(runner, rows, fields);
        switch (method) {
          case "select":
            return rows;
          case "first":
            return rows[0];
          case "pluck":
            return map3(rows, obj.pluck);
          case "insert":
            return [rows.insertId];
          case "del":
          case "update":
          case "counter":
            return rows.affectedRows;
          default:
            return response;
        }
      }
      async cancelQuery(connectionToKill) {
        const conn = await this.acquireRawConnection();
        try {
          return await this._wrappedCancelQueryCall(conn, connectionToKill);
        } finally {
          await this.destroyRawConnection(conn);
          if (conn.__knex__disposed) {
            this.logger.warn(`Connection Error: ${conn.__knex__disposed}`);
          }
        }
      }
      _wrappedCancelQueryCall(conn, connectionToKill) {
        return this._query(conn, {
          sql: "KILL QUERY ?",
          bindings: [connectionToKill.threadId],
          options: {}
        });
      }
      async checkVersion(connection) {
        if (this._versionCheckPromise) {
          return this._versionCheckPromise;
        }
        this._versionCheckPromise = (async () => {
          if (this.version) {
            return this._resolveConfiguredVersion(this.version);
          }
          try {
            const query = promisify2(connection.query).bind(connection);
            const rows = await query("select version() as version");
            const rawVersion = rows?.[0]?.version;
            if (!rawVersion) {
              return this._assumeLatestVersion({
                reason: "Unable to retrieve MySQL/MariaDB version from server"
              });
            }
            return this._applyParsedVersion(rawVersion, { source: "server" });
          } catch (err) {
            return this._assumeLatestVersion({
              reason: "Unable to retrieve MySQL/MariaDB version from server",
              error: err
            });
          }
        })();
        return this._versionCheckPromise;
      }
      _resolveConfiguredVersion(versionString) {
        if (this._isLatestVersionString(versionString)) {
          return this._assumeLatestVersion({
            reason: "MySQL/MariaDB version set to latest in configuration",
            skipWarning: true
          });
        }
        return this._applyParsedVersion(versionString, { source: "config" });
      }
      _applyParsedVersion(versionString, { source }) {
        const { version: version3, isMariaDB } = this._parseVersion(versionString);
        if (typeof isMariaDB !== "undefined") {
          this.isMariaDB = isMariaDB;
        }
        if (!version3) {
          const reason = source === "config" ? `Invalid MySQL/MariaDB version "${versionString}" in configuration` : `Unable to parse MySQL/MariaDB version string "${versionString}"`;
          return this._assumeLatestVersion({ reason });
        }
        if (!this.version || source === "server") {
          this.version = version3;
        }
        return this.version;
      }
      _assumeLatestVersion({ reason, error: error73, skipWarning } = {}) {
        if (!skipWarning) {
          const suffix = error73 && error73.message ? ` (${error73.message})` : "";
          this.logger.warn(`Knex: ${reason}${suffix}. Assuming latest version.`);
        }
        this.version = null;
        return this.version;
      }
      _isLatestVersionString(versionString) {
        return typeof versionString === "string" && versionString.toLowerCase() === "latest";
      }
      _parseVersion(versionString) {
        const isMariaDB = /mariadb/i.test(versionString);
        let versionMatch;
        if (isMariaDB) {
          const mariaMatch = versionString.match(/(\d+\.\d+\.\d+)(?=[^\d]*mariadb)/i) || versionString.match(/(\d+\.\d+\.\d+)/);
          versionMatch = mariaMatch && mariaMatch[1];
        } else {
          const mysqlMatch = versionString.match(/(\d+\.\d+\.\d+)/);
          versionMatch = mysqlMatch && mysqlMatch[1];
        }
        return { version: versionMatch || null, isMariaDB };
      }
    };
    Object.assign(Client_MySQL.prototype, {
      dialect: "mysql",
      driverName: "mysql",
      _escapeBinding: makeEscape(),
      canCancelQuery: true
    });
    module2.exports = Client_MySQL;
  }
});

// node_modules/knex/lib/dialects/mysql2/transaction.js
var require_transaction4 = __commonJS({
  "node_modules/knex/lib/dialects/mysql2/transaction.js"(exports2, module2) {
    "use strict";
    var Transaction = require_transaction();
    var debug = require_src3()("knex:tx");
    var Transaction_MySQL2 = class extends Transaction {
      query(conn, sql, status, value) {
        const t = this;
        const q = this.trxClient.query(conn, sql).catch((err) => {
          if (err.code === "ER_SP_DOES_NOT_EXIST") {
            this.trxClient.logger.warn(
              "Transaction was implicitly committed, do not mix transactions and DDL with MySQL (#805)"
            );
            return;
          }
          status = 2;
          value = err;
          t._completed = true;
          debug("%s error running transaction query", t.txid);
        }).then(function(res) {
          if (status === 1) t._resolver(value);
          if (status === 2) {
            if (value === void 0) {
              if (t.doNotRejectOnRollback && /^ROLLBACK\b/i.test(sql)) {
                t._resolver();
                return;
              }
              value = new Error(`Transaction rejected with non-error: ${value}`);
            }
            t._rejecter(value);
            return res;
          }
        });
        if (status === 1 || status === 2) {
          t._completed = true;
        }
        return q;
      }
    };
    module2.exports = Transaction_MySQL2;
  }
});

// node_modules/knex/lib/dialects/mysql2/index.js
var require_mysql2 = __commonJS({
  "node_modules/knex/lib/dialects/mysql2/index.js"(exports2, module2) {
    "use strict";
    var Client_MySQL = require_mysql();
    var Transaction = require_transaction4();
    var Client_MySQL2 = class extends Client_MySQL {
      transaction() {
        return new Transaction(this, ...arguments);
      }
      _driver() {
        return require("mysql2");
      }
      initializeDriver() {
        try {
          this.driver = this._driver();
        } catch (e) {
          let message = `Knex: run
$ npm install ${this.driverName}`;
          const nodeMajorVersion = process.version.replace(/^v/, "").split(".")[0];
          if (nodeMajorVersion <= 12) {
            message += `@3.2.0`;
            this.logger.error(
              "Mysql2 version 3.2.0 is the latest version to support Node.js 12 or lower."
            );
          }
          message += ` --save`;
          this.logger.error(`${message}
${e.message}
${e.stack}`);
          throw new Error(`${message}
${e.message}`);
        }
      }
      validateConnection(connection) {
        return connection && !connection._fatalError && !connection._protocolError && !connection._closing && !connection.stream.destroyed;
      }
    };
    Object.assign(Client_MySQL2.prototype, {
      // The "dialect", for reference elsewhere.
      driverName: "mysql2"
    });
    module2.exports = Client_MySQL2;
  }
});

// node_modules/knex/lib/dialects/oracle/utils.js
var require_utils10 = __commonJS({
  "node_modules/knex/lib/dialects/oracle/utils.js"(exports2, module2) {
    "use strict";
    var NameHelper = class {
      constructor(oracleVersion) {
        this.oracleVersion = oracleVersion;
        const versionParts = oracleVersion.split(".").map((versionPart) => parseInt(versionPart));
        if (versionParts[0] > 12 || versionParts[0] === 12 && versionParts[1] >= 2) {
          this.limit = 128;
        } else {
          this.limit = 30;
        }
      }
      generateCombinedName(logger3, postfix, name28, subNames) {
        const crypto7 = require("crypto");
        if (!Array.isArray(subNames)) subNames = subNames ? [subNames] : [];
        const table = name28.replace(/\.|-/g, "_");
        const subNamesPart = subNames.join("_");
        let result = `${table}_${subNamesPart.length ? subNamesPart + "_" : ""}${postfix}`.toLowerCase();
        if (result.length > this.limit) {
          logger3.warn(
            `Automatically generated name "${result}" exceeds ${this.limit} character limit for Oracle Database ${this.oracleVersion}. Using base64 encoded sha1 of that name instead.`
          );
          result = crypto7.createHash("sha1").update(result).digest("base64").replace("=", "");
        }
        return result;
      }
    };
    function wrapSqlWithCatch(sql, errorNumberToCatch) {
      return `begin execute immediate '${sql.replace(/'/g, "''")}'; exception when others then if sqlcode != ${errorNumberToCatch} then raise; end if; end;`;
    }
    function ReturningHelper(columnName) {
      this.columnName = columnName;
    }
    ReturningHelper.prototype.toString = function() {
      return `[object ReturningHelper:${this.columnName}]`;
    };
    function isConnectionError(err) {
      return [
        "DPI-1010",
        // not connected
        "DPI-1080",
        // connection was closed by ORA-%d
        "ORA-03114",
        // not connected to ORACLE
        "ORA-03113",
        // end-of-file on communication channel
        "ORA-03135",
        // connection lost contact
        "ORA-12514",
        // listener does not currently know of service requested in connect descriptor
        "ORA-00022",
        // invalid session ID; access denied
        "ORA-00028",
        // your session has been killed
        "ORA-00031",
        // your session has been marked for kill
        "ORA-00045",
        // your session has been terminated with no replay
        "ORA-00378",
        // buffer pools cannot be created as specified
        "ORA-00602",
        // internal programming exception
        "ORA-00603",
        // ORACLE server session terminated by fatal error
        "ORA-00609",
        // could not attach to incoming connection
        "ORA-01012",
        // not logged on
        "ORA-01041",
        // internal error. hostdef extension doesn't exist
        "ORA-01043",
        // user side memory corruption
        "ORA-01089",
        // immediate shutdown or close in progress
        "ORA-01092",
        // ORACLE instance terminated. Disconnection forced
        "ORA-02396",
        // exceeded maximum idle time, please connect again
        "ORA-03122",
        // attempt to close ORACLE-side window on user side
        "ORA-12153",
        // TNS'not connected
        "ORA-12537",
        // TNS'connection closed
        "ORA-12547",
        // TNS'lost contact
        "ORA-12570",
        // TNS'packet reader failure
        "ORA-12583",
        // TNS'no reader
        "ORA-27146",
        // post/wait initialization failed
        "ORA-28511",
        // lost RPC connection
        "ORA-56600",
        // an illegal OCI function call was issued
        "NJS-024",
        "NJS-003",
        "NJS-500"
      ].some(function(prefix) {
        return err.message.indexOf(prefix) === 0;
      });
    }
    module2.exports = {
      NameHelper,
      isConnectionError,
      wrapSqlWithCatch,
      ReturningHelper
    };
  }
});

// node_modules/knex/lib/dialects/oracle/schema/internal/trigger.js
var require_trigger = __commonJS({
  "node_modules/knex/lib/dialects/oracle/schema/internal/trigger.js"(exports2, module2) {
    "use strict";
    var { NameHelper } = require_utils10();
    var Trigger = class {
      constructor(oracleVersion) {
        this.nameHelper = new NameHelper(oracleVersion);
      }
      renameColumnTrigger(logger3, tableName, columnName, to) {
        const triggerName = this.nameHelper.generateCombinedName(
          logger3,
          "autoinc_trg",
          tableName
        );
        const sequenceName = this.nameHelper.generateCombinedName(
          logger3,
          "seq",
          tableName
        );
        return `DECLARE PK_NAME VARCHAR(200); IS_AUTOINC NUMBER := 0; BEGIN  EXECUTE IMMEDIATE ('ALTER TABLE "${tableName}" RENAME COLUMN "${columnName}" TO "${to}"');  SELECT COUNT(*) INTO IS_AUTOINC from "USER_TRIGGERS" where trigger_name = '${triggerName}';  IF (IS_AUTOINC > 0) THEN    SELECT cols.column_name INTO PK_NAME    FROM all_constraints cons, all_cons_columns cols    WHERE cons.constraint_type = 'P'    AND cons.constraint_name = cols.constraint_name    AND cons.owner = cols.owner    AND cols.table_name = '${tableName}';    IF ('${to}' = PK_NAME) THEN      EXECUTE IMMEDIATE ('DROP TRIGGER "${triggerName}"');      EXECUTE IMMEDIATE ('create or replace trigger "${triggerName}"      BEFORE INSERT on "${tableName}" for each row        declare        checking number := 1;        begin          if (:new."${to}" is null) then            while checking >= 1 loop              select "${sequenceName}".nextval into :new."${to}" from dual;              select count("${to}") into checking from "${tableName}"              where "${to}" = :new."${to}";            end loop;          end if;        end;');    end if;  end if;END;`;
      }
      createAutoIncrementTrigger(logger3, tableName, schemaName) {
        const tableQuoted = `"${tableName}"`;
        const tableUnquoted = tableName;
        const schemaQuoted = schemaName ? `"${schemaName}".` : "";
        const constraintOwner = schemaName ? `'${schemaName}'` : "cols.owner";
        const triggerName = this.nameHelper.generateCombinedName(
          logger3,
          "autoinc_trg",
          tableName
        );
        const sequenceNameUnquoted = this.nameHelper.generateCombinedName(
          logger3,
          "seq",
          tableName
        );
        const sequenceNameQuoted = `"${sequenceNameUnquoted}"`;
        return `DECLARE PK_NAME VARCHAR(200); BEGIN  EXECUTE IMMEDIATE ('CREATE SEQUENCE ${schemaQuoted}${sequenceNameQuoted}');  SELECT cols.column_name INTO PK_NAME  FROM all_constraints cons, all_cons_columns cols  WHERE cons.constraint_type = 'P'  AND cons.constraint_name = cols.constraint_name  AND cons.owner = ${constraintOwner}  AND cols.table_name = '${tableUnquoted}';  execute immediate ('create or replace trigger ${schemaQuoted}"${triggerName}"  BEFORE INSERT on ${schemaQuoted}${tableQuoted}  for each row  declare  checking number := 1;  begin    if (:new."' || PK_NAME || '" is null) then      while checking >= 1 loop        select ${schemaQuoted}${sequenceNameQuoted}.nextval into :new."' || PK_NAME || '" from dual;        select count("' || PK_NAME || '") into checking from ${schemaQuoted}${tableQuoted}        where "' || PK_NAME || '" = :new."' || PK_NAME || '";      end loop;    end if;  end;'); END;`;
      }
      renameTableAndAutoIncrementTrigger(logger3, tableName, to) {
        const triggerName = this.nameHelper.generateCombinedName(
          logger3,
          "autoinc_trg",
          tableName
        );
        const sequenceName = this.nameHelper.generateCombinedName(
          logger3,
          "seq",
          tableName
        );
        const toTriggerName = this.nameHelper.generateCombinedName(
          logger3,
          "autoinc_trg",
          to
        );
        const toSequenceName = this.nameHelper.generateCombinedName(
          logger3,
          "seq",
          to
        );
        return `DECLARE PK_NAME VARCHAR(200); IS_AUTOINC NUMBER := 0; BEGIN  EXECUTE IMMEDIATE ('RENAME "${tableName}" TO "${to}"');  SELECT COUNT(*) INTO IS_AUTOINC from "USER_TRIGGERS" where trigger_name = '${triggerName}';  IF (IS_AUTOINC > 0) THEN    EXECUTE IMMEDIATE ('DROP TRIGGER "${triggerName}"');    EXECUTE IMMEDIATE ('RENAME "${sequenceName}" TO "${toSequenceName}"');    SELECT cols.column_name INTO PK_NAME    FROM all_constraints cons, all_cons_columns cols    WHERE cons.constraint_type = 'P'    AND cons.constraint_name = cols.constraint_name    AND cons.owner = cols.owner    AND cols.table_name = '${to}';    EXECUTE IMMEDIATE ('create or replace trigger "${toTriggerName}"    BEFORE INSERT on "${to}" for each row      declare      checking number := 1;      begin        if (:new."' || PK_NAME || '" is null) then          while checking >= 1 loop            select "${toSequenceName}".nextval into :new."' || PK_NAME || '" from dual;            select count("' || PK_NAME || '") into checking from "${to}"            where "' || PK_NAME || '" = :new."' || PK_NAME || '";          end loop;        end if;      end;');  end if;END;`;
      }
    };
    module2.exports = Trigger;
  }
});

// node_modules/knex/lib/dialects/oracle/schema/oracle-compiler.js
var require_oracle_compiler = __commonJS({
  "node_modules/knex/lib/dialects/oracle/schema/oracle-compiler.js"(exports2, module2) {
    "use strict";
    var SchemaCompiler = require_compiler();
    var utils = require_utils10();
    var Trigger = require_trigger();
    var SchemaCompiler_Oracle = class extends SchemaCompiler {
      constructor() {
        super(...arguments);
      }
      // Rename a table on the schema.
      renameTable(tableName, to) {
        const trigger = new Trigger(this.client.version);
        const renameTable = trigger.renameTableAndAutoIncrementTrigger(
          this.client.logger,
          tableName,
          to
        );
        this.pushQuery(renameTable);
      }
      // Check whether a table exists on the query.
      hasTable(tableName) {
        this.pushQuery({
          sql: "select TABLE_NAME from USER_TABLES where TABLE_NAME = " + this.client.parameter(tableName, this.builder, this.bindingsHolder),
          output(resp) {
            return resp.length > 0;
          }
        });
      }
      // Check whether a column exists on the schema.
      hasColumn(tableName, column) {
        const sql = `select COLUMN_NAME from ALL_TAB_COLUMNS where TABLE_NAME = ${this.client.parameter(
          tableName,
          this.builder,
          this.bindingsHolder
        )} and COLUMN_NAME = ${this.client.parameter(
          column,
          this.builder,
          this.bindingsHolder
        )}`;
        this.pushQuery({ sql, output: (resp) => resp.length > 0 });
      }
      dropSequenceIfExists(sequenceName) {
        const prefix = this.schema ? `"${this.schema}".` : "";
        this.pushQuery(
          utils.wrapSqlWithCatch(
            `drop sequence ${prefix}${this.formatter.wrap(sequenceName)}`,
            -2289
          )
        );
      }
      _dropRelatedSequenceIfExists(tableName) {
        const nameHelper = new utils.NameHelper(this.client.version);
        const sequenceName = nameHelper.generateCombinedName(
          this.client.logger,
          "seq",
          tableName
        );
        this.dropSequenceIfExists(sequenceName);
      }
      dropTable(tableName) {
        const prefix = this.schema ? `"${this.schema}".` : "";
        this.pushQuery(`drop table ${prefix}${this.formatter.wrap(tableName)}`);
        this._dropRelatedSequenceIfExists(tableName);
      }
      dropTableIfExists(tableName) {
        this.dropObject(tableName, "table");
      }
      dropViewIfExists(viewName) {
        this.dropObject(viewName, "view");
      }
      dropObject(objectName, type) {
        const prefix = this.schema ? `"${this.schema}".` : "";
        let errorCode = -942;
        if (type === "materialized view") {
          errorCode = -12003;
        }
        this.pushQuery(
          utils.wrapSqlWithCatch(
            `drop ${type} ${prefix}${this.formatter.wrap(objectName)}`,
            errorCode
          )
        );
        this._dropRelatedSequenceIfExists(objectName);
      }
      refreshMaterializedView(viewName) {
        return this.pushQuery({
          sql: `BEGIN DBMS_MVIEW.REFRESH('${this.schemaNameRaw ? this.schemaNameRaw + "." : ""}${viewName}'); END;`
        });
      }
      dropMaterializedView(viewName) {
        this._dropView(viewName, false, true);
      }
      dropMaterializedViewIfExists(viewName) {
        this.dropObject(viewName, "materialized view");
      }
    };
    module2.exports = SchemaCompiler_Oracle;
  }
});

// node_modules/knex/lib/dialects/oracle/schema/oracle-columnbuilder.js
var require_oracle_columnbuilder = __commonJS({
  "node_modules/knex/lib/dialects/oracle/schema/oracle-columnbuilder.js"(exports2, module2) {
    "use strict";
    var ColumnBuilder = require_columnbuilder();
    var toArray2 = require_toArray();
    var ColumnBuilder_Oracle = class extends ColumnBuilder {
      constructor() {
        super(...arguments);
      }
      // checkIn added to the builder to allow the column compiler to change the
      // order via the modifiers ("check" must be after "default")
      checkIn() {
        this._modifiers.checkIn = toArray2(arguments);
        return this;
      }
    };
    module2.exports = ColumnBuilder_Oracle;
  }
});

// node_modules/lodash/noop.js
var require_noop2 = __commonJS({
  "node_modules/lodash/noop.js"(exports2, module2) {
    "use strict";
    function noop4() {
    }
    module2.exports = noop4;
  }
});

// node_modules/lodash/_createSet.js
var require_createSet = __commonJS({
  "node_modules/lodash/_createSet.js"(exports2, module2) {
    "use strict";
    var Set3 = require_Set();
    var noop4 = require_noop2();
    var setToArray2 = require_setToArray();
    var INFINITY4 = 1 / 0;
    var createSet2 = !(Set3 && 1 / setToArray2(new Set3([, -0]))[1] == INFINITY4) ? noop4 : function(values) {
      return new Set3(values);
    };
    module2.exports = createSet2;
  }
});

// node_modules/lodash/_baseUniq.js
var require_baseUniq = __commonJS({
  "node_modules/lodash/_baseUniq.js"(exports2, module2) {
    "use strict";
    var SetCache2 = require_SetCache();
    var arrayIncludes2 = require_arrayIncludes();
    var arrayIncludesWith2 = require_arrayIncludesWith();
    var cacheHas2 = require_cacheHas();
    var createSet2 = require_createSet();
    var setToArray2 = require_setToArray();
    var LARGE_ARRAY_SIZE3 = 200;
    function baseUniq2(array4, iteratee, comparator) {
      var index = -1, includes = arrayIncludes2, length = array4.length, isCommon = true, result = [], seen = result;
      if (comparator) {
        isCommon = false;
        includes = arrayIncludesWith2;
      } else if (length >= LARGE_ARRAY_SIZE3) {
        var set3 = iteratee ? null : createSet2(array4);
        if (set3) {
          return setToArray2(set3);
        }
        isCommon = false;
        includes = cacheHas2;
        seen = new SetCache2();
      } else {
        seen = iteratee ? [] : result;
      }
      outer:
        while (++index < length) {
          var value = array4[index], computed = iteratee ? iteratee(value) : value;
          value = comparator || value !== 0 ? value : 0;
          if (isCommon && computed === computed) {
            var seenIndex = seen.length;
            while (seenIndex--) {
              if (seen[seenIndex] === computed) {
                continue outer;
              }
            }
            if (iteratee) {
              seen.push(computed);
            }
            result.push(value);
          } else if (!includes(seen, computed, comparator)) {
            if (seen !== result) {
              seen.push(computed);
            }
            result.push(value);
          }
        }
      return result;
    }
    module2.exports = baseUniq2;
  }
});

// node_modules/lodash/uniq.js
var require_uniq = __commonJS({
  "node_modules/lodash/uniq.js"(exports2, module2) {
    "use strict";
    var baseUniq2 = require_baseUniq();
    function uniq(array4) {
      return array4 && array4.length ? baseUniq2(array4) : [];
    }
    module2.exports = uniq;
  }
});

// node_modules/knex/lib/dialects/oracle/schema/internal/incrementUtils.js
var require_incrementUtils = __commonJS({
  "node_modules/knex/lib/dialects/oracle/schema/internal/incrementUtils.js"(exports2, module2) {
    "use strict";
    var Trigger = require_trigger();
    function createAutoIncrementTriggerAndSequence(columnCompiler) {
      const trigger = new Trigger(columnCompiler.client.version);
      columnCompiler.pushAdditional(function() {
        const tableName = this.tableCompiler.tableNameRaw;
        const schemaName = this.tableCompiler.schemaNameRaw;
        const createTriggerSQL = trigger.createAutoIncrementTrigger(
          this.client.logger,
          tableName,
          schemaName
        );
        this.pushQuery(createTriggerSQL);
      });
    }
    module2.exports = {
      createAutoIncrementTriggerAndSequence
    };
  }
});

// node_modules/knex/lib/dialects/oracle/schema/oracle-columncompiler.js
var require_oracle_columncompiler = __commonJS({
  "node_modules/knex/lib/dialects/oracle/schema/oracle-columncompiler.js"(exports2, module2) {
    "use strict";
    var uniq = require_uniq();
    var Raw = require_raw2();
    var ColumnCompiler = require_columncompiler();
    var {
      createAutoIncrementTriggerAndSequence
    } = require_incrementUtils();
    var { toNumber: toNumber2 } = require_helpers();
    var ColumnCompiler_Oracle = class extends ColumnCompiler {
      constructor() {
        super(...arguments);
        this.modifiers = ["defaultTo", "checkIn", "nullable", "comment"];
      }
      increments(options = { primaryKey: true }) {
        createAutoIncrementTriggerAndSequence(this);
        return "integer not null" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
      }
      bigincrements(options = { primaryKey: true }) {
        createAutoIncrementTriggerAndSequence(this);
        return "number(20, 0) not null" + (this.tableCompiler._canBeAddPrimaryKey(options) ? " primary key" : "");
      }
      floating(precision) {
        const parsedPrecision = toNumber2(precision, 0);
        return `float${parsedPrecision ? `(${parsedPrecision})` : ""}`;
      }
      double(precision, scale) {
        return `number(${toNumber2(precision, 8)}, ${toNumber2(scale, 2)})`;
      }
      decimal(precision, scale) {
        if (precision === null) return "decimal";
        return `decimal(${toNumber2(precision, 8)}, ${toNumber2(scale, 2)})`;
      }
      integer(length) {
        return length ? `number(${toNumber2(length, 11)})` : "integer";
      }
      enu(allowed) {
        allowed = uniq(allowed);
        const maxLength = (allowed || []).reduce(
          (maxLength2, name28) => Math.max(maxLength2, String(name28).length),
          1
        );
        this.columnBuilder._modifiers.checkIn = [allowed];
        return `varchar2(${maxLength})`;
      }
      datetime(without) {
        return without ? "timestamp" : "timestamp with time zone";
      }
      timestamp(without) {
        return without ? "timestamp" : "timestamp with time zone";
      }
      bool() {
        this.columnBuilder._modifiers.checkIn = [[0, 1]];
        return "number(1, 0)";
      }
      varchar(length) {
        return `varchar2(${toNumber2(length, 255)})`;
      }
      // Modifiers
      // ------
      comment(comment) {
        const columnName = this.args[0] || this.defaults("columnName");
        this.pushAdditional(function() {
          this.pushQuery(
            `comment on column ${this.tableCompiler.tableName()}.` + this.formatter.wrap(columnName) + " is '" + (comment || "") + "'"
          );
        }, comment);
      }
      checkIn(value) {
        if (value === void 0) {
          return "";
        } else if (value instanceof Raw) {
          value = value.toQuery();
        } else if (Array.isArray(value)) {
          value = value.map((v) => `'${v}'`).join(", ");
        } else {
          value = `'${value}'`;
        }
        return `check (${this.formatter.wrap(this.args[0])} in (${value}))`;
      }
    };
    ColumnCompiler_Oracle.prototype.tinyint = "smallint";
    ColumnCompiler_Oracle.prototype.smallint = "smallint";
    ColumnCompiler_Oracle.prototype.mediumint = "integer";
    ColumnCompiler_Oracle.prototype.biginteger = "number(20, 0)";
    ColumnCompiler_Oracle.prototype.text = "clob";
    ColumnCompiler_Oracle.prototype.time = "timestamp with time zone";
    ColumnCompiler_Oracle.prototype.bit = "clob";
    ColumnCompiler_Oracle.prototype.json = "clob";
    module2.exports = ColumnCompiler_Oracle;
  }
});

// node_modules/knex/lib/dialects/oracle/schema/oracle-tablecompiler.js
var require_oracle_tablecompiler = __commonJS({
  "node_modules/knex/lib/dialects/oracle/schema/oracle-tablecompiler.js"(exports2, module2) {
    "use strict";
    var utils = require_utils10();
    var TableCompiler = require_tablecompiler();
    var helpers = require_helpers();
    var Trigger = require_trigger();
    var { isObject: isObject5 } = require_is();
    var TableCompiler_Oracle = class extends TableCompiler {
      constructor() {
        super(...arguments);
      }
      addColumns(columns, prefix) {
        if (columns.sql.length > 0) {
          prefix = prefix || this.addColumnsPrefix;
          const columnSql = columns.sql;
          const alter = this.lowerCase ? "alter table " : "ALTER TABLE ";
          let sql = `${alter}${this.tableName()} ${prefix}`;
          if (columns.sql.length > 1) {
            sql += `(${columnSql.join(", ")})`;
          } else {
            sql += columnSql.join(", ");
          }
          this.pushQuery({
            sql,
            bindings: columns.bindings
          });
        }
      }
      // Compile a rename column command.
      renameColumn(from, to) {
        const tableName = this.tableName().slice(1, -1);
        const trigger = new Trigger(this.client.version);
        return this.pushQuery(
          trigger.renameColumnTrigger(this.client.logger, tableName, from, to)
        );
      }
      compileAdd(builder) {
        const table = this.formatter.wrap(builder);
        const columns = this.prefixArray("add column", this.getColumns(builder));
        return this.pushQuery({
          sql: `alter table ${table} ${columns.join(", ")}`
        });
      }
      // Adds the "create" query to the query sequence.
      createQuery(columns, ifNot, like) {
        const columnsSql = like && this.tableNameLike() ? " as (select * from " + this.tableNameLike() + " where 0=1)" : " (" + columns.sql.join(", ") + this._addChecks() + ")";
        const sql = `create table ${this.tableName()}${columnsSql}`;
        this.pushQuery({
          // catch "name is already used by an existing object" for workaround for "if not exists"
          sql: ifNot ? utils.wrapSqlWithCatch(sql, -955) : sql,
          bindings: columns.bindings
        });
        if (this.single.comment) this.comment(this.single.comment);
        if (like) {
          this.addColumns(columns, this.addColumnsPrefix);
        }
      }
      // Compiles the comment on the table.
      comment(comment) {
        this.pushQuery(`comment on table ${this.tableName()} is '${comment}'`);
      }
      dropColumn() {
        const columns = helpers.normalizeArr.apply(null, arguments);
        this.pushQuery(
          `alter table ${this.tableName()} drop (${this.formatter.columnize(
            columns
          )})`
        );
      }
      _indexCommand(type, tableName, columns) {
        const nameHelper = new utils.NameHelper(this.client.version);
        return this.formatter.wrap(
          nameHelper.generateCombinedName(
            this.client.logger,
            type,
            tableName,
            columns
          )
        );
      }
      primary(columns, constraintName) {
        let deferrable;
        if (isObject5(constraintName)) {
          ({ constraintName, deferrable } = constraintName);
        }
        deferrable = deferrable ? ` deferrable initially ${deferrable}` : "";
        constraintName = constraintName ? this.formatter.wrap(constraintName) : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
        const primaryCols = columns;
        let incrementsCols = [];
        if (this.grouped.columns) {
          incrementsCols = this._getIncrementsColumnNames();
          if (incrementsCols) {
            incrementsCols.forEach((c) => {
              if (!primaryCols.includes(c)) {
                primaryCols.unshift(c);
              }
            });
          }
        }
        this.pushQuery(
          `alter table ${this.tableName()} add constraint ${constraintName} primary key (${this.formatter.columnize(
            primaryCols
          )})${deferrable}`
        );
      }
      dropPrimary(constraintName) {
        constraintName = constraintName ? this.formatter.wrap(constraintName) : this.formatter.wrap(this.tableNameRaw + "_pkey");
        this.pushQuery(
          `alter table ${this.tableName()} drop constraint ${constraintName}`
        );
      }
      index(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        this.pushQuery(
          `create index ${indexName} on ${this.tableName()} (` + this.formatter.columnize(columns) + ")"
        );
      }
      dropIndex(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("index", this.tableNameRaw, columns);
        this.pushQuery(`drop index ${indexName}`);
      }
      unique(columns, indexName) {
        let deferrable;
        if (isObject5(indexName)) {
          ({ indexName, deferrable } = indexName);
        }
        deferrable = deferrable ? ` deferrable initially ${deferrable}` : "";
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        this.pushQuery(
          `alter table ${this.tableName()} add constraint ${indexName} unique (` + this.formatter.columnize(columns) + ")" + deferrable
        );
      }
      dropUnique(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("unique", this.tableNameRaw, columns);
        this.pushQuery(
          `alter table ${this.tableName()} drop constraint ${indexName}`
        );
      }
      dropUniqueIfExists(columns, indexName) {
        throw new Error(".dropUniqueIfExists() is not supported by oracle");
      }
      dropForeign(columns, indexName) {
        indexName = indexName ? this.formatter.wrap(indexName) : this._indexCommand("foreign", this.tableNameRaw, columns);
        this.pushQuery(
          `alter table ${this.tableName()} drop constraint ${indexName}`
        );
      }
      dropForeignIfExists() {
        throw new Error(".dropForeignIfExists() is not supported by oracle");
      }
      dropPrimaryIfExists() {
        throw new Error(".dropPrimaryIfExists() is not supported by oracle");
      }
    };
    TableCompiler_Oracle.prototype.addColumnsPrefix = "add ";
    TableCompiler_Oracle.prototype.alterColumnsPrefix = "modify ";
    module2.exports = TableCompiler_Oracle;
  }
});

// node_modules/knex/lib/dialects/oracle/index.js
var require_oracle = __commonJS({
  "node_modules/knex/lib/dialects/oracle/index.js"(exports2, module2) {
    "use strict";
    var { ReturningHelper } = require_utils10();
    var { isConnectionError } = require_utils10();
    var Client2 = require_client2();
    var SchemaCompiler = require_oracle_compiler();
    var ColumnBuilder = require_oracle_columnbuilder();
    var ColumnCompiler = require_oracle_columncompiler();
    var TableCompiler = require_oracle_tablecompiler();
    var Client_Oracle = class extends Client2 {
      schemaCompiler() {
        return new SchemaCompiler(this, ...arguments);
      }
      columnBuilder() {
        return new ColumnBuilder(this, ...arguments);
      }
      columnCompiler() {
        return new ColumnCompiler(this, ...arguments);
      }
      tableCompiler() {
        return new TableCompiler(this, ...arguments);
      }
      // Return the database for the Oracle client.
      database() {
        return this.connectionSettings.database;
      }
      // Position the bindings for the query.
      positionBindings(sql) {
        let questionCount = 0;
        return sql.replace(/\?/g, function() {
          questionCount += 1;
          return `:${questionCount}`;
        });
      }
      _stream(connection, obj, stream4, options) {
        if (!obj.sql) throw new Error("The query is empty");
        return new Promise(function(resolver, rejecter) {
          stream4.on("error", (err) => {
            if (isConnectionError(err)) {
              connection.__knex__disposed = err;
            }
            rejecter(err);
          });
          stream4.on("end", resolver);
          const queryStream = connection.queryStream(
            obj.sql,
            obj.bindings,
            options
          );
          queryStream.pipe(stream4);
          queryStream.on("error", function(error73) {
            rejecter(error73);
            stream4.emit("error", error73);
          });
        });
      }
      // Formatter part
      alias(first, second) {
        return first + " " + second;
      }
      parameter(value, builder, formatter) {
        if (value instanceof ReturningHelper && this.driver) {
          value = new this.driver.OutParam(this.driver.OCCISTRING);
        } else if (typeof value === "boolean") {
          value = value ? 1 : 0;
        }
        return super.parameter(value, builder, formatter);
      }
    };
    Object.assign(Client_Oracle.prototype, {
      dialect: "oracle",
      driverName: "oracle"
    });
    module2.exports = Client_Oracle;
  }
});

// node_modules/knex/lib/dialects/oracle/query/oracle-querycompiler.js
var require_oracle_querycompiler = __commonJS({
  "node_modules/knex/lib/dialects/oracle/query/oracle-querycompiler.js"(exports2, module2) {
    "use strict";
    var compact = require_compact();
    var identity2 = require_identity();
    var isEmpty = require_isEmpty();
    var isPlainObject4 = require_isPlainObject();
    var reduce = require_reduce();
    var QueryCompiler = require_querycompiler();
    var { ReturningHelper } = require_utils10();
    var { isString: isString2 } = require_is();
    var components = [
      "comments",
      "columns",
      "join",
      "where",
      "union",
      "group",
      "having",
      "order",
      "lock"
    ];
    var QueryCompiler_Oracle = class extends QueryCompiler {
      constructor(client, builder, formatter) {
        super(client, builder, formatter);
        const { onConflict } = this.single;
        if (onConflict) {
          throw new Error(".onConflict() is not supported for oracledb.");
        }
        this.first = this.select;
      }
      // Compiles an "insert" query, allowing for multiple
      // inserts using a single query statement.
      insert() {
        let insertValues = this.single.insert || [];
        let { returning } = this.single;
        if (!Array.isArray(insertValues) && isPlainObject4(this.single.insert)) {
          insertValues = [this.single.insert];
        }
        if (returning && !Array.isArray(returning)) {
          returning = [returning];
        }
        if (Array.isArray(insertValues) && insertValues.length === 1 && isEmpty(insertValues[0])) {
          return this._addReturningToSqlAndConvert(
            `insert into ${this.tableName} (${this.formatter.wrap(
              this.single.returning
            )}) values (default)`,
            returning,
            this.tableName
          );
        }
        if (isEmpty(this.single.insert) && typeof this.single.insert !== "function") {
          return "";
        }
        const insertData = this._prepInsert(insertValues);
        const sql = {};
        if (isString2(insertData)) {
          return this._addReturningToSqlAndConvert(
            `insert into ${this.tableName} ${insertData}`,
            returning
          );
        }
        if (insertData.values.length === 1) {
          return this._addReturningToSqlAndConvert(
            `insert into ${this.tableName} (${this.formatter.columnize(
              insertData.columns
            )}) values (${this.client.parameterize(
              insertData.values[0],
              void 0,
              this.builder,
              this.bindingsHolder
            )})`,
            returning,
            this.tableName
          );
        }
        const insertDefaultsOnly = insertData.columns.length === 0;
        sql.sql = "begin " + insertData.values.map((value) => {
          let returningHelper;
          const parameterizedValues = !insertDefaultsOnly ? this.client.parameterize(
            value,
            this.client.valueForUndefined,
            this.builder,
            this.bindingsHolder
          ) : "";
          const returningValues = Array.isArray(returning) ? returning : [returning];
          let subSql = `insert into ${this.tableName} `;
          if (returning) {
            returningHelper = new ReturningHelper(returningValues.join(":"));
            sql.outParams = (sql.outParams || []).concat(returningHelper);
          }
          if (insertDefaultsOnly) {
            subSql += `(${this.formatter.wrap(
              this.single.returning
            )}) values (default)`;
          } else {
            subSql += `(${this.formatter.columnize(
              insertData.columns
            )}) values (${parameterizedValues})`;
          }
          subSql += returning ? ` returning ROWID into ${this.client.parameter(
            returningHelper,
            this.builder,
            this.bindingsHolder
          )}` : "";
          subSql = this.formatter.client.positionBindings(subSql);
          const parameterizedValuesWithoutDefault = parameterizedValues.replace("DEFAULT, ", "").replace(", DEFAULT", "");
          return `execute immediate '${subSql.replace(/'/g, "''")}` + (parameterizedValuesWithoutDefault || returning ? "' using " : "") + parameterizedValuesWithoutDefault + (parameterizedValuesWithoutDefault && returning ? ", " : "") + (returning ? "out ?" : "") + ";";
        }).join(" ") + "end;";
        if (returning) {
          sql.returning = returning;
          sql.returningSql = `select ${this.formatter.columnize(returning)} from ` + this.tableName + " where ROWID in (" + sql.outParams.map((v, i) => `:${i + 1}`).join(", ") + ") order by case ROWID " + sql.outParams.map((v, i) => `when CHARTOROWID(:${i + 1}) then ${i}`).join(" ") + " end";
        }
        return sql;
      }
      // Update method, including joins, wheres, order & limits.
      update() {
        const updates = this._prepUpdate(this.single.update);
        const where = this.where();
        let { returning } = this.single;
        const sql = `update ${this.tableName} set ` + updates.join(", ") + (where ? ` ${where}` : "");
        if (!returning) {
          return sql;
        }
        if (!Array.isArray(returning)) {
          returning = [returning];
        }
        return this._addReturningToSqlAndConvert(sql, returning, this.tableName);
      }
      // Compiles a `truncate` query.
      truncate() {
        return `truncate table ${this.tableName}`;
      }
      forUpdate() {
        return "for update";
      }
      forShare() {
        this.client.logger.warn(
          "lock for share is not supported by oracle dialect"
        );
        return "";
      }
      // Compiles a `columnInfo` query.
      columnInfo() {
        const column = this.single.columnInfo;
        const table = this.client.customWrapIdentifier(this.single.table, identity2);
        const sql = `select * from xmltable( '/ROWSET/ROW'
      passing dbms_xmlgen.getXMLType('
      select char_col_decl_length, column_name, data_type, data_default, nullable
      from all_tab_columns where table_name = ''${table}'' ')
      columns
      CHAR_COL_DECL_LENGTH number, COLUMN_NAME varchar2(200), DATA_TYPE varchar2(106),
      DATA_DEFAULT clob, NULLABLE varchar2(1))`;
        return {
          sql,
          output(resp) {
            const out = reduce(
              resp,
              function(columns, val) {
                columns[val.COLUMN_NAME] = {
                  type: val.DATA_TYPE,
                  defaultValue: val.DATA_DEFAULT,
                  maxLength: val.CHAR_COL_DECL_LENGTH,
                  nullable: val.NULLABLE === "Y"
                };
                return columns;
              },
              {}
            );
            return column && out[column] || out;
          }
        };
      }
      select() {
        let query = this.with();
        const statements = components.map((component) => {
          return this[component]();
        });
        query += compact(statements).join(" ");
        return this._surroundQueryWithLimitAndOffset(query);
      }
      aggregate(stmt) {
        return this._aggregate(stmt, { aliasSeparator: " " });
      }
      // for single commands only
      _addReturningToSqlAndConvert(sql, returning, tableName) {
        const res = {
          sql
        };
        if (!returning) {
          return res;
        }
        const returningValues = Array.isArray(returning) ? returning : [returning];
        const returningHelper = new ReturningHelper(returningValues.join(":"));
        res.sql = sql + " returning ROWID into " + this.client.parameter(returningHelper, this.builder, this.bindingsHolder);
        res.returningSql = `select ${this.formatter.columnize(
          returning
        )} from ${tableName} where ROWID = :1`;
        res.outParams = [returningHelper];
        res.returning = returning;
        return res;
      }
      _surroundQueryWithLimitAndOffset(query) {
        let { limit } = this.single;
        const { offset } = this.single;
        const hasLimit = limit || limit === 0 || limit === "0";
        limit = +limit;
        if (!hasLimit && !offset) return query;
        query = query || "";
        if (hasLimit && !offset) {
          return `select * from (${query}) where rownum <= ${this._getValueOrParameterFromAttribute(
            "limit",
            limit
          )}`;
        }
        const endRow = +offset + (hasLimit ? limit : 1e13);
        return "select * from (select row_.*, ROWNUM rownum_ from (" + query + ") row_ where rownum <= " + (this.single.skipBinding["offset"] ? endRow : this.client.parameter(endRow, this.builder, this.bindingsHolder)) + ") where rownum_ > " + this._getValueOrParameterFromAttribute("offset", offset);
      }
    };
    module2.exports = QueryCompiler_Oracle;
  }
});

// node_modules/knex/lib/dialects/oracledb/utils.js
var require_utils11 = __commonJS({
  "node_modules/knex/lib/dialects/oracledb/utils.js"(exports2, module2) {
    "use strict";
    var Utils = require_utils10();
    var { promisify: promisify2 } = require("util");
    var stream4 = require("stream");
    function BlobHelper(columnName, value) {
      this.columnName = columnName;
      this.value = value;
      this.returning = false;
    }
    BlobHelper.prototype.toString = function() {
      return "[object BlobHelper:" + this.columnName + "]";
    };
    function readStream2(stream5, type) {
      return new Promise((resolve3, reject) => {
        let data = type === "string" ? "" : Buffer.alloc(0);
        stream5.on("error", function(err) {
          reject(err);
        });
        stream5.on("data", function(chunk) {
          if (type === "string") {
            data += chunk;
          } else {
            data = Buffer.concat([data, chunk]);
          }
        });
        stream5.on("end", function() {
          resolve3(data);
        });
      });
    }
    var lobProcessing = function(stream5) {
      const oracledb = require("oracledb");
      let type;
      if (stream5.type) {
        if (stream5.type === oracledb.BLOB) {
          type = "buffer";
        } else if (stream5.type === oracledb.CLOB) {
          type = "string";
        }
      } else if (stream5.iLob) {
        if (stream5.iLob.type === oracledb.CLOB) {
          type = "string";
        } else if (stream5.iLob.type === oracledb.BLOB) {
          type = "buffer";
        }
      } else {
        throw new Error("Unrecognized oracledb lob stream type");
      }
      if (type === "string") {
        stream5.setEncoding("utf-8");
      }
      return readStream2(stream5, type);
    };
    function monkeyPatchConnection(connection, client) {
      if (connection.executeAsync) {
        return;
      }
      connection.commitAsync = function() {
        return new Promise((commitResolve, commitReject) => {
          this.commit(function(err) {
            if (err) {
              return commitReject(err);
            }
            commitResolve();
          });
        });
      };
      connection.rollbackAsync = function() {
        return new Promise((rollbackResolve, rollbackReject) => {
          this.rollback(function(err) {
            if (err) {
              return rollbackReject(err);
            }
            rollbackResolve();
          });
        });
      };
      const fetchAsync = promisify2(function(sql, bindParams, options, cb) {
        options = options || {};
        options.outFormat = client.driver.OUT_FORMAT_OBJECT || client.driver.OBJECT;
        if (!options.outFormat) {
          throw new Error("not found oracledb.outFormat constants");
        }
        if (options.resultSet) {
          connection.execute(
            sql,
            bindParams || [],
            options,
            function(err, result) {
              if (err) {
                if (Utils.isConnectionError(err)) {
                  connection.close().catch(function(err2) {
                  });
                  connection.__knex__disposed = err;
                }
                return cb(err);
              }
              const fetchResult = { rows: [], resultSet: result.resultSet };
              const numRows = 100;
              const fetchRowsFromRS = function(connection2, resultSet, numRows2) {
                resultSet.getRows(numRows2, function(err2, rows) {
                  if (err2) {
                    if (Utils.isConnectionError(err2)) {
                      connection2.close().catch(function(err3) {
                      });
                      connection2.__knex__disposed = err2;
                    }
                    resultSet.close(function() {
                      return cb(err2);
                    });
                  } else if (rows.length === 0) {
                    return cb(null, fetchResult);
                  } else if (rows.length > 0) {
                    if (rows.length === numRows2) {
                      fetchResult.rows = fetchResult.rows.concat(rows);
                      fetchRowsFromRS(connection2, resultSet, numRows2);
                    } else {
                      fetchResult.rows = fetchResult.rows.concat(rows);
                      return cb(null, fetchResult);
                    }
                  }
                });
              };
              fetchRowsFromRS(connection, result.resultSet, numRows);
            }
          );
        } else {
          connection.execute(
            sql,
            bindParams || [],
            options,
            function(err, result) {
              if (err) {
                if (Utils.isConnectionError(err)) {
                  connection.close().catch(function(err2) {
                  });
                  connection.__knex__disposed = err;
                }
                return cb(err);
              }
              return cb(null, result);
            }
          );
        }
      });
      connection.executeAsync = function(sql, bindParams, options) {
        return fetchAsync(sql, bindParams, options).then(async (results) => {
          const closeResultSet = () => {
            return results.resultSet ? promisify2(results.resultSet.close).call(results.resultSet) : Promise.resolve();
          };
          const lobs = [];
          if (results.rows) {
            if (Array.isArray(results.rows)) {
              for (let i = 0; i < results.rows.length; i++) {
                const row = results.rows[i];
                for (const column in row) {
                  if (row[column] instanceof stream4.Readable) {
                    lobs.push({ index: i, key: column, stream: row[column] });
                  }
                }
              }
            }
          }
          try {
            for (const lob of lobs) {
              results.rows[lob.index][lob.key] = await lobProcessing(lob.stream);
            }
          } catch (e) {
            await closeResultSet().catch(() => {
            });
            throw e;
          }
          await closeResultSet();
          return results;
        });
      };
    }
    Utils.BlobHelper = BlobHelper;
    Utils.monkeyPatchConnection = monkeyPatchConnection;
    module2.exports = Utils;
  }
});

// node_modules/knex/lib/dialects/oracledb/query/oracledb-querycompiler.js
var require_oracledb_querycompiler = __commonJS({
  "node_modules/knex/lib/dialects/oracledb/query/oracledb-querycompiler.js"(exports2, module2) {
    "use strict";
    var clone3 = require_clone();
    var each = require_each();
    var isEmpty = require_isEmpty();
    var isPlainObject4 = require_isPlainObject();
    var Oracle_Compiler = require_oracle_querycompiler();
    var ReturningHelper = require_utils11().ReturningHelper;
    var BlobHelper = require_utils11().BlobHelper;
    var { isString: isString2 } = require_is();
    var {
      columnize: columnize_
    } = require_wrappingFormatter();
    var Oracledb_Compiler = class extends Oracle_Compiler {
      // Compiles an "insert" query, allowing for multiple
      // inserts using a single query statement.
      insert() {
        const self2 = this;
        const outBindPrep = this._prepOutbindings(
          this.single.insert,
          this.single.returning
        );
        const outBinding = outBindPrep.outBinding;
        const returning = outBindPrep.returning;
        const insertValues = outBindPrep.values;
        if (Array.isArray(insertValues) && insertValues.length === 1 && isEmpty(insertValues[0])) {
          const returningFragment = this.single.returning ? " (" + this.formatter.wrap(this.single.returning) + ")" : "";
          return this._addReturningToSqlAndConvert(
            "insert into " + this.tableName + returningFragment + " values (default)",
            outBinding[0],
            this.tableName,
            returning
          );
        }
        if (isEmpty(this.single.insert) && typeof this.single.insert !== "function") {
          return "";
        }
        const insertData = this._prepInsert(insertValues);
        const sql = {};
        if (isString2(insertData)) {
          return this._addReturningToSqlAndConvert(
            "insert into " + this.tableName + " " + insertData,
            outBinding[0],
            this.tableName,
            returning
          );
        }
        if (insertData.values.length === 1) {
          return this._addReturningToSqlAndConvert(
            "insert into " + this.tableName + " (" + this.formatter.columnize(insertData.columns) + ") values (" + this.client.parameterize(
              insertData.values[0],
              void 0,
              this.builder,
              this.bindingsHolder
            ) + ")",
            outBinding[0],
            this.tableName,
            returning
          );
        }
        const insertDefaultsOnly = insertData.columns.length === 0;
        sql.returning = returning;
        sql.sql = "begin " + insertData.values.map(function(value, index) {
          const parameterizedValues = !insertDefaultsOnly ? self2.client.parameterize(
            value,
            self2.client.valueForUndefined,
            self2.builder,
            self2.bindingsHolder
          ) : "";
          let subSql = "insert into " + self2.tableName;
          if (insertDefaultsOnly) {
            subSql += " (" + self2.formatter.wrap(self2.single.returning) + ") values (default)";
          } else {
            subSql += " (" + self2.formatter.columnize(insertData.columns) + ") values (" + parameterizedValues + ")";
          }
          let returningClause = "";
          let intoClause = "";
          let usingClause = "";
          let outClause = "";
          each(value, function(val) {
            if (!(val instanceof BlobHelper)) {
              usingClause += " ?,";
            }
          });
          usingClause = usingClause.slice(0, -1);
          outBinding[index].forEach(function(ret) {
            const columnName = ret.columnName || ret;
            returningClause += self2.formatter.wrap(columnName) + ",";
            intoClause += " ?,";
            outClause += " out ?,";
            if (ret instanceof BlobHelper) {
              return self2.formatter.bindings.push(ret);
            }
            self2.formatter.bindings.push(new ReturningHelper(columnName));
          });
          returningClause = returningClause.slice(0, -1);
          intoClause = intoClause.slice(0, -1);
          outClause = outClause.slice(0, -1);
          if (returningClause && intoClause) {
            subSql += " returning " + returningClause + " into" + intoClause;
          }
          subSql = self2.formatter.client.positionBindings(subSql);
          const parameterizedValuesWithoutDefaultAndBlob = parameterizedValues.replace(/DEFAULT, /g, "").replace(/, DEFAULT/g, "").replace("EMPTY_BLOB(), ", "").replace(", EMPTY_BLOB()", "");
          return "execute immediate '" + subSql.replace(/'/g, "''") + (parameterizedValuesWithoutDefaultAndBlob || value ? "' using " : "") + parameterizedValuesWithoutDefaultAndBlob + (parameterizedValuesWithoutDefaultAndBlob && outClause ? "," : "") + outClause + ";";
        }).join(" ") + "end;";
        sql.outBinding = outBinding;
        if (returning[0] === "*") {
          sql.returningSql = function() {
            return "select * from " + self2.tableName + " where ROWID in (" + this.outBinding.map(function(v, i) {
              return ":" + (i + 1);
            }).join(", ") + ") order by case ROWID " + this.outBinding.map(function(v, i) {
              return "when CHARTOROWID(:" + (i + 1) + ") then " + i;
            }).join(" ") + " end";
          };
        }
        return sql;
      }
      with() {
        const undoList = [];
        if (this.grouped.with) {
          for (const stmt of this.grouped.with) {
            if (stmt.recursive) {
              undoList.push(stmt);
              stmt.recursive = false;
            }
          }
        }
        const result = super.with();
        for (const stmt of undoList) {
          stmt.recursive = true;
        }
        return result;
      }
      _addReturningToSqlAndConvert(sql, outBinding, tableName, returning) {
        const self2 = this;
        const res = {
          sql
        };
        if (!outBinding) {
          return res;
        }
        const returningValues = Array.isArray(outBinding) ? outBinding : [outBinding];
        let returningClause = "";
        let intoClause = "";
        returningValues.forEach(function(ret) {
          const columnName = ret.columnName || ret;
          returningClause += self2.formatter.wrap(columnName) + ",";
          intoClause += "?,";
          if (ret instanceof BlobHelper) {
            return self2.formatter.bindings.push(ret);
          }
          self2.formatter.bindings.push(new ReturningHelper(columnName));
        });
        res.sql = sql;
        returningClause = returningClause.slice(0, -1);
        intoClause = intoClause.slice(0, -1);
        if (returningClause && intoClause) {
          res.sql += " returning " + returningClause + " into " + intoClause;
        }
        res.outBinding = [outBinding];
        if (returning[0] === "*") {
          res.returningSql = function() {
            return "select * from " + self2.tableName + " where ROWID = :1";
          };
        }
        res.returning = returning;
        return res;
      }
      _prepOutbindings(paramValues, paramReturning) {
        const result = {};
        let params = paramValues || [];
        let returning = paramReturning || [];
        if (!Array.isArray(params) && isPlainObject4(paramValues)) {
          params = [params];
        }
        if (returning && !Array.isArray(returning)) {
          returning = [returning];
        }
        const outBinding = [];
        each(params, function(values, index) {
          if (returning[0] === "*") {
            outBinding[index] = ["ROWID"];
          } else {
            outBinding[index] = clone3(returning);
          }
          each(values, function(value, key) {
            if (value instanceof Buffer) {
              values[key] = new BlobHelper(key, value);
              const blobIndex = outBinding[index].indexOf(key);
              if (blobIndex >= 0) {
                outBinding[index].splice(blobIndex, 1);
                values[key].returning = true;
              }
              outBinding[index].push(values[key]);
            }
            if (value === void 0) {
              delete params[index][key];
            }
          });
        });
        result.returning = returning;
        result.outBinding = outBinding;
        result.values = params;
        return result;
      }
      _groupOrder(item, type) {
        return super._groupOrderNulls(item, type);
      }
      update() {
        const self2 = this;
        const sql = {};
        const outBindPrep = this._prepOutbindings(
          this.single.update || this.single.counter,
          this.single.returning
        );
        const outBinding = outBindPrep.outBinding;
        const returning = outBindPrep.returning;
        const updates = this._prepUpdate(this.single.update);
        const where = this.where();
        let returningClause = "";
        let intoClause = "";
        if (isEmpty(updates) && typeof this.single.update !== "function") {
          return "";
        }
        outBinding.forEach(function(out) {
          out.forEach(function(ret) {
            const columnName = ret.columnName || ret;
            returningClause += self2.formatter.wrap(columnName) + ",";
            intoClause += " ?,";
            if (ret instanceof BlobHelper) {
              return self2.formatter.bindings.push(ret);
            }
            self2.formatter.bindings.push(new ReturningHelper(columnName));
          });
        });
        returningClause = returningClause.slice(0, -1);
        intoClause = intoClause.slice(0, -1);
        sql.outBinding = outBinding;
        sql.returning = returning;
        sql.sql = "update " + this.tableName + " set " + updates.join(", ") + (where ? " " + where : "");
        if (outBinding.length && !isEmpty(outBinding[0])) {
          sql.sql += " returning " + returningClause + " into" + intoClause;
        }
        if (returning[0] === "*") {
          sql.returningSql = function() {
            let sql2 = "select * from " + self2.tableName;
            const modifiedRowsCount = this.rowsAffected.length || this.rowsAffected;
            let returningSqlIn = " where ROWID in (";
            let returningSqlOrderBy = ") order by case ROWID ";
            for (let i = 0; i < modifiedRowsCount; i++) {
              if (this.returning[0] === "*") {
                returningSqlIn += ":" + (i + 1) + ", ";
                returningSqlOrderBy += "when CHARTOROWID(:" + (i + 1) + ") then " + i + " ";
              }
            }
            if (this.returning[0] === "*") {
              this.returning = this.returning.slice(0, -1);
              returningSqlIn = returningSqlIn.slice(0, -2);
              returningSqlOrderBy = returningSqlOrderBy.slice(0, -1);
            }
            return sql2 += returningSqlIn + returningSqlOrderBy + " end";
          };
        }
        return sql;
      }
      _jsonPathWrap(extraction) {
        return `'${extraction.path || extraction[1]}'`;
      }
      // Json functions
      jsonExtract(params) {
        return this._jsonExtract(
          params.singleValue ? "json_value" : "json_query",
          params
        );
      }
      jsonSet(params) {
        return `json_transform(${columnize_(
          params.column,
          this.builder,
          this.client,
          this.bindingsHolder
        )}, set ${this.client.parameter(
          params.path,
          this.builder,
          this.bindingsHolder
        )} = ${this.client.parameter(
          params.value,
          this.builder,
          this.bindingsHolder
        )})`;
      }
      jsonInsert(params) {
        return `json_transform(${columnize_(
          params.column,
          this.builder,
          this.client,
          this.bindingsHolder
        )}, insert ${this.client.parameter(
          params.path,
          this.builder,
          this.bindingsHolder
        )} = ${this.client.parameter(
          params.value,
          this.builder,
          this.bindingsHolder
        )})`;
      }
      jsonRemove(params) {
        const jsonCol = `json_transform(${columnize_(
          params.column,
          this.builder,
          this.client,
          this.bindingsHolder
        )}, remove ${this.client.parameter(
          params.path,
          this.builder,
          this.bindingsHolder
        )})`;
        return params.alias ? this.client.alias(jsonCol, this.formatter.wrap(params.alias)) : jsonCol;
      }
      whereJsonPath(statement) {
        return this._whereJsonPath("json_value", statement);
      }
      whereJsonSupersetOf(statement) {
        throw new Error(
          "Json superset where clause not actually supported by Oracle"
        );
      }
      whereJsonSubsetOf(statement) {
        throw new Error(
          "Json subset where clause not actually supported by Oracle"
        );
      }
      onJsonPathEquals(clause) {
        return this._onJsonPathEquals("json_value", clause);
      }
    };
    module2.exports = Oracledb_Compiler;
  }
});

// node_modules/knex/lib/dialects/oracledb/schema/oracledb-tablecompiler.js
var require_oracledb_tablecompiler = __commonJS({
  "node_modules/knex/lib/dialects/oracledb/schema/oracledb-tablecompiler.js"(exports2, module2) {
    "use strict";
    var TableCompiler_Oracle = require_oracle_tablecompiler();
    var TableCompiler_Oracledb = class extends TableCompiler_Oracle {
      constructor(client, tableBuilder) {
        super(client, tableBuilder);
      }
      _setNullableState(column, isNullable) {
        const nullability = isNullable ? "NULL" : "NOT NULL";
        const sql = `alter table ${this.tableName()} modify (${this.formatter.wrap(
          column
        )} ${nullability})`;
        return this.pushQuery({
          sql
        });
      }
    };
    module2.exports = TableCompiler_Oracledb;
  }
});

// node_modules/knex/lib/dialects/oracledb/schema/oracledb-columncompiler.js
var require_oracledb_columncompiler = __commonJS({
  "node_modules/knex/lib/dialects/oracledb/schema/oracledb-columncompiler.js"(exports2, module2) {
    "use strict";
    var ColumnCompiler_Oracle = require_oracle_columncompiler();
    var { isObject: isObject5 } = require_is();
    var ColumnCompiler_Oracledb = class extends ColumnCompiler_Oracle {
      constructor() {
        super(...arguments);
        this.modifiers = ["defaultTo", "nullable", "comment", "checkJson"];
        this._addCheckModifiers();
      }
      datetime(withoutTz) {
        let useTz;
        if (isObject5(withoutTz)) {
          ({ useTz } = withoutTz);
        } else {
          useTz = !withoutTz;
        }
        return useTz ? "timestamp with local time zone" : "timestamp";
      }
      timestamp(withoutTz) {
        let useTz;
        if (isObject5(withoutTz)) {
          ({ useTz } = withoutTz);
        } else {
          useTz = !withoutTz;
        }
        return useTz ? "timestamp with local time zone" : "timestamp";
      }
      checkRegex(regex, constraintName) {
        return this._check(
          `REGEXP_LIKE(${this.formatter.wrap(
            this.getColumnName()
          )},${this.client._escapeBinding(regex)})`,
          constraintName
        );
      }
      json() {
        this.columnBuilder._modifiers.checkJson = [
          this.formatter.columnize(this.getColumnName())
        ];
        return "varchar2(4000)";
      }
      jsonb() {
        return this.json();
      }
      checkJson(column) {
        return `check (${column} is json)`;
      }
    };
    ColumnCompiler_Oracledb.prototype.time = "timestamp with local time zone";
    ColumnCompiler_Oracledb.prototype.uuid = ({ useBinaryUuid = false } = {}) => useBinaryUuid ? "raw(16)" : "char(36)";
    module2.exports = ColumnCompiler_Oracledb;
  }
});

// node_modules/knex/lib/dialects/oracledb/schema/oracledb-viewcompiler.js
var require_oracledb_viewcompiler = __commonJS({
  "node_modules/knex/lib/dialects/oracledb/schema/oracledb-viewcompiler.js"(exports2, module2) {
    "use strict";
    var ViewCompiler = require_viewcompiler();
    var ViewCompiler_Oracledb = class extends ViewCompiler {
      constructor(client, viewCompiler) {
        super(client, viewCompiler);
      }
      createOrReplace() {
        this.createQuery(this.columns, this.selectQuery, false, true);
      }
      createMaterializedView() {
        this.createQuery(this.columns, this.selectQuery, true);
      }
    };
    module2.exports = ViewCompiler_Oracledb;
  }
});

// node_modules/knex/lib/dialects/oracledb/schema/oracledb-viewbuilder.js
var require_oracledb_viewbuilder = __commonJS({
  "node_modules/knex/lib/dialects/oracledb/schema/oracledb-viewbuilder.js"(exports2, module2) {
    "use strict";
    var ViewBuilder = require_viewbuilder();
    var ViewBuilder_Oracledb = class extends ViewBuilder {
      constructor() {
        super(...arguments);
      }
      checkOption() {
        this._single.checkOption = "default_option";
      }
    };
    module2.exports = ViewBuilder_Oracledb;
  }
});

// node_modules/knex/lib/dialects/oracledb/transaction.js
var require_transaction5 = __commonJS({
  "node_modules/knex/lib/dialects/oracledb/transaction.js"(exports2, module2) {
    "use strict";
    var Transaction = require_transaction();
    var { timeout, KnexTimeoutError } = require_timeout();
    var debugTx = require_src3()("knex:tx");
    var supportedIsolationLevels = ["read committed", "serializable"];
    var isIsolationLevelEnabled = false;
    module2.exports = class Oracle_Transaction extends Transaction {
      // disable autocommit to allow correct behavior (default is true)
      begin(conn) {
        if (this.isolationLevel) {
          if (isIsolationLevelEnabled) {
            if (!supportedIsolationLevels.includes(this.isolationLevel)) {
              this.client.logger.warn(
                "Oracle only supports read committed and serializable transactions, ignoring the isolation level param"
              );
            } else {
              return this.query(conn, `SET TRANSACTION ${this.isolationLevel}`);
            }
          } else {
            this.client.logger.warn(
              "Transaction isolation is not currently supported for Oracle"
            );
          }
        }
        return Promise.resolve();
      }
      async commit(conn, value) {
        this._completed = true;
        try {
          await conn.commitAsync();
          this._resolver(value);
        } catch (err) {
          this._rejecter(err);
        }
      }
      release(conn, value) {
        return this._resolver(value);
      }
      rollback(conn, err) {
        this._completed = true;
        debugTx("%s: rolling back", this.txid);
        return timeout(conn.rollbackAsync(), 5e3).catch((e) => {
          if (!(e instanceof KnexTimeoutError)) {
            return Promise.reject(e);
          }
          this._rejecter(e);
        }).then(() => {
          if (err === void 0) {
            if (this.doNotRejectOnRollback) {
              this._resolver();
              return;
            }
            err = new Error(`Transaction rejected with non-error: ${err}`);
          }
          this._rejecter(err);
        });
      }
      savepoint(conn) {
        return this.query(conn, `SAVEPOINT ${this.txid}`);
      }
      async acquireConnection(config3, cb) {
        const configConnection = config3 && config3.connection;
        const connection = configConnection || await this.client.acquireConnection();
        try {
          connection.__knexTxId = this.txid;
          connection.isTransaction = true;
          return await cb(connection);
        } finally {
          debugTx("%s: releasing connection", this.txid);
          connection.isTransaction = false;
          try {
            await connection.commitAsync();
          } catch (err) {
            this._rejecter(err);
          } finally {
            if (!configConnection) {
              await this.client.releaseConnection(connection);
            } else {
              debugTx("%s: not releasing external connection", this.txid);
            }
          }
        }
      }
    };
  }
});

// node_modules/knex/lib/dialects/oracledb/index.js
var require_oracledb = __commonJS({
  "node_modules/knex/lib/dialects/oracledb/index.js"(exports2, module2) {
    "use strict";
    var each = require_each();
    var flatten = require_flatten();
    var isEmpty = require_isEmpty();
    var map3 = require_map();
    var Formatter = require_formatter();
    var QueryCompiler = require_oracledb_querycompiler();
    var TableCompiler = require_oracledb_tablecompiler();
    var ColumnCompiler = require_oracledb_columncompiler();
    var {
      BlobHelper,
      ReturningHelper,
      monkeyPatchConnection
    } = require_utils11();
    var ViewCompiler = require_oracledb_viewcompiler();
    var ViewBuilder = require_oracledb_viewbuilder();
    var Transaction = require_transaction5();
    var Client_Oracle = require_oracle();
    var { isString: isString2 } = require_is();
    var { outputQuery, unwrapRaw } = require_wrappingFormatter();
    var { compileCallback } = require_formatterUtils();
    var Client_Oracledb = class extends Client_Oracle {
      constructor(config3) {
        super(config3);
        if (this.version) {
          this.version = parseVersion(this.version);
        }
        if (this.driver) {
          process.env.UV_THREADPOOL_SIZE = process.env.UV_THREADPOOL_SIZE || 1;
          process.env.UV_THREADPOOL_SIZE = parseInt(process.env.UV_THREADPOOL_SIZE) + this.driver.poolMax;
        }
      }
      _driver() {
        const client = this;
        const oracledb = require("oracledb");
        client.fetchAsString = [];
        if (this.config.fetchAsString && Array.isArray(this.config.fetchAsString)) {
          this.config.fetchAsString.forEach(function(type) {
            if (!isString2(type)) return;
            type = type.toUpperCase();
            if (oracledb[type]) {
              if (type !== "NUMBER" && type !== "DATE" && type !== "CLOB" && type !== "BUFFER") {
                this.logger.warn(
                  'Only "date", "number", "clob" and "buffer" are supported for fetchAsString'
                );
              }
              client.fetchAsString.push(oracledb[type]);
            }
          });
        }
        return oracledb;
      }
      queryCompiler(builder, formatter) {
        return new QueryCompiler(this, builder, formatter);
      }
      tableCompiler() {
        return new TableCompiler(this, ...arguments);
      }
      columnCompiler() {
        return new ColumnCompiler(this, ...arguments);
      }
      viewBuilder() {
        return new ViewBuilder(this, ...arguments);
      }
      viewCompiler() {
        return new ViewCompiler(this, ...arguments);
      }
      formatter(builder) {
        return new Formatter(this, builder);
      }
      transaction() {
        return new Transaction(this, ...arguments);
      }
      prepBindings(bindings) {
        return map3(bindings, (value) => {
          if (value instanceof BlobHelper && this.driver) {
            return { type: this.driver.BLOB, dir: this.driver.BIND_OUT };
          } else if (value instanceof ReturningHelper && this.driver) {
            return { type: this.driver.STRING, dir: this.driver.BIND_OUT };
          } else if (typeof value === "boolean") {
            return value ? 1 : 0;
          }
          return value;
        });
      }
      // Checks whether a value is a function... if it is, we compile it
      // otherwise we check whether it's a raw
      parameter(value, builder, formatter) {
        if (typeof value === "function") {
          return outputQuery(
            compileCallback(value, void 0, this, formatter),
            true,
            builder,
            this
          );
        } else if (value instanceof BlobHelper) {
          formatter.bindings.push(value.value);
          return "?";
        }
        return unwrapRaw(value, true, builder, this, formatter) || "?";
      }
      // Get a raw connection, called by the `pool` whenever a new
      // connection needs to be added to the pool.
      acquireRawConnection() {
        return new Promise((resolver, rejecter) => {
          const oracleDbConfig = this.connectionSettings.externalAuth ? { externalAuth: this.connectionSettings.externalAuth } : {
            user: this.connectionSettings.user,
            password: this.connectionSettings.password
          };
          oracleDbConfig.connectString = resolveConnectString(
            this.connectionSettings
          );
          if (this.connectionSettings.prefetchRowCount) {
            oracleDbConfig.prefetchRows = this.connectionSettings.prefetchRowCount;
          }
          if (this.connectionSettings.stmtCacheSize !== void 0) {
            oracleDbConfig.stmtCacheSize = this.connectionSettings.stmtCacheSize;
          }
          this.driver.fetchAsString = this.fetchAsString;
          this.driver.getConnection(oracleDbConfig, (err, connection) => {
            if (err) {
              return rejecter(err);
            }
            monkeyPatchConnection(connection, this);
            resolver(connection);
          });
        });
      }
      // Used to explicitly close a connection, called internally by the pool
      // when a connection times out or the pool is shutdown.
      destroyRawConnection(connection) {
        return connection.release();
      }
      // Handle oracle version resolution on acquiring connection from pool instead of connection creation.
      // Must do this here since only the client used to create a connection would be updated with version
      // information on creation. Poses a problem when knex instance is cloned since instances share the
      // connection pool while having their own client instances.
      async acquireConnection() {
        const connection = await super.acquireConnection();
        this.checkVersion(connection);
        return connection;
      }
      // In Oracle, we need to check the version to dynamically determine
      // certain limits. If user did not specify a version, get it from the connection.
      checkVersion(connection) {
        if (this.version) {
          return this.version;
        }
        const detectedVersion = parseVersion(connection.oracleServerVersionString);
        if (!detectedVersion) {
          throw new Error(
            this.version === null ? "Invalid Oracledb version number format passed to knex. Unable to successfully auto-detect as fallback. Please specify a valid oracledb version." : "Unable to detect Oracledb version number automatically. Please specify the version in knex configuration."
          );
        }
        this.version = detectedVersion;
        return detectedVersion;
      }
      // Runs the query on the specified connection, providing the bindings
      // and any other necessary prep work.
      _query(connection, obj) {
        if (!obj.sql) throw new Error("The query is empty");
        const options = Object.assign({}, obj.options, { autoCommit: false });
        if (obj.method === "select") {
          options.resultSet = true;
        }
        return connection.executeAsync(obj.sql, obj.bindings, options).then(async function(response) {
          let outBinds = flatten(response.outBinds);
          obj.response = response.rows || [];
          obj.rowsAffected = response.rows ? response.rows.rowsAffected : response.rowsAffected;
          if (obj.method === "raw" && outBinds.length > 0) {
            return {
              response: outBinds
            };
          }
          if (obj.method === "update") {
            const modifiedRowsCount = obj.rowsAffected.length || obj.rowsAffected;
            const updatedObjOutBinding = [];
            const updatedOutBinds = [];
            const updateOutBinds = (i) => function(value, index) {
              const OutBindsOffset = index * modifiedRowsCount;
              updatedOutBinds.push(outBinds[i + OutBindsOffset]);
            };
            for (let i = 0; i < modifiedRowsCount; i++) {
              updatedObjOutBinding.push(obj.outBinding[0]);
              each(obj.outBinding[0], updateOutBinds(i));
            }
            outBinds = updatedOutBinds;
            obj.outBinding = updatedObjOutBinding;
          }
          if (!obj.returning && outBinds.length === 0) {
            if (!connection.isTransaction) {
              await connection.commitAsync();
            }
            return obj;
          }
          const rowIds = [];
          let offset = 0;
          for (let line = 0; line < obj.outBinding.length; line++) {
            const ret = obj.outBinding[line];
            offset = offset + (obj.outBinding[line - 1] ? obj.outBinding[line - 1].length : 0);
            for (let index = 0; index < ret.length; index++) {
              const out = ret[index];
              await new Promise(function(bindResolver, bindRejecter) {
                if (out instanceof BlobHelper) {
                  const blob = outBinds[index + offset];
                  if (out.returning) {
                    obj.response[line] = obj.response[line] || {};
                    obj.response[line][out.columnName] = out.value;
                  }
                  blob.on("error", function(err) {
                    bindRejecter(err);
                  });
                  blob.on("finish", function() {
                    bindResolver();
                  });
                  blob.write(out.value);
                  blob.end();
                } else if (obj.outBinding[line][index] === "ROWID") {
                  rowIds.push(outBinds[index + offset]);
                  bindResolver();
                } else {
                  obj.response[line] = obj.response[line] || {};
                  obj.response[line][out] = outBinds[index + offset];
                  bindResolver();
                }
              });
            }
          }
          if (obj.returningSql) {
            const response2 = await connection.executeAsync(
              obj.returningSql(),
              rowIds,
              { resultSet: true }
            );
            obj.response = response2.rows;
          }
          if (connection.isTransaction) {
            return obj;
          }
          await connection.commitAsync();
          return obj;
        });
      }
      // Process the response as returned from the query.
      processResponse(obj, runner) {
        const { response } = obj;
        if (obj.output) {
          return obj.output.call(runner, response);
        }
        switch (obj.method) {
          case "select":
            return response;
          case "first":
            return response[0];
          case "pluck":
            return map3(response, obj.pluck);
          case "insert":
          case "del":
          case "update":
          case "counter":
            if (obj.returning && !isEmpty(obj.returning) || obj.returningSql) {
              return response;
            } else if (obj.rowsAffected !== void 0) {
              return obj.rowsAffected;
            } else {
              return 1;
            }
          default:
            return response;
        }
      }
      processPassedConnection(connection) {
        this.checkVersion(connection);
        monkeyPatchConnection(connection, this);
      }
    };
    Client_Oracledb.prototype.driverName = "oracledb";
    function parseVersion(versionString) {
      try {
        const versionParts = versionString.split(".").slice(0, 2);
        versionParts.forEach((versionPart, idx) => {
          versionParts[idx] = versionPart.replace(/\D$/, "");
        });
        const version3 = versionParts.join(".");
        return version3.match(/^\d+\.?\d*$/) ? version3 : null;
      } catch (err) {
        return null;
      }
    }
    function resolveConnectString(connectionSettings) {
      if (connectionSettings.connectString) {
        return connectionSettings.connectString;
      }
      if (!connectionSettings.port) {
        return connectionSettings.host + "/" + connectionSettings.database;
      }
      return connectionSettings.host + ":" + connectionSettings.port + "/" + connectionSettings.database;
    }
    module2.exports = Client_Oracledb;
  }
});

// node_modules/knex/lib/dialects/pgnative/index.js
var require_pgnative = __commonJS({
  "node_modules/knex/lib/dialects/pgnative/index.js"(exports2, module2) {
    "use strict";
    var Client_PG = require_postgres();
    var Client_PgNative = class extends Client_PG {
      constructor(...args) {
        super(...args);
        this.driverName = "pgnative";
        this.canCancelQuery = true;
      }
      _driver() {
        return require("pg").native;
      }
      _stream(connection, obj, stream4, options) {
        if (!obj.sql) throw new Error("The query is empty");
        const client = this;
        return new Promise((resolver, rejecter) => {
          stream4.on("error", rejecter);
          stream4.on("end", resolver);
          return client._query(connection, obj).then((obj2) => obj2.response).then(({ rows }) => rows.forEach((row) => stream4.write(row))).catch(function(err) {
            stream4.emit("error", err);
          }).then(function() {
            stream4.end();
          });
        });
      }
      async cancelQuery(connectionToKill) {
        try {
          return await this._wrappedCancelQueryCall(null, connectionToKill);
        } catch (err) {
          this.logger.warn(`Connection Error: ${err}`);
          throw err;
        }
      }
      _wrappedCancelQueryCall(emptyConnection, connectionToKill) {
        return new Promise(function(resolve3, reject) {
          connectionToKill.native.cancel(function(err) {
            if (err) {
              reject(err);
              return;
            }
            resolve3(true);
          });
        });
      }
    };
    module2.exports = Client_PgNative;
  }
});

// node_modules/knex/lib/dialects/redshift/transaction.js
var require_transaction6 = __commonJS({
  "node_modules/knex/lib/dialects/redshift/transaction.js"(exports2, module2) {
    "use strict";
    var Transaction = require_transaction();
    module2.exports = class Redshift_Transaction extends Transaction {
      begin(conn) {
        const trxMode = [
          this.isolationLevel ? `ISOLATION LEVEL ${this.isolationLevel}` : "",
          this.readOnly ? "READ ONLY" : ""
        ].join(" ").trim();
        if (trxMode.length === 0) {
          return this.query(conn, "BEGIN;");
        }
        return this.query(conn, `BEGIN ${trxMode};`);
      }
      savepoint(conn) {
        this.trxClient.logger("Redshift does not support savepoints.");
        return Promise.resolve();
      }
      release(conn, value) {
        this.trxClient.logger("Redshift does not support savepoints.");
        return Promise.resolve();
      }
      rollbackTo(conn, error73) {
        this.trxClient.logger("Redshift does not support savepoints.");
        return Promise.resolve();
      }
    };
  }
});

// node_modules/knex/lib/dialects/redshift/query/redshift-querycompiler.js
var require_redshift_querycompiler = __commonJS({
  "node_modules/knex/lib/dialects/redshift/query/redshift-querycompiler.js"(exports2, module2) {
    "use strict";
    var QueryCompiler = require_querycompiler();
    var QueryCompiler_PG = require_pg_querycompiler();
    var identity2 = require_identity();
    var {
      columnize: columnize_
    } = require_wrappingFormatter();
    var QueryCompiler_Redshift = class extends QueryCompiler_PG {
      truncate() {
        return `truncate ${this.tableName.toLowerCase()}`;
      }
      // Compiles an `insert` query, allowing for multiple
      // inserts using a single query statement.
      insert() {
        const sql = QueryCompiler.prototype.insert.apply(this, arguments);
        if (sql === "") return sql;
        this._slightReturn();
        return {
          sql
        };
      }
      // Compiles an `update` query, warning on unsupported returning
      update() {
        const sql = QueryCompiler.prototype.update.apply(this, arguments);
        this._slightReturn();
        return {
          sql
        };
      }
      // Compiles an `delete` query, warning on unsupported returning
      del() {
        const sql = QueryCompiler.prototype.del.apply(this, arguments);
        this._slightReturn();
        return {
          sql
        };
      }
      // simple: if trying to return, warn
      _slightReturn() {
        if (this.single.isReturning) {
          this.client.logger.warn(
            "insert/update/delete returning is not supported by redshift dialect"
          );
        }
      }
      forUpdate() {
        this.client.logger.warn("table lock is not supported by redshift dialect");
        return "";
      }
      forShare() {
        this.client.logger.warn(
          "lock for share is not supported by redshift dialect"
        );
        return "";
      }
      forNoKeyUpdate() {
        this.client.logger.warn("table lock is not supported by redshift dialect");
        return "";
      }
      forKeyShare() {
        this.client.logger.warn(
          "lock for share is not supported by redshift dialect"
        );
        return "";
      }
      // Compiles a columnInfo query
      columnInfo() {
        const column = this.single.columnInfo;
        let schema = this.single.schema;
        const table = this.client.customWrapIdentifier(this.single.table, identity2);
        if (schema) {
          schema = this.client.customWrapIdentifier(schema, identity2);
        }
        const sql = "select * from information_schema.columns where table_name = ? and table_catalog = ?";
        const bindings = [
          table.toLowerCase(),
          this.client.database().toLowerCase()
        ];
        return this._buildColumnInfoQuery(schema, sql, bindings, column);
      }
      jsonExtract(params) {
        let extractions;
        if (Array.isArray(params.column)) {
          extractions = params.column;
        } else {
          extractions = [params];
        }
        return extractions.map((extraction) => {
          const jsonCol = `json_extract_path_text(${columnize_(
            extraction.column || extraction[0],
            this.builder,
            this.client,
            this.bindingsHolder
          )}, ${this.client.toPathForJson(
            params.path || extraction[1],
            this.builder,
            this.bindingsHolder
          )})`;
          const alias = extraction.alias || extraction[2];
          return alias ? this.client.alias(jsonCol, this.formatter.wrap(alias)) : jsonCol;
        }).join(", ");
      }
      jsonSet(params) {
        throw new Error("Json set is not supported by Redshift");
      }
      jsonInsert(params) {
        throw new Error("Json insert is not supported by Redshift");
      }
      jsonRemove(params) {
        throw new Error("Json remove is not supported by Redshift");
      }
      whereJsonPath(statement) {
        return this._whereJsonPath(
          "json_extract_path_text",
          Object.assign({}, statement, {
            path: this.client.toPathForJson(statement.path)
          })
        );
      }
      whereJsonSupersetOf(statement) {
        throw new Error("Json superset is not supported by Redshift");
      }
      whereJsonSubsetOf(statement) {
        throw new Error("Json subset is not supported by Redshift");
      }
      onJsonPathEquals(clause) {
        return this._onJsonPathEquals("json_extract_path_text", clause);
      }
    };
    module2.exports = QueryCompiler_Redshift;
  }
});

// node_modules/knex/lib/dialects/redshift/schema/redshift-columnbuilder.js
var require_redshift_columnbuilder = __commonJS({
  "node_modules/knex/lib/dialects/redshift/schema/redshift-columnbuilder.js"(exports2, module2) {
    "use strict";
    var ColumnBuilder = require_columnbuilder();
    var ColumnBuilder_Redshift = class extends ColumnBuilder {
      constructor() {
        super(...arguments);
      }
      // primary needs to set not null on non-preexisting columns, or fail
      primary() {
        this.notNullable();
        return super.primary(...arguments);
      }
      index() {
        this.client.logger.warn(
          "Redshift does not support the creation of indexes."
        );
        return this;
      }
    };
    module2.exports = ColumnBuilder_Redshift;
  }
});

// node_modules/knex/lib/dialects/redshift/schema/redshift-columncompiler.js
var require_redshift_columncompiler = __commonJS({
  "node_modules/knex/lib/dialects/redshift/schema/redshift-columncompiler.js"(exports2, module2) {
    "use strict";
    var ColumnCompiler_PG = require_pg_columncompiler();
    var ColumnCompiler = require_columncompiler();
    var ColumnCompiler_Redshift = class extends ColumnCompiler_PG {
      constructor() {
        super(...arguments);
      }
      // Types:
      // ------
      bit(column) {
        return column.length !== false ? `char(${column.length})` : "char(1)";
      }
      datetime(without) {
        return without ? "timestamp" : "timestamptz";
      }
      timestamp(without) {
        return without ? "timestamp" : "timestamptz";
      }
      // Modifiers:
      // ------
      comment(comment) {
        this.pushAdditional(function() {
          this.pushQuery(
            `comment on column ${this.tableCompiler.tableName()}.` + this.formatter.wrap(this.args[0]) + " is " + (comment ? `'${comment}'` : "NULL")
          );
        }, comment);
      }
    };
    ColumnCompiler_Redshift.prototype.increments = ({ primaryKey = true } = {}) => "integer identity(1,1)" + (primaryKey ? " primary key" : "") + " not null";
    ColumnCompiler_Redshift.prototype.bigincrements = ({
      primaryKey = true
    } = {}) => "bigint identity(1,1)" + (primaryKey ? " primary key" : "") + " not null";
    ColumnCompiler_Redshift.prototype.binary = "varchar(max)";
    ColumnCompiler_Redshift.prototype.blob = "varchar(max)";
    ColumnCompiler_Redshift.prototype.enu = "varchar(255)";
    ColumnCompiler_Redshift.prototype.enum = "varchar(255)";
    ColumnCompiler_Redshift.prototype.json = "varchar(max)";
    ColumnCompiler_Redshift.prototype.jsonb = "varchar(max)";
    ColumnCompiler_Redshift.prototype.longblob = "varchar(max)";
    ColumnCompiler_Redshift.prototype.mediumblob = "varchar(16777218)";
    ColumnCompiler_Redshift.prototype.set = "text";
    ColumnCompiler_Redshift.prototype.text = "varchar(max)";
    ColumnCompiler_Redshift.prototype.tinyblob = "varchar(256)";
    ColumnCompiler_Redshift.prototype.uuid = ColumnCompiler.prototype.uuid;
    ColumnCompiler_Redshift.prototype.varbinary = "varchar(max)";
    ColumnCompiler_Redshift.prototype.bigint = "bigint";
    ColumnCompiler_Redshift.prototype.bool = "boolean";
    ColumnCompiler_Redshift.prototype.double = "double precision";
    ColumnCompiler_Redshift.prototype.floating = "real";
    ColumnCompiler_Redshift.prototype.smallint = "smallint";
    ColumnCompiler_Redshift.prototype.tinyint = "smallint";
    module2.exports = ColumnCompiler_Redshift;
  }
});

// node_modules/knex/lib/dialects/redshift/schema/redshift-tablecompiler.js
var require_redshift_tablecompiler = __commonJS({
  "node_modules/knex/lib/dialects/redshift/schema/redshift-tablecompiler.js"(exports2, module2) {
    "use strict";
    var has = require_has();
    var TableCompiler_PG = require_pg_tablecompiler();
    var TableCompiler_Redshift = class extends TableCompiler_PG {
      constructor() {
        super(...arguments);
      }
      index(columns, indexName, options) {
        this.client.logger.warn(
          "Redshift does not support the creation of indexes."
        );
      }
      dropIndex(columns, indexName) {
        this.client.logger.warn(
          "Redshift does not support the deletion of indexes."
        );
      }
      dropPrimaryIfExists() {
        throw new Error(".dropPrimaryIfExists() is not supported by redshift");
      }
      dropForeignIfExists() {
        throw new Error(".dropForeignIfExists() is not supported by redshift");
      }
      dropUniqueIfExists() {
        throw new Error(".dropUniqueIfExists() is not supported by redshift");
      }
      // TODO: have to disable setting not null on columns that already exist...
      // Adds the "create" query to the query sequence.
      createQuery(columns, ifNot, like) {
        const createStatement = ifNot ? "create table if not exists " : "create table ";
        const columnsSql = " (" + columns.sql.join(", ") + this._addChecks() + ")";
        let sql = createStatement + this.tableName() + (like && this.tableNameLike() ? " (like " + this.tableNameLike() + ")" : columnsSql);
        if (this.single.inherits)
          sql += ` like (${this.formatter.wrap(this.single.inherits)})`;
        this.pushQuery({
          sql,
          bindings: columns.bindings
        });
        const hasComment = has(this.single, "comment");
        if (hasComment) this.comment(this.single.comment);
        if (like) {
          this.addColumns(columns, this.addColumnsPrefix);
        }
      }
      primary(columns, constraintName) {
        const self2 = this;
        constraintName = constraintName ? self2.formatter.wrap(constraintName) : self2.formatter.wrap(`${this.tableNameRaw}_pkey`);
        if (columns.constructor !== Array) {
          columns = [columns];
        }
        const thiscolumns = self2.grouped.columns;
        if (thiscolumns) {
          for (let i = 0; i < columns.length; i++) {
            let exists = thiscolumns.find(
              (tcb) => tcb.grouping === "columns" && tcb.builder && tcb.builder._method === "add" && tcb.builder._args && tcb.builder._args.indexOf(columns[i]) > -1
            );
            if (exists) {
              exists = exists.builder;
            }
            const nullable3 = !(exists && exists._modifiers && exists._modifiers["nullable"] && exists._modifiers["nullable"][0] === false);
            if (nullable3) {
              if (exists) {
                return this.client.logger.warn(
                  "Redshift does not allow primary keys to contain nullable columns."
                );
              } else {
                return this.client.logger.warn(
                  "Redshift does not allow primary keys to contain nonexistent columns."
                );
              }
            }
          }
        }
        return self2.pushQuery(
          `alter table ${self2.tableName()} add constraint ${constraintName} primary key (${self2.formatter.columnize(
            columns
          )})`
        );
      }
      // Compiles column add. Redshift can only add one column per ALTER TABLE, so core addColumns doesn't work.  #2545
      addColumns(columns, prefix, colCompilers) {
        if (prefix === this.alterColumnsPrefix) {
          super.addColumns(columns, prefix, colCompilers);
        } else {
          prefix = prefix || this.addColumnsPrefix;
          colCompilers = colCompilers || this.getColumns();
          for (const col of colCompilers) {
            const quotedTableName = this.tableName();
            const colCompiled = col.compileColumn();
            this.pushQuery({
              sql: `alter table ${quotedTableName} ${prefix}${colCompiled}`,
              bindings: []
            });
          }
        }
      }
    };
    module2.exports = TableCompiler_Redshift;
  }
});

// node_modules/knex/lib/dialects/redshift/schema/redshift-compiler.js
var require_redshift_compiler = __commonJS({
  "node_modules/knex/lib/dialects/redshift/schema/redshift-compiler.js"(exports2, module2) {
    "use strict";
    var SchemaCompiler_PG = require_pg_compiler();
    var SchemaCompiler_Redshift = class extends SchemaCompiler_PG {
      constructor() {
        super(...arguments);
      }
    };
    module2.exports = SchemaCompiler_Redshift;
  }
});

// node_modules/knex/lib/dialects/redshift/schema/redshift-viewcompiler.js
var require_redshift_viewcompiler = __commonJS({
  "node_modules/knex/lib/dialects/redshift/schema/redshift-viewcompiler.js"(exports2, module2) {
    "use strict";
    var ViewCompiler_PG = require_pg_viewcompiler();
    var ViewCompiler_Redshift = class extends ViewCompiler_PG {
      constructor(client, viewCompiler) {
        super(client, viewCompiler);
      }
    };
    module2.exports = ViewCompiler_Redshift;
  }
});

// node_modules/knex/lib/dialects/redshift/index.js
var require_redshift = __commonJS({
  "node_modules/knex/lib/dialects/redshift/index.js"(exports2, module2) {
    "use strict";
    var Client_PG = require_postgres();
    var map3 = require_map();
    var Transaction = require_transaction6();
    var QueryCompiler = require_redshift_querycompiler();
    var ColumnBuilder = require_redshift_columnbuilder();
    var ColumnCompiler = require_redshift_columncompiler();
    var TableCompiler = require_redshift_tablecompiler();
    var SchemaCompiler = require_redshift_compiler();
    var ViewCompiler = require_redshift_viewcompiler();
    var Client_Redshift = class extends Client_PG {
      transaction() {
        return new Transaction(this, ...arguments);
      }
      queryCompiler(builder, formatter) {
        return new QueryCompiler(this, builder, formatter);
      }
      columnBuilder() {
        return new ColumnBuilder(this, ...arguments);
      }
      columnCompiler() {
        return new ColumnCompiler(this, ...arguments);
      }
      tableCompiler() {
        return new TableCompiler(this, ...arguments);
      }
      schemaCompiler() {
        return new SchemaCompiler(this, ...arguments);
      }
      viewCompiler() {
        return new ViewCompiler(this, ...arguments);
      }
      _driver() {
        return require("pg");
      }
      // Ensures the response is returned in the same format as other clients.
      processResponse(obj, runner) {
        const resp = obj.response;
        if (obj.output) return obj.output.call(runner, resp);
        if (obj.method === "raw") return resp;
        if (resp.command === "SELECT") {
          if (obj.method === "first") return resp.rows[0];
          if (obj.method === "pluck") return map3(resp.rows, obj.pluck);
          return resp.rows;
        }
        if (resp.command === "INSERT" || resp.command === "UPDATE" || resp.command === "DELETE") {
          return resp.rowCount;
        }
        return resp;
      }
      toPathForJson(jsonPath, builder, bindingsHolder) {
        return jsonPath.replace(/^(\$\.)/, "").split(".").map(
          function(v) {
            return this.parameter(v, builder, bindingsHolder);
          }.bind(this)
        ).join(", ");
      }
    };
    Object.assign(Client_Redshift.prototype, {
      dialect: "redshift",
      driverName: "pg-redshift"
    });
    module2.exports = Client_Redshift;
  }
});

// node_modules/knex/lib/dialects/index.js
var require_dialects = __commonJS({
  "node_modules/knex/lib/dialects/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getDialectByNameOrAlias = void 0;
    var { resolveClientNameWithAliases } = require_helpers();
    var dbNameToDialectLoader = Object.freeze({
      "better-sqlite3": () => require_better_sqlite3(),
      cockroachdb: () => require_cockroachdb(),
      mssql: () => require_mssql(),
      mysql: () => require_mysql(),
      mysql2: () => require_mysql2(),
      oracle: () => require_oracle(),
      oracledb: () => require_oracledb(),
      pgnative: () => require_pgnative(),
      postgres: () => require_postgres(),
      redshift: () => require_redshift(),
      sqlite3: () => require_sqlite3()
    });
    function getDialectByNameOrAlias(clientName) {
      const resolvedClientName = resolveClientNameWithAliases(clientName);
      const dialectLoader = dbNameToDialectLoader[resolvedClientName];
      if (!dialectLoader) {
        throw new Error(`Invalid clientName given: ${clientName}`);
      }
      return dialectLoader();
    }
    exports2.getDialectByNameOrAlias = getDialectByNameOrAlias;
  }
});

// node_modules/knex/lib/knex-builder/internal/config-resolver.js
var require_config_resolver = __commonJS({
  "node_modules/knex/lib/knex-builder/internal/config-resolver.js"(exports2, module2) {
    "use strict";
    var Client2 = require_client2();
    var { SUPPORTED_CLIENTS } = require_constants6();
    var parseConnection = require_parse_connection();
    var { getDialectByNameOrAlias } = require_dialects();
    function resolveConfig(config3) {
      let Dialect;
      let resolvedConfig;
      const parsedConfig = typeof config3 === "string" ? Object.assign(parseConnection(config3), arguments[2]) : config3;
      if (arguments.length === 0 || !parsedConfig.client && !parsedConfig.dialect) {
        Dialect = Client2;
      } else if (typeof parsedConfig.client === "function") {
        Dialect = parsedConfig.client;
      } else {
        const clientName = parsedConfig.client || parsedConfig.dialect;
        if (!SUPPORTED_CLIENTS.includes(clientName)) {
          throw new Error(
            `knex: Unknown configuration option 'client' value ${clientName}. Note that it is case-sensitive, check documentation for supported values.`
          );
        }
        Dialect = getDialectByNameOrAlias(clientName);
      }
      if (typeof parsedConfig.connection === "string") {
        resolvedConfig = Object.assign({}, parsedConfig, {
          connection: parseConnection(parsedConfig.connection).connection
        });
      } else {
        resolvedConfig = Object.assign({}, parsedConfig);
      }
      return {
        resolvedConfig,
        Dialect
      };
    }
    module2.exports = {
      resolveConfig
    };
  }
});

// node_modules/knex/lib/knex-builder/Knex.js
var require_Knex = __commonJS({
  "node_modules/knex/lib/knex-builder/Knex.js"(exports2, module2) {
    "use strict";
    var Client2 = require_client2();
    var QueryBuilder = require_querybuilder();
    var QueryInterface = require_method_constants();
    var makeKnex = require_make_knex();
    var { KnexTimeoutError } = require_timeout();
    var { resolveConfig } = require_config_resolver();
    var SchemaBuilder = require_builder();
    var ViewBuilder = require_viewbuilder();
    var ColumnBuilder = require_columnbuilder();
    var TableBuilder = require_tablebuilder();
    function knex3(config3) {
      const { resolvedConfig, Dialect } = resolveConfig(...arguments);
      const newKnex = makeKnex(new Dialect(resolvedConfig));
      if (resolvedConfig.userParams) {
        newKnex.userParams = resolvedConfig.userParams;
      }
      return newKnex;
    }
    knex3.Client = Client2;
    knex3.KnexTimeoutError = KnexTimeoutError;
    knex3.QueryBuilder = {
      extend: function(methodName, fn) {
        QueryBuilder.extend(methodName, fn);
        QueryInterface.push(methodName);
      }
    };
    knex3.SchemaBuilder = {
      extend: function(methodName, fn) {
        SchemaBuilder.extend(methodName, fn);
      }
    };
    knex3.ViewBuilder = {
      extend: function(methodName, fn) {
        ViewBuilder.extend(methodName, fn);
      }
    };
    knex3.ColumnBuilder = {
      extend: function(methodName, fn) {
        ColumnBuilder.extend(methodName, fn);
      }
    };
    knex3.TableBuilder = {
      extend: function(methodName, fn) {
        TableBuilder.extend(methodName, fn);
      }
    };
    module2.exports = knex3;
  }
});

// node_modules/knex/lib/index.js
var require_lib5 = __commonJS({
  "node_modules/knex/lib/index.js"(exports2, module2) {
    "use strict";
    var Knex = require_Knex();
    module2.exports = Knex;
  }
});

// node_modules/knex/knex.js
var require_knex = __commonJS({
  "node_modules/knex/knex.js"(exports2, module2) {
    "use strict";
    var knex3 = require_lib5();
    knex3.knex = knex3;
    knex3.default = knex3;
    module2.exports = knex3;
  }
});

// node_modules/uuid/dist-node/stringify.js
function unsafeStringify(arr, offset = 0) {
  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
}
var byteToHex;
var init_stringify = __esm({
  "node_modules/uuid/dist-node/stringify.js"() {
    "use strict";
    byteToHex = [];
    for (let i = 0; i < 256; ++i) {
      byteToHex.push((i + 256).toString(16).slice(1));
    }
  }
});

// node_modules/uuid/dist-node/rng.js
function rng() {
  if (poolPtr > rnds8Pool.length - 16) {
    (0, import_node_crypto.randomFillSync)(rnds8Pool);
    poolPtr = 0;
  }
  return rnds8Pool.slice(poolPtr, poolPtr += 16);
}
var import_node_crypto, rnds8Pool, poolPtr;
var init_rng = __esm({
  "node_modules/uuid/dist-node/rng.js"() {
    "use strict";
    import_node_crypto = require("node:crypto");
    rnds8Pool = new Uint8Array(256);
    poolPtr = rnds8Pool.length;
  }
});

// node_modules/uuid/dist-node/native.js
var import_node_crypto2, native_default;
var init_native = __esm({
  "node_modules/uuid/dist-node/native.js"() {
    "use strict";
    import_node_crypto2 = require("node:crypto");
    native_default = { randomUUID: import_node_crypto2.randomUUID };
  }
});

// node_modules/uuid/dist-node/v4.js
function _v4(options, buf, offset) {
  options = options || {};
  const rnds = options.random ?? options.rng?.() ?? rng();
  if (rnds.length < 16) {
    throw new Error("Random bytes length must be >= 16");
  }
  rnds[6] = rnds[6] & 15 | 64;
  rnds[8] = rnds[8] & 63 | 128;
  if (buf) {
    offset = offset || 0;
    if (offset < 0 || offset + 16 > buf.length) {
      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
    }
    for (let i = 0; i < 16; ++i) {
      buf[offset + i] = rnds[i];
    }
    return buf;
  }
  return unsafeStringify(rnds);
}
function v4(options, buf, offset) {
  if (native_default.randomUUID && !buf && !options) {
    return native_default.randomUUID();
  }
  return _v4(options, buf, offset);
}
var v4_default;
var init_v4 = __esm({
  "node_modules/uuid/dist-node/v4.js"() {
    "use strict";
    init_native();
    init_rng();
    init_stringify();
    v4_default = v4;
  }
});

// node_modules/uuid/dist-node/index.js
var init_dist_node = __esm({
  "node_modules/uuid/dist-node/index.js"() {
    "use strict";
    init_v4();
  }
});

// src/utils/agent/embedding.ts
async function initEmbedding() {
  if (extractor) return;
  const modelConfigData = await db_default("o_setting").whereIn("key", ["modelOnnxFile", "modelDtype"]);
  const modelObj = {};
  Object.entries(modelConfigData).forEach(([key, value]) => {
    modelObj[key] = value;
  });
  let modelOnnxFile = modelObj?.modelOnnxFile ? JSON.parse(modelObj.modelOnnxFile) : ["all-MiniLM-L6-v2", "onnx", "model_fp16.onnx"];
  let modelDtype = modelObj?.modelDtype ?? "fp16";
  const onnxPath = import_path3.default.join(getPath_default("models"), ...modelOnnxFile);
  if (!import_fs.default.existsSync(onnxPath)) {
    throw new Error(`Embedding \u6A21\u578B\u6587\u4EF6\u4E0D\u5B58\u5728: ${onnxPath}`);
  }
  import_transformers.env.allowRemoteModels = false;
  import_transformers.env.allowLocalModels = true;
  import_transformers.env.localModelPath = getPath_default("models").replace(/\\/g, "/") + "/";
  const modelFolder = modelOnnxFile[0];
  extractor = await (0, import_transformers.pipeline)("feature-extraction", modelFolder, { dtype: modelDtype });
}
async function getEmbedding(text2) {
  if (!extractor) await initEmbedding();
  const output = await extractor(text2, { pooling: "mean", normalize: true });
  return Array.from(output.data);
}
function cosineSimilarity(a, b) {
  return a.reduce((dot, v, i) => dot + v * b[i], 0);
}
var import_transformers, import_path3, import_fs, extractor;
var init_embedding = __esm({
  "src/utils/agent/embedding.ts"() {
    "use strict";
    import_transformers = require("@huggingface/transformers");
    import_path3 = __toESM(require("path"));
    import_fs = __toESM(require("fs"));
    init_getPath();
    init_db();
    extractor = null;
  }
});

// src/lib/initDB.ts
var initDB_default;
var init_initDB = __esm({
  "src/lib/initDB.ts"() {
    "use strict";
    init_dist_node();
    init_embedding();
    initDB_default = async (knex3, forceInit = false) => {
      const tables = [
        // 用户表
        {
          name: "o_user",
          builder: (table) => {
            table.integer("id").notNullable();
            table.text("name");
            table.text("phone");
            table.text("password");
            table.primary(["id"]);
            table.unique(["id"]);
            table.unique(["name"]);
            table.unique(["phone"]);
          },
          initData: async (knex4) => {
            await knex4("o_user").insert([{ id: 1, name: "admin", password: "admin123" }]);
          }
        },
        // 短信验证码表
        {
          name: "o_smsCode",
          builder: (table) => {
            table.integer("id").notNullable();
            table.text("phone").notNullable();
            table.text("purpose").notNullable();
            table.text("codeHash").notNullable();
            table.integer("expiresAt").notNullable();
            table.integer("used").defaultTo(0);
            table.integer("attempts").defaultTo(0);
            table.integer("createTime").notNullable();
            table.integer("sentAt").notNullable();
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        // 用户级配置表：平台配置作为模板，敏感值与个人偏好写入用户表
        {
          name: "o_userVendorConfig",
          builder: (table) => {
            table.integer("userId").notNullable();
            table.string("vendorId").notNullable();
            table.text("inputValues");
            table.text("models");
            table.integer("enable");
            table.primary(["userId", "vendorId"]);
          }
        },
        {
          name: "o_userAgentDeploy",
          builder: (table) => {
            table.integer("userId").notNullable();
            table.string("key").notNullable();
            table.string("model");
            table.string("modelName");
            table.text("vendorId");
            table.integer("temperature");
            table.integer("maxOutputTokens");
            table.boolean("disabled").defaultTo(false);
            table.primary(["userId", "key"]);
          }
        },
        {
          name: "o_userSetting",
          builder: (table) => {
            table.integer("userId").notNullable();
            table.string("key").notNullable();
            table.text("value");
            table.primary(["userId", "key"]);
          }
        },
        {
          name: "o_userPrompt",
          builder: (table) => {
            table.integer("userId").notNullable();
            table.integer("promptId").notNullable();
            table.text("useData");
            table.primary(["userId", "promptId"]);
          }
        },
        {
          name: "o_userModelPrompt",
          builder: (table) => {
            table.integer("userId").notNullable();
            table.text("vendorId").notNullable();
            table.text("model").notNullable();
            table.string("fileName");
            table.text("path");
            table.primary(["userId", "vendorId", "model"]);
          }
        },
        //项目表
        {
          name: "o_project",
          builder: (table) => {
            table.integer("id");
            table.string("projectType");
            table.string("imageModel");
            table.string("imageQuality");
            table.string("videoModel");
            table.text("name");
            table.text("intro");
            table.text("type");
            table.text("artStyle");
            table.text("directorManual");
            table.text("mode");
            table.text("videoRatio");
            table.integer("createTime");
            table.integer("userId");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        //风格表
        {
          name: "o_artStyle",
          builder: (table) => {
            table.integer("id").notNullable();
            table.string("name");
            table.text("fileUrl");
            table.text("label");
            table.text("prompt");
            table.primary(["id"]);
            table.unique(["id"]);
          },
          initData: async (knex4) => {
          }
        },
        //Agent配置表
        {
          name: "o_agentDeploy",
          builder: (table) => {
            table.integer("id").notNullable();
            table.string("model");
            table.string("key");
            table.string("modelName");
            table.text("vendorId");
            table.string("desc");
            table.string("name");
            table.integer("temperature");
            table.integer("maxOutputTokens");
            table.boolean("disabled").defaultTo(false);
            table.primary(["id"]);
            table.unique(["id"]);
          },
          initData: async (knex4) => {
            await knex4("o_agentDeploy").insert([
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "scriptAgent",
                name: "\u5267\u672CAgent",
                desc: "\u7528\u4E8E\u8BFB\u53D6\u539F\u6587\u751F\u6210\u6545\u4E8B\u9AA8\u67B6\u3001\u6539\u7F16\u7B56\u7565\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u5177\u5907\u5F3A\u5927\u6587\u672C\u7406\u89E3\u548C\u751F\u6210\u80FD\u529B\u7684\u6A21\u578B",
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "productionAgent",
                name: "\u751F\u4EA7Agent",
                desc: "\u5BF9\u5DE5\u4F5C\u6D41\u8FDB\u884C\u8C03\u5EA6\u548C\u7BA1\u7406\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u5177\u5907\u8F83\u5F3A\u7684\u903B\u8F91\u63A8\u7406\u548C\u4EFB\u52A1\u7BA1\u7406\u80FD\u529B\u7684\u6A21\u578B",
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "universalAi",
                name: "\u901A\u7528AI",
                desc: "\u7528\u4E8E\u5C0F\u8BF4\u4E8B\u4EF6\u63D0\u53D6\u3001\u8D44\u4EA7\u63D0\u793A\u8BCD\u751F\u6210\u3001\u53F0\u8BCD\u63D0\u53D6\u7B49\u8FB9\u7F18\u529F\u80FD\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u5177\u5907\u8F83\u5F3A\u6587\u672C\u5904\u7406\u80FD\u529B\u7684\u6A21\u578B",
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "ttsDubbing",
                name: "TTS\u914D\u97F3",
                desc: "\u6839\u636E\u5267\u672C\u5185\u5BB9\u751F\u6210\u89D2\u8272\u914D\u97F3\uFF0C\u652F\u6301\u591A\u79CD\u58F0\u97F3\u98CE\u683C\u548C\u60C5\u7EEA",
                disabled: true
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "scriptAgent:decisionAgent",
                name: "\u5267\u672CAgent:\u51B3\u7B56\u5C42",
                desc: "\u51B3\u7B56\u5C42",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "scriptAgent:supervisionAgent",
                name: "\u5267\u672CAgent:\u76D1\u7763\u5C42",
                desc: "\u76D1\u7763\u5C42",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "scriptAgent:storySkeletonAgent",
                name: "\u5267\u672CAgent:\u6545\u4E8B\u9AA8\u67B6",
                desc: "\u6545\u4E8B\u9AA8\u67B6\u751F\u6210",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "scriptAgent:adaptationStrategyAgent",
                name: "\u5267\u672CAgent:\u6539\u7F16\u7B56\u7565",
                desc: "\u6539\u7F16\u7B56\u7565\u751F\u6210",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "scriptAgent:scriptAgent",
                name: "\u5267\u672CAgent:\u5267\u672C\u751F\u6210",
                desc: "\u5267\u672C\u751F\u6210",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "productionAgent:decisionAgent",
                name: "\u751F\u4EA7Agent:\u51B3\u7B56\u5C42",
                desc: "\u51B3\u7B56\u5C42",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "productionAgent:supervisionAgent",
                name: "\u751F\u4EA7Agent:\u76D1\u7763\u5C42",
                desc: "\u76D1\u7763\u5C42",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "productionAgent:deriveAssetsAgent",
                name: "\u751F\u4EA7Agent:\u884D\u751F\u8D44\u4EA7",
                desc: "\u884D\u751F\u8D44\u4EA7",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "productionAgent:generateAssetsAgent",
                name: "\u751F\u4EA7Agent:\u751F\u6210\u8D44\u4EA7",
                desc: "\u751F\u6210\u8D44\u4EA7",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "productionAgent:directorPlanAgent",
                name: "\u751F\u4EA7Agent:\u5BFC\u6F14\u89C4\u5212",
                desc: "\u5BFC\u6F14\u89C4\u5212",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "productionAgent:storyboardGenAgent",
                name: "\u751F\u4EA7Agent:\u5206\u955C\u751F\u6210",
                desc: "\u5206\u955C\u751F\u6210",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "productionAgent:storyboardPanelAgent",
                name: "\u751F\u4EA7Agent:\u5206\u955C\u9762\u677F",
                desc: "\u5206\u955C\u9762\u677F\u751F\u6210",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              },
              {
                model: "",
                modelName: "",
                vendorId: null,
                key: "productionAgent:storyboardTableAgent",
                name: "\u751F\u4EA7Agent:\u5206\u955C\u8868\u683C",
                desc: "\u5206\u955C\u8868\u683C\u751F\u6210",
                temperature: 1,
                maxOutputTokens: 0,
                disabled: false
              }
            ]);
          }
        },
        //设置表
        {
          name: "o_setting",
          builder: (table) => {
            table.text("key");
            table.text("value");
            table.primary(["key"]);
            table.unique(["key"]);
          },
          initData: async (knex4) => {
            await knex4("o_setting").insert([
              {
                key: "tokenKey",
                value: v4_default().slice(0, 8)
              },
              {
                key: "messagesPerSummary",
                value: 10
              },
              {
                key: "shortTermLimit",
                value: 5
              },
              {
                key: "summaryMaxLength",
                value: 500
              },
              {
                key: "summaryLimit",
                value: 10
              },
              {
                key: "ragLimit",
                value: 3
              },
              {
                key: "deepRetrieveSummaryLimit",
                value: 5
              },
              {
                key: "modelOnnxFile",
                value: '["all-MiniLM-L6-v2", "onnx", "model_fp16.onnx"]'
              },
              {
                key: "modelDtype",
                value: "fp16"
              },
              {
                key: "switchAiDevTool",
                value: "0"
              }
            ]);
          }
        },
        //任务中心表
        {
          name: "o_tasks",
          builder: (table) => {
            table.integer("id").notNullable();
            table.integer("projectId");
            table.string("taskClass");
            table.string("relatedObjects");
            table.string("model");
            table.text("describe");
            table.string("state");
            table.integer("startTime");
            table.text("reason");
            table.primary(["id"]);
            table.unique(["id"]);
          },
          initData: async (knex4) => {
          }
        },
        //提示词表
        {
          name: "o_prompt",
          builder: (table) => {
            table.integer("id").notNullable();
            table.string("name");
            table.string("type");
            table.text("data");
            table.text("useData");
            table.primary(["id"]);
            table.unique(["id"]);
          },
          initData: async (knex4) => {
            await knex4("o_prompt").insert([
              {
                name: "\u4E8B\u4EF6\u63D0\u53D6",
                type: "eventExtraction",
                data: `# \u4E8B\u4EF6\u63D0\u53D6\u6307\u4EE4

\u4F60\u662F\u5C0F\u8BF4\u6587\u672C\u5206\u6790\u52A9\u624B\u3002\u7528\u6237\u6BCF\u6B21\u63D0\u4F9B\u4E00\u4E2A\u7AE0\u8282\u7684\u539F\u6587\uFF0C\u4F60\u63D0\u53D6\u8BE5\u7AE0\u7684\u7ED3\u6784\u5316\u4E8B\u4EF6\u4FE1\u606F\u3002

## \u26A0\uFE0F \u8F93\u51FA\u7EA6\u675F\uFF08\u6700\u9AD8\u4F18\u5148\u7EA7\uFF0C\u8FDD\u53CD\u4EFB\u4F55\u4E00\u6761\u5373\u4E3A\u5931\u8D25\uFF09

1. \u4F60\u7684**\u5B8C\u6574\u56DE\u590D**\u53EA\u6709\u4E00\u884C\uFF0C\u4EE5 \`|\` \u5F00\u5934\u3001\u4EE5 \`|\` \u7ED3\u5C3E\uFF0C\u6070\u597D 7 \u4E2A\u5B57\u6BB5
2. \u56DE\u590D\u7684**\u7B2C\u4E00\u4E2A\u5B57\u7B26**\u5FC5\u987B\u662F \`|\`\uFF0C**\u6700\u540E\u4E00\u4E2A\u5B57\u7B26**\u5FC5\u987B\u662F \`|\`
3. \`|\` \u4E4B\u524D\u4E0D\u8BB8\u6709\u4EFB\u4F55\u5B57\u7B26\u2014\u2014\u6CA1\u6709\u5F15\u5BFC\u8BED\u3001\u6CA1\u6709\u89E3\u91CA\u3001\u6CA1\u6709"\u6839\u636E\u2026\u2026"\u3001\u6CA1\u6709"\u4EE5\u4E0B\u662F\u2026\u2026"
4. \`|\` \u4E4B\u540E\u4E0D\u8BB8\u6709\u4EFB\u4F55\u5B57\u7B26\u2014\u2014\u6CA1\u6709\u603B\u7ED3\u3001\u6CA1\u6709\u63D0\u53D6\u8BF4\u660E\u3001\u6CA1\u6709\u6539\u7F16\u5EFA\u8BAE
5. \u4E0D\u8F93\u51FA\u8868\u5934\u884C\u3001\u5206\u9694\u7EBF\u3001Markdown \u6807\u9898\u3001emoji\u3001\u4EE3\u7801\u5757\u6807\u8BB0

## \u8F93\u51FA\u683C\u5F0F

\`\`\`
| \u7B2CX\u7AE0 {\u7AE0\u8282\u6807\u9898} | {\u6D89\u53CA\u89D2\u8272} | {\u6838\u5FC3\u4E8B\u4EF6} | {\u4E3B\u7EBF\u5173\u7CFB} | {\u4FE1\u606F\u5BC6\u5EA6} | {\u9884\u4F30\u96C6\u957F} | {\u60C5\u7EEA\u5F3A\u5EA6} |
\`\`\`

### \u5B57\u6BB5\u89C4\u8303

| \u5B57\u6BB5 | \u683C\u5F0F\u8981\u6C42 | \u793A\u4F8B |
|------|----------|------|
| \u7AE0\u8282 | \`\u7B2CX\u7AE0 {\u7AE0\u8282\u6807\u9898}\` | \`\u7B2C1\u7AE0 \u804C\u4E1A\u5371\u673A\u4E0E\u8BB8\u613F\` |
| \u6D89\u53CA\u89D2\u8272 | \u6709\u5B9E\u9645\u620F\u4EFD\u7684\u89D2\u8272\uFF0C\u987F\u53F7\u5206\u9694 | \`\u6797\u9038\u3001\u767D\u6709\u5BB9\` |
| \u6838\u5FC3\u4E8B\u4EF6 | 30-60\u5B57\uFF0C\u5FC5\u987B\u542B\u52A8\u4F5C+\u7ED3\u679C | \`\u6797\u9038\u56E0\u89E3\u5BC6\u98CE\u6F6E\u4E8B\u4E1A\u5D29\u584C\uFF0C\u9893\u5E9F\u4E2D\u8BB8\u613F\u89E6\u53D1\u9B54\u6CD5\u7CFB\u7EDF\u7ED1\u5B9A\` |
| \u4E3B\u7EBF\u5173\u7CFB | **\u5FC5\u987B**\u4E3A \`\u5F3A/\u4E2D/\u5F31\uFF083-8\u5B57\u7406\u7531\uFF09\` | \`\u5F3A\uFF08\u52A8\u673A\u5EFA\u7ACB+\u7CFB\u7EDF\u6FC0\u6D3B\uFF09\` |
| \u4FE1\u606F\u5BC6\u5EA6 | \`\u9AD8\` / \`\u4E2D\` / \`\u4F4E\` | \`\u9AD8\` |
| \u9884\u4F30\u96C6\u957F | **\u5FC5\u987B**\u4E3A \`X\u79D2\`\uFF0C\u7981\u6B62\u7528\u5206\u949F | \`50\u79D2\` |
| \u60C5\u7EEA\u5F3A\u5EA6 | \u6587\u5B57\u6807\u7B7E\uFF0C\`+\` \u8FDE\u63A5\uFF0C\u7981\u6B62\u661F\u7EA7/\u6570\u5B57 | \`\u8F6C\u6298+\u60AC\u7591\` |

**\u4E3B\u7EBF\u5173\u7CFB\u5224\u5B9A**\uFF1A\u5F3A\uFF1D\u76F4\u63A5\u63A8\u52A8\u4E3B\u89D2\u5F27\u7EBF\uFF1B\u4E2D\uFF1D\u8865\u5145\u4E16\u754C\u89C2/\u4EBA\u7269\u5173\u7CFB/\u4F0F\u7B14\uFF1B\u5F31\uFF1D\u8FC7\u6E21/\u6C14\u6C1B\u3002

**\u9884\u4F30\u96C6\u957F\u53C2\u8003**\uFF1A\u9AD8\u5BC6\u5EA6+\u9AD8\u60C5\u7EEA\u219245-60\u79D2\uFF1B\u4E2D\u219235-45\u79D2\uFF1B\u4F4E\u219225-35\u79D2\u3002

**\u53EF\u7528\u60C5\u7EEA\u6807\u7B7E**\uFF1A\`\u51B2\u7A81\`\u3001\`\u6050\u6016\`\u3001\`\u60C5\u611F\`\u3001\`\u8F6C\u6298\`\u3001\`\u9AD8\u6F6E\`\u3001\`\u5E73\u94FA\`\u3001\`\u559C\u5267\`\u3001\`\u60AC\u7591\`\u3001\`\u60C5\u611F\u5D29\u6E83\`\u3002

## \u8F93\u51FA\u793A\u4F8B

\u4EE5\u4E0B\u4E24\u4E2A\u793A\u4F8B\u5C55\u793A\u7684\u662F**\u5B8C\u6574\u56DE\u590D**\u2014\u2014\u9664\u8FD9\u4E00\u884C\u5916\u6CA1\u6709\u4EFB\u4F55\u5176\u4ED6\u5185\u5BB9\uFF1A

\`\`\`
| \u7B2C1\u7AE0 \u804C\u4E1A\u5371\u673A\u4E0E\u8BB8\u613F | \u6797\u9038 | \u804C\u4E1A\u9B54\u672F\u5E08\u6797\u9038\u56E0\u89E3\u5BC6\u6253\u5047\u98CE\u6F6E\u5BFC\u81F4\u4E8B\u4E1A\u5D29\u584C\uFF0C\u9893\u5E9F\u4E2D\u611F\u6168"\u5982\u679C\u4F1A\u9B54\u6CD5\u5C31\u597D\u4E86"\uFF0C\u610F\u5916\u89E6\u53D1\u795E\u5947\u9B54\u6CD5\u7CFB\u7EDF\u7ED1\u5B9A | \u5F3A\uFF08\u4E3B\u89D2\u52A8\u673A\u5EFA\u7ACB+\u7CFB\u7EDF\u6FC0\u6D3B\uFF09 | \u9AD8 | 50\u79D2 | \u8F6C\u6298+\u60AC\u7591 |
\`\`\`
\`\`\`
| \u7B2C12\u7AE0 \u5C71\u95F4\u5C0F\u61A9 | \u51CC\u7384\u3001\u82CF\u665A\u537F | \u51CC\u7384\u4E0E\u82CF\u665A\u537F\u5728\u5C71\u95F4\u6B47\u811A\uFF0C\u82CF\u665A\u537F\u56DE\u5FC6\u5E7C\u65F6\u5F80\u4E8B\uFF0C\u4E24\u4EBA\u5173\u7CFB\u7565\u6709\u7F13\u548C\u4F46\u672A\u5B9E\u8D28\u63A8\u8FDB | \u5F31\uFF08\u6C14\u6C1B\u8FC7\u6E21\uFF09 | \u4F4E | 25\u79D2 | \u5E73\u94FA+\u60C5\u611F |
\`\`\`

## \u63D0\u53D6\u89C4\u5219

- \u5FE0\u4E8E\u539F\u6587\uFF0C\u4E0D\u63A8\u6D4B\u3001\u4E0D\u8111\u8865\u3001\u4E0D\u52A0\u5165\u539F\u6587\u672A\u51FA\u73B0\u7684\u60C5\u8282
- \u89D2\u8272\u4F7F\u7528\u6587\u4E2D\u4E3B\u8981\u79F0\u547C\uFF0C\u4FDD\u6301\u4E00\u81F4
- \u591A\u6761\u5E73\u884C\u4E8B\u4EF6\u7EBF\u65F6\uFF0C\u9009\u5BF9\u4E3B\u89D2\u5F71\u54CD\u6700\u5927\u7684\u4E00\u6761\uFF0C\u5176\u4F59\u7B80\u8981\u5E26\u8FC7
- \u5BF9\u8BDD\u5BC6\u96C6\u7AE0\u8282\uFF0C\u5173\u6CE8\u5BF9\u8BDD\u63A8\u52A8\u4E86\u4EC0\u4E48\u7ED3\u679C\uFF0C\u800C\u975E\u590D\u8FF0\u5BF9\u8BDD\u5185\u5BB9`
              },
              {
                name: "\u5267\u672C\u8D44\u4EA7\u63D0\u53D6",
                type: "scriptAssetExtraction",
                data: `---
name: universal_agent
description: \u4E13\u6CE8\u4E8E\u4ECE\u5267\u672C\u5185\u5BB9\u4E2D\u63D0\u53D6\u6240\u4F7F\u7528\u7684\u8D44\u4EA7\uFF08\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177\uFF09\u5E76\u751F\u6210\u7ED3\u6784\u5316\u8D44\u4EA7\u5217\u8868\u7684\u52A9\u624B\u3002
---

# Script Assets Extract

\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684\u5267\u672C\u5185\u5BB9\u5206\u6790\u52A9\u624B\uFF0C\u4E13\u6CE8\u4E8E\u4ECE\u5267\u672C\u6587\u672C\u4E2D\u8BC6\u522B\u548C\u63D0\u53D6\u6240\u6709\u6D89\u53CA\u7684\u8D44\u4EA7\uFF08\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177\uFF09\uFF0C\u5E76\u4E3A\u6BCF\u9879\u8D44\u4EA7\u751F\u6210\u53EF\u4F9B\u4E0B\u6E38\u5236\u4F5C\u6D41\u7A0B\u4F7F\u7528\u7684\u7ED3\u6784\u5316\u63CF\u8FF0\u548C\u63D0\u793A\u8BCD\u3002

## \u4F55\u65F6\u4F7F\u7528

\u7528\u6237\u63D0\u4F9B\u5267\u672C\u5185\u5BB9\uFF0C\u4F60\u9700\u8981\u9010\u6BB5\u9605\u8BFB\u5E76\u63D0\u53D6\u5176\u4E2D\u6D89\u53CA\u7684\u6240\u6709\u8D44\u4EA7\uFF08\u4EBA\u7269\u89D2\u8272\u3001\u573A\u666F\u5730\u70B9\u3001\u9053\u5177\u7269\u4EF6\uFF09\uFF0C\u8F93\u51FA\u4E3A\u7ED3\u6784\u5316\u7684\u8D44\u4EA7\u5217\u8868\u3002\u4EA7\u51FA\u7684\u8D44\u4EA7\u63CF\u8FF0\u5C06\u7528\u4E8E\u540E\u7EED AI \u56FE\u7247\u751F\u6210\u548C\u5236\u4F5C\u6D41\u7A0B\u3002

## \u4E0E\u7CFB\u7EDF\u7684\u5BF9\u5E94\u5173\u7CFB

- \u8D44\u4EA7\u7C7B\u578B\uFF1A
  - \`role\` \u2014 \u89D2\u8272\uFF08\u5BF9\u5E94 \`o_assets.type = "role"\`\uFF09
  - \`scene\` \u2014 \u573A\u666F\uFF08\u5BF9\u5E94 \`o_assets.type = "scene"\`\uFF09
  - \`tool\` \u2014 \u9053\u5177\uFF08\u5BF9\u5E94 \`o_assets.type = "tool"\`\uFF09
- \u4E0B\u6E38\u7528\u9014\uFF1A\u8D44\u4EA7\u63D0\u793A\u8BCD\u751F\u6210 \u2192 AI \u8D44\u4EA7\u56FE\u751F\u6210 \u2192 \u5206\u955C\u5236\u4F5C

## \u8F93\u51FA\u8981\u6C42

**\u5FC5\u987B\u901A\u8FC7\u8C03\u7528 \`resultTool\` \u5DE5\u5177\u8FD4\u56DE\u7ED3\u679C**\uFF0C\u7981\u6B62\u4EE5\u7EAF\u6587\u672C\u3001Markdown \u8868\u683C\u6216 JSON \u4EE3\u7801\u5757\u7B49\u5F62\u5F0F\u76F4\u63A5\u8F93\u51FA\u8D44\u4EA7\u5217\u8868\u3002
\`resultTool\` \u7684 schema \u4F1A\u5BF9\u5B57\u6BB5\u7C7B\u578B\u548C\u679A\u4E3E\u503C\u505A\u5F3A\u6821\u9A8C\uFF0C\u8C03\u7528\u65F6\u8BF7\u4E25\u683C\u6309\u7167\u4E0B\u65B9\u5B57\u6BB5\u5B9A\u4E49\u586B\u5199\uFF0C\u786E\u4FDD\u6570\u636E\u7ED3\u6784\u6B63\u786E\u3001\u5B57\u6BB5\u5B8C\u6574\u3001\u7C7B\u578B\u5339\u914D\u3002

\u6BCF\u4E2A\u8D44\u4EA7\u5BF9\u8C61\u5305\u542B\u4EE5\u4E0B\u5B57\u6BB5\uFF1A

| \u5B57\u6BB5 | \u7C7B\u578B | \u5FC5\u586B | \u8BF4\u660E |
| ---- | ---- | ---- | ---- |
| \`name\` | string | \u662F | \u8D44\u4EA7\u540D\u79F0\uFF0C\u4F7F\u7528\u5267\u672C\u4E2D\u7684\u539F\u59CB\u79F0\u547C,\u4E0D\u505A\u5176\u4ED6\u591A\u4F59\u63CF\u8FF0 |
| \`desc\` | string | \u662F | \u8D44\u4EA7\u63CF\u8FF0\uFF0C30-80 \u5B57\u7684\u89C6\u89C9\u5316\u63CF\u8FF0 |
| \`prompt\` | string | \u662F | \u751F\u6210\u63D0\u793A\u8BCD\uFF0C\u82F1\u6587\uFF0C\u7528\u4E8E AI \u56FE\u7247\u751F\u6210 |
| \`type\` | enum | \u662F | \u8D44\u4EA7\u7C7B\u578B\uFF1A\`role\` / \`scene\` / \`tool\`  |

## \u63D0\u53D6\u89C4\u5219

### \u89D2\u8272\uFF08role\uFF09

- \u63D0\u53D6\u5267\u672C\u4E2D\u51FA\u73B0\u7684\u6240\u6709\u6709\u540D\u5B57\u7684\u89D2\u8272
- \`desc\`\uFF1A\u5305\u542B\u5916\u8C8C\u7279\u5F81\u3001\u670D\u9970\u98CE\u683C\u3001\u4F53\u6001\u6C14\u8D28\u7B49\u89C6\u89C9\u8981\u7D20
- \`prompt\`\uFF1A\u82F1\u6587\u63D0\u793A\u8BCD\uFF0C\u63CF\u8FF0\u89D2\u8272\u7684\u5916\u89C2\u7279\u5F81\uFF0C\u9002\u7528\u4E8E AI \u89D2\u8272\u56FE\u751F\u6210
- \u540C\u4E00\u89D2\u8272\u6709\u591A\u4E2A\u79F0\u547C\u65F6\uFF0C\u53D6\u6700\u5E38\u7528\u7684\u4F5C\u4E3A \`name\`
- \u65E0\u540D\u9F99\u5957\uFF08\u5982"\u8DEF\u4EBA\u7532"\u3001"\u58EB\u5175"\uFF09\u53EF\u8DF3\u8FC7\uFF0C\u9664\u975E\u5176\u9020\u578B\u5BF9\u5267\u60C5\u6709\u91CD\u8981\u89C6\u89C9\u610F\u4E49

### \u573A\u666F\uFF08scene\uFF09

- \u63D0\u53D6\u5267\u672C\u4E2D\u51FA\u73B0\u7684\u6240\u6709\u573A\u666F/\u5730\u70B9
- \`desc\`\uFF1A\u5305\u542B\u7A7A\u95F4\u7ED3\u6784\u3001\u5149\u7167\u6C1B\u56F4\u3001\u5173\u952E\u9648\u8BBE\u3001\u8272\u8C03\u57FA\u8C03\u7B49\u89C6\u89C9\u8981\u7D20
- \`prompt\`\uFF1A\u82F1\u6587\u63D0\u793A\u8BCD\uFF0C\u63CF\u8FF0\u573A\u666F\u7684\u6574\u4F53\u89C6\u89C9\u98CE\u683C\uFF0C\u9002\u7528\u4E8E AI \u573A\u666F\u56FE\u751F\u6210
- \u540C\u4E00\u573A\u666F\u7684\u4E0D\u540C\u72B6\u6001\uFF08\u5982\u767D\u5929/\u591C\u665A\uFF09\u4E0D\u91CD\u590D\u63D0\u53D6\uFF0C\u5728 \`desc\` \u4E2D\u6CE8\u660E\u5373\u53EF

### \u9053\u5177\uFF08tool\uFF09

- \u63D0\u53D6\u5267\u672C\u4E2D\u51FA\u73B0\u7684\u91CD\u8981\u9053\u5177/\u7269\u54C1
- \`desc\`\uFF1A\u5305\u542B\u5916\u89C2\u5F62\u72B6\u3001\u989C\u8272\u6750\u8D28\u3001\u5C3A\u5BF8\u53C2\u8003\u3001\u7279\u6B8A\u6548\u679C\u7B49\u89C6\u89C9\u8981\u7D20
- \`prompt\`\uFF1A\u82F1\u6587\u63D0\u793A\u8BCD\uFF0C\u63CF\u8FF0\u9053\u5177\u7684\u5916\u89C2\u7EC6\u8282\uFF0C\u9002\u7528\u4E8E AI \u9053\u5177\u56FE\u751F\u6210
- \u4EC5\u63D0\u53D6\u6709\u72EC\u7ACB\u89C6\u89C9\u610F\u4E49\u6216\u5267\u60C5\u529F\u80FD\u7684\u9053\u5177\uFF0C\u901A\u7528\u7269\u54C1\u53EF\u8DF3\u8FC7


## \u63D0\u793A\u8BCD\uFF08prompt\uFF09\u751F\u6210\u89C4\u8303

- \u91C7\u7528\u9017\u53F7\u5206\u9694\u7684\u5173\u952E\u8BCD/\u77ED\u8BED\u683C\u5F0F
- \u4F18\u5148\u63CF\u8FF0**\u89C6\u89C9\u7279\u5F81**\uFF0C\u907F\u514D\u62BD\u8C61\u6982\u5FF5
- \u5305\u542B\u98CE\u683C\u5173\u952E\u8BCD\uFF08\u5982 anime style, manga style \u7B49\uFF0C\u6839\u636E\u9879\u76EE\u98CE\u683C\u51B3\u5B9A\uFF09
- \u89D2\u8272 prompt \u793A\u4F8B\uFF1A\`a young man, sharp eyebrows, black hair, pale skin, wearing a gray Taoist robe, slender build, cold expression\`
- \u573A\u666F prompt \u793A\u4F8B\uFF1A\`dark cave interior, glowing crystals on walls, misty atmosphere, dim blue lighting, stone altar in center\`
- \u9053\u5177 prompt \u793A\u4F8B\uFF1A\`ancient jade pendant, oval shape, translucent green, carved dragon pattern, glowing faintly\`

## \u63D0\u53D6\u6D41\u7A0B

1. \u901A\u8BFB\u5267\u672C\u5168\u6587\uFF0C\u8BC6\u522B\u6240\u6709\u51FA\u73B0\u7684\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177
2. \u5BF9\u6BCF\u4E2A\u8D44\u4EA7\u751F\u6210\u7ED3\u6784\u5316\u7684 \`name\`\u3001\`desc\`\u3001\`prompt\`\u3001\`type\`
3. \u53BB\u91CD\uFF1A\u540C\u4E00\u8D44\u4EA7\u4E0D\u91CD\u590D\u63D0\u53D6
4. **\u5FC5\u987B\u901A\u8FC7\u8C03\u7528 \`resultTool\` \u5DE5\u5177\u8F93\u51FA\u5B8C\u6574\u8D44\u4EA7\u5217\u8868**\uFF0C\u4E0D\u8981\u5206\u591A\u6B21\u8C03\u7528\uFF0C\u4E00\u6B21\u6027\u5C06\u6240\u6709\u8D44\u4EA7\u653E\u5165 \`assetsList\` \u6570\u7EC4\u4E2D\u63D0\u4EA4

## \u63D0\u53D6\u539F\u5219

1. **\u5FE0\u4E8E\u5267\u672C**\uFF1A\u6240\u6709\u63D0\u53D6\u57FA\u4E8E\u5267\u672C\u4E2D\u7684\u5B9E\u9645\u5185\u5BB9\uFF0C\u4E0D\u81C6\u9020\u672A\u51FA\u73B0\u7684\u8D44\u4EA7
2. **\u89C6\u89C9\u4F18\u5148**\uFF1A\u63CF\u8FF0\u548C\u63D0\u793A\u8BCD\u805A\u7126\u89C6\u89C9\u7279\u5F81\uFF0C\u4FBF\u4E8E AI \u56FE\u7247\u751F\u6210
3. **\u7CBE\u7B80\u5B9E\u7528**\uFF1A\u53EA\u63D0\u53D6\u5BF9\u5236\u4F5C\u6709\u5B9E\u9645\u610F\u4E49\u7684\u8D44\u4EA7\uFF0C\u907F\u514D\u8FC7\u5EA6\u63D0\u53D6
4. **\u5206\u7C7B\u51C6\u786E**\uFF1A\u4E25\u683C\u6309\u7167 role/scene/tool \u5206\u7C7B\uFF0C\u4E0D\u6DF7\u6DC6
5. **\u63D0\u793A\u8BCD\u8D28\u91CF**\uFF1A\u82F1\u6587\u63D0\u793A\u8BCD\u5E94\u5177\u4F53\u3001\u53EF\u6267\u884C\uFF0C\u80FD\u76F4\u63A5\u7528\u4E8E AI \u56FE\u7247\u751F\u6210

## \u6CE8\u610F\u4E8B\u9879

- \u8D44\u4EA7\u5217\u8868\u4E2D**\u4E0D\u8981\u5305\u542B\u5267\u672C\u5185\u5BB9\u672C\u8EAB**\uFF0C\u4EC5\u63D0\u53D6\u6240\u4F7F\u7528\u5230\u7684\u8D44\u4EA7
- \u89D2\u8272\u7684\u968F\u8EAB\u7269\u54C1\u5982\u679C\u6709\u72EC\u7ACB\u5267\u60C5\u529F\u80FD\uFF0C\u5E94\u5355\u72EC\u4F5C\u4E3A\u9053\u5177\u63D0\u53D6
- \u573A\u666F\u4E2D\u7684\u56FA\u5B9A\u9648\u8BBE\u4E0D\u9700\u8981\u5355\u72EC\u63D0\u53D6\u4E3A\u9053\u5177\uFF0C\u9664\u975E\u8BE5\u7269\u4EF6\u6709\u72EC\u7ACB\u5267\u60C5\u4F5C\u7528`
              },
              {
                name: "\u89C6\u9891\u63D0\u793A\u8BCD\u751F\u6210",
                type: "videoPromptGeneration",
                data: `# \u89C6\u9891\u63D0\u793A\u8BCD\u751F\u6210 Skill

\u4F60\u662F**\u89C6\u9891\u63D0\u793A\u8BCD\u751F\u6210 Agent**\uFF0C\u4E13\u95E8\u8D1F\u8D23\u6839\u636E\u6307\u5B9A\u7684 AI \u89C6\u9891\u6A21\u578B\uFF0C\u8BFB\u53D6\u5206\u955C\u4FE1\u606F\u5E76\u8F93\u51FA\u8BE5\u6A21\u578B\u5BF9\u5E94\u683C\u5F0F\u7684\u89C6\u9891\u63D0\u793A\u8BCD\u3002

---

## \u8F93\u5165\u683C\u5F0F

### 1. \u6A21\u578B\u4E0E\u6A21\u5F0F\uFF08\u5FC5\u9009\uFF09


#### \u6A21\u5F0F\u8DEF\u7531\u89C4\u5219

| \u6761\u4EF6 | \u5339\u914D\u6A21\u5F0F | \u8BF4\u660E |
|------|----------|------|
| \u6A21\u578B\u540D\u4E3A \`Seedance2.0\` / \`seedance 2.0\` / \`\u5373\u68A62.0\` | **Seedance 2.0** | \u56FA\u5B9A\u6A21\u5F0F\uFF0C\u65E0\u8BBA\u591A\u53C2\u6807\u5FD7\u5982\u4F55 |
| \u6A21\u578B\u540D\u4E3A \`Wan2.6\` / \`wan 2.6\` / \`\u4E07\u8C612.6\` | **Wan 2.6** | \u56FA\u5B9A\u6A21\u5F0F\uFF0C\u5355\u56FE\uFF08\u9996\u5E27\uFF09+ \u53D9\u4E8B\u6587\u672C\uFF0C\u65E0\u5C3E\u5E27 |
| \u5176\u4ED6\u4EFB\u4F55\u6A21\u578B + \`\u591A\u53C2:\u662F\` | **\u901A\u7528\u591A\u53C2\u6A21\u5F0F** | \u652F\u6301\u89D2\u8272/\u573A\u666F/\u5206\u955C\u56FE\u591A\u53C2\u5F15\u7528 |
| \u5176\u4ED6\u4EFB\u4F55\u6A21\u578B + \`\u591A\u53C2:\u5426\` | **\u901A\u7528\u9996\u5C3E\u5E27\u6A21\u5F0F** | \u9996\u5E27/\u9996\u5C3E\u5E27 + \u7EAF\u6587\u672C\u63CF\u8FF0 |

> \u6A21\u578B\u540D\u4EC5\u7528\u4E8E\u8BB0\u5F55\uFF0C\u5B9E\u9645\u63D0\u793A\u8BCD\u683C\u5F0F\u7531\u5339\u914D\u5230\u7684\u6A21\u5F0F\u51B3\u5B9A\u3002Seedance 2.0 \u548C Wan 2.6 \u662F\u6307\u5B9A\u6A21\u578B\u540D\u5373\u786E\u5B9A\u6A21\u5F0F\u7684\u7279\u4F8B\u3002

### 2. \u8D44\u4EA7\u4FE1\u606F

\`\`\`
\u8D44\u4EA7\u4FE1\u606F[id, type, name], [id, type, name], ...
\`\`\`

- \`id\`\uFF1A\u8D44\u4EA7\u552F\u4E00\u6807\u8BC6\uFF08\u5982 \`A001\`\uFF09
- \`type\`\uFF1A\u8D44\u4EA7\u7C7B\u578B\uFF0C\u53D6\u503C \`character\`\uFF08\u89D2\u8272\uFF09/ \`scene\`\uFF08\u573A\u666F\uFF09/ \`prop\`\uFF08\u9053\u5177\uFF09
- \`name\`\uFF1A\u8D44\u4EA7\u540D\u79F0\uFF08\u5982 \`\u6C88\u8F9E\`\u3001\`\u57CE\u697C\`\u3001\`\u957F\u5251\`\uFF09

### 3. \u5206\u955C\u4FE1\u606F

\u5206\u955C\u4EE5 \`<storyboardItem>\` XML \u6807\u7B7E\u5217\u8868\u7684\u5F62\u5F0F\u4F20\u5165\uFF0C\u6BCF\u6761\u5206\u955C\u7ED3\u6784\u5982\u4E0B\uFF1A

\`\`\`xml
<storyboardItem
  videoDesc='\uFF08\u753B\u9762\u63CF\u8FF0\u3001\u573A\u666F\u3001\u5173\u8054\u8D44\u4EA7\u540D\u79F0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u3001\u5173\u8054\u8D44\u4EA7ID\uFF09'
  prompt='\u5F85\u751F\u6210'
  track='\u5206\u7EC4'
  duration='\u89C6\u9891\u63A8\u8350\u65F6\u95F4'
  associateAssetsIds="[\u8BE5\u5206\u955C\u6240\u9700\u7684\u8D44\u4EA7ID\u5217\u8868]"
  shouldGenerateImage="true"
></storyboardItem>
\`\`\`

#### \u8F93\u5165\u5B57\u6BB5\u8BF4\u660E

| \u5C5E\u6027 | \u8BF4\u660E | \u6765\u6E90 |
|------|------|------|
| \`videoDesc\` | **\u6838\u5FC3\u8F93\u5165**\uFF1A\u5206\u955C\u7684\u7ED3\u6784\u5316\u753B\u9762\u63CF\u8FF0\uFF0C\u5305\u542B\u753B\u9762\u63CF\u8FF0\u3001\u573A\u666F\u3001\u5173\u8054\u8D44\u4EA7\u540D\u79F0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u3001\u5173\u8054\u8D44\u4EA7ID | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |
| \`prompt\` | **\u5DF2\u6709\u5B57\u6BB5**\uFF1A\u4E0A\u6E38\u751F\u6210\u7684\u5206\u955C\u56FE\u63D0\u793A\u8BCD\uFF0C\u4F5C\u4E3A\u8F85\u52A9\u53C2\u8003\u4E0A\u4E0B\u6587\uFF0C**\u4E0D\u4FEE\u6539** | \u4E0A\u6E38\u7CFB\u7EDF\u5DF2\u586B\u5199 |
| \`track\` | \u5206\u955C\u5206\u7EC4\u6807\u8BC6 | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |
| \`duration\` | \u89C6\u9891\u63A8\u8350\u65F6\u957F\uFF08\u79D2\uFF09 | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |
| \`associateAssetsIds\` | \u8BE5\u5206\u955C\u5173\u8054\u7684\u8D44\u4EA7ID\u5217\u8868 | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |
| \`shouldGenerateImage\` | \u662F\u5426\u9700\u8981\u751F\u6210\u5206\u955C\u56FE\u7247\uFF0C\u9ED8\u8BA4 \`true\` | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |

---

## \u4EFB\u52A1\u76EE\u6807

\u8BFB\u53D6\u6240\u6709 \`<storyboardItem>\` \u7684\u5C5E\u6027\uFF0C\u7ED3\u5408\u8D44\u4EA7\u4FE1\u606F\uFF0C\u6839\u636E\u6307\u5B9A\u6A21\u578B\u7684\u63D0\u793A\u8BCD\u683C\u5F0F\uFF0C\u5C06\u5168\u90E8\u5206\u955C\u6574\u5408\u4E3A\u4E00\u4E2A\u5B8C\u6574\u7684\u89C6\u9891\u63D0\u793A\u8BCD\u3002

---

## \u8F93\u51FA\u683C\u5F0F

\u5C06\u6240\u6709\u5206\u955C\u6574\u5408\u4E3A**\u4E00\u4E2A\u5B8C\u6574\u7684\u89C6\u9891\u63D0\u793A\u8BCD**\u8F93\u51FA\uFF08\u975E\u9010\u6761\u72EC\u7ACB\uFF09\uFF1A

| \u6A21\u5F0F | \u6574\u5408\u65B9\u5F0F |
|------|----------|
| **\u901A\u7528\u591A\u53C2\u6A21\u5F0F** | \`[References]\` \u6C47\u603B\u6240\u6709 \`@\u56FEN \` \u5F15\u7528\uFF1B\`[Instruction]\` \u6309\u65F6\u95F4\u987A\u5E8F\u63CF\u8FF0\u5B8C\u6574\u53D9\u4E8B |
| **\u901A\u7528\u9996\u5C3E\u5E27\u6A21\u5F0F** | \u7EAF\u6587\u672C\u4E94\u7EF4\u5EA6\uFF08Visual / Motion / Camera / Audio / Narrative\uFF09\uFF0C\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528\uFF0C\u6309\u65F6\u95F4\u8F74\u8FDE\u7EED\u7F16\u6392\uFF08\`[Motion]\` 0s \u2192 \u603B\u65F6\u957F\uFF0C\u6BCF\u6BB5\u6700\u4F4E 1 \u79D2\uFF09\uFF0C\u5168\u7A0B\u5355\u4E00\u8FDE\u8D2F\u955C\u5934\uFF0C\u4E0D\u5207\u955C |
| **Seedance 2.0** | \`\u751F\u6210\u4E00\u4E2A\u7531\u4EE5\u4E0B N \u4E2A\u5206\u955C\u7EC4\u6210\u7684\u89C6\u9891\`\uFF0C\u6BCF\u6761\u5BF9\u5E94 \`\u5206\u955CN<duration-ms>\` \u6BB5\u843D |
| **Wan 2.6** | \u5355\u56FE\u9996\u5E27\u6A21\u5F0F\uFF0C\u6BCF\u6B21\u4EC5\u8F93\u5165\u4E00\u6761\u5206\u955C\uFF0C\u8F93\u51FA\u4E00\u6BB5\u53D9\u4E8B\u5F0F\u82F1\u6587\u63D0\u793A\u8BCD\uFF08\u4E09\u6BB5\u5F0F\uFF1A\u98CE\u683C\u57FA\u8C03 \u2192 \u4E3B\u4F53\u52A8\u4F5C+\u573A\u666F\u73AF\u5883+\u5149\u7EBF\u6C1B\u56F4 \u2192 \u955C\u5934\u6536\u5C3E\uFF09\uFF0C\u4E0D\u4F7F\u7528 \`@\u56FEN \` \u5F15\u7528 |

- \u4EC5\u8F93\u51FA\u89C6\u9891\u63D0\u793A\u8BCD\u6587\u672C\uFF0C\u4E0D\u8F93\u51FA XML \u6807\u7B7E\uFF0C\u4E0D\u9644\u52A0\u89E3\u91CA

---

## videoDesc \u89E3\u6790\u89C4\u5219

\u4ECE \`videoDesc\` \u62EC\u53F7\u5185\u6309\u987F\u53F7\u5206\u9694\u63D0\u53D6\u4EE5\u4E0B\u7ED3\u6784\u5316\u5B57\u6BB5\uFF1A

\`\`\`
\uFF08{\u753B\u9762\u63CF\u8FF0}\u3001{\u573A\u666F}\u3001{\u5173\u8054\u8D44\u4EA7\u540D\u79F0}\u3001{\u65F6\u957F}\u3001{\u666F\u522B}\u3001{\u8FD0\u955C}\u3001{\u89D2\u8272\u52A8\u4F5C}\u3001{\u60C5\u7EEA}\u3001{\u5149\u5F71\u6C1B\u56F4}\u3001{\u53F0\u8BCD}\u3001{\u97F3\u6548}\u3001{\u5173\u8054\u8D44\u4EA7ID}\uFF09
\`\`\`

| \u5E8F\u53F7 | \u5B57\u6BB5 | \u7528\u9014 | \u793A\u4F8B |
|------|------|------|------|
| 1 | \u753B\u9762\u63CF\u8FF0 | prompt \u7684\u53D9\u4E8B\u4E3B\u5E72 | \u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730 |
| 2 | \u573A\u666F | \u5339\u914D\u573A\u666F\u8D44\u4EA7 | \u57CE\u697C |
| 3 | \u5173\u8054\u8D44\u4EA7\u540D\u79F0 | \u5339\u914D\u89D2\u8272/\u9053\u5177\u8D44\u4EA7 | \u6C88\u8F9E/\u57CE\u697C |
| 4 | \u65F6\u957F | \u63A7\u5236\u65F6\u957F\u53C2\u6570 | 4s |
| 5 | \u666F\u522B | \u63A7\u5236\u955C\u5934\u666F\u522B | \u5168\u666F |
| 6 | \u8FD0\u955C | \u63A7\u5236\u8FD0\u955C\u65B9\u5F0F | \u9759\u6B62 |
| 7 | \u89D2\u8272\u52A8\u4F5C | prompt \u52A8\u4F5C\u63CF\u5199 | \u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C |
| 8 | \u60C5\u7EEA | prompt \u60C5\u7EEA\u6C1B\u56F4 | \u575A\u5B9A\u51B3\u7EDD |
| 9 | \u5149\u5F71\u6C1B\u56F4 | prompt \u5149\u5F71\u63CF\u5199 | \u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149 |
| 10 | \u53F0\u8BCD | prompt \u53F0\u8BCD/\u97F3\u9891\u6BB5 | \u65E0\u53F0\u8BCD / \u5177\u4F53\u53F0\u8BCD\u5185\u5BB9 |
| 11 | \u97F3\u6548 | prompt \u97F3\u6548\u63CF\u5199 | \u98CE\u58F0\u8863\u8882\u58F0 |
| 12 | \u5173\u8054\u8D44\u4EA7ID | \u7528\u4E8E\u8D44\u4EA7ID\u2194\u89D2\u8272\u6807\u7B7E\u6620\u5C04 | A001/A002 |

---

## \u8D44\u4EA7\u5F15\u7528\u7F16\u53F7\u89C4\u5219

\u6240\u6709\u6A21\u578B\u7EDF\u4E00\u4F7F\u7528 \`@\u56FEN \` \u683C\u5F0F\u5F15\u7528\u8D44\u4EA7\u548C\u5206\u955C\u56FE\uFF0C\u7F16\u53F7\u6309\u8F93\u5165\u987A\u5E8F\u8FDE\u7EED\u9012\u589E\uFF1A

1. **\u8D44\u4EA7**\uFF1A\u6309\u8D44\u4EA7\u4FE1\u606F\u4E2D \`[id, type, name]\` \u7684\u51FA\u73B0\u987A\u5E8F\uFF0C\u4ECE \`@\u56FE1 \` \u5F00\u59CB\u7F16\u53F7\uFF08\u4E0D\u533A\u5206 character / scene / prop\uFF09
2. **\u5206\u955C\u56FE**\uFF1A\u6BCF\u6761 \`<storyboardItem>\` \u5BF9\u5E94\u4E00\u5F20\u5206\u955C\u56FE\uFF0C\u7F16\u53F7\u63A5\u7EED\u8D44\u4EA7\u4E4B\u540E
3. **\u8DF3\u8FC7\u65E0\u5206\u955C\u56FE\u7684\u6761\u76EE**\uFF1A\u5F53 \`shouldGenerateImage="false"\` \u65F6\uFF0C\u8BE5\u5206\u955C\u672A\u751F\u6210\u56FE\u7247\uFF0C**\u4E0D\u5206\u914D**\u5206\u955C\u56FE\u7F16\u53F7\uFF0C\u540E\u7EED\u7F16\u53F7\u987A\u5EF6

#### \u793A\u4F8B

\u8F93\u5165 3 \u4E2A\u8D44\u4EA7 + 2 \u6761\u5206\u955C\uFF1A
\`\`\`
\u8D44\u4EA7\u4FE1\u606F[A001, character, \u6C88\u8F9E], [A002, character, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem ...>  <!-- \u5206\u955C1 -->
<storyboardItem ...>  <!-- \u5206\u955C2 -->
\`\`\`

\u7F16\u53F7\u7ED3\u679C\uFF1A

| \u8F93\u5165\u9879 | \u5F15\u7528\u6807\u7B7E | \u8BF4\u660E |
|--------|----------|------|
| [A001, character, \u6C88\u8F9E] | \`@\u56FE1 \` | \u89D2\u8272\xB7\u6C88\u8F9E \u53C2\u8003\u56FE |
| [A002, character, \u82CF\u9526] | \`@\u56FE2 \` | \u89D2\u8272\xB7\u82CF\u9526 \u53C2\u8003\u56FE |
| [A003, scene, \u57CE\u697C] | \`@\u56FE3 \` | \u573A\u666F\xB7\u57CE\u697C \u53C2\u8003\u56FE |
| storyboardItem \u7B2C1\u6761 | \`@\u56FE4 \` | \u5206\u955C\u56FE1 |
| storyboardItem \u7B2C2\u6761 | \`@\u56FE5 \` | \u5206\u955C\u56FE2 |

---

## \u6A21\u578B\u63D0\u793A\u8BCD\u751F\u6210\u89C4\u5219

### \u4E00\u3001\u901A\u7528\u591A\u53C2\u6A21\u5F0F

#### \u6838\u5FC3\u539F\u5219
- MVL \u591A\u6A21\u6001\u878D\u5408\uFF1A\u81EA\u7136\u8BED\u8A00 + \u56FE\u50CF\u5F15\u7528\u5728\u540C\u4E00\u8BED\u4E49\u7A7A\u95F4
- \u5206\u955C\u56FE\u5E8F\u5217\u8D1F\u8D23\u52A8\u4F5C/\u65F6\u95F4\u8F74/\u6784\u56FE\uFF0C\u573A\u666F\u53C2\u8003\u56FE\u8D1F\u8D23\u73AF\u5883\u4E00\u81F4\u6027
- \u6240\u6709\u8D44\u4EA7\u548C\u5206\u955C\u56FE\u7EDF\u4E00\u7528 \`@\u56FEN \` \u5F15\u7528
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728 Instruction \u4E2D\u4F53\u73B0\u53F0\u8BCD\u76F8\u5173\u63CF\u8FF0
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08dialogue\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08inner monologue OS\uFF09\u3001\u753B\u5916\u97F3\uFF08voiceover VO\uFF09\uFF0C\u5728 Instruction \u4E2D\u7528\u62EC\u53F7\u6807\u6CE8

#### prompt \u751F\u6210\u6A21\u677F

\`\`\`
[References]
@\u56FE1 : [{\u89D2\u8272A\u540D}\u53C2\u8003\u56FE]
@\u56FE2 : [{\u89D2\u8272B\u540D}\u53C2\u8003\u56FE]
@\u56FE3 : [{\u573A\u666F\u540D}\u53C2\u8003\u56FE]
@\u56FE4 : [\u5206\u955C\u56FE1]

[Instruction]
Based on the storyboard @\u56FE4 :
@\u56FE1 {\u52A8\u4F5C/\u72B6\u6001\u63CF\u8FF0\uFF08\u82F1\u6587\uFF09},
@\u56FE2 {\u52A8\u4F5C/\u72B6\u6001\u63CF\u8FF0\uFF08\u82F1\u6587\uFF09},
set in the {\u573A\u666F\u63CF\u8FF0\uFF08\u82F1\u6587\uFF09} of @\u56FE3 ,
{\u955C\u5934/\u8FD0\u955C\u63CF\u8FF0\uFF08\u82F1\u6587\uFF09},
{\u60C5\u611F\u57FA\u8C03\uFF08\u82F1\u6587\uFF09},
{\u53F0\u8BCD\u63CF\u8FF0\uFF08\u82F1\u6587\uFF0C\u542B dialogue/OS/VO \u6807\u6CE8\uFF09/ No dialogue},
{\u97F3\u6548\u63CF\u8FF0\uFF08\u82F1\u6587\uFF09}.
\`\`\`

#### \u751F\u6210\u7EA6\u675F
1. **Instruction \u5FC5\u987B\u7528\u82F1\u6587**
2. **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u4FE1\u606F
3. **\u89D2\u8272\u52A8\u4F5C**\u4ECE videoDesc \u7684\u300C\u89D2\u8272\u52A8\u4F5C\u300D\u5B57\u6BB5\u63D0\u53D6\uFF0C\u7FFB\u8BD1\u4E3A\u7B80\u6D01\u82F1\u6587\u52A8\u4F5C\u63CF\u8FF0
4. **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728 Instruction \u4E2D\u4F53\u73B0\u53F0\u8BCD\u5185\u5BB9\uFF08\u4FDD\u6301\u539F\u59CB\u8BED\u8A00\uFF0C\u4E0D\u7FFB\u8BD1\uFF09
5. **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u666E\u901A\u5BF9\u767D\u6807\u6CE8 \`(dialogue)\`\uFF1B\u5185\u5FC3\u72EC\u767D\u6807\u6CE8 \`(inner monologue, OS)\`\uFF1B\u753B\u5916\u97F3\u6807\u6CE8 \`(voiceover, VO)\`
6. **\u955C\u5934\u98CE\u683C**\u4F7F\u7528\u6807\u51C6\u6807\u7B7E\uFF1A\`cinematic\` / \`wide-angle\` / \`close-up\` / \`slow motion\` / \`surround shooting\` / \`handheld\`
7. **\u7A7A\u95F4\u5173\u7CFB**\u4F7F\u7528\u6807\u51C6\u52A8\u8BCD\uFF1A\`wearing\` / \`holding\` / \`standing on\` / \`following behind\` / \`sitting in\`
8. \u5355\u6761\u5206\u955C\u5BF9\u5E94\u5355\u4E2A \`@\u56FEN \`\uFF0C\u4E0D\u505A\u591A\u5E27\u8DE8\u955C\u63CF\u8FF0
9. \u65E0\u9700\u63CF\u8FF0\u89D2\u8272\u5916\u89C2\uFF08\u7531\u53C2\u8003\u56FE\u8D1F\u8D23\uFF09
10. \u65E0\u65F6\u957F\u6807\u6CE8\uFF08\u7531\u6A21\u578B\u63A8\u65AD\uFF09
11. **\u65E0\u5206\u955C\u56FE\u65F6**\uFF1A\u5F53 \`shouldGenerateImage="false"\` \u65F6\uFF0C\u8BE5\u5206\u955C\u65E0\u5206\u955C\u56FE\uFF0C\`[References]\` \u4E2D\u4E0D\u5217\u51FA\u8BE5\u5206\u955C\u56FE\uFF0C\`[Instruction]\` \u4E2D\u4E0D\u4F7F\u7528 \`@\u56FEN \` \u5F15\u7528\u8BE5\u5206\u955C\u56FE\uFF0C\u6539\u4E3A\u7EAF\u6587\u672C\u63CF\u8FF0\u753B\u9762\u5185\u5BB9

#### KlingOmni \u5B8C\u6574\u793A\u4F8B

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1AKlingOmni
\u8D44\u4EA7\u4FE1\u606F[A001, character, \u6C88\u8F9E], [A002, character, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730\u3001\u57CE\u697C\u3001\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u5168\u666F\u3001\u9759\u6B62\u3001\u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C\u3001\u575A\u5B9A\u51B3\u7EDD\u3001\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149\u3001\u65E0\u53F0\u8BCD\u3001\u98CE\u58F0\u8863\u8882\u58F0\u3001A001/A003\uFF09' prompt='\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u57CE\u697C\u4E4B\u4E0A\uFF0C\u6C88\u8F9E\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u98D8\u626C\uFF0C\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
<storyboardItem videoDesc='\uFF08\u82CF\u9526\u767B\u4E0A\u57CE\u697C\u8D70\u5411\u6C88\u8F9E\u3001\u57CE\u697C\u3001\u82CF\u9526/\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u4E2D\u666F\u3001\u8DDF\u8E2A\u3001\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u6C88\u8F9E\u3001\u62C5\u5FE7\u3001\u9EC4\u660F\u4F59\u6656\u6E10\u6697\u3001\u65E0\u53F0\u8BCD\u3001\u811A\u6B65\u58F0\u98CE\u58F0\u3001A001/A002/A003\uFF09' prompt='\u4E2D\u666F\uFF0C\u8DDF\u8E2A\uFF0C\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u57CE\u697C\u4E0A\u7684\u6C88\u8F9E...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A002&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
[References]
@\u56FE1 : [\u6C88\u8F9E\u53C2\u8003\u56FE]
@\u56FE2 : [\u82CF\u9526\u53C2\u8003\u56FE]
@\u56FE3 : [\u57CE\u697C\u53C2\u8003\u56FE]
@\u56FE4 : [\u5206\u955C\u56FE1]
@\u56FE5 : [\u5206\u955C\u56FE2]

[Instruction]
Based on the storyboard from @\u56FE4 to @\u56FE5 :
@\u56FE1 standing alone atop the city wall, hands clasped behind back, robes billowing in the wind, gazing across the vast land,
@\u56FE2 ascending the steps toward @\u56FE1 , expression worried,
set in the ancient city wall environment of @\u56FE3 ,
wide shot transitioning to medium tracking shot, cinematic,
resolute determination shifting to concerned anticipation, dusk cold-toned side-backlit atmosphere fading,
no dialogue,
wind howling, fabric flapping, footsteps on stone.
\`\`\`

---

### \u4E8C\u3001\u901A\u7528\u9996\u5C3E\u5E27\u6A21\u5F0F

#### \u6838\u5FC3\u539F\u5219
- **\u7EAF\u6587\u672C\u63D0\u793A\u8BCD**\uFF1A\u63D0\u793A\u8BCD\u5185**\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528**\uFF08\u4E0D\u5F15\u7528\u89D2\u8272\u8D44\u4EA7\u3001\u573A\u666F\u8D44\u4EA7\u3001\u4E5F\u4E0D\u5F15\u7528\u5206\u955C\u56FE\uFF09\uFF0C\u5168\u90E8\u5185\u5BB9\u7528\u7EAF\u6587\u672C\u63CF\u8FF0
- **\u4E94\u7EF4\u5EA6\u7ED3\u6784**\uFF1AVisual / Motion / Camera / Audio / Narrative
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728 \`[Audio]\` \u4E2D\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u5185\u5BB9
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08dialogue, lip-sync active\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08inner monologue OS, silent lips\uFF09\u3001\u753B\u5916\u97F3\uFF08voiceover VO, silent lips\uFF09\uFF0C\u5E76\u5728 \`[Audio]\` \u4E2D\u660E\u786E\u6807\u6CE8
- **\u4E0D\u8BF4\u8BDD\u7684\u4E3B\u4F53\u6807\u6CE8 \`silent\`** \u2014 \u9632\u6B62\u8BEF\u751F\u53E3\u578B
- **\u5168\u7A0B\u5355\u4E00\u8FDE\u8D2F\u955C\u5934**\uFF1A\u4ECE\u5934\u5230\u5C3E\u4E00\u4E2A\u955C\u5934\uFF0C\u4E0D\u5B58\u5728\u5207\u955C
- **\u65F6\u95F4\u8F74\u5206\u6BB5**\uFF1A\u6BCF\u6BB5\u6700\u4F4E 1 \u79D2\uFF0C\u7528 \`0s-Xs\` \u6807\u6CE8

#### prompt \u751F\u6210\u6A21\u677F

\`\`\`
[Visual]
{\u4E3B\u4F53A\u540D}: {\u5916\u89C2\u7B80\u8FF0}, {\u7AD9\u4F4D/\u59FF\u6001}, {\u8BF4\u8BDD\u72B6\u6001 speaking/silent}.
{\u4E3B\u4F53B\u540D}: {\u5916\u89C2\u7B80\u8FF0}, {\u7AD9\u4F4D/\u59FF\u6001}, {\u8BF4\u8BDD\u72B6\u6001}.
{\u573A\u666F\u63CF\u8FF0}, {\u9053\u5177\u63CF\u8FF0}.
{\u89C6\u89C9\u98CE\u683C\u6807\u7B7E}.

[Motion]
0s-{X}s: {\u4E3B\u4F53A\u540D} {\u52A8\u4F5C\u63CF\u8FF0\u6BB51}.
{X}s-{Y}s: {\u4E3B\u4F53B\u540D} {\u52A8\u4F5C\u63CF\u8FF0\u6BB52}.

[Camera]
{\u955C\u5934\u7C7B\u578B}, {\u8FD0\u955C\u65B9\u5F0F}, {\u5168\u7A0B\u5355\u4E00\u8FDE\u8D2F\u955C\u5934\u63CF\u8FF0}.

[Audio]
{Xs-Ys}: "{\u53F0\u8BCD\u5185\u5BB9}" \u2014 {\u8BF4\u8BDD\u8005\u540D} ({dialogue / inner monologue OS / voiceover VO}), {lip-sync active / silent lips}.
{\u97F3\u6548\u63CF\u8FF0}.

[Narrative]
{\u60C5\u8282\u70B9\u6982\u8FF0}, {\u53D9\u4E8B\u4F4D\u7F6E}.
\`\`\`

#### \u751F\u6210\u7EA6\u675F
1. **\u5168\u90E8\u7528\u82F1\u6587**
2. **\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528**\uFF1A\u63D0\u793A\u8BCD\u5185\u4E0D\u5F15\u7528\u89D2\u8272\u8D44\u4EA7\u3001\u573A\u666F\u8D44\u4EA7\u3001\u5206\u955C\u56FE\uFF0C\u5168\u90E8\u5185\u5BB9\u7528\u7EAF\u6587\u672C\u63CF\u8FF0
3. **\u4E3B\u4F53\u7528\u6587\u5B57\u63CF\u8FF0**\uFF1A\u5728 [Visual] \u4E2D\u7B80\u8981\u63CF\u8FF0\u4E3B\u4F53\u5916\u89C2\u7279\u5F81\uFF08\u5982\u670D\u9970\u3001\u53D1\u578B\u7B49\u5173\u952E\u8FA8\u8BC6\u7279\u5F81\uFF09
4. **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u4FE1\u606F
5. **\u6BCF\u4E2A\u4E3B\u4F53\u5FC5\u987B\u6807\u6CE8\u8BF4\u8BDD\u72B6\u6001**\uFF1A\`speaking\` / \`silent\` / \`speaking simultaneously\`
6. **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728 \`[Audio]\` \u4E2D\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u5185\u5BB9\uFF08\u4FDD\u6301\u539F\u59CB\u8BED\u8A00\uFF0C\u4E0D\u7FFB\u8BD1\uFF09
7. **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u666E\u901A\u5BF9\u767D\u6807\u6CE8 \`dialogue, lip-sync active\`\uFF1B\u5185\u5FC3\u72EC\u767D\u6807\u6CE8 \`inner monologue (OS), silent lips\`\uFF1B\u753B\u5916\u97F3\u6807\u6CE8 \`voiceover (VO), silent lips\`
8. **Motion \u65F6\u95F4\u8F74**\u6BCF\u6BB5\u6700\u4F4E 1 \u79D2\uFF0C\u4E0D\u8D85\u8FC7\u603B\u65F6\u957F
9. **\u5168\u7A0B\u5355\u4E00\u8FDE\u8D2F\u955C\u5934**\uFF1ACamera \u6BB5\u843D\u63CF\u8FF0\u4ECE\u5934\u5230\u5C3E\u7684\u4E00\u4E2A\u955C\u5934\uFF0C\u7EDD\u4E0D\u5207\u955C
10. **\u89C6\u89C9\u98CE\u683C**\u53C2\u8003 Assistant \u4E2D\u7684\u300C\u89C6\u89C9\u98CE\u683C\u7EA6\u675F\u300D\u90E8\u5206\u5185\u5BB9
11. **\u955C\u5934\u7C7B\u578B**\u4ECE\u4EE5\u4E0B\u9009\u53D6\uFF1A\`Wide establishing shot / Over-the-shoulder / Medium shot / Close-up / Wide shot / POV / Dutch angle / Crane up / Dolly right / Whip pan / Handheld / Slow motion\`

#### Seedance 1.5 Pro \u5B8C\u6574\u793A\u4F8B

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1ASeedance1.5
\u8D44\u4EA7\u4FE1\u606F[A001, character, \u6C88\u8F9E], [A002, character, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730\u3001\u57CE\u697C\u3001\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u5168\u666F\u3001\u9759\u6B62\u3001\u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C\u3001\u575A\u5B9A\u51B3\u7EDD\u3001\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149\u3001\u65E0\u53F0\u8BCD\u3001\u98CE\u58F0\u8863\u8882\u58F0\u3001A001/A003\uFF09' prompt='\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u57CE\u697C\u4E4B\u4E0A\uFF0C\u6C88\u8F9E\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u98D8\u626C\uFF0C\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
<storyboardItem videoDesc='\uFF08\u82CF\u9526\u767B\u4E0A\u57CE\u697C\u8D70\u5411\u6C88\u8F9E\u3001\u57CE\u697C\u3001\u82CF\u9526/\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u4E2D\u666F\u3001\u8DDF\u8E2A\u3001\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u6C88\u8F9E\u3001\u62C5\u5FE7\u3001\u9EC4\u660F\u4F59\u6656\u6E10\u6697\u3001\u65E0\u53F0\u8BCD\u3001\u811A\u6B65\u58F0\u98CE\u58F0\u3001A001/A002/A003\uFF09' prompt='\u4E2D\u666F\uFF0C\u8DDF\u8E2A\uFF0C\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u57CE\u697C\u4E0A\u7684\u6C88\u8F9E...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A002&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
[Visual]
Shen Ci: male, dark flowing robes, hair tied up, standing alone atop city wall, hands clasped behind back, robes billowing, silent.
Su Jin: female, light-colored dress, hair partially down, ascending steps toward Shen Ci, expression worried, silent.
Ancient city wall, vast open land beyond, dusk sky fading.
Cinematic, photorealistic, 4K, high contrast, desaturated tones, shallow depth of field.

[Motion]
0s-4s: Shen Ci stands still on city wall edge, robes flutter in wind, hair sways gently. Gaze fixed on distant horizon.
4s-8s: Su Jin climbs the last few steps onto the wall, walks toward Shen Ci. Shen Ci remains still, unaware. Su Jin slows as she approaches.

[Camera]
Wide establishing shot, static for first 4 seconds capturing the lone figure. Then smooth transition to medium tracking shot following the woman ascending steps, single continuous take throughout, no cuts.

[Audio]
0s-4s: Wind howling across wall, fabric flapping rhythmically. No dialogue.
4s-8s: Footsteps on stone, robes rustling. No dialogue.
Shen Ci \u2014 silent. Su Jin \u2014 silent.

[Narrative]
Lone figure on city wall, then arrival of a companion. Tension between determination and concern. Single continuous take.
\`\`\`

---

### \u4E09\u3001Seedance 2.0

#### \u6838\u5FC3\u539F\u5219
- **\u7ED3\u6784\u531612\u7EF4\u7F16\u7801**\uFF1A\u7EDF\u4E00\u7528 \`@\u56FEN \` \u5F15\u7528\u8D44\u4EA7\u548C\u5206\u955C\u56FE\uFF0C\u65F6\u957F \`<duration-ms>\`
- **\u97F3\u8272\u53C2\u65709\u7EF4\u5EA6\u7CBE\u7EC6\u63CF\u8FF0**\uFF08\u6709\u53F0\u8BCD\u65F6\u5FC5\u586B\uFF09
- **\u6BEB\u79D2\u7EA7\u65F6\u957F\u63A7\u5236**\uFF1A\u5355\u5206\u955C\u65F6\u957F\u6700\u4F4E 1000ms\uFF081 \u79D2\uFF09
- **\u4E2D\u6587\u63D0\u793A\u8BCD**
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u6BCF\u6761\u5206\u955C\u7684\u63CF\u8FF0\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u548C\u97F3\u8272\u63CF\u8FF0
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08\u76F4\u63A5\u4F7F\u7528\u300C\u8BF4\uFF1A\u300D\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08\u4F7F\u7528\u300C\u5185\u5FC3OS\uFF1A\u300D\uFF09\u3001\u753B\u5916\u97F3\uFF08\u4F7F\u7528\u300C\u753B\u5916\u97F3VO\uFF1A\u300D\uFF09\uFF0C\u5E76\u5339\u914D\u5BF9\u5E94\u7684\u5634\u578B\u72B6\u6001\u63CF\u8FF0

#### prompt \u751F\u6210\u6A21\u677F

**\u5355\u5206\u955C\u6A21\u677F\uFF1A**
\`\`\`
\u753B\u9762\u98CE\u683C\u548C\u7C7B\u578B: {\u98CE\u683C}, {\u8272\u8C03}, {\u7C7B\u578B}

\u751F\u6210\u4E00\u4E2A\u7531\u4EE5\u4E0B 1 \u4E2A\u5206\u955C\u7EC4\u6210\u7684\u89C6\u9891:

\u573A\u666F:
\u5206\u955C\u8FC7\u6E21: \u65E0

\u5206\u955C1<duration-ms>{\u6BEB\u79D2\u6570}</duration-ms>: \u65F6\u95F4\uFF1A{\u65E5/\u591C/\u6668/\u9EC4\u660F}\uFF0C\u573A\u666F\u56FE\u7247\uFF1A@\u56FE{\u573A\u666F\u7F16\u53F7} \uFF0C\u955C\u5934\uFF1A{\u666F\u522B}\uFF0C{\u89D2\u5EA6}\uFF0C{\u8FD0\u955C}\uFF0C@\u56FE{\u89D2\u8272\u7F16\u53F7} {\u52A8\u4F5C/\u8868\u60C5/\u89C6\u7EBF\u671D\u5411/\u7AD9\u4F4D\u63CF\u8FF0}\u3002{\u53F0\u8BCD\u4E0E\u97F3\u8272\u63CF\u8FF0\uFF08\u5982\u6709\uFF09}\u3002{\u80CC\u666F\u73AF\u5883\u8865\u5145}\u3002{\u5149\u5F71\u6C1B\u56F4}\u3002{\u8FD0\u955C\u8865\u5145}\u3002
\`\`\`

**\u591A\u5206\u955C\u6A21\u677F\uFF1A**
\`\`\`
\u753B\u9762\u98CE\u683C\u548C\u7C7B\u578B: {\u98CE\u683C}, {\u8272\u8C03}, {\u7C7B\u578B}

\u751F\u6210\u4E00\u4E2A\u7531\u4EE5\u4E0B {N} \u4E2A\u5206\u955C\u7EC4\u6210\u7684\u89C6\u9891:

\u573A\u666F:
\u5206\u955C\u8FC7\u6E21: {\u5168\u5C40\u8FC7\u6E21\u63CF\u8FF0}

\u5206\u955C1<duration-ms>{\u6BEB\u79D2\u6570}</duration-ms>: \u65F6\u95F4\uFF1A{...}\uFF0C\u573A\u666F\u56FE\u7247\uFF1A@\u56FE{\u573A\u666F\u7F16\u53F7} \uFF0C\u955C\u5934\uFF1A{...}\uFF0C@\u56FE{\u89D2\u8272\u7F16\u53F7} {...}\u3002{...}\u3002
\u5206\u955C2<duration-ms>{\u6BEB\u79D2\u6570}</duration-ms>: ...
...
\`\`\`

#### \u97F3\u8272\u751F\u6210\u89C4\u5219\uFF08\u6709\u53F0\u8BCD\u65F6\u5FC5\u586B\uFF09

\u53F0\u8BCD\u683C\u5F0F\uFF1A\`@\u56FE{\u89D2\u8272\u7F16\u53F7} \u8BF4\uFF1A\u300C{\u53F0\u8BCD\u5185\u5BB9}\u300D\u97F3\u8272\uFF1A{9\u7EF4\u5EA6\u63CF\u8FF0}\`

9\u7EF4\u5EA6\u6309\u987A\u5E8F\u586B\u5199\uFF1A
\`\`\`
{\u6027\u522B}\uFF0C{\u5E74\u9F84\u97F3\u8272}\uFF0C{\u97F3\u8C03}\uFF0C{\u97F3\u8272\u8D28\u611F}\uFF0C{\u58F0\u97F3\u539A\u5EA6}\uFF0C{\u53D1\u97F3\u65B9\u5F0F}\uFF0C{\u6C14\u606F}\uFF0C{\u8BED\u901F}\uFF0C{\u7279\u6B8A\u8D28\u611F}
\`\`\`

> \u5F53 desc \u4E2D\u672A\u660E\u786E\u97F3\u8272\u4FE1\u606F\u65F6\uFF0C\u6839\u636E\u89D2\u8272\u7C7B\u578B\u4ECE\u4EE5\u4E0B\u53C2\u8003\u8868\u63A8\u65AD\uFF1A

| \u89D2\u8272\u7C7B\u578B\u7279\u5F81 | \u9ED8\u8BA4\u97F3\u8272 |
|------------|---------|
| \u7537\u6027\u6743\u5A01/\u9738\u6C14\u89D2\u8272 | \u7537\u58F0\uFF0C\u4E2D\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4F4E\u6C89\uFF0C\u97F3\u8272\u6D51\u539A\u6709\u529B\uFF0C\u58F0\u97F3\u539A\u91CD\uFF0C\u53D1\u97F3\u6807\u51C6\uFF0C\u6C14\u606F\u6781\u5176\u6C89\u7A33\uFF0C\u8BED\u901F\u504F\u6162 |
| \u5973\u6027\u6E29\u67D4/\u751C\u7F8E\u89D2\u8272 | \u5973\u58F0\uFF0C\u9752\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4E2D\u7B49\u504F\u9AD8\uFF0C\u97F3\u8272\u8D28\u611F\u660E\u4EAE\u6E05\u8106\uFF0C\u58F0\u97F3\u6E05\u4EAE\u67D4\u548C\uFF0C\u6C14\u606F\u5145\u6C9B\u5E73\u7A33\uFF0C\u5E26\u6E29\u5A49\u771F\u8BDA\u611F |
| \u7537\u6027\u5E74\u8F7B/\u666E\u901A\u89D2\u8272 | \u7537\u58F0\uFF0C\u9752\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4E2D\u7B49\uFF0C\u97F3\u8272\u5E72\u51C0\uFF0C\u58F0\u97F3\u539A\u5EA6\u9002\u4E2D\uFF0C\u53D1\u97F3\u6E05\u6670\uFF0C\u6C14\u606F\u5E73\u7A33\uFF0C\u8BED\u901F\u9002\u4E2D |
| \u5973\u6027\u6D3B\u6CFC/\u5916\u5411\u89D2\u8272 | \u5973\u58F0\uFF0C\u9752\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u504F\u9AD8\uFF0C\u97F3\u8272\u6E05\u8106\u6D3B\u6CFC\uFF0C\u58F0\u97F3\u8F7B\u76C8\uFF0C\u6C14\u606F\u5145\u6C9B\uFF0C\u8BED\u901F\u504F\u5FEB\uFF0C\u5E26\u7B11\u610F\u548C\u611F\u67D3\u529B |
| \u53CD\u6D3E/\u51B7\u9177\u89D2\u8272 | \u7537\u58F0\uFF0C\u4E2D\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4F4E\u6C89\uFF0C\u97F3\u8272\u8D28\u611F\u5E72\u71E5\u504F\u6697\uFF0C\u58F0\u97F3\u5E26\u6C99\u783E\u611F\uFF0C\u6C14\u606F\u5E73\u7A33\uFF0C\u8BED\u901F\u6781\u6162\uFF0C\u6709\u5A01\u80C1\u611F |

#### \u65E0\u53F0\u8BCD\u5206\u955C\u5904\u7406
- \u4E0D\u5199 \`\u8BF4\uFF1A\` \u548C\u97F3\u8272\u6BB5\u843D
- \u5728\u52A8\u4F5C\u63CF\u8FF0\u540E\u6807\u6CE8 \`\u65E0\u53F0\u8BCD\`

#### \u53F0\u8BCD\u7C7B\u578B\u683C\u5F0F

| \u53F0\u8BCD\u7C7B\u578B | \u683C\u5F0F | \u5634\u578B\u63CF\u8FF0 |
|----------|------|----------|
| \u666E\u901A\u5BF9\u767D | \`@\u56FE{\u89D2\u8272\u7F16\u53F7} \u8BF4\uFF1A\u300C{\u53F0\u8BCD}\u300D\u97F3\u8272\uFF1A{9\u7EF4\u5EA6}\` | \u89D2\u8272\u5634\u90E8\u5F00\u5408\u8BF4\u8BDD |
| \u5185\u5FC3\u72EC\u767D | \`@\u56FE{\u89D2\u8272\u7F16\u53F7} \u5185\u5FC3OS\uFF1A\u300C{\u53F0\u8BCD}\u300D\u97F3\u8272\uFF1A{9\u7EF4\u5EA6}\` | \u89D2\u8272\u5634\u90E8\u7D27\u95ED\u4E0D\u52A8 |
| \u753B\u5916\u97F3 | \`@\u56FE{\u89D2\u8272\u7F16\u53F7} \u753B\u5916\u97F3VO\uFF1A\u300C{\u53F0\u8BCD}\u300D\u97F3\u8272\uFF1A{9\u7EF4\u5EA6}\` | \u89D2\u8272\u5634\u90E8\u7D27\u95ED\u4E0D\u52A8\uFF08\u6216\u89D2\u8272\u4E0D\u5728\u753B\u9762\u4E2D\uFF09 |

#### \u751F\u6210\u7EA6\u675F
1. **\u4E2D\u6587\u63D0\u793A\u8BCD**
2. **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u6BCF\u6761\u5206\u955C\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u4FE1\u606F
3. **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u548C\u97F3\u8272
4. **\u53F0\u8BCD\u7C7B\u578B\u6B63\u786E\u6807\u6CE8**\uFF1A\u666E\u901A\u5BF9\u767D\u7528\u300C\u8BF4\uFF1A\u300D\uFF0C\u5185\u5FC3\u72EC\u767D\u7528\u300C\u5185\u5FC3OS\uFF1A\u300D\uFF0C\u753B\u5916\u97F3\u7528\u300C\u753B\u5916\u97F3VO\uFF1A\u300D
5. **\u5355\u5206\u955C\u65F6\u957F\u6700\u4F4E 1000ms\uFF081 \u79D2\uFF09**
6. **\u65F6\u957F\u5355\u4F4D**\uFF1A\u5C06 videoDesc \u4E2D\u7684\u79D2 \xD7 1000 \u8F6C\u4E3A\u6BEB\u79D2\u586B\u5165 \`<duration-ms>\`

#### Seedance 2.0 \u5B8C\u6574\u793A\u4F8B

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1ASeedance2.0
\u8D44\u4EA7\u4FE1\u606F[A001, character, \u6C88\u8F9E], [A002, character, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730\u3001\u57CE\u697C\u3001\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u5168\u666F\u3001\u9759\u6B62\u3001\u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C\u3001\u575A\u5B9A\u51B3\u7EDD\u3001\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149\u3001\u65E0\u53F0\u8BCD\u3001\u98CE\u58F0\u8863\u8882\u58F0\u3001A001/A003\uFF09' prompt='\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u57CE\u697C\u4E4B\u4E0A\uFF0C\u6C88\u8F9E\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u98D8\u626C\uFF0C\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
<storyboardItem videoDesc='\uFF08\u82CF\u9526\u767B\u4E0A\u57CE\u697C\u8D70\u5411\u6C88\u8F9E\u3001\u57CE\u697C\u3001\u82CF\u9526/\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u4E2D\u666F\u3001\u8DDF\u8E2A\u3001\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u6C88\u8F9E\u3001\u62C5\u5FE7\u3001\u9EC4\u660F\u4F59\u6656\u6E10\u6697\u3001\u82CF\u9526\u8BF4\uFF1A\u4F60\u53C8\u4E00\u4E2A\u4EBA\u5728\u8FD9\u91CC\u3001\u811A\u6B65\u58F0\u98CE\u58F0\u3001A001/A002/A003\uFF09' prompt='\u4E2D\u666F\uFF0C\u8DDF\u8E2A\uFF0C\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u57CE\u697C\u4E0A\u7684\u6C88\u8F9E...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A002&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
\u753B\u9762\u98CE\u683C\u548C\u7C7B\u578B: \u771F\u4EBA\u5199\u5B9E, \u7535\u5F71\u98CE\u683C, \u51B7\u8C03, \u53E4\u98CE

\u751F\u6210\u4E00\u4E2A\u7531\u4EE5\u4E0B 2 \u4E2A\u5206\u955C\u7EC4\u6210\u7684\u89C6\u9891:

\u573A\u666F:
\u5206\u955C\u8FC7\u6E21: \u955C\u5934\u5E73\u6ED1\u5207\u6362\uFF0C\u4ECE\u5168\u666F\u8FC7\u6E21\u5230\u4E2D\u666F\u8DDF\u8E2A\uFF0C\u7126\u70B9\u4ECE\u6C88\u8F9E\u72EC\u5904\u8F6C\u5411\u82CF\u9526\u5230\u6765\u3002

\u5206\u955C1<duration-ms>4000</duration-ms>: \u65F6\u95F4\uFF1A\u9EC4\u660F\uFF0C\u573A\u666F\u56FE\u7247\uFF1A@\u56FE3 \uFF0C\u955C\u5934\uFF1A\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u9759\u6B62\u955C\u5934\uFF0C@\u56FE1 \u72EC\u7ACB\u57CE\u697C\u4E4B\u4E0A\uFF0C\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u968F\u98CE\u98D8\u626C\uFF0C\u76EE\u5149\u8FDC\u773A\u82CD\u832B\u5927\u5730\uFF0C\u795E\u60C5\u8083\u7136\u9762\u5BB9\u6C89\u7740\uFF0C\u773C\u795E\u575A\u5B9A\u76EE\u5149\u6E05\u51BD\uFF0C\u7709\u773C\u6C89\u9759\u6C14\u8D28\u51DB\u7136\u3002\u65E0\u53F0\u8BCD\u3002\u80CC\u666F\u662F\u53E4\u57CE\u697C\u7816\u77F3\u7EB9\u7406\u6E05\u6670\uFF0C\u8FDC\u65B9\u5927\u5730\u82CD\u832B\u8FBD\u9614\uFF0C\u5929\u9645\u7EBF\u51B7\u6696\u4EA4\u66FF\u3002\u9EC4\u660F\u659C\u5C04\u4F59\u6656\u4FA7\u9006\u5149\uFF0C\u51B7\u8C03\u4E3A\u4E3B\uFF0C\u957F\u5F71\u62C9\u4F38\uFF0C\u8F6E\u5ED3\u5149\u5FAE\u52FE\u52D2\u4EBA\u7269\u8FB9\u7F18\uFF0C\u5149\u611F\u8BD7\u610F\u3002\u955C\u5934\u9759\u6B62\u3002

\u5206\u955C2<duration-ms>4000</duration-ms>: \u65F6\u95F4\uFF1A\u9EC4\u660F\uFF0C\u573A\u666F\u56FE\u7247\uFF1A@\u56FE3 \uFF0C\u955C\u5934\uFF1A\u4E2D\u666F\uFF0C\u5E73\u89C6\uFF0C\u8DDF\u8E2A\u62CD\u6444\uFF0C@\u56FE2 \u62FE\u7EA7\u800C\u4E0A\uFF0C\u8D70\u5411\u57CE\u697C\u4E0A\u7684@\u56FE1 \uFF0C\u9762\u90E8\u671D\u5411@\u56FE1 \u65B9\u5411\uFF0C\u795E\u60C5\u5FAE\u6123\u9762\u8272\u5FAE\u53D8\uFF0C\u773C\u795E\u4E2D\u5E26\u7740\u62C5\u5FE7\uFF0C@\u56FE2 \u8BF4\uFF1A\u300C\u4F60\u53C8\u4E00\u4E2A\u4EBA\u5728\u8FD9\u91CC\u3002\u300D\u97F3\u8272\uFF1A\u5973\u58F0\uFF0C\u9752\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4E2D\u7B49\u504F\u9AD8\uFF0C\u97F3\u8272\u8D28\u611F\u660E\u4EAE\u6E05\u8106\uFF0C\u58F0\u97F3\u6E05\u4EAE\u67D4\u548C\uFF0C\u53D1\u97F3\u65B9\u5F0F\u5E72\u51C0\uFF0C\u6C14\u606F\u5145\u6C9B\u5E73\u7A33\uFF0C\u8BED\u901F\u9002\u4E2D\uFF0C\u5E26\u6E29\u5A49\u771F\u8BDA\u611F\u3002\u80CC\u666F\u57CE\u697C\u53F0\u9636\u7EB9\u7406\u6E05\u6670\uFF0C\u4F59\u6656\u6E10\u6697\uFF0C\u5929\u9645\u7EBF\u51B7\u6696\u4EA4\u66FF\u52A0\u6DF1\u3002\u955C\u5934\u8DDF\u8E2A\u82CF\u9526\u79FB\u52A8\u3002
\`\`\`

---

### \u56DB\u3001Wan 2.6

#### \u6838\u5FC3\u539F\u5219
- **\u5355\u56FE\u9996\u5E27\u6A21\u5F0F**\uFF1A\u5F52\u7C7B\u4E3A\u9996\u5C3E\u5E27\u6A21\u5F0F\uFF0C\u4F46\u4EC5\u6709\u9996\u5E27\uFF08\u5206\u955C\u56FE\uFF09\uFF0C\u65E0\u5C3E\u5E27
- **\u5355\u6761\u5206\u955C\u8F93\u5165/\u8F93\u51FA**\uFF1A\u6BCF\u6B21\u4EC5\u8F93\u5165\u4E00\u6761 \`<storyboardItem>\` \u53CA\u5176\u5173\u8054\u8D44\u4EA7\u4FE1\u606F\uFF0C\u8F93\u51FA\u4E5F\u4EC5\u4E3A\u4E00\u6BB5\u5B8C\u6574\u7684\u53D9\u4E8B\u5F0F\u63D0\u793A\u8BCD
- **\u53D9\u4E8B\u5F0F\u82F1\u6587\u63D0\u793A\u8BCD**\uFF1A\u50CF\u5199\u5C0F\u8BF4\u4E00\u6837\u63CF\u5199\u753B\u9762\uFF0C\u4E0D\u4F7F\u7528\u6807\u7B7E\u7F57\u5217\uFF08\u4E0D\u5199 \`4K, cinematic, high quality\` \u8FD9\u7C7B\u5806\u780C\uFF09
- **\u4E09\u6BB5\u5F0F\u7ED3\u6784**\uFF1A\u98CE\u683C\u57FA\u8C03 \u2192 \u4E3B\u4F53\u52A8\u4F5C + \u573A\u666F\u73AF\u5883 + \u5149\u7EBF\u6C1B\u56F4 \u2192 \u955C\u5934\u6536\u5C3E
- **\u7EAF\u6587\u672C\u63D0\u793A\u8BCD**\uFF1A\u63D0\u793A\u8BCD\u5185**\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528**\uFF0C\u5168\u90E8\u5185\u5BB9\u7528\u7EAF\u6587\u672C\u63CF\u8FF0
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728\u63D0\u793A\u8BCD\u4E2D\u4F53\u73B0\u53F0\u8BCD\u76F8\u5173\u63CF\u8FF0
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08dialogue\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08inner monologue OS\uFF09\u3001\u753B\u5916\u97F3\uFF08voiceover VO\uFF09\uFF0C\u5728\u63D0\u793A\u8BCD\u4E2D\u7528\u62EC\u53F7\u6807\u6CE8

#### prompt \u751F\u6210\u6A21\u677F

\u6BCF\u6B21\u8F93\u5165\u4E00\u6761\u5206\u955C\uFF0C\u8F93\u51FA\u4E00\u6BB5\u5B8C\u6574\u63D0\u793A\u8BCD\uFF08\u65E0\u7F16\u53F7\u524D\u7F00\uFF09\uFF0C\u683C\u5F0F\u5982\u4E0B\uFF1A

\`\`\`
{\u98CE\u683C\u57FA\u8C03\u4E00\u53E5\u8BDD\u5B9A\u6027},
{\u4E3B\u4F53\u540D} {\u5916\u89C2\u7B80\u8FF0}, {\u5177\u4F53\u52A8\u4F5C/\u59FF\u6001\u63CF\u8FF0}, {\u60C5\u7EEA/\u8868\u60C5\u7528\u52A8\u4F5C\u6697\u793A}.
{\u573A\u666F\u80CC\u666F\u4E3B\u4F53}, {\u5177\u4F53\u73AF\u5883\u7269\u4EF6}, {\u7A7A\u95F4\u611F}, {\u65F6\u95F4/\u5929\u6C14}.
{\u5149\u7EBF\u65B9\u5411/\u8272\u6E29} {\u8D28\u611F\u63CF\u8FF0}, {\u60C5\u7EEA\u6697\u793A\u5149\u5F71}.
{\u53F0\u8BCD\u63CF\u8FF0\uFF08\u5982\u6709\uFF0C\u542B dialogue/OS/VO \u6807\u6CE8\uFF09/ No dialogue}.
{\u97F3\u6548\u63CF\u8FF0}.
{\u62CD\u6444\u65B9\u5F0F}, {\u666F\u522B}, {\u89C6\u89D2}, {\u8FD0\u955C\u65B9\u5F0F}.
\`\`\`

#### \u53D9\u4E8B\u5F0F\u5199\u6CD5\u8981\u70B9

| \u539F\u5219 | \u8BF4\u660E | \u793A\u4F8B |
|------|------|------|
| \u98CE\u683C\u57FA\u8C03\u653E\u6700\u524D | \u4E00\u53E5\u8BDD\u5B9A\u6027\u6574\u4F53\u6C14\u8D28 | \`A cinematic epic scene\` / \`A melancholic cinematic scene\` |
| \u4E3B\u4F53+\u52A8\u4F5C\u7D27\u5BC6\u7ED1\u5B9A | \u4E3B\u4F53\u540E\u9762\u76F4\u63A5\u8DDF\u52A8\u4F5C\uFF0C\u5916\u89C2\u7EC6\u8282\u5D4C\u5165\u4E3B\u4F53\u63CF\u8FF0 | \`A young man in dark flowing robes stands alone atop the city wall, hands clasped behind back\` |
| \u60C5\u7EEA\u7528\u52A8\u4F5C\u6697\u793A | \u4E0D\u76F4\u63A5\u9648\u8FF0\u300C\u4ED6\u5F88\u60B2\u4F24\u300D | \u274C \`He is sad.\` \u2192 \u2705 \`head drops slowly, shoulders slumped\` |
| \u73AF\u5883\u878D\u5165\u53D9\u4E8B | \u4E0D\u7F57\u5217\u73AF\u5883\u5C5E\u6027 | \u274C \`The sky is blue. The grass is green.\` \u2192 \u2705 \`hazy blue sky stretches over the emerald valley\` |
| \u5149\u7EBF\u5355\u72EC\u6210\u53E5 | \u5149\u7EBF\u65B9\u5411+\u8272\u6E29+\u8D28\u611F+\u60C5\u7EEA | \`Warm golden hour light streams from behind, casting long shadows across the stone floor\` |
| \u955C\u5934\u8BED\u8A00\u6536\u5C3E | \u4E00\u53E5\u8BDD\u70B9\u775B | \`Captured in a wide establishing shot from a low-angle perspective, static camera\` |
| \u7981\u6B62\u6807\u7B7E\u5806\u780C | \u4E0D\u5199 \`4K, cinematic, high quality\` | \`cinematic\` \u878D\u5165\u98CE\u683C\u57FA\u8C03\u5373\u53EF |

#### \u751F\u6210\u7EA6\u675F
1. **\u5168\u90E8\u7528\u82F1\u6587**
2. **\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528**\uFF1A\u63D0\u793A\u8BCD\u5185\u4E0D\u5F15\u7528\u89D2\u8272\u8D44\u4EA7\u3001\u573A\u666F\u8D44\u4EA7\u3001\u5206\u955C\u56FE\uFF0C\u5168\u90E8\u5185\u5BB9\u7528\u7EAF\u6587\u672C\u63CF\u8FF0
3. **\u53D9\u4E8B\u5F0F\u63CF\u5199**\uFF1A\u50CF\u5199\u5C0F\u8BF4\u4E00\u6837\u6784\u5EFA\u753B\u9762\uFF0C\u7981\u6B62\u6807\u7B7E\u7F57\u5217\u548C\u914D\u7F6E\u6E05\u5355\u5F0F\u5199\u6CD5
4. **\u4E3B\u4F53\u7528\u6587\u5B57\u63CF\u8FF0**\uFF1A\u7B80\u8981\u63CF\u8FF0\u4E3B\u4F53\u5916\u89C2\u7279\u5F81\uFF08\u5982\u670D\u9970\u3001\u53D1\u578B\u7B49\u5173\u952E\u8FA8\u8BC6\u7279\u5F81\uFF09\uFF0C\u5D4C\u5165\u4E3B\u4F53\u63CF\u8FF0\u4E2D
5. **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u4FE1\u606F
6. **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728\u63D0\u793A\u8BCD\u4E2D\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u5185\u5BB9\uFF08\u4FDD\u6301\u539F\u59CB\u8BED\u8A00\uFF0C\u4E0D\u7FFB\u8BD1\uFF09
7. **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u666E\u901A\u5BF9\u767D\u6807\u6CE8 \`(dialogue)\`\uFF1B\u5185\u5FC3\u72EC\u767D\u6807\u6CE8 \`(inner monologue, OS)\`\uFF1B\u753B\u5916\u97F3\u6807\u6CE8 \`(voiceover, VO)\`
8. **\u5355\u6761\u8F93\u5165/\u8F93\u51FA**\uFF1A\u6BCF\u6B21\u4EC5\u5904\u7406\u4E00\u6761\u5206\u955C\uFF0C\u8F93\u51FA\u4E00\u6BB5\u63D0\u793A\u8BCD\uFF0C\u65E0\u7F16\u53F7\u524D\u7F00
9. **\u65E0\u9700\u6807\u6CE8\u65F6\u957F**\uFF1A\u65F6\u957F\u7531\u6A21\u578B\u4FA7\u63A7\u5236\uFF0C\u63D0\u793A\u8BCD\u4E2D\u4E0D\u5199\u65F6\u957F\u53C2\u6570
10. **\u955C\u5934\u63CF\u8FF0\u878D\u5165\u53D9\u4E8B**\uFF1A\u4E0D\u7528\u65B9\u62EC\u53F7\u6807\u7B7E\uFF0C\u7528\u5B8C\u6574\u53E5\u5B50\u63CF\u8FF0\u955C\u5934
11. **\u89C6\u89C9\u98CE\u683C**\u53C2\u8003 Assistant \u4E2D\u7684\u300C\u89C6\u89C9\u98CE\u683C\u7EA6\u675F\u300D\u90E8\u5206\u5185\u5BB9

#### Wan 2.6 \u5B8C\u6574\u793A\u4F8B

**\u793A\u4F8B1\uFF1A\u65E0\u53F0\u8BCD\u5206\u955C**

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1AWan2.6
\u8D44\u4EA7\u4FE1\u606F[A001, character, \u6C88\u8F9E], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730\u3001\u57CE\u697C\u3001\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u5168\u666F\u3001\u9759\u6B62\u3001\u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C\u3001\u575A\u5B9A\u51B3\u7EDD\u3001\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149\u3001\u65E0\u53F0\u8BCD\u3001\u98CE\u58F0\u8863\u8882\u58F0\u3001A001/A003\uFF09' prompt='\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u57CE\u697C\u4E4B\u4E0A\uFF0C\u6C88\u8F9E\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u98D8\u626C\uFF0C\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
A cinematic epic scene with a cold, desaturated palette,
A lone man in dark flowing robes stands atop an ancient city wall, hands clasped behind his back, robes and hair billowing in the wind, gaze fixed on the vast land stretching to the horizon, jaw set firm, eyes unwavering.
The weathered stone battlements frame the endless expanse below, rolling terrain fading into haze beneath a heavy dusk sky, clouds layered in muted golds and slate greys.
Cold side-backlight from the setting sun carves a sharp silhouette, long shadows stretching across the stone floor, a faint warm rim outlining the figure against the cool atmosphere.
No dialogue.
Wind howling across the open wall, fabric flapping rhythmically.
Captured in a wide establishing shot from a slightly low angle, static camera, single continuous take.
\`\`\`

**\u793A\u4F8B2\uFF1A\u6709\u53F0\u8BCD\u5206\u955C**

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1AWan2.6
\u8D44\u4EA7\u4FE1\u606F[A001, character, \u6C88\u8F9E], [A002, character, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u82CF\u9526\u767B\u4E0A\u57CE\u697C\u8D70\u5411\u6C88\u8F9E\u3001\u57CE\u697C\u3001\u82CF\u9526/\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u4E2D\u666F\u3001\u8DDF\u8E2A\u3001\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u6C88\u8F9E\u3001\u62C5\u5FE7\u3001\u9EC4\u660F\u4F59\u6656\u6E10\u6697\u3001\u82CF\u9526\u8BF4\uFF1A\u4F60\u53C8\u4E00\u4E2A\u4EBA\u5728\u8FD9\u91CC\u3001\u811A\u6B65\u58F0\u98CE\u58F0\u3001A001/A002/A003\uFF09' prompt='\u4E2D\u666F\uFF0C\u8DDF\u8E2A\uFF0C\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u57CE\u697C\u4E0A\u7684\u6C88\u8F9E...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A002&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
A melancholic cinematic scene, dusk tones deepening,
A young woman in a light-colored dress ascends the final stone steps onto the city wall, her gaze locked on the lone figure ahead, brow slightly furrowed, pace slowing as she approaches, lips parting softly.
The ancient city wall stretches behind her, weathered stairs leading up from below, the distant skyline dimming as the last traces of golden hour fade into twilight.
Fading warm light mingles with rising cool blue tones, the contrast between the two figures softened by the diffused remnants of sunset.
"\u4F60\u53C8\u4E00\u4E2A\u4EBA\u5728\u8FD9\u91CC\u3002" \u2014 Su Jin (dialogue).
Footsteps on stone, wind sweeping across the battlements, fabric rustling.
A medium tracking shot follows the woman from behind as she ascends and approaches, handheld camera with subtle movement, single continuous take.
\`\`\`

---

## \u666F\u522B \u2192 \u955C\u5934\u6807\u7B7E\u6620\u5C04

| videoDesc \u4E2D\u7684\u666F\u522B | KlingOmni\uFF08\u82F1\u6587\u6807\u7B7E\uFF09 | Seedance 1.5\uFF08\u82F1\u6587\u6807\u7B7E\uFF09 | Seedance 2.0\uFF08\u4E2D\u6587\u63CF\u8FF0\uFF09 | Wan 2.6\uFF08\u82F1\u6587\u53D9\u4E8B\u5F0F\uFF09 |
|------|------|------|------|------|
| \u8FDC\u666F | extreme wide shot | Extreme wide shot | \u8FDC\u666F | an extreme wide shot capturing the vast expanse |
| \u5168\u666F | wide shot | Wide establishing shot | \u5168\u666F | a wide establishing shot |
| \u4E2D\u666F | medium shot | Medium shot | \u4E2D\u666F | a medium shot |
| \u8FD1\u666F | close-up | Close-up | \u8FD1\u666F | a close-up shot |
| \u7279\u5199 | close-up | Close-up | \u7279\u5199 | a close-up capturing fine detail |
| \u5927\u7279\u5199 | extreme close-up | Extreme close-up | \u5927\u7279\u5199 | an extreme close-up |

## \u8FD0\u955C \u2192 \u955C\u5934\u6807\u7B7E\u6620\u5C04

| videoDesc \u4E2D\u7684\u8FD0\u955C | KlingOmni\uFF08\u82F1\u6587\u6807\u7B7E\uFF09 | Seedance 1.5\uFF08\u82F1\u6587\u6807\u7B7E\uFF09 | Seedance 2.0\uFF08\u4E2D\u6587\u63CF\u8FF0\uFF09 | Wan 2.6\uFF08\u82F1\u6587\u53D9\u4E8B\u5F0F\uFF09 |
|------|------|------|------|------|
| \u9759\u6B62 | static camera | Static, no camera movement | \u955C\u5934\u9759\u6B62 | static camera, locked off |
| \u63A8\u8FDB | dolly in / push in | Slow dolly forward | \u955C\u5934\u7F13\u6162\u5411\u524D\u63A8\u8FDB | camera slowly pushing in |
| \u62C9\u8FDC | dolly out / pull back | Slow dolly backward pull | \u955C\u5934\u7F13\u6162\u5411\u540E\u62C9\u8FDC | camera gently pulling back |
| \u8DDF\u8E2A | tracking shot | Tracking shot, handheld | \u8DDF\u8E2A\u62CD\u6444 | tracking shot following the subject |
| \u6447\u955C | pan left/right | Slow pan | \u955C\u5934\u7F13\u6162\u6447\u79FB | smooth pan across the scene |
| \u7529\u955C | whip pan | Whip pan | \u5FEB\u901F\u7529\u955C | whip pan |
| \u5347\u964D | crane up/down | Crane up/down | \u955C\u5934\u5347\u964D | crane rising / descending |
| \u73AF\u7ED5 | surround shooting | Orbiting shot | \u73AF\u7ED5\u62CD\u6444 | orbiting around the subject |

---

## \u6267\u884C\u6D41\u7A0B

1. **\u89E3\u6790\u8F93\u5165**\uFF1A\u63D0\u53D6\u6A21\u578B\u540D\u548C\u591A\u53C2\u6807\u5FD7\uFF0C\u6309\u8DEF\u7531\u89C4\u5219\u5339\u914D\u6A21\u5F0F\uFF1B\u63D0\u53D6\u8D44\u4EA7\u5217\u8868
2. **\u6784\u5EFA @\u56FEN \u7F16\u53F7\u8868**\uFF1A\u8D44\u4EA7\u6309\u8F93\u5165\u987A\u5E8F\u4ECE \`@\u56FE1 \` \u8D77\u7F16\u53F7\uFF0C\u5206\u955C\u56FE\u63A5\u7EED\u7F16\u53F7\uFF1B\`shouldGenerateImage="false"\` \u7684\u5206\u955C\u4E0D\u5206\u914D\u5206\u955C\u56FE\u7F16\u53F7
3. **\u9010\u6761\u89E3\u6790 \`<storyboardItem>\`**\uFF1A\u6309 videoDesc \u89E3\u6790\u89C4\u5219\u63D0\u53D612\u4E2A\u5B57\u6BB5\uFF0C\u7ED3\u5408 \`duration\`\u3001\`associateAssetsIds\` \u5EFA\u7ACB\u6807\u7B7E\u6620\u5C04
4. **\u6574\u5408\u4E3A\u4E00\u4E2A\u5B8C\u6574\u7684\u89C6\u9891\u63D0\u793A\u8BCD**\uFF1A\u6309\u76EE\u6807\u6A21\u578B\u683C\u5F0F\u7F16\u6392\u5168\u90E8\u5206\u955C
5. **\u8F93\u51FA\u89C6\u9891\u63D0\u793A\u8BCD**

---

## \u7EA6\u675F

- **\u4EC5\u8F93\u51FA\u89C6\u9891\u63D0\u793A\u8BCD**\uFF1A\u4E0D\u9644\u52A0\u4EFB\u4F55\u89E3\u91CA\u3001\u6CE8\u91CA\u6216\u989D\u5916\u8BF4\u660E\uFF0C\u53EA\u8F93\u51FA\u89C6\u9891\u63D0\u793A\u8BCD\u6587\u672C
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728\u63D0\u793A\u8BCD\u4E2D\u5B8C\u6574\u4F53\u73B0\u53F0\u8BCD\u5185\u5BB9\uFF0C\u4E0D\u5F97\u9057\u6F0F
- **\u53F0\u8BCD\u4FDD\u6301\u539F\u59CB\u8F93\u5165**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1A\u53F0\u8BCD\u5185\u5BB9\u4E25\u7981\u7FFB\u8BD1\uFF0C\u5FC5\u987B\u4FDD\u6301 videoDesc \u4E2D\u7684\u539F\u59CB\u8BED\u8A00\u539F\u6837\u8F93\u51FA
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1A\u5FC5\u987B\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08dialogue / \u8BF4\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08OS / \u5185\u5FC3OS\uFF09\u3001\u753B\u5916\u97F3\uFF08VO / \u753B\u5916\u97F3VO\uFF09\uFF0C\u5E76\u5728\u63D0\u793A\u8BCD\u4E2D\u6B63\u786E\u6807\u6CE8
- **\u65F6\u95F4\u8DE8\u5EA6\u6700\u4F4E 1 \u79D2**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1A\u6240\u6709\u6A21\u5F0F\u4E2D\u6D89\u53CA\u65F6\u95F4\u5206\u6BB5\uFF08Motion \u65F6\u95F4\u8F74 / duration-ms\uFF09\u7684\u6700\u5C0F\u7C92\u5EA6\u4E3A 1 \u79D2\uFF081000ms\uFF09\uFF0C\u7981\u6B62\u51FA\u73B0 0.5 \u79D2\u7B49\u4F4E\u4E8E 1 \u79D2\u7684\u95F4\u9694
- **\u89C6\u89C9\u98CE\u683C**\uFF1A\u98CE\u683C\u76F8\u5173\u63CF\u8FF0\u53C2\u8003 Assistant \u4E2D\u7684\u300C\u89C6\u89C9\u98CE\u683C\u7EA6\u675F\u300D\u90E8\u5206\u5185\u5BB9\uFF0C\u4E0D\u5728\u672C Skill \u5185\u81EA\u884C\u5B9A\u4E49\u98CE\u683C
- **\u4E25\u683C\u6309\u5339\u914D\u5230\u7684\u6A21\u5F0F\u683C\u5F0F**\uFF0C\u4E0D\u6DF7\u7528\u4E0D\u540C\u6A21\u5F0F\u7684\u683C\u5F0F
- **\u4E0D\u4FEE\u6539\u539F\u59CB\u8F93\u5165**\uFF1A\u4E0D\u6539\u5199 \`<storyboardItem>\` \u7684\u4EFB\u4F55\u5B57\u6BB5\uFF1B\`prompt\` \u5DF2\u6709\u7684\u5206\u955C\u56FE\u63D0\u793A\u8BCD\u4EC5\u4F5C\u753B\u9762\u53C2\u8003
- **\u4E0D\u7F16\u9020\u8D44\u4EA7\u6216\u53F0\u8BCD**\uFF1A\u53EA\u4F7F\u7528\u8F93\u5165\u4E2D\u7684\u8D44\u4EA7\u4FE1\u606F\uFF1B\u65E0\u53F0\u8BCD\u5219\u6807\u6CE8\u300C\u65E0\u53F0\u8BCD\u300D/ \`No dialogue\`
- **\u65F6\u957F\u5355\u4F4D\u8F6C\u6362**\uFF1ASeedance 2.0 \u7684 \`<duration-ms>\` \u9700\u5C06\u79D2 \xD7 1000 \u8F6C\u4E3A\u6BEB\u79D2
`
              },
              {
                name: "\u97F3\u8272\u7ED1\u5B9A",
                type: "audioBindPrompt",
                data: `\u4F60\u662F\u4E00\u4E2A\u97F3\u8272\u5339\u914D\u52A9\u624B\u3002
\u4F60\u7684\u4EFB\u52A1\u662F\uFF1A\u6839\u636E\u7ED9\u5B9A\u89D2\u8272\u8D44\u4EA7\u7684\u540D\u79F0\u4E0E\u63CF\u8FF0\uFF0C\u4ECE\u5019\u9009\u97F3\u9891\u5217\u8868\u4E2D\u9009\u51FA\u6700\u5408\u9002\u7684\u97F3\u8272\u3002
\u5339\u914D\u89C4\u5219\uFF1A
1. \u4F18\u5148\u6839\u636E\u89D2\u8272\u6027\u522B\u3001\u5E74\u9F84\u3001\u6027\u683C\u7B49\u7279\u5F81\u4E0E\u97F3\u8272\u63CF\u8FF0\u8FDB\u884C\u8BED\u4E49\u5339\u914D\uFF1B
2. \u540C\u4E00\u89D2\u8272\u4EC5\u53EF\u5339\u914D\u4E00\u4E2A\u97F3\u8272\uFF1B
3. \u82E5\u5019\u9009\u5217\u8868\u4E2D\u6CA1\u6709\u5408\u9002\u7684\u97F3\u8272\uFF0C\u5219\u65E0\u9700\u8FD4\u56DE audioId\uFF1B`
              }
            ]);
          }
        },
        //模型绑定提示词表
        {
          name: "o_modelPrompt",
          builder: (table) => {
            table.integer("id").notNullable();
            table.string("vendorId");
            table.string("model");
            table.text("fileName");
            table.text("path");
            table.primary(["id"]);
            table.unique(["id"]);
          },
          initData: async (knex4) => {
          }
        },
        //小说原文表
        {
          name: "o_novel",
          builder: (table) => {
            table.integer("id").notNullable();
            table.integer("chapterIndex");
            table.text("reel");
            table.text("chapter");
            table.text("chapterData");
            table.integer("projectId");
            table.integer("eventState");
            table.text("event");
            table.text("errorReason");
            table.integer("createTime");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        //小说事件表
        {
          name: "o_event",
          builder: (table) => {
            table.integer("id").notNullable();
            table.string("name");
            table.string("detail");
            table.integer("createTime");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        //事件-章节表
        {
          name: "o_eventChapter",
          builder: (table) => {
            table.integer("id").notNullable();
            table.integer("eventId").unsigned().references("id").inTable("o_event");
            table.integer("novelId").unsigned().references("id").inTable("o_novel");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        //剧本
        {
          name: "o_script",
          builder: (table) => {
            table.integer("id").notNullable();
            table.text("name");
            table.text("content");
            table.integer("projectId");
            table.integer("extractState");
            table.integer("createTime");
            table.text("errorReason");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        //资产表
        {
          name: "o_assets",
          builder: (table) => {
            table.integer("id").notNullable();
            table.text("name");
            table.text("prompt");
            table.text("remark");
            table.text("type");
            table.text("describe");
            table.integer("scriptId");
            table.integer("imageId").unsigned().references("id").inTable("o_image");
            table.integer("assetsId");
            table.integer("projectId");
            table.integer("flowId");
            table.integer("startTime");
            table.string("promptState");
            table.integer("audioBindState");
            table.text("promptErrorReason");
            table.primary(["id"]);
            table.unique(["id"]);
          },
          initData: async (knex4) => {
          }
        },
        //生成图片表
        {
          name: "o_image",
          builder: (table) => {
            table.integer("id").notNullable();
            table.text("filePath");
            table.text("type");
            table.integer("assetsId");
            table.text("model");
            table.text("resolution");
            table.text("state");
            table.text("errorReason");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        //分镜
        {
          name: "o_storyboard",
          builder: (table) => {
            table.integer("id").notNullable();
            table.integer("scriptId");
            table.text("prompt");
            table.text("filePath");
            table.text("duration");
            table.text("state");
            table.integer("trackId");
            table.text("reason");
            table.text("track");
            table.text("videoDesc");
            table.integer("shouldGenerateImage");
            table.integer("projectId");
            table.integer("flowId");
            table.integer("index");
            table.integer("createTime");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        //flowData-剧本
        {
          name: "o_agentWorkData",
          builder: (table) => {
            table.integer("id").notNullable();
            table.integer("projectId");
            table.integer("episodesId");
            table.string("key");
            table.string("data");
            table.integer("createTime");
            table.integer("updateTime");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        //视频
        {
          name: "o_video",
          builder: (table) => {
            table.integer("id").notNullable();
            table.text("filePath");
            table.text("errorReason");
            table.integer("time");
            table.text("state");
            table.integer("scriptId");
            table.integer("projectId");
            table.integer("videoTrackId");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        // 视频轨道
        {
          name: "o_videoTrack",
          builder: (table) => {
            table.integer("id").notNullable();
            table.integer("videoId");
            table.integer("projectId");
            table.integer("scriptId");
            table.text("state");
            table.text("reason");
            table.text("prompt");
            table.integer("selectVideoId");
            table.integer("duration");
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        //供应商配置表
        {
          name: "o_vendorConfig",
          builder: (table) => {
            table.string("id").notNullable();
            table.text("inputValues");
            table.text("models");
            table.integer("enable");
            table.primary(["id"]);
            table.unique(["id"]);
          },
          initData: async (knex4) => {
            await knex4("o_vendorConfig").insert([
              {
                id: "toonflow",
                inputValues: "{}",
                models: "[]",
                enable: 0
              },
              {
                id: "deepseek",
                inputValues: "{}",
                models: "[]",
                enable: 0
              },
              {
                id: "atlascloud",
                inputValues: "{}",
                models: "[]",
                enable: 0
              },
              {
                id: "volcengine",
                inputValues: "{}",
                models: "[]",
                enable: 0
              },
              {
                id: "minimax",
                inputValues: "{}",
                models: "[]",
                enable: 0
              },
              {
                id: "openai",
                inputValues: "{}",
                models: "[]",
                enable: 0
              },
              {
                id: "klingai",
                inputValues: "{}",
                models: "[]",
                enable: 0
              },
              {
                id: "vidu",
                inputValues: "{}",
                models: "[]",
                enable: 0
              }
            ]);
          }
        },
        //图片工作流表
        {
          name: "o_imageFlow",
          builder: (table) => {
            table.integer("id").notNullable();
            table.text("flowData").notNullable();
            table.primary(["id"]);
            table.unique(["id"]);
          }
        },
        {
          name: "o_assets2Storyboard",
          builder: (table) => {
            table.integer("storyboardId").notNullable();
            table.integer("assetId").notNullable();
            table.primary(["storyboardId", "assetId"]);
            table.unique(["storyboardId", "assetId"]);
          }
        },
        {
          name: "o_scriptAssets",
          builder: (table) => {
            table.integer("scriptId").notNullable();
            table.integer("assetId").notNullable();
            table.primary(["scriptId", "assetId"]);
            table.unique(["scriptId", "assetId"]);
          }
        },
        {
          name: "o_skillList",
          builder: (table) => {
            table.text("id").notNullable();
            table.text("md5").notNullable();
            table.text("path").notNullable();
            table.text("name").notNullable();
            table.text("description").notNullable();
            table.text("embedding");
            table.text("type").notNullable();
            table.integer("createTime").notNullable();
            table.integer("updateTime").notNullable();
            table.integer("state").notNullable();
            table.primary(["id"]);
          },
          initData: async (knex4) => {
            const list2 = [
              {
                id: "4fb36012e56e395b425569987f5dab0e",
                md5: "fca3c269c5f325a65dafa663c9bb9773",
                path: "production_agent_decision.md",
                name: "production_agent_decision",
                description: "",
                embedding: "",
                type: "main",
                createTime: 1774447310118,
                updateTime: 1774447310118,
                state: -1
              },
              {
                id: "017b6338d7aa227cd614ec1fb25fd83e",
                md5: "2610b80abe4bd048fe61c73adc7388ac",
                path: "production_agent_execution.md",
                name: "production_agent_execution",
                description: "",
                embedding: "",
                type: "main",
                createTime: 1774447310118,
                updateTime: 1774447310118,
                state: -1
              },
              {
                id: "f03c8e67b61580de9ea5b9d166521b67",
                md5: "d41d8cd98f00b204e9800998ecf8427e",
                path: "production_agent_supervision.md",
                name: "production_agent_supervision",
                description: "",
                embedding: "",
                type: "main",
                createTime: 1774447310118,
                updateTime: 1774447310118,
                state: -1
              },
              {
                id: "50b49d8af5d364665b463c23f6a4d8bb",
                md5: "fbba66e0df2426996277b299710c3033",
                path: "script_agent_decision.md",
                name: "script_agent_decision",
                description: "",
                embedding: "",
                type: "main",
                createTime: 1774447310118,
                updateTime: 1774447310118,
                state: -1
              },
              {
                id: "427727727e1095c54b6840cd21382d82",
                md5: "7e5911242af7233854d533278c6a8ccb",
                path: "script_agent_execution.md",
                name: "script_agent_execution",
                description: "",
                embedding: "",
                type: "main",
                createTime: 1774447310118,
                updateTime: 1774447310118,
                state: -1
              },
              {
                id: "02848fb0dd582fd926502c77ecf9679c",
                md5: "7a8b6a311b015cd47bf17cc52b935348",
                path: "script_agent_supervision.md",
                name: "script_agent_supervision",
                description: "",
                embedding: "",
                type: "main",
                createTime: 1774447310118,
                updateTime: 1774447310118,
                state: -1
              },
              {
                id: "a1e818cc03a0b355b239ac1fb0512969",
                md5: "1fd22029e8047aa30b0dfd703cb837ed",
                path: "universal_agent.md",
                name: "universal_agent",
                description: "",
                embedding: "",
                type: "main",
                createTime: 1774447310118,
                updateTime: 1774447310118,
                state: -1
              },
              {
                id: "3e5efec258c8d8e6a39bcef12f8ee058",
                md5: "efccb0464cfd472861b49ebf737d4820",
                path: "references/event_extract.md",
                name: "event_extract",
                description: "\u4E13\u4E3A\u5C0F\u8BF4\u6539\u7F16\u77ED\u5267\u8BBE\u8BA1\u7684\u6587\u672C\u5206\u6790\u52A9\u624B\uFF0C\u9010\u7AE0\u63D0\u53D6\u6D89\u53CA\u89D2\u8272\u3001\u6838\u5FC3\u4E8B\u4EF6\u3001\u4E3B\u7EBF\u5173\u7CFB\u3001\u4FE1\u606F\u5BC6\u5EA6\u3001\u9884\u4F30\u96C6\u957F\u53CA\u60C5\u7EEA\u5F3A\u5EA6\u7B49\u7ED3\u6784\u5316\u4FE1\u606F\uFF0C\u4EE5Markdown\u8868\u683C\u5F62\u5F0F\u8F93\u51FA\uFF0C\u5E76\u9644\u6C47\u603B\u7EDF\u8BA1\uFF0C\u8F85\u52A9\u77ED\u5267\u5236\u4F5C\u7684\u5185\u5BB9\u89C4\u5212\u4E0E\u65F6\u957F\u4F30\u7B97\u3002",
                embedding: "",
                type: "references",
                createTime: 1774447310118,
                updateTime: 1774450165911,
                state: 1
              },
              {
                id: "52c51fa8655f899a1b7aae9b6aad7251",
                md5: "783678aaab829b34e7c30a414c356bf6",
                path: "references/novel_character_extract.md",
                name: "novel_character_extract",
                description: "\u4E13\u4E3A\u5C0F\u8BF4\u5185\u5BB9\u5206\u6790\u8BBE\u8BA1\u7684\u89D2\u8272\u63D0\u53D6\u52A9\u624B\uFF0C\u4ECE\u539F\u6587\u4E2D\u8BC6\u522B\u5E76\u7ED3\u6784\u5316\u8F93\u51FA\u6240\u6709\u91CD\u8981\u89D2\u8272\u7684\u89C6\u89C9\u63CF\u8FF0\u4FE1\u606F\uFF0C\u5305\u62EC\u5916\u8C8C\u3001\u670D\u9970\u3001\u4F53\u6001\u3001\u72B6\u6001\u53D8\u4F53\u7B49\u5B57\u6BB5\uFF0C\u4F9B\u7F8E\u672F\u5236\u4F5C\u548CAI\u89D2\u8272\u56FE\u751F\u6210\u4F7F\u7528\u3002",
                embedding: "",
                type: "references",
                createTime: 1774447310118,
                updateTime: 1774450080903,
                state: 1
              },
              {
                id: "6d46cdca10b2f49e07e515885d1387a0",
                md5: "10544d12c4ef011e6b3b63a99b8c7fa8",
                path: "references/novel_props_extract.md",
                name: "novel_props_extract",
                description: "\u4E13\u6CE8\u4E8E\u4ECE\u5C0F\u8BF4\u539F\u6587\u4E2D\u63D0\u53D6\u9053\u5177\u7269\u54C1\u4FE1\u606F\u7684\u5206\u6790\u52A9\u624B\uFF0C\u80FD\u8BC6\u522B\u6B66\u5668\u3001\u6CD5\u5668\u3001\u836F\u7269\u7B49\u5404\u7C7B\u9053\u5177\uFF0C\u751F\u6210\u5305\u542B\u5916\u89C2\u3001\u6750\u8D28\u3001\u5C3A\u5BF8\u3001\u529F\u80FD\u53CA\u72B6\u6001\u53D8\u4F53\u7684\u7ED3\u6784\u5316\u89C6\u89C9\u63CF\u8FF0\u8868\u683C\uFF0C\u4F9B\u7F8E\u672F\u5236\u4F5C\u548CAI\u7ED8\u56FE\u4F7F\u7528\u3002",
                embedding: "",
                type: "references",
                createTime: 1774447310118,
                updateTime: 1774450094771,
                state: 1
              },
              {
                id: "1864df75d1d65f76e275046649ecaef8",
                md5: "65603aa495a541f54c55b7f30e149f45",
                path: "references/novel_scene_extract.md",
                name: "novel_scene_extract",
                description: "\u4E13\u6CE8\u4E8E\u4ECE\u5C0F\u8BF4\u539F\u6587\u4E2D\u63D0\u53D6\u5E76\u7ED3\u6784\u5316\u573A\u666F\u4FE1\u606F\u7684\u5206\u6790\u52A9\u624B\uFF0C\u53EF\u8BC6\u522B\u5404\u7C7B\u573A\u666F\u5730\u70B9\uFF0C\u8F93\u51FA\u5305\u542B\u7A7A\u95F4\u63CF\u8FF0\u3001\u5149\u7167\u6C1B\u56F4\u3001\u5173\u952E\u9648\u8BBE\u3001\u8272\u8C03\u57FA\u8C03\u7B49\u5B57\u6BB5\u7684\u6807\u51C6\u5316\u573A\u666F\u8D44\u4EA7\u8868\uFF0C\u7528\u4E8E\u7F8E\u672F\u5236\u4F5C\u548CAI\u7ED8\u56FE\u7684\u573A\u666F\u6982\u5FF5\u56FE\u751F\u6210\u3002",
                embedding: "",
                type: "references",
                createTime: 1774447310118,
                updateTime: 1774450161878,
                state: 1
              },
              {
                id: "7fbce6f90d7d85496ba9817e9622e640",
                md5: "830559e8f2cd5d0fa8e6df48a164fe2d",
                path: "references/video_dialogue_extract.md",
                name: "video_dialogue_extract",
                description: "\u8FD9\u662F\u4E00\u4E2A\u4E13\u95E8\u4ECE\u89C6\u9891\u5206\u955C\u63D0\u793A\u8BCD\u4E2D\u63D0\u53D6\u7ED3\u6784\u5316\u53F0\u8BCD\u3001\u65C1\u767D\u4E0E\u97F3\u6548\u4FE1\u606F\u7684AI\u52A9\u624B\u914D\u7F6E\u6587\u6863\uFF0C\u5B9A\u4E49\u4E86\u5B8C\u6574\u7684\u8F93\u51FA\u683C\u5F0F\uFF08\u542B\u955C\u53F7\u3001\u89D2\u8272\u3001\u53F0\u8BCD\u7C7B\u578B\u3001\u8868\u6F14\u6307\u5BFC\u7B49\u5B57\u6BB5\uFF09\u3001\u63D0\u53D6\u89C4\u5219\u53CA\u5904\u7406\u6D41\u7A0B\uFF0C\u7528\u4E8E\u5C06\u89C6\u9891\u5206\u955C\u63CF\u8FF0\u8F6C\u5316\u4E3A\u6807\u51C6\u5316\u53F0\u8BCD\u8868\u3002",
                embedding: "",
                type: "references",
                createTime: 1774447310118,
                updateTime: 1774450180712,
                state: 1
              },
              {
                id: "31fb5c5a1f514ec1e66b4eba9f22d4db",
                md5: "43e63450efe0c9af8a3a40b036d36cb4",
                path: "references/pipeline.md",
                name: "pipeline",
                description: "\u9762\u5411\u77ED\u5267\u6539\u7F16\u9879\u76EE\u7684\u56DB\u9636\u6BB5\u6D41\u6C34\u7EBF\u8BF4\u660E\u6587\u6863\uFF0C\u6DB5\u76D6\u4E8B\u4EF6\u63D0\u53D6\u3001\u6545\u4E8B\u9AA8\u67B6\u3001\u6539\u7F16\u7B56\u7565\u3001\u5267\u672C\u7F16\u5199\u7684\u4E32\u884C\u6267\u884C\u6D41\u7A0B\uFF0C\u5B9A\u4E49\u4E86\u51B3\u7B56\u5C42\u3001\u6267\u884C\u5C42\u3001\u76D1\u7763\u5C42\u7684\u534F\u4F5C\u89C4\u8303\u53CA\u6D3E\u53D1\u3001\u5BA1\u6838\u3001\u4FEE\u590D\u7684\u4EA4\u4E92\u683C\u5F0F\u4E0E\u8D28\u91CF\u95E8\u63A7\u6807\u51C6\u3002",
                embedding: "",
                type: "references",
                createTime: 1774451946248,
                updateTime: 1774451984533,
                state: 1
              },
              {
                id: "27dc2dfc901de2180227d0269217583a",
                md5: "7d353be4bab7a794436d9abff2b9c6ee",
                path: "references/adaptation_format.md",
                name: "adaptation_format",
                description: "\u672C\u6587\u6863\u89C4\u5B9A\u4E86\u6539\u7F16\u7B56\u7565\u8F93\u51FA\u7684\u6807\u51C6\u683C\u5F0F\uFF0C\u5305\u62EC\u6838\u5FC3\u6539\u7F16\u539F\u5219\u3001\u5220\u9664\u51B3\u7B56\u548C\u4E16\u754C\u89C2\u5448\u73B0\u7B56\u7565\u4E09\u5927\u6A21\u5757\u7684\u4E66\u5199\u89C4\u8303\uFF0C\u660E\u786E\u5404\u6A21\u5757\u6240\u9700\u6DB5\u76D6\u7684\u7EF4\u5EA6\u4E0E\u8981\u7D20\uFF0C\u7528\u4E8E\u6307\u5BFC\u7AD6\u5C4F\u77ED\u5267\u7B49\u8F7D\u4F53\u7684\u6587\u5B66\u6539\u7F16\u5DE5\u4F5C\u3002",
                embedding: "",
                type: "references",
                createTime: 1774452010535,
                updateTime: 1774452022083,
                state: 1
              },
              {
                id: "d49fa09504fe784a8e6eb102756c6d56",
                md5: "2ef08a7479f29d74986999ceb02092c8",
                path: "references/event_format.md",
                name: "event_format",
                description: "\u672C\u6587\u6863\u89C4\u5B9A\u4E86\u5F71\u89C6\u6539\u7F16\u9879\u76EE\u4E2D\u4E8B\u4EF6\u8868\u7684\u6807\u51C6\u8F93\u51FA\u683C\u5F0F\uFF0C\u5305\u62EC\u6587\u4EF6\u5934\u3001\u4E8B\u4EF6\u8868\u683C\u3001\u5404\u5B57\u6BB5\u586B\u5199\u89C4\u8303\uFF08\u7AE0\u8282\u3001\u89D2\u8272\u3001\u6838\u5FC3\u4E8B\u4EF6\u3001\u4E3B\u7EBF\u5173\u7CFB\u3001\u60C5\u7EEA\u5F3A\u5EA6\u3001\u9884\u4F30\u65F6\u957F\uFF09\u53CA\u6C47\u603B\u7EDF\u8BA1\u6A21\u677F\uFF0C\u7528\u4E8E\u6307\u5BFC\u4ECE\u539F\u8457\u63D0\u53D6\u4E8B\u4EF6\u5E76\u8BC4\u4F30\u6539\u7F16\u96C6\u6570\u4E0E\u538B\u7F29\u6BD4\u7684\u7B2C\u4E00\u9636\u6BB5\u5DE5\u4F5C\u3002",
                embedding: "",
                type: "references",
                createTime: 1774452010535,
                updateTime: 1774452030858,
                state: 1
              },
              {
                id: "797906c2ddf0750f050bcdeae23eae3d",
                md5: "f5e7fe6db7e05db69d5dc327c4c538f2",
                path: "references/script_format.md",
                name: "script_format",
                description: "\u672C\u6587\u6863\u4E3A\u7AD6\u5C4F\u77ED\u5267\u5267\u672C\u7684\u8F93\u51FA\u683C\u5F0F\u89C4\u8303\uFF0C\u5B9A\u4E49\u4E86\u6587\u4EF6\u5934\u3001\u8282\u62CD\u7ED3\u6784\u3001\u5206\u955C\u811A\u672C\u3001\u753B\u9762\u63CF\u8FF0\u3001\u53F0\u8BCD\u3001\u8F6C\u573A\u6807\u6CE8\u7B49\u6807\u51C6\u683C\u5F0F\u8981\u6C42\uFF0C\u5E76\u9644\u6709\u65F6\u957F\u63A7\u5236\u53C2\u6570\u4E0E\u81EA\u67E5\u6E05\u5355\uFF0C\u4F9BAI\u89C6\u9891\u751F\u6210\u548C\u5BFC\u6F14\u5236\u4F5C\u4F7F\u7528\u3002",
                embedding: "",
                type: "references",
                createTime: 1774452010535,
                updateTime: 1774452042934,
                state: 1
              },
              {
                id: "1abd8675c0c3e62b20c0b151d2ec0fb1",
                md5: "a587532c737ce15022e1522021f099bb",
                path: "references/skeleton_format.md",
                name: "skeleton_format",
                description: "\u672C\u6587\u6863\u5B9A\u4E49\u4E86\u6545\u4E8B\u9AA8\u67B6\u6587\u4EF6\uFF08skeleton.md\uFF09\u7684\u6807\u51C6\u5316\u8F93\u51FA\u683C\u5F0F\uFF0C\u6DB5\u76D6\u6545\u4E8B\u6838\u3001\u4EBA\u7269\u6210\u957F\u9690\u7EBF\u3001\u4E09\u5E55\u7ED3\u6784\u3001\u5206\u96C6\u51B3\u7B56\u6A21\u677F\u3001\u5168\u5C40\u5220\u51CF\u8BB0\u5F55\u3001\u4ED8\u8D39\u5361\u70B9\u8BBE\u8BA1\u53CA\u81EA\u67E5\u6E05\u5355\uFF0C\u7528\u4E8E\u6307\u5BFC\u7F16\u5267\u5C06\u7AE0\u8282\u4E8B\u4EF6\u5217\u8868\u8F6C\u5316\u4E3A\u7ED3\u6784\u5B8C\u6574\u7684\u5267\u96C6\u6539\u7F16\u65B9\u6848\u3002",
                embedding: "",
                type: "references",
                createTime: 1774452010535,
                updateTime: 1774452057184,
                state: 1
              },
              {
                id: "0b7828d7a6ab458a4b201122f08d6c16",
                md5: "120b3c856f1b2a8a429e11319e8c95fe",
                path: "references/quality_criteria.md",
                name: "quality_criteria",
                description: "\u672C\u6587\u6863\u4E3A\u5F71\u89C6/\u77ED\u5267\u9879\u76EE\u7684\u8D28\u91CF\u5BA1\u6838\u6807\u51C6\u624B\u518C\uFF0C\u6DB5\u76D6\u4E8B\u4EF6\u8868\u3001\u6545\u4E8B\u9AA8\u67B6\u3001\u6539\u7F16\u7B56\u7565\u548C\u5267\u672C\u56DB\u5927\u6A21\u5757\u7684\u8BE6\u7EC6\u5BA1\u6838\u89C4\u5219\uFF0C\u89C4\u5B9A\u4E86\u683C\u5F0F\u89C4\u8303\u3001\u89D2\u8272\u540D\u79F0\u7EDF\u4E00\u3001\u65F6\u957F\u5408\u7406\u6027\u3001\u753B\u9762\u53EF\u6267\u884C\u6027\u53CA\u573A\u666F\u6C1B\u56F4\u4E00\u81F4\u6027\u7B49\u5BA1\u6838\u8981\u6C42\uFF0C\u7528\u4E8E\u786E\u4FDD\u5404\u9636\u6BB5\u4EA7\u51FA\u7269\u7684\u5185\u5BB9\u51C6\u786E\u6027\u4E0E\u5236\u4F5C\u53EF\u884C\u6027\u3002",
                embedding: "",
                type: "references",
                createTime: 1774452068093,
                updateTime: 1774452087877,
                state: 1
              },
              {
                id: "5c1772b5f9c420d9eae9ca02914ba087",
                md5: "c710ab7d237e1f0c5aa3d208e0f5b484",
                path: "references/plan.md",
                name: "plan",
                description: "\u8BE5\u6587\u6863\u5B9A\u4E49\u4E86AI\u4EE3\u7406\u751F\u6210\u6267\u884C\u8BA1\u5212\u7684\u89C4\u8303\uFF0C\u5305\u62EC\u4EFB\u52A1\u603B\u89C8\u3001\u6B65\u9AA4\u5217\u8868\uFF08\u542B\u7F16\u53F7\u3001\u540D\u79F0\u3001\u8BE6\u7EC6\u5185\u5BB9\u3001\u9884\u671F\u8F93\u51FA\u53CA\u4F9D\u8D56\u5173\u7CFB\uFF09\u548C\u6267\u884C\u987A\u5E8F\u6807\u6CE8\uFF0C\u5E76\u63D0\u4F9B\u6807\u51C6\u56DE\u590D\u6A21\u677F\uFF0C\u7528\u4E8E\u5C06\u7528\u6237\u9700\u6C42\u62C6\u89E3\u4E3A\u53EF\u76F4\u63A5\u4F20\u5165\u5B50\u4EE3\u7406\u5DE5\u5177\u6267\u884C\u7684\u5177\u4F53\u6B65\u9AA4\u3002",
                embedding: "",
                type: "references",
                createTime: 1774452098447,
                updateTime: 1774452109574,
                state: 1
              },
              {
                id: "75a45cf996015ca819582873887ec301",
                md5: "6045d76873fd58b8b87a914a21a38439",
                path: "references/derive_assets_extraction.md",
                name: "derive_assets_extraction",
                description: "\u672C\u6587\u6863\u662F\u4E00\u4EFD\u6280\u672F\u64CD\u4F5C\u6307\u5357\uFF0C\u8BF4\u660E\u5982\u4F55\u6839\u636E\u5267\u672C\u5185\u5BB9\u548C\u5DF2\u6709\u8D44\u4EA7\u5217\u8868\uFF0C\u63D0\u53D6\u6BCF\u4E2A\u8D44\u4EA7\u5728\u5267\u60C5\u4E2D\u51FA\u73B0\u7684\u4E0D\u540C\u89C6\u89C9\u72B6\u6001\u53D8\u4F53\uFF08derive\uFF09\uFF0C\u5E76\u901A\u8FC7\u5DE5\u5177\u51FD\u6570\u8BFB\u53D6\u548C\u5199\u5165\u6570\u636E\uFF0C\u7528\u4E8E\u540E\u7EED\u56FE\u7247\u751F\u6210\u53C2\u8003\u3002",
                embedding: "",
                type: "references",
                createTime: 1774452119499,
                updateTime: 1774452129516,
                state: 1
              },
              {
                id: "fce75f69d704c19bebcb356bc1bd6e81",
                md5: "a3b3432854970f22949ba47236a6532f",
                path: "references/storyboard_generation.md",
                name: "storyboard_generation",
                description: "\u6839\u636E\u5267\u672C\u548C\u8D44\u4EA7\u5217\u8868\u751F\u6210\u7ED3\u6784\u5316\u5206\u955C\u9762\u677F\u7684\u5DE5\u5177\u6307\u5357\uFF0C\u6DB5\u76D6\u5206\u955C\u62C6\u5206\u539F\u5219\u3001\u5B57\u6BB5\u586B\u5199\u89C4\u8303\u53CA\u5DE5\u5177\u8C03\u7528\u6D41\u7A0B\uFF0C\u7528\u4E8E\u5C06\u5267\u672C\u8F6C\u5316\u4E3A\u542B\u753B\u9762\u63CF\u8FF0\u3001\u955C\u5934\u8BED\u8A00\u3001\u53F0\u8BCD\u548CAI\u7ED8\u56FE\u63D0\u793A\u8BCD\u7684\u5206\u955C\u6570\u636E\u3002",
                embedding: "",
                type: "references",
                createTime: 1774452119499,
                updateTime: 1774452140873,
                state: 1
              }
            ];
            await Promise.all(
              list2.map(async (item) => {
                const embedding = await getEmbedding(item.description);
                item.embedding = JSON.stringify(embedding);
              })
            );
            await knex4("o_skillList").insert(list2);
          }
        },
        {
          name: "o_skillAttribution",
          builder: (table) => {
            table.text("skillId").notNullable().references("id").inTable("o_skillList").onDelete("CASCADE");
            table.text("attribution").notNullable();
            table.primary(["skillId", "attribution"]);
            table.index(["attribution"]);
          },
          initData: async (knex4) => {
            await knex4("o_skillAttribution").insert([
              {
                skillId: "52c51fa8655f899a1b7aae9b6aad7251",
                attribution: "universal_agent.md"
              },
              {
                skillId: "6d46cdca10b2f49e07e515885d1387a0",
                attribution: "universal_agent.md"
              },
              {
                skillId: "1864df75d1d65f76e275046649ecaef8",
                attribution: "universal_agent.md"
              },
              {
                skillId: "3e5efec258c8d8e6a39bcef12f8ee058",
                attribution: "universal_agent.md"
              },
              {
                skillId: "7fbce6f90d7d85496ba9817e9622e640",
                attribution: "universal_agent.md"
              },
              {
                skillId: "31fb5c5a1f514ec1e66b4eba9f22d4db",
                attribution: "script_agent_decision.md"
              },
              {
                skillId: "27dc2dfc901de2180227d0269217583a",
                attribution: "script_agent_execution.md"
              },
              {
                skillId: "d49fa09504fe784a8e6eb102756c6d56",
                attribution: "script_agent_execution.md"
              },
              {
                skillId: "797906c2ddf0750f050bcdeae23eae3d",
                attribution: "script_agent_execution.md"
              },
              {
                skillId: "1abd8675c0c3e62b20c0b151d2ec0fb1",
                attribution: "script_agent_execution.md"
              },
              {
                skillId: "0b7828d7a6ab458a4b201122f08d6c16",
                attribution: "script_agent_supervision.md"
              },
              {
                skillId: "5c1772b5f9c420d9eae9ca02914ba087",
                attribution: "production_agent_decision.md"
              },
              {
                skillId: "75a45cf996015ca819582873887ec301",
                attribution: "production_agent_execution.md"
              },
              {
                skillId: "fce75f69d704c19bebcb356bc1bd6e81",
                attribution: "production_agent_execution.md"
              }
            ]);
          }
        },
        //记忆表（message=原始消息, summary=压缩摘要）
        {
          name: "memories",
          builder: (table) => {
            table.text("id").notNullable();
            table.text("isolationKey").notNullable();
            table.text("type").notNullable();
            table.text("role");
            table.text("name");
            table.text("content").notNullable();
            table.text("embedding");
            table.text("relatedMessageIds");
            table.integer("summarized").defaultTo(0);
            table.integer("createTime").notNullable();
            table.primary(["id"]);
            table.index(["isolationKey", "type"]);
            table.index(["isolationKey", "summarized"]);
          }
        },
        {
          name: "o_assetsRole2Audio",
          builder: (table) => {
            table.integer("assetsRoleId").notNullable();
            table.integer("assetsAudioId").notNullable();
            table.primary(["assetsAudioId", "assetsRoleId"]);
            table.unique(["assetsAudioId", "assetsRoleId"]);
          }
        }
      ];
      for (const t of tables) {
        const tableExists = await knex3.schema.hasTable(t.name);
        if (!tableExists || forceInit) {
          if (tableExists && forceInit) {
            await knex3.schema.dropTable(t.name);
            console.log("[\u521D\u59CB\u5316\u6570\u636E\u5E93] \u5DF2\u5B58\u5728\u8868\u5220\u9664\u5E76\u91CD\u5EFA:", t.name);
          } else {
            console.log("[\u521D\u59CB\u5316\u6570\u636E\u5E93] \u521B\u5EFA\u6570\u636E\u8868:", t.name);
          }
          await knex3.schema.createTable(t.name, t.builder);
          if (t.initData) {
            await t.initData(knex3);
            console.log("[\u521D\u59CB\u5316\u6570\u636E\u5E93] \u8868\u6570\u636E\u521D\u59CB\u5316:", t.name);
          }
        }
      }
    };
  }
});

// node_modules/sucrase/dist/parser/tokenizer/keywords.js
var require_keywords = __commonJS({
  "node_modules/sucrase/dist/parser/tokenizer/keywords.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var ContextualKeyword;
    (function(ContextualKeyword2) {
      const NONE = 0;
      ContextualKeyword2[ContextualKeyword2["NONE"] = NONE] = "NONE";
      const _abstract = NONE + 1;
      ContextualKeyword2[ContextualKeyword2["_abstract"] = _abstract] = "_abstract";
      const _accessor = _abstract + 1;
      ContextualKeyword2[ContextualKeyword2["_accessor"] = _accessor] = "_accessor";
      const _as = _accessor + 1;
      ContextualKeyword2[ContextualKeyword2["_as"] = _as] = "_as";
      const _assert = _as + 1;
      ContextualKeyword2[ContextualKeyword2["_assert"] = _assert] = "_assert";
      const _asserts = _assert + 1;
      ContextualKeyword2[ContextualKeyword2["_asserts"] = _asserts] = "_asserts";
      const _async = _asserts + 1;
      ContextualKeyword2[ContextualKeyword2["_async"] = _async] = "_async";
      const _await = _async + 1;
      ContextualKeyword2[ContextualKeyword2["_await"] = _await] = "_await";
      const _checks = _await + 1;
      ContextualKeyword2[ContextualKeyword2["_checks"] = _checks] = "_checks";
      const _constructor = _checks + 1;
      ContextualKeyword2[ContextualKeyword2["_constructor"] = _constructor] = "_constructor";
      const _declare = _constructor + 1;
      ContextualKeyword2[ContextualKeyword2["_declare"] = _declare] = "_declare";
      const _enum4 = _declare + 1;
      ContextualKeyword2[ContextualKeyword2["_enum"] = _enum4] = "_enum";
      const _exports = _enum4 + 1;
      ContextualKeyword2[ContextualKeyword2["_exports"] = _exports] = "_exports";
      const _from = _exports + 1;
      ContextualKeyword2[ContextualKeyword2["_from"] = _from] = "_from";
      const _get = _from + 1;
      ContextualKeyword2[ContextualKeyword2["_get"] = _get] = "_get";
      const _global3 = _get + 1;
      ContextualKeyword2[ContextualKeyword2["_global"] = _global3] = "_global";
      const _implements = _global3 + 1;
      ContextualKeyword2[ContextualKeyword2["_implements"] = _implements] = "_implements";
      const _infer = _implements + 1;
      ContextualKeyword2[ContextualKeyword2["_infer"] = _infer] = "_infer";
      const _interface = _infer + 1;
      ContextualKeyword2[ContextualKeyword2["_interface"] = _interface] = "_interface";
      const _is = _interface + 1;
      ContextualKeyword2[ContextualKeyword2["_is"] = _is] = "_is";
      const _keyof = _is + 1;
      ContextualKeyword2[ContextualKeyword2["_keyof"] = _keyof] = "_keyof";
      const _mixins = _keyof + 1;
      ContextualKeyword2[ContextualKeyword2["_mixins"] = _mixins] = "_mixins";
      const _module = _mixins + 1;
      ContextualKeyword2[ContextualKeyword2["_module"] = _module] = "_module";
      const _namespace = _module + 1;
      ContextualKeyword2[ContextualKeyword2["_namespace"] = _namespace] = "_namespace";
      const _of = _namespace + 1;
      ContextualKeyword2[ContextualKeyword2["_of"] = _of] = "_of";
      const _opaque = _of + 1;
      ContextualKeyword2[ContextualKeyword2["_opaque"] = _opaque] = "_opaque";
      const _out = _opaque + 1;
      ContextualKeyword2[ContextualKeyword2["_out"] = _out] = "_out";
      const _override = _out + 1;
      ContextualKeyword2[ContextualKeyword2["_override"] = _override] = "_override";
      const _private = _override + 1;
      ContextualKeyword2[ContextualKeyword2["_private"] = _private] = "_private";
      const _protected = _private + 1;
      ContextualKeyword2[ContextualKeyword2["_protected"] = _protected] = "_protected";
      const _proto = _protected + 1;
      ContextualKeyword2[ContextualKeyword2["_proto"] = _proto] = "_proto";
      const _public = _proto + 1;
      ContextualKeyword2[ContextualKeyword2["_public"] = _public] = "_public";
      const _readonly3 = _public + 1;
      ContextualKeyword2[ContextualKeyword2["_readonly"] = _readonly3] = "_readonly";
      const _require = _readonly3 + 1;
      ContextualKeyword2[ContextualKeyword2["_require"] = _require] = "_require";
      const _satisfies = _require + 1;
      ContextualKeyword2[ContextualKeyword2["_satisfies"] = _satisfies] = "_satisfies";
      const _set3 = _satisfies + 1;
      ContextualKeyword2[ContextualKeyword2["_set"] = _set3] = "_set";
      const _static = _set3 + 1;
      ContextualKeyword2[ContextualKeyword2["_static"] = _static] = "_static";
      const _symbol3 = _static + 1;
      ContextualKeyword2[ContextualKeyword2["_symbol"] = _symbol3] = "_symbol";
      const _type = _symbol3 + 1;
      ContextualKeyword2[ContextualKeyword2["_type"] = _type] = "_type";
      const _unique = _type + 1;
      ContextualKeyword2[ContextualKeyword2["_unique"] = _unique] = "_unique";
      const _using = _unique + 1;
      ContextualKeyword2[ContextualKeyword2["_using"] = _using] = "_using";
    })(ContextualKeyword || (exports2.ContextualKeyword = ContextualKeyword = {}));
  }
});

// node_modules/sucrase/dist/parser/tokenizer/types.js
var require_types = __commonJS({
  "node_modules/sucrase/dist/parser/tokenizer/types.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var TokenType;
    (function(TokenType2) {
      const PRECEDENCE_MASK = 15;
      TokenType2[TokenType2["PRECEDENCE_MASK"] = PRECEDENCE_MASK] = "PRECEDENCE_MASK";
      const IS_KEYWORD = 1 << 4;
      TokenType2[TokenType2["IS_KEYWORD"] = IS_KEYWORD] = "IS_KEYWORD";
      const IS_ASSIGN = 1 << 5;
      TokenType2[TokenType2["IS_ASSIGN"] = IS_ASSIGN] = "IS_ASSIGN";
      const IS_RIGHT_ASSOCIATIVE = 1 << 6;
      TokenType2[TokenType2["IS_RIGHT_ASSOCIATIVE"] = IS_RIGHT_ASSOCIATIVE] = "IS_RIGHT_ASSOCIATIVE";
      const IS_PREFIX = 1 << 7;
      TokenType2[TokenType2["IS_PREFIX"] = IS_PREFIX] = "IS_PREFIX";
      const IS_POSTFIX = 1 << 8;
      TokenType2[TokenType2["IS_POSTFIX"] = IS_POSTFIX] = "IS_POSTFIX";
      const IS_EXPRESSION_START = 1 << 9;
      TokenType2[TokenType2["IS_EXPRESSION_START"] = IS_EXPRESSION_START] = "IS_EXPRESSION_START";
      const num = 512;
      TokenType2[TokenType2["num"] = num] = "num";
      const bigint5 = 1536;
      TokenType2[TokenType2["bigint"] = bigint5] = "bigint";
      const decimal = 2560;
      TokenType2[TokenType2["decimal"] = decimal] = "decimal";
      const regexp = 3584;
      TokenType2[TokenType2["regexp"] = regexp] = "regexp";
      const string5 = 4608;
      TokenType2[TokenType2["string"] = string5] = "string";
      const name28 = 5632;
      TokenType2[TokenType2["name"] = name28] = "name";
      const eof = 6144;
      TokenType2[TokenType2["eof"] = eof] = "eof";
      const bracketL = 7680;
      TokenType2[TokenType2["bracketL"] = bracketL] = "bracketL";
      const bracketR = 8192;
      TokenType2[TokenType2["bracketR"] = bracketR] = "bracketR";
      const braceL = 9728;
      TokenType2[TokenType2["braceL"] = braceL] = "braceL";
      const braceBarL = 10752;
      TokenType2[TokenType2["braceBarL"] = braceBarL] = "braceBarL";
      const braceR = 11264;
      TokenType2[TokenType2["braceR"] = braceR] = "braceR";
      const braceBarR = 12288;
      TokenType2[TokenType2["braceBarR"] = braceBarR] = "braceBarR";
      const parenL = 13824;
      TokenType2[TokenType2["parenL"] = parenL] = "parenL";
      const parenR = 14336;
      TokenType2[TokenType2["parenR"] = parenR] = "parenR";
      const comma = 15360;
      TokenType2[TokenType2["comma"] = comma] = "comma";
      const semi = 16384;
      TokenType2[TokenType2["semi"] = semi] = "semi";
      const colon = 17408;
      TokenType2[TokenType2["colon"] = colon] = "colon";
      const doubleColon = 18432;
      TokenType2[TokenType2["doubleColon"] = doubleColon] = "doubleColon";
      const dot = 19456;
      TokenType2[TokenType2["dot"] = dot] = "dot";
      const question = 20480;
      TokenType2[TokenType2["question"] = question] = "question";
      const questionDot = 21504;
      TokenType2[TokenType2["questionDot"] = questionDot] = "questionDot";
      const arrow = 22528;
      TokenType2[TokenType2["arrow"] = arrow] = "arrow";
      const template = 23552;
      TokenType2[TokenType2["template"] = template] = "template";
      const ellipsis = 24576;
      TokenType2[TokenType2["ellipsis"] = ellipsis] = "ellipsis";
      const backQuote = 25600;
      TokenType2[TokenType2["backQuote"] = backQuote] = "backQuote";
      const dollarBraceL = 27136;
      TokenType2[TokenType2["dollarBraceL"] = dollarBraceL] = "dollarBraceL";
      const at = 27648;
      TokenType2[TokenType2["at"] = at] = "at";
      const hash3 = 29184;
      TokenType2[TokenType2["hash"] = hash3] = "hash";
      const eq2 = 29728;
      TokenType2[TokenType2["eq"] = eq2] = "eq";
      const assign = 30752;
      TokenType2[TokenType2["assign"] = assign] = "assign";
      const preIncDec = 32640;
      TokenType2[TokenType2["preIncDec"] = preIncDec] = "preIncDec";
      const postIncDec = 33664;
      TokenType2[TokenType2["postIncDec"] = postIncDec] = "postIncDec";
      const bang = 34432;
      TokenType2[TokenType2["bang"] = bang] = "bang";
      const tilde = 35456;
      TokenType2[TokenType2["tilde"] = tilde] = "tilde";
      const pipeline2 = 35841;
      TokenType2[TokenType2["pipeline"] = pipeline2] = "pipeline";
      const nullishCoalescing = 36866;
      TokenType2[TokenType2["nullishCoalescing"] = nullishCoalescing] = "nullishCoalescing";
      const logicalOR = 37890;
      TokenType2[TokenType2["logicalOR"] = logicalOR] = "logicalOR";
      const logicalAND = 38915;
      TokenType2[TokenType2["logicalAND"] = logicalAND] = "logicalAND";
      const bitwiseOR = 39940;
      TokenType2[TokenType2["bitwiseOR"] = bitwiseOR] = "bitwiseOR";
      const bitwiseXOR = 40965;
      TokenType2[TokenType2["bitwiseXOR"] = bitwiseXOR] = "bitwiseXOR";
      const bitwiseAND = 41990;
      TokenType2[TokenType2["bitwiseAND"] = bitwiseAND] = "bitwiseAND";
      const equality = 43015;
      TokenType2[TokenType2["equality"] = equality] = "equality";
      const lessThan = 44040;
      TokenType2[TokenType2["lessThan"] = lessThan] = "lessThan";
      const greaterThan = 45064;
      TokenType2[TokenType2["greaterThan"] = greaterThan] = "greaterThan";
      const relationalOrEqual = 46088;
      TokenType2[TokenType2["relationalOrEqual"] = relationalOrEqual] = "relationalOrEqual";
      const bitShiftL = 47113;
      TokenType2[TokenType2["bitShiftL"] = bitShiftL] = "bitShiftL";
      const bitShiftR = 48137;
      TokenType2[TokenType2["bitShiftR"] = bitShiftR] = "bitShiftR";
      const plus = 49802;
      TokenType2[TokenType2["plus"] = plus] = "plus";
      const minus = 50826;
      TokenType2[TokenType2["minus"] = minus] = "minus";
      const modulo = 51723;
      TokenType2[TokenType2["modulo"] = modulo] = "modulo";
      const star = 52235;
      TokenType2[TokenType2["star"] = star] = "star";
      const slash = 53259;
      TokenType2[TokenType2["slash"] = slash] = "slash";
      const exponent = 54348;
      TokenType2[TokenType2["exponent"] = exponent] = "exponent";
      const jsxName = 55296;
      TokenType2[TokenType2["jsxName"] = jsxName] = "jsxName";
      const jsxText = 56320;
      TokenType2[TokenType2["jsxText"] = jsxText] = "jsxText";
      const jsxEmptyText = 57344;
      TokenType2[TokenType2["jsxEmptyText"] = jsxEmptyText] = "jsxEmptyText";
      const jsxTagStart = 58880;
      TokenType2[TokenType2["jsxTagStart"] = jsxTagStart] = "jsxTagStart";
      const jsxTagEnd = 59392;
      TokenType2[TokenType2["jsxTagEnd"] = jsxTagEnd] = "jsxTagEnd";
      const typeParameterStart = 60928;
      TokenType2[TokenType2["typeParameterStart"] = typeParameterStart] = "typeParameterStart";
      const nonNullAssertion = 61440;
      TokenType2[TokenType2["nonNullAssertion"] = nonNullAssertion] = "nonNullAssertion";
      const _break = 62480;
      TokenType2[TokenType2["_break"] = _break] = "_break";
      const _case = 63504;
      TokenType2[TokenType2["_case"] = _case] = "_case";
      const _catch4 = 64528;
      TokenType2[TokenType2["_catch"] = _catch4] = "_catch";
      const _continue = 65552;
      TokenType2[TokenType2["_continue"] = _continue] = "_continue";
      const _debugger = 66576;
      TokenType2[TokenType2["_debugger"] = _debugger] = "_debugger";
      const _default4 = 67600;
      TokenType2[TokenType2["_default"] = _default4] = "_default";
      const _do = 68624;
      TokenType2[TokenType2["_do"] = _do] = "_do";
      const _else = 69648;
      TokenType2[TokenType2["_else"] = _else] = "_else";
      const _finally = 70672;
      TokenType2[TokenType2["_finally"] = _finally] = "_finally";
      const _for = 71696;
      TokenType2[TokenType2["_for"] = _for] = "_for";
      const _function3 = 73232;
      TokenType2[TokenType2["_function"] = _function3] = "_function";
      const _if = 73744;
      TokenType2[TokenType2["_if"] = _if] = "_if";
      const _return = 74768;
      TokenType2[TokenType2["_return"] = _return] = "_return";
      const _switch = 75792;
      TokenType2[TokenType2["_switch"] = _switch] = "_switch";
      const _throw = 77456;
      TokenType2[TokenType2["_throw"] = _throw] = "_throw";
      const _try = 77840;
      TokenType2[TokenType2["_try"] = _try] = "_try";
      const _var = 78864;
      TokenType2[TokenType2["_var"] = _var] = "_var";
      const _let = 79888;
      TokenType2[TokenType2["_let"] = _let] = "_let";
      const _const = 80912;
      TokenType2[TokenType2["_const"] = _const] = "_const";
      const _while = 81936;
      TokenType2[TokenType2["_while"] = _while] = "_while";
      const _with = 82960;
      TokenType2[TokenType2["_with"] = _with] = "_with";
      const _new = 84496;
      TokenType2[TokenType2["_new"] = _new] = "_new";
      const _this = 85520;
      TokenType2[TokenType2["_this"] = _this] = "_this";
      const _super = 86544;
      TokenType2[TokenType2["_super"] = _super] = "_super";
      const _class = 87568;
      TokenType2[TokenType2["_class"] = _class] = "_class";
      const _extends = 88080;
      TokenType2[TokenType2["_extends"] = _extends] = "_extends";
      const _export = 89104;
      TokenType2[TokenType2["_export"] = _export] = "_export";
      const _import = 90640;
      TokenType2[TokenType2["_import"] = _import] = "_import";
      const _yield = 91664;
      TokenType2[TokenType2["_yield"] = _yield] = "_yield";
      const _null5 = 92688;
      TokenType2[TokenType2["_null"] = _null5] = "_null";
      const _true = 93712;
      TokenType2[TokenType2["_true"] = _true] = "_true";
      const _false = 94736;
      TokenType2[TokenType2["_false"] = _false] = "_false";
      const _in = 95256;
      TokenType2[TokenType2["_in"] = _in] = "_in";
      const _instanceof3 = 96280;
      TokenType2[TokenType2["_instanceof"] = _instanceof3] = "_instanceof";
      const _typeof = 97936;
      TokenType2[TokenType2["_typeof"] = _typeof] = "_typeof";
      const _void4 = 98960;
      TokenType2[TokenType2["_void"] = _void4] = "_void";
      const _delete = 99984;
      TokenType2[TokenType2["_delete"] = _delete] = "_delete";
      const _async = 100880;
      TokenType2[TokenType2["_async"] = _async] = "_async";
      const _get = 101904;
      TokenType2[TokenType2["_get"] = _get] = "_get";
      const _set3 = 102928;
      TokenType2[TokenType2["_set"] = _set3] = "_set";
      const _declare = 103952;
      TokenType2[TokenType2["_declare"] = _declare] = "_declare";
      const _readonly3 = 104976;
      TokenType2[TokenType2["_readonly"] = _readonly3] = "_readonly";
      const _abstract = 106e3;
      TokenType2[TokenType2["_abstract"] = _abstract] = "_abstract";
      const _static = 107024;
      TokenType2[TokenType2["_static"] = _static] = "_static";
      const _public = 107536;
      TokenType2[TokenType2["_public"] = _public] = "_public";
      const _private = 108560;
      TokenType2[TokenType2["_private"] = _private] = "_private";
      const _protected = 109584;
      TokenType2[TokenType2["_protected"] = _protected] = "_protected";
      const _override = 110608;
      TokenType2[TokenType2["_override"] = _override] = "_override";
      const _as = 112144;
      TokenType2[TokenType2["_as"] = _as] = "_as";
      const _enum4 = 113168;
      TokenType2[TokenType2["_enum"] = _enum4] = "_enum";
      const _type = 114192;
      TokenType2[TokenType2["_type"] = _type] = "_type";
      const _implements = 115216;
      TokenType2[TokenType2["_implements"] = _implements] = "_implements";
    })(TokenType || (exports2.TokenType = TokenType = {}));
    function formatTokenType(tokenType) {
      switch (tokenType) {
        case TokenType.num:
          return "num";
        case TokenType.bigint:
          return "bigint";
        case TokenType.decimal:
          return "decimal";
        case TokenType.regexp:
          return "regexp";
        case TokenType.string:
          return "string";
        case TokenType.name:
          return "name";
        case TokenType.eof:
          return "eof";
        case TokenType.bracketL:
          return "[";
        case TokenType.bracketR:
          return "]";
        case TokenType.braceL:
          return "{";
        case TokenType.braceBarL:
          return "{|";
        case TokenType.braceR:
          return "}";
        case TokenType.braceBarR:
          return "|}";
        case TokenType.parenL:
          return "(";
        case TokenType.parenR:
          return ")";
        case TokenType.comma:
          return ",";
        case TokenType.semi:
          return ";";
        case TokenType.colon:
          return ":";
        case TokenType.doubleColon:
          return "::";
        case TokenType.dot:
          return ".";
        case TokenType.question:
          return "?";
        case TokenType.questionDot:
          return "?.";
        case TokenType.arrow:
          return "=>";
        case TokenType.template:
          return "template";
        case TokenType.ellipsis:
          return "...";
        case TokenType.backQuote:
          return "`";
        case TokenType.dollarBraceL:
          return "${";
        case TokenType.at:
          return "@";
        case TokenType.hash:
          return "#";
        case TokenType.eq:
          return "=";
        case TokenType.assign:
          return "_=";
        case TokenType.preIncDec:
          return "++/--";
        case TokenType.postIncDec:
          return "++/--";
        case TokenType.bang:
          return "!";
        case TokenType.tilde:
          return "~";
        case TokenType.pipeline:
          return "|>";
        case TokenType.nullishCoalescing:
          return "??";
        case TokenType.logicalOR:
          return "||";
        case TokenType.logicalAND:
          return "&&";
        case TokenType.bitwiseOR:
          return "|";
        case TokenType.bitwiseXOR:
          return "^";
        case TokenType.bitwiseAND:
          return "&";
        case TokenType.equality:
          return "==/!=";
        case TokenType.lessThan:
          return "<";
        case TokenType.greaterThan:
          return ">";
        case TokenType.relationalOrEqual:
          return "<=/>=";
        case TokenType.bitShiftL:
          return "<<";
        case TokenType.bitShiftR:
          return ">>/>>>";
        case TokenType.plus:
          return "+";
        case TokenType.minus:
          return "-";
        case TokenType.modulo:
          return "%";
        case TokenType.star:
          return "*";
        case TokenType.slash:
          return "/";
        case TokenType.exponent:
          return "**";
        case TokenType.jsxName:
          return "jsxName";
        case TokenType.jsxText:
          return "jsxText";
        case TokenType.jsxEmptyText:
          return "jsxEmptyText";
        case TokenType.jsxTagStart:
          return "jsxTagStart";
        case TokenType.jsxTagEnd:
          return "jsxTagEnd";
        case TokenType.typeParameterStart:
          return "typeParameterStart";
        case TokenType.nonNullAssertion:
          return "nonNullAssertion";
        case TokenType._break:
          return "break";
        case TokenType._case:
          return "case";
        case TokenType._catch:
          return "catch";
        case TokenType._continue:
          return "continue";
        case TokenType._debugger:
          return "debugger";
        case TokenType._default:
          return "default";
        case TokenType._do:
          return "do";
        case TokenType._else:
          return "else";
        case TokenType._finally:
          return "finally";
        case TokenType._for:
          return "for";
        case TokenType._function:
          return "function";
        case TokenType._if:
          return "if";
        case TokenType._return:
          return "return";
        case TokenType._switch:
          return "switch";
        case TokenType._throw:
          return "throw";
        case TokenType._try:
          return "try";
        case TokenType._var:
          return "var";
        case TokenType._let:
          return "let";
        case TokenType._const:
          return "const";
        case TokenType._while:
          return "while";
        case TokenType._with:
          return "with";
        case TokenType._new:
          return "new";
        case TokenType._this:
          return "this";
        case TokenType._super:
          return "super";
        case TokenType._class:
          return "class";
        case TokenType._extends:
          return "extends";
        case TokenType._export:
          return "export";
        case TokenType._import:
          return "import";
        case TokenType._yield:
          return "yield";
        case TokenType._null:
          return "null";
        case TokenType._true:
          return "true";
        case TokenType._false:
          return "false";
        case TokenType._in:
          return "in";
        case TokenType._instanceof:
          return "instanceof";
        case TokenType._typeof:
          return "typeof";
        case TokenType._void:
          return "void";
        case TokenType._delete:
          return "delete";
        case TokenType._async:
          return "async";
        case TokenType._get:
          return "get";
        case TokenType._set:
          return "set";
        case TokenType._declare:
          return "declare";
        case TokenType._readonly:
          return "readonly";
        case TokenType._abstract:
          return "abstract";
        case TokenType._static:
          return "static";
        case TokenType._public:
          return "public";
        case TokenType._private:
          return "private";
        case TokenType._protected:
          return "protected";
        case TokenType._override:
          return "override";
        case TokenType._as:
          return "as";
        case TokenType._enum:
          return "enum";
        case TokenType._type:
          return "type";
        case TokenType._implements:
          return "implements";
        default:
          return "";
      }
    }
    exports2.formatTokenType = formatTokenType;
  }
});

// node_modules/sucrase/dist/parser/tokenizer/state.js
var require_state = __commonJS({
  "node_modules/sucrase/dist/parser/tokenizer/state.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _keywords = require_keywords();
    var _types = require_types();
    var Scope = class {
      constructor(startTokenIndex, endTokenIndex, isFunctionScope) {
        this.startTokenIndex = startTokenIndex;
        this.endTokenIndex = endTokenIndex;
        this.isFunctionScope = isFunctionScope;
      }
    };
    exports2.Scope = Scope;
    var StateSnapshot = class {
      constructor(potentialArrowAt, noAnonFunctionType, inDisallowConditionalTypesContext, tokensLength, scopesLength, pos, type, contextualKeyword, start, end, isType, scopeDepth, error73) {
        ;
        this.potentialArrowAt = potentialArrowAt;
        this.noAnonFunctionType = noAnonFunctionType;
        this.inDisallowConditionalTypesContext = inDisallowConditionalTypesContext;
        this.tokensLength = tokensLength;
        this.scopesLength = scopesLength;
        this.pos = pos;
        this.type = type;
        this.contextualKeyword = contextualKeyword;
        this.start = start;
        this.end = end;
        this.isType = isType;
        this.scopeDepth = scopeDepth;
        this.error = error73;
      }
    };
    exports2.StateSnapshot = StateSnapshot;
    var State = class _State {
      constructor() {
        _State.prototype.__init.call(this);
        _State.prototype.__init2.call(this);
        _State.prototype.__init3.call(this);
        _State.prototype.__init4.call(this);
        _State.prototype.__init5.call(this);
        _State.prototype.__init6.call(this);
        _State.prototype.__init7.call(this);
        _State.prototype.__init8.call(this);
        _State.prototype.__init9.call(this);
        _State.prototype.__init10.call(this);
        _State.prototype.__init11.call(this);
        _State.prototype.__init12.call(this);
        _State.prototype.__init13.call(this);
      }
      // Used to signify the start of a potential arrow function
      __init() {
        this.potentialArrowAt = -1;
      }
      // Used by Flow to handle an edge case involving function type parsing.
      __init2() {
        this.noAnonFunctionType = false;
      }
      // Used by TypeScript to handle ambiguities when parsing conditional types.
      __init3() {
        this.inDisallowConditionalTypesContext = false;
      }
      // Token store.
      __init4() {
        this.tokens = [];
      }
      // Array of all observed scopes, ordered by their ending position.
      __init5() {
        this.scopes = [];
      }
      // The current position of the tokenizer in the input.
      __init6() {
        this.pos = 0;
      }
      // Information about the current token.
      __init7() {
        this.type = _types.TokenType.eof;
      }
      __init8() {
        this.contextualKeyword = _keywords.ContextualKeyword.NONE;
      }
      __init9() {
        this.start = 0;
      }
      __init10() {
        this.end = 0;
      }
      __init11() {
        this.isType = false;
      }
      __init12() {
        this.scopeDepth = 0;
      }
      /**
       * If the parser is in an error state, then the token is always tt.eof and all functions can
       * keep executing but should be written so they don't get into an infinite loop in this situation.
       *
       * This approach, combined with the ability to snapshot and restore state, allows us to implement
       * backtracking without exceptions and without needing to explicitly propagate error states
       * everywhere.
       */
      __init13() {
        this.error = null;
      }
      snapshot() {
        return new StateSnapshot(
          this.potentialArrowAt,
          this.noAnonFunctionType,
          this.inDisallowConditionalTypesContext,
          this.tokens.length,
          this.scopes.length,
          this.pos,
          this.type,
          this.contextualKeyword,
          this.start,
          this.end,
          this.isType,
          this.scopeDepth,
          this.error
        );
      }
      restoreFromSnapshot(snapshot) {
        this.potentialArrowAt = snapshot.potentialArrowAt;
        this.noAnonFunctionType = snapshot.noAnonFunctionType;
        this.inDisallowConditionalTypesContext = snapshot.inDisallowConditionalTypesContext;
        this.tokens.length = snapshot.tokensLength;
        this.scopes.length = snapshot.scopesLength;
        this.pos = snapshot.pos;
        this.type = snapshot.type;
        this.contextualKeyword = snapshot.contextualKeyword;
        this.start = snapshot.start;
        this.end = snapshot.end;
        this.isType = snapshot.isType;
        this.scopeDepth = snapshot.scopeDepth;
        this.error = snapshot.error;
      }
    };
    exports2.default = State;
  }
});

// node_modules/sucrase/dist/parser/util/charcodes.js
var require_charcodes = __commonJS({
  "node_modules/sucrase/dist/parser/util/charcodes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var charCodes;
    (function(charCodes2) {
      const backSpace = 8;
      charCodes2[charCodes2["backSpace"] = backSpace] = "backSpace";
      const lineFeed = 10;
      charCodes2[charCodes2["lineFeed"] = lineFeed] = "lineFeed";
      const tab = 9;
      charCodes2[charCodes2["tab"] = tab] = "tab";
      const carriageReturn = 13;
      charCodes2[charCodes2["carriageReturn"] = carriageReturn] = "carriageReturn";
      const shiftOut = 14;
      charCodes2[charCodes2["shiftOut"] = shiftOut] = "shiftOut";
      const space = 32;
      charCodes2[charCodes2["space"] = space] = "space";
      const exclamationMark = 33;
      charCodes2[charCodes2["exclamationMark"] = exclamationMark] = "exclamationMark";
      const quotationMark = 34;
      charCodes2[charCodes2["quotationMark"] = quotationMark] = "quotationMark";
      const numberSign = 35;
      charCodes2[charCodes2["numberSign"] = numberSign] = "numberSign";
      const dollarSign = 36;
      charCodes2[charCodes2["dollarSign"] = dollarSign] = "dollarSign";
      const percentSign = 37;
      charCodes2[charCodes2["percentSign"] = percentSign] = "percentSign";
      const ampersand = 38;
      charCodes2[charCodes2["ampersand"] = ampersand] = "ampersand";
      const apostrophe = 39;
      charCodes2[charCodes2["apostrophe"] = apostrophe] = "apostrophe";
      const leftParenthesis = 40;
      charCodes2[charCodes2["leftParenthesis"] = leftParenthesis] = "leftParenthesis";
      const rightParenthesis = 41;
      charCodes2[charCodes2["rightParenthesis"] = rightParenthesis] = "rightParenthesis";
      const asterisk = 42;
      charCodes2[charCodes2["asterisk"] = asterisk] = "asterisk";
      const plusSign = 43;
      charCodes2[charCodes2["plusSign"] = plusSign] = "plusSign";
      const comma = 44;
      charCodes2[charCodes2["comma"] = comma] = "comma";
      const dash = 45;
      charCodes2[charCodes2["dash"] = dash] = "dash";
      const dot = 46;
      charCodes2[charCodes2["dot"] = dot] = "dot";
      const slash = 47;
      charCodes2[charCodes2["slash"] = slash] = "slash";
      const digit0 = 48;
      charCodes2[charCodes2["digit0"] = digit0] = "digit0";
      const digit1 = 49;
      charCodes2[charCodes2["digit1"] = digit1] = "digit1";
      const digit2 = 50;
      charCodes2[charCodes2["digit2"] = digit2] = "digit2";
      const digit3 = 51;
      charCodes2[charCodes2["digit3"] = digit3] = "digit3";
      const digit4 = 52;
      charCodes2[charCodes2["digit4"] = digit4] = "digit4";
      const digit5 = 53;
      charCodes2[charCodes2["digit5"] = digit5] = "digit5";
      const digit6 = 54;
      charCodes2[charCodes2["digit6"] = digit6] = "digit6";
      const digit7 = 55;
      charCodes2[charCodes2["digit7"] = digit7] = "digit7";
      const digit8 = 56;
      charCodes2[charCodes2["digit8"] = digit8] = "digit8";
      const digit9 = 57;
      charCodes2[charCodes2["digit9"] = digit9] = "digit9";
      const colon = 58;
      charCodes2[charCodes2["colon"] = colon] = "colon";
      const semicolon = 59;
      charCodes2[charCodes2["semicolon"] = semicolon] = "semicolon";
      const lessThan = 60;
      charCodes2[charCodes2["lessThan"] = lessThan] = "lessThan";
      const equalsTo = 61;
      charCodes2[charCodes2["equalsTo"] = equalsTo] = "equalsTo";
      const greaterThan = 62;
      charCodes2[charCodes2["greaterThan"] = greaterThan] = "greaterThan";
      const questionMark = 63;
      charCodes2[charCodes2["questionMark"] = questionMark] = "questionMark";
      const atSign = 64;
      charCodes2[charCodes2["atSign"] = atSign] = "atSign";
      const uppercaseA = 65;
      charCodes2[charCodes2["uppercaseA"] = uppercaseA] = "uppercaseA";
      const uppercaseB = 66;
      charCodes2[charCodes2["uppercaseB"] = uppercaseB] = "uppercaseB";
      const uppercaseC = 67;
      charCodes2[charCodes2["uppercaseC"] = uppercaseC] = "uppercaseC";
      const uppercaseD = 68;
      charCodes2[charCodes2["uppercaseD"] = uppercaseD] = "uppercaseD";
      const uppercaseE = 69;
      charCodes2[charCodes2["uppercaseE"] = uppercaseE] = "uppercaseE";
      const uppercaseF = 70;
      charCodes2[charCodes2["uppercaseF"] = uppercaseF] = "uppercaseF";
      const uppercaseG = 71;
      charCodes2[charCodes2["uppercaseG"] = uppercaseG] = "uppercaseG";
      const uppercaseH = 72;
      charCodes2[charCodes2["uppercaseH"] = uppercaseH] = "uppercaseH";
      const uppercaseI = 73;
      charCodes2[charCodes2["uppercaseI"] = uppercaseI] = "uppercaseI";
      const uppercaseJ = 74;
      charCodes2[charCodes2["uppercaseJ"] = uppercaseJ] = "uppercaseJ";
      const uppercaseK = 75;
      charCodes2[charCodes2["uppercaseK"] = uppercaseK] = "uppercaseK";
      const uppercaseL = 76;
      charCodes2[charCodes2["uppercaseL"] = uppercaseL] = "uppercaseL";
      const uppercaseM = 77;
      charCodes2[charCodes2["uppercaseM"] = uppercaseM] = "uppercaseM";
      const uppercaseN = 78;
      charCodes2[charCodes2["uppercaseN"] = uppercaseN] = "uppercaseN";
      const uppercaseO = 79;
      charCodes2[charCodes2["uppercaseO"] = uppercaseO] = "uppercaseO";
      const uppercaseP = 80;
      charCodes2[charCodes2["uppercaseP"] = uppercaseP] = "uppercaseP";
      const uppercaseQ = 81;
      charCodes2[charCodes2["uppercaseQ"] = uppercaseQ] = "uppercaseQ";
      const uppercaseR = 82;
      charCodes2[charCodes2["uppercaseR"] = uppercaseR] = "uppercaseR";
      const uppercaseS = 83;
      charCodes2[charCodes2["uppercaseS"] = uppercaseS] = "uppercaseS";
      const uppercaseT = 84;
      charCodes2[charCodes2["uppercaseT"] = uppercaseT] = "uppercaseT";
      const uppercaseU = 85;
      charCodes2[charCodes2["uppercaseU"] = uppercaseU] = "uppercaseU";
      const uppercaseV = 86;
      charCodes2[charCodes2["uppercaseV"] = uppercaseV] = "uppercaseV";
      const uppercaseW = 87;
      charCodes2[charCodes2["uppercaseW"] = uppercaseW] = "uppercaseW";
      const uppercaseX = 88;
      charCodes2[charCodes2["uppercaseX"] = uppercaseX] = "uppercaseX";
      const uppercaseY = 89;
      charCodes2[charCodes2["uppercaseY"] = uppercaseY] = "uppercaseY";
      const uppercaseZ = 90;
      charCodes2[charCodes2["uppercaseZ"] = uppercaseZ] = "uppercaseZ";
      const leftSquareBracket = 91;
      charCodes2[charCodes2["leftSquareBracket"] = leftSquareBracket] = "leftSquareBracket";
      const backslash = 92;
      charCodes2[charCodes2["backslash"] = backslash] = "backslash";
      const rightSquareBracket = 93;
      charCodes2[charCodes2["rightSquareBracket"] = rightSquareBracket] = "rightSquareBracket";
      const caret = 94;
      charCodes2[charCodes2["caret"] = caret] = "caret";
      const underscore = 95;
      charCodes2[charCodes2["underscore"] = underscore] = "underscore";
      const graveAccent = 96;
      charCodes2[charCodes2["graveAccent"] = graveAccent] = "graveAccent";
      const lowercaseA = 97;
      charCodes2[charCodes2["lowercaseA"] = lowercaseA] = "lowercaseA";
      const lowercaseB = 98;
      charCodes2[charCodes2["lowercaseB"] = lowercaseB] = "lowercaseB";
      const lowercaseC = 99;
      charCodes2[charCodes2["lowercaseC"] = lowercaseC] = "lowercaseC";
      const lowercaseD = 100;
      charCodes2[charCodes2["lowercaseD"] = lowercaseD] = "lowercaseD";
      const lowercaseE = 101;
      charCodes2[charCodes2["lowercaseE"] = lowercaseE] = "lowercaseE";
      const lowercaseF = 102;
      charCodes2[charCodes2["lowercaseF"] = lowercaseF] = "lowercaseF";
      const lowercaseG = 103;
      charCodes2[charCodes2["lowercaseG"] = lowercaseG] = "lowercaseG";
      const lowercaseH = 104;
      charCodes2[charCodes2["lowercaseH"] = lowercaseH] = "lowercaseH";
      const lowercaseI = 105;
      charCodes2[charCodes2["lowercaseI"] = lowercaseI] = "lowercaseI";
      const lowercaseJ = 106;
      charCodes2[charCodes2["lowercaseJ"] = lowercaseJ] = "lowercaseJ";
      const lowercaseK = 107;
      charCodes2[charCodes2["lowercaseK"] = lowercaseK] = "lowercaseK";
      const lowercaseL = 108;
      charCodes2[charCodes2["lowercaseL"] = lowercaseL] = "lowercaseL";
      const lowercaseM = 109;
      charCodes2[charCodes2["lowercaseM"] = lowercaseM] = "lowercaseM";
      const lowercaseN = 110;
      charCodes2[charCodes2["lowercaseN"] = lowercaseN] = "lowercaseN";
      const lowercaseO = 111;
      charCodes2[charCodes2["lowercaseO"] = lowercaseO] = "lowercaseO";
      const lowercaseP = 112;
      charCodes2[charCodes2["lowercaseP"] = lowercaseP] = "lowercaseP";
      const lowercaseQ = 113;
      charCodes2[charCodes2["lowercaseQ"] = lowercaseQ] = "lowercaseQ";
      const lowercaseR = 114;
      charCodes2[charCodes2["lowercaseR"] = lowercaseR] = "lowercaseR";
      const lowercaseS = 115;
      charCodes2[charCodes2["lowercaseS"] = lowercaseS] = "lowercaseS";
      const lowercaseT = 116;
      charCodes2[charCodes2["lowercaseT"] = lowercaseT] = "lowercaseT";
      const lowercaseU = 117;
      charCodes2[charCodes2["lowercaseU"] = lowercaseU] = "lowercaseU";
      const lowercaseV = 118;
      charCodes2[charCodes2["lowercaseV"] = lowercaseV] = "lowercaseV";
      const lowercaseW = 119;
      charCodes2[charCodes2["lowercaseW"] = lowercaseW] = "lowercaseW";
      const lowercaseX = 120;
      charCodes2[charCodes2["lowercaseX"] = lowercaseX] = "lowercaseX";
      const lowercaseY = 121;
      charCodes2[charCodes2["lowercaseY"] = lowercaseY] = "lowercaseY";
      const lowercaseZ = 122;
      charCodes2[charCodes2["lowercaseZ"] = lowercaseZ] = "lowercaseZ";
      const leftCurlyBrace = 123;
      charCodes2[charCodes2["leftCurlyBrace"] = leftCurlyBrace] = "leftCurlyBrace";
      const verticalBar = 124;
      charCodes2[charCodes2["verticalBar"] = verticalBar] = "verticalBar";
      const rightCurlyBrace = 125;
      charCodes2[charCodes2["rightCurlyBrace"] = rightCurlyBrace] = "rightCurlyBrace";
      const tilde = 126;
      charCodes2[charCodes2["tilde"] = tilde] = "tilde";
      const nonBreakingSpace = 160;
      charCodes2[charCodes2["nonBreakingSpace"] = nonBreakingSpace] = "nonBreakingSpace";
      const oghamSpaceMark = 5760;
      charCodes2[charCodes2["oghamSpaceMark"] = oghamSpaceMark] = "oghamSpaceMark";
      const lineSeparator = 8232;
      charCodes2[charCodes2["lineSeparator"] = lineSeparator] = "lineSeparator";
      const paragraphSeparator = 8233;
      charCodes2[charCodes2["paragraphSeparator"] = paragraphSeparator] = "paragraphSeparator";
    })(charCodes || (exports2.charCodes = charCodes = {}));
    function isDigit(code) {
      return code >= charCodes.digit0 && code <= charCodes.digit9 || code >= charCodes.lowercaseA && code <= charCodes.lowercaseF || code >= charCodes.uppercaseA && code <= charCodes.uppercaseF;
    }
    exports2.isDigit = isDigit;
  }
});

// node_modules/sucrase/dist/parser/traverser/base.js
var require_base = __commonJS({
  "node_modules/sucrase/dist/parser/traverser/base.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _state = require_state();
    var _state2 = _interopRequireDefault(_state);
    var _charcodes = require_charcodes();
    exports2.isJSXEnabled;
    exports2.isTypeScriptEnabled;
    exports2.isFlowEnabled;
    exports2.state;
    exports2.input;
    exports2.nextContextId;
    function getNextContextId() {
      return exports2.nextContextId++;
    }
    exports2.getNextContextId = getNextContextId;
    function augmentError(error73) {
      if ("pos" in error73) {
        const loc = locationForIndex(error73.pos);
        error73.message += ` (${loc.line}:${loc.column})`;
        error73.loc = loc;
      }
      return error73;
    }
    exports2.augmentError = augmentError;
    var Loc = class {
      constructor(line, column) {
        this.line = line;
        this.column = column;
      }
    };
    exports2.Loc = Loc;
    function locationForIndex(pos) {
      let line = 1;
      let column = 1;
      for (let i = 0; i < pos; i++) {
        if (exports2.input.charCodeAt(i) === _charcodes.charCodes.lineFeed) {
          line++;
          column = 1;
        } else {
          column++;
        }
      }
      return new Loc(line, column);
    }
    exports2.locationForIndex = locationForIndex;
    function initParser(inputCode, isJSXEnabledArg, isTypeScriptEnabledArg, isFlowEnabledArg) {
      exports2.input = inputCode;
      exports2.state = new (0, _state2.default)();
      exports2.nextContextId = 1;
      exports2.isJSXEnabled = isJSXEnabledArg;
      exports2.isTypeScriptEnabled = isTypeScriptEnabledArg;
      exports2.isFlowEnabled = isFlowEnabledArg;
    }
    exports2.initParser = initParser;
  }
});

// node_modules/sucrase/dist/parser/traverser/util.js
var require_util = __commonJS({
  "node_modules/sucrase/dist/parser/traverser/util.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _index = require_tokenizer2();
    var _types = require_types();
    var _charcodes = require_charcodes();
    var _base = require_base();
    function isContextual(contextualKeyword) {
      return _base.state.contextualKeyword === contextualKeyword;
    }
    exports2.isContextual = isContextual;
    function isLookaheadContextual(contextualKeyword) {
      const l = _index.lookaheadTypeAndKeyword.call(void 0);
      return l.type === _types.TokenType.name && l.contextualKeyword === contextualKeyword;
    }
    exports2.isLookaheadContextual = isLookaheadContextual;
    function eatContextual(contextualKeyword) {
      return _base.state.contextualKeyword === contextualKeyword && _index.eat.call(void 0, _types.TokenType.name);
    }
    exports2.eatContextual = eatContextual;
    function expectContextual(contextualKeyword) {
      if (!eatContextual(contextualKeyword)) {
        unexpected();
      }
    }
    exports2.expectContextual = expectContextual;
    function canInsertSemicolon() {
      return _index.match.call(void 0, _types.TokenType.eof) || _index.match.call(void 0, _types.TokenType.braceR) || hasPrecedingLineBreak();
    }
    exports2.canInsertSemicolon = canInsertSemicolon;
    function hasPrecedingLineBreak() {
      const prevToken = _base.state.tokens[_base.state.tokens.length - 1];
      const lastTokEnd = prevToken ? prevToken.end : 0;
      for (let i = lastTokEnd; i < _base.state.start; i++) {
        const code = _base.input.charCodeAt(i);
        if (code === _charcodes.charCodes.lineFeed || code === _charcodes.charCodes.carriageReturn || code === 8232 || code === 8233) {
          return true;
        }
      }
      return false;
    }
    exports2.hasPrecedingLineBreak = hasPrecedingLineBreak;
    function hasFollowingLineBreak() {
      const nextStart = _index.nextTokenStart.call(void 0);
      for (let i = _base.state.end; i < nextStart; i++) {
        const code = _base.input.charCodeAt(i);
        if (code === _charcodes.charCodes.lineFeed || code === _charcodes.charCodes.carriageReturn || code === 8232 || code === 8233) {
          return true;
        }
      }
      return false;
    }
    exports2.hasFollowingLineBreak = hasFollowingLineBreak;
    function isLineTerminator() {
      return _index.eat.call(void 0, _types.TokenType.semi) || canInsertSemicolon();
    }
    exports2.isLineTerminator = isLineTerminator;
    function semicolon() {
      if (!isLineTerminator()) {
        unexpected('Unexpected token, expected ";"');
      }
    }
    exports2.semicolon = semicolon;
    function expect(type) {
      const matched = _index.eat.call(void 0, type);
      if (!matched) {
        unexpected(`Unexpected token, expected "${_types.formatTokenType.call(void 0, type)}"`);
      }
    }
    exports2.expect = expect;
    function unexpected(message = "Unexpected token", pos = _base.state.start) {
      if (_base.state.error) {
        return;
      }
      const err = new SyntaxError(message);
      err.pos = pos;
      _base.state.error = err;
      _base.state.pos = _base.input.length;
      _index.finishToken.call(void 0, _types.TokenType.eof);
    }
    exports2.unexpected = unexpected;
  }
});

// node_modules/sucrase/dist/parser/util/whitespace.js
var require_whitespace = __commonJS({
  "node_modules/sucrase/dist/parser/util/whitespace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _charcodes = require_charcodes();
    var WHITESPACE_CHARS = [
      9,
      11,
      12,
      _charcodes.charCodes.space,
      _charcodes.charCodes.nonBreakingSpace,
      _charcodes.charCodes.oghamSpaceMark,
      8192,
      // EN QUAD
      8193,
      // EM QUAD
      8194,
      // EN SPACE
      8195,
      // EM SPACE
      8196,
      // THREE-PER-EM SPACE
      8197,
      // FOUR-PER-EM SPACE
      8198,
      // SIX-PER-EM SPACE
      8199,
      // FIGURE SPACE
      8200,
      // PUNCTUATION SPACE
      8201,
      // THIN SPACE
      8202,
      // HAIR SPACE
      8239,
      // NARROW NO-BREAK SPACE
      8287,
      // MEDIUM MATHEMATICAL SPACE
      12288,
      // IDEOGRAPHIC SPACE
      65279
      // ZERO WIDTH NO-BREAK SPACE
    ];
    exports2.WHITESPACE_CHARS = WHITESPACE_CHARS;
    var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
    exports2.skipWhiteSpace = skipWhiteSpace;
    var IS_WHITESPACE = new Uint8Array(65536);
    exports2.IS_WHITESPACE = IS_WHITESPACE;
    for (const char of exports2.WHITESPACE_CHARS) {
      exports2.IS_WHITESPACE[char] = 1;
    }
  }
});

// node_modules/sucrase/dist/parser/util/identifier.js
var require_identifier = __commonJS({
  "node_modules/sucrase/dist/parser/util/identifier.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _charcodes = require_charcodes();
    var _whitespace = require_whitespace();
    function computeIsIdentifierChar(code) {
      if (code < 48) return code === 36;
      if (code < 58) return true;
      if (code < 65) return false;
      if (code < 91) return true;
      if (code < 97) return code === 95;
      if (code < 123) return true;
      if (code < 128) return false;
      throw new Error("Should not be called with non-ASCII char code.");
    }
    var IS_IDENTIFIER_CHAR = new Uint8Array(65536);
    exports2.IS_IDENTIFIER_CHAR = IS_IDENTIFIER_CHAR;
    for (let i = 0; i < 128; i++) {
      exports2.IS_IDENTIFIER_CHAR[i] = computeIsIdentifierChar(i) ? 1 : 0;
    }
    for (let i = 128; i < 65536; i++) {
      exports2.IS_IDENTIFIER_CHAR[i] = 1;
    }
    for (const whitespaceChar of _whitespace.WHITESPACE_CHARS) {
      exports2.IS_IDENTIFIER_CHAR[whitespaceChar] = 0;
    }
    exports2.IS_IDENTIFIER_CHAR[8232] = 0;
    exports2.IS_IDENTIFIER_CHAR[8233] = 0;
    var IS_IDENTIFIER_START = exports2.IS_IDENTIFIER_CHAR.slice();
    exports2.IS_IDENTIFIER_START = IS_IDENTIFIER_START;
    for (let numChar = _charcodes.charCodes.digit0; numChar <= _charcodes.charCodes.digit9; numChar++) {
      exports2.IS_IDENTIFIER_START[numChar] = 0;
    }
  }
});

// node_modules/sucrase/dist/parser/tokenizer/readWordTree.js
var require_readWordTree = __commonJS({
  "node_modules/sucrase/dist/parser/tokenizer/readWordTree.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _keywords = require_keywords();
    var _types = require_types();
    var READ_WORD_TREE = new Int32Array([
      // ""
      -1,
      27,
      783,
      918,
      1755,
      2376,
      2862,
      3483,
      -1,
      3699,
      -1,
      4617,
      4752,
      4833,
      5130,
      5508,
      5940,
      -1,
      6480,
      6939,
      7749,
      8181,
      8451,
      8613,
      -1,
      8829,
      -1,
      // "a"
      -1,
      -1,
      54,
      243,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      432,
      -1,
      -1,
      -1,
      675,
      -1,
      -1,
      -1,
      // "ab"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      81,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "abs"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      108,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "abst"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      135,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "abstr"
      -1,
      162,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "abstra"
      -1,
      -1,
      -1,
      189,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "abstrac"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      216,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "abstract"
      _keywords.ContextualKeyword._abstract << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ac"
      -1,
      -1,
      -1,
      270,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "acc"
      -1,
      -1,
      -1,
      -1,
      -1,
      297,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "acce"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      324,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "acces"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      351,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "access"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      378,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "accesso"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      405,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "accessor"
      _keywords.ContextualKeyword._accessor << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "as"
      _keywords.ContextualKeyword._as << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      459,
      -1,
      -1,
      -1,
      -1,
      -1,
      594,
      -1,
      // "ass"
      -1,
      -1,
      -1,
      -1,
      -1,
      486,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "asse"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      513,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "asser"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      540,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "assert"
      _keywords.ContextualKeyword._assert << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      567,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "asserts"
      _keywords.ContextualKeyword._asserts << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "asy"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      621,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "asyn"
      -1,
      -1,
      -1,
      648,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "async"
      _keywords.ContextualKeyword._async << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "aw"
      -1,
      702,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "awa"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      729,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "awai"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      756,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "await"
      _keywords.ContextualKeyword._await << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "b"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      810,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "br"
      -1,
      -1,
      -1,
      -1,
      -1,
      837,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "bre"
      -1,
      864,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "brea"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      891,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "break"
      (_types.TokenType._break << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "c"
      -1,
      945,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1107,
      -1,
      -1,
      -1,
      1242,
      -1,
      -1,
      1350,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ca"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      972,
      1026,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "cas"
      -1,
      -1,
      -1,
      -1,
      -1,
      999,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "case"
      (_types.TokenType._case << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "cat"
      -1,
      -1,
      -1,
      1053,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "catc"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1080,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "catch"
      (_types.TokenType._catch << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ch"
      -1,
      -1,
      -1,
      -1,
      -1,
      1134,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "che"
      -1,
      -1,
      -1,
      1161,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "chec"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1188,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "check"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1215,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "checks"
      _keywords.ContextualKeyword._checks << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "cl"
      -1,
      1269,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "cla"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1296,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "clas"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1323,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "class"
      (_types.TokenType._class << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "co"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1377,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "con"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1404,
      1620,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "cons"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1431,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "const"
      (_types.TokenType._const << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1458,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "constr"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1485,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "constru"
      -1,
      -1,
      -1,
      1512,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "construc"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1539,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "construct"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1566,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "constructo"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1593,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "constructor"
      _keywords.ContextualKeyword._constructor << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "cont"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1647,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "conti"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1674,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "contin"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1701,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "continu"
      -1,
      -1,
      -1,
      -1,
      -1,
      1728,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "continue"
      (_types.TokenType._continue << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "d"
      -1,
      -1,
      -1,
      -1,
      -1,
      1782,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2349,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "de"
      -1,
      -1,
      1809,
      1971,
      -1,
      -1,
      2106,
      -1,
      -1,
      -1,
      -1,
      -1,
      2241,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "deb"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1836,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "debu"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1863,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "debug"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1890,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "debugg"
      -1,
      -1,
      -1,
      -1,
      -1,
      1917,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "debugge"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1944,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "debugger"
      (_types.TokenType._debugger << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "dec"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      1998,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "decl"
      -1,
      2025,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "decla"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2052,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "declar"
      -1,
      -1,
      -1,
      -1,
      -1,
      2079,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "declare"
      _keywords.ContextualKeyword._declare << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "def"
      -1,
      2133,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "defa"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2160,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "defau"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2187,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "defaul"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2214,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "default"
      (_types.TokenType._default << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "del"
      -1,
      -1,
      -1,
      -1,
      -1,
      2268,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "dele"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2295,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "delet"
      -1,
      -1,
      -1,
      -1,
      -1,
      2322,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "delete"
      (_types.TokenType._delete << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "do"
      (_types.TokenType._do << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "e"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2403,
      -1,
      2484,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2565,
      -1,
      -1,
      // "el"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2430,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "els"
      -1,
      -1,
      -1,
      -1,
      -1,
      2457,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "else"
      (_types.TokenType._else << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "en"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2511,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "enu"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2538,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "enum"
      _keywords.ContextualKeyword._enum << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ex"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2592,
      -1,
      -1,
      -1,
      2727,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "exp"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2619,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "expo"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2646,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "expor"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2673,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "export"
      (_types.TokenType._export << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2700,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "exports"
      _keywords.ContextualKeyword._exports << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ext"
      -1,
      -1,
      -1,
      -1,
      -1,
      2754,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "exte"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2781,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "exten"
      -1,
      -1,
      -1,
      -1,
      2808,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "extend"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2835,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "extends"
      (_types.TokenType._extends << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "f"
      -1,
      2889,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2997,
      -1,
      -1,
      -1,
      -1,
      -1,
      3159,
      -1,
      -1,
      3213,
      -1,
      -1,
      3294,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fa"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2916,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fal"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      2943,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fals"
      -1,
      -1,
      -1,
      -1,
      -1,
      2970,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "false"
      (_types.TokenType._false << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3024,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fin"
      -1,
      3051,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fina"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3078,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "final"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3105,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "finall"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3132,
      -1,
      // "finally"
      (_types.TokenType._finally << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fo"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3186,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "for"
      (_types.TokenType._for << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fr"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3240,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fro"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3267,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "from"
      _keywords.ContextualKeyword._from << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fu"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3321,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "fun"
      -1,
      -1,
      -1,
      3348,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "func"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3375,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "funct"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3402,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "functi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3429,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "functio"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3456,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "function"
      (_types.TokenType._function << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "g"
      -1,
      -1,
      -1,
      -1,
      -1,
      3510,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3564,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ge"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3537,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "get"
      _keywords.ContextualKeyword._get << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "gl"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3591,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "glo"
      -1,
      -1,
      3618,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "glob"
      -1,
      3645,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "globa"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3672,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "global"
      _keywords.ContextualKeyword._global << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "i"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3726,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3753,
      4077,
      -1,
      -1,
      -1,
      -1,
      4590,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "if"
      (_types.TokenType._if << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "im"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3780,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "imp"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3807,
      -1,
      -1,
      3996,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "impl"
      -1,
      -1,
      -1,
      -1,
      -1,
      3834,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "imple"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3861,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "implem"
      -1,
      -1,
      -1,
      -1,
      -1,
      3888,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "impleme"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3915,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "implemen"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3942,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "implement"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      3969,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "implements"
      _keywords.ContextualKeyword._implements << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "impo"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4023,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "impor"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4050,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "import"
      (_types.TokenType._import << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "in"
      (_types.TokenType._in << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4104,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4185,
      4401,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "inf"
      -1,
      -1,
      -1,
      -1,
      -1,
      4131,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "infe"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4158,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "infer"
      _keywords.ContextualKeyword._infer << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ins"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4212,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "inst"
      -1,
      4239,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "insta"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4266,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "instan"
      -1,
      -1,
      -1,
      4293,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "instanc"
      -1,
      -1,
      -1,
      -1,
      -1,
      4320,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "instance"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4347,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "instanceo"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4374,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "instanceof"
      (_types.TokenType._instanceof << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "int"
      -1,
      -1,
      -1,
      -1,
      -1,
      4428,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "inte"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4455,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "inter"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4482,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "interf"
      -1,
      4509,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "interfa"
      -1,
      -1,
      -1,
      4536,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "interfac"
      -1,
      -1,
      -1,
      -1,
      -1,
      4563,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "interface"
      _keywords.ContextualKeyword._interface << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "is"
      _keywords.ContextualKeyword._is << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "k"
      -1,
      -1,
      -1,
      -1,
      -1,
      4644,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ke"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4671,
      -1,
      // "key"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4698,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "keyo"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4725,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "keyof"
      _keywords.ContextualKeyword._keyof << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "l"
      -1,
      -1,
      -1,
      -1,
      -1,
      4779,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "le"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4806,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "let"
      (_types.TokenType._let << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "m"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4860,
      -1,
      -1,
      -1,
      -1,
      -1,
      4995,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "mi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4887,
      -1,
      -1,
      // "mix"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4914,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "mixi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4941,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "mixin"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      4968,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "mixins"
      _keywords.ContextualKeyword._mixins << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "mo"
      -1,
      -1,
      -1,
      -1,
      5022,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "mod"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5049,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "modu"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5076,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "modul"
      -1,
      -1,
      -1,
      -1,
      -1,
      5103,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "module"
      _keywords.ContextualKeyword._module << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "n"
      -1,
      5157,
      -1,
      -1,
      -1,
      5373,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5427,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "na"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5184,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "nam"
      -1,
      -1,
      -1,
      -1,
      -1,
      5211,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "name"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5238,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "names"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5265,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "namesp"
      -1,
      5292,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "namespa"
      -1,
      -1,
      -1,
      5319,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "namespac"
      -1,
      -1,
      -1,
      -1,
      -1,
      5346,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "namespace"
      _keywords.ContextualKeyword._namespace << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ne"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5400,
      -1,
      -1,
      -1,
      // "new"
      (_types.TokenType._new << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "nu"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5454,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "nul"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5481,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "null"
      (_types.TokenType._null << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "o"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5535,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5562,
      -1,
      -1,
      -1,
      -1,
      5697,
      5751,
      -1,
      -1,
      -1,
      -1,
      // "of"
      _keywords.ContextualKeyword._of << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "op"
      -1,
      5589,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "opa"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5616,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "opaq"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5643,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "opaqu"
      -1,
      -1,
      -1,
      -1,
      -1,
      5670,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "opaque"
      _keywords.ContextualKeyword._opaque << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ou"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5724,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "out"
      _keywords.ContextualKeyword._out << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ov"
      -1,
      -1,
      -1,
      -1,
      -1,
      5778,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ove"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5805,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "over"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5832,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "overr"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5859,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "overri"
      -1,
      -1,
      -1,
      -1,
      5886,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "overrid"
      -1,
      -1,
      -1,
      -1,
      -1,
      5913,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "override"
      _keywords.ContextualKeyword._override << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "p"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5967,
      -1,
      -1,
      6345,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "pr"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      5994,
      -1,
      -1,
      -1,
      -1,
      -1,
      6129,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "pri"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6021,
      -1,
      -1,
      -1,
      -1,
      // "priv"
      -1,
      6048,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "priva"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6075,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "privat"
      -1,
      -1,
      -1,
      -1,
      -1,
      6102,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "private"
      _keywords.ContextualKeyword._private << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "pro"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6156,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "prot"
      -1,
      -1,
      -1,
      -1,
      -1,
      6183,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6318,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "prote"
      -1,
      -1,
      -1,
      6210,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "protec"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6237,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "protect"
      -1,
      -1,
      -1,
      -1,
      -1,
      6264,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "protecte"
      -1,
      -1,
      -1,
      -1,
      6291,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "protected"
      _keywords.ContextualKeyword._protected << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "proto"
      _keywords.ContextualKeyword._proto << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "pu"
      -1,
      -1,
      6372,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "pub"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6399,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "publ"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6426,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "publi"
      -1,
      -1,
      -1,
      6453,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "public"
      _keywords.ContextualKeyword._public << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "r"
      -1,
      -1,
      -1,
      -1,
      -1,
      6507,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "re"
      -1,
      6534,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6696,
      -1,
      -1,
      6831,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "rea"
      -1,
      -1,
      -1,
      -1,
      6561,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "read"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6588,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "reado"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6615,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "readon"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6642,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "readonl"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6669,
      -1,
      // "readonly"
      _keywords.ContextualKeyword._readonly << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "req"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6723,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "requ"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6750,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "requi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6777,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "requir"
      -1,
      -1,
      -1,
      -1,
      -1,
      6804,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "require"
      _keywords.ContextualKeyword._require << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ret"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6858,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "retu"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6885,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "retur"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6912,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "return"
      (_types.TokenType._return << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "s"
      -1,
      6966,
      -1,
      -1,
      -1,
      7182,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7236,
      7371,
      -1,
      7479,
      -1,
      7614,
      -1,
      // "sa"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      6993,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "sat"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7020,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "sati"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7047,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "satis"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7074,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "satisf"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7101,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "satisfi"
      -1,
      -1,
      -1,
      -1,
      -1,
      7128,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "satisfie"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7155,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "satisfies"
      _keywords.ContextualKeyword._satisfies << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "se"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7209,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "set"
      _keywords.ContextualKeyword._set << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "st"
      -1,
      7263,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "sta"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7290,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "stat"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7317,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "stati"
      -1,
      -1,
      -1,
      7344,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "static"
      _keywords.ContextualKeyword._static << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "su"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7398,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "sup"
      -1,
      -1,
      -1,
      -1,
      -1,
      7425,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "supe"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7452,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "super"
      (_types.TokenType._super << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "sw"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7506,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "swi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7533,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "swit"
      -1,
      -1,
      -1,
      7560,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "switc"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7587,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "switch"
      (_types.TokenType._switch << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "sy"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7641,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "sym"
      -1,
      -1,
      7668,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "symb"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7695,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "symbo"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7722,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "symbol"
      _keywords.ContextualKeyword._symbol << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "t"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7776,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7938,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8046,
      -1,
      // "th"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7803,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7857,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "thi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7830,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "this"
      (_types.TokenType._this << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "thr"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7884,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "thro"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7911,
      -1,
      -1,
      -1,
      // "throw"
      (_types.TokenType._throw << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "tr"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      7965,
      -1,
      -1,
      -1,
      8019,
      -1,
      // "tru"
      -1,
      -1,
      -1,
      -1,
      -1,
      7992,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "true"
      (_types.TokenType._true << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "try"
      (_types.TokenType._try << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "ty"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8073,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "typ"
      -1,
      -1,
      -1,
      -1,
      -1,
      8100,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "type"
      _keywords.ContextualKeyword._type << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8127,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "typeo"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8154,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "typeof"
      (_types.TokenType._typeof << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "u"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8208,
      -1,
      -1,
      -1,
      -1,
      8343,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "un"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8235,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "uni"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8262,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "uniq"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8289,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "uniqu"
      -1,
      -1,
      -1,
      -1,
      -1,
      8316,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "unique"
      _keywords.ContextualKeyword._unique << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "us"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8370,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "usi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8397,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "usin"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8424,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "using"
      _keywords.ContextualKeyword._using << 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "v"
      -1,
      8478,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8532,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "va"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8505,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "var"
      (_types.TokenType._var << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "vo"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8559,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "voi"
      -1,
      -1,
      -1,
      -1,
      8586,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "void"
      (_types.TokenType._void << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "w"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8640,
      8748,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "wh"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8667,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "whi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8694,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "whil"
      -1,
      -1,
      -1,
      -1,
      -1,
      8721,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "while"
      (_types.TokenType._while << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "wi"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8775,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "wit"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8802,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "with"
      (_types.TokenType._with << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "y"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8856,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "yi"
      -1,
      -1,
      -1,
      -1,
      -1,
      8883,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "yie"
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      8910,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "yiel"
      -1,
      -1,
      -1,
      -1,
      8937,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      // "yield"
      (_types.TokenType._yield << 1) + 1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1
    ]);
    exports2.READ_WORD_TREE = READ_WORD_TREE;
  }
});

// node_modules/sucrase/dist/parser/tokenizer/readWord.js
var require_readWord = __commonJS({
  "node_modules/sucrase/dist/parser/tokenizer/readWord.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _base = require_base();
    var _charcodes = require_charcodes();
    var _identifier = require_identifier();
    var _index = require_tokenizer2();
    var _readWordTree = require_readWordTree();
    var _types = require_types();
    function readWord() {
      let treePos = 0;
      let code = 0;
      let pos = _base.state.pos;
      while (pos < _base.input.length) {
        code = _base.input.charCodeAt(pos);
        if (code < _charcodes.charCodes.lowercaseA || code > _charcodes.charCodes.lowercaseZ) {
          break;
        }
        const next = _readWordTree.READ_WORD_TREE[treePos + (code - _charcodes.charCodes.lowercaseA) + 1];
        if (next === -1) {
          break;
        } else {
          treePos = next;
          pos++;
        }
      }
      const keywordValue = _readWordTree.READ_WORD_TREE[treePos];
      if (keywordValue > -1 && !_identifier.IS_IDENTIFIER_CHAR[code]) {
        _base.state.pos = pos;
        if (keywordValue & 1) {
          _index.finishToken.call(void 0, keywordValue >>> 1);
        } else {
          _index.finishToken.call(void 0, _types.TokenType.name, keywordValue >>> 1);
        }
        return;
      }
      while (pos < _base.input.length) {
        const ch = _base.input.charCodeAt(pos);
        if (_identifier.IS_IDENTIFIER_CHAR[ch]) {
          pos++;
        } else if (ch === _charcodes.charCodes.backslash) {
          pos += 2;
          if (_base.input.charCodeAt(pos) === _charcodes.charCodes.leftCurlyBrace) {
            while (pos < _base.input.length && _base.input.charCodeAt(pos) !== _charcodes.charCodes.rightCurlyBrace) {
              pos++;
            }
            pos++;
          }
        } else if (ch === _charcodes.charCodes.atSign && _base.input.charCodeAt(pos + 1) === _charcodes.charCodes.atSign) {
          pos += 2;
        } else {
          break;
        }
      }
      _base.state.pos = pos;
      _index.finishToken.call(void 0, _types.TokenType.name);
    }
    exports2.default = readWord;
  }
});

// node_modules/sucrase/dist/parser/tokenizer/index.js
var require_tokenizer2 = __commonJS({
  "node_modules/sucrase/dist/parser/tokenizer/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _base = require_base();
    var _util = require_util();
    var _charcodes = require_charcodes();
    var _identifier = require_identifier();
    var _whitespace = require_whitespace();
    var _keywords = require_keywords();
    var _readWord = require_readWord();
    var _readWord2 = _interopRequireDefault(_readWord);
    var _types = require_types();
    var IdentifierRole;
    (function(IdentifierRole2) {
      const Access = 0;
      IdentifierRole2[IdentifierRole2["Access"] = Access] = "Access";
      const ExportAccess = Access + 1;
      IdentifierRole2[IdentifierRole2["ExportAccess"] = ExportAccess] = "ExportAccess";
      const TopLevelDeclaration = ExportAccess + 1;
      IdentifierRole2[IdentifierRole2["TopLevelDeclaration"] = TopLevelDeclaration] = "TopLevelDeclaration";
      const FunctionScopedDeclaration = TopLevelDeclaration + 1;
      IdentifierRole2[IdentifierRole2["FunctionScopedDeclaration"] = FunctionScopedDeclaration] = "FunctionScopedDeclaration";
      const BlockScopedDeclaration = FunctionScopedDeclaration + 1;
      IdentifierRole2[IdentifierRole2["BlockScopedDeclaration"] = BlockScopedDeclaration] = "BlockScopedDeclaration";
      const ObjectShorthandTopLevelDeclaration = BlockScopedDeclaration + 1;
      IdentifierRole2[IdentifierRole2["ObjectShorthandTopLevelDeclaration"] = ObjectShorthandTopLevelDeclaration] = "ObjectShorthandTopLevelDeclaration";
      const ObjectShorthandFunctionScopedDeclaration = ObjectShorthandTopLevelDeclaration + 1;
      IdentifierRole2[IdentifierRole2["ObjectShorthandFunctionScopedDeclaration"] = ObjectShorthandFunctionScopedDeclaration] = "ObjectShorthandFunctionScopedDeclaration";
      const ObjectShorthandBlockScopedDeclaration = ObjectShorthandFunctionScopedDeclaration + 1;
      IdentifierRole2[IdentifierRole2["ObjectShorthandBlockScopedDeclaration"] = ObjectShorthandBlockScopedDeclaration] = "ObjectShorthandBlockScopedDeclaration";
      const ObjectShorthand = ObjectShorthandBlockScopedDeclaration + 1;
      IdentifierRole2[IdentifierRole2["ObjectShorthand"] = ObjectShorthand] = "ObjectShorthand";
      const ImportDeclaration = ObjectShorthand + 1;
      IdentifierRole2[IdentifierRole2["ImportDeclaration"] = ImportDeclaration] = "ImportDeclaration";
      const ObjectKey = ImportDeclaration + 1;
      IdentifierRole2[IdentifierRole2["ObjectKey"] = ObjectKey] = "ObjectKey";
      const ImportAccess = ObjectKey + 1;
      IdentifierRole2[IdentifierRole2["ImportAccess"] = ImportAccess] = "ImportAccess";
    })(IdentifierRole || (exports2.IdentifierRole = IdentifierRole = {}));
    var JSXRole;
    (function(JSXRole2) {
      const NoChildren = 0;
      JSXRole2[JSXRole2["NoChildren"] = NoChildren] = "NoChildren";
      const OneChild = NoChildren + 1;
      JSXRole2[JSXRole2["OneChild"] = OneChild] = "OneChild";
      const StaticChildren = OneChild + 1;
      JSXRole2[JSXRole2["StaticChildren"] = StaticChildren] = "StaticChildren";
      const KeyAfterPropSpread = StaticChildren + 1;
      JSXRole2[JSXRole2["KeyAfterPropSpread"] = KeyAfterPropSpread] = "KeyAfterPropSpread";
    })(JSXRole || (exports2.JSXRole = JSXRole = {}));
    function isDeclaration(token) {
      const role = token.identifierRole;
      return role === IdentifierRole.TopLevelDeclaration || role === IdentifierRole.FunctionScopedDeclaration || role === IdentifierRole.BlockScopedDeclaration || role === IdentifierRole.ObjectShorthandTopLevelDeclaration || role === IdentifierRole.ObjectShorthandFunctionScopedDeclaration || role === IdentifierRole.ObjectShorthandBlockScopedDeclaration;
    }
    exports2.isDeclaration = isDeclaration;
    function isNonTopLevelDeclaration(token) {
      const role = token.identifierRole;
      return role === IdentifierRole.FunctionScopedDeclaration || role === IdentifierRole.BlockScopedDeclaration || role === IdentifierRole.ObjectShorthandFunctionScopedDeclaration || role === IdentifierRole.ObjectShorthandBlockScopedDeclaration;
    }
    exports2.isNonTopLevelDeclaration = isNonTopLevelDeclaration;
    function isTopLevelDeclaration(token) {
      const role = token.identifierRole;
      return role === IdentifierRole.TopLevelDeclaration || role === IdentifierRole.ObjectShorthandTopLevelDeclaration || role === IdentifierRole.ImportDeclaration;
    }
    exports2.isTopLevelDeclaration = isTopLevelDeclaration;
    function isBlockScopedDeclaration(token) {
      const role = token.identifierRole;
      return role === IdentifierRole.TopLevelDeclaration || role === IdentifierRole.BlockScopedDeclaration || role === IdentifierRole.ObjectShorthandTopLevelDeclaration || role === IdentifierRole.ObjectShorthandBlockScopedDeclaration;
    }
    exports2.isBlockScopedDeclaration = isBlockScopedDeclaration;
    function isFunctionScopedDeclaration(token) {
      const role = token.identifierRole;
      return role === IdentifierRole.FunctionScopedDeclaration || role === IdentifierRole.ObjectShorthandFunctionScopedDeclaration;
    }
    exports2.isFunctionScopedDeclaration = isFunctionScopedDeclaration;
    function isObjectShorthandDeclaration(token) {
      return token.identifierRole === IdentifierRole.ObjectShorthandTopLevelDeclaration || token.identifierRole === IdentifierRole.ObjectShorthandBlockScopedDeclaration || token.identifierRole === IdentifierRole.ObjectShorthandFunctionScopedDeclaration;
    }
    exports2.isObjectShorthandDeclaration = isObjectShorthandDeclaration;
    var Token = class {
      constructor() {
        this.type = _base.state.type;
        this.contextualKeyword = _base.state.contextualKeyword;
        this.start = _base.state.start;
        this.end = _base.state.end;
        this.scopeDepth = _base.state.scopeDepth;
        this.isType = _base.state.isType;
        this.identifierRole = null;
        this.jsxRole = null;
        this.shadowsGlobal = false;
        this.isAsyncOperation = false;
        this.contextId = null;
        this.rhsEndIndex = null;
        this.isExpression = false;
        this.numNullishCoalesceStarts = 0;
        this.numNullishCoalesceEnds = 0;
        this.isOptionalChainStart = false;
        this.isOptionalChainEnd = false;
        this.subscriptStartIndex = null;
        this.nullishStartIndex = null;
      }
      // Initially false for all tokens, then may be computed in a follow-up step that does scope
      // analysis.
      // Initially false for all tokens, but may be set during transform to mark it as containing an
      // await operation.
      // For assignments, the index of the RHS. For export tokens, the end of the export.
      // For class tokens, records if the class is a class expression or a class statement.
      // Number of times to insert a `nullishCoalesce(` snippet before this token.
      // Number of times to insert a `)` snippet after this token.
      // If true, insert an `optionalChain([` snippet before this token.
      // If true, insert a `])` snippet after this token.
      // Tag for `.`, `?.`, `[`, `?.[`, `(`, and `?.(` to denote the "root" token for this
      // subscript chain. This can be used to determine if this chain is an optional chain.
      // Tag for `??` operators to denote the root token for this nullish coalescing call.
    };
    exports2.Token = Token;
    function next() {
      _base.state.tokens.push(new Token());
      nextToken();
    }
    exports2.next = next;
    function nextTemplateToken() {
      _base.state.tokens.push(new Token());
      _base.state.start = _base.state.pos;
      readTmplToken();
    }
    exports2.nextTemplateToken = nextTemplateToken;
    function retokenizeSlashAsRegex() {
      if (_base.state.type === _types.TokenType.assign) {
        --_base.state.pos;
      }
      readRegexp();
    }
    exports2.retokenizeSlashAsRegex = retokenizeSlashAsRegex;
    function pushTypeContext(existingTokensInType) {
      for (let i = _base.state.tokens.length - existingTokensInType; i < _base.state.tokens.length; i++) {
        _base.state.tokens[i].isType = true;
      }
      const oldIsType = _base.state.isType;
      _base.state.isType = true;
      return oldIsType;
    }
    exports2.pushTypeContext = pushTypeContext;
    function popTypeContext(oldIsType) {
      _base.state.isType = oldIsType;
    }
    exports2.popTypeContext = popTypeContext;
    function eat(type) {
      if (match(type)) {
        next();
        return true;
      } else {
        return false;
      }
    }
    exports2.eat = eat;
    function eatTypeToken(tokenType) {
      const oldIsType = _base.state.isType;
      _base.state.isType = true;
      eat(tokenType);
      _base.state.isType = oldIsType;
    }
    exports2.eatTypeToken = eatTypeToken;
    function match(type) {
      return _base.state.type === type;
    }
    exports2.match = match;
    function lookaheadType() {
      const snapshot = _base.state.snapshot();
      next();
      const type = _base.state.type;
      _base.state.restoreFromSnapshot(snapshot);
      return type;
    }
    exports2.lookaheadType = lookaheadType;
    var TypeAndKeyword = class {
      constructor(type, contextualKeyword) {
        this.type = type;
        this.contextualKeyword = contextualKeyword;
      }
    };
    exports2.TypeAndKeyword = TypeAndKeyword;
    function lookaheadTypeAndKeyword() {
      const snapshot = _base.state.snapshot();
      next();
      const type = _base.state.type;
      const contextualKeyword = _base.state.contextualKeyword;
      _base.state.restoreFromSnapshot(snapshot);
      return new TypeAndKeyword(type, contextualKeyword);
    }
    exports2.lookaheadTypeAndKeyword = lookaheadTypeAndKeyword;
    function nextTokenStart() {
      return nextTokenStartSince(_base.state.pos);
    }
    exports2.nextTokenStart = nextTokenStart;
    function nextTokenStartSince(pos) {
      _whitespace.skipWhiteSpace.lastIndex = pos;
      const skip = _whitespace.skipWhiteSpace.exec(_base.input);
      return pos + skip[0].length;
    }
    exports2.nextTokenStartSince = nextTokenStartSince;
    function lookaheadCharCode() {
      return _base.input.charCodeAt(nextTokenStart());
    }
    exports2.lookaheadCharCode = lookaheadCharCode;
    function nextToken() {
      skipSpace();
      _base.state.start = _base.state.pos;
      if (_base.state.pos >= _base.input.length) {
        const tokens = _base.state.tokens;
        if (tokens.length >= 2 && tokens[tokens.length - 1].start >= _base.input.length && tokens[tokens.length - 2].start >= _base.input.length) {
          _util.unexpected.call(void 0, "Unexpectedly reached the end of input.");
        }
        finishToken(_types.TokenType.eof);
        return;
      }
      readToken(_base.input.charCodeAt(_base.state.pos));
    }
    exports2.nextToken = nextToken;
    function readToken(code) {
      if (_identifier.IS_IDENTIFIER_START[code] || code === _charcodes.charCodes.backslash || code === _charcodes.charCodes.atSign && _base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.atSign) {
        _readWord2.default.call(void 0);
      } else {
        getTokenFromCode(code);
      }
    }
    function skipBlockComment() {
      while (_base.input.charCodeAt(_base.state.pos) !== _charcodes.charCodes.asterisk || _base.input.charCodeAt(_base.state.pos + 1) !== _charcodes.charCodes.slash) {
        _base.state.pos++;
        if (_base.state.pos > _base.input.length) {
          _util.unexpected.call(void 0, "Unterminated comment", _base.state.pos - 2);
          return;
        }
      }
      _base.state.pos += 2;
    }
    function skipLineComment(startSkip) {
      let ch = _base.input.charCodeAt(_base.state.pos += startSkip);
      if (_base.state.pos < _base.input.length) {
        while (ch !== _charcodes.charCodes.lineFeed && ch !== _charcodes.charCodes.carriageReturn && ch !== _charcodes.charCodes.lineSeparator && ch !== _charcodes.charCodes.paragraphSeparator && ++_base.state.pos < _base.input.length) {
          ch = _base.input.charCodeAt(_base.state.pos);
        }
      }
    }
    exports2.skipLineComment = skipLineComment;
    function skipSpace() {
      while (_base.state.pos < _base.input.length) {
        const ch = _base.input.charCodeAt(_base.state.pos);
        switch (ch) {
          case _charcodes.charCodes.carriageReturn:
            if (_base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.lineFeed) {
              ++_base.state.pos;
            }
          case _charcodes.charCodes.lineFeed:
          case _charcodes.charCodes.lineSeparator:
          case _charcodes.charCodes.paragraphSeparator:
            ++_base.state.pos;
            break;
          case _charcodes.charCodes.slash:
            switch (_base.input.charCodeAt(_base.state.pos + 1)) {
              case _charcodes.charCodes.asterisk:
                _base.state.pos += 2;
                skipBlockComment();
                break;
              case _charcodes.charCodes.slash:
                skipLineComment(2);
                break;
              default:
                return;
            }
            break;
          default:
            if (_whitespace.IS_WHITESPACE[ch]) {
              ++_base.state.pos;
            } else {
              return;
            }
        }
      }
    }
    exports2.skipSpace = skipSpace;
    function finishToken(type, contextualKeyword = _keywords.ContextualKeyword.NONE) {
      _base.state.end = _base.state.pos;
      _base.state.type = type;
      _base.state.contextualKeyword = contextualKeyword;
    }
    exports2.finishToken = finishToken;
    function readToken_dot() {
      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      if (nextChar >= _charcodes.charCodes.digit0 && nextChar <= _charcodes.charCodes.digit9) {
        readNumber(true);
        return;
      }
      if (nextChar === _charcodes.charCodes.dot && _base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.dot) {
        _base.state.pos += 3;
        finishToken(_types.TokenType.ellipsis);
      } else {
        ++_base.state.pos;
        finishToken(_types.TokenType.dot);
      }
    }
    function readToken_slash() {
      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      if (nextChar === _charcodes.charCodes.equalsTo) {
        finishOp(_types.TokenType.assign, 2);
      } else {
        finishOp(_types.TokenType.slash, 1);
      }
    }
    function readToken_mult_modulo(code) {
      let tokenType = code === _charcodes.charCodes.asterisk ? _types.TokenType.star : _types.TokenType.modulo;
      let width = 1;
      let nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      if (code === _charcodes.charCodes.asterisk && nextChar === _charcodes.charCodes.asterisk) {
        width++;
        nextChar = _base.input.charCodeAt(_base.state.pos + 2);
        tokenType = _types.TokenType.exponent;
      }
      if (nextChar === _charcodes.charCodes.equalsTo && _base.input.charCodeAt(_base.state.pos + 2) !== _charcodes.charCodes.greaterThan) {
        width++;
        tokenType = _types.TokenType.assign;
      }
      finishOp(tokenType, width);
    }
    function readToken_pipe_amp(code) {
      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      if (nextChar === code) {
        if (_base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.equalsTo) {
          finishOp(_types.TokenType.assign, 3);
        } else {
          finishOp(code === _charcodes.charCodes.verticalBar ? _types.TokenType.logicalOR : _types.TokenType.logicalAND, 2);
        }
        return;
      }
      if (code === _charcodes.charCodes.verticalBar) {
        if (nextChar === _charcodes.charCodes.greaterThan) {
          finishOp(_types.TokenType.pipeline, 2);
          return;
        } else if (nextChar === _charcodes.charCodes.rightCurlyBrace && _base.isFlowEnabled) {
          finishOp(_types.TokenType.braceBarR, 2);
          return;
        }
      }
      if (nextChar === _charcodes.charCodes.equalsTo) {
        finishOp(_types.TokenType.assign, 2);
        return;
      }
      finishOp(code === _charcodes.charCodes.verticalBar ? _types.TokenType.bitwiseOR : _types.TokenType.bitwiseAND, 1);
    }
    function readToken_caret() {
      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      if (nextChar === _charcodes.charCodes.equalsTo) {
        finishOp(_types.TokenType.assign, 2);
      } else {
        finishOp(_types.TokenType.bitwiseXOR, 1);
      }
    }
    function readToken_plus_min(code) {
      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      if (nextChar === code) {
        finishOp(_types.TokenType.preIncDec, 2);
        return;
      }
      if (nextChar === _charcodes.charCodes.equalsTo) {
        finishOp(_types.TokenType.assign, 2);
      } else if (code === _charcodes.charCodes.plusSign) {
        finishOp(_types.TokenType.plus, 1);
      } else {
        finishOp(_types.TokenType.minus, 1);
      }
    }
    function readToken_lt() {
      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      if (nextChar === _charcodes.charCodes.lessThan) {
        if (_base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.equalsTo) {
          finishOp(_types.TokenType.assign, 3);
          return;
        }
        if (_base.state.isType) {
          finishOp(_types.TokenType.lessThan, 1);
        } else {
          finishOp(_types.TokenType.bitShiftL, 2);
        }
        return;
      }
      if (nextChar === _charcodes.charCodes.equalsTo) {
        finishOp(_types.TokenType.relationalOrEqual, 2);
      } else {
        finishOp(_types.TokenType.lessThan, 1);
      }
    }
    function readToken_gt() {
      if (_base.state.isType) {
        finishOp(_types.TokenType.greaterThan, 1);
        return;
      }
      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      if (nextChar === _charcodes.charCodes.greaterThan) {
        const size = _base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.greaterThan ? 3 : 2;
        if (_base.input.charCodeAt(_base.state.pos + size) === _charcodes.charCodes.equalsTo) {
          finishOp(_types.TokenType.assign, size + 1);
          return;
        }
        finishOp(_types.TokenType.bitShiftR, size);
        return;
      }
      if (nextChar === _charcodes.charCodes.equalsTo) {
        finishOp(_types.TokenType.relationalOrEqual, 2);
      } else {
        finishOp(_types.TokenType.greaterThan, 1);
      }
    }
    function rescan_gt() {
      if (_base.state.type === _types.TokenType.greaterThan) {
        _base.state.pos -= 1;
        readToken_gt();
      }
    }
    exports2.rescan_gt = rescan_gt;
    function readToken_eq_excl(code) {
      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      if (nextChar === _charcodes.charCodes.equalsTo) {
        finishOp(_types.TokenType.equality, _base.input.charCodeAt(_base.state.pos + 2) === _charcodes.charCodes.equalsTo ? 3 : 2);
        return;
      }
      if (code === _charcodes.charCodes.equalsTo && nextChar === _charcodes.charCodes.greaterThan) {
        _base.state.pos += 2;
        finishToken(_types.TokenType.arrow);
        return;
      }
      finishOp(code === _charcodes.charCodes.equalsTo ? _types.TokenType.eq : _types.TokenType.bang, 1);
    }
    function readToken_question() {
      const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
      const nextChar2 = _base.input.charCodeAt(_base.state.pos + 2);
      if (nextChar === _charcodes.charCodes.questionMark && // In Flow (but not TypeScript), ??string is a valid type that should be
      // tokenized as two individual ? tokens.
      !(_base.isFlowEnabled && _base.state.isType)) {
        if (nextChar2 === _charcodes.charCodes.equalsTo) {
          finishOp(_types.TokenType.assign, 3);
        } else {
          finishOp(_types.TokenType.nullishCoalescing, 2);
        }
      } else if (nextChar === _charcodes.charCodes.dot && !(nextChar2 >= _charcodes.charCodes.digit0 && nextChar2 <= _charcodes.charCodes.digit9)) {
        _base.state.pos += 2;
        finishToken(_types.TokenType.questionDot);
      } else {
        ++_base.state.pos;
        finishToken(_types.TokenType.question);
      }
    }
    function getTokenFromCode(code) {
      switch (code) {
        case _charcodes.charCodes.numberSign:
          ++_base.state.pos;
          finishToken(_types.TokenType.hash);
          return;
        // The interpretation of a dot depends on whether it is followed
        // by a digit or another two dots.
        case _charcodes.charCodes.dot:
          readToken_dot();
          return;
        // Punctuation tokens.
        case _charcodes.charCodes.leftParenthesis:
          ++_base.state.pos;
          finishToken(_types.TokenType.parenL);
          return;
        case _charcodes.charCodes.rightParenthesis:
          ++_base.state.pos;
          finishToken(_types.TokenType.parenR);
          return;
        case _charcodes.charCodes.semicolon:
          ++_base.state.pos;
          finishToken(_types.TokenType.semi);
          return;
        case _charcodes.charCodes.comma:
          ++_base.state.pos;
          finishToken(_types.TokenType.comma);
          return;
        case _charcodes.charCodes.leftSquareBracket:
          ++_base.state.pos;
          finishToken(_types.TokenType.bracketL);
          return;
        case _charcodes.charCodes.rightSquareBracket:
          ++_base.state.pos;
          finishToken(_types.TokenType.bracketR);
          return;
        case _charcodes.charCodes.leftCurlyBrace:
          if (_base.isFlowEnabled && _base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.verticalBar) {
            finishOp(_types.TokenType.braceBarL, 2);
          } else {
            ++_base.state.pos;
            finishToken(_types.TokenType.braceL);
          }
          return;
        case _charcodes.charCodes.rightCurlyBrace:
          ++_base.state.pos;
          finishToken(_types.TokenType.braceR);
          return;
        case _charcodes.charCodes.colon:
          if (_base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.colon) {
            finishOp(_types.TokenType.doubleColon, 2);
          } else {
            ++_base.state.pos;
            finishToken(_types.TokenType.colon);
          }
          return;
        case _charcodes.charCodes.questionMark:
          readToken_question();
          return;
        case _charcodes.charCodes.atSign:
          ++_base.state.pos;
          finishToken(_types.TokenType.at);
          return;
        case _charcodes.charCodes.graveAccent:
          ++_base.state.pos;
          finishToken(_types.TokenType.backQuote);
          return;
        case _charcodes.charCodes.digit0: {
          const nextChar = _base.input.charCodeAt(_base.state.pos + 1);
          if (nextChar === _charcodes.charCodes.lowercaseX || nextChar === _charcodes.charCodes.uppercaseX || nextChar === _charcodes.charCodes.lowercaseO || nextChar === _charcodes.charCodes.uppercaseO || nextChar === _charcodes.charCodes.lowercaseB || nextChar === _charcodes.charCodes.uppercaseB) {
            readRadixNumber();
            return;
          }
        }
        // Anything else beginning with a digit is an integer, octal
        // number, or float.
        case _charcodes.charCodes.digit1:
        case _charcodes.charCodes.digit2:
        case _charcodes.charCodes.digit3:
        case _charcodes.charCodes.digit4:
        case _charcodes.charCodes.digit5:
        case _charcodes.charCodes.digit6:
        case _charcodes.charCodes.digit7:
        case _charcodes.charCodes.digit8:
        case _charcodes.charCodes.digit9:
          readNumber(false);
          return;
        // Quotes produce strings.
        case _charcodes.charCodes.quotationMark:
        case _charcodes.charCodes.apostrophe:
          readString(code);
          return;
        // Operators are parsed inline in tiny state machines. '=' (charCodes.equalsTo) is
        // often referred to. `finishOp` simply skips the amount of
        // characters it is given as second argument, and returns a token
        // of the type given by its first argument.
        case _charcodes.charCodes.slash:
          readToken_slash();
          return;
        case _charcodes.charCodes.percentSign:
        case _charcodes.charCodes.asterisk:
          readToken_mult_modulo(code);
          return;
        case _charcodes.charCodes.verticalBar:
        case _charcodes.charCodes.ampersand:
          readToken_pipe_amp(code);
          return;
        case _charcodes.charCodes.caret:
          readToken_caret();
          return;
        case _charcodes.charCodes.plusSign:
        case _charcodes.charCodes.dash:
          readToken_plus_min(code);
          return;
        case _charcodes.charCodes.lessThan:
          readToken_lt();
          return;
        case _charcodes.charCodes.greaterThan:
          readToken_gt();
          return;
        case _charcodes.charCodes.equalsTo:
        case _charcodes.charCodes.exclamationMark:
          readToken_eq_excl(code);
          return;
        case _charcodes.charCodes.tilde:
          finishOp(_types.TokenType.tilde, 1);
          return;
        default:
          break;
      }
      _util.unexpected.call(void 0, `Unexpected character '${String.fromCharCode(code)}'`, _base.state.pos);
    }
    exports2.getTokenFromCode = getTokenFromCode;
    function finishOp(type, size) {
      _base.state.pos += size;
      finishToken(type);
    }
    function readRegexp() {
      const start = _base.state.pos;
      let escaped = false;
      let inClass = false;
      for (; ; ) {
        if (_base.state.pos >= _base.input.length) {
          _util.unexpected.call(void 0, "Unterminated regular expression", start);
          return;
        }
        const code = _base.input.charCodeAt(_base.state.pos);
        if (escaped) {
          escaped = false;
        } else {
          if (code === _charcodes.charCodes.leftSquareBracket) {
            inClass = true;
          } else if (code === _charcodes.charCodes.rightSquareBracket && inClass) {
            inClass = false;
          } else if (code === _charcodes.charCodes.slash && !inClass) {
            break;
          }
          escaped = code === _charcodes.charCodes.backslash;
        }
        ++_base.state.pos;
      }
      ++_base.state.pos;
      skipWord();
      finishToken(_types.TokenType.regexp);
    }
    function readInt() {
      while (true) {
        const code = _base.input.charCodeAt(_base.state.pos);
        if (code >= _charcodes.charCodes.digit0 && code <= _charcodes.charCodes.digit9 || code === _charcodes.charCodes.underscore) {
          _base.state.pos++;
        } else {
          break;
        }
      }
    }
    function readRadixNumber() {
      _base.state.pos += 2;
      while (true) {
        const code = _base.input.charCodeAt(_base.state.pos);
        if (code >= _charcodes.charCodes.digit0 && code <= _charcodes.charCodes.digit9 || code >= _charcodes.charCodes.lowercaseA && code <= _charcodes.charCodes.lowercaseF || code >= _charcodes.charCodes.uppercaseA && code <= _charcodes.charCodes.uppercaseF || code === _charcodes.charCodes.underscore) {
          _base.state.pos++;
        } else {
          break;
        }
      }
      const nextChar = _base.input.charCodeAt(_base.state.pos);
      if (nextChar === _charcodes.charCodes.lowercaseN) {
        ++_base.state.pos;
        finishToken(_types.TokenType.bigint);
      } else {
        finishToken(_types.TokenType.num);
      }
    }
    function readNumber(startsWithDot) {
      let isBigInt = false;
      let isDecimal = false;
      if (!startsWithDot) {
        readInt();
      }
      let nextChar = _base.input.charCodeAt(_base.state.pos);
      if (nextChar === _charcodes.charCodes.dot) {
        ++_base.state.pos;
        readInt();
        nextChar = _base.input.charCodeAt(_base.state.pos);
      }
      if (nextChar === _charcodes.charCodes.uppercaseE || nextChar === _charcodes.charCodes.lowercaseE) {
        nextChar = _base.input.charCodeAt(++_base.state.pos);
        if (nextChar === _charcodes.charCodes.plusSign || nextChar === _charcodes.charCodes.dash) {
          ++_base.state.pos;
        }
        readInt();
        nextChar = _base.input.charCodeAt(_base.state.pos);
      }
      if (nextChar === _charcodes.charCodes.lowercaseN) {
        ++_base.state.pos;
        isBigInt = true;
      } else if (nextChar === _charcodes.charCodes.lowercaseM) {
        ++_base.state.pos;
        isDecimal = true;
      }
      if (isBigInt) {
        finishToken(_types.TokenType.bigint);
        return;
      }
      if (isDecimal) {
        finishToken(_types.TokenType.decimal);
        return;
      }
      finishToken(_types.TokenType.num);
    }
    function readString(quote) {
      _base.state.pos++;
      for (; ; ) {
        if (_base.state.pos >= _base.input.length) {
          _util.unexpected.call(void 0, "Unterminated string constant");
          return;
        }
        const ch = _base.input.charCodeAt(_base.state.pos);
        if (ch === _charcodes.charCodes.backslash) {
          _base.state.pos++;
        } else if (ch === quote) {
          break;
        }
        _base.state.pos++;
      }
      _base.state.pos++;
      finishToken(_types.TokenType.string);
    }
    function readTmplToken() {
      for (; ; ) {
        if (_base.state.pos >= _base.input.length) {
          _util.unexpected.call(void 0, "Unterminated template");
          return;
        }
        const ch = _base.input.charCodeAt(_base.state.pos);
        if (ch === _charcodes.charCodes.graveAccent || ch === _charcodes.charCodes.dollarSign && _base.input.charCodeAt(_base.state.pos + 1) === _charcodes.charCodes.leftCurlyBrace) {
          if (_base.state.pos === _base.state.start && match(_types.TokenType.template)) {
            if (ch === _charcodes.charCodes.dollarSign) {
              _base.state.pos += 2;
              finishToken(_types.TokenType.dollarBraceL);
              return;
            } else {
              ++_base.state.pos;
              finishToken(_types.TokenType.backQuote);
              return;
            }
          }
          finishToken(_types.TokenType.template);
          return;
        }
        if (ch === _charcodes.charCodes.backslash) {
          _base.state.pos++;
        }
        _base.state.pos++;
      }
    }
    function skipWord() {
      while (_base.state.pos < _base.input.length) {
        const ch = _base.input.charCodeAt(_base.state.pos);
        if (_identifier.IS_IDENTIFIER_CHAR[ch]) {
          _base.state.pos++;
        } else if (ch === _charcodes.charCodes.backslash) {
          _base.state.pos += 2;
          if (_base.input.charCodeAt(_base.state.pos) === _charcodes.charCodes.leftCurlyBrace) {
            while (_base.state.pos < _base.input.length && _base.input.charCodeAt(_base.state.pos) !== _charcodes.charCodes.rightCurlyBrace) {
              _base.state.pos++;
            }
            _base.state.pos++;
          }
        } else {
          break;
        }
      }
    }
    exports2.skipWord = skipWord;
  }
});

// node_modules/sucrase/dist/util/getImportExportSpecifierInfo.js
var require_getImportExportSpecifierInfo = __commonJS({
  "node_modules/sucrase/dist/util/getImportExportSpecifierInfo.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _types = require_types();
    function getImportExportSpecifierInfo(tokens, index = tokens.currentIndex()) {
      let endIndex = index + 1;
      if (isSpecifierEnd(tokens, endIndex)) {
        const name28 = tokens.identifierNameAtIndex(index);
        return {
          isType: false,
          leftName: name28,
          rightName: name28,
          endIndex
        };
      }
      endIndex++;
      if (isSpecifierEnd(tokens, endIndex)) {
        return {
          isType: true,
          leftName: null,
          rightName: null,
          endIndex
        };
      }
      endIndex++;
      if (isSpecifierEnd(tokens, endIndex)) {
        return {
          isType: false,
          leftName: tokens.identifierNameAtIndex(index),
          rightName: tokens.identifierNameAtIndex(index + 2),
          endIndex
        };
      }
      endIndex++;
      if (isSpecifierEnd(tokens, endIndex)) {
        return {
          isType: true,
          leftName: null,
          rightName: null,
          endIndex
        };
      }
      throw new Error(`Unexpected import/export specifier at ${index}`);
    }
    exports2.default = getImportExportSpecifierInfo;
    function isSpecifierEnd(tokens, index) {
      const token = tokens.tokens[index];
      return token.type === _types.TokenType.braceR || token.type === _types.TokenType.comma;
    }
  }
});

// node_modules/sucrase/dist/parser/plugins/jsx/xhtml.js
var require_xhtml = __commonJS({
  "node_modules/sucrase/dist/parser/plugins/jsx/xhtml.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = /* @__PURE__ */ new Map([
      ["quot", '"'],
      ["amp", "&"],
      ["apos", "'"],
      ["lt", "<"],
      ["gt", ">"],
      ["nbsp", "\xA0"],
      ["iexcl", "\xA1"],
      ["cent", "\xA2"],
      ["pound", "\xA3"],
      ["curren", "\xA4"],
      ["yen", "\xA5"],
      ["brvbar", "\xA6"],
      ["sect", "\xA7"],
      ["uml", "\xA8"],
      ["copy", "\xA9"],
      ["ordf", "\xAA"],
      ["laquo", "\xAB"],
      ["not", "\xAC"],
      ["shy", "\xAD"],
      ["reg", "\xAE"],
      ["macr", "\xAF"],
      ["deg", "\xB0"],
      ["plusmn", "\xB1"],
      ["sup2", "\xB2"],
      ["sup3", "\xB3"],
      ["acute", "\xB4"],
      ["micro", "\xB5"],
      ["para", "\xB6"],
      ["middot", "\xB7"],
      ["cedil", "\xB8"],
      ["sup1", "\xB9"],
      ["ordm", "\xBA"],
      ["raquo", "\xBB"],
      ["frac14", "\xBC"],
      ["frac12", "\xBD"],
      ["frac34", "\xBE"],
      ["iquest", "\xBF"],
      ["Agrave", "\xC0"],
      ["Aacute", "\xC1"],
      ["Acirc", "\xC2"],
      ["Atilde", "\xC3"],
      ["Auml", "\xC4"],
      ["Aring", "\xC5"],
      ["AElig", "\xC6"],
      ["Ccedil", "\xC7"],
      ["Egrave", "\xC8"],
      ["Eacute", "\xC9"],
      ["Ecirc", "\xCA"],
      ["Euml", "\xCB"],
      ["Igrave", "\xCC"],
      ["Iacute", "\xCD"],
      ["Icirc", "\xCE"],
      ["Iuml", "\xCF"],
      ["ETH", "\xD0"],
      ["Ntilde", "\xD1"],
      ["Ograve", "\xD2"],
      ["Oacute", "\xD3"],
      ["Ocirc", "\xD4"],
      ["Otilde", "\xD5"],
      ["Ouml", "\xD6"],
      ["times", "\xD7"],
      ["Oslash", "\xD8"],
      ["Ugrave", "\xD9"],
      ["Uacute", "\xDA"],
      ["Ucirc", "\xDB"],
      ["Uuml", "\xDC"],
      ["Yacute", "\xDD"],
      ["THORN", "\xDE"],
      ["szlig", "\xDF"],
      ["agrave", "\xE0"],
      ["aacute", "\xE1"],
      ["acirc", "\xE2"],
      ["atilde", "\xE3"],
      ["auml", "\xE4"],
      ["aring", "\xE5"],
      ["aelig", "\xE6"],
      ["ccedil", "\xE7"],
      ["egrave", "\xE8"],
      ["eacute", "\xE9"],
      ["ecirc", "\xEA"],
      ["euml", "\xEB"],
      ["igrave", "\xEC"],
      ["iacute", "\xED"],
      ["icirc", "\xEE"],
      ["iuml", "\xEF"],
      ["eth", "\xF0"],
      ["ntilde", "\xF1"],
      ["ograve", "\xF2"],
      ["oacute", "\xF3"],
      ["ocirc", "\xF4"],
      ["otilde", "\xF5"],
      ["ouml", "\xF6"],
      ["divide", "\xF7"],
      ["oslash", "\xF8"],
      ["ugrave", "\xF9"],
      ["uacute", "\xFA"],
      ["ucirc", "\xFB"],
      ["uuml", "\xFC"],
      ["yacute", "\xFD"],
      ["thorn", "\xFE"],
      ["yuml", "\xFF"],
      ["OElig", "\u0152"],
      ["oelig", "\u0153"],
      ["Scaron", "\u0160"],
      ["scaron", "\u0161"],
      ["Yuml", "\u0178"],
      ["fnof", "\u0192"],
      ["circ", "\u02C6"],
      ["tilde", "\u02DC"],
      ["Alpha", "\u0391"],
      ["Beta", "\u0392"],
      ["Gamma", "\u0393"],
      ["Delta", "\u0394"],
      ["Epsilon", "\u0395"],
      ["Zeta", "\u0396"],
      ["Eta", "\u0397"],
      ["Theta", "\u0398"],
      ["Iota", "\u0399"],
      ["Kappa", "\u039A"],
      ["Lambda", "\u039B"],
      ["Mu", "\u039C"],
      ["Nu", "\u039D"],
      ["Xi", "\u039E"],
      ["Omicron", "\u039F"],
      ["Pi", "\u03A0"],
      ["Rho", "\u03A1"],
      ["Sigma", "\u03A3"],
      ["Tau", "\u03A4"],
      ["Upsilon", "\u03A5"],
      ["Phi", "\u03A6"],
      ["Chi", "\u03A7"],
      ["Psi", "\u03A8"],
      ["Omega", "\u03A9"],
      ["alpha", "\u03B1"],
      ["beta", "\u03B2"],
      ["gamma", "\u03B3"],
      ["delta", "\u03B4"],
      ["epsilon", "\u03B5"],
      ["zeta", "\u03B6"],
      ["eta", "\u03B7"],
      ["theta", "\u03B8"],
      ["iota", "\u03B9"],
      ["kappa", "\u03BA"],
      ["lambda", "\u03BB"],
      ["mu", "\u03BC"],
      ["nu", "\u03BD"],
      ["xi", "\u03BE"],
      ["omicron", "\u03BF"],
      ["pi", "\u03C0"],
      ["rho", "\u03C1"],
      ["sigmaf", "\u03C2"],
      ["sigma", "\u03C3"],
      ["tau", "\u03C4"],
      ["upsilon", "\u03C5"],
      ["phi", "\u03C6"],
      ["chi", "\u03C7"],
      ["psi", "\u03C8"],
      ["omega", "\u03C9"],
      ["thetasym", "\u03D1"],
      ["upsih", "\u03D2"],
      ["piv", "\u03D6"],
      ["ensp", "\u2002"],
      ["emsp", "\u2003"],
      ["thinsp", "\u2009"],
      ["zwnj", "\u200C"],
      ["zwj", "\u200D"],
      ["lrm", "\u200E"],
      ["rlm", "\u200F"],
      ["ndash", "\u2013"],
      ["mdash", "\u2014"],
      ["lsquo", "\u2018"],
      ["rsquo", "\u2019"],
      ["sbquo", "\u201A"],
      ["ldquo", "\u201C"],
      ["rdquo", "\u201D"],
      ["bdquo", "\u201E"],
      ["dagger", "\u2020"],
      ["Dagger", "\u2021"],
      ["bull", "\u2022"],
      ["hellip", "\u2026"],
      ["permil", "\u2030"],
      ["prime", "\u2032"],
      ["Prime", "\u2033"],
      ["lsaquo", "\u2039"],
      ["rsaquo", "\u203A"],
      ["oline", "\u203E"],
      ["frasl", "\u2044"],
      ["euro", "\u20AC"],
      ["image", "\u2111"],
      ["weierp", "\u2118"],
      ["real", "\u211C"],
      ["trade", "\u2122"],
      ["alefsym", "\u2135"],
      ["larr", "\u2190"],
      ["uarr", "\u2191"],
      ["rarr", "\u2192"],
      ["darr", "\u2193"],
      ["harr", "\u2194"],
      ["crarr", "\u21B5"],
      ["lArr", "\u21D0"],
      ["uArr", "\u21D1"],
      ["rArr", "\u21D2"],
      ["dArr", "\u21D3"],
      ["hArr", "\u21D4"],
      ["forall", "\u2200"],
      ["part", "\u2202"],
      ["exist", "\u2203"],
      ["empty", "\u2205"],
      ["nabla", "\u2207"],
      ["isin", "\u2208"],
      ["notin", "\u2209"],
      ["ni", "\u220B"],
      ["prod", "\u220F"],
      ["sum", "\u2211"],
      ["minus", "\u2212"],
      ["lowast", "\u2217"],
      ["radic", "\u221A"],
      ["prop", "\u221D"],
      ["infin", "\u221E"],
      ["ang", "\u2220"],
      ["and", "\u2227"],
      ["or", "\u2228"],
      ["cap", "\u2229"],
      ["cup", "\u222A"],
      ["int", "\u222B"],
      ["there4", "\u2234"],
      ["sim", "\u223C"],
      ["cong", "\u2245"],
      ["asymp", "\u2248"],
      ["ne", "\u2260"],
      ["equiv", "\u2261"],
      ["le", "\u2264"],
      ["ge", "\u2265"],
      ["sub", "\u2282"],
      ["sup", "\u2283"],
      ["nsub", "\u2284"],
      ["sube", "\u2286"],
      ["supe", "\u2287"],
      ["oplus", "\u2295"],
      ["otimes", "\u2297"],
      ["perp", "\u22A5"],
      ["sdot", "\u22C5"],
      ["lceil", "\u2308"],
      ["rceil", "\u2309"],
      ["lfloor", "\u230A"],
      ["rfloor", "\u230B"],
      ["lang", "\u2329"],
      ["rang", "\u232A"],
      ["loz", "\u25CA"],
      ["spades", "\u2660"],
      ["clubs", "\u2663"],
      ["hearts", "\u2665"],
      ["diams", "\u2666"]
    ]);
  }
});

// node_modules/sucrase/dist/util/getJSXPragmaInfo.js
var require_getJSXPragmaInfo = __commonJS({
  "node_modules/sucrase/dist/util/getJSXPragmaInfo.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function getJSXPragmaInfo(options) {
      const [base, suffix] = splitPragma(options.jsxPragma || "React.createElement");
      const [fragmentBase, fragmentSuffix] = splitPragma(options.jsxFragmentPragma || "React.Fragment");
      return { base, suffix, fragmentBase, fragmentSuffix };
    }
    exports2.default = getJSXPragmaInfo;
    function splitPragma(pragma) {
      let dotIndex = pragma.indexOf(".");
      if (dotIndex === -1) {
        dotIndex = pragma.length;
      }
      return [pragma.slice(0, dotIndex), pragma.slice(dotIndex)];
    }
  }
});

// node_modules/sucrase/dist/transformers/Transformer.js
var require_Transformer = __commonJS({
  "node_modules/sucrase/dist/transformers/Transformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var Transformer = class {
      // Return true if anything was processed, false otherwise.
      getPrefixCode() {
        return "";
      }
      getHoistedCode() {
        return "";
      }
      getSuffixCode() {
        return "";
      }
    };
    exports2.default = Transformer;
  }
});

// node_modules/sucrase/dist/transformers/JSXTransformer.js
var require_JSXTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/JSXTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _xhtml = require_xhtml();
    var _xhtml2 = _interopRequireDefault(_xhtml);
    var _tokenizer = require_tokenizer2();
    var _types = require_types();
    var _charcodes = require_charcodes();
    var _getJSXPragmaInfo = require_getJSXPragmaInfo();
    var _getJSXPragmaInfo2 = _interopRequireDefault(_getJSXPragmaInfo);
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var JSXTransformer = class _JSXTransformer extends _Transformer2.default {
      // State for calculating the line number of each JSX tag in development.
      __init() {
        this.lastLineNumber = 1;
      }
      __init2() {
        this.lastIndex = 0;
      }
      // In development, variable name holding the name of the current file.
      __init3() {
        this.filenameVarName = null;
      }
      // Mapping of claimed names for imports in the automatic transform, e,g.
      // {jsx: "_jsx"}. This determines which imports to generate in the prefix.
      __init4() {
        this.esmAutomaticImportNameResolutions = {};
      }
      // When automatically adding imports in CJS mode, we store the variable name
      // holding the imported CJS module so we can require it in the prefix.
      __init5() {
        this.cjsAutomaticModuleNameResolutions = {};
      }
      constructor(rootTransformer, tokens, importProcessor, nameManager, options) {
        super();
        this.rootTransformer = rootTransformer;
        this.tokens = tokens;
        this.importProcessor = importProcessor;
        this.nameManager = nameManager;
        this.options = options;
        _JSXTransformer.prototype.__init.call(this);
        _JSXTransformer.prototype.__init2.call(this);
        _JSXTransformer.prototype.__init3.call(this);
        _JSXTransformer.prototype.__init4.call(this);
        _JSXTransformer.prototype.__init5.call(this);
        ;
        this.jsxPragmaInfo = _getJSXPragmaInfo2.default.call(void 0, options);
        this.isAutomaticRuntime = options.jsxRuntime === "automatic";
        this.jsxImportSource = options.jsxImportSource || "react";
      }
      process() {
        if (this.tokens.matches1(_types.TokenType.jsxTagStart)) {
          this.processJSXTag();
          return true;
        }
        return false;
      }
      getPrefixCode() {
        let prefix = "";
        if (this.filenameVarName) {
          prefix += `const ${this.filenameVarName} = ${JSON.stringify(this.options.filePath || "")};`;
        }
        if (this.isAutomaticRuntime) {
          if (this.importProcessor) {
            for (const [path33, resolvedName] of Object.entries(this.cjsAutomaticModuleNameResolutions)) {
              prefix += `var ${resolvedName} = require("${path33}");`;
            }
          } else {
            const { createElement: createElementResolution, ...otherResolutions } = this.esmAutomaticImportNameResolutions;
            if (createElementResolution) {
              prefix += `import {createElement as ${createElementResolution}} from "${this.jsxImportSource}";`;
            }
            const importSpecifiers = Object.entries(otherResolutions).map(([name28, resolvedName]) => `${name28} as ${resolvedName}`).join(", ");
            if (importSpecifiers) {
              const importPath = this.jsxImportSource + (this.options.production ? "/jsx-runtime" : "/jsx-dev-runtime");
              prefix += `import {${importSpecifiers}} from "${importPath}";`;
            }
          }
        }
        return prefix;
      }
      processJSXTag() {
        const { jsxRole, start } = this.tokens.currentToken();
        const elementLocationCode = this.options.production ? null : this.getElementLocationCode(start);
        if (this.isAutomaticRuntime && jsxRole !== _tokenizer.JSXRole.KeyAfterPropSpread) {
          this.transformTagToJSXFunc(elementLocationCode, jsxRole);
        } else {
          this.transformTagToCreateElement(elementLocationCode);
        }
      }
      getElementLocationCode(firstTokenStart) {
        const lineNumber = this.getLineNumberForIndex(firstTokenStart);
        return `lineNumber: ${lineNumber}`;
      }
      /**
       * Get the line number for this source position. This is calculated lazily and
       * must be called in increasing order by index.
       */
      getLineNumberForIndex(index) {
        const code = this.tokens.code;
        while (this.lastIndex < index && this.lastIndex < code.length) {
          if (code[this.lastIndex] === "\n") {
            this.lastLineNumber++;
          }
          this.lastIndex++;
        }
        return this.lastLineNumber;
      }
      /**
       * Convert the current JSX element to a call to jsx, jsxs, or jsxDEV. This is
       * the primary transformation for the automatic transform.
       *
       * Example:
       * <div a={1} key={2}>Hello{x}</div>
       * becomes
       * jsxs('div', {a: 1, children: ["Hello", x]}, 2)
       */
      transformTagToJSXFunc(elementLocationCode, jsxRole) {
        const isStatic = jsxRole === _tokenizer.JSXRole.StaticChildren;
        this.tokens.replaceToken(this.getJSXFuncInvocationCode(isStatic));
        let keyCode = null;
        if (this.tokens.matches1(_types.TokenType.jsxTagEnd)) {
          this.tokens.replaceToken(`${this.getFragmentCode()}, {`);
          this.processAutomaticChildrenAndEndProps(jsxRole);
        } else {
          this.processTagIntro();
          this.tokens.appendCode(", {");
          keyCode = this.processProps(true);
          if (this.tokens.matches2(_types.TokenType.slash, _types.TokenType.jsxTagEnd)) {
            this.tokens.appendCode("}");
          } else if (this.tokens.matches1(_types.TokenType.jsxTagEnd)) {
            this.tokens.removeToken();
            this.processAutomaticChildrenAndEndProps(jsxRole);
          } else {
            throw new Error("Expected either /> or > at the end of the tag.");
          }
          if (keyCode) {
            this.tokens.appendCode(`, ${keyCode}`);
          }
        }
        if (!this.options.production) {
          if (keyCode === null) {
            this.tokens.appendCode(", void 0");
          }
          this.tokens.appendCode(`, ${isStatic}, ${this.getDevSource(elementLocationCode)}, this`);
        }
        this.tokens.removeInitialToken();
        while (!this.tokens.matches1(_types.TokenType.jsxTagEnd)) {
          this.tokens.removeToken();
        }
        this.tokens.replaceToken(")");
      }
      /**
       * Convert the current JSX element to a createElement call. In the classic
       * runtime, this is the only case. In the automatic runtime, this is called
       * as a fallback in some situations.
       *
       * Example:
       * <div a={1} key={2}>Hello{x}</div>
       * becomes
       * React.createElement('div', {a: 1, key: 2}, "Hello", x)
       */
      transformTagToCreateElement(elementLocationCode) {
        this.tokens.replaceToken(this.getCreateElementInvocationCode());
        if (this.tokens.matches1(_types.TokenType.jsxTagEnd)) {
          this.tokens.replaceToken(`${this.getFragmentCode()}, null`);
          this.processChildren(true);
        } else {
          this.processTagIntro();
          this.processPropsObjectWithDevInfo(elementLocationCode);
          if (this.tokens.matches2(_types.TokenType.slash, _types.TokenType.jsxTagEnd)) {
          } else if (this.tokens.matches1(_types.TokenType.jsxTagEnd)) {
            this.tokens.removeToken();
            this.processChildren(true);
          } else {
            throw new Error("Expected either /> or > at the end of the tag.");
          }
        }
        this.tokens.removeInitialToken();
        while (!this.tokens.matches1(_types.TokenType.jsxTagEnd)) {
          this.tokens.removeToken();
        }
        this.tokens.replaceToken(")");
      }
      /**
       * Get the code for the relevant function for this context: jsx, jsxs,
       * or jsxDEV. The following open-paren is included as well.
       *
       * These functions are only used for the automatic runtime, so they are always
       * auto-imported, but the auto-import will be either CJS or ESM based on the
       * target module format.
       */
      getJSXFuncInvocationCode(isStatic) {
        if (this.options.production) {
          if (isStatic) {
            return this.claimAutoImportedFuncInvocation("jsxs", "/jsx-runtime");
          } else {
            return this.claimAutoImportedFuncInvocation("jsx", "/jsx-runtime");
          }
        } else {
          return this.claimAutoImportedFuncInvocation("jsxDEV", "/jsx-dev-runtime");
        }
      }
      /**
       * Return the code to use for the createElement function, e.g.
       * `React.createElement`, including the following open-paren.
       *
       * This is the main function to use for the classic runtime. For the
       * automatic runtime, this function is used as a fallback function to
       * preserve behavior when there is a prop spread followed by an explicit
       * key. In that automatic runtime case, the function should be automatically
       * imported.
       */
      getCreateElementInvocationCode() {
        if (this.isAutomaticRuntime) {
          return this.claimAutoImportedFuncInvocation("createElement", "");
        } else {
          const { jsxPragmaInfo } = this;
          const resolvedPragmaBaseName = this.importProcessor ? this.importProcessor.getIdentifierReplacement(jsxPragmaInfo.base) || jsxPragmaInfo.base : jsxPragmaInfo.base;
          return `${resolvedPragmaBaseName}${jsxPragmaInfo.suffix}(`;
        }
      }
      /**
       * Return the code to use as the component when compiling a shorthand
       * fragment, e.g. `React.Fragment`.
       *
       * This may be called from either the classic or automatic runtime, and
       * the value should be auto-imported for the automatic runtime.
       */
      getFragmentCode() {
        if (this.isAutomaticRuntime) {
          return this.claimAutoImportedName(
            "Fragment",
            this.options.production ? "/jsx-runtime" : "/jsx-dev-runtime"
          );
        } else {
          const { jsxPragmaInfo } = this;
          const resolvedFragmentPragmaBaseName = this.importProcessor ? this.importProcessor.getIdentifierReplacement(jsxPragmaInfo.fragmentBase) || jsxPragmaInfo.fragmentBase : jsxPragmaInfo.fragmentBase;
          return resolvedFragmentPragmaBaseName + jsxPragmaInfo.fragmentSuffix;
        }
      }
      /**
       * Return code that invokes the given function.
       *
       * When the imports transform is enabled, use the CJSImportTransformer
       * strategy of using `.call(void 0, ...` to avoid passing a `this` value in a
       * situation that would otherwise look like a method call.
       */
      claimAutoImportedFuncInvocation(funcName, importPathSuffix) {
        const funcCode = this.claimAutoImportedName(funcName, importPathSuffix);
        if (this.importProcessor) {
          return `${funcCode}.call(void 0, `;
        } else {
          return `${funcCode}(`;
        }
      }
      claimAutoImportedName(funcName, importPathSuffix) {
        if (this.importProcessor) {
          const path33 = this.jsxImportSource + importPathSuffix;
          if (!this.cjsAutomaticModuleNameResolutions[path33]) {
            this.cjsAutomaticModuleNameResolutions[path33] = this.importProcessor.getFreeIdentifierForPath(path33);
          }
          return `${this.cjsAutomaticModuleNameResolutions[path33]}.${funcName}`;
        } else {
          if (!this.esmAutomaticImportNameResolutions[funcName]) {
            this.esmAutomaticImportNameResolutions[funcName] = this.nameManager.claimFreeName(
              `_${funcName}`
            );
          }
          return this.esmAutomaticImportNameResolutions[funcName];
        }
      }
      /**
       * Process the first part of a tag, before any props.
       */
      processTagIntro() {
        let introEnd = this.tokens.currentIndex() + 1;
        while (this.tokens.tokens[introEnd].isType || !this.tokens.matches2AtIndex(introEnd - 1, _types.TokenType.jsxName, _types.TokenType.jsxName) && !this.tokens.matches2AtIndex(introEnd - 1, _types.TokenType.greaterThan, _types.TokenType.jsxName) && !this.tokens.matches1AtIndex(introEnd, _types.TokenType.braceL) && !this.tokens.matches1AtIndex(introEnd, _types.TokenType.jsxTagEnd) && !this.tokens.matches2AtIndex(introEnd, _types.TokenType.slash, _types.TokenType.jsxTagEnd)) {
          introEnd++;
        }
        if (introEnd === this.tokens.currentIndex() + 1) {
          const tagName = this.tokens.identifierName();
          if (startsWithLowerCase(tagName)) {
            this.tokens.replaceToken(`'${tagName}'`);
          }
        }
        while (this.tokens.currentIndex() < introEnd) {
          this.rootTransformer.processToken();
        }
      }
      /**
       * Starting at the beginning of the props, add the props argument to
       * React.createElement, including the comma before it.
       */
      processPropsObjectWithDevInfo(elementLocationCode) {
        const devProps = this.options.production ? "" : `__self: this, __source: ${this.getDevSource(elementLocationCode)}`;
        if (!this.tokens.matches1(_types.TokenType.jsxName) && !this.tokens.matches1(_types.TokenType.braceL)) {
          if (devProps) {
            this.tokens.appendCode(`, {${devProps}}`);
          } else {
            this.tokens.appendCode(`, null`);
          }
          return;
        }
        this.tokens.appendCode(`, {`);
        this.processProps(false);
        if (devProps) {
          this.tokens.appendCode(` ${devProps}}`);
        } else {
          this.tokens.appendCode("}");
        }
      }
      /**
       * Transform the core part of the props, assuming that a { has already been
       * inserted before us and that a } will be inserted after us.
       *
       * If extractKeyCode is true (i.e. when using any jsx... function), any prop
       * named "key" has its code captured and returned rather than being emitted to
       * the output code. This shifts line numbers, and emitting the code later will
       * correct line numbers again. If no key is found or if extractKeyCode is
       * false, this function returns null.
       */
      processProps(extractKeyCode) {
        let keyCode = null;
        while (true) {
          if (this.tokens.matches2(_types.TokenType.jsxName, _types.TokenType.eq)) {
            const propName = this.tokens.identifierName();
            if (extractKeyCode && propName === "key") {
              if (keyCode !== null) {
                this.tokens.appendCode(keyCode.replace(/[^\n]/g, ""));
              }
              this.tokens.removeToken();
              this.tokens.removeToken();
              const snapshot = this.tokens.snapshot();
              this.processPropValue();
              keyCode = this.tokens.dangerouslyGetAndRemoveCodeSinceSnapshot(snapshot);
              continue;
            } else {
              this.processPropName(propName);
              this.tokens.replaceToken(": ");
              this.processPropValue();
            }
          } else if (this.tokens.matches1(_types.TokenType.jsxName)) {
            const propName = this.tokens.identifierName();
            this.processPropName(propName);
            this.tokens.appendCode(": true");
          } else if (this.tokens.matches1(_types.TokenType.braceL)) {
            this.tokens.replaceToken("");
            this.rootTransformer.processBalancedCode();
            this.tokens.replaceToken("");
          } else {
            break;
          }
          this.tokens.appendCode(",");
        }
        return keyCode;
      }
      processPropName(propName) {
        if (propName.includes("-")) {
          this.tokens.replaceToken(`'${propName}'`);
        } else {
          this.tokens.copyToken();
        }
      }
      processPropValue() {
        if (this.tokens.matches1(_types.TokenType.braceL)) {
          this.tokens.replaceToken("");
          this.rootTransformer.processBalancedCode();
          this.tokens.replaceToken("");
        } else if (this.tokens.matches1(_types.TokenType.jsxTagStart)) {
          this.processJSXTag();
        } else {
          this.processStringPropValue();
        }
      }
      processStringPropValue() {
        const token = this.tokens.currentToken();
        const valueCode = this.tokens.code.slice(token.start + 1, token.end - 1);
        const replacementCode = formatJSXTextReplacement(valueCode);
        const literalCode = formatJSXStringValueLiteral(valueCode);
        this.tokens.replaceToken(literalCode + replacementCode);
      }
      /**
       * Starting in the middle of the props object literal, produce an additional
       * prop for the children and close the object literal.
       */
      processAutomaticChildrenAndEndProps(jsxRole) {
        if (jsxRole === _tokenizer.JSXRole.StaticChildren) {
          this.tokens.appendCode(" children: [");
          this.processChildren(false);
          this.tokens.appendCode("]}");
        } else {
          if (jsxRole === _tokenizer.JSXRole.OneChild) {
            this.tokens.appendCode(" children: ");
          }
          this.processChildren(false);
          this.tokens.appendCode("}");
        }
      }
      /**
       * Transform children into a comma-separated list, which will be either
       * arguments to createElement or array elements of a children prop.
       */
      processChildren(needsInitialComma) {
        let needsComma = needsInitialComma;
        while (true) {
          if (this.tokens.matches2(_types.TokenType.jsxTagStart, _types.TokenType.slash)) {
            return;
          }
          let didEmitElement = false;
          if (this.tokens.matches1(_types.TokenType.braceL)) {
            if (this.tokens.matches2(_types.TokenType.braceL, _types.TokenType.braceR)) {
              this.tokens.replaceToken("");
              this.tokens.replaceToken("");
            } else {
              this.tokens.replaceToken(needsComma ? ", " : "");
              this.rootTransformer.processBalancedCode();
              this.tokens.replaceToken("");
              didEmitElement = true;
            }
          } else if (this.tokens.matches1(_types.TokenType.jsxTagStart)) {
            this.tokens.appendCode(needsComma ? ", " : "");
            this.processJSXTag();
            didEmitElement = true;
          } else if (this.tokens.matches1(_types.TokenType.jsxText) || this.tokens.matches1(_types.TokenType.jsxEmptyText)) {
            didEmitElement = this.processChildTextElement(needsComma);
          } else {
            throw new Error("Unexpected token when processing JSX children.");
          }
          if (didEmitElement) {
            needsComma = true;
          }
        }
      }
      /**
       * Turn a JSX text element into a string literal, or nothing at all if the JSX
       * text resolves to the empty string.
       *
       * Returns true if a string literal is emitted, false otherwise.
       */
      processChildTextElement(needsComma) {
        const token = this.tokens.currentToken();
        const valueCode = this.tokens.code.slice(token.start, token.end);
        const replacementCode = formatJSXTextReplacement(valueCode);
        const literalCode = formatJSXTextLiteral(valueCode);
        if (literalCode === '""') {
          this.tokens.replaceToken(replacementCode);
          return false;
        } else {
          this.tokens.replaceToken(`${needsComma ? ", " : ""}${literalCode}${replacementCode}`);
          return true;
        }
      }
      getDevSource(elementLocationCode) {
        return `{fileName: ${this.getFilenameVarName()}, ${elementLocationCode}}`;
      }
      getFilenameVarName() {
        if (!this.filenameVarName) {
          this.filenameVarName = this.nameManager.claimFreeName("_jsxFileName");
        }
        return this.filenameVarName;
      }
    };
    exports2.default = JSXTransformer;
    function startsWithLowerCase(s) {
      const firstChar = s.charCodeAt(0);
      return firstChar >= _charcodes.charCodes.lowercaseA && firstChar <= _charcodes.charCodes.lowercaseZ;
    }
    exports2.startsWithLowerCase = startsWithLowerCase;
    function formatJSXTextLiteral(text2) {
      let result = "";
      let whitespace = "";
      let isInInitialLineWhitespace = false;
      let seenNonWhitespace = false;
      for (let i = 0; i < text2.length; i++) {
        const c = text2[i];
        if (c === " " || c === "	" || c === "\r") {
          if (!isInInitialLineWhitespace) {
            whitespace += c;
          }
        } else if (c === "\n") {
          whitespace = "";
          isInInitialLineWhitespace = true;
        } else {
          if (seenNonWhitespace && isInInitialLineWhitespace) {
            result += " ";
          }
          result += whitespace;
          whitespace = "";
          if (c === "&") {
            const { entity, newI } = processEntity(text2, i + 1);
            i = newI - 1;
            result += entity;
          } else {
            result += c;
          }
          seenNonWhitespace = true;
          isInInitialLineWhitespace = false;
        }
      }
      if (!isInInitialLineWhitespace) {
        result += whitespace;
      }
      return JSON.stringify(result);
    }
    function formatJSXTextReplacement(text2) {
      let numNewlines = 0;
      let numSpaces = 0;
      for (const c of text2) {
        if (c === "\n") {
          numNewlines++;
          numSpaces = 0;
        } else if (c === " ") {
          numSpaces++;
        }
      }
      return "\n".repeat(numNewlines) + " ".repeat(numSpaces);
    }
    function formatJSXStringValueLiteral(text2) {
      let result = "";
      for (let i = 0; i < text2.length; i++) {
        const c = text2[i];
        if (c === "\n") {
          if (/\s/.test(text2[i + 1])) {
            result += " ";
            while (i < text2.length && /\s/.test(text2[i + 1])) {
              i++;
            }
          } else {
            result += "\n";
          }
        } else if (c === "&") {
          const { entity, newI } = processEntity(text2, i + 1);
          result += entity;
          i = newI - 1;
        } else {
          result += c;
        }
      }
      return JSON.stringify(result);
    }
    function processEntity(text2, indexAfterAmpersand) {
      let str = "";
      let count = 0;
      let entity;
      let i = indexAfterAmpersand;
      if (text2[i] === "#") {
        let radix = 10;
        i++;
        let numStart;
        if (text2[i] === "x") {
          radix = 16;
          i++;
          numStart = i;
          while (i < text2.length && isHexDigit(text2.charCodeAt(i))) {
            i++;
          }
        } else {
          numStart = i;
          while (i < text2.length && isDecimalDigit(text2.charCodeAt(i))) {
            i++;
          }
        }
        if (text2[i] === ";") {
          const numStr = text2.slice(numStart, i);
          if (numStr) {
            i++;
            entity = String.fromCodePoint(parseInt(numStr, radix));
          }
        }
      } else {
        while (i < text2.length && count++ < 10) {
          const ch = text2[i];
          i++;
          if (ch === ";") {
            entity = _xhtml2.default.get(str);
            break;
          }
          str += ch;
        }
      }
      if (!entity) {
        return { entity: "&", newI: indexAfterAmpersand };
      }
      return { entity, newI: i };
    }
    function isDecimalDigit(code) {
      return code >= _charcodes.charCodes.digit0 && code <= _charcodes.charCodes.digit9;
    }
    function isHexDigit(code) {
      return code >= _charcodes.charCodes.digit0 && code <= _charcodes.charCodes.digit9 || code >= _charcodes.charCodes.lowercaseA && code <= _charcodes.charCodes.lowercaseF || code >= _charcodes.charCodes.uppercaseA && code <= _charcodes.charCodes.uppercaseF;
    }
  }
});

// node_modules/sucrase/dist/util/getNonTypeIdentifiers.js
var require_getNonTypeIdentifiers = __commonJS({
  "node_modules/sucrase/dist/util/getNonTypeIdentifiers.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _tokenizer = require_tokenizer2();
    var _types = require_types();
    var _JSXTransformer = require_JSXTransformer();
    var _getJSXPragmaInfo = require_getJSXPragmaInfo();
    var _getJSXPragmaInfo2 = _interopRequireDefault(_getJSXPragmaInfo);
    function getNonTypeIdentifiers(tokens, options) {
      const jsxPragmaInfo = _getJSXPragmaInfo2.default.call(void 0, options);
      const nonTypeIdentifiers = /* @__PURE__ */ new Set();
      for (let i = 0; i < tokens.tokens.length; i++) {
        const token = tokens.tokens[i];
        if (token.type === _types.TokenType.name && !token.isType && (token.identifierRole === _tokenizer.IdentifierRole.Access || token.identifierRole === _tokenizer.IdentifierRole.ObjectShorthand || token.identifierRole === _tokenizer.IdentifierRole.ExportAccess) && !token.shadowsGlobal) {
          nonTypeIdentifiers.add(tokens.identifierNameForToken(token));
        }
        if (token.type === _types.TokenType.jsxTagStart) {
          nonTypeIdentifiers.add(jsxPragmaInfo.base);
        }
        if (token.type === _types.TokenType.jsxTagStart && i + 1 < tokens.tokens.length && tokens.tokens[i + 1].type === _types.TokenType.jsxTagEnd) {
          nonTypeIdentifiers.add(jsxPragmaInfo.base);
          nonTypeIdentifiers.add(jsxPragmaInfo.fragmentBase);
        }
        if (token.type === _types.TokenType.jsxName && token.identifierRole === _tokenizer.IdentifierRole.Access) {
          const identifierName = tokens.identifierNameForToken(token);
          if (!_JSXTransformer.startsWithLowerCase.call(void 0, identifierName) || tokens.tokens[i + 1].type === _types.TokenType.dot) {
            nonTypeIdentifiers.add(tokens.identifierNameForToken(token));
          }
        }
      }
      return nonTypeIdentifiers;
    }
    exports2.getNonTypeIdentifiers = getNonTypeIdentifiers;
  }
});

// node_modules/sucrase/dist/CJSImportProcessor.js
var require_CJSImportProcessor = __commonJS({
  "node_modules/sucrase/dist/CJSImportProcessor.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _tokenizer = require_tokenizer2();
    var _keywords = require_keywords();
    var _types = require_types();
    var _getImportExportSpecifierInfo = require_getImportExportSpecifierInfo();
    var _getImportExportSpecifierInfo2 = _interopRequireDefault(_getImportExportSpecifierInfo);
    var _getNonTypeIdentifiers = require_getNonTypeIdentifiers();
    var CJSImportProcessor = class _CJSImportProcessor {
      __init() {
        this.nonTypeIdentifiers = /* @__PURE__ */ new Set();
      }
      __init2() {
        this.importInfoByPath = /* @__PURE__ */ new Map();
      }
      __init3() {
        this.importsToReplace = /* @__PURE__ */ new Map();
      }
      __init4() {
        this.identifierReplacements = /* @__PURE__ */ new Map();
      }
      __init5() {
        this.exportBindingsByLocalName = /* @__PURE__ */ new Map();
      }
      constructor(nameManager, tokens, enableLegacyTypeScriptModuleInterop, options, isTypeScriptTransformEnabled, keepUnusedImports, helperManager) {
        ;
        this.nameManager = nameManager;
        this.tokens = tokens;
        this.enableLegacyTypeScriptModuleInterop = enableLegacyTypeScriptModuleInterop;
        this.options = options;
        this.isTypeScriptTransformEnabled = isTypeScriptTransformEnabled;
        this.keepUnusedImports = keepUnusedImports;
        this.helperManager = helperManager;
        _CJSImportProcessor.prototype.__init.call(this);
        _CJSImportProcessor.prototype.__init2.call(this);
        _CJSImportProcessor.prototype.__init3.call(this);
        _CJSImportProcessor.prototype.__init4.call(this);
        _CJSImportProcessor.prototype.__init5.call(this);
      }
      preprocessTokens() {
        for (let i = 0; i < this.tokens.tokens.length; i++) {
          if (this.tokens.matches1AtIndex(i, _types.TokenType._import) && !this.tokens.matches3AtIndex(i, _types.TokenType._import, _types.TokenType.name, _types.TokenType.eq)) {
            this.preprocessImportAtIndex(i);
          }
          if (this.tokens.matches1AtIndex(i, _types.TokenType._export) && !this.tokens.matches2AtIndex(i, _types.TokenType._export, _types.TokenType.eq)) {
            this.preprocessExportAtIndex(i);
          }
        }
        this.generateImportReplacements();
      }
      /**
       * In TypeScript, import statements that only import types should be removed.
       * This includes `import {} from 'foo';`, but not `import 'foo';`.
       */
      pruneTypeOnlyImports() {
        this.nonTypeIdentifiers = _getNonTypeIdentifiers.getNonTypeIdentifiers.call(void 0, this.tokens, this.options);
        for (const [path33, importInfo] of this.importInfoByPath.entries()) {
          if (importInfo.hasBareImport || importInfo.hasStarExport || importInfo.exportStarNames.length > 0 || importInfo.namedExports.length > 0) {
            continue;
          }
          const names = [
            ...importInfo.defaultNames,
            ...importInfo.wildcardNames,
            ...importInfo.namedImports.map(({ localName }) => localName)
          ];
          if (names.every((name28) => this.shouldAutomaticallyElideImportedName(name28))) {
            this.importsToReplace.set(path33, "");
          }
        }
      }
      shouldAutomaticallyElideImportedName(name28) {
        return this.isTypeScriptTransformEnabled && !this.keepUnusedImports && !this.nonTypeIdentifiers.has(name28);
      }
      generateImportReplacements() {
        for (const [path33, importInfo] of this.importInfoByPath.entries()) {
          const {
            defaultNames,
            wildcardNames,
            namedImports,
            namedExports,
            exportStarNames,
            hasStarExport
          } = importInfo;
          if (defaultNames.length === 0 && wildcardNames.length === 0 && namedImports.length === 0 && namedExports.length === 0 && exportStarNames.length === 0 && !hasStarExport) {
            this.importsToReplace.set(path33, `require('${path33}');`);
            continue;
          }
          const primaryImportName = this.getFreeIdentifierForPath(path33);
          let secondaryImportName;
          if (this.enableLegacyTypeScriptModuleInterop) {
            secondaryImportName = primaryImportName;
          } else {
            secondaryImportName = wildcardNames.length > 0 ? wildcardNames[0] : this.getFreeIdentifierForPath(path33);
          }
          let requireCode = `var ${primaryImportName} = require('${path33}');`;
          if (wildcardNames.length > 0) {
            for (const wildcardName of wildcardNames) {
              const moduleExpr = this.enableLegacyTypeScriptModuleInterop ? primaryImportName : `${this.helperManager.getHelperName("interopRequireWildcard")}(${primaryImportName})`;
              requireCode += ` var ${wildcardName} = ${moduleExpr};`;
            }
          } else if (exportStarNames.length > 0 && secondaryImportName !== primaryImportName) {
            requireCode += ` var ${secondaryImportName} = ${this.helperManager.getHelperName(
              "interopRequireWildcard"
            )}(${primaryImportName});`;
          } else if (defaultNames.length > 0 && secondaryImportName !== primaryImportName) {
            requireCode += ` var ${secondaryImportName} = ${this.helperManager.getHelperName(
              "interopRequireDefault"
            )}(${primaryImportName});`;
          }
          for (const { importedName, localName } of namedExports) {
            requireCode += ` ${this.helperManager.getHelperName(
              "createNamedExportFrom"
            )}(${primaryImportName}, '${localName}', '${importedName}');`;
          }
          for (const exportStarName of exportStarNames) {
            requireCode += ` exports.${exportStarName} = ${secondaryImportName};`;
          }
          if (hasStarExport) {
            requireCode += ` ${this.helperManager.getHelperName(
              "createStarExport"
            )}(${primaryImportName});`;
          }
          this.importsToReplace.set(path33, requireCode);
          for (const defaultName of defaultNames) {
            this.identifierReplacements.set(defaultName, `${secondaryImportName}.default`);
          }
          for (const { importedName, localName } of namedImports) {
            this.identifierReplacements.set(localName, `${primaryImportName}.${importedName}`);
          }
        }
      }
      getFreeIdentifierForPath(path33) {
        const components = path33.split("/");
        const lastComponent = components[components.length - 1];
        const baseName = lastComponent.replace(/\W/g, "");
        return this.nameManager.claimFreeName(`_${baseName}`);
      }
      preprocessImportAtIndex(index) {
        const defaultNames = [];
        const wildcardNames = [];
        const namedImports = [];
        index++;
        if ((this.tokens.matchesContextualAtIndex(index, _keywords.ContextualKeyword._type) || this.tokens.matches1AtIndex(index, _types.TokenType._typeof)) && !this.tokens.matches1AtIndex(index + 1, _types.TokenType.comma) && !this.tokens.matchesContextualAtIndex(index + 1, _keywords.ContextualKeyword._from)) {
          return;
        }
        if (this.tokens.matches1AtIndex(index, _types.TokenType.parenL)) {
          return;
        }
        if (this.tokens.matches1AtIndex(index, _types.TokenType.name)) {
          defaultNames.push(this.tokens.identifierNameAtIndex(index));
          index++;
          if (this.tokens.matches1AtIndex(index, _types.TokenType.comma)) {
            index++;
          }
        }
        if (this.tokens.matches1AtIndex(index, _types.TokenType.star)) {
          index += 2;
          wildcardNames.push(this.tokens.identifierNameAtIndex(index));
          index++;
        }
        if (this.tokens.matches1AtIndex(index, _types.TokenType.braceL)) {
          const result = this.getNamedImports(index + 1);
          index = result.newIndex;
          for (const namedImport of result.namedImports) {
            if (namedImport.importedName === "default") {
              defaultNames.push(namedImport.localName);
            } else {
              namedImports.push(namedImport);
            }
          }
        }
        if (this.tokens.matchesContextualAtIndex(index, _keywords.ContextualKeyword._from)) {
          index++;
        }
        if (!this.tokens.matches1AtIndex(index, _types.TokenType.string)) {
          throw new Error("Expected string token at the end of import statement.");
        }
        const path33 = this.tokens.stringValueAtIndex(index);
        const importInfo = this.getImportInfo(path33);
        importInfo.defaultNames.push(...defaultNames);
        importInfo.wildcardNames.push(...wildcardNames);
        importInfo.namedImports.push(...namedImports);
        if (defaultNames.length === 0 && wildcardNames.length === 0 && namedImports.length === 0) {
          importInfo.hasBareImport = true;
        }
      }
      preprocessExportAtIndex(index) {
        if (this.tokens.matches2AtIndex(index, _types.TokenType._export, _types.TokenType._var) || this.tokens.matches2AtIndex(index, _types.TokenType._export, _types.TokenType._let) || this.tokens.matches2AtIndex(index, _types.TokenType._export, _types.TokenType._const)) {
          this.preprocessVarExportAtIndex(index);
        } else if (this.tokens.matches2AtIndex(index, _types.TokenType._export, _types.TokenType._function) || this.tokens.matches2AtIndex(index, _types.TokenType._export, _types.TokenType._class)) {
          const exportName = this.tokens.identifierNameAtIndex(index + 2);
          this.addExportBinding(exportName, exportName);
        } else if (this.tokens.matches3AtIndex(index, _types.TokenType._export, _types.TokenType.name, _types.TokenType._function)) {
          const exportName = this.tokens.identifierNameAtIndex(index + 3);
          this.addExportBinding(exportName, exportName);
        } else if (this.tokens.matches2AtIndex(index, _types.TokenType._export, _types.TokenType.braceL)) {
          this.preprocessNamedExportAtIndex(index);
        } else if (this.tokens.matches2AtIndex(index, _types.TokenType._export, _types.TokenType.star)) {
          this.preprocessExportStarAtIndex(index);
        }
      }
      preprocessVarExportAtIndex(index) {
        let depth = 0;
        for (let i = index + 2; ; i++) {
          if (this.tokens.matches1AtIndex(i, _types.TokenType.braceL) || this.tokens.matches1AtIndex(i, _types.TokenType.dollarBraceL) || this.tokens.matches1AtIndex(i, _types.TokenType.bracketL)) {
            depth++;
          } else if (this.tokens.matches1AtIndex(i, _types.TokenType.braceR) || this.tokens.matches1AtIndex(i, _types.TokenType.bracketR)) {
            depth--;
          } else if (depth === 0 && !this.tokens.matches1AtIndex(i, _types.TokenType.name)) {
            break;
          } else if (this.tokens.matches1AtIndex(1, _types.TokenType.eq)) {
            const endIndex = this.tokens.currentToken().rhsEndIndex;
            if (endIndex == null) {
              throw new Error("Expected = token with an end index.");
            }
            i = endIndex - 1;
          } else {
            const token = this.tokens.tokens[i];
            if (_tokenizer.isDeclaration.call(void 0, token)) {
              const exportName = this.tokens.identifierNameAtIndex(i);
              this.identifierReplacements.set(exportName, `exports.${exportName}`);
            }
          }
        }
      }
      /**
       * Walk this export statement just in case it's an export...from statement.
       * If it is, combine it into the import info for that path. Otherwise, just
       * bail out; it'll be handled later.
       */
      preprocessNamedExportAtIndex(index) {
        index += 2;
        const { newIndex, namedImports } = this.getNamedImports(index);
        index = newIndex;
        if (this.tokens.matchesContextualAtIndex(index, _keywords.ContextualKeyword._from)) {
          index++;
        } else {
          for (const { importedName: localName, localName: exportedName } of namedImports) {
            this.addExportBinding(localName, exportedName);
          }
          return;
        }
        if (!this.tokens.matches1AtIndex(index, _types.TokenType.string)) {
          throw new Error("Expected string token at the end of import statement.");
        }
        const path33 = this.tokens.stringValueAtIndex(index);
        const importInfo = this.getImportInfo(path33);
        importInfo.namedExports.push(...namedImports);
      }
      preprocessExportStarAtIndex(index) {
        let exportedName = null;
        if (this.tokens.matches3AtIndex(index, _types.TokenType._export, _types.TokenType.star, _types.TokenType._as)) {
          index += 3;
          exportedName = this.tokens.identifierNameAtIndex(index);
          index += 2;
        } else {
          index += 3;
        }
        if (!this.tokens.matches1AtIndex(index, _types.TokenType.string)) {
          throw new Error("Expected string token at the end of star export statement.");
        }
        const path33 = this.tokens.stringValueAtIndex(index);
        const importInfo = this.getImportInfo(path33);
        if (exportedName !== null) {
          importInfo.exportStarNames.push(exportedName);
        } else {
          importInfo.hasStarExport = true;
        }
      }
      getNamedImports(index) {
        const namedImports = [];
        while (true) {
          if (this.tokens.matches1AtIndex(index, _types.TokenType.braceR)) {
            index++;
            break;
          }
          const specifierInfo = _getImportExportSpecifierInfo2.default.call(void 0, this.tokens, index);
          index = specifierInfo.endIndex;
          if (!specifierInfo.isType) {
            namedImports.push({
              importedName: specifierInfo.leftName,
              localName: specifierInfo.rightName
            });
          }
          if (this.tokens.matches2AtIndex(index, _types.TokenType.comma, _types.TokenType.braceR)) {
            index += 2;
            break;
          } else if (this.tokens.matches1AtIndex(index, _types.TokenType.braceR)) {
            index++;
            break;
          } else if (this.tokens.matches1AtIndex(index, _types.TokenType.comma)) {
            index++;
          } else {
            throw new Error(`Unexpected token: ${JSON.stringify(this.tokens.tokens[index])}`);
          }
        }
        return { newIndex: index, namedImports };
      }
      /**
       * Get a mutable import info object for this path, creating one if it doesn't
       * exist yet.
       */
      getImportInfo(path33) {
        const existingInfo = this.importInfoByPath.get(path33);
        if (existingInfo) {
          return existingInfo;
        }
        const newInfo = {
          defaultNames: [],
          wildcardNames: [],
          namedImports: [],
          namedExports: [],
          hasBareImport: false,
          exportStarNames: [],
          hasStarExport: false
        };
        this.importInfoByPath.set(path33, newInfo);
        return newInfo;
      }
      addExportBinding(localName, exportedName) {
        if (!this.exportBindingsByLocalName.has(localName)) {
          this.exportBindingsByLocalName.set(localName, []);
        }
        this.exportBindingsByLocalName.get(localName).push(exportedName);
      }
      /**
       * Return the code to use for the import for this path, or the empty string if
       * the code has already been "claimed" by a previous import.
       */
      claimImportCode(importPath) {
        const result = this.importsToReplace.get(importPath);
        this.importsToReplace.set(importPath, "");
        return result || "";
      }
      getIdentifierReplacement(identifierName) {
        return this.identifierReplacements.get(identifierName) || null;
      }
      /**
       * Return a string like `exports.foo = exports.bar`.
       */
      resolveExportBinding(assignedName) {
        const exportedNames = this.exportBindingsByLocalName.get(assignedName);
        if (!exportedNames || exportedNames.length === 0) {
          return null;
        }
        return exportedNames.map((exportedName) => `exports.${exportedName}`).join(" = ");
      }
      /**
       * Return all imported/exported names where we might be interested in whether usages of those
       * names are shadowed.
       */
      getGlobalNames() {
        return /* @__PURE__ */ new Set([
          ...this.identifierReplacements.keys(),
          ...this.exportBindingsByLocalName.keys()
        ]);
      }
    };
    exports2.default = CJSImportProcessor;
  }
});

// node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
var require_sourcemap_codec_umd = __commonJS({
  "node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js"(exports2, module2) {
    "use strict";
    (function(global2, factory12) {
      if (typeof exports2 === "object" && typeof module2 !== "undefined") {
        factory12(module2);
        module2.exports = def(module2);
      } else if (typeof define === "function" && define.amd) {
        define(["module"], function(mod) {
          factory12.apply(this, arguments);
          mod.exports = def(mod);
        });
      } else {
        const mod = { exports: {} };
        factory12(mod);
        global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self;
        global2.sourcemapCodec = def(mod);
      }
      function def(m) {
        return "default" in m.exports ? m.exports.default : m.exports;
      }
    })(exports2, (function(module3) {
      "use strict";
      var __defProp4 = Object.defineProperty;
      var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
      var __getOwnPropNames2 = Object.getOwnPropertyNames;
      var __hasOwnProp2 = Object.prototype.hasOwnProperty;
      var __export4 = (target, all3) => {
        for (var name28 in all3)
          __defProp4(target, name28, { get: all3[name28], enumerable: true });
      };
      var __copyProps2 = (to, from, except, desc) => {
        if (from && typeof from === "object" || typeof from === "function") {
          for (let key of __getOwnPropNames2(from))
            if (!__hasOwnProp2.call(to, key) && key !== except)
              __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
        }
        return to;
      };
      var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
      var sourcemap_codec_exports = {};
      __export4(sourcemap_codec_exports, {
        decode: () => decode4,
        decodeGeneratedRanges: () => decodeGeneratedRanges,
        decodeOriginalScopes: () => decodeOriginalScopes,
        encode: () => encode6,
        encodeGeneratedRanges: () => encodeGeneratedRanges,
        encodeOriginalScopes: () => encodeOriginalScopes
      });
      module3.exports = __toCommonJS2(sourcemap_codec_exports);
      var comma = ",".charCodeAt(0);
      var semicolon = ";".charCodeAt(0);
      var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      var intToChar = new Uint8Array(64);
      var charToInt = new Uint8Array(128);
      for (let i = 0; i < chars.length; i++) {
        const c = chars.charCodeAt(i);
        intToChar[i] = c;
        charToInt[c] = i;
      }
      function decodeInteger(reader, relative) {
        let value = 0;
        let shift = 0;
        let integer3 = 0;
        do {
          const c = reader.next();
          integer3 = charToInt[c];
          value |= (integer3 & 31) << shift;
          shift += 5;
        } while (integer3 & 32);
        const shouldNegate = value & 1;
        value >>>= 1;
        if (shouldNegate) {
          value = -2147483648 | -value;
        }
        return relative + value;
      }
      function encodeInteger(builder, num, relative) {
        let delta = num - relative;
        delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
        do {
          let clamped = delta & 31;
          delta >>>= 5;
          if (delta > 0) clamped |= 32;
          builder.write(intToChar[clamped]);
        } while (delta > 0);
        return num;
      }
      function hasMoreVlq(reader, max) {
        if (reader.pos >= max) return false;
        return reader.peek() !== comma;
      }
      var bufLength = 1024 * 16;
      var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
        decode(buf) {
          const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
          return out.toString();
        }
      } : {
        decode(buf) {
          let out = "";
          for (let i = 0; i < buf.length; i++) {
            out += String.fromCharCode(buf[i]);
          }
          return out;
        }
      };
      var StringWriter = class {
        constructor() {
          this.pos = 0;
          this.out = "";
          this.buffer = new Uint8Array(bufLength);
        }
        write(v) {
          const { buffer } = this;
          buffer[this.pos++] = v;
          if (this.pos === bufLength) {
            this.out += td.decode(buffer);
            this.pos = 0;
          }
        }
        flush() {
          const { buffer, out, pos } = this;
          return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
        }
      };
      var StringReader = class {
        constructor(buffer) {
          this.pos = 0;
          this.buffer = buffer;
        }
        next() {
          return this.buffer.charCodeAt(this.pos++);
        }
        peek() {
          return this.buffer.charCodeAt(this.pos);
        }
        indexOf(char) {
          const { buffer, pos } = this;
          const idx = buffer.indexOf(char, pos);
          return idx === -1 ? buffer.length : idx;
        }
      };
      var EMPTY = [];
      function decodeOriginalScopes(input) {
        const { length } = input;
        const reader = new StringReader(input);
        const scopes = [];
        const stack = [];
        let line = 0;
        for (; reader.pos < length; reader.pos++) {
          line = decodeInteger(reader, line);
          const column = decodeInteger(reader, 0);
          if (!hasMoreVlq(reader, length)) {
            const last = stack.pop();
            last[2] = line;
            last[3] = column;
            continue;
          }
          const kind = decodeInteger(reader, 0);
          const fields = decodeInteger(reader, 0);
          const hasName = fields & 1;
          const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind];
          let vars = EMPTY;
          if (hasMoreVlq(reader, length)) {
            vars = [];
            do {
              const varsIndex = decodeInteger(reader, 0);
              vars.push(varsIndex);
            } while (hasMoreVlq(reader, length));
          }
          scope.vars = vars;
          scopes.push(scope);
          stack.push(scope);
        }
        return scopes;
      }
      function encodeOriginalScopes(scopes) {
        const writer = new StringWriter();
        for (let i = 0; i < scopes.length; ) {
          i = _encodeOriginalScopes(scopes, i, writer, [0]);
        }
        return writer.flush();
      }
      function _encodeOriginalScopes(scopes, index, writer, state) {
        const scope = scopes[index];
        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
        if (index > 0) writer.write(comma);
        state[0] = encodeInteger(writer, startLine, state[0]);
        encodeInteger(writer, startColumn, 0);
        encodeInteger(writer, kind, 0);
        const fields = scope.length === 6 ? 1 : 0;
        encodeInteger(writer, fields, 0);
        if (scope.length === 6) encodeInteger(writer, scope[5], 0);
        for (const v of vars) {
          encodeInteger(writer, v, 0);
        }
        for (index++; index < scopes.length; ) {
          const next = scopes[index];
          const { 0: l, 1: c } = next;
          if (l > endLine || l === endLine && c >= endColumn) {
            break;
          }
          index = _encodeOriginalScopes(scopes, index, writer, state);
        }
        writer.write(comma);
        state[0] = encodeInteger(writer, endLine, state[0]);
        encodeInteger(writer, endColumn, 0);
        return index;
      }
      function decodeGeneratedRanges(input) {
        const { length } = input;
        const reader = new StringReader(input);
        const ranges = [];
        const stack = [];
        let genLine = 0;
        let definitionSourcesIndex = 0;
        let definitionScopeIndex = 0;
        let callsiteSourcesIndex = 0;
        let callsiteLine = 0;
        let callsiteColumn = 0;
        let bindingLine = 0;
        let bindingColumn = 0;
        do {
          const semi = reader.indexOf(";");
          let genColumn = 0;
          for (; reader.pos < semi; reader.pos++) {
            genColumn = decodeInteger(reader, genColumn);
            if (!hasMoreVlq(reader, semi)) {
              const last = stack.pop();
              last[2] = genLine;
              last[3] = genColumn;
              continue;
            }
            const fields = decodeInteger(reader, 0);
            const hasDefinition = fields & 1;
            const hasCallsite = fields & 2;
            const hasScope = fields & 4;
            let callsite = null;
            let bindings = EMPTY;
            let range;
            if (hasDefinition) {
              const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
              definitionScopeIndex = decodeInteger(
                reader,
                definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0
              );
              definitionSourcesIndex = defSourcesIndex;
              range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
            } else {
              range = [genLine, genColumn, 0, 0];
            }
            range.isScope = !!hasScope;
            if (hasCallsite) {
              const prevCsi = callsiteSourcesIndex;
              const prevLine = callsiteLine;
              callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
              const sameSource = prevCsi === callsiteSourcesIndex;
              callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
              callsiteColumn = decodeInteger(
                reader,
                sameSource && prevLine === callsiteLine ? callsiteColumn : 0
              );
              callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
            }
            range.callsite = callsite;
            if (hasMoreVlq(reader, semi)) {
              bindings = [];
              do {
                bindingLine = genLine;
                bindingColumn = genColumn;
                const expressionsCount = decodeInteger(reader, 0);
                let expressionRanges;
                if (expressionsCount < -1) {
                  expressionRanges = [[decodeInteger(reader, 0)]];
                  for (let i = -1; i > expressionsCount; i--) {
                    const prevBl = bindingLine;
                    bindingLine = decodeInteger(reader, bindingLine);
                    bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
                    const expression = decodeInteger(reader, 0);
                    expressionRanges.push([expression, bindingLine, bindingColumn]);
                  }
                } else {
                  expressionRanges = [[expressionsCount]];
                }
                bindings.push(expressionRanges);
              } while (hasMoreVlq(reader, semi));
            }
            range.bindings = bindings;
            ranges.push(range);
            stack.push(range);
          }
          genLine++;
          reader.pos = semi + 1;
        } while (reader.pos < length);
        return ranges;
      }
      function encodeGeneratedRanges(ranges) {
        if (ranges.length === 0) return "";
        const writer = new StringWriter();
        for (let i = 0; i < ranges.length; ) {
          i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
        }
        return writer.flush();
      }
      function _encodeGeneratedRanges(ranges, index, writer, state) {
        const range = ranges[index];
        const {
          0: startLine,
          1: startColumn,
          2: endLine,
          3: endColumn,
          isScope,
          callsite,
          bindings
        } = range;
        if (state[0] < startLine) {
          catchupLine(writer, state[0], startLine);
          state[0] = startLine;
          state[1] = 0;
        } else if (index > 0) {
          writer.write(comma);
        }
        state[1] = encodeInteger(writer, range[1], state[1]);
        const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);
        encodeInteger(writer, fields, 0);
        if (range.length === 6) {
          const { 4: sourcesIndex, 5: scopesIndex } = range;
          if (sourcesIndex !== state[2]) {
            state[3] = 0;
          }
          state[2] = encodeInteger(writer, sourcesIndex, state[2]);
          state[3] = encodeInteger(writer, scopesIndex, state[3]);
        }
        if (callsite) {
          const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
          if (sourcesIndex !== state[4]) {
            state[5] = 0;
            state[6] = 0;
          } else if (callLine !== state[5]) {
            state[6] = 0;
          }
          state[4] = encodeInteger(writer, sourcesIndex, state[4]);
          state[5] = encodeInteger(writer, callLine, state[5]);
          state[6] = encodeInteger(writer, callColumn, state[6]);
        }
        if (bindings) {
          for (const binding of bindings) {
            if (binding.length > 1) encodeInteger(writer, -binding.length, 0);
            const expression = binding[0][0];
            encodeInteger(writer, expression, 0);
            let bindingStartLine = startLine;
            let bindingStartColumn = startColumn;
            for (let i = 1; i < binding.length; i++) {
              const expRange = binding[i];
              bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);
              bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);
              encodeInteger(writer, expRange[0], 0);
            }
          }
        }
        for (index++; index < ranges.length; ) {
          const next = ranges[index];
          const { 0: l, 1: c } = next;
          if (l > endLine || l === endLine && c >= endColumn) {
            break;
          }
          index = _encodeGeneratedRanges(ranges, index, writer, state);
        }
        if (state[0] < endLine) {
          catchupLine(writer, state[0], endLine);
          state[0] = endLine;
          state[1] = 0;
        } else {
          writer.write(comma);
        }
        state[1] = encodeInteger(writer, endColumn, state[1]);
        return index;
      }
      function catchupLine(writer, lastLine, line) {
        do {
          writer.write(semicolon);
        } while (++lastLine < line);
      }
      function decode4(mappings) {
        const { length } = mappings;
        const reader = new StringReader(mappings);
        const decoded = [];
        let genColumn = 0;
        let sourcesIndex = 0;
        let sourceLine = 0;
        let sourceColumn = 0;
        let namesIndex = 0;
        do {
          const semi = reader.indexOf(";");
          const line = [];
          let sorted = true;
          let lastCol = 0;
          genColumn = 0;
          while (reader.pos < semi) {
            let seg;
            genColumn = decodeInteger(reader, genColumn);
            if (genColumn < lastCol) sorted = false;
            lastCol = genColumn;
            if (hasMoreVlq(reader, semi)) {
              sourcesIndex = decodeInteger(reader, sourcesIndex);
              sourceLine = decodeInteger(reader, sourceLine);
              sourceColumn = decodeInteger(reader, sourceColumn);
              if (hasMoreVlq(reader, semi)) {
                namesIndex = decodeInteger(reader, namesIndex);
                seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
              } else {
                seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
              }
            } else {
              seg = [genColumn];
            }
            line.push(seg);
            reader.pos++;
          }
          if (!sorted) sort(line);
          decoded.push(line);
          reader.pos = semi + 1;
        } while (reader.pos <= length);
        return decoded;
      }
      function sort(line) {
        line.sort(sortComparator);
      }
      function sortComparator(a, b) {
        return a[0] - b[0];
      }
      function encode6(decoded) {
        const writer = new StringWriter();
        let sourcesIndex = 0;
        let sourceLine = 0;
        let sourceColumn = 0;
        let namesIndex = 0;
        for (let i = 0; i < decoded.length; i++) {
          const line = decoded[i];
          if (i > 0) writer.write(semicolon);
          if (line.length === 0) continue;
          let genColumn = 0;
          for (let j = 0; j < line.length; j++) {
            const segment = line[j];
            if (j > 0) writer.write(comma);
            genColumn = encodeInteger(writer, segment[0], genColumn);
            if (segment.length === 1) continue;
            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
            sourceLine = encodeInteger(writer, segment[2], sourceLine);
            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
            if (segment.length === 4) continue;
            namesIndex = encodeInteger(writer, segment[4], namesIndex);
          }
        }
        return writer.flush();
      }
    }));
  }
});

// node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
var require_resolve_uri_umd = __commonJS({
  "node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js"(exports2, module2) {
    "use strict";
    (function(global2, factory12) {
      typeof exports2 === "object" && typeof module2 !== "undefined" ? module2.exports = factory12() : typeof define === "function" && define.amd ? define(factory12) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.resolveURI = factory12());
    })(exports2, (function() {
      "use strict";
      const schemeRegex = /^[\w+.-]+:\/\//;
      const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
      const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
      function isAbsoluteUrl(input) {
        return schemeRegex.test(input);
      }
      function isSchemeRelativeUrl(input) {
        return input.startsWith("//");
      }
      function isAbsolutePath(input) {
        return input.startsWith("/");
      }
      function isFileUrl(input) {
        return input.startsWith("file:");
      }
      function isRelative(input) {
        return /^[.?#]/.test(input);
      }
      function parseAbsoluteUrl(input) {
        const match = urlRegex.exec(input);
        return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
      }
      function parseFileUrl(input) {
        const match = fileRegex.exec(input);
        const path33 = match[2];
        return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path33) ? path33 : "/" + path33, match[3] || "", match[4] || "");
      }
      function makeUrl(scheme, user, host, port, path33, query, hash3) {
        return {
          scheme,
          user,
          host,
          port,
          path: path33,
          query,
          hash: hash3,
          type: 7
        };
      }
      function parseUrl2(input) {
        if (isSchemeRelativeUrl(input)) {
          const url5 = parseAbsoluteUrl("http:" + input);
          url5.scheme = "";
          url5.type = 6;
          return url5;
        }
        if (isAbsolutePath(input)) {
          const url5 = parseAbsoluteUrl("http://foo.com" + input);
          url5.scheme = "";
          url5.host = "";
          url5.type = 5;
          return url5;
        }
        if (isFileUrl(input))
          return parseFileUrl(input);
        if (isAbsoluteUrl(input))
          return parseAbsoluteUrl(input);
        const url4 = parseAbsoluteUrl("http://foo.com/" + input);
        url4.scheme = "";
        url4.host = "";
        url4.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
        return url4;
      }
      function stripPathFilename(path33) {
        if (path33.endsWith("/.."))
          return path33;
        const index = path33.lastIndexOf("/");
        return path33.slice(0, index + 1);
      }
      function mergePaths(url4, base) {
        normalizePath(base, base.type);
        if (url4.path === "/") {
          url4.path = base.path;
        } else {
          url4.path = stripPathFilename(base.path) + url4.path;
        }
      }
      function normalizePath(url4, type) {
        const rel = type <= 4;
        const pieces = url4.path.split("/");
        let pointer = 1;
        let positive = 0;
        let addTrailingSlash = false;
        for (let i = 1; i < pieces.length; i++) {
          const piece = pieces[i];
          if (!piece) {
            addTrailingSlash = true;
            continue;
          }
          addTrailingSlash = false;
          if (piece === ".")
            continue;
          if (piece === "..") {
            if (positive) {
              addTrailingSlash = true;
              positive--;
              pointer--;
            } else if (rel) {
              pieces[pointer++] = piece;
            }
            continue;
          }
          pieces[pointer++] = piece;
          positive++;
        }
        let path33 = "";
        for (let i = 1; i < pointer; i++) {
          path33 += "/" + pieces[i];
        }
        if (!path33 || addTrailingSlash && !path33.endsWith("/..")) {
          path33 += "/";
        }
        url4.path = path33;
      }
      function resolve3(input, base) {
        if (!input && !base)
          return "";
        const url4 = parseUrl2(input);
        let inputType = url4.type;
        if (base && inputType !== 7) {
          const baseUrl = parseUrl2(base);
          const baseType = baseUrl.type;
          switch (inputType) {
            case 1:
              url4.hash = baseUrl.hash;
            // fall through
            case 2:
              url4.query = baseUrl.query;
            // fall through
            case 3:
            case 4:
              mergePaths(url4, baseUrl);
            // fall through
            case 5:
              url4.user = baseUrl.user;
              url4.host = baseUrl.host;
              url4.port = baseUrl.port;
            // fall through
            case 6:
              url4.scheme = baseUrl.scheme;
          }
          if (baseType > inputType)
            inputType = baseType;
        }
        normalizePath(url4, inputType);
        const queryHash = url4.query + url4.hash;
        switch (inputType) {
          // This is impossible, because of the empty checks at the start of the function.
          // case UrlType.Empty:
          case 2:
          case 3:
            return queryHash;
          case 4: {
            const path33 = url4.path.slice(1);
            if (!path33)
              return queryHash || ".";
            if (isRelative(base || input) && !isRelative(path33)) {
              return "./" + path33 + queryHash;
            }
            return path33 + queryHash;
          }
          case 5:
            return url4.path + queryHash;
          default:
            return url4.scheme + "//" + url4.user + url4.host + url4.port + url4.path + queryHash;
        }
      }
      return resolve3;
    }));
  }
});

// node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js
var require_trace_mapping_umd = __commonJS({
  "node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js"(exports2, module2) {
    "use strict";
    (function(global2, factory12) {
      if (typeof exports2 === "object" && typeof module2 !== "undefined") {
        factory12(module2, require_resolve_uri_umd(), require_sourcemap_codec_umd());
        module2.exports = def(module2);
      } else if (typeof define === "function" && define.amd) {
        define(["module", "@jridgewell/resolve-uri", "@jridgewell/sourcemap-codec"], function(mod) {
          factory12.apply(this, arguments);
          mod.exports = def(mod);
        });
      } else {
        const mod = { exports: {} };
        factory12(mod, global2.resolveURI, global2.sourcemapCodec);
        global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self;
        global2.traceMapping = def(mod);
      }
      function def(m) {
        return "default" in m.exports ? m.exports.default : m.exports;
      }
    })(exports2, (function(module3, require_resolveURI, require_sourcemapCodec) {
      "use strict";
      var __create2 = Object.create;
      var __defProp4 = Object.defineProperty;
      var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
      var __getOwnPropNames2 = Object.getOwnPropertyNames;
      var __getProtoOf2 = Object.getPrototypeOf;
      var __hasOwnProp2 = Object.prototype.hasOwnProperty;
      var __commonJS2 = (cb, mod) => function __require() {
        return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
      };
      var __export4 = (target, all3) => {
        for (var name28 in all3)
          __defProp4(target, name28, { get: all3[name28], enumerable: true });
      };
      var __copyProps2 = (to, from, except, desc) => {
        if (from && typeof from === "object" || typeof from === "function") {
          for (let key of __getOwnPropNames2(from))
            if (!__hasOwnProp2.call(to, key) && key !== except)
              __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
        }
        return to;
      };
      var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
        // If the importer is in node compatibility mode or this is not an ESM
        // file that has been converted to a CommonJS file using a Babel-
        // compatible transform (i.e. "__esModule" has not been set), then set
        // "default" to the CommonJS "module.exports" for node compatibility.
        isNodeMode || !mod || !mod.__esModule ? __defProp4(target, "default", { value: mod, enumerable: true }) : target,
        mod
      ));
      var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
      var require_sourcemap_codec = __commonJS2({
        "umd:@jridgewell/sourcemap-codec"(exports3, module22) {
          module22.exports = require_sourcemapCodec;
        }
      });
      var require_resolve_uri = __commonJS2({
        "umd:@jridgewell/resolve-uri"(exports3, module22) {
          module22.exports = require_resolveURI;
        }
      });
      var trace_mapping_exports = {};
      __export4(trace_mapping_exports, {
        AnyMap: () => FlattenMap,
        FlattenMap: () => FlattenMap,
        GREATEST_LOWER_BOUND: () => GREATEST_LOWER_BOUND,
        LEAST_UPPER_BOUND: () => LEAST_UPPER_BOUND,
        TraceMap: () => TraceMap,
        allGeneratedPositionsFor: () => allGeneratedPositionsFor,
        decodedMap: () => decodedMap,
        decodedMappings: () => decodedMappings,
        eachMapping: () => eachMapping,
        encodedMap: () => encodedMap,
        encodedMappings: () => encodedMappings,
        generatedPositionFor: () => generatedPositionFor,
        isIgnored: () => isIgnored,
        originalPositionFor: () => originalPositionFor,
        presortedDecodedMap: () => presortedDecodedMap,
        sourceContentFor: () => sourceContentFor,
        traceSegment: () => traceSegment
      });
      module3.exports = __toCommonJS2(trace_mapping_exports);
      var import_sourcemap_codec = __toESM2(require_sourcemap_codec());
      var import_resolve_uri = __toESM2(require_resolve_uri());
      function stripFilename(path33) {
        if (!path33) return "";
        const index = path33.lastIndexOf("/");
        return path33.slice(0, index + 1);
      }
      function resolver(mapUrl, sourceRoot) {
        const from = stripFilename(mapUrl);
        const prefix = sourceRoot ? sourceRoot + "/" : "";
        return (source) => (0, import_resolve_uri.default)(prefix + (source || ""), from);
      }
      var COLUMN = 0;
      var SOURCES_INDEX = 1;
      var SOURCE_LINE = 2;
      var SOURCE_COLUMN = 3;
      var NAMES_INDEX = 4;
      var REV_GENERATED_LINE = 1;
      var REV_GENERATED_COLUMN = 2;
      function maybeSort(mappings, owned) {
        const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
        if (unsortedIndex === mappings.length) return mappings;
        if (!owned) mappings = mappings.slice();
        for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
          mappings[i] = sortSegments(mappings[i], owned);
        }
        return mappings;
      }
      function nextUnsortedSegmentLine(mappings, start) {
        for (let i = start; i < mappings.length; i++) {
          if (!isSorted(mappings[i])) return i;
        }
        return mappings.length;
      }
      function isSorted(line) {
        for (let j = 1; j < line.length; j++) {
          if (line[j][COLUMN] < line[j - 1][COLUMN]) {
            return false;
          }
        }
        return true;
      }
      function sortSegments(line, owned) {
        if (!owned) line = line.slice();
        return line.sort(sortComparator);
      }
      function sortComparator(a, b) {
        return a[COLUMN] - b[COLUMN];
      }
      function buildBySources(decoded, memos) {
        const sources = memos.map(() => []);
        for (let i = 0; i < decoded.length; i++) {
          const line = decoded[i];
          for (let j = 0; j < line.length; j++) {
            const seg = line[j];
            if (seg.length === 1) continue;
            const sourceIndex2 = seg[SOURCES_INDEX];
            const sourceLine = seg[SOURCE_LINE];
            const sourceColumn = seg[SOURCE_COLUMN];
            const source = sources[sourceIndex2];
            const segs = source[sourceLine] || (source[sourceLine] = []);
            segs.push([sourceColumn, i, seg[COLUMN]]);
          }
        }
        for (let i = 0; i < sources.length; i++) {
          const source = sources[i];
          for (let j = 0; j < source.length; j++) {
            const line = source[j];
            if (line) line.sort(sortComparator);
          }
        }
        return sources;
      }
      var found = false;
      function binarySearch(haystack, needle, low, high) {
        while (low <= high) {
          const mid = low + (high - low >> 1);
          const cmp = haystack[mid][COLUMN] - needle;
          if (cmp === 0) {
            found = true;
            return mid;
          }
          if (cmp < 0) {
            low = mid + 1;
          } else {
            high = mid - 1;
          }
        }
        found = false;
        return low - 1;
      }
      function upperBound(haystack, needle, index) {
        for (let i = index + 1; i < haystack.length; index = i++) {
          if (haystack[i][COLUMN] !== needle) break;
        }
        return index;
      }
      function lowerBound(haystack, needle, index) {
        for (let i = index - 1; i >= 0; index = i--) {
          if (haystack[i][COLUMN] !== needle) break;
        }
        return index;
      }
      function memoizedState() {
        return {
          lastKey: -1,
          lastNeedle: -1,
          lastIndex: -1
        };
      }
      function memoizedBinarySearch(haystack, needle, state, key) {
        const { lastKey, lastNeedle, lastIndex } = state;
        let low = 0;
        let high = haystack.length - 1;
        if (key === lastKey) {
          if (needle === lastNeedle) {
            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
            return lastIndex;
          }
          if (needle >= lastNeedle) {
            low = lastIndex === -1 ? 0 : lastIndex;
          } else {
            high = lastIndex;
          }
        }
        state.lastKey = key;
        state.lastNeedle = needle;
        return state.lastIndex = binarySearch(haystack, needle, low, high);
      }
      function parse4(map3) {
        return typeof map3 === "string" ? JSON.parse(map3) : map3;
      }
      var FlattenMap = function(map3, mapUrl) {
        const parsed = parse4(map3);
        if (!("sections" in parsed)) {
          return new TraceMap(parsed, mapUrl);
        }
        const mappings = [];
        const sources = [];
        const sourcesContent = [];
        const names = [];
        const ignoreList = [];
        recurse(
          parsed,
          mapUrl,
          mappings,
          sources,
          sourcesContent,
          names,
          ignoreList,
          0,
          0,
          Infinity,
          Infinity
        );
        const joined = {
          version: 3,
          file: parsed.file,
          names,
          sources,
          sourcesContent,
          mappings,
          ignoreList
        };
        return presortedDecodedMap(joined);
      };
      function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
        const { sections } = input;
        for (let i = 0; i < sections.length; i++) {
          const { map: map3, offset } = sections[i];
          let sl = stopLine;
          let sc = stopColumn;
          if (i + 1 < sections.length) {
            const nextOffset = sections[i + 1].offset;
            sl = Math.min(stopLine, lineOffset + nextOffset.line);
            if (sl === stopLine) {
              sc = Math.min(stopColumn, columnOffset + nextOffset.column);
            } else if (sl < stopLine) {
              sc = columnOffset + nextOffset.column;
            }
          }
          addSection(
            map3,
            mapUrl,
            mappings,
            sources,
            sourcesContent,
            names,
            ignoreList,
            lineOffset + offset.line,
            columnOffset + offset.column,
            sl,
            sc
          );
        }
      }
      function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
        const parsed = parse4(input);
        if ("sections" in parsed) return recurse(...arguments);
        const map3 = new TraceMap(parsed, mapUrl);
        const sourcesOffset = sources.length;
        const namesOffset = names.length;
        const decoded = decodedMappings(map3);
        const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map3;
        append2(sources, resolvedSources);
        append2(names, map3.names);
        if (contents) append2(sourcesContent, contents);
        else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null);
        if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset);
        for (let i = 0; i < decoded.length; i++) {
          const lineI = lineOffset + i;
          if (lineI > stopLine) return;
          const out = getLine(mappings, lineI);
          const cOffset = i === 0 ? columnOffset : 0;
          const line = decoded[i];
          for (let j = 0; j < line.length; j++) {
            const seg = line[j];
            const column = cOffset + seg[COLUMN];
            if (lineI === stopLine && column >= stopColumn) return;
            if (seg.length === 1) {
              out.push([column]);
              continue;
            }
            const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
            const sourceLine = seg[SOURCE_LINE];
            const sourceColumn = seg[SOURCE_COLUMN];
            out.push(
              seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]
            );
          }
        }
      }
      function append2(arr, other) {
        for (let i = 0; i < other.length; i++) arr.push(other[i]);
      }
      function getLine(arr, index) {
        for (let i = arr.length; i <= index; i++) arr[i] = [];
        return arr[index];
      }
      var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
      var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
      var LEAST_UPPER_BOUND = -1;
      var GREATEST_LOWER_BOUND = 1;
      var TraceMap = class {
        constructor(map3, mapUrl) {
          const isString2 = typeof map3 === "string";
          if (!isString2 && map3._decodedMemo) return map3;
          const parsed = parse4(map3);
          const { version: version3, file: file3, names, sourceRoot, sources, sourcesContent } = parsed;
          this.version = version3;
          this.file = file3;
          this.names = names || [];
          this.sourceRoot = sourceRoot;
          this.sources = sources;
          this.sourcesContent = sourcesContent;
          this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
          const resolve3 = resolver(mapUrl, sourceRoot);
          this.resolvedSources = sources.map(resolve3);
          const { mappings } = parsed;
          if (typeof mappings === "string") {
            this._encoded = mappings;
            this._decoded = void 0;
          } else if (Array.isArray(mappings)) {
            this._encoded = void 0;
            this._decoded = maybeSort(mappings, isString2);
          } else if (parsed.sections) {
            throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
          } else {
            throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
          }
          this._decodedMemo = memoizedState();
          this._bySources = void 0;
          this._bySourceMemos = void 0;
        }
      };
      function cast(map3) {
        return map3;
      }
      function encodedMappings(map3) {
        var _a31, _b27;
        return (_b27 = (_a31 = cast(map3))._encoded) != null ? _b27 : _a31._encoded = (0, import_sourcemap_codec.encode)(cast(map3)._decoded);
      }
      function decodedMappings(map3) {
        var _a31;
        return (_a31 = cast(map3))._decoded || (_a31._decoded = (0, import_sourcemap_codec.decode)(cast(map3)._encoded));
      }
      function traceSegment(map3, line, column) {
        const decoded = decodedMappings(map3);
        if (line >= decoded.length) return null;
        const segments = decoded[line];
        const index = traceSegmentInternal(
          segments,
          cast(map3)._decodedMemo,
          line,
          column,
          GREATEST_LOWER_BOUND
        );
        return index === -1 ? null : segments[index];
      }
      function originalPositionFor(map3, needle) {
        let { line, column, bias } = needle;
        line--;
        if (line < 0) throw new Error(LINE_GTR_ZERO);
        if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
        const decoded = decodedMappings(map3);
        if (line >= decoded.length) return OMapping(null, null, null, null);
        const segments = decoded[line];
        const index = traceSegmentInternal(
          segments,
          cast(map3)._decodedMemo,
          line,
          column,
          bias || GREATEST_LOWER_BOUND
        );
        if (index === -1) return OMapping(null, null, null, null);
        const segment = segments[index];
        if (segment.length === 1) return OMapping(null, null, null, null);
        const { names, resolvedSources } = map3;
        return OMapping(
          resolvedSources[segment[SOURCES_INDEX]],
          segment[SOURCE_LINE] + 1,
          segment[SOURCE_COLUMN],
          segment.length === 5 ? names[segment[NAMES_INDEX]] : null
        );
      }
      function generatedPositionFor(map3, needle) {
        const { source, line, column, bias } = needle;
        return generatedPosition(map3, source, line, column, bias || GREATEST_LOWER_BOUND, false);
      }
      function allGeneratedPositionsFor(map3, needle) {
        const { source, line, column, bias } = needle;
        return generatedPosition(map3, source, line, column, bias || LEAST_UPPER_BOUND, true);
      }
      function eachMapping(map3, cb) {
        const decoded = decodedMappings(map3);
        const { names, resolvedSources } = map3;
        for (let i = 0; i < decoded.length; i++) {
          const line = decoded[i];
          for (let j = 0; j < line.length; j++) {
            const seg = line[j];
            const generatedLine = i + 1;
            const generatedColumn = seg[0];
            let source = null;
            let originalLine = null;
            let originalColumn = null;
            let name28 = null;
            if (seg.length !== 1) {
              source = resolvedSources[seg[1]];
              originalLine = seg[2] + 1;
              originalColumn = seg[3];
            }
            if (seg.length === 5) name28 = names[seg[4]];
            cb({
              generatedLine,
              generatedColumn,
              source,
              originalLine,
              originalColumn,
              name: name28
            });
          }
        }
      }
      function sourceIndex(map3, source) {
        const { sources, resolvedSources } = map3;
        let index = sources.indexOf(source);
        if (index === -1) index = resolvedSources.indexOf(source);
        return index;
      }
      function sourceContentFor(map3, source) {
        const { sourcesContent } = map3;
        if (sourcesContent == null) return null;
        const index = sourceIndex(map3, source);
        return index === -1 ? null : sourcesContent[index];
      }
      function isIgnored(map3, source) {
        const { ignoreList } = map3;
        if (ignoreList == null) return false;
        const index = sourceIndex(map3, source);
        return index === -1 ? false : ignoreList.includes(index);
      }
      function presortedDecodedMap(map3, mapUrl) {
        const tracer = new TraceMap(clone3(map3, []), mapUrl);
        cast(tracer)._decoded = map3.mappings;
        return tracer;
      }
      function decodedMap(map3) {
        return clone3(map3, decodedMappings(map3));
      }
      function encodedMap(map3) {
        return clone3(map3, encodedMappings(map3));
      }
      function clone3(map3, mappings) {
        return {
          version: map3.version,
          file: map3.file,
          names: map3.names,
          sourceRoot: map3.sourceRoot,
          sources: map3.sources,
          sourcesContent: map3.sourcesContent,
          mappings,
          ignoreList: map3.ignoreList || map3.x_google_ignoreList
        };
      }
      function OMapping(source, line, column, name28) {
        return { source, line, column, name: name28 };
      }
      function GMapping(line, column) {
        return { line, column };
      }
      function traceSegmentInternal(segments, memo, line, column, bias) {
        let index = memoizedBinarySearch(segments, column, memo, line);
        if (found) {
          index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
        } else if (bias === LEAST_UPPER_BOUND) index++;
        if (index === -1 || index === segments.length) return -1;
        return index;
      }
      function sliceGeneratedPositions(segments, memo, line, column, bias) {
        let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
        if (!found && bias === LEAST_UPPER_BOUND) min++;
        if (min === -1 || min === segments.length) return [];
        const matchedColumn = found ? column : segments[min][COLUMN];
        if (!found) min = lowerBound(segments, matchedColumn, min);
        const max = upperBound(segments, matchedColumn, min);
        const result = [];
        for (; min <= max; min++) {
          const segment = segments[min];
          result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
        }
        return result;
      }
      function generatedPosition(map3, source, line, column, bias, all3) {
        var _a31, _b27;
        line--;
        if (line < 0) throw new Error(LINE_GTR_ZERO);
        if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
        const { sources, resolvedSources } = map3;
        let sourceIndex2 = sources.indexOf(source);
        if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source);
        if (sourceIndex2 === -1) return all3 ? [] : GMapping(null, null);
        const bySourceMemos = (_a31 = cast(map3))._bySourceMemos || (_a31._bySourceMemos = sources.map(memoizedState));
        const generated = (_b27 = cast(map3))._bySources || (_b27._bySources = buildBySources(decodedMappings(map3), bySourceMemos));
        const segments = generated[sourceIndex2][line];
        if (segments == null) return all3 ? [] : GMapping(null, null);
        const memo = bySourceMemos[sourceIndex2];
        if (all3) return sliceGeneratedPositions(segments, memo, line, column, bias);
        const index = traceSegmentInternal(segments, memo, line, column, bias);
        if (index === -1) return GMapping(null, null);
        const segment = segments[index];
        return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
      }
    }));
  }
});

// node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js
var require_gen_mapping_umd = __commonJS({
  "node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js"(exports2, module2) {
    "use strict";
    (function(global2, factory12) {
      if (typeof exports2 === "object" && typeof module2 !== "undefined") {
        factory12(module2, require_sourcemap_codec_umd(), require_trace_mapping_umd());
        module2.exports = def(module2);
      } else if (typeof define === "function" && define.amd) {
        define(["module", "@jridgewell/sourcemap-codec", "@jridgewell/trace-mapping"], function(mod) {
          factory12.apply(this, arguments);
          mod.exports = def(mod);
        });
      } else {
        const mod = { exports: {} };
        factory12(mod, global2.sourcemapCodec, global2.traceMapping);
        global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self;
        global2.genMapping = def(mod);
      }
      function def(m) {
        return "default" in m.exports ? m.exports.default : m.exports;
      }
    })(exports2, (function(module3, require_sourcemapCodec, require_traceMapping) {
      "use strict";
      var __create2 = Object.create;
      var __defProp4 = Object.defineProperty;
      var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
      var __getOwnPropNames2 = Object.getOwnPropertyNames;
      var __getProtoOf2 = Object.getPrototypeOf;
      var __hasOwnProp2 = Object.prototype.hasOwnProperty;
      var __commonJS2 = (cb, mod) => function __require() {
        return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
      };
      var __export4 = (target, all3) => {
        for (var name28 in all3)
          __defProp4(target, name28, { get: all3[name28], enumerable: true });
      };
      var __copyProps2 = (to, from, except, desc) => {
        if (from && typeof from === "object" || typeof from === "function") {
          for (let key of __getOwnPropNames2(from))
            if (!__hasOwnProp2.call(to, key) && key !== except)
              __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
        }
        return to;
      };
      var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
        // If the importer is in node compatibility mode or this is not an ESM
        // file that has been converted to a CommonJS file using a Babel-
        // compatible transform (i.e. "__esModule" has not been set), then set
        // "default" to the CommonJS "module.exports" for node compatibility.
        isNodeMode || !mod || !mod.__esModule ? __defProp4(target, "default", { value: mod, enumerable: true }) : target,
        mod
      ));
      var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
      var require_sourcemap_codec = __commonJS2({
        "umd:@jridgewell/sourcemap-codec"(exports3, module22) {
          module22.exports = require_sourcemapCodec;
        }
      });
      var require_trace_mapping = __commonJS2({
        "umd:@jridgewell/trace-mapping"(exports3, module22) {
          module22.exports = require_traceMapping;
        }
      });
      var gen_mapping_exports = {};
      __export4(gen_mapping_exports, {
        GenMapping: () => GenMapping,
        addMapping: () => addMapping,
        addSegment: () => addSegment,
        allMappings: () => allMappings,
        fromMap: () => fromMap,
        maybeAddMapping: () => maybeAddMapping,
        maybeAddSegment: () => maybeAddSegment,
        setIgnore: () => setIgnore,
        setSourceContent: () => setSourceContent,
        toDecodedMap: () => toDecodedMap,
        toEncodedMap: () => toEncodedMap
      });
      module3.exports = __toCommonJS2(gen_mapping_exports);
      var SetArray = class {
        constructor() {
          this._indexes = { __proto__: null };
          this.array = [];
        }
      };
      function cast(set3) {
        return set3;
      }
      function get2(setarr, key) {
        return cast(setarr)._indexes[key];
      }
      function put(setarr, key) {
        const index = get2(setarr, key);
        if (index !== void 0) return index;
        const { array: array4, _indexes: indexes } = cast(setarr);
        const length = array4.push(key);
        return indexes[key] = length - 1;
      }
      function remove(setarr, key) {
        const index = get2(setarr, key);
        if (index === void 0) return;
        const { array: array4, _indexes: indexes } = cast(setarr);
        for (let i = index + 1; i < array4.length; i++) {
          const k = array4[i];
          array4[i - 1] = k;
          indexes[k]--;
        }
        indexes[key] = void 0;
        array4.pop();
      }
      var import_sourcemap_codec = __toESM2(require_sourcemap_codec());
      var import_trace_mapping = __toESM2(require_trace_mapping());
      var COLUMN = 0;
      var SOURCES_INDEX = 1;
      var SOURCE_LINE = 2;
      var SOURCE_COLUMN = 3;
      var NAMES_INDEX = 4;
      var NO_NAME = -1;
      var GenMapping = class {
        constructor({ file: file3, sourceRoot } = {}) {
          this._names = new SetArray();
          this._sources = new SetArray();
          this._sourcesContent = [];
          this._mappings = [];
          this.file = file3;
          this.sourceRoot = sourceRoot;
          this._ignoreList = new SetArray();
        }
      };
      function cast2(map3) {
        return map3;
      }
      function addSegment(map3, genLine, genColumn, source, sourceLine, sourceColumn, name28, content) {
        return addSegmentInternal(
          false,
          map3,
          genLine,
          genColumn,
          source,
          sourceLine,
          sourceColumn,
          name28,
          content
        );
      }
      function addMapping(map3, mapping) {
        return addMappingInternal(false, map3, mapping);
      }
      var maybeAddSegment = (map3, genLine, genColumn, source, sourceLine, sourceColumn, name28, content) => {
        return addSegmentInternal(
          true,
          map3,
          genLine,
          genColumn,
          source,
          sourceLine,
          sourceColumn,
          name28,
          content
        );
      };
      var maybeAddMapping = (map3, mapping) => {
        return addMappingInternal(true, map3, mapping);
      };
      function setSourceContent(map3, source, content) {
        const {
          _sources: sources,
          _sourcesContent: sourcesContent
          // _originalScopes: originalScopes,
        } = cast2(map3);
        const index = put(sources, source);
        sourcesContent[index] = content;
      }
      function setIgnore(map3, source, ignore = true) {
        const {
          _sources: sources,
          _sourcesContent: sourcesContent,
          _ignoreList: ignoreList
          // _originalScopes: originalScopes,
        } = cast2(map3);
        const index = put(sources, source);
        if (index === sourcesContent.length) sourcesContent[index] = null;
        if (ignore) put(ignoreList, index);
        else remove(ignoreList, index);
      }
      function toDecodedMap(map3) {
        const {
          _mappings: mappings,
          _sources: sources,
          _sourcesContent: sourcesContent,
          _names: names,
          _ignoreList: ignoreList
          // _originalScopes: originalScopes,
          // _generatedRanges: generatedRanges,
        } = cast2(map3);
        removeEmptyFinalLines(mappings);
        return {
          version: 3,
          file: map3.file || void 0,
          names: names.array,
          sourceRoot: map3.sourceRoot || void 0,
          sources: sources.array,
          sourcesContent,
          mappings,
          // originalScopes,
          // generatedRanges,
          ignoreList: ignoreList.array
        };
      }
      function toEncodedMap(map3) {
        const decoded = toDecodedMap(map3);
        return Object.assign({}, decoded, {
          // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)),
          // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]),
          mappings: (0, import_sourcemap_codec.encode)(decoded.mappings)
        });
      }
      function fromMap(input) {
        const map3 = new import_trace_mapping.TraceMap(input);
        const gen = new GenMapping({ file: map3.file, sourceRoot: map3.sourceRoot });
        putAll(cast2(gen)._names, map3.names);
        putAll(cast2(gen)._sources, map3.sources);
        cast2(gen)._sourcesContent = map3.sourcesContent || map3.sources.map(() => null);
        cast2(gen)._mappings = (0, import_trace_mapping.decodedMappings)(map3);
        if (map3.ignoreList) putAll(cast2(gen)._ignoreList, map3.ignoreList);
        return gen;
      }
      function allMappings(map3) {
        const out = [];
        const { _mappings: mappings, _sources: sources, _names: names } = cast2(map3);
        for (let i = 0; i < mappings.length; i++) {
          const line = mappings[i];
          for (let j = 0; j < line.length; j++) {
            const seg = line[j];
            const generated = { line: i + 1, column: seg[COLUMN] };
            let source = void 0;
            let original = void 0;
            let name28 = void 0;
            if (seg.length !== 1) {
              source = sources.array[seg[SOURCES_INDEX]];
              original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
              if (seg.length === 5) name28 = names.array[seg[NAMES_INDEX]];
            }
            out.push({ generated, source, original, name: name28 });
          }
        }
        return out;
      }
      function addSegmentInternal(skipable, map3, genLine, genColumn, source, sourceLine, sourceColumn, name28, content) {
        const {
          _mappings: mappings,
          _sources: sources,
          _sourcesContent: sourcesContent,
          _names: names
          // _originalScopes: originalScopes,
        } = cast2(map3);
        const line = getIndex(mappings, genLine);
        const index = getColumnIndex(line, genColumn);
        if (!source) {
          if (skipable && skipSourceless(line, index)) return;
          return insert(line, index, [genColumn]);
        }
        assert3(sourceLine);
        assert3(sourceColumn);
        const sourcesIndex = put(sources, source);
        const namesIndex = name28 ? put(names, name28) : NO_NAME;
        if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null;
        if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
          return;
        }
        return insert(
          line,
          index,
          name28 ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]
        );
      }
      function assert3(_val) {
      }
      function getIndex(arr, index) {
        for (let i = arr.length; i <= index; i++) {
          arr[i] = [];
        }
        return arr[index];
      }
      function getColumnIndex(line, genColumn) {
        let index = line.length;
        for (let i = index - 1; i >= 0; index = i--) {
          const current = line[i];
          if (genColumn >= current[COLUMN]) break;
        }
        return index;
      }
      function insert(array4, index, value) {
        for (let i = array4.length; i > index; i--) {
          array4[i] = array4[i - 1];
        }
        array4[index] = value;
      }
      function removeEmptyFinalLines(mappings) {
        const { length } = mappings;
        let len = length;
        for (let i = len - 1; i >= 0; len = i, i--) {
          if (mappings[i].length > 0) break;
        }
        if (len < length) mappings.length = len;
      }
      function putAll(setarr, array4) {
        for (let i = 0; i < array4.length; i++) put(setarr, array4[i]);
      }
      function skipSourceless(line, index) {
        if (index === 0) return true;
        const prev = line[index - 1];
        return prev.length === 1;
      }
      function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
        if (index === 0) return false;
        const prev = line[index - 1];
        if (prev.length === 1) return false;
        return sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
      }
      function addMappingInternal(skipable, map3, mapping) {
        const { generated, source, original, name: name28, content } = mapping;
        if (!source) {
          return addSegmentInternal(
            skipable,
            map3,
            generated.line - 1,
            generated.column,
            null,
            null,
            null,
            null,
            null
          );
        }
        assert3(original);
        return addSegmentInternal(
          skipable,
          map3,
          generated.line - 1,
          generated.column,
          source,
          original.line - 1,
          original.column,
          name28,
          content
        );
      }
    }));
  }
});

// node_modules/sucrase/dist/computeSourceMap.js
var require_computeSourceMap = __commonJS({
  "node_modules/sucrase/dist/computeSourceMap.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _genmapping = require_gen_mapping_umd();
    var _charcodes = require_charcodes();
    function computeSourceMap({ code: generatedCode, mappings: rawMappings }, filePath, options, source, tokens) {
      const sourceColumns = computeSourceColumns(source, tokens);
      const map3 = new (0, _genmapping.GenMapping)({ file: options.compiledFilename });
      let tokenIndex = 0;
      let currentMapping = rawMappings[0];
      while (currentMapping === void 0 && tokenIndex < rawMappings.length - 1) {
        tokenIndex++;
        currentMapping = rawMappings[tokenIndex];
      }
      let line = 0;
      let lineStart = 0;
      if (currentMapping !== lineStart) {
        _genmapping.maybeAddSegment.call(void 0, map3, line, 0, filePath, line, 0);
      }
      for (let i = 0; i < generatedCode.length; i++) {
        if (i === currentMapping) {
          const genColumn = currentMapping - lineStart;
          const sourceColumn = sourceColumns[tokenIndex];
          _genmapping.maybeAddSegment.call(void 0, map3, line, genColumn, filePath, line, sourceColumn);
          while ((currentMapping === i || currentMapping === void 0) && tokenIndex < rawMappings.length - 1) {
            tokenIndex++;
            currentMapping = rawMappings[tokenIndex];
          }
        }
        if (generatedCode.charCodeAt(i) === _charcodes.charCodes.lineFeed) {
          line++;
          lineStart = i + 1;
          if (currentMapping !== lineStart) {
            _genmapping.maybeAddSegment.call(void 0, map3, line, 0, filePath, line, 0);
          }
        }
      }
      const { sourceRoot, sourcesContent, ...sourceMap } = _genmapping.toEncodedMap.call(void 0, map3);
      return sourceMap;
    }
    exports2.default = computeSourceMap;
    function computeSourceColumns(code, tokens) {
      const sourceColumns = new Array(tokens.length);
      let tokenIndex = 0;
      let currentMapping = tokens[tokenIndex].start;
      let lineStart = 0;
      for (let i = 0; i < code.length; i++) {
        if (i === currentMapping) {
          sourceColumns[tokenIndex] = currentMapping - lineStart;
          tokenIndex++;
          currentMapping = tokens[tokenIndex].start;
        }
        if (code.charCodeAt(i) === _charcodes.charCodes.lineFeed) {
          lineStart = i + 1;
        }
      }
      return sourceColumns;
    }
  }
});

// node_modules/sucrase/dist/HelperManager.js
var require_HelperManager = __commonJS({
  "node_modules/sucrase/dist/HelperManager.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var HELPERS = {
      require: `
    import {createRequire as CREATE_REQUIRE_NAME} from "module";
    const require = CREATE_REQUIRE_NAME(import.meta.url);
  `,
      interopRequireWildcard: `
    function interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) {
              newObj[key] = obj[key];
            }
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }
  `,
      interopRequireDefault: `
    function interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
  `,
      createNamedExportFrom: `
    function createNamedExportFrom(obj, localName, importedName) {
      Object.defineProperty(exports, localName, {enumerable: true, configurable: true, get: () => obj[importedName]});
    }
  `,
      // Note that TypeScript and Babel do this differently; TypeScript does a simple existence
      // check in the exports object and does a plain assignment, whereas Babel uses
      // defineProperty and builds an object of explicitly-exported names so that star exports can
      // always take lower precedence. For now, we do the easier TypeScript thing.
      createStarExport: `
    function createStarExport(obj) {
      Object.keys(obj)
        .filter((key) => key !== "default" && key !== "__esModule")
        .forEach((key) => {
          if (exports.hasOwnProperty(key)) {
            return;
          }
          Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]});
        });
    }
  `,
      nullishCoalesce: `
    function nullishCoalesce(lhs, rhsFn) {
      if (lhs != null) {
        return lhs;
      } else {
        return rhsFn();
      }
    }
  `,
      asyncNullishCoalesce: `
    async function asyncNullishCoalesce(lhs, rhsFn) {
      if (lhs != null) {
        return lhs;
      } else {
        return await rhsFn();
      }
    }
  `,
      optionalChain: `
    function optionalChain(ops) {
      let lastAccessLHS = undefined;
      let value = ops[0];
      let i = 1;
      while (i < ops.length) {
        const op = ops[i];
        const fn = ops[i + 1];
        i += 2;
        if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {
          return undefined;
        }
        if (op === 'access' || op === 'optionalAccess') {
          lastAccessLHS = value;
          value = fn(value);
        } else if (op === 'call' || op === 'optionalCall') {
          value = fn((...args) => value.call(lastAccessLHS, ...args));
          lastAccessLHS = undefined;
        }
      }
      return value;
    }
  `,
      asyncOptionalChain: `
    async function asyncOptionalChain(ops) {
      let lastAccessLHS = undefined;
      let value = ops[0];
      let i = 1;
      while (i < ops.length) {
        const op = ops[i];
        const fn = ops[i + 1];
        i += 2;
        if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {
          return undefined;
        }
        if (op === 'access' || op === 'optionalAccess') {
          lastAccessLHS = value;
          value = await fn(value);
        } else if (op === 'call' || op === 'optionalCall') {
          value = await fn((...args) => value.call(lastAccessLHS, ...args));
          lastAccessLHS = undefined;
        }
      }
      return value;
    }
  `,
      optionalChainDelete: `
    function optionalChainDelete(ops) {
      const result = OPTIONAL_CHAIN_NAME(ops);
      return result == null ? true : result;
    }
  `,
      asyncOptionalChainDelete: `
    async function asyncOptionalChainDelete(ops) {
      const result = await ASYNC_OPTIONAL_CHAIN_NAME(ops);
      return result == null ? true : result;
    }
  `
    };
    var HelperManager = class _HelperManager {
      __init() {
        this.helperNames = {};
      }
      __init2() {
        this.createRequireName = null;
      }
      constructor(nameManager) {
        ;
        this.nameManager = nameManager;
        _HelperManager.prototype.__init.call(this);
        _HelperManager.prototype.__init2.call(this);
      }
      getHelperName(baseName) {
        let helperName = this.helperNames[baseName];
        if (helperName) {
          return helperName;
        }
        helperName = this.nameManager.claimFreeName(`_${baseName}`);
        this.helperNames[baseName] = helperName;
        return helperName;
      }
      emitHelpers() {
        let resultCode = "";
        if (this.helperNames.optionalChainDelete) {
          this.getHelperName("optionalChain");
        }
        if (this.helperNames.asyncOptionalChainDelete) {
          this.getHelperName("asyncOptionalChain");
        }
        for (const [baseName, helperCodeTemplate] of Object.entries(HELPERS)) {
          const helperName = this.helperNames[baseName];
          let helperCode = helperCodeTemplate;
          if (baseName === "optionalChainDelete") {
            helperCode = helperCode.replace("OPTIONAL_CHAIN_NAME", this.helperNames.optionalChain);
          } else if (baseName === "asyncOptionalChainDelete") {
            helperCode = helperCode.replace(
              "ASYNC_OPTIONAL_CHAIN_NAME",
              this.helperNames.asyncOptionalChain
            );
          } else if (baseName === "require") {
            if (this.createRequireName === null) {
              this.createRequireName = this.nameManager.claimFreeName("_createRequire");
            }
            helperCode = helperCode.replace(/CREATE_REQUIRE_NAME/g, this.createRequireName);
          }
          if (helperName) {
            resultCode += " ";
            resultCode += helperCode.replace(baseName, helperName).replace(/\s+/g, " ").trim();
          }
        }
        return resultCode;
      }
    };
    exports2.HelperManager = HelperManager;
  }
});

// node_modules/sucrase/dist/identifyShadowedGlobals.js
var require_identifyShadowedGlobals = __commonJS({
  "node_modules/sucrase/dist/identifyShadowedGlobals.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _tokenizer = require_tokenizer2();
    var _types = require_types();
    function identifyShadowedGlobals(tokens, scopes, globalNames) {
      if (!hasShadowedGlobals(tokens, globalNames)) {
        return;
      }
      markShadowedGlobals(tokens, scopes, globalNames);
    }
    exports2.default = identifyShadowedGlobals;
    function hasShadowedGlobals(tokens, globalNames) {
      for (const token of tokens.tokens) {
        if (token.type === _types.TokenType.name && !token.isType && _tokenizer.isNonTopLevelDeclaration.call(void 0, token) && globalNames.has(tokens.identifierNameForToken(token))) {
          return true;
        }
      }
      return false;
    }
    exports2.hasShadowedGlobals = hasShadowedGlobals;
    function markShadowedGlobals(tokens, scopes, globalNames) {
      const scopeStack = [];
      let scopeIndex = scopes.length - 1;
      for (let i = tokens.tokens.length - 1; ; i--) {
        while (scopeStack.length > 0 && scopeStack[scopeStack.length - 1].startTokenIndex === i + 1) {
          scopeStack.pop();
        }
        while (scopeIndex >= 0 && scopes[scopeIndex].endTokenIndex === i + 1) {
          scopeStack.push(scopes[scopeIndex]);
          scopeIndex--;
        }
        if (i < 0) {
          break;
        }
        const token = tokens.tokens[i];
        const name28 = tokens.identifierNameForToken(token);
        if (scopeStack.length > 1 && !token.isType && token.type === _types.TokenType.name && globalNames.has(name28)) {
          if (_tokenizer.isBlockScopedDeclaration.call(void 0, token)) {
            markShadowedForScope(scopeStack[scopeStack.length - 1], tokens, name28);
          } else if (_tokenizer.isFunctionScopedDeclaration.call(void 0, token)) {
            let stackIndex = scopeStack.length - 1;
            while (stackIndex > 0 && !scopeStack[stackIndex].isFunctionScope) {
              stackIndex--;
            }
            if (stackIndex < 0) {
              throw new Error("Did not find parent function scope.");
            }
            markShadowedForScope(scopeStack[stackIndex], tokens, name28);
          }
        }
      }
      if (scopeStack.length > 0) {
        throw new Error("Expected empty scope stack after processing file.");
      }
    }
    function markShadowedForScope(scope, tokens, name28) {
      for (let i = scope.startTokenIndex; i < scope.endTokenIndex; i++) {
        const token = tokens.tokens[i];
        if ((token.type === _types.TokenType.name || token.type === _types.TokenType.jsxName) && tokens.identifierNameForToken(token) === name28) {
          token.shadowsGlobal = true;
        }
      }
    }
  }
});

// node_modules/sucrase/dist/util/getIdentifierNames.js
var require_getIdentifierNames = __commonJS({
  "node_modules/sucrase/dist/util/getIdentifierNames.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _types = require_types();
    function getIdentifierNames(code, tokens) {
      const names = [];
      for (const token of tokens) {
        if (token.type === _types.TokenType.name) {
          names.push(code.slice(token.start, token.end));
        }
      }
      return names;
    }
    exports2.default = getIdentifierNames;
  }
});

// node_modules/sucrase/dist/NameManager.js
var require_NameManager = __commonJS({
  "node_modules/sucrase/dist/NameManager.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _getIdentifierNames = require_getIdentifierNames();
    var _getIdentifierNames2 = _interopRequireDefault(_getIdentifierNames);
    var NameManager = class _NameManager {
      __init() {
        this.usedNames = /* @__PURE__ */ new Set();
      }
      constructor(code, tokens) {
        ;
        _NameManager.prototype.__init.call(this);
        this.usedNames = new Set(_getIdentifierNames2.default.call(void 0, code, tokens));
      }
      claimFreeName(name28) {
        const newName = this.findFreeName(name28);
        this.usedNames.add(newName);
        return newName;
      }
      findFreeName(name28) {
        if (!this.usedNames.has(name28)) {
          return name28;
        }
        let suffixNum = 2;
        while (this.usedNames.has(name28 + String(suffixNum))) {
          suffixNum++;
        }
        return name28 + String(suffixNum);
      }
    };
    exports2.default = NameManager;
  }
});

// node_modules/ts-interface-checker/dist/util.js
var require_util2 = __commonJS({
  "node_modules/ts-interface-checker/dist/util.js"(exports2) {
    "use strict";
    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
      var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
          d2.__proto__ = b2;
        } || function(d2, b2) {
          for (var p3 in b2) if (b2.hasOwnProperty(p3)) d2[p3] = b2[p3];
        };
        return extendStatics(d, b);
      };
      return function(d, b) {
        extendStatics(d, b);
        function __() {
          this.constructor = d;
        }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
    })();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.DetailContext = exports2.NoopContext = exports2.VError = void 0;
    var VError = (
      /** @class */
      (function(_super) {
        __extends(VError2, _super);
        function VError2(path33, message) {
          var _this = _super.call(this, message) || this;
          _this.path = path33;
          Object.setPrototypeOf(_this, VError2.prototype);
          return _this;
        }
        return VError2;
      })(Error)
    );
    exports2.VError = VError;
    var NoopContext = (
      /** @class */
      (function() {
        function NoopContext2() {
        }
        NoopContext2.prototype.fail = function(relPath, message, score) {
          return false;
        };
        NoopContext2.prototype.unionResolver = function() {
          return this;
        };
        NoopContext2.prototype.createContext = function() {
          return this;
        };
        NoopContext2.prototype.resolveUnion = function(ur) {
        };
        return NoopContext2;
      })()
    );
    exports2.NoopContext = NoopContext;
    var DetailContext = (
      /** @class */
      (function() {
        function DetailContext2() {
          this._propNames = [""];
          this._messages = [null];
          this._score = 0;
        }
        DetailContext2.prototype.fail = function(relPath, message, score) {
          this._propNames.push(relPath);
          this._messages.push(message);
          this._score += score;
          return false;
        };
        DetailContext2.prototype.unionResolver = function() {
          return new DetailUnionResolver();
        };
        DetailContext2.prototype.resolveUnion = function(unionResolver) {
          var _a31, _b27;
          var u = unionResolver;
          var best = null;
          for (var _i = 0, _c = u.contexts; _i < _c.length; _i++) {
            var ctx = _c[_i];
            if (!best || ctx._score >= best._score) {
              best = ctx;
            }
          }
          if (best && best._score > 0) {
            (_a31 = this._propNames).push.apply(_a31, best._propNames);
            (_b27 = this._messages).push.apply(_b27, best._messages);
          }
        };
        DetailContext2.prototype.getError = function(path33) {
          var msgParts = [];
          for (var i = this._propNames.length - 1; i >= 0; i--) {
            var p3 = this._propNames[i];
            path33 += typeof p3 === "number" ? "[" + p3 + "]" : p3 ? "." + p3 : "";
            var m = this._messages[i];
            if (m) {
              msgParts.push(path33 + " " + m);
            }
          }
          return new VError(path33, msgParts.join("; "));
        };
        DetailContext2.prototype.getErrorDetail = function(path33) {
          var details = [];
          for (var i = this._propNames.length - 1; i >= 0; i--) {
            var p3 = this._propNames[i];
            path33 += typeof p3 === "number" ? "[" + p3 + "]" : p3 ? "." + p3 : "";
            var message = this._messages[i];
            if (message) {
              details.push({ path: path33, message });
            }
          }
          var detail = null;
          for (var i = details.length - 1; i >= 0; i--) {
            if (detail) {
              details[i].nested = [detail];
            }
            detail = details[i];
          }
          return detail;
        };
        return DetailContext2;
      })()
    );
    exports2.DetailContext = DetailContext;
    var DetailUnionResolver = (
      /** @class */
      (function() {
        function DetailUnionResolver2() {
          this.contexts = [];
        }
        DetailUnionResolver2.prototype.createContext = function() {
          var ctx = new DetailContext();
          this.contexts.push(ctx);
          return ctx;
        };
        return DetailUnionResolver2;
      })()
    );
  }
});

// node_modules/ts-interface-checker/dist/types.js
var require_types2 = __commonJS({
  "node_modules/ts-interface-checker/dist/types.js"(exports2) {
    "use strict";
    var __extends = exports2 && exports2.__extends || /* @__PURE__ */ (function() {
      var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
          d2.__proto__ = b2;
        } || function(d2, b2) {
          for (var p3 in b2) if (b2.hasOwnProperty(p3)) d2[p3] = b2[p3];
        };
        return extendStatics(d, b);
      };
      return function(d, b) {
        extendStatics(d, b);
        function __() {
          this.constructor = d;
        }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
    })();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.basicTypes = exports2.BasicType = exports2.TParamList = exports2.TParam = exports2.param = exports2.TFunc = exports2.func = exports2.TProp = exports2.TOptional = exports2.opt = exports2.TIface = exports2.iface = exports2.TEnumLiteral = exports2.enumlit = exports2.TEnumType = exports2.enumtype = exports2.TIntersection = exports2.intersection = exports2.TUnion = exports2.union = exports2.TTuple = exports2.tuple = exports2.TArray = exports2.array = exports2.TLiteral = exports2.lit = exports2.TName = exports2.name = exports2.TType = void 0;
    var util_1 = require_util2();
    var TType = (
      /** @class */
      /* @__PURE__ */ (function() {
        function TType2() {
        }
        return TType2;
      })()
    );
    exports2.TType = TType;
    function parseSpec(typeSpec) {
      return typeof typeSpec === "string" ? name28(typeSpec) : typeSpec;
    }
    function getNamedType(suite, name29) {
      var ttype = suite[name29];
      if (!ttype) {
        throw new Error("Unknown type " + name29);
      }
      return ttype;
    }
    function name28(value) {
      return new TName(value);
    }
    exports2.name = name28;
    var TName = (
      /** @class */
      (function(_super) {
        __extends(TName2, _super);
        function TName2(name29) {
          var _this = _super.call(this) || this;
          _this.name = name29;
          _this._failMsg = "is not a " + name29;
          return _this;
        }
        TName2.prototype.getChecker = function(suite, strict, allowedProps) {
          var _this = this;
          var ttype = getNamedType(suite, this.name);
          var checker = ttype.getChecker(suite, strict, allowedProps);
          if (ttype instanceof BasicType || ttype instanceof TName2) {
            return checker;
          }
          return function(value, ctx) {
            return checker(value, ctx) ? true : ctx.fail(null, _this._failMsg, 0);
          };
        };
        return TName2;
      })(TType)
    );
    exports2.TName = TName;
    function lit(value) {
      return new TLiteral(value);
    }
    exports2.lit = lit;
    var TLiteral = (
      /** @class */
      (function(_super) {
        __extends(TLiteral2, _super);
        function TLiteral2(value) {
          var _this = _super.call(this) || this;
          _this.value = value;
          _this.name = JSON.stringify(value);
          _this._failMsg = "is not " + _this.name;
          return _this;
        }
        TLiteral2.prototype.getChecker = function(suite, strict) {
          var _this = this;
          return function(value, ctx) {
            return value === _this.value ? true : ctx.fail(null, _this._failMsg, -1);
          };
        };
        return TLiteral2;
      })(TType)
    );
    exports2.TLiteral = TLiteral;
    function array4(typeSpec) {
      return new TArray(parseSpec(typeSpec));
    }
    exports2.array = array4;
    var TArray = (
      /** @class */
      (function(_super) {
        __extends(TArray2, _super);
        function TArray2(ttype) {
          var _this = _super.call(this) || this;
          _this.ttype = ttype;
          return _this;
        }
        TArray2.prototype.getChecker = function(suite, strict) {
          var itemChecker = this.ttype.getChecker(suite, strict);
          return function(value, ctx) {
            if (!Array.isArray(value)) {
              return ctx.fail(null, "is not an array", 0);
            }
            for (var i = 0; i < value.length; i++) {
              var ok = itemChecker(value[i], ctx);
              if (!ok) {
                return ctx.fail(i, null, 1);
              }
            }
            return true;
          };
        };
        return TArray2;
      })(TType)
    );
    exports2.TArray = TArray;
    function tuple3() {
      var typeSpec = [];
      for (var _i2 = 0; _i2 < arguments.length; _i2++) {
        typeSpec[_i2] = arguments[_i2];
      }
      return new TTuple(typeSpec.map(function(t) {
        return parseSpec(t);
      }));
    }
    exports2.tuple = tuple3;
    var TTuple = (
      /** @class */
      (function(_super) {
        __extends(TTuple2, _super);
        function TTuple2(ttypes) {
          var _this = _super.call(this) || this;
          _this.ttypes = ttypes;
          return _this;
        }
        TTuple2.prototype.getChecker = function(suite, strict) {
          var itemCheckers = this.ttypes.map(function(t) {
            return t.getChecker(suite, strict);
          });
          var checker = function(value, ctx) {
            if (!Array.isArray(value)) {
              return ctx.fail(null, "is not an array", 0);
            }
            for (var i = 0; i < itemCheckers.length; i++) {
              var ok = itemCheckers[i](value[i], ctx);
              if (!ok) {
                return ctx.fail(i, null, 1);
              }
            }
            return true;
          };
          if (!strict) {
            return checker;
          }
          return function(value, ctx) {
            if (!checker(value, ctx)) {
              return false;
            }
            return value.length <= itemCheckers.length ? true : ctx.fail(itemCheckers.length, "is extraneous", 2);
          };
        };
        return TTuple2;
      })(TType)
    );
    exports2.TTuple = TTuple;
    function union3() {
      var typeSpec = [];
      for (var _i2 = 0; _i2 < arguments.length; _i2++) {
        typeSpec[_i2] = arguments[_i2];
      }
      return new TUnion(typeSpec.map(function(t) {
        return parseSpec(t);
      }));
    }
    exports2.union = union3;
    var TUnion = (
      /** @class */
      (function(_super) {
        __extends(TUnion2, _super);
        function TUnion2(ttypes) {
          var _this = _super.call(this) || this;
          _this.ttypes = ttypes;
          var names = ttypes.map(function(t) {
            return t instanceof TName || t instanceof TLiteral ? t.name : null;
          }).filter(function(n) {
            return n;
          });
          var otherTypes = ttypes.length - names.length;
          if (names.length) {
            if (otherTypes > 0) {
              names.push(otherTypes + " more");
            }
            _this._failMsg = "is none of " + names.join(", ");
          } else {
            _this._failMsg = "is none of " + otherTypes + " types";
          }
          return _this;
        }
        TUnion2.prototype.getChecker = function(suite, strict) {
          var _this = this;
          var itemCheckers = this.ttypes.map(function(t) {
            return t.getChecker(suite, strict);
          });
          return function(value, ctx) {
            var ur = ctx.unionResolver();
            for (var i = 0; i < itemCheckers.length; i++) {
              var ok = itemCheckers[i](value, ur.createContext());
              if (ok) {
                return true;
              }
            }
            ctx.resolveUnion(ur);
            return ctx.fail(null, _this._failMsg, 0);
          };
        };
        return TUnion2;
      })(TType)
    );
    exports2.TUnion = TUnion;
    function intersection3() {
      var typeSpec = [];
      for (var _i2 = 0; _i2 < arguments.length; _i2++) {
        typeSpec[_i2] = arguments[_i2];
      }
      return new TIntersection(typeSpec.map(function(t) {
        return parseSpec(t);
      }));
    }
    exports2.intersection = intersection3;
    var TIntersection = (
      /** @class */
      (function(_super) {
        __extends(TIntersection2, _super);
        function TIntersection2(ttypes) {
          var _this = _super.call(this) || this;
          _this.ttypes = ttypes;
          return _this;
        }
        TIntersection2.prototype.getChecker = function(suite, strict) {
          var allowedProps = /* @__PURE__ */ new Set();
          var itemCheckers = this.ttypes.map(function(t) {
            return t.getChecker(suite, strict, allowedProps);
          });
          return function(value, ctx) {
            var ok = itemCheckers.every(function(checker) {
              return checker(value, ctx);
            });
            if (ok) {
              return true;
            }
            return ctx.fail(null, null, 0);
          };
        };
        return TIntersection2;
      })(TType)
    );
    exports2.TIntersection = TIntersection;
    function enumtype(values) {
      return new TEnumType(values);
    }
    exports2.enumtype = enumtype;
    var TEnumType = (
      /** @class */
      (function(_super) {
        __extends(TEnumType2, _super);
        function TEnumType2(members) {
          var _this = _super.call(this) || this;
          _this.members = members;
          _this.validValues = /* @__PURE__ */ new Set();
          _this._failMsg = "is not a valid enum value";
          _this.validValues = new Set(Object.keys(members).map(function(name29) {
            return members[name29];
          }));
          return _this;
        }
        TEnumType2.prototype.getChecker = function(suite, strict) {
          var _this = this;
          return function(value, ctx) {
            return _this.validValues.has(value) ? true : ctx.fail(null, _this._failMsg, 0);
          };
        };
        return TEnumType2;
      })(TType)
    );
    exports2.TEnumType = TEnumType;
    function enumlit(name29, prop) {
      return new TEnumLiteral(name29, prop);
    }
    exports2.enumlit = enumlit;
    var TEnumLiteral = (
      /** @class */
      (function(_super) {
        __extends(TEnumLiteral2, _super);
        function TEnumLiteral2(enumName, prop) {
          var _this = _super.call(this) || this;
          _this.enumName = enumName;
          _this.prop = prop;
          _this._failMsg = "is not " + enumName + "." + prop;
          return _this;
        }
        TEnumLiteral2.prototype.getChecker = function(suite, strict) {
          var _this = this;
          var ttype = getNamedType(suite, this.enumName);
          if (!(ttype instanceof TEnumType)) {
            throw new Error("Type " + this.enumName + " used in enumlit is not an enum type");
          }
          var val = ttype.members[this.prop];
          if (!ttype.members.hasOwnProperty(this.prop)) {
            throw new Error("Unknown value " + this.enumName + "." + this.prop + " used in enumlit");
          }
          return function(value, ctx) {
            return value === val ? true : ctx.fail(null, _this._failMsg, -1);
          };
        };
        return TEnumLiteral2;
      })(TType)
    );
    exports2.TEnumLiteral = TEnumLiteral;
    function makeIfaceProps(props) {
      return Object.keys(props).map(function(name29) {
        return makeIfaceProp(name29, props[name29]);
      });
    }
    function makeIfaceProp(name29, prop) {
      return prop instanceof TOptional ? new TProp(name29, prop.ttype, true) : new TProp(name29, parseSpec(prop), false);
    }
    function iface(bases, props) {
      return new TIface(bases, makeIfaceProps(props));
    }
    exports2.iface = iface;
    var TIface = (
      /** @class */
      (function(_super) {
        __extends(TIface2, _super);
        function TIface2(bases, props) {
          var _this = _super.call(this) || this;
          _this.bases = bases;
          _this.props = props;
          _this.propSet = new Set(props.map(function(p3) {
            return p3.name;
          }));
          return _this;
        }
        TIface2.prototype.getChecker = function(suite, strict, allowedProps) {
          var _this = this;
          var baseCheckers = this.bases.map(function(b) {
            return getNamedType(suite, b).getChecker(suite, strict);
          });
          var propCheckers = this.props.map(function(prop) {
            return prop.ttype.getChecker(suite, strict);
          });
          var testCtx = new util_1.NoopContext();
          var isPropRequired = this.props.map(function(prop, i) {
            return !prop.isOpt && !propCheckers[i](void 0, testCtx);
          });
          var checker = function(value, ctx) {
            if (typeof value !== "object" || value === null) {
              return ctx.fail(null, "is not an object", 0);
            }
            for (var i = 0; i < baseCheckers.length; i++) {
              if (!baseCheckers[i](value, ctx)) {
                return false;
              }
            }
            for (var i = 0; i < propCheckers.length; i++) {
              var name_1 = _this.props[i].name;
              var v = value[name_1];
              if (v === void 0) {
                if (isPropRequired[i]) {
                  return ctx.fail(name_1, "is missing", 1);
                }
              } else {
                var ok = propCheckers[i](v, ctx);
                if (!ok) {
                  return ctx.fail(name_1, null, 1);
                }
              }
            }
            return true;
          };
          if (!strict) {
            return checker;
          }
          var propSet = this.propSet;
          if (allowedProps) {
            this.propSet.forEach(function(prop) {
              return allowedProps.add(prop);
            });
            propSet = allowedProps;
          }
          return function(value, ctx) {
            if (!checker(value, ctx)) {
              return false;
            }
            for (var prop in value) {
              if (!propSet.has(prop)) {
                return ctx.fail(prop, "is extraneous", 2);
              }
            }
            return true;
          };
        };
        return TIface2;
      })(TType)
    );
    exports2.TIface = TIface;
    function opt(typeSpec) {
      return new TOptional(parseSpec(typeSpec));
    }
    exports2.opt = opt;
    var TOptional = (
      /** @class */
      (function(_super) {
        __extends(TOptional2, _super);
        function TOptional2(ttype) {
          var _this = _super.call(this) || this;
          _this.ttype = ttype;
          return _this;
        }
        TOptional2.prototype.getChecker = function(suite, strict) {
          var itemChecker = this.ttype.getChecker(suite, strict);
          return function(value, ctx) {
            return value === void 0 || itemChecker(value, ctx);
          };
        };
        return TOptional2;
      })(TType)
    );
    exports2.TOptional = TOptional;
    var TProp = (
      /** @class */
      /* @__PURE__ */ (function() {
        function TProp2(name29, ttype, isOpt) {
          this.name = name29;
          this.ttype = ttype;
          this.isOpt = isOpt;
        }
        return TProp2;
      })()
    );
    exports2.TProp = TProp;
    function func(resultSpec) {
      var params = [];
      for (var _i2 = 1; _i2 < arguments.length; _i2++) {
        params[_i2 - 1] = arguments[_i2];
      }
      return new TFunc(new TParamList(params), parseSpec(resultSpec));
    }
    exports2.func = func;
    var TFunc = (
      /** @class */
      (function(_super) {
        __extends(TFunc2, _super);
        function TFunc2(paramList, result) {
          var _this = _super.call(this) || this;
          _this.paramList = paramList;
          _this.result = result;
          return _this;
        }
        TFunc2.prototype.getChecker = function(suite, strict) {
          return function(value, ctx) {
            return typeof value === "function" ? true : ctx.fail(null, "is not a function", 0);
          };
        };
        return TFunc2;
      })(TType)
    );
    exports2.TFunc = TFunc;
    function param(name29, typeSpec, isOpt) {
      return new TParam(name29, parseSpec(typeSpec), Boolean(isOpt));
    }
    exports2.param = param;
    var TParam = (
      /** @class */
      /* @__PURE__ */ (function() {
        function TParam2(name29, ttype, isOpt) {
          this.name = name29;
          this.ttype = ttype;
          this.isOpt = isOpt;
        }
        return TParam2;
      })()
    );
    exports2.TParam = TParam;
    var TParamList = (
      /** @class */
      (function(_super) {
        __extends(TParamList2, _super);
        function TParamList2(params) {
          var _this = _super.call(this) || this;
          _this.params = params;
          return _this;
        }
        TParamList2.prototype.getChecker = function(suite, strict) {
          var _this = this;
          var itemCheckers = this.params.map(function(t) {
            return t.ttype.getChecker(suite, strict);
          });
          var testCtx = new util_1.NoopContext();
          var isParamRequired = this.params.map(function(param2, i) {
            return !param2.isOpt && !itemCheckers[i](void 0, testCtx);
          });
          var checker = function(value, ctx) {
            if (!Array.isArray(value)) {
              return ctx.fail(null, "is not an array", 0);
            }
            for (var i = 0; i < itemCheckers.length; i++) {
              var p3 = _this.params[i];
              if (value[i] === void 0) {
                if (isParamRequired[i]) {
                  return ctx.fail(p3.name, "is missing", 1);
                }
              } else {
                var ok = itemCheckers[i](value[i], ctx);
                if (!ok) {
                  return ctx.fail(p3.name, null, 1);
                }
              }
            }
            return true;
          };
          if (!strict) {
            return checker;
          }
          return function(value, ctx) {
            if (!checker(value, ctx)) {
              return false;
            }
            return value.length <= itemCheckers.length ? true : ctx.fail(itemCheckers.length, "is extraneous", 2);
          };
        };
        return TParamList2;
      })(TType)
    );
    exports2.TParamList = TParamList;
    var BasicType = (
      /** @class */
      (function(_super) {
        __extends(BasicType2, _super);
        function BasicType2(validator2, message) {
          var _this = _super.call(this) || this;
          _this.validator = validator2;
          _this.message = message;
          return _this;
        }
        BasicType2.prototype.getChecker = function(suite, strict) {
          var _this = this;
          return function(value, ctx) {
            return _this.validator(value) ? true : ctx.fail(null, _this.message, 0);
          };
        };
        return BasicType2;
      })(TType)
    );
    exports2.BasicType = BasicType;
    exports2.basicTypes = {
      any: new BasicType(function(v) {
        return true;
      }, "is invalid"),
      number: new BasicType(function(v) {
        return typeof v === "number";
      }, "is not a number"),
      object: new BasicType(function(v) {
        return typeof v === "object" && v;
      }, "is not an object"),
      boolean: new BasicType(function(v) {
        return typeof v === "boolean";
      }, "is not a boolean"),
      string: new BasicType(function(v) {
        return typeof v === "string";
      }, "is not a string"),
      symbol: new BasicType(function(v) {
        return typeof v === "symbol";
      }, "is not a symbol"),
      void: new BasicType(function(v) {
        return v == null;
      }, "is not void"),
      undefined: new BasicType(function(v) {
        return v === void 0;
      }, "is not undefined"),
      null: new BasicType(function(v) {
        return v === null;
      }, "is not null"),
      never: new BasicType(function(v) {
        return false;
      }, "is unexpected"),
      Date: new BasicType(getIsNativeChecker("[object Date]"), "is not a Date"),
      RegExp: new BasicType(getIsNativeChecker("[object RegExp]"), "is not a RegExp")
    };
    var nativeToString = Object.prototype.toString;
    function getIsNativeChecker(tag) {
      return function(v) {
        return typeof v === "object" && v && nativeToString.call(v) === tag;
      };
    }
    if (typeof Buffer !== "undefined") {
      exports2.basicTypes.Buffer = new BasicType(function(v) {
        return Buffer.isBuffer(v);
      }, "is not a Buffer");
    }
    var _loop_1 = function(array_12) {
      exports2.basicTypes[array_12.name] = new BasicType(function(v) {
        return v instanceof array_12;
      }, "is not a " + array_12.name);
    };
    for (_i = 0, _a31 = [
      Int8Array,
      Uint8Array,
      Uint8ClampedArray,
      Int16Array,
      Uint16Array,
      Int32Array,
      Uint32Array,
      Float32Array,
      Float64Array,
      ArrayBuffer
    ]; _i < _a31.length; _i++) {
      array_1 = _a31[_i];
      _loop_1(array_1);
    }
    var array_1;
    var _i;
    var _a31;
  }
});

// node_modules/ts-interface-checker/dist/index.js
var require_dist4 = __commonJS({
  "node_modules/ts-interface-checker/dist/index.js"(exports2) {
    "use strict";
    var __spreadArrays = exports2 && exports2.__spreadArrays || function() {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
          r[k] = a[j];
      return r;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Checker = exports2.createCheckers = void 0;
    var types_1 = require_types2();
    var util_1 = require_util2();
    var types_2 = require_types2();
    Object.defineProperty(exports2, "TArray", { enumerable: true, get: function() {
      return types_2.TArray;
    } });
    Object.defineProperty(exports2, "TEnumType", { enumerable: true, get: function() {
      return types_2.TEnumType;
    } });
    Object.defineProperty(exports2, "TEnumLiteral", { enumerable: true, get: function() {
      return types_2.TEnumLiteral;
    } });
    Object.defineProperty(exports2, "TFunc", { enumerable: true, get: function() {
      return types_2.TFunc;
    } });
    Object.defineProperty(exports2, "TIface", { enumerable: true, get: function() {
      return types_2.TIface;
    } });
    Object.defineProperty(exports2, "TLiteral", { enumerable: true, get: function() {
      return types_2.TLiteral;
    } });
    Object.defineProperty(exports2, "TName", { enumerable: true, get: function() {
      return types_2.TName;
    } });
    Object.defineProperty(exports2, "TOptional", { enumerable: true, get: function() {
      return types_2.TOptional;
    } });
    Object.defineProperty(exports2, "TParam", { enumerable: true, get: function() {
      return types_2.TParam;
    } });
    Object.defineProperty(exports2, "TParamList", { enumerable: true, get: function() {
      return types_2.TParamList;
    } });
    Object.defineProperty(exports2, "TProp", { enumerable: true, get: function() {
      return types_2.TProp;
    } });
    Object.defineProperty(exports2, "TTuple", { enumerable: true, get: function() {
      return types_2.TTuple;
    } });
    Object.defineProperty(exports2, "TType", { enumerable: true, get: function() {
      return types_2.TType;
    } });
    Object.defineProperty(exports2, "TUnion", { enumerable: true, get: function() {
      return types_2.TUnion;
    } });
    Object.defineProperty(exports2, "TIntersection", { enumerable: true, get: function() {
      return types_2.TIntersection;
    } });
    Object.defineProperty(exports2, "array", { enumerable: true, get: function() {
      return types_2.array;
    } });
    Object.defineProperty(exports2, "enumlit", { enumerable: true, get: function() {
      return types_2.enumlit;
    } });
    Object.defineProperty(exports2, "enumtype", { enumerable: true, get: function() {
      return types_2.enumtype;
    } });
    Object.defineProperty(exports2, "func", { enumerable: true, get: function() {
      return types_2.func;
    } });
    Object.defineProperty(exports2, "iface", { enumerable: true, get: function() {
      return types_2.iface;
    } });
    Object.defineProperty(exports2, "lit", { enumerable: true, get: function() {
      return types_2.lit;
    } });
    Object.defineProperty(exports2, "name", { enumerable: true, get: function() {
      return types_2.name;
    } });
    Object.defineProperty(exports2, "opt", { enumerable: true, get: function() {
      return types_2.opt;
    } });
    Object.defineProperty(exports2, "param", { enumerable: true, get: function() {
      return types_2.param;
    } });
    Object.defineProperty(exports2, "tuple", { enumerable: true, get: function() {
      return types_2.tuple;
    } });
    Object.defineProperty(exports2, "union", { enumerable: true, get: function() {
      return types_2.union;
    } });
    Object.defineProperty(exports2, "intersection", { enumerable: true, get: function() {
      return types_2.intersection;
    } });
    Object.defineProperty(exports2, "BasicType", { enumerable: true, get: function() {
      return types_2.BasicType;
    } });
    var util_2 = require_util2();
    Object.defineProperty(exports2, "VError", { enumerable: true, get: function() {
      return util_2.VError;
    } });
    function createCheckers() {
      var typeSuite = [];
      for (var _i = 0; _i < arguments.length; _i++) {
        typeSuite[_i] = arguments[_i];
      }
      var fullSuite = Object.assign.apply(Object, __spreadArrays([{}, types_1.basicTypes], typeSuite));
      var checkers = {};
      for (var _a31 = 0, typeSuite_1 = typeSuite; _a31 < typeSuite_1.length; _a31++) {
        var suite_1 = typeSuite_1[_a31];
        for (var _b27 = 0, _c = Object.keys(suite_1); _b27 < _c.length; _b27++) {
          var name28 = _c[_b27];
          checkers[name28] = new Checker(fullSuite, suite_1[name28]);
        }
      }
      return checkers;
    }
    exports2.createCheckers = createCheckers;
    var Checker = (
      /** @class */
      (function() {
        function Checker2(suite, ttype, _path) {
          if (_path === void 0) {
            _path = "value";
          }
          this.suite = suite;
          this.ttype = ttype;
          this._path = _path;
          this.props = /* @__PURE__ */ new Map();
          if (ttype instanceof types_1.TIface) {
            for (var _i = 0, _a31 = ttype.props; _i < _a31.length; _i++) {
              var p3 = _a31[_i];
              this.props.set(p3.name, p3.ttype);
            }
          }
          this.checkerPlain = this.ttype.getChecker(suite, false);
          this.checkerStrict = this.ttype.getChecker(suite, true);
        }
        Checker2.prototype.setReportedPath = function(path33) {
          this._path = path33;
        };
        Checker2.prototype.check = function(value) {
          return this._doCheck(this.checkerPlain, value);
        };
        Checker2.prototype.test = function(value) {
          return this.checkerPlain(value, new util_1.NoopContext());
        };
        Checker2.prototype.validate = function(value) {
          return this._doValidate(this.checkerPlain, value);
        };
        Checker2.prototype.strictCheck = function(value) {
          return this._doCheck(this.checkerStrict, value);
        };
        Checker2.prototype.strictTest = function(value) {
          return this.checkerStrict(value, new util_1.NoopContext());
        };
        Checker2.prototype.strictValidate = function(value) {
          return this._doValidate(this.checkerStrict, value);
        };
        Checker2.prototype.getProp = function(prop) {
          var ttype = this.props.get(prop);
          if (!ttype) {
            throw new Error("Type has no property " + prop);
          }
          return new Checker2(this.suite, ttype, this._path + "." + prop);
        };
        Checker2.prototype.methodArgs = function(methodName) {
          var tfunc = this._getMethod(methodName);
          return new Checker2(this.suite, tfunc.paramList);
        };
        Checker2.prototype.methodResult = function(methodName) {
          var tfunc = this._getMethod(methodName);
          return new Checker2(this.suite, tfunc.result);
        };
        Checker2.prototype.getArgs = function() {
          if (!(this.ttype instanceof types_1.TFunc)) {
            throw new Error("getArgs() applied to non-function");
          }
          return new Checker2(this.suite, this.ttype.paramList);
        };
        Checker2.prototype.getResult = function() {
          if (!(this.ttype instanceof types_1.TFunc)) {
            throw new Error("getResult() applied to non-function");
          }
          return new Checker2(this.suite, this.ttype.result);
        };
        Checker2.prototype.getType = function() {
          return this.ttype;
        };
        Checker2.prototype._doCheck = function(checkerFunc, value) {
          var noopCtx = new util_1.NoopContext();
          if (!checkerFunc(value, noopCtx)) {
            var detailCtx = new util_1.DetailContext();
            checkerFunc(value, detailCtx);
            throw detailCtx.getError(this._path);
          }
        };
        Checker2.prototype._doValidate = function(checkerFunc, value) {
          var noopCtx = new util_1.NoopContext();
          if (checkerFunc(value, noopCtx)) {
            return null;
          }
          var detailCtx = new util_1.DetailContext();
          checkerFunc(value, detailCtx);
          return detailCtx.getErrorDetail(this._path);
        };
        Checker2.prototype._getMethod = function(methodName) {
          var ttype = this.props.get(methodName);
          if (!ttype) {
            throw new Error("Type has no property " + methodName);
          }
          if (!(ttype instanceof types_1.TFunc)) {
            throw new Error("Property " + methodName + " is not a method");
          }
          return ttype;
        };
        return Checker2;
      })()
    );
    exports2.Checker = Checker;
  }
});

// node_modules/sucrase/dist/Options-gen-types.js
var require_Options_gen_types = __commonJS({
  "node_modules/sucrase/dist/Options-gen-types.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) {
              newObj[key] = obj[key];
            }
          }
        }
        newObj.default = obj;
        return newObj;
      }
    }
    var _tsinterfacechecker = require_dist4();
    var t = _interopRequireWildcard(_tsinterfacechecker);
    var Transform = t.union(
      t.lit("jsx"),
      t.lit("typescript"),
      t.lit("flow"),
      t.lit("imports"),
      t.lit("react-hot-loader"),
      t.lit("jest")
    );
    exports2.Transform = Transform;
    var SourceMapOptions = t.iface([], {
      compiledFilename: "string"
    });
    exports2.SourceMapOptions = SourceMapOptions;
    var Options = t.iface([], {
      transforms: t.array("Transform"),
      disableESTransforms: t.opt("boolean"),
      jsxRuntime: t.opt(t.union(t.lit("classic"), t.lit("automatic"), t.lit("preserve"))),
      production: t.opt("boolean"),
      jsxImportSource: t.opt("string"),
      jsxPragma: t.opt("string"),
      jsxFragmentPragma: t.opt("string"),
      keepUnusedImports: t.opt("boolean"),
      preserveDynamicImport: t.opt("boolean"),
      injectCreateRequireForImportRequire: t.opt("boolean"),
      enableLegacyTypeScriptModuleInterop: t.opt("boolean"),
      enableLegacyBabel5ModuleInterop: t.opt("boolean"),
      sourceMapOptions: t.opt("SourceMapOptions"),
      filePath: t.opt("string")
    });
    exports2.Options = Options;
    var exportedTypeSuite = {
      Transform: exports2.Transform,
      SourceMapOptions: exports2.SourceMapOptions,
      Options: exports2.Options
    };
    exports2.default = exportedTypeSuite;
  }
});

// node_modules/sucrase/dist/Options.js
var require_Options = __commonJS({
  "node_modules/sucrase/dist/Options.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _tsinterfacechecker = require_dist4();
    var _Optionsgentypes = require_Options_gen_types();
    var _Optionsgentypes2 = _interopRequireDefault(_Optionsgentypes);
    var { Options: OptionsChecker } = _tsinterfacechecker.createCheckers.call(void 0, _Optionsgentypes2.default);
    function validateOptions(options) {
      OptionsChecker.strictCheck(options);
    }
    exports2.validateOptions = validateOptions;
  }
});

// node_modules/sucrase/dist/parser/traverser/lval.js
var require_lval = __commonJS({
  "node_modules/sucrase/dist/parser/traverser/lval.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _flow = require_flow();
    var _typescript = require_typescript();
    var _index = require_tokenizer2();
    var _keywords = require_keywords();
    var _types = require_types();
    var _base = require_base();
    var _expression = require_expression();
    var _util = require_util();
    function parseSpread() {
      _index.next.call(void 0);
      _expression.parseMaybeAssign.call(void 0, false);
    }
    exports2.parseSpread = parseSpread;
    function parseRest(isBlockScope) {
      _index.next.call(void 0);
      parseBindingAtom(isBlockScope);
    }
    exports2.parseRest = parseRest;
    function parseBindingIdentifier(isBlockScope) {
      _expression.parseIdentifier.call(void 0);
      markPriorBindingIdentifier(isBlockScope);
    }
    exports2.parseBindingIdentifier = parseBindingIdentifier;
    function parseImportedIdentifier() {
      _expression.parseIdentifier.call(void 0);
      _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
    }
    exports2.parseImportedIdentifier = parseImportedIdentifier;
    function markPriorBindingIdentifier(isBlockScope) {
      let identifierRole;
      if (_base.state.scopeDepth === 0) {
        identifierRole = _index.IdentifierRole.TopLevelDeclaration;
      } else if (isBlockScope) {
        identifierRole = _index.IdentifierRole.BlockScopedDeclaration;
      } else {
        identifierRole = _index.IdentifierRole.FunctionScopedDeclaration;
      }
      _base.state.tokens[_base.state.tokens.length - 1].identifierRole = identifierRole;
    }
    exports2.markPriorBindingIdentifier = markPriorBindingIdentifier;
    function parseBindingAtom(isBlockScope) {
      switch (_base.state.type) {
        case _types.TokenType._this: {
          const oldIsType = _index.pushTypeContext.call(void 0, 0);
          _index.next.call(void 0);
          _index.popTypeContext.call(void 0, oldIsType);
          return;
        }
        case _types.TokenType._yield:
        case _types.TokenType.name: {
          _base.state.type = _types.TokenType.name;
          parseBindingIdentifier(isBlockScope);
          return;
        }
        case _types.TokenType.bracketL: {
          _index.next.call(void 0);
          parseBindingList(
            _types.TokenType.bracketR,
            isBlockScope,
            true
            /* allowEmpty */
          );
          return;
        }
        case _types.TokenType.braceL:
          _expression.parseObj.call(void 0, true, isBlockScope);
          return;
        default:
          _util.unexpected.call(void 0);
      }
    }
    exports2.parseBindingAtom = parseBindingAtom;
    function parseBindingList(close, isBlockScope, allowEmpty = false, allowModifiers = false, contextId = 0) {
      let first = true;
      let hasRemovedComma = false;
      const firstItemTokenIndex = _base.state.tokens.length;
      while (!_index.eat.call(void 0, close) && !_base.state.error) {
        if (first) {
          first = false;
        } else {
          _util.expect.call(void 0, _types.TokenType.comma);
          _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
          if (!hasRemovedComma && _base.state.tokens[firstItemTokenIndex].isType) {
            _base.state.tokens[_base.state.tokens.length - 1].isType = true;
            hasRemovedComma = true;
          }
        }
        if (allowEmpty && _index.match.call(void 0, _types.TokenType.comma)) {
        } else if (_index.eat.call(void 0, close)) {
          break;
        } else if (_index.match.call(void 0, _types.TokenType.ellipsis)) {
          parseRest(isBlockScope);
          parseAssignableListItemTypes();
          _index.eat.call(void 0, _types.TokenType.comma);
          _util.expect.call(void 0, close);
          break;
        } else {
          parseAssignableListItem(allowModifiers, isBlockScope);
        }
      }
    }
    exports2.parseBindingList = parseBindingList;
    function parseAssignableListItem(allowModifiers, isBlockScope) {
      if (allowModifiers) {
        _typescript.tsParseModifiers.call(void 0, [
          _keywords.ContextualKeyword._public,
          _keywords.ContextualKeyword._protected,
          _keywords.ContextualKeyword._private,
          _keywords.ContextualKeyword._readonly,
          _keywords.ContextualKeyword._override
        ]);
      }
      parseMaybeDefault(isBlockScope);
      parseAssignableListItemTypes();
      parseMaybeDefault(
        isBlockScope,
        true
        /* leftAlreadyParsed */
      );
    }
    function parseAssignableListItemTypes() {
      if (_base.isFlowEnabled) {
        _flow.flowParseAssignableListItemTypes.call(void 0);
      } else if (_base.isTypeScriptEnabled) {
        _typescript.tsParseAssignableListItemTypes.call(void 0);
      }
    }
    function parseMaybeDefault(isBlockScope, leftAlreadyParsed = false) {
      if (!leftAlreadyParsed) {
        parseBindingAtom(isBlockScope);
      }
      if (!_index.eat.call(void 0, _types.TokenType.eq)) {
        return;
      }
      const eqIndex = _base.state.tokens.length - 1;
      _expression.parseMaybeAssign.call(void 0);
      _base.state.tokens[eqIndex].rhsEndIndex = _base.state.tokens.length;
    }
    exports2.parseMaybeDefault = parseMaybeDefault;
  }
});

// node_modules/sucrase/dist/parser/plugins/typescript.js
var require_typescript = __commonJS({
  "node_modules/sucrase/dist/parser/plugins/typescript.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _index = require_tokenizer2();
    var _keywords = require_keywords();
    var _types = require_types();
    var _base = require_base();
    var _expression = require_expression();
    var _lval = require_lval();
    var _statement = require_statement();
    var _util = require_util();
    var _jsx = require_jsx();
    function tsIsIdentifier() {
      return _index.match.call(void 0, _types.TokenType.name);
    }
    function isLiteralPropertyName() {
      return _index.match.call(void 0, _types.TokenType.name) || Boolean(_base.state.type & _types.TokenType.IS_KEYWORD) || _index.match.call(void 0, _types.TokenType.string) || _index.match.call(void 0, _types.TokenType.num) || _index.match.call(void 0, _types.TokenType.bigint) || _index.match.call(void 0, _types.TokenType.decimal);
    }
    function tsNextTokenCanFollowModifier() {
      const snapshot = _base.state.snapshot();
      _index.next.call(void 0);
      const canFollowModifier = (_index.match.call(void 0, _types.TokenType.bracketL) || _index.match.call(void 0, _types.TokenType.braceL) || _index.match.call(void 0, _types.TokenType.star) || _index.match.call(void 0, _types.TokenType.ellipsis) || _index.match.call(void 0, _types.TokenType.hash) || isLiteralPropertyName()) && !_util.hasPrecedingLineBreak.call(void 0);
      if (canFollowModifier) {
        return true;
      } else {
        _base.state.restoreFromSnapshot(snapshot);
        return false;
      }
    }
    function tsParseModifiers(allowedModifiers) {
      while (true) {
        const modifier = tsParseModifier(allowedModifiers);
        if (modifier === null) {
          break;
        }
      }
    }
    exports2.tsParseModifiers = tsParseModifiers;
    function tsParseModifier(allowedModifiers) {
      if (!_index.match.call(void 0, _types.TokenType.name)) {
        return null;
      }
      const modifier = _base.state.contextualKeyword;
      if (allowedModifiers.indexOf(modifier) !== -1 && tsNextTokenCanFollowModifier()) {
        switch (modifier) {
          case _keywords.ContextualKeyword._readonly:
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._readonly;
            break;
          case _keywords.ContextualKeyword._abstract:
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._abstract;
            break;
          case _keywords.ContextualKeyword._static:
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._static;
            break;
          case _keywords.ContextualKeyword._public:
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._public;
            break;
          case _keywords.ContextualKeyword._private:
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._private;
            break;
          case _keywords.ContextualKeyword._protected:
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._protected;
            break;
          case _keywords.ContextualKeyword._override:
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._override;
            break;
          case _keywords.ContextualKeyword._declare:
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._declare;
            break;
          default:
            break;
        }
        return modifier;
      }
      return null;
    }
    exports2.tsParseModifier = tsParseModifier;
    function tsParseEntityName() {
      _expression.parseIdentifier.call(void 0);
      while (_index.eat.call(void 0, _types.TokenType.dot)) {
        _expression.parseIdentifier.call(void 0);
      }
    }
    function tsParseTypeReference() {
      tsParseEntityName();
      if (!_util.hasPrecedingLineBreak.call(void 0) && _index.match.call(void 0, _types.TokenType.lessThan)) {
        tsParseTypeArguments();
      }
    }
    function tsParseThisTypePredicate() {
      _index.next.call(void 0);
      tsParseTypeAnnotation();
    }
    function tsParseThisTypeNode() {
      _index.next.call(void 0);
    }
    function tsParseTypeQuery() {
      _util.expect.call(void 0, _types.TokenType._typeof);
      if (_index.match.call(void 0, _types.TokenType._import)) {
        tsParseImportType();
      } else {
        tsParseEntityName();
      }
      if (!_util.hasPrecedingLineBreak.call(void 0) && _index.match.call(void 0, _types.TokenType.lessThan)) {
        tsParseTypeArguments();
      }
    }
    function tsParseImportType() {
      _util.expect.call(void 0, _types.TokenType._import);
      _util.expect.call(void 0, _types.TokenType.parenL);
      _util.expect.call(void 0, _types.TokenType.string);
      _util.expect.call(void 0, _types.TokenType.parenR);
      if (_index.eat.call(void 0, _types.TokenType.dot)) {
        tsParseEntityName();
      }
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        tsParseTypeArguments();
      }
    }
    function tsParseTypeParameter() {
      _index.eat.call(void 0, _types.TokenType._const);
      const hadIn = _index.eat.call(void 0, _types.TokenType._in);
      const hadOut = _util.eatContextual.call(void 0, _keywords.ContextualKeyword._out);
      _index.eat.call(void 0, _types.TokenType._const);
      if ((hadIn || hadOut) && !_index.match.call(void 0, _types.TokenType.name)) {
        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.name;
      } else {
        _expression.parseIdentifier.call(void 0);
      }
      if (_index.eat.call(void 0, _types.TokenType._extends)) {
        tsParseType();
      }
      if (_index.eat.call(void 0, _types.TokenType.eq)) {
        tsParseType();
      }
    }
    function tsTryParseTypeParameters() {
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        tsParseTypeParameters();
      }
    }
    exports2.tsTryParseTypeParameters = tsTryParseTypeParameters;
    function tsParseTypeParameters() {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.typeParameterStart)) {
        _index.next.call(void 0);
      } else {
        _util.unexpected.call(void 0);
      }
      while (!_index.eat.call(void 0, _types.TokenType.greaterThan) && !_base.state.error) {
        tsParseTypeParameter();
        _index.eat.call(void 0, _types.TokenType.comma);
      }
      _index.popTypeContext.call(void 0, oldIsType);
    }
    function tsFillSignature(returnToken) {
      const returnTokenRequired = returnToken === _types.TokenType.arrow;
      tsTryParseTypeParameters();
      _util.expect.call(void 0, _types.TokenType.parenL);
      _base.state.scopeDepth++;
      tsParseBindingListForSignature(
        false
        /* isBlockScope */
      );
      _base.state.scopeDepth--;
      if (returnTokenRequired) {
        tsParseTypeOrTypePredicateAnnotation(returnToken);
      } else if (_index.match.call(void 0, returnToken)) {
        tsParseTypeOrTypePredicateAnnotation(returnToken);
      }
    }
    function tsParseBindingListForSignature(isBlockScope) {
      _lval.parseBindingList.call(void 0, _types.TokenType.parenR, isBlockScope);
    }
    function tsParseTypeMemberSemicolon() {
      if (!_index.eat.call(void 0, _types.TokenType.comma)) {
        _util.semicolon.call(void 0);
      }
    }
    function tsParseSignatureMember() {
      tsFillSignature(_types.TokenType.colon);
      tsParseTypeMemberSemicolon();
    }
    function tsIsUnambiguouslyIndexSignature() {
      const snapshot = _base.state.snapshot();
      _index.next.call(void 0);
      const isIndexSignature = _index.eat.call(void 0, _types.TokenType.name) && _index.match.call(void 0, _types.TokenType.colon);
      _base.state.restoreFromSnapshot(snapshot);
      return isIndexSignature;
    }
    function tsTryParseIndexSignature() {
      if (!(_index.match.call(void 0, _types.TokenType.bracketL) && tsIsUnambiguouslyIndexSignature())) {
        return false;
      }
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      _util.expect.call(void 0, _types.TokenType.bracketL);
      _expression.parseIdentifier.call(void 0);
      tsParseTypeAnnotation();
      _util.expect.call(void 0, _types.TokenType.bracketR);
      tsTryParseTypeAnnotation();
      tsParseTypeMemberSemicolon();
      _index.popTypeContext.call(void 0, oldIsType);
      return true;
    }
    function tsParsePropertyOrMethodSignature(isReadonly) {
      _index.eat.call(void 0, _types.TokenType.question);
      if (!isReadonly && (_index.match.call(void 0, _types.TokenType.parenL) || _index.match.call(void 0, _types.TokenType.lessThan))) {
        tsFillSignature(_types.TokenType.colon);
        tsParseTypeMemberSemicolon();
      } else {
        tsTryParseTypeAnnotation();
        tsParseTypeMemberSemicolon();
      }
    }
    function tsParseTypeMember() {
      if (_index.match.call(void 0, _types.TokenType.parenL) || _index.match.call(void 0, _types.TokenType.lessThan)) {
        tsParseSignatureMember();
        return;
      }
      if (_index.match.call(void 0, _types.TokenType._new)) {
        _index.next.call(void 0);
        if (_index.match.call(void 0, _types.TokenType.parenL) || _index.match.call(void 0, _types.TokenType.lessThan)) {
          tsParseSignatureMember();
        } else {
          tsParsePropertyOrMethodSignature(false);
        }
        return;
      }
      const readonly3 = !!tsParseModifier([_keywords.ContextualKeyword._readonly]);
      const found = tsTryParseIndexSignature();
      if (found) {
        return;
      }
      if ((_util.isContextual.call(void 0, _keywords.ContextualKeyword._get) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._set)) && tsNextTokenCanFollowModifier()) {
      }
      _expression.parsePropertyName.call(
        void 0,
        -1
        /* Types don't need context IDs. */
      );
      tsParsePropertyOrMethodSignature(readonly3);
    }
    function tsParseTypeLiteral() {
      tsParseObjectTypeMembers();
    }
    function tsParseObjectTypeMembers() {
      _util.expect.call(void 0, _types.TokenType.braceL);
      while (!_index.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
        tsParseTypeMember();
      }
    }
    function tsLookaheadIsStartOfMappedType() {
      const snapshot = _base.state.snapshot();
      const isStartOfMappedType = tsIsStartOfMappedType();
      _base.state.restoreFromSnapshot(snapshot);
      return isStartOfMappedType;
    }
    function tsIsStartOfMappedType() {
      _index.next.call(void 0);
      if (_index.eat.call(void 0, _types.TokenType.plus) || _index.eat.call(void 0, _types.TokenType.minus)) {
        return _util.isContextual.call(void 0, _keywords.ContextualKeyword._readonly);
      }
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._readonly)) {
        _index.next.call(void 0);
      }
      if (!_index.match.call(void 0, _types.TokenType.bracketL)) {
        return false;
      }
      _index.next.call(void 0);
      if (!tsIsIdentifier()) {
        return false;
      }
      _index.next.call(void 0);
      return _index.match.call(void 0, _types.TokenType._in);
    }
    function tsParseMappedTypeParameter() {
      _expression.parseIdentifier.call(void 0);
      _util.expect.call(void 0, _types.TokenType._in);
      tsParseType();
    }
    function tsParseMappedType() {
      _util.expect.call(void 0, _types.TokenType.braceL);
      if (_index.match.call(void 0, _types.TokenType.plus) || _index.match.call(void 0, _types.TokenType.minus)) {
        _index.next.call(void 0);
        _util.expectContextual.call(void 0, _keywords.ContextualKeyword._readonly);
      } else {
        _util.eatContextual.call(void 0, _keywords.ContextualKeyword._readonly);
      }
      _util.expect.call(void 0, _types.TokenType.bracketL);
      tsParseMappedTypeParameter();
      if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as)) {
        tsParseType();
      }
      _util.expect.call(void 0, _types.TokenType.bracketR);
      if (_index.match.call(void 0, _types.TokenType.plus) || _index.match.call(void 0, _types.TokenType.minus)) {
        _index.next.call(void 0);
        _util.expect.call(void 0, _types.TokenType.question);
      } else {
        _index.eat.call(void 0, _types.TokenType.question);
      }
      tsTryParseType();
      _util.semicolon.call(void 0);
      _util.expect.call(void 0, _types.TokenType.braceR);
    }
    function tsParseTupleType() {
      _util.expect.call(void 0, _types.TokenType.bracketL);
      while (!_index.eat.call(void 0, _types.TokenType.bracketR) && !_base.state.error) {
        tsParseTupleElementType();
        _index.eat.call(void 0, _types.TokenType.comma);
      }
    }
    function tsParseTupleElementType() {
      if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
        tsParseType();
      } else {
        tsParseType();
        _index.eat.call(void 0, _types.TokenType.question);
      }
      if (_index.eat.call(void 0, _types.TokenType.colon)) {
        tsParseType();
      }
    }
    function tsParseParenthesizedType() {
      _util.expect.call(void 0, _types.TokenType.parenL);
      tsParseType();
      _util.expect.call(void 0, _types.TokenType.parenR);
    }
    function tsParseTemplateLiteralType() {
      _index.nextTemplateToken.call(void 0);
      _index.nextTemplateToken.call(void 0);
      while (!_index.match.call(void 0, _types.TokenType.backQuote) && !_base.state.error) {
        _util.expect.call(void 0, _types.TokenType.dollarBraceL);
        tsParseType();
        _index.nextTemplateToken.call(void 0);
        _index.nextTemplateToken.call(void 0);
      }
      _index.next.call(void 0);
    }
    var FunctionType;
    (function(FunctionType2) {
      const TSFunctionType = 0;
      FunctionType2[FunctionType2["TSFunctionType"] = TSFunctionType] = "TSFunctionType";
      const TSConstructorType = TSFunctionType + 1;
      FunctionType2[FunctionType2["TSConstructorType"] = TSConstructorType] = "TSConstructorType";
      const TSAbstractConstructorType = TSConstructorType + 1;
      FunctionType2[FunctionType2["TSAbstractConstructorType"] = TSAbstractConstructorType] = "TSAbstractConstructorType";
    })(FunctionType || (FunctionType = {}));
    function tsParseFunctionOrConstructorType(type) {
      if (type === FunctionType.TSAbstractConstructorType) {
        _util.expectContextual.call(void 0, _keywords.ContextualKeyword._abstract);
      }
      if (type === FunctionType.TSConstructorType || type === FunctionType.TSAbstractConstructorType) {
        _util.expect.call(void 0, _types.TokenType._new);
      }
      const oldInDisallowConditionalTypesContext = _base.state.inDisallowConditionalTypesContext;
      _base.state.inDisallowConditionalTypesContext = false;
      tsFillSignature(_types.TokenType.arrow);
      _base.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
    }
    function tsParseNonArrayType() {
      switch (_base.state.type) {
        case _types.TokenType.name:
          tsParseTypeReference();
          return;
        case _types.TokenType._void:
        case _types.TokenType._null:
          _index.next.call(void 0);
          return;
        case _types.TokenType.string:
        case _types.TokenType.num:
        case _types.TokenType.bigint:
        case _types.TokenType.decimal:
        case _types.TokenType._true:
        case _types.TokenType._false:
          _expression.parseLiteral.call(void 0);
          return;
        case _types.TokenType.minus:
          _index.next.call(void 0);
          _expression.parseLiteral.call(void 0);
          return;
        case _types.TokenType._this: {
          tsParseThisTypeNode();
          if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._is) && !_util.hasPrecedingLineBreak.call(void 0)) {
            tsParseThisTypePredicate();
          }
          return;
        }
        case _types.TokenType._typeof:
          tsParseTypeQuery();
          return;
        case _types.TokenType._import:
          tsParseImportType();
          return;
        case _types.TokenType.braceL:
          if (tsLookaheadIsStartOfMappedType()) {
            tsParseMappedType();
          } else {
            tsParseTypeLiteral();
          }
          return;
        case _types.TokenType.bracketL:
          tsParseTupleType();
          return;
        case _types.TokenType.parenL:
          tsParseParenthesizedType();
          return;
        case _types.TokenType.backQuote:
          tsParseTemplateLiteralType();
          return;
        default:
          if (_base.state.type & _types.TokenType.IS_KEYWORD) {
            _index.next.call(void 0);
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.name;
            return;
          }
          break;
      }
      _util.unexpected.call(void 0);
    }
    function tsParseArrayTypeOrHigher() {
      tsParseNonArrayType();
      while (!_util.hasPrecedingLineBreak.call(void 0) && _index.eat.call(void 0, _types.TokenType.bracketL)) {
        if (!_index.eat.call(void 0, _types.TokenType.bracketR)) {
          tsParseType();
          _util.expect.call(void 0, _types.TokenType.bracketR);
        }
      }
    }
    function tsParseInferType() {
      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._infer);
      _expression.parseIdentifier.call(void 0);
      if (_index.match.call(void 0, _types.TokenType._extends)) {
        const snapshot = _base.state.snapshot();
        _util.expect.call(void 0, _types.TokenType._extends);
        const oldInDisallowConditionalTypesContext = _base.state.inDisallowConditionalTypesContext;
        _base.state.inDisallowConditionalTypesContext = true;
        tsParseType();
        _base.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
        if (_base.state.error || !_base.state.inDisallowConditionalTypesContext && _index.match.call(void 0, _types.TokenType.question)) {
          _base.state.restoreFromSnapshot(snapshot);
        }
      }
    }
    function tsParseTypeOperatorOrHigher() {
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._keyof) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._unique) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._readonly)) {
        _index.next.call(void 0);
        tsParseTypeOperatorOrHigher();
      } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._infer)) {
        tsParseInferType();
      } else {
        const oldInDisallowConditionalTypesContext = _base.state.inDisallowConditionalTypesContext;
        _base.state.inDisallowConditionalTypesContext = false;
        tsParseArrayTypeOrHigher();
        _base.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
      }
    }
    function tsParseIntersectionTypeOrHigher() {
      _index.eat.call(void 0, _types.TokenType.bitwiseAND);
      tsParseTypeOperatorOrHigher();
      if (_index.match.call(void 0, _types.TokenType.bitwiseAND)) {
        while (_index.eat.call(void 0, _types.TokenType.bitwiseAND)) {
          tsParseTypeOperatorOrHigher();
        }
      }
    }
    function tsParseUnionTypeOrHigher() {
      _index.eat.call(void 0, _types.TokenType.bitwiseOR);
      tsParseIntersectionTypeOrHigher();
      if (_index.match.call(void 0, _types.TokenType.bitwiseOR)) {
        while (_index.eat.call(void 0, _types.TokenType.bitwiseOR)) {
          tsParseIntersectionTypeOrHigher();
        }
      }
    }
    function tsIsStartOfFunctionType() {
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        return true;
      }
      return _index.match.call(void 0, _types.TokenType.parenL) && tsLookaheadIsUnambiguouslyStartOfFunctionType();
    }
    function tsSkipParameterStart() {
      if (_index.match.call(void 0, _types.TokenType.name) || _index.match.call(void 0, _types.TokenType._this)) {
        _index.next.call(void 0);
        return true;
      }
      if (_index.match.call(void 0, _types.TokenType.braceL) || _index.match.call(void 0, _types.TokenType.bracketL)) {
        let depth = 1;
        _index.next.call(void 0);
        while (depth > 0 && !_base.state.error) {
          if (_index.match.call(void 0, _types.TokenType.braceL) || _index.match.call(void 0, _types.TokenType.bracketL)) {
            depth++;
          } else if (_index.match.call(void 0, _types.TokenType.braceR) || _index.match.call(void 0, _types.TokenType.bracketR)) {
            depth--;
          }
          _index.next.call(void 0);
        }
        return true;
      }
      return false;
    }
    function tsLookaheadIsUnambiguouslyStartOfFunctionType() {
      const snapshot = _base.state.snapshot();
      const isUnambiguouslyStartOfFunctionType = tsIsUnambiguouslyStartOfFunctionType();
      _base.state.restoreFromSnapshot(snapshot);
      return isUnambiguouslyStartOfFunctionType;
    }
    function tsIsUnambiguouslyStartOfFunctionType() {
      _index.next.call(void 0);
      if (_index.match.call(void 0, _types.TokenType.parenR) || _index.match.call(void 0, _types.TokenType.ellipsis)) {
        return true;
      }
      if (tsSkipParameterStart()) {
        if (_index.match.call(void 0, _types.TokenType.colon) || _index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.question) || _index.match.call(void 0, _types.TokenType.eq)) {
          return true;
        }
        if (_index.match.call(void 0, _types.TokenType.parenR)) {
          _index.next.call(void 0);
          if (_index.match.call(void 0, _types.TokenType.arrow)) {
            return true;
          }
        }
      }
      return false;
    }
    function tsParseTypeOrTypePredicateAnnotation(returnToken) {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      _util.expect.call(void 0, returnToken);
      const finishedReturn = tsParseTypePredicateOrAssertsPrefix();
      if (!finishedReturn) {
        tsParseType();
      }
      _index.popTypeContext.call(void 0, oldIsType);
    }
    function tsTryParseTypeOrTypePredicateAnnotation() {
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        tsParseTypeOrTypePredicateAnnotation(_types.TokenType.colon);
      }
    }
    function tsTryParseTypeAnnotation() {
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        tsParseTypeAnnotation();
      }
    }
    exports2.tsTryParseTypeAnnotation = tsTryParseTypeAnnotation;
    function tsTryParseType() {
      if (_index.eat.call(void 0, _types.TokenType.colon)) {
        tsParseType();
      }
    }
    function tsParseTypePredicateOrAssertsPrefix() {
      const snapshot = _base.state.snapshot();
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._asserts)) {
        _index.next.call(void 0);
        if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._is)) {
          tsParseType();
          return true;
        } else if (tsIsIdentifier() || _index.match.call(void 0, _types.TokenType._this)) {
          _index.next.call(void 0);
          if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._is)) {
            tsParseType();
          }
          return true;
        } else {
          _base.state.restoreFromSnapshot(snapshot);
          return false;
        }
      } else if (tsIsIdentifier() || _index.match.call(void 0, _types.TokenType._this)) {
        _index.next.call(void 0);
        if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._is) && !_util.hasPrecedingLineBreak.call(void 0)) {
          _index.next.call(void 0);
          tsParseType();
          return true;
        } else {
          _base.state.restoreFromSnapshot(snapshot);
          return false;
        }
      }
      return false;
    }
    function tsParseTypeAnnotation() {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      _util.expect.call(void 0, _types.TokenType.colon);
      tsParseType();
      _index.popTypeContext.call(void 0, oldIsType);
    }
    exports2.tsParseTypeAnnotation = tsParseTypeAnnotation;
    function tsParseType() {
      tsParseNonConditionalType();
      if (_base.state.inDisallowConditionalTypesContext || _util.hasPrecedingLineBreak.call(void 0) || !_index.eat.call(void 0, _types.TokenType._extends)) {
        return;
      }
      const oldInDisallowConditionalTypesContext = _base.state.inDisallowConditionalTypesContext;
      _base.state.inDisallowConditionalTypesContext = true;
      tsParseNonConditionalType();
      _base.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
      _util.expect.call(void 0, _types.TokenType.question);
      tsParseType();
      _util.expect.call(void 0, _types.TokenType.colon);
      tsParseType();
    }
    exports2.tsParseType = tsParseType;
    function isAbstractConstructorSignature() {
      return _util.isContextual.call(void 0, _keywords.ContextualKeyword._abstract) && _index.lookaheadType.call(void 0) === _types.TokenType._new;
    }
    function tsParseNonConditionalType() {
      if (tsIsStartOfFunctionType()) {
        tsParseFunctionOrConstructorType(FunctionType.TSFunctionType);
        return;
      }
      if (_index.match.call(void 0, _types.TokenType._new)) {
        tsParseFunctionOrConstructorType(FunctionType.TSConstructorType);
        return;
      } else if (isAbstractConstructorSignature()) {
        tsParseFunctionOrConstructorType(FunctionType.TSAbstractConstructorType);
        return;
      }
      tsParseUnionTypeOrHigher();
    }
    exports2.tsParseNonConditionalType = tsParseNonConditionalType;
    function tsParseTypeAssertion() {
      const oldIsType = _index.pushTypeContext.call(void 0, 1);
      tsParseType();
      _util.expect.call(void 0, _types.TokenType.greaterThan);
      _index.popTypeContext.call(void 0, oldIsType);
      _expression.parseMaybeUnary.call(void 0);
    }
    exports2.tsParseTypeAssertion = tsParseTypeAssertion;
    function tsTryParseJSXTypeArgument() {
      if (_index.eat.call(void 0, _types.TokenType.jsxTagStart)) {
        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.typeParameterStart;
        const oldIsType = _index.pushTypeContext.call(void 0, 1);
        while (!_index.match.call(void 0, _types.TokenType.greaterThan) && !_base.state.error) {
          tsParseType();
          _index.eat.call(void 0, _types.TokenType.comma);
        }
        _jsx.nextJSXTagToken.call(void 0);
        _index.popTypeContext.call(void 0, oldIsType);
      }
    }
    exports2.tsTryParseJSXTypeArgument = tsTryParseJSXTypeArgument;
    function tsParseHeritageClause() {
      while (!_index.match.call(void 0, _types.TokenType.braceL) && !_base.state.error) {
        tsParseExpressionWithTypeArguments();
        _index.eat.call(void 0, _types.TokenType.comma);
      }
    }
    function tsParseExpressionWithTypeArguments() {
      tsParseEntityName();
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        tsParseTypeArguments();
      }
    }
    function tsParseInterfaceDeclaration() {
      _lval.parseBindingIdentifier.call(void 0, false);
      tsTryParseTypeParameters();
      if (_index.eat.call(void 0, _types.TokenType._extends)) {
        tsParseHeritageClause();
      }
      tsParseObjectTypeMembers();
    }
    function tsParseTypeAliasDeclaration() {
      _lval.parseBindingIdentifier.call(void 0, false);
      tsTryParseTypeParameters();
      _util.expect.call(void 0, _types.TokenType.eq);
      tsParseType();
      _util.semicolon.call(void 0);
    }
    function tsParseEnumMember() {
      if (_index.match.call(void 0, _types.TokenType.string)) {
        _expression.parseLiteral.call(void 0);
      } else {
        _expression.parseIdentifier.call(void 0);
      }
      if (_index.eat.call(void 0, _types.TokenType.eq)) {
        const eqIndex = _base.state.tokens.length - 1;
        _expression.parseMaybeAssign.call(void 0);
        _base.state.tokens[eqIndex].rhsEndIndex = _base.state.tokens.length;
      }
    }
    function tsParseEnumDeclaration() {
      _lval.parseBindingIdentifier.call(void 0, false);
      _util.expect.call(void 0, _types.TokenType.braceL);
      while (!_index.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
        tsParseEnumMember();
        _index.eat.call(void 0, _types.TokenType.comma);
      }
    }
    function tsParseModuleBlock() {
      _util.expect.call(void 0, _types.TokenType.braceL);
      _statement.parseBlockBody.call(
        void 0,
        /* end */
        _types.TokenType.braceR
      );
    }
    function tsParseModuleOrNamespaceDeclaration() {
      _lval.parseBindingIdentifier.call(void 0, false);
      if (_index.eat.call(void 0, _types.TokenType.dot)) {
        tsParseModuleOrNamespaceDeclaration();
      } else {
        tsParseModuleBlock();
      }
    }
    function tsParseAmbientExternalModuleDeclaration() {
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._global)) {
        _expression.parseIdentifier.call(void 0);
      } else if (_index.match.call(void 0, _types.TokenType.string)) {
        _expression.parseExprAtom.call(void 0);
      } else {
        _util.unexpected.call(void 0);
      }
      if (_index.match.call(void 0, _types.TokenType.braceL)) {
        tsParseModuleBlock();
      } else {
        _util.semicolon.call(void 0);
      }
    }
    function tsParseImportEqualsDeclaration() {
      _lval.parseImportedIdentifier.call(void 0);
      _util.expect.call(void 0, _types.TokenType.eq);
      tsParseModuleReference();
      _util.semicolon.call(void 0);
    }
    exports2.tsParseImportEqualsDeclaration = tsParseImportEqualsDeclaration;
    function tsIsExternalModuleReference() {
      return _util.isContextual.call(void 0, _keywords.ContextualKeyword._require) && _index.lookaheadType.call(void 0) === _types.TokenType.parenL;
    }
    function tsParseModuleReference() {
      if (tsIsExternalModuleReference()) {
        tsParseExternalModuleReference();
      } else {
        tsParseEntityName();
      }
    }
    function tsParseExternalModuleReference() {
      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._require);
      _util.expect.call(void 0, _types.TokenType.parenL);
      if (!_index.match.call(void 0, _types.TokenType.string)) {
        _util.unexpected.call(void 0);
      }
      _expression.parseLiteral.call(void 0);
      _util.expect.call(void 0, _types.TokenType.parenR);
    }
    function tsTryParseDeclare() {
      if (_util.isLineTerminator.call(void 0)) {
        return false;
      }
      switch (_base.state.type) {
        case _types.TokenType._function: {
          const oldIsType = _index.pushTypeContext.call(void 0, 1);
          _index.next.call(void 0);
          const functionStart = _base.state.start;
          _statement.parseFunction.call(
            void 0,
            functionStart,
            /* isStatement */
            true
          );
          _index.popTypeContext.call(void 0, oldIsType);
          return true;
        }
        case _types.TokenType._class: {
          const oldIsType = _index.pushTypeContext.call(void 0, 1);
          _statement.parseClass.call(
            void 0,
            /* isStatement */
            true,
            /* optionalId */
            false
          );
          _index.popTypeContext.call(void 0, oldIsType);
          return true;
        }
        case _types.TokenType._const: {
          if (_index.match.call(void 0, _types.TokenType._const) && _util.isLookaheadContextual.call(void 0, _keywords.ContextualKeyword._enum)) {
            const oldIsType = _index.pushTypeContext.call(void 0, 1);
            _util.expect.call(void 0, _types.TokenType._const);
            _util.expectContextual.call(void 0, _keywords.ContextualKeyword._enum);
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._enum;
            tsParseEnumDeclaration();
            _index.popTypeContext.call(void 0, oldIsType);
            return true;
          }
        }
        // falls through
        case _types.TokenType._var:
        case _types.TokenType._let: {
          const oldIsType = _index.pushTypeContext.call(void 0, 1);
          _statement.parseVarStatement.call(void 0, _base.state.type !== _types.TokenType._var);
          _index.popTypeContext.call(void 0, oldIsType);
          return true;
        }
        case _types.TokenType.name: {
          const oldIsType = _index.pushTypeContext.call(void 0, 1);
          const contextualKeyword = _base.state.contextualKeyword;
          let matched = false;
          if (contextualKeyword === _keywords.ContextualKeyword._global) {
            tsParseAmbientExternalModuleDeclaration();
            matched = true;
          } else {
            matched = tsParseDeclaration(
              contextualKeyword,
              /* isBeforeToken */
              true
            );
          }
          _index.popTypeContext.call(void 0, oldIsType);
          return matched;
        }
        default:
          return false;
      }
    }
    function tsTryParseExportDeclaration() {
      return tsParseDeclaration(
        _base.state.contextualKeyword,
        /* isBeforeToken */
        true
      );
    }
    function tsParseExpressionStatement(contextualKeyword) {
      switch (contextualKeyword) {
        case _keywords.ContextualKeyword._declare: {
          const declareTokenIndex = _base.state.tokens.length - 1;
          const matched = tsTryParseDeclare();
          if (matched) {
            _base.state.tokens[declareTokenIndex].type = _types.TokenType._declare;
            return true;
          }
          break;
        }
        case _keywords.ContextualKeyword._global:
          if (_index.match.call(void 0, _types.TokenType.braceL)) {
            tsParseModuleBlock();
            return true;
          }
          break;
        default:
          return tsParseDeclaration(
            contextualKeyword,
            /* isBeforeToken */
            false
          );
      }
      return false;
    }
    function tsParseDeclaration(contextualKeyword, isBeforeToken) {
      switch (contextualKeyword) {
        case _keywords.ContextualKeyword._abstract:
          if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType._class)) {
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._abstract;
            _statement.parseClass.call(
              void 0,
              /* isStatement */
              true,
              /* optionalId */
              false
            );
            return true;
          }
          break;
        case _keywords.ContextualKeyword._enum:
          if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType.name)) {
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._enum;
            tsParseEnumDeclaration();
            return true;
          }
          break;
        case _keywords.ContextualKeyword._interface:
          if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType.name)) {
            const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
            tsParseInterfaceDeclaration();
            _index.popTypeContext.call(void 0, oldIsType);
            return true;
          }
          break;
        case _keywords.ContextualKeyword._module:
          if (tsCheckLineTerminator(isBeforeToken)) {
            if (_index.match.call(void 0, _types.TokenType.string)) {
              const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
              tsParseAmbientExternalModuleDeclaration();
              _index.popTypeContext.call(void 0, oldIsType);
              return true;
            } else if (_index.match.call(void 0, _types.TokenType.name)) {
              const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
              tsParseModuleOrNamespaceDeclaration();
              _index.popTypeContext.call(void 0, oldIsType);
              return true;
            }
          }
          break;
        case _keywords.ContextualKeyword._namespace:
          if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType.name)) {
            const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
            tsParseModuleOrNamespaceDeclaration();
            _index.popTypeContext.call(void 0, oldIsType);
            return true;
          }
          break;
        case _keywords.ContextualKeyword._type:
          if (tsCheckLineTerminator(isBeforeToken) && _index.match.call(void 0, _types.TokenType.name)) {
            const oldIsType = _index.pushTypeContext.call(void 0, isBeforeToken ? 2 : 1);
            tsParseTypeAliasDeclaration();
            _index.popTypeContext.call(void 0, oldIsType);
            return true;
          }
          break;
        default:
          break;
      }
      return false;
    }
    function tsCheckLineTerminator(isBeforeToken) {
      if (isBeforeToken) {
        _index.next.call(void 0);
        return true;
      } else {
        return !_util.isLineTerminator.call(void 0);
      }
    }
    function tsTryParseGenericAsyncArrowFunction() {
      const snapshot = _base.state.snapshot();
      tsParseTypeParameters();
      _statement.parseFunctionParams.call(void 0);
      tsTryParseTypeOrTypePredicateAnnotation();
      _util.expect.call(void 0, _types.TokenType.arrow);
      if (_base.state.error) {
        _base.state.restoreFromSnapshot(snapshot);
        return false;
      }
      _expression.parseFunctionBody.call(void 0, true);
      return true;
    }
    function tsParseTypeArgumentsWithPossibleBitshift() {
      if (_base.state.type === _types.TokenType.bitShiftL) {
        _base.state.pos -= 1;
        _index.finishToken.call(void 0, _types.TokenType.lessThan);
      }
      tsParseTypeArguments();
    }
    function tsParseTypeArguments() {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      _util.expect.call(void 0, _types.TokenType.lessThan);
      while (!_index.match.call(void 0, _types.TokenType.greaterThan) && !_base.state.error) {
        tsParseType();
        _index.eat.call(void 0, _types.TokenType.comma);
      }
      if (!oldIsType) {
        _index.popTypeContext.call(void 0, oldIsType);
        _index.rescan_gt.call(void 0);
        _util.expect.call(void 0, _types.TokenType.greaterThan);
        _base.state.tokens[_base.state.tokens.length - 1].isType = true;
      } else {
        _util.expect.call(void 0, _types.TokenType.greaterThan);
        _index.popTypeContext.call(void 0, oldIsType);
      }
    }
    function tsIsDeclarationStart() {
      if (_index.match.call(void 0, _types.TokenType.name)) {
        switch (_base.state.contextualKeyword) {
          case _keywords.ContextualKeyword._abstract:
          case _keywords.ContextualKeyword._declare:
          case _keywords.ContextualKeyword._enum:
          case _keywords.ContextualKeyword._interface:
          case _keywords.ContextualKeyword._module:
          case _keywords.ContextualKeyword._namespace:
          case _keywords.ContextualKeyword._type:
            return true;
          default:
            break;
        }
      }
      return false;
    }
    exports2.tsIsDeclarationStart = tsIsDeclarationStart;
    function tsParseFunctionBodyAndFinish(functionStart, funcContextId) {
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        tsParseTypeOrTypePredicateAnnotation(_types.TokenType.colon);
      }
      if (!_index.match.call(void 0, _types.TokenType.braceL) && _util.isLineTerminator.call(void 0)) {
        let i = _base.state.tokens.length - 1;
        while (i >= 0 && (_base.state.tokens[i].start >= functionStart || _base.state.tokens[i].type === _types.TokenType._default || _base.state.tokens[i].type === _types.TokenType._export)) {
          _base.state.tokens[i].isType = true;
          i--;
        }
        return;
      }
      _expression.parseFunctionBody.call(void 0, false, funcContextId);
    }
    exports2.tsParseFunctionBodyAndFinish = tsParseFunctionBodyAndFinish;
    function tsParseSubscript(startTokenIndex, noCalls, stopState) {
      if (!_util.hasPrecedingLineBreak.call(void 0) && _index.eat.call(void 0, _types.TokenType.bang)) {
        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.nonNullAssertion;
        return;
      }
      if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.bitShiftL)) {
        const snapshot = _base.state.snapshot();
        if (!noCalls && _expression.atPossibleAsync.call(void 0)) {
          const asyncArrowFn = tsTryParseGenericAsyncArrowFunction();
          if (asyncArrowFn) {
            return;
          }
        }
        tsParseTypeArgumentsWithPossibleBitshift();
        if (!noCalls && _index.eat.call(void 0, _types.TokenType.parenL)) {
          _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
          _expression.parseCallExpressionArguments.call(void 0);
        } else if (_index.match.call(void 0, _types.TokenType.backQuote)) {
          _expression.parseTemplate.call(void 0);
        } else if (
          // The remaining possible case is an instantiation expression, e.g.
          // Array<number> . Check for a few cases that would disqualify it and
          // cause us to bail out.
          // a<b>>c is not (a<b>)>c, but a<(b>>c)
          _base.state.type === _types.TokenType.greaterThan || // a<b>c is (a<b)>c
          _base.state.type !== _types.TokenType.parenL && Boolean(_base.state.type & _types.TokenType.IS_EXPRESSION_START) && !_util.hasPrecedingLineBreak.call(void 0)
        ) {
          _util.unexpected.call(void 0);
        }
        if (_base.state.error) {
          _base.state.restoreFromSnapshot(snapshot);
        } else {
          return;
        }
      } else if (!noCalls && _index.match.call(void 0, _types.TokenType.questionDot) && _index.lookaheadType.call(void 0) === _types.TokenType.lessThan) {
        _index.next.call(void 0);
        _base.state.tokens[startTokenIndex].isOptionalChainStart = true;
        _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
        tsParseTypeArguments();
        _util.expect.call(void 0, _types.TokenType.parenL);
        _expression.parseCallExpressionArguments.call(void 0);
      }
      _expression.baseParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
    }
    exports2.tsParseSubscript = tsParseSubscript;
    function tsTryParseExport() {
      if (_index.eat.call(void 0, _types.TokenType._import)) {
        if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type) && _index.lookaheadType.call(void 0) !== _types.TokenType.eq) {
          _util.expectContextual.call(void 0, _keywords.ContextualKeyword._type);
        }
        tsParseImportEqualsDeclaration();
        return true;
      } else if (_index.eat.call(void 0, _types.TokenType.eq)) {
        _expression.parseExpression.call(void 0);
        _util.semicolon.call(void 0);
        return true;
      } else if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as)) {
        _util.expectContextual.call(void 0, _keywords.ContextualKeyword._namespace);
        _expression.parseIdentifier.call(void 0);
        _util.semicolon.call(void 0);
        return true;
      } else {
        if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
          const nextType = _index.lookaheadType.call(void 0);
          if (nextType === _types.TokenType.braceL || nextType === _types.TokenType.star) {
            _index.next.call(void 0);
          }
        }
        return false;
      }
    }
    exports2.tsTryParseExport = tsTryParseExport;
    function tsParseImportSpecifier() {
      _expression.parseIdentifier.call(void 0);
      if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
        _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
        return;
      }
      _expression.parseIdentifier.call(void 0);
      if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
        _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
        _base.state.tokens[_base.state.tokens.length - 2].isType = true;
        _base.state.tokens[_base.state.tokens.length - 1].isType = true;
        return;
      }
      _expression.parseIdentifier.call(void 0);
      if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
        _base.state.tokens[_base.state.tokens.length - 3].identifierRole = _index.IdentifierRole.ImportAccess;
        _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
        return;
      }
      _expression.parseIdentifier.call(void 0);
      _base.state.tokens[_base.state.tokens.length - 3].identifierRole = _index.IdentifierRole.ImportAccess;
      _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ImportDeclaration;
      _base.state.tokens[_base.state.tokens.length - 4].isType = true;
      _base.state.tokens[_base.state.tokens.length - 3].isType = true;
      _base.state.tokens[_base.state.tokens.length - 2].isType = true;
      _base.state.tokens[_base.state.tokens.length - 1].isType = true;
    }
    exports2.tsParseImportSpecifier = tsParseImportSpecifier;
    function tsParseExportSpecifier() {
      _expression.parseIdentifier.call(void 0);
      if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
        _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ExportAccess;
        return;
      }
      _expression.parseIdentifier.call(void 0);
      if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
        _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index.IdentifierRole.ExportAccess;
        _base.state.tokens[_base.state.tokens.length - 2].isType = true;
        _base.state.tokens[_base.state.tokens.length - 1].isType = true;
        return;
      }
      _expression.parseIdentifier.call(void 0);
      if (_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.braceR)) {
        _base.state.tokens[_base.state.tokens.length - 3].identifierRole = _index.IdentifierRole.ExportAccess;
        return;
      }
      _expression.parseIdentifier.call(void 0);
      _base.state.tokens[_base.state.tokens.length - 3].identifierRole = _index.IdentifierRole.ExportAccess;
      _base.state.tokens[_base.state.tokens.length - 4].isType = true;
      _base.state.tokens[_base.state.tokens.length - 3].isType = true;
      _base.state.tokens[_base.state.tokens.length - 2].isType = true;
      _base.state.tokens[_base.state.tokens.length - 1].isType = true;
    }
    exports2.tsParseExportSpecifier = tsParseExportSpecifier;
    function tsTryParseExportDefaultExpression() {
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._abstract) && _index.lookaheadType.call(void 0) === _types.TokenType._class) {
        _base.state.type = _types.TokenType._abstract;
        _index.next.call(void 0);
        _statement.parseClass.call(void 0, true, true);
        return true;
      }
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
        const oldIsType = _index.pushTypeContext.call(void 0, 2);
        tsParseDeclaration(_keywords.ContextualKeyword._interface, true);
        _index.popTypeContext.call(void 0, oldIsType);
        return true;
      }
      return false;
    }
    exports2.tsTryParseExportDefaultExpression = tsTryParseExportDefaultExpression;
    function tsTryParseStatementContent() {
      if (_base.state.type === _types.TokenType._const) {
        const ahead = _index.lookaheadTypeAndKeyword.call(void 0);
        if (ahead.type === _types.TokenType.name && ahead.contextualKeyword === _keywords.ContextualKeyword._enum) {
          _util.expect.call(void 0, _types.TokenType._const);
          _util.expectContextual.call(void 0, _keywords.ContextualKeyword._enum);
          _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._enum;
          tsParseEnumDeclaration();
          return true;
        }
      }
      return false;
    }
    exports2.tsTryParseStatementContent = tsTryParseStatementContent;
    function tsTryParseClassMemberWithIsStatic(isStatic) {
      const memberStartIndexAfterStatic = _base.state.tokens.length;
      tsParseModifiers([
        _keywords.ContextualKeyword._abstract,
        _keywords.ContextualKeyword._readonly,
        _keywords.ContextualKeyword._declare,
        _keywords.ContextualKeyword._static,
        _keywords.ContextualKeyword._override
      ]);
      const modifiersEndIndex = _base.state.tokens.length;
      const found = tsTryParseIndexSignature();
      if (found) {
        const memberStartIndex = isStatic ? memberStartIndexAfterStatic - 1 : memberStartIndexAfterStatic;
        for (let i = memberStartIndex; i < modifiersEndIndex; i++) {
          _base.state.tokens[i].isType = true;
        }
        return true;
      }
      return false;
    }
    exports2.tsTryParseClassMemberWithIsStatic = tsTryParseClassMemberWithIsStatic;
    function tsParseIdentifierStatement(contextualKeyword) {
      const matched = tsParseExpressionStatement(contextualKeyword);
      if (!matched) {
        _util.semicolon.call(void 0);
      }
    }
    exports2.tsParseIdentifierStatement = tsParseIdentifierStatement;
    function tsParseExportDeclaration() {
      const isDeclare = _util.eatContextual.call(void 0, _keywords.ContextualKeyword._declare);
      if (isDeclare) {
        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._declare;
      }
      let matchedDeclaration = false;
      if (_index.match.call(void 0, _types.TokenType.name)) {
        if (isDeclare) {
          const oldIsType = _index.pushTypeContext.call(void 0, 2);
          matchedDeclaration = tsTryParseExportDeclaration();
          _index.popTypeContext.call(void 0, oldIsType);
        } else {
          matchedDeclaration = tsTryParseExportDeclaration();
        }
      }
      if (!matchedDeclaration) {
        if (isDeclare) {
          const oldIsType = _index.pushTypeContext.call(void 0, 2);
          _statement.parseStatement.call(void 0, true);
          _index.popTypeContext.call(void 0, oldIsType);
        } else {
          _statement.parseStatement.call(void 0, true);
        }
      }
    }
    exports2.tsParseExportDeclaration = tsParseExportDeclaration;
    function tsAfterParseClassSuper(hasSuper) {
      if (hasSuper && (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.bitShiftL))) {
        tsParseTypeArgumentsWithPossibleBitshift();
      }
      if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._implements)) {
        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._implements;
        const oldIsType = _index.pushTypeContext.call(void 0, 1);
        tsParseHeritageClause();
        _index.popTypeContext.call(void 0, oldIsType);
      }
    }
    exports2.tsAfterParseClassSuper = tsAfterParseClassSuper;
    function tsStartParseObjPropValue() {
      tsTryParseTypeParameters();
    }
    exports2.tsStartParseObjPropValue = tsStartParseObjPropValue;
    function tsStartParseFunctionParams() {
      tsTryParseTypeParameters();
    }
    exports2.tsStartParseFunctionParams = tsStartParseFunctionParams;
    function tsAfterParseVarHead() {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      if (!_util.hasPrecedingLineBreak.call(void 0)) {
        _index.eat.call(void 0, _types.TokenType.bang);
      }
      tsTryParseTypeAnnotation();
      _index.popTypeContext.call(void 0, oldIsType);
    }
    exports2.tsAfterParseVarHead = tsAfterParseVarHead;
    function tsStartParseAsyncArrowFromCallExpression() {
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        tsParseTypeAnnotation();
      }
    }
    exports2.tsStartParseAsyncArrowFromCallExpression = tsStartParseAsyncArrowFromCallExpression;
    function tsParseMaybeAssign(noIn, isWithinParens) {
      if (_base.isJSXEnabled) {
        return tsParseMaybeAssignWithJSX(noIn, isWithinParens);
      } else {
        return tsParseMaybeAssignWithoutJSX(noIn, isWithinParens);
      }
    }
    exports2.tsParseMaybeAssign = tsParseMaybeAssign;
    function tsParseMaybeAssignWithJSX(noIn, isWithinParens) {
      if (!_index.match.call(void 0, _types.TokenType.lessThan)) {
        return _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
      }
      const snapshot = _base.state.snapshot();
      let wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
      if (_base.state.error) {
        _base.state.restoreFromSnapshot(snapshot);
      } else {
        return wasArrow;
      }
      _base.state.type = _types.TokenType.typeParameterStart;
      tsParseTypeParameters();
      wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
      if (!wasArrow) {
        _util.unexpected.call(void 0);
      }
      return wasArrow;
    }
    exports2.tsParseMaybeAssignWithJSX = tsParseMaybeAssignWithJSX;
    function tsParseMaybeAssignWithoutJSX(noIn, isWithinParens) {
      if (!_index.match.call(void 0, _types.TokenType.lessThan)) {
        return _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
      }
      const snapshot = _base.state.snapshot();
      tsParseTypeParameters();
      const wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
      if (!wasArrow) {
        _util.unexpected.call(void 0);
      }
      if (_base.state.error) {
        _base.state.restoreFromSnapshot(snapshot);
      } else {
        return wasArrow;
      }
      return _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
    }
    exports2.tsParseMaybeAssignWithoutJSX = tsParseMaybeAssignWithoutJSX;
    function tsParseArrow() {
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        const snapshot = _base.state.snapshot();
        tsParseTypeOrTypePredicateAnnotation(_types.TokenType.colon);
        if (_util.canInsertSemicolon.call(void 0)) _util.unexpected.call(void 0);
        if (!_index.match.call(void 0, _types.TokenType.arrow)) _util.unexpected.call(void 0);
        if (_base.state.error) {
          _base.state.restoreFromSnapshot(snapshot);
        }
      }
      return _index.eat.call(void 0, _types.TokenType.arrow);
    }
    exports2.tsParseArrow = tsParseArrow;
    function tsParseAssignableListItemTypes() {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      _index.eat.call(void 0, _types.TokenType.question);
      tsTryParseTypeAnnotation();
      _index.popTypeContext.call(void 0, oldIsType);
    }
    exports2.tsParseAssignableListItemTypes = tsParseAssignableListItemTypes;
    function tsParseMaybeDecoratorArguments() {
      if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.bitShiftL)) {
        tsParseTypeArgumentsWithPossibleBitshift();
      }
      _statement.baseParseMaybeDecoratorArguments.call(void 0);
    }
    exports2.tsParseMaybeDecoratorArguments = tsParseMaybeDecoratorArguments;
  }
});

// node_modules/sucrase/dist/parser/plugins/jsx/index.js
var require_jsx = __commonJS({
  "node_modules/sucrase/dist/parser/plugins/jsx/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _index = require_tokenizer2();
    var _types = require_types();
    var _base = require_base();
    var _expression = require_expression();
    var _util = require_util();
    var _charcodes = require_charcodes();
    var _identifier = require_identifier();
    var _typescript = require_typescript();
    function jsxReadToken() {
      let sawNewline = false;
      let sawNonWhitespace = false;
      while (true) {
        if (_base.state.pos >= _base.input.length) {
          _util.unexpected.call(void 0, "Unterminated JSX contents");
          return;
        }
        const ch = _base.input.charCodeAt(_base.state.pos);
        if (ch === _charcodes.charCodes.lessThan || ch === _charcodes.charCodes.leftCurlyBrace) {
          if (_base.state.pos === _base.state.start) {
            if (ch === _charcodes.charCodes.lessThan) {
              _base.state.pos++;
              _index.finishToken.call(void 0, _types.TokenType.jsxTagStart);
              return;
            }
            _index.getTokenFromCode.call(void 0, ch);
            return;
          }
          if (sawNewline && !sawNonWhitespace) {
            _index.finishToken.call(void 0, _types.TokenType.jsxEmptyText);
          } else {
            _index.finishToken.call(void 0, _types.TokenType.jsxText);
          }
          return;
        }
        if (ch === _charcodes.charCodes.lineFeed) {
          sawNewline = true;
        } else if (ch !== _charcodes.charCodes.space && ch !== _charcodes.charCodes.carriageReturn && ch !== _charcodes.charCodes.tab) {
          sawNonWhitespace = true;
        }
        _base.state.pos++;
      }
    }
    function jsxReadString(quote) {
      _base.state.pos++;
      for (; ; ) {
        if (_base.state.pos >= _base.input.length) {
          _util.unexpected.call(void 0, "Unterminated string constant");
          return;
        }
        const ch = _base.input.charCodeAt(_base.state.pos);
        if (ch === quote) {
          _base.state.pos++;
          break;
        }
        _base.state.pos++;
      }
      _index.finishToken.call(void 0, _types.TokenType.string);
    }
    function jsxReadWord() {
      let ch;
      do {
        if (_base.state.pos > _base.input.length) {
          _util.unexpected.call(void 0, "Unexpectedly reached the end of input.");
          return;
        }
        ch = _base.input.charCodeAt(++_base.state.pos);
      } while (_identifier.IS_IDENTIFIER_CHAR[ch] || ch === _charcodes.charCodes.dash);
      _index.finishToken.call(void 0, _types.TokenType.jsxName);
    }
    function jsxParseIdentifier() {
      nextJSXTagToken();
    }
    function jsxParseNamespacedName(identifierRole) {
      jsxParseIdentifier();
      if (!_index.eat.call(void 0, _types.TokenType.colon)) {
        _base.state.tokens[_base.state.tokens.length - 1].identifierRole = identifierRole;
        return;
      }
      jsxParseIdentifier();
    }
    function jsxParseElementName() {
      const firstTokenIndex = _base.state.tokens.length;
      jsxParseNamespacedName(_index.IdentifierRole.Access);
      let hadDot = false;
      while (_index.match.call(void 0, _types.TokenType.dot)) {
        hadDot = true;
        nextJSXTagToken();
        jsxParseIdentifier();
      }
      if (!hadDot) {
        const firstToken = _base.state.tokens[firstTokenIndex];
        const firstChar = _base.input.charCodeAt(firstToken.start);
        if (firstChar >= _charcodes.charCodes.lowercaseA && firstChar <= _charcodes.charCodes.lowercaseZ) {
          firstToken.identifierRole = null;
        }
      }
    }
    function jsxParseAttributeValue() {
      switch (_base.state.type) {
        case _types.TokenType.braceL:
          _index.next.call(void 0);
          _expression.parseExpression.call(void 0);
          nextJSXTagToken();
          return;
        case _types.TokenType.jsxTagStart:
          jsxParseElement();
          nextJSXTagToken();
          return;
        case _types.TokenType.string:
          nextJSXTagToken();
          return;
        default:
          _util.unexpected.call(void 0, "JSX value should be either an expression or a quoted JSX text");
      }
    }
    function jsxParseSpreadChild() {
      _util.expect.call(void 0, _types.TokenType.ellipsis);
      _expression.parseExpression.call(void 0);
    }
    function jsxParseOpeningElement(initialTokenIndex) {
      if (_index.match.call(void 0, _types.TokenType.jsxTagEnd)) {
        return false;
      }
      jsxParseElementName();
      if (_base.isTypeScriptEnabled) {
        _typescript.tsTryParseJSXTypeArgument.call(void 0);
      }
      let hasSeenPropSpread = false;
      while (!_index.match.call(void 0, _types.TokenType.slash) && !_index.match.call(void 0, _types.TokenType.jsxTagEnd) && !_base.state.error) {
        if (_index.eat.call(void 0, _types.TokenType.braceL)) {
          hasSeenPropSpread = true;
          _util.expect.call(void 0, _types.TokenType.ellipsis);
          _expression.parseMaybeAssign.call(void 0);
          nextJSXTagToken();
          continue;
        }
        if (hasSeenPropSpread && _base.state.end - _base.state.start === 3 && _base.input.charCodeAt(_base.state.start) === _charcodes.charCodes.lowercaseK && _base.input.charCodeAt(_base.state.start + 1) === _charcodes.charCodes.lowercaseE && _base.input.charCodeAt(_base.state.start + 2) === _charcodes.charCodes.lowercaseY) {
          _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.KeyAfterPropSpread;
        }
        jsxParseNamespacedName(_index.IdentifierRole.ObjectKey);
        if (_index.match.call(void 0, _types.TokenType.eq)) {
          nextJSXTagToken();
          jsxParseAttributeValue();
        }
      }
      const isSelfClosing = _index.match.call(void 0, _types.TokenType.slash);
      if (isSelfClosing) {
        nextJSXTagToken();
      }
      return isSelfClosing;
    }
    function jsxParseClosingElement() {
      if (_index.match.call(void 0, _types.TokenType.jsxTagEnd)) {
        return;
      }
      jsxParseElementName();
    }
    function jsxParseElementAt() {
      const initialTokenIndex = _base.state.tokens.length - 1;
      _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.NoChildren;
      let numExplicitChildren = 0;
      const isSelfClosing = jsxParseOpeningElement(initialTokenIndex);
      if (!isSelfClosing) {
        nextJSXExprToken();
        while (true) {
          switch (_base.state.type) {
            case _types.TokenType.jsxTagStart:
              nextJSXTagToken();
              if (_index.match.call(void 0, _types.TokenType.slash)) {
                nextJSXTagToken();
                jsxParseClosingElement();
                if (_base.state.tokens[initialTokenIndex].jsxRole !== _index.JSXRole.KeyAfterPropSpread) {
                  if (numExplicitChildren === 1) {
                    _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.OneChild;
                  } else if (numExplicitChildren > 1) {
                    _base.state.tokens[initialTokenIndex].jsxRole = _index.JSXRole.StaticChildren;
                  }
                }
                return;
              }
              numExplicitChildren++;
              jsxParseElementAt();
              nextJSXExprToken();
              break;
            case _types.TokenType.jsxText:
              numExplicitChildren++;
              nextJSXExprToken();
              break;
            case _types.TokenType.jsxEmptyText:
              nextJSXExprToken();
              break;
            case _types.TokenType.braceL:
              _index.next.call(void 0);
              if (_index.match.call(void 0, _types.TokenType.ellipsis)) {
                jsxParseSpreadChild();
                nextJSXExprToken();
                numExplicitChildren += 2;
              } else {
                if (!_index.match.call(void 0, _types.TokenType.braceR)) {
                  numExplicitChildren++;
                  _expression.parseExpression.call(void 0);
                }
                nextJSXExprToken();
              }
              break;
            // istanbul ignore next - should never happen
            default:
              _util.unexpected.call(void 0);
              return;
          }
        }
      }
    }
    function jsxParseElement() {
      nextJSXTagToken();
      jsxParseElementAt();
    }
    exports2.jsxParseElement = jsxParseElement;
    function nextJSXTagToken() {
      _base.state.tokens.push(new (0, _index.Token)());
      _index.skipSpace.call(void 0);
      _base.state.start = _base.state.pos;
      const code = _base.input.charCodeAt(_base.state.pos);
      if (_identifier.IS_IDENTIFIER_START[code]) {
        jsxReadWord();
      } else if (code === _charcodes.charCodes.quotationMark || code === _charcodes.charCodes.apostrophe) {
        jsxReadString(code);
      } else {
        ++_base.state.pos;
        switch (code) {
          case _charcodes.charCodes.greaterThan:
            _index.finishToken.call(void 0, _types.TokenType.jsxTagEnd);
            break;
          case _charcodes.charCodes.lessThan:
            _index.finishToken.call(void 0, _types.TokenType.jsxTagStart);
            break;
          case _charcodes.charCodes.slash:
            _index.finishToken.call(void 0, _types.TokenType.slash);
            break;
          case _charcodes.charCodes.equalsTo:
            _index.finishToken.call(void 0, _types.TokenType.eq);
            break;
          case _charcodes.charCodes.leftCurlyBrace:
            _index.finishToken.call(void 0, _types.TokenType.braceL);
            break;
          case _charcodes.charCodes.dot:
            _index.finishToken.call(void 0, _types.TokenType.dot);
            break;
          case _charcodes.charCodes.colon:
            _index.finishToken.call(void 0, _types.TokenType.colon);
            break;
          default:
            _util.unexpected.call(void 0);
        }
      }
    }
    exports2.nextJSXTagToken = nextJSXTagToken;
    function nextJSXExprToken() {
      _base.state.tokens.push(new (0, _index.Token)());
      _base.state.start = _base.state.pos;
      jsxReadToken();
    }
  }
});

// node_modules/sucrase/dist/parser/plugins/types.js
var require_types3 = __commonJS({
  "node_modules/sucrase/dist/parser/plugins/types.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _index = require_tokenizer2();
    var _types = require_types();
    var _base = require_base();
    var _expression = require_expression();
    var _flow = require_flow();
    var _typescript = require_typescript();
    function typedParseConditional(noIn) {
      if (_index.match.call(void 0, _types.TokenType.question)) {
        const nextType = _index.lookaheadType.call(void 0);
        if (nextType === _types.TokenType.colon || nextType === _types.TokenType.comma || nextType === _types.TokenType.parenR) {
          return;
        }
      }
      _expression.baseParseConditional.call(void 0, noIn);
    }
    exports2.typedParseConditional = typedParseConditional;
    function typedParseParenItem() {
      _index.eatTypeToken.call(void 0, _types.TokenType.question);
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        if (_base.isTypeScriptEnabled) {
          _typescript.tsParseTypeAnnotation.call(void 0);
        } else if (_base.isFlowEnabled) {
          _flow.flowParseTypeAnnotation.call(void 0);
        }
      }
    }
    exports2.typedParseParenItem = typedParseParenItem;
  }
});

// node_modules/sucrase/dist/parser/traverser/expression.js
var require_expression = __commonJS({
  "node_modules/sucrase/dist/parser/traverser/expression.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _flow = require_flow();
    var _index = require_jsx();
    var _types = require_types3();
    var _typescript = require_typescript();
    var _index3 = require_tokenizer2();
    var _keywords = require_keywords();
    var _state = require_state();
    var _types3 = require_types();
    var _charcodes = require_charcodes();
    var _identifier = require_identifier();
    var _base = require_base();
    var _lval = require_lval();
    var _statement = require_statement();
    var _util = require_util();
    var StopState = class {
      constructor(stop) {
        this.stop = stop;
      }
    };
    exports2.StopState = StopState;
    function parseExpression(noIn = false) {
      parseMaybeAssign(noIn);
      if (_index3.match.call(void 0, _types3.TokenType.comma)) {
        while (_index3.eat.call(void 0, _types3.TokenType.comma)) {
          parseMaybeAssign(noIn);
        }
      }
    }
    exports2.parseExpression = parseExpression;
    function parseMaybeAssign(noIn = false, isWithinParens = false) {
      if (_base.isTypeScriptEnabled) {
        return _typescript.tsParseMaybeAssign.call(void 0, noIn, isWithinParens);
      } else if (_base.isFlowEnabled) {
        return _flow.flowParseMaybeAssign.call(void 0, noIn, isWithinParens);
      } else {
        return baseParseMaybeAssign(noIn, isWithinParens);
      }
    }
    exports2.parseMaybeAssign = parseMaybeAssign;
    function baseParseMaybeAssign(noIn, isWithinParens) {
      if (_index3.match.call(void 0, _types3.TokenType._yield)) {
        parseYield();
        return false;
      }
      if (_index3.match.call(void 0, _types3.TokenType.parenL) || _index3.match.call(void 0, _types3.TokenType.name) || _index3.match.call(void 0, _types3.TokenType._yield)) {
        _base.state.potentialArrowAt = _base.state.start;
      }
      const wasArrow = parseMaybeConditional(noIn);
      if (isWithinParens) {
        parseParenItem();
      }
      if (_base.state.type & _types3.TokenType.IS_ASSIGN) {
        _index3.next.call(void 0);
        parseMaybeAssign(noIn);
        return false;
      }
      return wasArrow;
    }
    exports2.baseParseMaybeAssign = baseParseMaybeAssign;
    function parseMaybeConditional(noIn) {
      const wasArrow = parseExprOps(noIn);
      if (wasArrow) {
        return true;
      }
      parseConditional(noIn);
      return false;
    }
    function parseConditional(noIn) {
      if (_base.isTypeScriptEnabled || _base.isFlowEnabled) {
        _types.typedParseConditional.call(void 0, noIn);
      } else {
        baseParseConditional(noIn);
      }
    }
    function baseParseConditional(noIn) {
      if (_index3.eat.call(void 0, _types3.TokenType.question)) {
        parseMaybeAssign();
        _util.expect.call(void 0, _types3.TokenType.colon);
        parseMaybeAssign(noIn);
      }
    }
    exports2.baseParseConditional = baseParseConditional;
    function parseExprOps(noIn) {
      const startTokenIndex = _base.state.tokens.length;
      const wasArrow = parseMaybeUnary();
      if (wasArrow) {
        return true;
      }
      parseExprOp(startTokenIndex, -1, noIn);
      return false;
    }
    function parseExprOp(startTokenIndex, minPrec, noIn) {
      if (_base.isTypeScriptEnabled && (_types3.TokenType._in & _types3.TokenType.PRECEDENCE_MASK) > minPrec && !_util.hasPrecedingLineBreak.call(void 0) && (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as) || _util.eatContextual.call(void 0, _keywords.ContextualKeyword._satisfies))) {
        const oldIsType = _index3.pushTypeContext.call(void 0, 1);
        _typescript.tsParseType.call(void 0);
        _index3.popTypeContext.call(void 0, oldIsType);
        _index3.rescan_gt.call(void 0);
        parseExprOp(startTokenIndex, minPrec, noIn);
        return;
      }
      const prec = _base.state.type & _types3.TokenType.PRECEDENCE_MASK;
      if (prec > 0 && (!noIn || !_index3.match.call(void 0, _types3.TokenType._in))) {
        if (prec > minPrec) {
          const op = _base.state.type;
          _index3.next.call(void 0);
          if (op === _types3.TokenType.nullishCoalescing) {
            _base.state.tokens[_base.state.tokens.length - 1].nullishStartIndex = startTokenIndex;
          }
          const rhsStartTokenIndex = _base.state.tokens.length;
          parseMaybeUnary();
          parseExprOp(rhsStartTokenIndex, op & _types3.TokenType.IS_RIGHT_ASSOCIATIVE ? prec - 1 : prec, noIn);
          if (op === _types3.TokenType.nullishCoalescing) {
            _base.state.tokens[startTokenIndex].numNullishCoalesceStarts++;
            _base.state.tokens[_base.state.tokens.length - 1].numNullishCoalesceEnds++;
          }
          parseExprOp(startTokenIndex, minPrec, noIn);
        }
      }
    }
    function parseMaybeUnary() {
      if (_base.isTypeScriptEnabled && !_base.isJSXEnabled && _index3.eat.call(void 0, _types3.TokenType.lessThan)) {
        _typescript.tsParseTypeAssertion.call(void 0);
        return false;
      }
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._module) && _index3.lookaheadCharCode.call(void 0) === _charcodes.charCodes.leftCurlyBrace && !_util.hasFollowingLineBreak.call(void 0)) {
        parseModuleExpression();
        return false;
      }
      if (_base.state.type & _types3.TokenType.IS_PREFIX) {
        _index3.next.call(void 0);
        parseMaybeUnary();
        return false;
      }
      const wasArrow = parseExprSubscripts();
      if (wasArrow) {
        return true;
      }
      while (_base.state.type & _types3.TokenType.IS_POSTFIX && !_util.canInsertSemicolon.call(void 0)) {
        if (_base.state.type === _types3.TokenType.preIncDec) {
          _base.state.type = _types3.TokenType.postIncDec;
        }
        _index3.next.call(void 0);
      }
      return false;
    }
    exports2.parseMaybeUnary = parseMaybeUnary;
    function parseExprSubscripts() {
      const startTokenIndex = _base.state.tokens.length;
      const wasArrow = parseExprAtom();
      if (wasArrow) {
        return true;
      }
      parseSubscripts(startTokenIndex);
      if (_base.state.tokens.length > startTokenIndex && _base.state.tokens[startTokenIndex].isOptionalChainStart) {
        _base.state.tokens[_base.state.tokens.length - 1].isOptionalChainEnd = true;
      }
      return false;
    }
    exports2.parseExprSubscripts = parseExprSubscripts;
    function parseSubscripts(startTokenIndex, noCalls = false) {
      if (_base.isFlowEnabled) {
        _flow.flowParseSubscripts.call(void 0, startTokenIndex, noCalls);
      } else {
        baseParseSubscripts(startTokenIndex, noCalls);
      }
    }
    function baseParseSubscripts(startTokenIndex, noCalls = false) {
      const stopState = new StopState(false);
      do {
        parseSubscript(startTokenIndex, noCalls, stopState);
      } while (!stopState.stop && !_base.state.error);
    }
    exports2.baseParseSubscripts = baseParseSubscripts;
    function parseSubscript(startTokenIndex, noCalls, stopState) {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
      } else if (_base.isFlowEnabled) {
        _flow.flowParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
      } else {
        baseParseSubscript(startTokenIndex, noCalls, stopState);
      }
    }
    function baseParseSubscript(startTokenIndex, noCalls, stopState) {
      if (!noCalls && _index3.eat.call(void 0, _types3.TokenType.doubleColon)) {
        parseNoCallExpr();
        stopState.stop = true;
        parseSubscripts(startTokenIndex, noCalls);
      } else if (_index3.match.call(void 0, _types3.TokenType.questionDot)) {
        _base.state.tokens[startTokenIndex].isOptionalChainStart = true;
        if (noCalls && _index3.lookaheadType.call(void 0) === _types3.TokenType.parenL) {
          stopState.stop = true;
          return;
        }
        _index3.next.call(void 0);
        _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
        if (_index3.eat.call(void 0, _types3.TokenType.bracketL)) {
          parseExpression();
          _util.expect.call(void 0, _types3.TokenType.bracketR);
        } else if (_index3.eat.call(void 0, _types3.TokenType.parenL)) {
          parseCallExpressionArguments();
        } else {
          parseMaybePrivateName();
        }
      } else if (_index3.eat.call(void 0, _types3.TokenType.dot)) {
        _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
        parseMaybePrivateName();
      } else if (_index3.eat.call(void 0, _types3.TokenType.bracketL)) {
        _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
        parseExpression();
        _util.expect.call(void 0, _types3.TokenType.bracketR);
      } else if (!noCalls && _index3.match.call(void 0, _types3.TokenType.parenL)) {
        if (atPossibleAsync()) {
          const snapshot = _base.state.snapshot();
          const asyncStartTokenIndex = _base.state.tokens.length;
          _index3.next.call(void 0);
          _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
          const callContextId = _base.getNextContextId.call(void 0);
          _base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
          parseCallExpressionArguments();
          _base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
          if (shouldParseAsyncArrow()) {
            _base.state.restoreFromSnapshot(snapshot);
            stopState.stop = true;
            _base.state.scopeDepth++;
            _statement.parseFunctionParams.call(void 0);
            parseAsyncArrowFromCallExpression(asyncStartTokenIndex);
          }
        } else {
          _index3.next.call(void 0);
          _base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
          const callContextId = _base.getNextContextId.call(void 0);
          _base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
          parseCallExpressionArguments();
          _base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
        }
      } else if (_index3.match.call(void 0, _types3.TokenType.backQuote)) {
        parseTemplate();
      } else {
        stopState.stop = true;
      }
    }
    exports2.baseParseSubscript = baseParseSubscript;
    function atPossibleAsync() {
      return _base.state.tokens[_base.state.tokens.length - 1].contextualKeyword === _keywords.ContextualKeyword._async && !_util.canInsertSemicolon.call(void 0);
    }
    exports2.atPossibleAsync = atPossibleAsync;
    function parseCallExpressionArguments() {
      let first = true;
      while (!_index3.eat.call(void 0, _types3.TokenType.parenR) && !_base.state.error) {
        if (first) {
          first = false;
        } else {
          _util.expect.call(void 0, _types3.TokenType.comma);
          if (_index3.eat.call(void 0, _types3.TokenType.parenR)) {
            break;
          }
        }
        parseExprListItem(false);
      }
    }
    exports2.parseCallExpressionArguments = parseCallExpressionArguments;
    function shouldParseAsyncArrow() {
      return _index3.match.call(void 0, _types3.TokenType.colon) || _index3.match.call(void 0, _types3.TokenType.arrow);
    }
    function parseAsyncArrowFromCallExpression(startTokenIndex) {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsStartParseAsyncArrowFromCallExpression.call(void 0);
      } else if (_base.isFlowEnabled) {
        _flow.flowStartParseAsyncArrowFromCallExpression.call(void 0);
      }
      _util.expect.call(void 0, _types3.TokenType.arrow);
      parseArrowExpression(startTokenIndex);
    }
    function parseNoCallExpr() {
      const startTokenIndex = _base.state.tokens.length;
      parseExprAtom();
      parseSubscripts(startTokenIndex, true);
    }
    function parseExprAtom() {
      if (_index3.eat.call(void 0, _types3.TokenType.modulo)) {
        parseIdentifier();
        return false;
      }
      if (_index3.match.call(void 0, _types3.TokenType.jsxText) || _index3.match.call(void 0, _types3.TokenType.jsxEmptyText)) {
        parseLiteral();
        return false;
      } else if (_index3.match.call(void 0, _types3.TokenType.lessThan) && _base.isJSXEnabled) {
        _base.state.type = _types3.TokenType.jsxTagStart;
        _index.jsxParseElement.call(void 0);
        _index3.next.call(void 0);
        return false;
      }
      const canBeArrow = _base.state.potentialArrowAt === _base.state.start;
      switch (_base.state.type) {
        case _types3.TokenType.slash:
        case _types3.TokenType.assign:
          _index3.retokenizeSlashAsRegex.call(void 0);
        // Fall through.
        case _types3.TokenType._super:
        case _types3.TokenType._this:
        case _types3.TokenType.regexp:
        case _types3.TokenType.num:
        case _types3.TokenType.bigint:
        case _types3.TokenType.decimal:
        case _types3.TokenType.string:
        case _types3.TokenType._null:
        case _types3.TokenType._true:
        case _types3.TokenType._false:
          _index3.next.call(void 0);
          return false;
        case _types3.TokenType._import:
          _index3.next.call(void 0);
          if (_index3.match.call(void 0, _types3.TokenType.dot)) {
            _base.state.tokens[_base.state.tokens.length - 1].type = _types3.TokenType.name;
            _index3.next.call(void 0);
            parseIdentifier();
          }
          return false;
        case _types3.TokenType.name: {
          const startTokenIndex = _base.state.tokens.length;
          const functionStart = _base.state.start;
          const contextualKeyword = _base.state.contextualKeyword;
          parseIdentifier();
          if (contextualKeyword === _keywords.ContextualKeyword._await) {
            parseAwait();
            return false;
          } else if (contextualKeyword === _keywords.ContextualKeyword._async && _index3.match.call(void 0, _types3.TokenType._function) && !_util.canInsertSemicolon.call(void 0)) {
            _index3.next.call(void 0);
            _statement.parseFunction.call(void 0, functionStart, false);
            return false;
          } else if (canBeArrow && contextualKeyword === _keywords.ContextualKeyword._async && !_util.canInsertSemicolon.call(void 0) && _index3.match.call(void 0, _types3.TokenType.name)) {
            _base.state.scopeDepth++;
            _lval.parseBindingIdentifier.call(void 0, false);
            _util.expect.call(void 0, _types3.TokenType.arrow);
            parseArrowExpression(startTokenIndex);
            return true;
          } else if (_index3.match.call(void 0, _types3.TokenType._do) && !_util.canInsertSemicolon.call(void 0)) {
            _index3.next.call(void 0);
            _statement.parseBlock.call(void 0);
            return false;
          }
          if (canBeArrow && !_util.canInsertSemicolon.call(void 0) && _index3.match.call(void 0, _types3.TokenType.arrow)) {
            _base.state.scopeDepth++;
            _lval.markPriorBindingIdentifier.call(void 0, false);
            _util.expect.call(void 0, _types3.TokenType.arrow);
            parseArrowExpression(startTokenIndex);
            return true;
          }
          _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index3.IdentifierRole.Access;
          return false;
        }
        case _types3.TokenType._do: {
          _index3.next.call(void 0);
          _statement.parseBlock.call(void 0);
          return false;
        }
        case _types3.TokenType.parenL: {
          const wasArrow = parseParenAndDistinguishExpression(canBeArrow);
          return wasArrow;
        }
        case _types3.TokenType.bracketL:
          _index3.next.call(void 0);
          parseExprList(_types3.TokenType.bracketR, true);
          return false;
        case _types3.TokenType.braceL:
          parseObj(false, false);
          return false;
        case _types3.TokenType._function:
          parseFunctionExpression();
          return false;
        case _types3.TokenType.at:
          _statement.parseDecorators.call(void 0);
        // Fall through.
        case _types3.TokenType._class:
          _statement.parseClass.call(void 0, false);
          return false;
        case _types3.TokenType._new:
          parseNew();
          return false;
        case _types3.TokenType.backQuote:
          parseTemplate();
          return false;
        case _types3.TokenType.doubleColon: {
          _index3.next.call(void 0);
          parseNoCallExpr();
          return false;
        }
        case _types3.TokenType.hash: {
          const code = _index3.lookaheadCharCode.call(void 0);
          if (_identifier.IS_IDENTIFIER_START[code] || code === _charcodes.charCodes.backslash) {
            parseMaybePrivateName();
          } else {
            _index3.next.call(void 0);
          }
          return false;
        }
        default:
          _util.unexpected.call(void 0);
          return false;
      }
    }
    exports2.parseExprAtom = parseExprAtom;
    function parseMaybePrivateName() {
      _index3.eat.call(void 0, _types3.TokenType.hash);
      parseIdentifier();
    }
    function parseFunctionExpression() {
      const functionStart = _base.state.start;
      parseIdentifier();
      if (_index3.eat.call(void 0, _types3.TokenType.dot)) {
        parseIdentifier();
      }
      _statement.parseFunction.call(void 0, functionStart, false);
    }
    function parseLiteral() {
      _index3.next.call(void 0);
    }
    exports2.parseLiteral = parseLiteral;
    function parseParenExpression() {
      _util.expect.call(void 0, _types3.TokenType.parenL);
      parseExpression();
      _util.expect.call(void 0, _types3.TokenType.parenR);
    }
    exports2.parseParenExpression = parseParenExpression;
    function parseParenAndDistinguishExpression(canBeArrow) {
      const snapshot = _base.state.snapshot();
      const startTokenIndex = _base.state.tokens.length;
      _util.expect.call(void 0, _types3.TokenType.parenL);
      let first = true;
      while (!_index3.match.call(void 0, _types3.TokenType.parenR) && !_base.state.error) {
        if (first) {
          first = false;
        } else {
          _util.expect.call(void 0, _types3.TokenType.comma);
          if (_index3.match.call(void 0, _types3.TokenType.parenR)) {
            break;
          }
        }
        if (_index3.match.call(void 0, _types3.TokenType.ellipsis)) {
          _lval.parseRest.call(
            void 0,
            false
            /* isBlockScope */
          );
          parseParenItem();
          break;
        } else {
          parseMaybeAssign(false, true);
        }
      }
      _util.expect.call(void 0, _types3.TokenType.parenR);
      if (canBeArrow && shouldParseArrow()) {
        const wasArrow = parseArrow();
        if (wasArrow) {
          _base.state.restoreFromSnapshot(snapshot);
          _base.state.scopeDepth++;
          _statement.parseFunctionParams.call(void 0);
          parseArrow();
          parseArrowExpression(startTokenIndex);
          if (_base.state.error) {
            _base.state.restoreFromSnapshot(snapshot);
            parseParenAndDistinguishExpression(false);
            return false;
          }
          return true;
        }
      }
      return false;
    }
    function shouldParseArrow() {
      return _index3.match.call(void 0, _types3.TokenType.colon) || !_util.canInsertSemicolon.call(void 0);
    }
    function parseArrow() {
      if (_base.isTypeScriptEnabled) {
        return _typescript.tsParseArrow.call(void 0);
      } else if (_base.isFlowEnabled) {
        return _flow.flowParseArrow.call(void 0);
      } else {
        return _index3.eat.call(void 0, _types3.TokenType.arrow);
      }
    }
    exports2.parseArrow = parseArrow;
    function parseParenItem() {
      if (_base.isTypeScriptEnabled || _base.isFlowEnabled) {
        _types.typedParseParenItem.call(void 0);
      }
    }
    function parseNew() {
      _util.expect.call(void 0, _types3.TokenType._new);
      if (_index3.eat.call(void 0, _types3.TokenType.dot)) {
        parseIdentifier();
        return;
      }
      parseNewCallee();
      if (_base.isFlowEnabled) {
        _flow.flowStartParseNewArguments.call(void 0);
      }
      if (_index3.eat.call(void 0, _types3.TokenType.parenL)) {
        parseExprList(_types3.TokenType.parenR);
      }
    }
    function parseNewCallee() {
      parseNoCallExpr();
      _index3.eat.call(void 0, _types3.TokenType.questionDot);
    }
    function parseTemplate() {
      _index3.nextTemplateToken.call(void 0);
      _index3.nextTemplateToken.call(void 0);
      while (!_index3.match.call(void 0, _types3.TokenType.backQuote) && !_base.state.error) {
        _util.expect.call(void 0, _types3.TokenType.dollarBraceL);
        parseExpression();
        _index3.nextTemplateToken.call(void 0);
        _index3.nextTemplateToken.call(void 0);
      }
      _index3.next.call(void 0);
    }
    exports2.parseTemplate = parseTemplate;
    function parseObj(isPattern, isBlockScope) {
      const contextId = _base.getNextContextId.call(void 0);
      let first = true;
      _index3.next.call(void 0);
      _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
      while (!_index3.eat.call(void 0, _types3.TokenType.braceR) && !_base.state.error) {
        if (first) {
          first = false;
        } else {
          _util.expect.call(void 0, _types3.TokenType.comma);
          if (_index3.eat.call(void 0, _types3.TokenType.braceR)) {
            break;
          }
        }
        let isGenerator = false;
        if (_index3.match.call(void 0, _types3.TokenType.ellipsis)) {
          const previousIndex = _base.state.tokens.length;
          _lval.parseSpread.call(void 0);
          if (isPattern) {
            if (_base.state.tokens.length === previousIndex + 2) {
              _lval.markPriorBindingIdentifier.call(void 0, isBlockScope);
            }
            if (_index3.eat.call(void 0, _types3.TokenType.braceR)) {
              break;
            }
          }
          continue;
        }
        if (!isPattern) {
          isGenerator = _index3.eat.call(void 0, _types3.TokenType.star);
        }
        if (!isPattern && _util.isContextual.call(void 0, _keywords.ContextualKeyword._async)) {
          if (isGenerator) _util.unexpected.call(void 0);
          parseIdentifier();
          if (_index3.match.call(void 0, _types3.TokenType.colon) || _index3.match.call(void 0, _types3.TokenType.parenL) || _index3.match.call(void 0, _types3.TokenType.braceR) || _index3.match.call(void 0, _types3.TokenType.eq) || _index3.match.call(void 0, _types3.TokenType.comma)) {
          } else {
            if (_index3.match.call(void 0, _types3.TokenType.star)) {
              _index3.next.call(void 0);
              isGenerator = true;
            }
            parsePropertyName(contextId);
          }
        } else {
          parsePropertyName(contextId);
        }
        parseObjPropValue(isPattern, isBlockScope, contextId);
      }
      _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
    }
    exports2.parseObj = parseObj;
    function isGetterOrSetterMethod(isPattern) {
      return !isPattern && (_index3.match.call(void 0, _types3.TokenType.string) || // get "string"() {}
      _index3.match.call(void 0, _types3.TokenType.num) || // get 1() {}
      _index3.match.call(void 0, _types3.TokenType.bracketL) || // get ["string"]() {}
      _index3.match.call(void 0, _types3.TokenType.name) || // get foo() {}
      !!(_base.state.type & _types3.TokenType.IS_KEYWORD));
    }
    function parseObjectMethod(isPattern, objectContextId) {
      const functionStart = _base.state.start;
      if (_index3.match.call(void 0, _types3.TokenType.parenL)) {
        if (isPattern) _util.unexpected.call(void 0);
        parseMethod(
          functionStart,
          /* isConstructor */
          false
        );
        return true;
      }
      if (isGetterOrSetterMethod(isPattern)) {
        parsePropertyName(objectContextId);
        parseMethod(
          functionStart,
          /* isConstructor */
          false
        );
        return true;
      }
      return false;
    }
    function parseObjectProperty(isPattern, isBlockScope) {
      if (_index3.eat.call(void 0, _types3.TokenType.colon)) {
        if (isPattern) {
          _lval.parseMaybeDefault.call(void 0, isBlockScope);
        } else {
          parseMaybeAssign(false);
        }
        return;
      }
      let identifierRole;
      if (isPattern) {
        if (_base.state.scopeDepth === 0) {
          identifierRole = _index3.IdentifierRole.ObjectShorthandTopLevelDeclaration;
        } else if (isBlockScope) {
          identifierRole = _index3.IdentifierRole.ObjectShorthandBlockScopedDeclaration;
        } else {
          identifierRole = _index3.IdentifierRole.ObjectShorthandFunctionScopedDeclaration;
        }
      } else {
        identifierRole = _index3.IdentifierRole.ObjectShorthand;
      }
      _base.state.tokens[_base.state.tokens.length - 1].identifierRole = identifierRole;
      _lval.parseMaybeDefault.call(void 0, isBlockScope, true);
    }
    function parseObjPropValue(isPattern, isBlockScope, objectContextId) {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsStartParseObjPropValue.call(void 0);
      } else if (_base.isFlowEnabled) {
        _flow.flowStartParseObjPropValue.call(void 0);
      }
      const wasMethod = parseObjectMethod(isPattern, objectContextId);
      if (!wasMethod) {
        parseObjectProperty(isPattern, isBlockScope);
      }
    }
    function parsePropertyName(objectContextId) {
      if (_base.isFlowEnabled) {
        _flow.flowParseVariance.call(void 0);
      }
      if (_index3.eat.call(void 0, _types3.TokenType.bracketL)) {
        _base.state.tokens[_base.state.tokens.length - 1].contextId = objectContextId;
        parseMaybeAssign();
        _util.expect.call(void 0, _types3.TokenType.bracketR);
        _base.state.tokens[_base.state.tokens.length - 1].contextId = objectContextId;
      } else {
        if (_index3.match.call(void 0, _types3.TokenType.num) || _index3.match.call(void 0, _types3.TokenType.string) || _index3.match.call(void 0, _types3.TokenType.bigint) || _index3.match.call(void 0, _types3.TokenType.decimal)) {
          parseExprAtom();
        } else {
          parseMaybePrivateName();
        }
        _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index3.IdentifierRole.ObjectKey;
        _base.state.tokens[_base.state.tokens.length - 1].contextId = objectContextId;
      }
    }
    exports2.parsePropertyName = parsePropertyName;
    function parseMethod(functionStart, isConstructor) {
      const funcContextId = _base.getNextContextId.call(void 0);
      _base.state.scopeDepth++;
      const startTokenIndex = _base.state.tokens.length;
      const allowModifiers = isConstructor;
      _statement.parseFunctionParams.call(void 0, allowModifiers, funcContextId);
      parseFunctionBodyAndFinish(functionStart, funcContextId);
      const endTokenIndex = _base.state.tokens.length;
      _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, true));
      _base.state.scopeDepth--;
    }
    exports2.parseMethod = parseMethod;
    function parseArrowExpression(startTokenIndex) {
      parseFunctionBody(true);
      const endTokenIndex = _base.state.tokens.length;
      _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, true));
      _base.state.scopeDepth--;
    }
    exports2.parseArrowExpression = parseArrowExpression;
    function parseFunctionBodyAndFinish(functionStart, funcContextId = 0) {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsParseFunctionBodyAndFinish.call(void 0, functionStart, funcContextId);
      } else if (_base.isFlowEnabled) {
        _flow.flowParseFunctionBodyAndFinish.call(void 0, funcContextId);
      } else {
        parseFunctionBody(false, funcContextId);
      }
    }
    exports2.parseFunctionBodyAndFinish = parseFunctionBodyAndFinish;
    function parseFunctionBody(allowExpression, funcContextId = 0) {
      const isExpression = allowExpression && !_index3.match.call(void 0, _types3.TokenType.braceL);
      if (isExpression) {
        parseMaybeAssign();
      } else {
        _statement.parseBlock.call(void 0, true, funcContextId);
      }
    }
    exports2.parseFunctionBody = parseFunctionBody;
    function parseExprList(close, allowEmpty = false) {
      let first = true;
      while (!_index3.eat.call(void 0, close) && !_base.state.error) {
        if (first) {
          first = false;
        } else {
          _util.expect.call(void 0, _types3.TokenType.comma);
          if (_index3.eat.call(void 0, close)) break;
        }
        parseExprListItem(allowEmpty);
      }
    }
    function parseExprListItem(allowEmpty) {
      if (allowEmpty && _index3.match.call(void 0, _types3.TokenType.comma)) {
      } else if (_index3.match.call(void 0, _types3.TokenType.ellipsis)) {
        _lval.parseSpread.call(void 0);
        parseParenItem();
      } else if (_index3.match.call(void 0, _types3.TokenType.question)) {
        _index3.next.call(void 0);
      } else {
        parseMaybeAssign(false, true);
      }
    }
    function parseIdentifier() {
      _index3.next.call(void 0);
      _base.state.tokens[_base.state.tokens.length - 1].type = _types3.TokenType.name;
    }
    exports2.parseIdentifier = parseIdentifier;
    function parseAwait() {
      parseMaybeUnary();
    }
    function parseYield() {
      _index3.next.call(void 0);
      if (!_index3.match.call(void 0, _types3.TokenType.semi) && !_util.canInsertSemicolon.call(void 0)) {
        _index3.eat.call(void 0, _types3.TokenType.star);
        parseMaybeAssign();
      }
    }
    function parseModuleExpression() {
      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._module);
      _util.expect.call(void 0, _types3.TokenType.braceL);
      _statement.parseBlockBody.call(void 0, _types3.TokenType.braceR);
    }
  }
});

// node_modules/sucrase/dist/parser/plugins/flow.js
var require_flow = __commonJS({
  "node_modules/sucrase/dist/parser/plugins/flow.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _index = require_tokenizer2();
    var _keywords = require_keywords();
    var _types = require_types();
    var _base = require_base();
    var _expression = require_expression();
    var _statement = require_statement();
    var _util = require_util();
    function isMaybeDefaultImport(lookahead) {
      return (lookahead.type === _types.TokenType.name || !!(lookahead.type & _types.TokenType.IS_KEYWORD)) && lookahead.contextualKeyword !== _keywords.ContextualKeyword._from;
    }
    function flowParseTypeInitialiser(tok) {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      _util.expect.call(void 0, tok || _types.TokenType.colon);
      flowParseType();
      _index.popTypeContext.call(void 0, oldIsType);
    }
    function flowParsePredicate() {
      _util.expect.call(void 0, _types.TokenType.modulo);
      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._checks);
      if (_index.eat.call(void 0, _types.TokenType.parenL)) {
        _expression.parseExpression.call(void 0);
        _util.expect.call(void 0, _types.TokenType.parenR);
      }
    }
    function flowParseTypeAndPredicateInitialiser() {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      _util.expect.call(void 0, _types.TokenType.colon);
      if (_index.match.call(void 0, _types.TokenType.modulo)) {
        flowParsePredicate();
      } else {
        flowParseType();
        if (_index.match.call(void 0, _types.TokenType.modulo)) {
          flowParsePredicate();
        }
      }
      _index.popTypeContext.call(void 0, oldIsType);
    }
    function flowParseDeclareClass() {
      _index.next.call(void 0);
      flowParseInterfaceish(
        /* isClass */
        true
      );
    }
    function flowParseDeclareFunction() {
      _index.next.call(void 0);
      _expression.parseIdentifier.call(void 0);
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        flowParseTypeParameterDeclaration();
      }
      _util.expect.call(void 0, _types.TokenType.parenL);
      flowParseFunctionTypeParams();
      _util.expect.call(void 0, _types.TokenType.parenR);
      flowParseTypeAndPredicateInitialiser();
      _util.semicolon.call(void 0);
    }
    function flowParseDeclare() {
      if (_index.match.call(void 0, _types.TokenType._class)) {
        flowParseDeclareClass();
      } else if (_index.match.call(void 0, _types.TokenType._function)) {
        flowParseDeclareFunction();
      } else if (_index.match.call(void 0, _types.TokenType._var)) {
        flowParseDeclareVariable();
      } else if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._module)) {
        if (_index.eat.call(void 0, _types.TokenType.dot)) {
          flowParseDeclareModuleExports();
        } else {
          flowParseDeclareModule();
        }
      } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
        flowParseDeclareTypeAlias();
      } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque)) {
        flowParseDeclareOpaqueType();
      } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
        flowParseDeclareInterface();
      } else if (_index.match.call(void 0, _types.TokenType._export)) {
        flowParseDeclareExportDeclaration();
      } else {
        _util.unexpected.call(void 0);
      }
    }
    function flowParseDeclareVariable() {
      _index.next.call(void 0);
      flowParseTypeAnnotatableIdentifier();
      _util.semicolon.call(void 0);
    }
    function flowParseDeclareModule() {
      if (_index.match.call(void 0, _types.TokenType.string)) {
        _expression.parseExprAtom.call(void 0);
      } else {
        _expression.parseIdentifier.call(void 0);
      }
      _util.expect.call(void 0, _types.TokenType.braceL);
      while (!_index.match.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
        if (_index.match.call(void 0, _types.TokenType._import)) {
          _index.next.call(void 0);
          _statement.parseImport.call(void 0);
        } else {
          _util.unexpected.call(void 0);
        }
      }
      _util.expect.call(void 0, _types.TokenType.braceR);
    }
    function flowParseDeclareExportDeclaration() {
      _util.expect.call(void 0, _types.TokenType._export);
      if (_index.eat.call(void 0, _types.TokenType._default)) {
        if (_index.match.call(void 0, _types.TokenType._function) || _index.match.call(void 0, _types.TokenType._class)) {
          flowParseDeclare();
        } else {
          flowParseType();
          _util.semicolon.call(void 0);
        }
      } else if (_index.match.call(void 0, _types.TokenType._var) || // declare export var ...
      _index.match.call(void 0, _types.TokenType._function) || // declare export function ...
      _index.match.call(void 0, _types.TokenType._class) || // declare export class ...
      _util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque)) {
        flowParseDeclare();
      } else if (_index.match.call(void 0, _types.TokenType.star) || // declare export * from ''
      _index.match.call(void 0, _types.TokenType.braceL) || // declare export {} ...
      _util.isContextual.call(void 0, _keywords.ContextualKeyword._interface) || // declare export interface ...
      _util.isContextual.call(void 0, _keywords.ContextualKeyword._type) || // declare export type ...
      _util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque)) {
        _statement.parseExport.call(void 0);
      } else {
        _util.unexpected.call(void 0);
      }
    }
    function flowParseDeclareModuleExports() {
      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._exports);
      flowParseTypeAnnotation();
      _util.semicolon.call(void 0);
    }
    function flowParseDeclareTypeAlias() {
      _index.next.call(void 0);
      flowParseTypeAlias();
    }
    function flowParseDeclareOpaqueType() {
      _index.next.call(void 0);
      flowParseOpaqueType(true);
    }
    function flowParseDeclareInterface() {
      _index.next.call(void 0);
      flowParseInterfaceish();
    }
    function flowParseInterfaceish(isClass = false) {
      flowParseRestrictedIdentifier();
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        flowParseTypeParameterDeclaration();
      }
      if (_index.eat.call(void 0, _types.TokenType._extends)) {
        do {
          flowParseInterfaceExtends();
        } while (!isClass && _index.eat.call(void 0, _types.TokenType.comma));
      }
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._mixins)) {
        _index.next.call(void 0);
        do {
          flowParseInterfaceExtends();
        } while (_index.eat.call(void 0, _types.TokenType.comma));
      }
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._implements)) {
        _index.next.call(void 0);
        do {
          flowParseInterfaceExtends();
        } while (_index.eat.call(void 0, _types.TokenType.comma));
      }
      flowParseObjectType(isClass, false, isClass);
    }
    function flowParseInterfaceExtends() {
      flowParseQualifiedTypeIdentifier(false);
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        flowParseTypeParameterInstantiation();
      }
    }
    function flowParseInterface() {
      flowParseInterfaceish();
    }
    function flowParseRestrictedIdentifier() {
      _expression.parseIdentifier.call(void 0);
    }
    function flowParseTypeAlias() {
      flowParseRestrictedIdentifier();
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        flowParseTypeParameterDeclaration();
      }
      flowParseTypeInitialiser(_types.TokenType.eq);
      _util.semicolon.call(void 0);
    }
    function flowParseOpaqueType(declare) {
      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._type);
      flowParseRestrictedIdentifier();
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        flowParseTypeParameterDeclaration();
      }
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        flowParseTypeInitialiser(_types.TokenType.colon);
      }
      if (!declare) {
        flowParseTypeInitialiser(_types.TokenType.eq);
      }
      _util.semicolon.call(void 0);
    }
    function flowParseTypeParameter() {
      flowParseVariance();
      flowParseTypeAnnotatableIdentifier();
      if (_index.eat.call(void 0, _types.TokenType.eq)) {
        flowParseType();
      }
    }
    function flowParseTypeParameterDeclaration() {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.typeParameterStart)) {
        _index.next.call(void 0);
      } else {
        _util.unexpected.call(void 0);
      }
      do {
        flowParseTypeParameter();
        if (!_index.match.call(void 0, _types.TokenType.greaterThan)) {
          _util.expect.call(void 0, _types.TokenType.comma);
        }
      } while (!_index.match.call(void 0, _types.TokenType.greaterThan) && !_base.state.error);
      _util.expect.call(void 0, _types.TokenType.greaterThan);
      _index.popTypeContext.call(void 0, oldIsType);
    }
    exports2.flowParseTypeParameterDeclaration = flowParseTypeParameterDeclaration;
    function flowParseTypeParameterInstantiation() {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      _util.expect.call(void 0, _types.TokenType.lessThan);
      while (!_index.match.call(void 0, _types.TokenType.greaterThan) && !_base.state.error) {
        flowParseType();
        if (!_index.match.call(void 0, _types.TokenType.greaterThan)) {
          _util.expect.call(void 0, _types.TokenType.comma);
        }
      }
      _util.expect.call(void 0, _types.TokenType.greaterThan);
      _index.popTypeContext.call(void 0, oldIsType);
    }
    function flowParseInterfaceType() {
      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._interface);
      if (_index.eat.call(void 0, _types.TokenType._extends)) {
        do {
          flowParseInterfaceExtends();
        } while (_index.eat.call(void 0, _types.TokenType.comma));
      }
      flowParseObjectType(false, false, false);
    }
    function flowParseObjectPropertyKey() {
      if (_index.match.call(void 0, _types.TokenType.num) || _index.match.call(void 0, _types.TokenType.string)) {
        _expression.parseExprAtom.call(void 0);
      } else {
        _expression.parseIdentifier.call(void 0);
      }
    }
    function flowParseObjectTypeIndexer() {
      if (_index.lookaheadType.call(void 0) === _types.TokenType.colon) {
        flowParseObjectPropertyKey();
        flowParseTypeInitialiser();
      } else {
        flowParseType();
      }
      _util.expect.call(void 0, _types.TokenType.bracketR);
      flowParseTypeInitialiser();
    }
    function flowParseObjectTypeInternalSlot() {
      flowParseObjectPropertyKey();
      _util.expect.call(void 0, _types.TokenType.bracketR);
      _util.expect.call(void 0, _types.TokenType.bracketR);
      if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.parenL)) {
        flowParseObjectTypeMethodish();
      } else {
        _index.eat.call(void 0, _types.TokenType.question);
        flowParseTypeInitialiser();
      }
    }
    function flowParseObjectTypeMethodish() {
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        flowParseTypeParameterDeclaration();
      }
      _util.expect.call(void 0, _types.TokenType.parenL);
      while (!_index.match.call(void 0, _types.TokenType.parenR) && !_index.match.call(void 0, _types.TokenType.ellipsis) && !_base.state.error) {
        flowParseFunctionTypeParam();
        if (!_index.match.call(void 0, _types.TokenType.parenR)) {
          _util.expect.call(void 0, _types.TokenType.comma);
        }
      }
      if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
        flowParseFunctionTypeParam();
      }
      _util.expect.call(void 0, _types.TokenType.parenR);
      flowParseTypeInitialiser();
    }
    function flowParseObjectTypeCallProperty() {
      flowParseObjectTypeMethodish();
    }
    function flowParseObjectType(allowStatic, allowExact, allowProto) {
      let endDelim;
      if (allowExact && _index.match.call(void 0, _types.TokenType.braceBarL)) {
        _util.expect.call(void 0, _types.TokenType.braceBarL);
        endDelim = _types.TokenType.braceBarR;
      } else {
        _util.expect.call(void 0, _types.TokenType.braceL);
        endDelim = _types.TokenType.braceR;
      }
      while (!_index.match.call(void 0, endDelim) && !_base.state.error) {
        if (allowProto && _util.isContextual.call(void 0, _keywords.ContextualKeyword._proto)) {
          const lookahead = _index.lookaheadType.call(void 0);
          if (lookahead !== _types.TokenType.colon && lookahead !== _types.TokenType.question) {
            _index.next.call(void 0);
            allowStatic = false;
          }
        }
        if (allowStatic && _util.isContextual.call(void 0, _keywords.ContextualKeyword._static)) {
          const lookahead = _index.lookaheadType.call(void 0);
          if (lookahead !== _types.TokenType.colon && lookahead !== _types.TokenType.question) {
            _index.next.call(void 0);
          }
        }
        flowParseVariance();
        if (_index.eat.call(void 0, _types.TokenType.bracketL)) {
          if (_index.eat.call(void 0, _types.TokenType.bracketL)) {
            flowParseObjectTypeInternalSlot();
          } else {
            flowParseObjectTypeIndexer();
          }
        } else if (_index.match.call(void 0, _types.TokenType.parenL) || _index.match.call(void 0, _types.TokenType.lessThan)) {
          flowParseObjectTypeCallProperty();
        } else {
          if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._get) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._set)) {
            const lookahead = _index.lookaheadType.call(void 0);
            if (lookahead === _types.TokenType.name || lookahead === _types.TokenType.string || lookahead === _types.TokenType.num) {
              _index.next.call(void 0);
            }
          }
          flowParseObjectTypeProperty();
        }
        flowObjectTypeSemicolon();
      }
      _util.expect.call(void 0, endDelim);
    }
    function flowParseObjectTypeProperty() {
      if (_index.match.call(void 0, _types.TokenType.ellipsis)) {
        _util.expect.call(void 0, _types.TokenType.ellipsis);
        if (!_index.eat.call(void 0, _types.TokenType.comma)) {
          _index.eat.call(void 0, _types.TokenType.semi);
        }
        if (_index.match.call(void 0, _types.TokenType.braceR)) {
          return;
        }
        flowParseType();
      } else {
        flowParseObjectPropertyKey();
        if (_index.match.call(void 0, _types.TokenType.lessThan) || _index.match.call(void 0, _types.TokenType.parenL)) {
          flowParseObjectTypeMethodish();
        } else {
          _index.eat.call(void 0, _types.TokenType.question);
          flowParseTypeInitialiser();
        }
      }
    }
    function flowObjectTypeSemicolon() {
      if (!_index.eat.call(void 0, _types.TokenType.semi) && !_index.eat.call(void 0, _types.TokenType.comma) && !_index.match.call(void 0, _types.TokenType.braceR) && !_index.match.call(void 0, _types.TokenType.braceBarR)) {
        _util.unexpected.call(void 0);
      }
    }
    function flowParseQualifiedTypeIdentifier(initialIdAlreadyParsed) {
      if (!initialIdAlreadyParsed) {
        _expression.parseIdentifier.call(void 0);
      }
      while (_index.eat.call(void 0, _types.TokenType.dot)) {
        _expression.parseIdentifier.call(void 0);
      }
    }
    function flowParseGenericType() {
      flowParseQualifiedTypeIdentifier(true);
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        flowParseTypeParameterInstantiation();
      }
    }
    function flowParseTypeofType() {
      _util.expect.call(void 0, _types.TokenType._typeof);
      flowParsePrimaryType();
    }
    function flowParseTupleType() {
      _util.expect.call(void 0, _types.TokenType.bracketL);
      while (_base.state.pos < _base.input.length && !_index.match.call(void 0, _types.TokenType.bracketR)) {
        flowParseType();
        if (_index.match.call(void 0, _types.TokenType.bracketR)) {
          break;
        }
        _util.expect.call(void 0, _types.TokenType.comma);
      }
      _util.expect.call(void 0, _types.TokenType.bracketR);
    }
    function flowParseFunctionTypeParam() {
      const lookahead = _index.lookaheadType.call(void 0);
      if (lookahead === _types.TokenType.colon || lookahead === _types.TokenType.question) {
        _expression.parseIdentifier.call(void 0);
        _index.eat.call(void 0, _types.TokenType.question);
        flowParseTypeInitialiser();
      } else {
        flowParseType();
      }
    }
    function flowParseFunctionTypeParams() {
      while (!_index.match.call(void 0, _types.TokenType.parenR) && !_index.match.call(void 0, _types.TokenType.ellipsis) && !_base.state.error) {
        flowParseFunctionTypeParam();
        if (!_index.match.call(void 0, _types.TokenType.parenR)) {
          _util.expect.call(void 0, _types.TokenType.comma);
        }
      }
      if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
        flowParseFunctionTypeParam();
      }
    }
    function flowParsePrimaryType() {
      let isGroupedType = false;
      const oldNoAnonFunctionType = _base.state.noAnonFunctionType;
      switch (_base.state.type) {
        case _types.TokenType.name: {
          if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
            flowParseInterfaceType();
            return;
          }
          _expression.parseIdentifier.call(void 0);
          flowParseGenericType();
          return;
        }
        case _types.TokenType.braceL:
          flowParseObjectType(false, false, false);
          return;
        case _types.TokenType.braceBarL:
          flowParseObjectType(false, true, false);
          return;
        case _types.TokenType.bracketL:
          flowParseTupleType();
          return;
        case _types.TokenType.lessThan:
          flowParseTypeParameterDeclaration();
          _util.expect.call(void 0, _types.TokenType.parenL);
          flowParseFunctionTypeParams();
          _util.expect.call(void 0, _types.TokenType.parenR);
          _util.expect.call(void 0, _types.TokenType.arrow);
          flowParseType();
          return;
        case _types.TokenType.parenL:
          _index.next.call(void 0);
          if (!_index.match.call(void 0, _types.TokenType.parenR) && !_index.match.call(void 0, _types.TokenType.ellipsis)) {
            if (_index.match.call(void 0, _types.TokenType.name)) {
              const token = _index.lookaheadType.call(void 0);
              isGroupedType = token !== _types.TokenType.question && token !== _types.TokenType.colon;
            } else {
              isGroupedType = true;
            }
          }
          if (isGroupedType) {
            _base.state.noAnonFunctionType = false;
            flowParseType();
            _base.state.noAnonFunctionType = oldNoAnonFunctionType;
            if (_base.state.noAnonFunctionType || !(_index.match.call(void 0, _types.TokenType.comma) || _index.match.call(void 0, _types.TokenType.parenR) && _index.lookaheadType.call(void 0) === _types.TokenType.arrow)) {
              _util.expect.call(void 0, _types.TokenType.parenR);
              return;
            } else {
              _index.eat.call(void 0, _types.TokenType.comma);
            }
          }
          flowParseFunctionTypeParams();
          _util.expect.call(void 0, _types.TokenType.parenR);
          _util.expect.call(void 0, _types.TokenType.arrow);
          flowParseType();
          return;
        case _types.TokenType.minus:
          _index.next.call(void 0);
          _expression.parseLiteral.call(void 0);
          return;
        case _types.TokenType.string:
        case _types.TokenType.num:
        case _types.TokenType._true:
        case _types.TokenType._false:
        case _types.TokenType._null:
        case _types.TokenType._this:
        case _types.TokenType._void:
        case _types.TokenType.star:
          _index.next.call(void 0);
          return;
        default:
          if (_base.state.type === _types.TokenType._typeof) {
            flowParseTypeofType();
            return;
          } else if (_base.state.type & _types.TokenType.IS_KEYWORD) {
            _index.next.call(void 0);
            _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType.name;
            return;
          }
      }
      _util.unexpected.call(void 0);
    }
    function flowParsePostfixType() {
      flowParsePrimaryType();
      while (!_util.canInsertSemicolon.call(void 0) && (_index.match.call(void 0, _types.TokenType.bracketL) || _index.match.call(void 0, _types.TokenType.questionDot))) {
        _index.eat.call(void 0, _types.TokenType.questionDot);
        _util.expect.call(void 0, _types.TokenType.bracketL);
        if (_index.eat.call(void 0, _types.TokenType.bracketR)) {
        } else {
          flowParseType();
          _util.expect.call(void 0, _types.TokenType.bracketR);
        }
      }
    }
    function flowParsePrefixType() {
      if (_index.eat.call(void 0, _types.TokenType.question)) {
        flowParsePrefixType();
      } else {
        flowParsePostfixType();
      }
    }
    function flowParseAnonFunctionWithoutParens() {
      flowParsePrefixType();
      if (!_base.state.noAnonFunctionType && _index.eat.call(void 0, _types.TokenType.arrow)) {
        flowParseType();
      }
    }
    function flowParseIntersectionType() {
      _index.eat.call(void 0, _types.TokenType.bitwiseAND);
      flowParseAnonFunctionWithoutParens();
      while (_index.eat.call(void 0, _types.TokenType.bitwiseAND)) {
        flowParseAnonFunctionWithoutParens();
      }
    }
    function flowParseUnionType() {
      _index.eat.call(void 0, _types.TokenType.bitwiseOR);
      flowParseIntersectionType();
      while (_index.eat.call(void 0, _types.TokenType.bitwiseOR)) {
        flowParseIntersectionType();
      }
    }
    function flowParseType() {
      flowParseUnionType();
    }
    function flowParseTypeAnnotation() {
      flowParseTypeInitialiser();
    }
    exports2.flowParseTypeAnnotation = flowParseTypeAnnotation;
    function flowParseTypeAnnotatableIdentifier() {
      _expression.parseIdentifier.call(void 0);
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        flowParseTypeAnnotation();
      }
    }
    function flowParseVariance() {
      if (_index.match.call(void 0, _types.TokenType.plus) || _index.match.call(void 0, _types.TokenType.minus)) {
        _index.next.call(void 0);
        _base.state.tokens[_base.state.tokens.length - 1].isType = true;
      }
    }
    exports2.flowParseVariance = flowParseVariance;
    function flowParseFunctionBodyAndFinish(funcContextId) {
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        flowParseTypeAndPredicateInitialiser();
      }
      _expression.parseFunctionBody.call(void 0, false, funcContextId);
    }
    exports2.flowParseFunctionBodyAndFinish = flowParseFunctionBodyAndFinish;
    function flowParseSubscript(startTokenIndex, noCalls, stopState) {
      if (_index.match.call(void 0, _types.TokenType.questionDot) && _index.lookaheadType.call(void 0) === _types.TokenType.lessThan) {
        if (noCalls) {
          stopState.stop = true;
          return;
        }
        _index.next.call(void 0);
        flowParseTypeParameterInstantiation();
        _util.expect.call(void 0, _types.TokenType.parenL);
        _expression.parseCallExpressionArguments.call(void 0);
        return;
      } else if (!noCalls && _index.match.call(void 0, _types.TokenType.lessThan)) {
        const snapshot = _base.state.snapshot();
        flowParseTypeParameterInstantiation();
        _util.expect.call(void 0, _types.TokenType.parenL);
        _expression.parseCallExpressionArguments.call(void 0);
        if (_base.state.error) {
          _base.state.restoreFromSnapshot(snapshot);
        } else {
          return;
        }
      }
      _expression.baseParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
    }
    exports2.flowParseSubscript = flowParseSubscript;
    function flowStartParseNewArguments() {
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        const snapshot = _base.state.snapshot();
        flowParseTypeParameterInstantiation();
        if (_base.state.error) {
          _base.state.restoreFromSnapshot(snapshot);
        }
      }
    }
    exports2.flowStartParseNewArguments = flowStartParseNewArguments;
    function flowTryParseStatement() {
      if (_index.match.call(void 0, _types.TokenType.name) && _base.state.contextualKeyword === _keywords.ContextualKeyword._interface) {
        const oldIsType = _index.pushTypeContext.call(void 0, 0);
        _index.next.call(void 0);
        flowParseInterface();
        _index.popTypeContext.call(void 0, oldIsType);
        return true;
      } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._enum)) {
        flowParseEnumDeclaration();
        return true;
      }
      return false;
    }
    exports2.flowTryParseStatement = flowTryParseStatement;
    function flowTryParseExportDefaultExpression() {
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._enum)) {
        flowParseEnumDeclaration();
        return true;
      }
      return false;
    }
    exports2.flowTryParseExportDefaultExpression = flowTryParseExportDefaultExpression;
    function flowParseIdentifierStatement(contextualKeyword) {
      if (contextualKeyword === _keywords.ContextualKeyword._declare) {
        if (_index.match.call(void 0, _types.TokenType._class) || _index.match.call(void 0, _types.TokenType.name) || _index.match.call(void 0, _types.TokenType._function) || _index.match.call(void 0, _types.TokenType._var) || _index.match.call(void 0, _types.TokenType._export)) {
          const oldIsType = _index.pushTypeContext.call(void 0, 1);
          flowParseDeclare();
          _index.popTypeContext.call(void 0, oldIsType);
        }
      } else if (_index.match.call(void 0, _types.TokenType.name)) {
        if (contextualKeyword === _keywords.ContextualKeyword._interface) {
          const oldIsType = _index.pushTypeContext.call(void 0, 1);
          flowParseInterface();
          _index.popTypeContext.call(void 0, oldIsType);
        } else if (contextualKeyword === _keywords.ContextualKeyword._type) {
          const oldIsType = _index.pushTypeContext.call(void 0, 1);
          flowParseTypeAlias();
          _index.popTypeContext.call(void 0, oldIsType);
        } else if (contextualKeyword === _keywords.ContextualKeyword._opaque) {
          const oldIsType = _index.pushTypeContext.call(void 0, 1);
          flowParseOpaqueType(false);
          _index.popTypeContext.call(void 0, oldIsType);
        }
      }
      _util.semicolon.call(void 0);
    }
    exports2.flowParseIdentifierStatement = flowParseIdentifierStatement;
    function flowShouldParseExportDeclaration() {
      return _util.isContextual.call(void 0, _keywords.ContextualKeyword._type) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._interface) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._enum);
    }
    exports2.flowShouldParseExportDeclaration = flowShouldParseExportDeclaration;
    function flowShouldDisallowExportDefaultSpecifier() {
      return _index.match.call(void 0, _types.TokenType.name) && (_base.state.contextualKeyword === _keywords.ContextualKeyword._type || _base.state.contextualKeyword === _keywords.ContextualKeyword._interface || _base.state.contextualKeyword === _keywords.ContextualKeyword._opaque || _base.state.contextualKeyword === _keywords.ContextualKeyword._enum);
    }
    exports2.flowShouldDisallowExportDefaultSpecifier = flowShouldDisallowExportDefaultSpecifier;
    function flowParseExportDeclaration() {
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
        const oldIsType = _index.pushTypeContext.call(void 0, 1);
        _index.next.call(void 0);
        if (_index.match.call(void 0, _types.TokenType.braceL)) {
          _statement.parseExportSpecifiers.call(void 0);
          _statement.parseExportFrom.call(void 0);
        } else {
          flowParseTypeAlias();
        }
        _index.popTypeContext.call(void 0, oldIsType);
      } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._opaque)) {
        const oldIsType = _index.pushTypeContext.call(void 0, 1);
        _index.next.call(void 0);
        flowParseOpaqueType(false);
        _index.popTypeContext.call(void 0, oldIsType);
      } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._interface)) {
        const oldIsType = _index.pushTypeContext.call(void 0, 1);
        _index.next.call(void 0);
        flowParseInterface();
        _index.popTypeContext.call(void 0, oldIsType);
      } else {
        _statement.parseStatement.call(void 0, true);
      }
    }
    exports2.flowParseExportDeclaration = flowParseExportDeclaration;
    function flowShouldParseExportStar() {
      return _index.match.call(void 0, _types.TokenType.star) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._type) && _index.lookaheadType.call(void 0) === _types.TokenType.star;
    }
    exports2.flowShouldParseExportStar = flowShouldParseExportStar;
    function flowParseExportStar() {
      if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._type)) {
        const oldIsType = _index.pushTypeContext.call(void 0, 2);
        _statement.baseParseExportStar.call(void 0);
        _index.popTypeContext.call(void 0, oldIsType);
      } else {
        _statement.baseParseExportStar.call(void 0);
      }
    }
    exports2.flowParseExportStar = flowParseExportStar;
    function flowAfterParseClassSuper(hasSuper) {
      if (hasSuper && _index.match.call(void 0, _types.TokenType.lessThan)) {
        flowParseTypeParameterInstantiation();
      }
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._implements)) {
        const oldIsType = _index.pushTypeContext.call(void 0, 0);
        _index.next.call(void 0);
        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._implements;
        do {
          flowParseRestrictedIdentifier();
          if (_index.match.call(void 0, _types.TokenType.lessThan)) {
            flowParseTypeParameterInstantiation();
          }
        } while (_index.eat.call(void 0, _types.TokenType.comma));
        _index.popTypeContext.call(void 0, oldIsType);
      }
    }
    exports2.flowAfterParseClassSuper = flowAfterParseClassSuper;
    function flowStartParseObjPropValue() {
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        flowParseTypeParameterDeclaration();
        if (!_index.match.call(void 0, _types.TokenType.parenL)) _util.unexpected.call(void 0);
      }
    }
    exports2.flowStartParseObjPropValue = flowStartParseObjPropValue;
    function flowParseAssignableListItemTypes() {
      const oldIsType = _index.pushTypeContext.call(void 0, 0);
      _index.eat.call(void 0, _types.TokenType.question);
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        flowParseTypeAnnotation();
      }
      _index.popTypeContext.call(void 0, oldIsType);
    }
    exports2.flowParseAssignableListItemTypes = flowParseAssignableListItemTypes;
    function flowStartParseImportSpecifiers() {
      if (_index.match.call(void 0, _types.TokenType._typeof) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
        const lh = _index.lookaheadTypeAndKeyword.call(void 0);
        if (isMaybeDefaultImport(lh) || lh.type === _types.TokenType.braceL || lh.type === _types.TokenType.star) {
          _index.next.call(void 0);
        }
      }
    }
    exports2.flowStartParseImportSpecifiers = flowStartParseImportSpecifiers;
    function flowParseImportSpecifier() {
      const isTypeKeyword = _base.state.contextualKeyword === _keywords.ContextualKeyword._type || _base.state.type === _types.TokenType._typeof;
      if (isTypeKeyword) {
        _index.next.call(void 0);
      } else {
        _expression.parseIdentifier.call(void 0);
      }
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._as) && !_util.isLookaheadContextual.call(void 0, _keywords.ContextualKeyword._as)) {
        _expression.parseIdentifier.call(void 0);
        if (isTypeKeyword && !_index.match.call(void 0, _types.TokenType.name) && !(_base.state.type & _types.TokenType.IS_KEYWORD)) {
        } else {
          _expression.parseIdentifier.call(void 0);
        }
      } else {
        if (isTypeKeyword && (_index.match.call(void 0, _types.TokenType.name) || !!(_base.state.type & _types.TokenType.IS_KEYWORD))) {
          _expression.parseIdentifier.call(void 0);
        }
        if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as)) {
          _expression.parseIdentifier.call(void 0);
        }
      }
    }
    exports2.flowParseImportSpecifier = flowParseImportSpecifier;
    function flowStartParseFunctionParams() {
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        const oldIsType = _index.pushTypeContext.call(void 0, 0);
        flowParseTypeParameterDeclaration();
        _index.popTypeContext.call(void 0, oldIsType);
      }
    }
    exports2.flowStartParseFunctionParams = flowStartParseFunctionParams;
    function flowAfterParseVarHead() {
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        flowParseTypeAnnotation();
      }
    }
    exports2.flowAfterParseVarHead = flowAfterParseVarHead;
    function flowStartParseAsyncArrowFromCallExpression() {
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        const oldNoAnonFunctionType = _base.state.noAnonFunctionType;
        _base.state.noAnonFunctionType = true;
        flowParseTypeAnnotation();
        _base.state.noAnonFunctionType = oldNoAnonFunctionType;
      }
    }
    exports2.flowStartParseAsyncArrowFromCallExpression = flowStartParseAsyncArrowFromCallExpression;
    function flowParseMaybeAssign(noIn, isWithinParens) {
      if (_index.match.call(void 0, _types.TokenType.lessThan)) {
        const snapshot = _base.state.snapshot();
        let wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
        if (_base.state.error) {
          _base.state.restoreFromSnapshot(snapshot);
          _base.state.type = _types.TokenType.typeParameterStart;
        } else {
          return wasArrow;
        }
        const oldIsType = _index.pushTypeContext.call(void 0, 0);
        flowParseTypeParameterDeclaration();
        _index.popTypeContext.call(void 0, oldIsType);
        wasArrow = _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
        if (wasArrow) {
          return true;
        }
        _util.unexpected.call(void 0);
      }
      return _expression.baseParseMaybeAssign.call(void 0, noIn, isWithinParens);
    }
    exports2.flowParseMaybeAssign = flowParseMaybeAssign;
    function flowParseArrow() {
      if (_index.match.call(void 0, _types.TokenType.colon)) {
        const oldIsType = _index.pushTypeContext.call(void 0, 0);
        const snapshot = _base.state.snapshot();
        const oldNoAnonFunctionType = _base.state.noAnonFunctionType;
        _base.state.noAnonFunctionType = true;
        flowParseTypeAndPredicateInitialiser();
        _base.state.noAnonFunctionType = oldNoAnonFunctionType;
        if (_util.canInsertSemicolon.call(void 0)) _util.unexpected.call(void 0);
        if (!_index.match.call(void 0, _types.TokenType.arrow)) _util.unexpected.call(void 0);
        if (_base.state.error) {
          _base.state.restoreFromSnapshot(snapshot);
        }
        _index.popTypeContext.call(void 0, oldIsType);
      }
      return _index.eat.call(void 0, _types.TokenType.arrow);
    }
    exports2.flowParseArrow = flowParseArrow;
    function flowParseSubscripts(startTokenIndex, noCalls = false) {
      if (_base.state.tokens[_base.state.tokens.length - 1].contextualKeyword === _keywords.ContextualKeyword._async && _index.match.call(void 0, _types.TokenType.lessThan)) {
        const snapshot = _base.state.snapshot();
        const wasArrow = parseAsyncArrowWithTypeParameters();
        if (wasArrow && !_base.state.error) {
          return;
        }
        _base.state.restoreFromSnapshot(snapshot);
      }
      _expression.baseParseSubscripts.call(void 0, startTokenIndex, noCalls);
    }
    exports2.flowParseSubscripts = flowParseSubscripts;
    function parseAsyncArrowWithTypeParameters() {
      _base.state.scopeDepth++;
      const startTokenIndex = _base.state.tokens.length;
      _statement.parseFunctionParams.call(void 0);
      if (!_expression.parseArrow.call(void 0)) {
        return false;
      }
      _expression.parseArrowExpression.call(void 0, startTokenIndex);
      return true;
    }
    function flowParseEnumDeclaration() {
      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._enum);
      _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._enum;
      _expression.parseIdentifier.call(void 0);
      flowParseEnumBody();
    }
    function flowParseEnumBody() {
      if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._of)) {
        _index.next.call(void 0);
      }
      _util.expect.call(void 0, _types.TokenType.braceL);
      flowParseEnumMembers();
      _util.expect.call(void 0, _types.TokenType.braceR);
    }
    function flowParseEnumMembers() {
      while (!_index.match.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
        if (_index.eat.call(void 0, _types.TokenType.ellipsis)) {
          break;
        }
        flowParseEnumMember();
        if (!_index.match.call(void 0, _types.TokenType.braceR)) {
          _util.expect.call(void 0, _types.TokenType.comma);
        }
      }
    }
    function flowParseEnumMember() {
      _expression.parseIdentifier.call(void 0);
      if (_index.eat.call(void 0, _types.TokenType.eq)) {
        _index.next.call(void 0);
      }
    }
  }
});

// node_modules/sucrase/dist/parser/traverser/statement.js
var require_statement = __commonJS({
  "node_modules/sucrase/dist/parser/traverser/statement.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _index = require_parser2();
    var _flow = require_flow();
    var _typescript = require_typescript();
    var _tokenizer = require_tokenizer2();
    var _keywords = require_keywords();
    var _state = require_state();
    var _types = require_types();
    var _charcodes = require_charcodes();
    var _base = require_base();
    var _expression = require_expression();
    var _lval = require_lval();
    var _util = require_util();
    function parseTopLevel() {
      parseBlockBody(_types.TokenType.eof);
      _base.state.scopes.push(new (0, _state.Scope)(0, _base.state.tokens.length, true));
      if (_base.state.scopeDepth !== 0) {
        throw new Error(`Invalid scope depth at end of file: ${_base.state.scopeDepth}`);
      }
      return new (0, _index.File)(_base.state.tokens, _base.state.scopes);
    }
    exports2.parseTopLevel = parseTopLevel;
    function parseStatement(declaration) {
      if (_base.isFlowEnabled) {
        if (_flow.flowTryParseStatement.call(void 0)) {
          return;
        }
      }
      if (_tokenizer.match.call(void 0, _types.TokenType.at)) {
        parseDecorators();
      }
      parseStatementContent(declaration);
    }
    exports2.parseStatement = parseStatement;
    function parseStatementContent(declaration) {
      if (_base.isTypeScriptEnabled) {
        if (_typescript.tsTryParseStatementContent.call(void 0)) {
          return;
        }
      }
      const starttype = _base.state.type;
      switch (starttype) {
        case _types.TokenType._break:
        case _types.TokenType._continue:
          parseBreakContinueStatement();
          return;
        case _types.TokenType._debugger:
          parseDebuggerStatement();
          return;
        case _types.TokenType._do:
          parseDoStatement();
          return;
        case _types.TokenType._for:
          parseForStatement();
          return;
        case _types.TokenType._function:
          if (_tokenizer.lookaheadType.call(void 0) === _types.TokenType.dot) break;
          if (!declaration) _util.unexpected.call(void 0);
          parseFunctionStatement();
          return;
        case _types.TokenType._class:
          if (!declaration) _util.unexpected.call(void 0);
          parseClass(true);
          return;
        case _types.TokenType._if:
          parseIfStatement();
          return;
        case _types.TokenType._return:
          parseReturnStatement();
          return;
        case _types.TokenType._switch:
          parseSwitchStatement();
          return;
        case _types.TokenType._throw:
          parseThrowStatement();
          return;
        case _types.TokenType._try:
          parseTryStatement();
          return;
        case _types.TokenType._let:
        case _types.TokenType._const:
          if (!declaration) _util.unexpected.call(void 0);
        // NOTE: falls through to _var
        case _types.TokenType._var:
          parseVarStatement(starttype !== _types.TokenType._var);
          return;
        case _types.TokenType._while:
          parseWhileStatement();
          return;
        case _types.TokenType.braceL:
          parseBlock();
          return;
        case _types.TokenType.semi:
          parseEmptyStatement();
          return;
        case _types.TokenType._export:
        case _types.TokenType._import: {
          const nextType = _tokenizer.lookaheadType.call(void 0);
          if (nextType === _types.TokenType.parenL || nextType === _types.TokenType.dot) {
            break;
          }
          _tokenizer.next.call(void 0);
          if (starttype === _types.TokenType._import) {
            parseImport();
          } else {
            parseExport();
          }
          return;
        }
        case _types.TokenType.name:
          if (_base.state.contextualKeyword === _keywords.ContextualKeyword._async) {
            const functionStart = _base.state.start;
            const snapshot = _base.state.snapshot();
            _tokenizer.next.call(void 0);
            if (_tokenizer.match.call(void 0, _types.TokenType._function) && !_util.canInsertSemicolon.call(void 0)) {
              _util.expect.call(void 0, _types.TokenType._function);
              parseFunction(functionStart, true);
              return;
            } else {
              _base.state.restoreFromSnapshot(snapshot);
            }
          } else if (_base.state.contextualKeyword === _keywords.ContextualKeyword._using && !_util.hasFollowingLineBreak.call(void 0) && // Statements like `using[0]` and `using in foo` aren't actual using
          // declarations.
          _tokenizer.lookaheadType.call(void 0) === _types.TokenType.name) {
            parseVarStatement(true);
            return;
          } else if (startsAwaitUsing()) {
            _util.expectContextual.call(void 0, _keywords.ContextualKeyword._await);
            parseVarStatement(true);
            return;
          }
        default:
          break;
      }
      const initialTokensLength = _base.state.tokens.length;
      _expression.parseExpression.call(void 0);
      let simpleName = null;
      if (_base.state.tokens.length === initialTokensLength + 1) {
        const token = _base.state.tokens[_base.state.tokens.length - 1];
        if (token.type === _types.TokenType.name) {
          simpleName = token.contextualKeyword;
        }
      }
      if (simpleName == null) {
        _util.semicolon.call(void 0);
        return;
      }
      if (_tokenizer.eat.call(void 0, _types.TokenType.colon)) {
        parseLabeledStatement();
      } else {
        parseIdentifierStatement(simpleName);
      }
    }
    function startsAwaitUsing() {
      if (!_util.isContextual.call(void 0, _keywords.ContextualKeyword._await)) {
        return false;
      }
      const snapshot = _base.state.snapshot();
      _tokenizer.next.call(void 0);
      if (!_util.isContextual.call(void 0, _keywords.ContextualKeyword._using) || _util.hasPrecedingLineBreak.call(void 0)) {
        _base.state.restoreFromSnapshot(snapshot);
        return false;
      }
      _tokenizer.next.call(void 0);
      if (!_tokenizer.match.call(void 0, _types.TokenType.name) || _util.hasPrecedingLineBreak.call(void 0)) {
        _base.state.restoreFromSnapshot(snapshot);
        return false;
      }
      _base.state.restoreFromSnapshot(snapshot);
      return true;
    }
    function parseDecorators() {
      while (_tokenizer.match.call(void 0, _types.TokenType.at)) {
        parseDecorator();
      }
    }
    exports2.parseDecorators = parseDecorators;
    function parseDecorator() {
      _tokenizer.next.call(void 0);
      if (_tokenizer.eat.call(void 0, _types.TokenType.parenL)) {
        _expression.parseExpression.call(void 0);
        _util.expect.call(void 0, _types.TokenType.parenR);
      } else {
        _expression.parseIdentifier.call(void 0);
        while (_tokenizer.eat.call(void 0, _types.TokenType.dot)) {
          _expression.parseIdentifier.call(void 0);
        }
        parseMaybeDecoratorArguments();
      }
    }
    function parseMaybeDecoratorArguments() {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsParseMaybeDecoratorArguments.call(void 0);
      } else {
        baseParseMaybeDecoratorArguments();
      }
    }
    function baseParseMaybeDecoratorArguments() {
      if (_tokenizer.eat.call(void 0, _types.TokenType.parenL)) {
        _expression.parseCallExpressionArguments.call(void 0);
      }
    }
    exports2.baseParseMaybeDecoratorArguments = baseParseMaybeDecoratorArguments;
    function parseBreakContinueStatement() {
      _tokenizer.next.call(void 0);
      if (!_util.isLineTerminator.call(void 0)) {
        _expression.parseIdentifier.call(void 0);
        _util.semicolon.call(void 0);
      }
    }
    function parseDebuggerStatement() {
      _tokenizer.next.call(void 0);
      _util.semicolon.call(void 0);
    }
    function parseDoStatement() {
      _tokenizer.next.call(void 0);
      parseStatement(false);
      _util.expect.call(void 0, _types.TokenType._while);
      _expression.parseParenExpression.call(void 0);
      _tokenizer.eat.call(void 0, _types.TokenType.semi);
    }
    function parseForStatement() {
      _base.state.scopeDepth++;
      const startTokenIndex = _base.state.tokens.length;
      parseAmbiguousForStatement();
      const endTokenIndex = _base.state.tokens.length;
      _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, false));
      _base.state.scopeDepth--;
    }
    function isUsingInLoop() {
      if (!_util.isContextual.call(void 0, _keywords.ContextualKeyword._using)) {
        return false;
      }
      if (_util.isLookaheadContextual.call(void 0, _keywords.ContextualKeyword._of)) {
        return false;
      }
      return true;
    }
    function parseAmbiguousForStatement() {
      _tokenizer.next.call(void 0);
      let forAwait = false;
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._await)) {
        forAwait = true;
        _tokenizer.next.call(void 0);
      }
      _util.expect.call(void 0, _types.TokenType.parenL);
      if (_tokenizer.match.call(void 0, _types.TokenType.semi)) {
        if (forAwait) {
          _util.unexpected.call(void 0);
        }
        parseFor();
        return;
      }
      const isAwaitUsing = startsAwaitUsing();
      if (isAwaitUsing || _tokenizer.match.call(void 0, _types.TokenType._var) || _tokenizer.match.call(void 0, _types.TokenType._let) || _tokenizer.match.call(void 0, _types.TokenType._const) || isUsingInLoop()) {
        if (isAwaitUsing) {
          _util.expectContextual.call(void 0, _keywords.ContextualKeyword._await);
        }
        _tokenizer.next.call(void 0);
        parseVar(true, _base.state.type !== _types.TokenType._var);
        if (_tokenizer.match.call(void 0, _types.TokenType._in) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._of)) {
          parseForIn(forAwait);
          return;
        }
        parseFor();
        return;
      }
      _expression.parseExpression.call(void 0, true);
      if (_tokenizer.match.call(void 0, _types.TokenType._in) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._of)) {
        parseForIn(forAwait);
        return;
      }
      if (forAwait) {
        _util.unexpected.call(void 0);
      }
      parseFor();
    }
    function parseFunctionStatement() {
      const functionStart = _base.state.start;
      _tokenizer.next.call(void 0);
      parseFunction(functionStart, true);
    }
    function parseIfStatement() {
      _tokenizer.next.call(void 0);
      _expression.parseParenExpression.call(void 0);
      parseStatement(false);
      if (_tokenizer.eat.call(void 0, _types.TokenType._else)) {
        parseStatement(false);
      }
    }
    function parseReturnStatement() {
      _tokenizer.next.call(void 0);
      if (!_util.isLineTerminator.call(void 0)) {
        _expression.parseExpression.call(void 0);
        _util.semicolon.call(void 0);
      }
    }
    function parseSwitchStatement() {
      _tokenizer.next.call(void 0);
      _expression.parseParenExpression.call(void 0);
      _base.state.scopeDepth++;
      const startTokenIndex = _base.state.tokens.length;
      _util.expect.call(void 0, _types.TokenType.braceL);
      while (!_tokenizer.match.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
        if (_tokenizer.match.call(void 0, _types.TokenType._case) || _tokenizer.match.call(void 0, _types.TokenType._default)) {
          const isCase = _tokenizer.match.call(void 0, _types.TokenType._case);
          _tokenizer.next.call(void 0);
          if (isCase) {
            _expression.parseExpression.call(void 0);
          }
          _util.expect.call(void 0, _types.TokenType.colon);
        } else {
          parseStatement(true);
        }
      }
      _tokenizer.next.call(void 0);
      const endTokenIndex = _base.state.tokens.length;
      _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, false));
      _base.state.scopeDepth--;
    }
    function parseThrowStatement() {
      _tokenizer.next.call(void 0);
      _expression.parseExpression.call(void 0);
      _util.semicolon.call(void 0);
    }
    function parseCatchClauseParam() {
      _lval.parseBindingAtom.call(
        void 0,
        true
        /* isBlockScope */
      );
      if (_base.isTypeScriptEnabled) {
        _typescript.tsTryParseTypeAnnotation.call(void 0);
      }
    }
    function parseTryStatement() {
      _tokenizer.next.call(void 0);
      parseBlock();
      if (_tokenizer.match.call(void 0, _types.TokenType._catch)) {
        _tokenizer.next.call(void 0);
        let catchBindingStartTokenIndex = null;
        if (_tokenizer.match.call(void 0, _types.TokenType.parenL)) {
          _base.state.scopeDepth++;
          catchBindingStartTokenIndex = _base.state.tokens.length;
          _util.expect.call(void 0, _types.TokenType.parenL);
          parseCatchClauseParam();
          _util.expect.call(void 0, _types.TokenType.parenR);
        }
        parseBlock();
        if (catchBindingStartTokenIndex != null) {
          const endTokenIndex = _base.state.tokens.length;
          _base.state.scopes.push(new (0, _state.Scope)(catchBindingStartTokenIndex, endTokenIndex, false));
          _base.state.scopeDepth--;
        }
      }
      if (_tokenizer.eat.call(void 0, _types.TokenType._finally)) {
        parseBlock();
      }
    }
    function parseVarStatement(isBlockScope) {
      _tokenizer.next.call(void 0);
      parseVar(false, isBlockScope);
      _util.semicolon.call(void 0);
    }
    exports2.parseVarStatement = parseVarStatement;
    function parseWhileStatement() {
      _tokenizer.next.call(void 0);
      _expression.parseParenExpression.call(void 0);
      parseStatement(false);
    }
    function parseEmptyStatement() {
      _tokenizer.next.call(void 0);
    }
    function parseLabeledStatement() {
      parseStatement(true);
    }
    function parseIdentifierStatement(contextualKeyword) {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsParseIdentifierStatement.call(void 0, contextualKeyword);
      } else if (_base.isFlowEnabled) {
        _flow.flowParseIdentifierStatement.call(void 0, contextualKeyword);
      } else {
        _util.semicolon.call(void 0);
      }
    }
    function parseBlock(isFunctionScope = false, contextId = 0) {
      const startTokenIndex = _base.state.tokens.length;
      _base.state.scopeDepth++;
      _util.expect.call(void 0, _types.TokenType.braceL);
      if (contextId) {
        _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
      }
      parseBlockBody(_types.TokenType.braceR);
      if (contextId) {
        _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
      }
      const endTokenIndex = _base.state.tokens.length;
      _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, isFunctionScope));
      _base.state.scopeDepth--;
    }
    exports2.parseBlock = parseBlock;
    function parseBlockBody(end) {
      while (!_tokenizer.eat.call(void 0, end) && !_base.state.error) {
        parseStatement(true);
      }
    }
    exports2.parseBlockBody = parseBlockBody;
    function parseFor() {
      _util.expect.call(void 0, _types.TokenType.semi);
      if (!_tokenizer.match.call(void 0, _types.TokenType.semi)) {
        _expression.parseExpression.call(void 0);
      }
      _util.expect.call(void 0, _types.TokenType.semi);
      if (!_tokenizer.match.call(void 0, _types.TokenType.parenR)) {
        _expression.parseExpression.call(void 0);
      }
      _util.expect.call(void 0, _types.TokenType.parenR);
      parseStatement(false);
    }
    function parseForIn(forAwait) {
      if (forAwait) {
        _util.eatContextual.call(void 0, _keywords.ContextualKeyword._of);
      } else {
        _tokenizer.next.call(void 0);
      }
      _expression.parseExpression.call(void 0);
      _util.expect.call(void 0, _types.TokenType.parenR);
      parseStatement(false);
    }
    function parseVar(isFor, isBlockScope) {
      while (true) {
        parseVarHead(isBlockScope);
        if (_tokenizer.eat.call(void 0, _types.TokenType.eq)) {
          const eqIndex = _base.state.tokens.length - 1;
          _expression.parseMaybeAssign.call(void 0, isFor);
          _base.state.tokens[eqIndex].rhsEndIndex = _base.state.tokens.length;
        }
        if (!_tokenizer.eat.call(void 0, _types.TokenType.comma)) {
          break;
        }
      }
    }
    function parseVarHead(isBlockScope) {
      _lval.parseBindingAtom.call(void 0, isBlockScope);
      if (_base.isTypeScriptEnabled) {
        _typescript.tsAfterParseVarHead.call(void 0);
      } else if (_base.isFlowEnabled) {
        _flow.flowAfterParseVarHead.call(void 0);
      }
    }
    function parseFunction(functionStart, isStatement, optionalId = false) {
      if (_tokenizer.match.call(void 0, _types.TokenType.star)) {
        _tokenizer.next.call(void 0);
      }
      if (isStatement && !optionalId && !_tokenizer.match.call(void 0, _types.TokenType.name) && !_tokenizer.match.call(void 0, _types.TokenType._yield)) {
        _util.unexpected.call(void 0);
      }
      let nameScopeStartTokenIndex = null;
      if (_tokenizer.match.call(void 0, _types.TokenType.name)) {
        if (!isStatement) {
          nameScopeStartTokenIndex = _base.state.tokens.length;
          _base.state.scopeDepth++;
        }
        _lval.parseBindingIdentifier.call(void 0, false);
      }
      const startTokenIndex = _base.state.tokens.length;
      _base.state.scopeDepth++;
      parseFunctionParams();
      _expression.parseFunctionBodyAndFinish.call(void 0, functionStart);
      const endTokenIndex = _base.state.tokens.length;
      _base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, true));
      _base.state.scopeDepth--;
      if (nameScopeStartTokenIndex !== null) {
        _base.state.scopes.push(new (0, _state.Scope)(nameScopeStartTokenIndex, endTokenIndex, true));
        _base.state.scopeDepth--;
      }
    }
    exports2.parseFunction = parseFunction;
    function parseFunctionParams(allowModifiers = false, funcContextId = 0) {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsStartParseFunctionParams.call(void 0);
      } else if (_base.isFlowEnabled) {
        _flow.flowStartParseFunctionParams.call(void 0);
      }
      _util.expect.call(void 0, _types.TokenType.parenL);
      if (funcContextId) {
        _base.state.tokens[_base.state.tokens.length - 1].contextId = funcContextId;
      }
      _lval.parseBindingList.call(
        void 0,
        _types.TokenType.parenR,
        false,
        false,
        allowModifiers,
        funcContextId
      );
      if (funcContextId) {
        _base.state.tokens[_base.state.tokens.length - 1].contextId = funcContextId;
      }
    }
    exports2.parseFunctionParams = parseFunctionParams;
    function parseClass(isStatement, optionalId = false) {
      const contextId = _base.getNextContextId.call(void 0);
      _tokenizer.next.call(void 0);
      _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
      _base.state.tokens[_base.state.tokens.length - 1].isExpression = !isStatement;
      let nameScopeStartTokenIndex = null;
      if (!isStatement) {
        nameScopeStartTokenIndex = _base.state.tokens.length;
        _base.state.scopeDepth++;
      }
      parseClassId(isStatement, optionalId);
      parseClassSuper();
      const openBraceIndex = _base.state.tokens.length;
      parseClassBody(contextId);
      if (_base.state.error) {
        return;
      }
      _base.state.tokens[openBraceIndex].contextId = contextId;
      _base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
      if (nameScopeStartTokenIndex !== null) {
        const endTokenIndex = _base.state.tokens.length;
        _base.state.scopes.push(new (0, _state.Scope)(nameScopeStartTokenIndex, endTokenIndex, false));
        _base.state.scopeDepth--;
      }
    }
    exports2.parseClass = parseClass;
    function isClassProperty() {
      return _tokenizer.match.call(void 0, _types.TokenType.eq) || _tokenizer.match.call(void 0, _types.TokenType.semi) || _tokenizer.match.call(void 0, _types.TokenType.braceR) || _tokenizer.match.call(void 0, _types.TokenType.bang) || _tokenizer.match.call(void 0, _types.TokenType.colon);
    }
    function isClassMethod() {
      return _tokenizer.match.call(void 0, _types.TokenType.parenL) || _tokenizer.match.call(void 0, _types.TokenType.lessThan);
    }
    function parseClassBody(classContextId) {
      _util.expect.call(void 0, _types.TokenType.braceL);
      while (!_tokenizer.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
        if (_tokenizer.eat.call(void 0, _types.TokenType.semi)) {
          continue;
        }
        if (_tokenizer.match.call(void 0, _types.TokenType.at)) {
          parseDecorator();
          continue;
        }
        const memberStart = _base.state.start;
        parseClassMember(memberStart, classContextId);
      }
    }
    function parseClassMember(memberStart, classContextId) {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsParseModifiers.call(void 0, [
          _keywords.ContextualKeyword._declare,
          _keywords.ContextualKeyword._public,
          _keywords.ContextualKeyword._protected,
          _keywords.ContextualKeyword._private,
          _keywords.ContextualKeyword._override
        ]);
      }
      let isStatic = false;
      if (_tokenizer.match.call(void 0, _types.TokenType.name) && _base.state.contextualKeyword === _keywords.ContextualKeyword._static) {
        _expression.parseIdentifier.call(void 0);
        if (isClassMethod()) {
          parseClassMethod(
            memberStart,
            /* isConstructor */
            false
          );
          return;
        } else if (isClassProperty()) {
          parseClassProperty();
          return;
        }
        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._static;
        isStatic = true;
        if (_tokenizer.match.call(void 0, _types.TokenType.braceL)) {
          _base.state.tokens[_base.state.tokens.length - 1].contextId = classContextId;
          parseBlock();
          return;
        }
      }
      parseClassMemberWithIsStatic(memberStart, isStatic, classContextId);
    }
    function parseClassMemberWithIsStatic(memberStart, isStatic, classContextId) {
      if (_base.isTypeScriptEnabled) {
        if (_typescript.tsTryParseClassMemberWithIsStatic.call(void 0, isStatic)) {
          return;
        }
      }
      if (_tokenizer.eat.call(void 0, _types.TokenType.star)) {
        parseClassPropertyName(classContextId);
        parseClassMethod(
          memberStart,
          /* isConstructor */
          false
        );
        return;
      }
      parseClassPropertyName(classContextId);
      let isConstructor = false;
      const token = _base.state.tokens[_base.state.tokens.length - 1];
      if (token.contextualKeyword === _keywords.ContextualKeyword._constructor) {
        isConstructor = true;
      }
      parsePostMemberNameModifiers();
      if (isClassMethod()) {
        parseClassMethod(memberStart, isConstructor);
      } else if (isClassProperty()) {
        parseClassProperty();
      } else if (token.contextualKeyword === _keywords.ContextualKeyword._async && !_util.isLineTerminator.call(void 0)) {
        _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._async;
        const isGenerator = _tokenizer.match.call(void 0, _types.TokenType.star);
        if (isGenerator) {
          _tokenizer.next.call(void 0);
        }
        parseClassPropertyName(classContextId);
        parsePostMemberNameModifiers();
        parseClassMethod(
          memberStart,
          false
          /* isConstructor */
        );
      } else if ((token.contextualKeyword === _keywords.ContextualKeyword._get || token.contextualKeyword === _keywords.ContextualKeyword._set) && !(_util.isLineTerminator.call(void 0) && _tokenizer.match.call(void 0, _types.TokenType.star))) {
        if (token.contextualKeyword === _keywords.ContextualKeyword._get) {
          _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._get;
        } else {
          _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._set;
        }
        parseClassPropertyName(classContextId);
        parseClassMethod(
          memberStart,
          /* isConstructor */
          false
        );
      } else if (token.contextualKeyword === _keywords.ContextualKeyword._accessor && !_util.isLineTerminator.call(void 0)) {
        parseClassPropertyName(classContextId);
        parseClassProperty();
      } else if (_util.isLineTerminator.call(void 0)) {
        parseClassProperty();
      } else {
        _util.unexpected.call(void 0);
      }
    }
    function parseClassMethod(functionStart, isConstructor) {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsTryParseTypeParameters.call(void 0);
      } else if (_base.isFlowEnabled) {
        if (_tokenizer.match.call(void 0, _types.TokenType.lessThan)) {
          _flow.flowParseTypeParameterDeclaration.call(void 0);
        }
      }
      _expression.parseMethod.call(void 0, functionStart, isConstructor);
    }
    function parseClassPropertyName(classContextId) {
      _expression.parsePropertyName.call(void 0, classContextId);
    }
    exports2.parseClassPropertyName = parseClassPropertyName;
    function parsePostMemberNameModifiers() {
      if (_base.isTypeScriptEnabled) {
        const oldIsType = _tokenizer.pushTypeContext.call(void 0, 0);
        _tokenizer.eat.call(void 0, _types.TokenType.question);
        _tokenizer.popTypeContext.call(void 0, oldIsType);
      }
    }
    exports2.parsePostMemberNameModifiers = parsePostMemberNameModifiers;
    function parseClassProperty() {
      if (_base.isTypeScriptEnabled) {
        _tokenizer.eatTypeToken.call(void 0, _types.TokenType.bang);
        _typescript.tsTryParseTypeAnnotation.call(void 0);
      } else if (_base.isFlowEnabled) {
        if (_tokenizer.match.call(void 0, _types.TokenType.colon)) {
          _flow.flowParseTypeAnnotation.call(void 0);
        }
      }
      if (_tokenizer.match.call(void 0, _types.TokenType.eq)) {
        const equalsTokenIndex = _base.state.tokens.length;
        _tokenizer.next.call(void 0);
        _expression.parseMaybeAssign.call(void 0);
        _base.state.tokens[equalsTokenIndex].rhsEndIndex = _base.state.tokens.length;
      }
      _util.semicolon.call(void 0);
    }
    exports2.parseClassProperty = parseClassProperty;
    function parseClassId(isStatement, optionalId = false) {
      if (_base.isTypeScriptEnabled && (!isStatement || optionalId) && _util.isContextual.call(void 0, _keywords.ContextualKeyword._implements)) {
        return;
      }
      if (_tokenizer.match.call(void 0, _types.TokenType.name)) {
        _lval.parseBindingIdentifier.call(void 0, true);
      }
      if (_base.isTypeScriptEnabled) {
        _typescript.tsTryParseTypeParameters.call(void 0);
      } else if (_base.isFlowEnabled) {
        if (_tokenizer.match.call(void 0, _types.TokenType.lessThan)) {
          _flow.flowParseTypeParameterDeclaration.call(void 0);
        }
      }
    }
    function parseClassSuper() {
      let hasSuper = false;
      if (_tokenizer.eat.call(void 0, _types.TokenType._extends)) {
        _expression.parseExprSubscripts.call(void 0);
        hasSuper = true;
      } else {
        hasSuper = false;
      }
      if (_base.isTypeScriptEnabled) {
        _typescript.tsAfterParseClassSuper.call(void 0, hasSuper);
      } else if (_base.isFlowEnabled) {
        _flow.flowAfterParseClassSuper.call(void 0, hasSuper);
      }
    }
    function parseExport() {
      const exportIndex = _base.state.tokens.length - 1;
      if (_base.isTypeScriptEnabled) {
        if (_typescript.tsTryParseExport.call(void 0)) {
          return;
        }
      }
      if (shouldParseExportStar()) {
        parseExportStar();
      } else if (isExportDefaultSpecifier()) {
        _expression.parseIdentifier.call(void 0);
        if (_tokenizer.match.call(void 0, _types.TokenType.comma) && _tokenizer.lookaheadType.call(void 0) === _types.TokenType.star) {
          _util.expect.call(void 0, _types.TokenType.comma);
          _util.expect.call(void 0, _types.TokenType.star);
          _util.expectContextual.call(void 0, _keywords.ContextualKeyword._as);
          _expression.parseIdentifier.call(void 0);
        } else {
          parseExportSpecifiersMaybe();
        }
        parseExportFrom();
      } else if (_tokenizer.eat.call(void 0, _types.TokenType._default)) {
        parseExportDefaultExpression();
      } else if (shouldParseExportDeclaration()) {
        parseExportDeclaration();
      } else {
        parseExportSpecifiers();
        parseExportFrom();
      }
      _base.state.tokens[exportIndex].rhsEndIndex = _base.state.tokens.length;
    }
    exports2.parseExport = parseExport;
    function parseExportDefaultExpression() {
      if (_base.isTypeScriptEnabled) {
        if (_typescript.tsTryParseExportDefaultExpression.call(void 0)) {
          return;
        }
      }
      if (_base.isFlowEnabled) {
        if (_flow.flowTryParseExportDefaultExpression.call(void 0)) {
          return;
        }
      }
      const functionStart = _base.state.start;
      if (_tokenizer.eat.call(void 0, _types.TokenType._function)) {
        parseFunction(functionStart, true, true);
      } else if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._async) && _tokenizer.lookaheadType.call(void 0) === _types.TokenType._function) {
        _util.eatContextual.call(void 0, _keywords.ContextualKeyword._async);
        _tokenizer.eat.call(void 0, _types.TokenType._function);
        parseFunction(functionStart, true, true);
      } else if (_tokenizer.match.call(void 0, _types.TokenType._class)) {
        parseClass(true, true);
      } else if (_tokenizer.match.call(void 0, _types.TokenType.at)) {
        parseDecorators();
        parseClass(true, true);
      } else {
        _expression.parseMaybeAssign.call(void 0);
        _util.semicolon.call(void 0);
      }
    }
    function parseExportDeclaration() {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsParseExportDeclaration.call(void 0);
      } else if (_base.isFlowEnabled) {
        _flow.flowParseExportDeclaration.call(void 0);
      } else {
        parseStatement(true);
      }
    }
    function isExportDefaultSpecifier() {
      if (_base.isTypeScriptEnabled && _typescript.tsIsDeclarationStart.call(void 0)) {
        return false;
      } else if (_base.isFlowEnabled && _flow.flowShouldDisallowExportDefaultSpecifier.call(void 0)) {
        return false;
      }
      if (_tokenizer.match.call(void 0, _types.TokenType.name)) {
        return _base.state.contextualKeyword !== _keywords.ContextualKeyword._async;
      }
      if (!_tokenizer.match.call(void 0, _types.TokenType._default)) {
        return false;
      }
      const _next = _tokenizer.nextTokenStart.call(void 0);
      const lookahead = _tokenizer.lookaheadTypeAndKeyword.call(void 0);
      const hasFrom = lookahead.type === _types.TokenType.name && lookahead.contextualKeyword === _keywords.ContextualKeyword._from;
      if (lookahead.type === _types.TokenType.comma) {
        return true;
      }
      if (hasFrom) {
        const nextAfterFrom = _base.input.charCodeAt(_tokenizer.nextTokenStartSince.call(void 0, _next + 4));
        return nextAfterFrom === _charcodes.charCodes.quotationMark || nextAfterFrom === _charcodes.charCodes.apostrophe;
      }
      return false;
    }
    function parseExportSpecifiersMaybe() {
      if (_tokenizer.eat.call(void 0, _types.TokenType.comma)) {
        parseExportSpecifiers();
      }
    }
    function parseExportFrom() {
      if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._from)) {
        _expression.parseExprAtom.call(void 0);
        maybeParseImportAttributes();
      }
      _util.semicolon.call(void 0);
    }
    exports2.parseExportFrom = parseExportFrom;
    function shouldParseExportStar() {
      if (_base.isFlowEnabled) {
        return _flow.flowShouldParseExportStar.call(void 0);
      } else {
        return _tokenizer.match.call(void 0, _types.TokenType.star);
      }
    }
    function parseExportStar() {
      if (_base.isFlowEnabled) {
        _flow.flowParseExportStar.call(void 0);
      } else {
        baseParseExportStar();
      }
    }
    function baseParseExportStar() {
      _util.expect.call(void 0, _types.TokenType.star);
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._as)) {
        parseExportNamespace();
      } else {
        parseExportFrom();
      }
    }
    exports2.baseParseExportStar = baseParseExportStar;
    function parseExportNamespace() {
      _tokenizer.next.call(void 0);
      _base.state.tokens[_base.state.tokens.length - 1].type = _types.TokenType._as;
      _expression.parseIdentifier.call(void 0);
      parseExportSpecifiersMaybe();
      parseExportFrom();
    }
    function shouldParseExportDeclaration() {
      return _base.isTypeScriptEnabled && _typescript.tsIsDeclarationStart.call(void 0) || _base.isFlowEnabled && _flow.flowShouldParseExportDeclaration.call(void 0) || _base.state.type === _types.TokenType._var || _base.state.type === _types.TokenType._const || _base.state.type === _types.TokenType._let || _base.state.type === _types.TokenType._function || _base.state.type === _types.TokenType._class || _util.isContextual.call(void 0, _keywords.ContextualKeyword._async) || _tokenizer.match.call(void 0, _types.TokenType.at);
    }
    function parseExportSpecifiers() {
      let first = true;
      _util.expect.call(void 0, _types.TokenType.braceL);
      while (!_tokenizer.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
        if (first) {
          first = false;
        } else {
          _util.expect.call(void 0, _types.TokenType.comma);
          if (_tokenizer.eat.call(void 0, _types.TokenType.braceR)) {
            break;
          }
        }
        parseExportSpecifier();
      }
    }
    exports2.parseExportSpecifiers = parseExportSpecifiers;
    function parseExportSpecifier() {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsParseExportSpecifier.call(void 0);
        return;
      }
      _expression.parseIdentifier.call(void 0);
      _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _tokenizer.IdentifierRole.ExportAccess;
      if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as)) {
        _expression.parseIdentifier.call(void 0);
      }
    }
    function isImportReflection() {
      const snapshot = _base.state.snapshot();
      _util.expectContextual.call(void 0, _keywords.ContextualKeyword._module);
      if (_util.eatContextual.call(void 0, _keywords.ContextualKeyword._from)) {
        if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._from)) {
          _base.state.restoreFromSnapshot(snapshot);
          return true;
        } else {
          _base.state.restoreFromSnapshot(snapshot);
          return false;
        }
      } else if (_tokenizer.match.call(void 0, _types.TokenType.comma)) {
        _base.state.restoreFromSnapshot(snapshot);
        return false;
      } else {
        _base.state.restoreFromSnapshot(snapshot);
        return true;
      }
    }
    function parseMaybeImportReflection() {
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._module) && isImportReflection()) {
        _tokenizer.next.call(void 0);
      }
    }
    function parseImport() {
      if (_base.isTypeScriptEnabled && _tokenizer.match.call(void 0, _types.TokenType.name) && _tokenizer.lookaheadType.call(void 0) === _types.TokenType.eq) {
        _typescript.tsParseImportEqualsDeclaration.call(void 0);
        return;
      }
      if (_base.isTypeScriptEnabled && _util.isContextual.call(void 0, _keywords.ContextualKeyword._type)) {
        const lookahead = _tokenizer.lookaheadTypeAndKeyword.call(void 0);
        if (lookahead.type === _types.TokenType.name && lookahead.contextualKeyword !== _keywords.ContextualKeyword._from) {
          _util.expectContextual.call(void 0, _keywords.ContextualKeyword._type);
          if (_tokenizer.lookaheadType.call(void 0) === _types.TokenType.eq) {
            _typescript.tsParseImportEqualsDeclaration.call(void 0);
            return;
          }
        } else if (lookahead.type === _types.TokenType.star || lookahead.type === _types.TokenType.braceL) {
          _util.expectContextual.call(void 0, _keywords.ContextualKeyword._type);
        }
      }
      if (_tokenizer.match.call(void 0, _types.TokenType.string)) {
        _expression.parseExprAtom.call(void 0);
      } else {
        parseMaybeImportReflection();
        parseImportSpecifiers();
        _util.expectContextual.call(void 0, _keywords.ContextualKeyword._from);
        _expression.parseExprAtom.call(void 0);
      }
      maybeParseImportAttributes();
      _util.semicolon.call(void 0);
    }
    exports2.parseImport = parseImport;
    function shouldParseDefaultImport() {
      return _tokenizer.match.call(void 0, _types.TokenType.name);
    }
    function parseImportSpecifierLocal() {
      _lval.parseImportedIdentifier.call(void 0);
    }
    function parseImportSpecifiers() {
      if (_base.isFlowEnabled) {
        _flow.flowStartParseImportSpecifiers.call(void 0);
      }
      let first = true;
      if (shouldParseDefaultImport()) {
        parseImportSpecifierLocal();
        if (!_tokenizer.eat.call(void 0, _types.TokenType.comma)) return;
      }
      if (_tokenizer.match.call(void 0, _types.TokenType.star)) {
        _tokenizer.next.call(void 0);
        _util.expectContextual.call(void 0, _keywords.ContextualKeyword._as);
        parseImportSpecifierLocal();
        return;
      }
      _util.expect.call(void 0, _types.TokenType.braceL);
      while (!_tokenizer.eat.call(void 0, _types.TokenType.braceR) && !_base.state.error) {
        if (first) {
          first = false;
        } else {
          if (_tokenizer.eat.call(void 0, _types.TokenType.colon)) {
            _util.unexpected.call(
              void 0,
              "ES2015 named imports do not destructure. Use another statement for destructuring after the import."
            );
          }
          _util.expect.call(void 0, _types.TokenType.comma);
          if (_tokenizer.eat.call(void 0, _types.TokenType.braceR)) {
            break;
          }
        }
        parseImportSpecifier();
      }
    }
    function parseImportSpecifier() {
      if (_base.isTypeScriptEnabled) {
        _typescript.tsParseImportSpecifier.call(void 0);
        return;
      }
      if (_base.isFlowEnabled) {
        _flow.flowParseImportSpecifier.call(void 0);
        return;
      }
      _lval.parseImportedIdentifier.call(void 0);
      if (_util.isContextual.call(void 0, _keywords.ContextualKeyword._as)) {
        _base.state.tokens[_base.state.tokens.length - 1].identifierRole = _tokenizer.IdentifierRole.ImportAccess;
        _tokenizer.next.call(void 0);
        _lval.parseImportedIdentifier.call(void 0);
      }
    }
    function maybeParseImportAttributes() {
      if (_tokenizer.match.call(void 0, _types.TokenType._with) || _util.isContextual.call(void 0, _keywords.ContextualKeyword._assert) && !_util.hasPrecedingLineBreak.call(void 0)) {
        _tokenizer.next.call(void 0);
        _expression.parseObj.call(void 0, false, false);
      }
    }
  }
});

// node_modules/sucrase/dist/parser/traverser/index.js
var require_traverser = __commonJS({
  "node_modules/sucrase/dist/parser/traverser/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _index = require_tokenizer2();
    var _charcodes = require_charcodes();
    var _base = require_base();
    var _statement = require_statement();
    function parseFile() {
      if (_base.state.pos === 0 && _base.input.charCodeAt(0) === _charcodes.charCodes.numberSign && _base.input.charCodeAt(1) === _charcodes.charCodes.exclamationMark) {
        _index.skipLineComment.call(void 0, 2);
      }
      _index.nextToken.call(void 0);
      return _statement.parseTopLevel.call(void 0);
    }
    exports2.parseFile = parseFile;
  }
});

// node_modules/sucrase/dist/parser/index.js
var require_parser2 = __commonJS({
  "node_modules/sucrase/dist/parser/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _base = require_base();
    var _index = require_traverser();
    var File2 = class {
      constructor(tokens, scopes) {
        this.tokens = tokens;
        this.scopes = scopes;
      }
    };
    exports2.File = File2;
    function parse4(input, isJSXEnabled, isTypeScriptEnabled, isFlowEnabled) {
      if (isFlowEnabled && isTypeScriptEnabled) {
        throw new Error("Cannot combine flow and typescript plugins.");
      }
      _base.initParser.call(void 0, input, isJSXEnabled, isTypeScriptEnabled, isFlowEnabled);
      const result = _index.parseFile.call(void 0);
      if (_base.state.error) {
        throw _base.augmentError.call(void 0, _base.state.error);
      }
      return result;
    }
    exports2.parse = parse4;
  }
});

// node_modules/sucrase/dist/util/isAsyncOperation.js
var require_isAsyncOperation = __commonJS({
  "node_modules/sucrase/dist/util/isAsyncOperation.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _keywords = require_keywords();
    function isAsyncOperation(tokens) {
      let index = tokens.currentIndex();
      let depth = 0;
      const startToken = tokens.currentToken();
      do {
        const token = tokens.tokens[index];
        if (token.isOptionalChainStart) {
          depth++;
        }
        if (token.isOptionalChainEnd) {
          depth--;
        }
        depth += token.numNullishCoalesceStarts;
        depth -= token.numNullishCoalesceEnds;
        if (token.contextualKeyword === _keywords.ContextualKeyword._await && token.identifierRole == null && token.scopeDepth === startToken.scopeDepth) {
          return true;
        }
        index += 1;
      } while (depth > 0 && index < tokens.tokens.length);
      return false;
    }
    exports2.default = isAsyncOperation;
  }
});

// node_modules/sucrase/dist/TokenProcessor.js
var require_TokenProcessor = __commonJS({
  "node_modules/sucrase/dist/TokenProcessor.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _types = require_types();
    var _isAsyncOperation = require_isAsyncOperation();
    var _isAsyncOperation2 = _interopRequireDefault(_isAsyncOperation);
    var TokenProcessor = class _TokenProcessor {
      __init() {
        this.resultCode = "";
      }
      // Array mapping input token index to optional string index position in the
      // output code.
      __init2() {
        this.resultMappings = new Array(this.tokens.length);
      }
      __init3() {
        this.tokenIndex = 0;
      }
      constructor(code, tokens, isFlowEnabled, disableESTransforms, helperManager) {
        ;
        this.code = code;
        this.tokens = tokens;
        this.isFlowEnabled = isFlowEnabled;
        this.disableESTransforms = disableESTransforms;
        this.helperManager = helperManager;
        _TokenProcessor.prototype.__init.call(this);
        _TokenProcessor.prototype.__init2.call(this);
        _TokenProcessor.prototype.__init3.call(this);
      }
      /**
       * Snapshot the token state in a way that can be restored later, useful for
       * things like lookahead.
       *
       * resultMappings do not need to be copied since in all use cases, they will
       * be overwritten anyway after restore.
       */
      snapshot() {
        return {
          resultCode: this.resultCode,
          tokenIndex: this.tokenIndex
        };
      }
      restoreToSnapshot(snapshot) {
        this.resultCode = snapshot.resultCode;
        this.tokenIndex = snapshot.tokenIndex;
      }
      /**
       * Remove and return the code generated since the snapshot, leaving the
       * current token position in-place. Unlike most TokenProcessor operations,
       * this operation can result in input/output line number mismatches because
       * the removed code may contain newlines, so this operation should be used
       * sparingly.
       */
      dangerouslyGetAndRemoveCodeSinceSnapshot(snapshot) {
        const result = this.resultCode.slice(snapshot.resultCode.length);
        this.resultCode = snapshot.resultCode;
        return result;
      }
      reset() {
        this.resultCode = "";
        this.resultMappings = new Array(this.tokens.length);
        this.tokenIndex = 0;
      }
      matchesContextualAtIndex(index, contextualKeyword) {
        return this.matches1AtIndex(index, _types.TokenType.name) && this.tokens[index].contextualKeyword === contextualKeyword;
      }
      identifierNameAtIndex(index) {
        return this.identifierNameForToken(this.tokens[index]);
      }
      identifierNameAtRelativeIndex(relativeIndex) {
        return this.identifierNameForToken(this.tokenAtRelativeIndex(relativeIndex));
      }
      identifierName() {
        return this.identifierNameForToken(this.currentToken());
      }
      identifierNameForToken(token) {
        return this.code.slice(token.start, token.end);
      }
      rawCodeForToken(token) {
        return this.code.slice(token.start, token.end);
      }
      stringValueAtIndex(index) {
        return this.stringValueForToken(this.tokens[index]);
      }
      stringValue() {
        return this.stringValueForToken(this.currentToken());
      }
      stringValueForToken(token) {
        return this.code.slice(token.start + 1, token.end - 1);
      }
      matches1AtIndex(index, t1) {
        return this.tokens[index].type === t1;
      }
      matches2AtIndex(index, t1, t2) {
        return this.tokens[index].type === t1 && this.tokens[index + 1].type === t2;
      }
      matches3AtIndex(index, t1, t2, t3) {
        return this.tokens[index].type === t1 && this.tokens[index + 1].type === t2 && this.tokens[index + 2].type === t3;
      }
      matches1(t1) {
        return this.tokens[this.tokenIndex].type === t1;
      }
      matches2(t1, t2) {
        return this.tokens[this.tokenIndex].type === t1 && this.tokens[this.tokenIndex + 1].type === t2;
      }
      matches3(t1, t2, t3) {
        return this.tokens[this.tokenIndex].type === t1 && this.tokens[this.tokenIndex + 1].type === t2 && this.tokens[this.tokenIndex + 2].type === t3;
      }
      matches4(t1, t2, t3, t4) {
        return this.tokens[this.tokenIndex].type === t1 && this.tokens[this.tokenIndex + 1].type === t2 && this.tokens[this.tokenIndex + 2].type === t3 && this.tokens[this.tokenIndex + 3].type === t4;
      }
      matches5(t1, t2, t3, t4, t5) {
        return this.tokens[this.tokenIndex].type === t1 && this.tokens[this.tokenIndex + 1].type === t2 && this.tokens[this.tokenIndex + 2].type === t3 && this.tokens[this.tokenIndex + 3].type === t4 && this.tokens[this.tokenIndex + 4].type === t5;
      }
      matchesContextual(contextualKeyword) {
        return this.matchesContextualAtIndex(this.tokenIndex, contextualKeyword);
      }
      matchesContextIdAndLabel(type, contextId) {
        return this.matches1(type) && this.currentToken().contextId === contextId;
      }
      previousWhitespaceAndComments() {
        let whitespaceAndComments = this.code.slice(
          this.tokenIndex > 0 ? this.tokens[this.tokenIndex - 1].end : 0,
          this.tokenIndex < this.tokens.length ? this.tokens[this.tokenIndex].start : this.code.length
        );
        if (this.isFlowEnabled) {
          whitespaceAndComments = whitespaceAndComments.replace(/@flow/g, "");
        }
        return whitespaceAndComments;
      }
      replaceToken(newCode) {
        this.resultCode += this.previousWhitespaceAndComments();
        this.appendTokenPrefix();
        this.resultMappings[this.tokenIndex] = this.resultCode.length;
        this.resultCode += newCode;
        this.appendTokenSuffix();
        this.tokenIndex++;
      }
      replaceTokenTrimmingLeftWhitespace(newCode) {
        this.resultCode += this.previousWhitespaceAndComments().replace(/[^\r\n]/g, "");
        this.appendTokenPrefix();
        this.resultMappings[this.tokenIndex] = this.resultCode.length;
        this.resultCode += newCode;
        this.appendTokenSuffix();
        this.tokenIndex++;
      }
      removeInitialToken() {
        this.replaceToken("");
      }
      removeToken() {
        this.replaceTokenTrimmingLeftWhitespace("");
      }
      /**
       * Remove all code until the next }, accounting for balanced braces.
       */
      removeBalancedCode() {
        let braceDepth = 0;
        while (!this.isAtEnd()) {
          if (this.matches1(_types.TokenType.braceL)) {
            braceDepth++;
          } else if (this.matches1(_types.TokenType.braceR)) {
            if (braceDepth === 0) {
              return;
            }
            braceDepth--;
          }
          this.removeToken();
        }
      }
      copyExpectedToken(tokenType) {
        if (this.tokens[this.tokenIndex].type !== tokenType) {
          throw new Error(`Expected token ${tokenType}`);
        }
        this.copyToken();
      }
      copyToken() {
        this.resultCode += this.previousWhitespaceAndComments();
        this.appendTokenPrefix();
        this.resultMappings[this.tokenIndex] = this.resultCode.length;
        this.resultCode += this.code.slice(
          this.tokens[this.tokenIndex].start,
          this.tokens[this.tokenIndex].end
        );
        this.appendTokenSuffix();
        this.tokenIndex++;
      }
      copyTokenWithPrefix(prefix) {
        this.resultCode += this.previousWhitespaceAndComments();
        this.appendTokenPrefix();
        this.resultCode += prefix;
        this.resultMappings[this.tokenIndex] = this.resultCode.length;
        this.resultCode += this.code.slice(
          this.tokens[this.tokenIndex].start,
          this.tokens[this.tokenIndex].end
        );
        this.appendTokenSuffix();
        this.tokenIndex++;
      }
      appendTokenPrefix() {
        const token = this.currentToken();
        if (token.numNullishCoalesceStarts || token.isOptionalChainStart) {
          token.isAsyncOperation = _isAsyncOperation2.default.call(void 0, this);
        }
        if (this.disableESTransforms) {
          return;
        }
        if (token.numNullishCoalesceStarts) {
          for (let i = 0; i < token.numNullishCoalesceStarts; i++) {
            if (token.isAsyncOperation) {
              this.resultCode += "await ";
              this.resultCode += this.helperManager.getHelperName("asyncNullishCoalesce");
            } else {
              this.resultCode += this.helperManager.getHelperName("nullishCoalesce");
            }
            this.resultCode += "(";
          }
        }
        if (token.isOptionalChainStart) {
          if (token.isAsyncOperation) {
            this.resultCode += "await ";
          }
          if (this.tokenIndex > 0 && this.tokenAtRelativeIndex(-1).type === _types.TokenType._delete) {
            if (token.isAsyncOperation) {
              this.resultCode += this.helperManager.getHelperName("asyncOptionalChainDelete");
            } else {
              this.resultCode += this.helperManager.getHelperName("optionalChainDelete");
            }
          } else if (token.isAsyncOperation) {
            this.resultCode += this.helperManager.getHelperName("asyncOptionalChain");
          } else {
            this.resultCode += this.helperManager.getHelperName("optionalChain");
          }
          this.resultCode += "([";
        }
      }
      appendTokenSuffix() {
        const token = this.currentToken();
        if (token.isOptionalChainEnd && !this.disableESTransforms) {
          this.resultCode += "])";
        }
        if (token.numNullishCoalesceEnds && !this.disableESTransforms) {
          for (let i = 0; i < token.numNullishCoalesceEnds; i++) {
            this.resultCode += "))";
          }
        }
      }
      appendCode(code) {
        this.resultCode += code;
      }
      currentToken() {
        return this.tokens[this.tokenIndex];
      }
      currentTokenCode() {
        const token = this.currentToken();
        return this.code.slice(token.start, token.end);
      }
      tokenAtRelativeIndex(relativeIndex) {
        return this.tokens[this.tokenIndex + relativeIndex];
      }
      currentIndex() {
        return this.tokenIndex;
      }
      /**
       * Move to the next token. Only suitable in preprocessing steps. When
       * generating new code, you should use copyToken or removeToken.
       */
      nextToken() {
        if (this.tokenIndex === this.tokens.length) {
          throw new Error("Unexpectedly reached end of input.");
        }
        this.tokenIndex++;
      }
      previousToken() {
        this.tokenIndex--;
      }
      finish() {
        if (this.tokenIndex !== this.tokens.length) {
          throw new Error("Tried to finish processing tokens before reaching the end.");
        }
        this.resultCode += this.previousWhitespaceAndComments();
        return { code: this.resultCode, mappings: this.resultMappings };
      }
      isAtEnd() {
        return this.tokenIndex === this.tokens.length;
      }
    };
    exports2.default = TokenProcessor;
  }
});

// node_modules/sucrase/dist/util/getClassInfo.js
var require_getClassInfo = __commonJS({
  "node_modules/sucrase/dist/util/getClassInfo.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _keywords = require_keywords();
    var _types = require_types();
    function getClassInfo(rootTransformer, tokens, nameManager, disableESTransforms) {
      const snapshot = tokens.snapshot();
      const headerInfo = processClassHeader(tokens);
      let constructorInitializerStatements = [];
      const instanceInitializerNames = [];
      const staticInitializerNames = [];
      let constructorInsertPos = null;
      const fields = [];
      const rangesToRemove = [];
      const classContextId = tokens.currentToken().contextId;
      if (classContextId == null) {
        throw new Error("Expected non-null class context ID on class open-brace.");
      }
      tokens.nextToken();
      while (!tokens.matchesContextIdAndLabel(_types.TokenType.braceR, classContextId)) {
        if (tokens.matchesContextual(_keywords.ContextualKeyword._constructor) && !tokens.currentToken().isType) {
          ({ constructorInitializerStatements, constructorInsertPos } = processConstructor(tokens));
        } else if (tokens.matches1(_types.TokenType.semi)) {
          if (!disableESTransforms) {
            rangesToRemove.push({ start: tokens.currentIndex(), end: tokens.currentIndex() + 1 });
          }
          tokens.nextToken();
        } else if (tokens.currentToken().isType) {
          tokens.nextToken();
        } else {
          const statementStartIndex = tokens.currentIndex();
          let isStatic = false;
          let isESPrivate = false;
          let isDeclareOrAbstract = false;
          while (isAccessModifier(tokens.currentToken())) {
            if (tokens.matches1(_types.TokenType._static)) {
              isStatic = true;
            }
            if (tokens.matches1(_types.TokenType.hash)) {
              isESPrivate = true;
            }
            if (tokens.matches1(_types.TokenType._declare) || tokens.matches1(_types.TokenType._abstract)) {
              isDeclareOrAbstract = true;
            }
            tokens.nextToken();
          }
          if (isStatic && tokens.matches1(_types.TokenType.braceL)) {
            skipToNextClassElement(tokens, classContextId);
            continue;
          }
          if (isESPrivate) {
            skipToNextClassElement(tokens, classContextId);
            continue;
          }
          if (tokens.matchesContextual(_keywords.ContextualKeyword._constructor) && !tokens.currentToken().isType) {
            ({ constructorInitializerStatements, constructorInsertPos } = processConstructor(tokens));
            continue;
          }
          const nameStartIndex = tokens.currentIndex();
          skipFieldName(tokens);
          if (tokens.matches1(_types.TokenType.lessThan) || tokens.matches1(_types.TokenType.parenL)) {
            skipToNextClassElement(tokens, classContextId);
            continue;
          }
          while (tokens.currentToken().isType) {
            tokens.nextToken();
          }
          if (tokens.matches1(_types.TokenType.eq)) {
            const equalsIndex = tokens.currentIndex();
            const valueEnd = tokens.currentToken().rhsEndIndex;
            if (valueEnd == null) {
              throw new Error("Expected rhsEndIndex on class field assignment.");
            }
            tokens.nextToken();
            while (tokens.currentIndex() < valueEnd) {
              rootTransformer.processToken();
            }
            let initializerName;
            if (isStatic) {
              initializerName = nameManager.claimFreeName("__initStatic");
              staticInitializerNames.push(initializerName);
            } else {
              initializerName = nameManager.claimFreeName("__init");
              instanceInitializerNames.push(initializerName);
            }
            fields.push({
              initializerName,
              equalsIndex,
              start: nameStartIndex,
              end: tokens.currentIndex()
            });
          } else if (!disableESTransforms || isDeclareOrAbstract) {
            rangesToRemove.push({ start: statementStartIndex, end: tokens.currentIndex() });
          }
        }
      }
      tokens.restoreToSnapshot(snapshot);
      if (disableESTransforms) {
        return {
          headerInfo,
          constructorInitializerStatements,
          instanceInitializerNames: [],
          staticInitializerNames: [],
          constructorInsertPos,
          fields: [],
          rangesToRemove
        };
      } else {
        return {
          headerInfo,
          constructorInitializerStatements,
          instanceInitializerNames,
          staticInitializerNames,
          constructorInsertPos,
          fields,
          rangesToRemove
        };
      }
    }
    exports2.default = getClassInfo;
    function skipToNextClassElement(tokens, classContextId) {
      tokens.nextToken();
      while (tokens.currentToken().contextId !== classContextId) {
        tokens.nextToken();
      }
      while (isAccessModifier(tokens.tokenAtRelativeIndex(-1))) {
        tokens.previousToken();
      }
    }
    function processClassHeader(tokens) {
      const classToken = tokens.currentToken();
      const contextId = classToken.contextId;
      if (contextId == null) {
        throw new Error("Expected context ID on class token.");
      }
      const isExpression = classToken.isExpression;
      if (isExpression == null) {
        throw new Error("Expected isExpression on class token.");
      }
      let className = null;
      let hasSuperclass = false;
      tokens.nextToken();
      if (tokens.matches1(_types.TokenType.name)) {
        className = tokens.identifierName();
      }
      while (!tokens.matchesContextIdAndLabel(_types.TokenType.braceL, contextId)) {
        if (tokens.matches1(_types.TokenType._extends) && !tokens.currentToken().isType) {
          hasSuperclass = true;
        }
        tokens.nextToken();
      }
      return { isExpression, className, hasSuperclass };
    }
    function processConstructor(tokens) {
      const constructorInitializerStatements = [];
      tokens.nextToken();
      const constructorContextId = tokens.currentToken().contextId;
      if (constructorContextId == null) {
        throw new Error("Expected context ID on open-paren starting constructor params.");
      }
      while (!tokens.matchesContextIdAndLabel(_types.TokenType.parenR, constructorContextId)) {
        if (tokens.currentToken().contextId === constructorContextId) {
          tokens.nextToken();
          if (isAccessModifier(tokens.currentToken())) {
            tokens.nextToken();
            while (isAccessModifier(tokens.currentToken())) {
              tokens.nextToken();
            }
            const token = tokens.currentToken();
            if (token.type !== _types.TokenType.name) {
              throw new Error("Expected identifier after access modifiers in constructor arg.");
            }
            const name28 = tokens.identifierNameForToken(token);
            constructorInitializerStatements.push(`this.${name28} = ${name28}`);
          }
        } else {
          tokens.nextToken();
        }
      }
      tokens.nextToken();
      while (tokens.currentToken().isType) {
        tokens.nextToken();
      }
      let constructorInsertPos = tokens.currentIndex();
      let foundSuperCall = false;
      while (!tokens.matchesContextIdAndLabel(_types.TokenType.braceR, constructorContextId)) {
        if (!foundSuperCall && tokens.matches2(_types.TokenType._super, _types.TokenType.parenL)) {
          tokens.nextToken();
          const superCallContextId = tokens.currentToken().contextId;
          if (superCallContextId == null) {
            throw new Error("Expected a context ID on the super call");
          }
          while (!tokens.matchesContextIdAndLabel(_types.TokenType.parenR, superCallContextId)) {
            tokens.nextToken();
          }
          constructorInsertPos = tokens.currentIndex();
          foundSuperCall = true;
        }
        tokens.nextToken();
      }
      tokens.nextToken();
      return { constructorInitializerStatements, constructorInsertPos };
    }
    function isAccessModifier(token) {
      return [
        _types.TokenType._async,
        _types.TokenType._get,
        _types.TokenType._set,
        _types.TokenType.plus,
        _types.TokenType.minus,
        _types.TokenType._readonly,
        _types.TokenType._static,
        _types.TokenType._public,
        _types.TokenType._private,
        _types.TokenType._protected,
        _types.TokenType._override,
        _types.TokenType._abstract,
        _types.TokenType.star,
        _types.TokenType._declare,
        _types.TokenType.hash
      ].includes(token.type);
    }
    function skipFieldName(tokens) {
      if (tokens.matches1(_types.TokenType.bracketL)) {
        const startToken = tokens.currentToken();
        const classContextId = startToken.contextId;
        if (classContextId == null) {
          throw new Error("Expected class context ID on computed name open bracket.");
        }
        while (!tokens.matchesContextIdAndLabel(_types.TokenType.bracketR, classContextId)) {
          tokens.nextToken();
        }
        tokens.nextToken();
      } else {
        tokens.nextToken();
      }
    }
  }
});

// node_modules/sucrase/dist/util/elideImportEquals.js
var require_elideImportEquals = __commonJS({
  "node_modules/sucrase/dist/util/elideImportEquals.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _types = require_types();
    function elideImportEquals(tokens) {
      tokens.removeInitialToken();
      tokens.removeToken();
      tokens.removeToken();
      tokens.removeToken();
      if (tokens.matches1(_types.TokenType.parenL)) {
        tokens.removeToken();
        tokens.removeToken();
        tokens.removeToken();
      } else {
        while (tokens.matches1(_types.TokenType.dot)) {
          tokens.removeToken();
          tokens.removeToken();
        }
      }
    }
    exports2.default = elideImportEquals;
  }
});

// node_modules/sucrase/dist/util/getDeclarationInfo.js
var require_getDeclarationInfo = __commonJS({
  "node_modules/sucrase/dist/util/getDeclarationInfo.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _tokenizer = require_tokenizer2();
    var _types = require_types();
    var EMPTY_DECLARATION_INFO = {
      typeDeclarations: /* @__PURE__ */ new Set(),
      valueDeclarations: /* @__PURE__ */ new Set()
    };
    exports2.EMPTY_DECLARATION_INFO = EMPTY_DECLARATION_INFO;
    function getDeclarationInfo(tokens) {
      const typeDeclarations = /* @__PURE__ */ new Set();
      const valueDeclarations = /* @__PURE__ */ new Set();
      for (let i = 0; i < tokens.tokens.length; i++) {
        const token = tokens.tokens[i];
        if (token.type === _types.TokenType.name && _tokenizer.isTopLevelDeclaration.call(void 0, token)) {
          if (token.isType) {
            typeDeclarations.add(tokens.identifierNameForToken(token));
          } else {
            valueDeclarations.add(tokens.identifierNameForToken(token));
          }
        }
      }
      return { typeDeclarations, valueDeclarations };
    }
    exports2.default = getDeclarationInfo;
  }
});

// node_modules/sucrase/dist/util/isExportFrom.js
var require_isExportFrom = __commonJS({
  "node_modules/sucrase/dist/util/isExportFrom.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _keywords = require_keywords();
    var _types = require_types();
    function isExportFrom(tokens) {
      let closeBraceIndex = tokens.currentIndex();
      while (!tokens.matches1AtIndex(closeBraceIndex, _types.TokenType.braceR)) {
        closeBraceIndex++;
      }
      return tokens.matchesContextualAtIndex(closeBraceIndex + 1, _keywords.ContextualKeyword._from) && tokens.matches1AtIndex(closeBraceIndex + 2, _types.TokenType.string);
    }
    exports2.default = isExportFrom;
  }
});

// node_modules/sucrase/dist/util/removeMaybeImportAttributes.js
var require_removeMaybeImportAttributes = __commonJS({
  "node_modules/sucrase/dist/util/removeMaybeImportAttributes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _keywords = require_keywords();
    var _types = require_types();
    function removeMaybeImportAttributes(tokens) {
      if (tokens.matches2(_types.TokenType._with, _types.TokenType.braceL) || tokens.matches2(_types.TokenType.name, _types.TokenType.braceL) && tokens.matchesContextual(_keywords.ContextualKeyword._assert)) {
        tokens.removeToken();
        tokens.removeToken();
        tokens.removeBalancedCode();
        tokens.removeToken();
      }
    }
    exports2.removeMaybeImportAttributes = removeMaybeImportAttributes;
  }
});

// node_modules/sucrase/dist/util/shouldElideDefaultExport.js
var require_shouldElideDefaultExport = __commonJS({
  "node_modules/sucrase/dist/util/shouldElideDefaultExport.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _types = require_types();
    function shouldElideDefaultExport(isTypeScriptTransformEnabled, keepUnusedImports, tokens, declarationInfo) {
      if (!isTypeScriptTransformEnabled || keepUnusedImports) {
        return false;
      }
      const exportToken = tokens.currentToken();
      if (exportToken.rhsEndIndex == null) {
        throw new Error("Expected non-null rhsEndIndex on export token.");
      }
      const numTokens = exportToken.rhsEndIndex - tokens.currentIndex();
      if (numTokens !== 3 && !(numTokens === 4 && tokens.matches1AtIndex(exportToken.rhsEndIndex - 1, _types.TokenType.semi))) {
        return false;
      }
      const identifierToken = tokens.tokenAtRelativeIndex(2);
      if (identifierToken.type !== _types.TokenType.name) {
        return false;
      }
      const exportedName = tokens.identifierNameForToken(identifierToken);
      return declarationInfo.typeDeclarations.has(exportedName) && !declarationInfo.valueDeclarations.has(exportedName);
    }
    exports2.default = shouldElideDefaultExport;
  }
});

// node_modules/sucrase/dist/transformers/CJSImportTransformer.js
var require_CJSImportTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/CJSImportTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _tokenizer = require_tokenizer2();
    var _keywords = require_keywords();
    var _types = require_types();
    var _elideImportEquals = require_elideImportEquals();
    var _elideImportEquals2 = _interopRequireDefault(_elideImportEquals);
    var _getDeclarationInfo = require_getDeclarationInfo();
    var _getDeclarationInfo2 = _interopRequireDefault(_getDeclarationInfo);
    var _getImportExportSpecifierInfo = require_getImportExportSpecifierInfo();
    var _getImportExportSpecifierInfo2 = _interopRequireDefault(_getImportExportSpecifierInfo);
    var _isExportFrom = require_isExportFrom();
    var _isExportFrom2 = _interopRequireDefault(_isExportFrom);
    var _removeMaybeImportAttributes = require_removeMaybeImportAttributes();
    var _shouldElideDefaultExport = require_shouldElideDefaultExport();
    var _shouldElideDefaultExport2 = _interopRequireDefault(_shouldElideDefaultExport);
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var CJSImportTransformer = class _CJSImportTransformer extends _Transformer2.default {
      __init() {
        this.hadExport = false;
      }
      __init2() {
        this.hadNamedExport = false;
      }
      __init3() {
        this.hadDefaultExport = false;
      }
      constructor(rootTransformer, tokens, importProcessor, nameManager, helperManager, reactHotLoaderTransformer, enableLegacyBabel5ModuleInterop, enableLegacyTypeScriptModuleInterop, isTypeScriptTransformEnabled, isFlowTransformEnabled, preserveDynamicImport, keepUnusedImports) {
        super();
        this.rootTransformer = rootTransformer;
        this.tokens = tokens;
        this.importProcessor = importProcessor;
        this.nameManager = nameManager;
        this.helperManager = helperManager;
        this.reactHotLoaderTransformer = reactHotLoaderTransformer;
        this.enableLegacyBabel5ModuleInterop = enableLegacyBabel5ModuleInterop;
        this.enableLegacyTypeScriptModuleInterop = enableLegacyTypeScriptModuleInterop;
        this.isTypeScriptTransformEnabled = isTypeScriptTransformEnabled;
        this.isFlowTransformEnabled = isFlowTransformEnabled;
        this.preserveDynamicImport = preserveDynamicImport;
        this.keepUnusedImports = keepUnusedImports;
        _CJSImportTransformer.prototype.__init.call(this);
        _CJSImportTransformer.prototype.__init2.call(this);
        _CJSImportTransformer.prototype.__init3.call(this);
        ;
        this.declarationInfo = isTypeScriptTransformEnabled ? _getDeclarationInfo2.default.call(void 0, tokens) : _getDeclarationInfo.EMPTY_DECLARATION_INFO;
      }
      getPrefixCode() {
        let prefix = "";
        if (this.hadExport) {
          prefix += 'Object.defineProperty(exports, "__esModule", {value: true});';
        }
        return prefix;
      }
      getSuffixCode() {
        if (this.enableLegacyBabel5ModuleInterop && this.hadDefaultExport && !this.hadNamedExport) {
          return "\nmodule.exports = exports.default;\n";
        }
        return "";
      }
      process() {
        if (this.tokens.matches3(_types.TokenType._import, _types.TokenType.name, _types.TokenType.eq)) {
          return this.processImportEquals();
        }
        if (this.tokens.matches1(_types.TokenType._import)) {
          this.processImport();
          return true;
        }
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType.eq)) {
          this.tokens.replaceToken("module.exports");
          return true;
        }
        if (this.tokens.matches1(_types.TokenType._export) && !this.tokens.currentToken().isType) {
          this.hadExport = true;
          return this.processExport();
        }
        if (this.tokens.matches2(_types.TokenType.name, _types.TokenType.postIncDec)) {
          if (this.processPostIncDec()) {
            return true;
          }
        }
        if (this.tokens.matches1(_types.TokenType.name) || this.tokens.matches1(_types.TokenType.jsxName)) {
          return this.processIdentifier();
        }
        if (this.tokens.matches1(_types.TokenType.eq)) {
          return this.processAssignment();
        }
        if (this.tokens.matches1(_types.TokenType.assign)) {
          return this.processComplexAssignment();
        }
        if (this.tokens.matches1(_types.TokenType.preIncDec)) {
          return this.processPreIncDec();
        }
        return false;
      }
      processImportEquals() {
        const importName = this.tokens.identifierNameAtIndex(this.tokens.currentIndex() + 1);
        if (this.importProcessor.shouldAutomaticallyElideImportedName(importName)) {
          _elideImportEquals2.default.call(void 0, this.tokens);
        } else {
          this.tokens.replaceToken("const");
        }
        return true;
      }
      /**
       * Transform this:
       * import foo, {bar} from 'baz';
       * into
       * var _baz = require('baz'); var _baz2 = _interopRequireDefault(_baz);
       *
       * The import code was already generated in the import preprocessing step, so
       * we just need to look it up.
       */
      processImport() {
        if (this.tokens.matches2(_types.TokenType._import, _types.TokenType.parenL)) {
          if (this.preserveDynamicImport) {
            this.tokens.copyToken();
            return;
          }
          const requireWrapper = this.enableLegacyTypeScriptModuleInterop ? "" : `${this.helperManager.getHelperName("interopRequireWildcard")}(`;
          this.tokens.replaceToken(`Promise.resolve().then(() => ${requireWrapper}require`);
          const contextId = this.tokens.currentToken().contextId;
          if (contextId == null) {
            throw new Error("Expected context ID on dynamic import invocation.");
          }
          this.tokens.copyToken();
          while (!this.tokens.matchesContextIdAndLabel(_types.TokenType.parenR, contextId)) {
            this.rootTransformer.processToken();
          }
          this.tokens.replaceToken(requireWrapper ? ")))" : "))");
          return;
        }
        const shouldElideImport = this.removeImportAndDetectIfShouldElide();
        if (shouldElideImport) {
          this.tokens.removeToken();
        } else {
          const path33 = this.tokens.stringValue();
          this.tokens.replaceTokenTrimmingLeftWhitespace(this.importProcessor.claimImportCode(path33));
          this.tokens.appendCode(this.importProcessor.claimImportCode(path33));
        }
        _removeMaybeImportAttributes.removeMaybeImportAttributes.call(void 0, this.tokens);
        if (this.tokens.matches1(_types.TokenType.semi)) {
          this.tokens.removeToken();
        }
      }
      /**
       * Erase this import (since any CJS output would be completely different), and
       * return true if this import is should be elided due to being a type-only
       * import. Such imports will not be emitted at all to avoid side effects.
       *
       * Import elision only happens with the TypeScript or Flow transforms enabled.
       *
       * TODO: This function has some awkward overlap with
       *  CJSImportProcessor.pruneTypeOnlyImports , and the two should be unified.
       *  That function handles TypeScript implicit import name elision, and removes
       *  an import if all typical imported names (without `type`) are removed due
       *  to being type-only imports. This function handles Flow import removal and
       *  properly distinguishes `import 'foo'` from `import {} from 'foo'` for TS
       *  purposes.
       *
       * The position should end at the import string.
       */
      removeImportAndDetectIfShouldElide() {
        this.tokens.removeInitialToken();
        if (this.tokens.matchesContextual(_keywords.ContextualKeyword._type) && !this.tokens.matches1AtIndex(this.tokens.currentIndex() + 1, _types.TokenType.comma) && !this.tokens.matchesContextualAtIndex(this.tokens.currentIndex() + 1, _keywords.ContextualKeyword._from)) {
          this.removeRemainingImport();
          return true;
        }
        if (this.tokens.matches1(_types.TokenType.name) || this.tokens.matches1(_types.TokenType.star)) {
          this.removeRemainingImport();
          return false;
        }
        if (this.tokens.matches1(_types.TokenType.string)) {
          return false;
        }
        let foundNonTypeImport = false;
        let foundAnyNamedImport = false;
        while (!this.tokens.matches1(_types.TokenType.string)) {
          if (!foundNonTypeImport && this.tokens.matches1(_types.TokenType.braceL) || this.tokens.matches1(_types.TokenType.comma)) {
            this.tokens.removeToken();
            if (!this.tokens.matches1(_types.TokenType.braceR)) {
              foundAnyNamedImport = true;
            }
            if (this.tokens.matches2(_types.TokenType.name, _types.TokenType.comma) || this.tokens.matches2(_types.TokenType.name, _types.TokenType.braceR) || this.tokens.matches4(_types.TokenType.name, _types.TokenType.name, _types.TokenType.name, _types.TokenType.comma) || this.tokens.matches4(_types.TokenType.name, _types.TokenType.name, _types.TokenType.name, _types.TokenType.braceR)) {
              foundNonTypeImport = true;
            }
          }
          this.tokens.removeToken();
        }
        if (this.keepUnusedImports) {
          return false;
        }
        if (this.isTypeScriptTransformEnabled) {
          return !foundNonTypeImport;
        } else if (this.isFlowTransformEnabled) {
          return foundAnyNamedImport && !foundNonTypeImport;
        } else {
          return false;
        }
      }
      removeRemainingImport() {
        while (!this.tokens.matches1(_types.TokenType.string)) {
          this.tokens.removeToken();
        }
      }
      processIdentifier() {
        const token = this.tokens.currentToken();
        if (token.shadowsGlobal) {
          return false;
        }
        if (token.identifierRole === _tokenizer.IdentifierRole.ObjectShorthand) {
          return this.processObjectShorthand();
        }
        if (token.identifierRole !== _tokenizer.IdentifierRole.Access) {
          return false;
        }
        const replacement = this.importProcessor.getIdentifierReplacement(
          this.tokens.identifierNameForToken(token)
        );
        if (!replacement) {
          return false;
        }
        let possibleOpenParenIndex = this.tokens.currentIndex() + 1;
        while (possibleOpenParenIndex < this.tokens.tokens.length && this.tokens.tokens[possibleOpenParenIndex].type === _types.TokenType.parenR) {
          possibleOpenParenIndex++;
        }
        if (this.tokens.tokens[possibleOpenParenIndex].type === _types.TokenType.parenL) {
          if (this.tokens.tokenAtRelativeIndex(1).type === _types.TokenType.parenL && this.tokens.tokenAtRelativeIndex(-1).type !== _types.TokenType._new) {
            this.tokens.replaceToken(`${replacement}.call(void 0, `);
            this.tokens.removeToken();
            this.rootTransformer.processBalancedCode();
            this.tokens.copyExpectedToken(_types.TokenType.parenR);
          } else {
            this.tokens.replaceToken(`(0, ${replacement})`);
          }
        } else {
          this.tokens.replaceToken(replacement);
        }
        return true;
      }
      processObjectShorthand() {
        const identifier = this.tokens.identifierName();
        const replacement = this.importProcessor.getIdentifierReplacement(identifier);
        if (!replacement) {
          return false;
        }
        this.tokens.replaceToken(`${identifier}: ${replacement}`);
        return true;
      }
      processExport() {
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType._enum) || this.tokens.matches3(_types.TokenType._export, _types.TokenType._const, _types.TokenType._enum)) {
          this.hadNamedExport = true;
          return false;
        }
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType._default)) {
          if (this.tokens.matches3(_types.TokenType._export, _types.TokenType._default, _types.TokenType._enum)) {
            this.hadDefaultExport = true;
            return false;
          }
          this.processExportDefault();
          return true;
        } else if (this.tokens.matches2(_types.TokenType._export, _types.TokenType.braceL)) {
          this.processExportBindings();
          return true;
        } else if (this.tokens.matches2(_types.TokenType._export, _types.TokenType.name) && this.tokens.matchesContextualAtIndex(this.tokens.currentIndex() + 1, _keywords.ContextualKeyword._type)) {
          this.tokens.removeInitialToken();
          this.tokens.removeToken();
          if (this.tokens.matches1(_types.TokenType.braceL)) {
            while (!this.tokens.matches1(_types.TokenType.braceR)) {
              this.tokens.removeToken();
            }
            this.tokens.removeToken();
          } else {
            this.tokens.removeToken();
            if (this.tokens.matches1(_types.TokenType._as)) {
              this.tokens.removeToken();
              this.tokens.removeToken();
            }
          }
          if (this.tokens.matchesContextual(_keywords.ContextualKeyword._from) && this.tokens.matches1AtIndex(this.tokens.currentIndex() + 1, _types.TokenType.string)) {
            this.tokens.removeToken();
            this.tokens.removeToken();
            _removeMaybeImportAttributes.removeMaybeImportAttributes.call(void 0, this.tokens);
          }
          return true;
        }
        this.hadNamedExport = true;
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType._var) || this.tokens.matches2(_types.TokenType._export, _types.TokenType._let) || this.tokens.matches2(_types.TokenType._export, _types.TokenType._const)) {
          this.processExportVar();
          return true;
        } else if (this.tokens.matches2(_types.TokenType._export, _types.TokenType._function) || // export async function
        this.tokens.matches3(_types.TokenType._export, _types.TokenType.name, _types.TokenType._function)) {
          this.processExportFunction();
          return true;
        } else if (this.tokens.matches2(_types.TokenType._export, _types.TokenType._class) || this.tokens.matches3(_types.TokenType._export, _types.TokenType._abstract, _types.TokenType._class) || this.tokens.matches2(_types.TokenType._export, _types.TokenType.at)) {
          this.processExportClass();
          return true;
        } else if (this.tokens.matches2(_types.TokenType._export, _types.TokenType.star)) {
          this.processExportStar();
          return true;
        } else {
          throw new Error("Unrecognized export syntax.");
        }
      }
      processAssignment() {
        const index = this.tokens.currentIndex();
        const identifierToken = this.tokens.tokens[index - 1];
        if (identifierToken.isType || identifierToken.type !== _types.TokenType.name) {
          return false;
        }
        if (identifierToken.shadowsGlobal) {
          return false;
        }
        if (index >= 2 && this.tokens.matches1AtIndex(index - 2, _types.TokenType.dot)) {
          return false;
        }
        if (index >= 2 && [_types.TokenType._var, _types.TokenType._let, _types.TokenType._const].includes(this.tokens.tokens[index - 2].type)) {
          return false;
        }
        const assignmentSnippet = this.importProcessor.resolveExportBinding(
          this.tokens.identifierNameForToken(identifierToken)
        );
        if (!assignmentSnippet) {
          return false;
        }
        this.tokens.copyToken();
        this.tokens.appendCode(` ${assignmentSnippet} =`);
        return true;
      }
      /**
       * Process something like `a += 3`, where `a` might be an exported value.
       */
      processComplexAssignment() {
        const index = this.tokens.currentIndex();
        const identifierToken = this.tokens.tokens[index - 1];
        if (identifierToken.type !== _types.TokenType.name) {
          return false;
        }
        if (identifierToken.shadowsGlobal) {
          return false;
        }
        if (index >= 2 && this.tokens.matches1AtIndex(index - 2, _types.TokenType.dot)) {
          return false;
        }
        const assignmentSnippet = this.importProcessor.resolveExportBinding(
          this.tokens.identifierNameForToken(identifierToken)
        );
        if (!assignmentSnippet) {
          return false;
        }
        this.tokens.appendCode(` = ${assignmentSnippet}`);
        this.tokens.copyToken();
        return true;
      }
      /**
       * Process something like `++a`, where `a` might be an exported value.
       */
      processPreIncDec() {
        const index = this.tokens.currentIndex();
        const identifierToken = this.tokens.tokens[index + 1];
        if (identifierToken.type !== _types.TokenType.name) {
          return false;
        }
        if (identifierToken.shadowsGlobal) {
          return false;
        }
        if (index + 2 < this.tokens.tokens.length && (this.tokens.matches1AtIndex(index + 2, _types.TokenType.dot) || this.tokens.matches1AtIndex(index + 2, _types.TokenType.bracketL) || this.tokens.matches1AtIndex(index + 2, _types.TokenType.parenL))) {
          return false;
        }
        const identifierName = this.tokens.identifierNameForToken(identifierToken);
        const assignmentSnippet = this.importProcessor.resolveExportBinding(identifierName);
        if (!assignmentSnippet) {
          return false;
        }
        this.tokens.appendCode(`${assignmentSnippet} = `);
        this.tokens.copyToken();
        return true;
      }
      /**
       * Process something like `a++`, where `a` might be an exported value.
       * This starts at the `a`, not at the `++`.
       */
      processPostIncDec() {
        const index = this.tokens.currentIndex();
        const identifierToken = this.tokens.tokens[index];
        const operatorToken = this.tokens.tokens[index + 1];
        if (identifierToken.type !== _types.TokenType.name) {
          return false;
        }
        if (identifierToken.shadowsGlobal) {
          return false;
        }
        if (index >= 1 && this.tokens.matches1AtIndex(index - 1, _types.TokenType.dot)) {
          return false;
        }
        const identifierName = this.tokens.identifierNameForToken(identifierToken);
        const assignmentSnippet = this.importProcessor.resolveExportBinding(identifierName);
        if (!assignmentSnippet) {
          return false;
        }
        const operatorCode = this.tokens.rawCodeForToken(operatorToken);
        const base = this.importProcessor.getIdentifierReplacement(identifierName) || identifierName;
        if (operatorCode === "++") {
          this.tokens.replaceToken(`(${base} = ${assignmentSnippet} = ${base} + 1, ${base} - 1)`);
        } else if (operatorCode === "--") {
          this.tokens.replaceToken(`(${base} = ${assignmentSnippet} = ${base} - 1, ${base} + 1)`);
        } else {
          throw new Error(`Unexpected operator: ${operatorCode}`);
        }
        this.tokens.removeToken();
        return true;
      }
      processExportDefault() {
        let exportedRuntimeValue = true;
        if (this.tokens.matches4(_types.TokenType._export, _types.TokenType._default, _types.TokenType._function, _types.TokenType.name) || // export default async function
        this.tokens.matches5(_types.TokenType._export, _types.TokenType._default, _types.TokenType.name, _types.TokenType._function, _types.TokenType.name) && this.tokens.matchesContextualAtIndex(
          this.tokens.currentIndex() + 2,
          _keywords.ContextualKeyword._async
        )) {
          this.tokens.removeInitialToken();
          this.tokens.removeToken();
          const name28 = this.processNamedFunction();
          this.tokens.appendCode(` exports.default = ${name28};`);
        } else if (this.tokens.matches4(_types.TokenType._export, _types.TokenType._default, _types.TokenType._class, _types.TokenType.name) || this.tokens.matches5(_types.TokenType._export, _types.TokenType._default, _types.TokenType._abstract, _types.TokenType._class, _types.TokenType.name) || this.tokens.matches3(_types.TokenType._export, _types.TokenType._default, _types.TokenType.at)) {
          this.tokens.removeInitialToken();
          this.tokens.removeToken();
          this.copyDecorators();
          if (this.tokens.matches1(_types.TokenType._abstract)) {
            this.tokens.removeToken();
          }
          const name28 = this.rootTransformer.processNamedClass();
          this.tokens.appendCode(` exports.default = ${name28};`);
        } else if (_shouldElideDefaultExport2.default.call(
          void 0,
          this.isTypeScriptTransformEnabled,
          this.keepUnusedImports,
          this.tokens,
          this.declarationInfo
        )) {
          exportedRuntimeValue = false;
          this.tokens.removeInitialToken();
          this.tokens.removeToken();
          this.tokens.removeToken();
        } else if (this.reactHotLoaderTransformer) {
          const defaultVarName = this.nameManager.claimFreeName("_default");
          this.tokens.replaceToken(`let ${defaultVarName}; exports.`);
          this.tokens.copyToken();
          this.tokens.appendCode(` = ${defaultVarName} =`);
          this.reactHotLoaderTransformer.setExtractedDefaultExportName(defaultVarName);
        } else {
          this.tokens.replaceToken("exports.");
          this.tokens.copyToken();
          this.tokens.appendCode(" =");
        }
        if (exportedRuntimeValue) {
          this.hadDefaultExport = true;
        }
      }
      copyDecorators() {
        while (this.tokens.matches1(_types.TokenType.at)) {
          this.tokens.copyToken();
          if (this.tokens.matches1(_types.TokenType.parenL)) {
            this.tokens.copyExpectedToken(_types.TokenType.parenL);
            this.rootTransformer.processBalancedCode();
            this.tokens.copyExpectedToken(_types.TokenType.parenR);
          } else {
            this.tokens.copyExpectedToken(_types.TokenType.name);
            while (this.tokens.matches1(_types.TokenType.dot)) {
              this.tokens.copyExpectedToken(_types.TokenType.dot);
              this.tokens.copyExpectedToken(_types.TokenType.name);
            }
            if (this.tokens.matches1(_types.TokenType.parenL)) {
              this.tokens.copyExpectedToken(_types.TokenType.parenL);
              this.rootTransformer.processBalancedCode();
              this.tokens.copyExpectedToken(_types.TokenType.parenR);
            }
          }
        }
      }
      /**
       * Transform a declaration like `export var`, `export let`, or `export const`.
       */
      processExportVar() {
        if (this.isSimpleExportVar()) {
          this.processSimpleExportVar();
        } else {
          this.processComplexExportVar();
        }
      }
      /**
       * Determine if the export is of the form:
       * export var/let/const [varName] = [expr];
       * In other words, determine if function name inference might apply.
       */
      isSimpleExportVar() {
        let tokenIndex = this.tokens.currentIndex();
        tokenIndex++;
        tokenIndex++;
        if (!this.tokens.matches1AtIndex(tokenIndex, _types.TokenType.name)) {
          return false;
        }
        tokenIndex++;
        while (tokenIndex < this.tokens.tokens.length && this.tokens.tokens[tokenIndex].isType) {
          tokenIndex++;
        }
        if (!this.tokens.matches1AtIndex(tokenIndex, _types.TokenType.eq)) {
          return false;
        }
        return true;
      }
      /**
       * Transform an `export var` declaration initializing a single variable.
       *
       * For example, this:
       * export const f = () => {};
       * becomes this:
       * const f = () => {}; exports.f = f;
       *
       * The variable is unused (e.g. exports.f has the true value of the export).
       * We need to produce an assignment of this form so that the function will
       * have an inferred name of "f", which wouldn't happen in the more general
       * case below.
       */
      processSimpleExportVar() {
        this.tokens.removeInitialToken();
        this.tokens.copyToken();
        const varName = this.tokens.identifierName();
        while (!this.tokens.matches1(_types.TokenType.eq)) {
          this.rootTransformer.processToken();
        }
        const endIndex = this.tokens.currentToken().rhsEndIndex;
        if (endIndex == null) {
          throw new Error("Expected = token with an end index.");
        }
        while (this.tokens.currentIndex() < endIndex) {
          this.rootTransformer.processToken();
        }
        this.tokens.appendCode(`; exports.${varName} = ${varName}`);
      }
      /**
       * Transform normal declaration exports, including handling destructuring.
       * For example, this:
       * export const {x: [a = 2, b], c} = d;
       * becomes this:
       * ({x: [exports.a = 2, exports.b], c: exports.c} = d;)
       */
      processComplexExportVar() {
        this.tokens.removeInitialToken();
        this.tokens.removeToken();
        const needsParens = this.tokens.matches1(_types.TokenType.braceL);
        if (needsParens) {
          this.tokens.appendCode("(");
        }
        let depth = 0;
        while (true) {
          if (this.tokens.matches1(_types.TokenType.braceL) || this.tokens.matches1(_types.TokenType.dollarBraceL) || this.tokens.matches1(_types.TokenType.bracketL)) {
            depth++;
            this.tokens.copyToken();
          } else if (this.tokens.matches1(_types.TokenType.braceR) || this.tokens.matches1(_types.TokenType.bracketR)) {
            depth--;
            this.tokens.copyToken();
          } else if (depth === 0 && !this.tokens.matches1(_types.TokenType.name) && !this.tokens.currentToken().isType) {
            break;
          } else if (this.tokens.matches1(_types.TokenType.eq)) {
            const endIndex = this.tokens.currentToken().rhsEndIndex;
            if (endIndex == null) {
              throw new Error("Expected = token with an end index.");
            }
            while (this.tokens.currentIndex() < endIndex) {
              this.rootTransformer.processToken();
            }
          } else {
            const token = this.tokens.currentToken();
            if (_tokenizer.isDeclaration.call(void 0, token)) {
              const name28 = this.tokens.identifierName();
              let replacement = this.importProcessor.getIdentifierReplacement(name28);
              if (replacement === null) {
                throw new Error(`Expected a replacement for ${name28} in \`export var\` syntax.`);
              }
              if (_tokenizer.isObjectShorthandDeclaration.call(void 0, token)) {
                replacement = `${name28}: ${replacement}`;
              }
              this.tokens.replaceToken(replacement);
            } else {
              this.rootTransformer.processToken();
            }
          }
        }
        if (needsParens) {
          const endIndex = this.tokens.currentToken().rhsEndIndex;
          if (endIndex == null) {
            throw new Error("Expected = token with an end index.");
          }
          while (this.tokens.currentIndex() < endIndex) {
            this.rootTransformer.processToken();
          }
          this.tokens.appendCode(")");
        }
      }
      /**
       * Transform this:
       * export function foo() {}
       * into this:
       * function foo() {} exports.foo = foo;
       */
      processExportFunction() {
        this.tokens.replaceToken("");
        const name28 = this.processNamedFunction();
        this.tokens.appendCode(` exports.${name28} = ${name28};`);
      }
      /**
       * Skip past a function with a name and return that name.
       */
      processNamedFunction() {
        if (this.tokens.matches1(_types.TokenType._function)) {
          this.tokens.copyToken();
        } else if (this.tokens.matches2(_types.TokenType.name, _types.TokenType._function)) {
          if (!this.tokens.matchesContextual(_keywords.ContextualKeyword._async)) {
            throw new Error("Expected async keyword in function export.");
          }
          this.tokens.copyToken();
          this.tokens.copyToken();
        }
        if (this.tokens.matches1(_types.TokenType.star)) {
          this.tokens.copyToken();
        }
        if (!this.tokens.matches1(_types.TokenType.name)) {
          throw new Error("Expected identifier for exported function name.");
        }
        const name28 = this.tokens.identifierName();
        this.tokens.copyToken();
        if (this.tokens.currentToken().isType) {
          this.tokens.removeInitialToken();
          while (this.tokens.currentToken().isType) {
            this.tokens.removeToken();
          }
        }
        this.tokens.copyExpectedToken(_types.TokenType.parenL);
        this.rootTransformer.processBalancedCode();
        this.tokens.copyExpectedToken(_types.TokenType.parenR);
        this.rootTransformer.processPossibleTypeRange();
        this.tokens.copyExpectedToken(_types.TokenType.braceL);
        this.rootTransformer.processBalancedCode();
        this.tokens.copyExpectedToken(_types.TokenType.braceR);
        return name28;
      }
      /**
       * Transform this:
       * export class A {}
       * into this:
       * class A {} exports.A = A;
       */
      processExportClass() {
        this.tokens.removeInitialToken();
        this.copyDecorators();
        if (this.tokens.matches1(_types.TokenType._abstract)) {
          this.tokens.removeToken();
        }
        const name28 = this.rootTransformer.processNamedClass();
        this.tokens.appendCode(` exports.${name28} = ${name28};`);
      }
      /**
       * Transform this:
       * export {a, b as c};
       * into this:
       * exports.a = a; exports.c = b;
       *
       * OR
       *
       * Transform this:
       * export {a, b as c} from './foo';
       * into the pre-generated Object.defineProperty code from the ImportProcessor.
       *
       * For the first case, if the TypeScript transform is enabled, we need to skip
       * exports that are only defined as types.
       */
      processExportBindings() {
        this.tokens.removeInitialToken();
        this.tokens.removeToken();
        const isReExport = _isExportFrom2.default.call(void 0, this.tokens);
        const exportStatements = [];
        while (true) {
          if (this.tokens.matches1(_types.TokenType.braceR)) {
            this.tokens.removeToken();
            break;
          }
          const specifierInfo = _getImportExportSpecifierInfo2.default.call(void 0, this.tokens);
          while (this.tokens.currentIndex() < specifierInfo.endIndex) {
            this.tokens.removeToken();
          }
          const shouldRemoveExport = specifierInfo.isType || !isReExport && this.shouldElideExportedIdentifier(specifierInfo.leftName);
          if (!shouldRemoveExport) {
            const exportedName = specifierInfo.rightName;
            if (exportedName === "default") {
              this.hadDefaultExport = true;
            } else {
              this.hadNamedExport = true;
            }
            const localName = specifierInfo.leftName;
            const newLocalName = this.importProcessor.getIdentifierReplacement(localName);
            exportStatements.push(`exports.${exportedName} = ${newLocalName || localName};`);
          }
          if (this.tokens.matches1(_types.TokenType.braceR)) {
            this.tokens.removeToken();
            break;
          }
          if (this.tokens.matches2(_types.TokenType.comma, _types.TokenType.braceR)) {
            this.tokens.removeToken();
            this.tokens.removeToken();
            break;
          } else if (this.tokens.matches1(_types.TokenType.comma)) {
            this.tokens.removeToken();
          } else {
            throw new Error(`Unexpected token: ${JSON.stringify(this.tokens.currentToken())}`);
          }
        }
        if (this.tokens.matchesContextual(_keywords.ContextualKeyword._from)) {
          this.tokens.removeToken();
          const path33 = this.tokens.stringValue();
          this.tokens.replaceTokenTrimmingLeftWhitespace(this.importProcessor.claimImportCode(path33));
          _removeMaybeImportAttributes.removeMaybeImportAttributes.call(void 0, this.tokens);
        } else {
          this.tokens.appendCode(exportStatements.join(" "));
        }
        if (this.tokens.matches1(_types.TokenType.semi)) {
          this.tokens.removeToken();
        }
      }
      processExportStar() {
        this.tokens.removeInitialToken();
        while (!this.tokens.matches1(_types.TokenType.string)) {
          this.tokens.removeToken();
        }
        const path33 = this.tokens.stringValue();
        this.tokens.replaceTokenTrimmingLeftWhitespace(this.importProcessor.claimImportCode(path33));
        _removeMaybeImportAttributes.removeMaybeImportAttributes.call(void 0, this.tokens);
        if (this.tokens.matches1(_types.TokenType.semi)) {
          this.tokens.removeToken();
        }
      }
      shouldElideExportedIdentifier(name28) {
        return this.isTypeScriptTransformEnabled && !this.keepUnusedImports && !this.declarationInfo.valueDeclarations.has(name28);
      }
    };
    exports2.default = CJSImportTransformer;
  }
});

// node_modules/sucrase/dist/transformers/ESMImportTransformer.js
var require_ESMImportTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/ESMImportTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _keywords = require_keywords();
    var _types = require_types();
    var _elideImportEquals = require_elideImportEquals();
    var _elideImportEquals2 = _interopRequireDefault(_elideImportEquals);
    var _getDeclarationInfo = require_getDeclarationInfo();
    var _getDeclarationInfo2 = _interopRequireDefault(_getDeclarationInfo);
    var _getImportExportSpecifierInfo = require_getImportExportSpecifierInfo();
    var _getImportExportSpecifierInfo2 = _interopRequireDefault(_getImportExportSpecifierInfo);
    var _getNonTypeIdentifiers = require_getNonTypeIdentifiers();
    var _isExportFrom = require_isExportFrom();
    var _isExportFrom2 = _interopRequireDefault(_isExportFrom);
    var _removeMaybeImportAttributes = require_removeMaybeImportAttributes();
    var _shouldElideDefaultExport = require_shouldElideDefaultExport();
    var _shouldElideDefaultExport2 = _interopRequireDefault(_shouldElideDefaultExport);
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var ESMImportTransformer = class extends _Transformer2.default {
      constructor(tokens, nameManager, helperManager, reactHotLoaderTransformer, isTypeScriptTransformEnabled, isFlowTransformEnabled, keepUnusedImports, options) {
        super();
        this.tokens = tokens;
        this.nameManager = nameManager;
        this.helperManager = helperManager;
        this.reactHotLoaderTransformer = reactHotLoaderTransformer;
        this.isTypeScriptTransformEnabled = isTypeScriptTransformEnabled;
        this.isFlowTransformEnabled = isFlowTransformEnabled;
        this.keepUnusedImports = keepUnusedImports;
        ;
        this.nonTypeIdentifiers = isTypeScriptTransformEnabled && !keepUnusedImports ? _getNonTypeIdentifiers.getNonTypeIdentifiers.call(void 0, tokens, options) : /* @__PURE__ */ new Set();
        this.declarationInfo = isTypeScriptTransformEnabled && !keepUnusedImports ? _getDeclarationInfo2.default.call(void 0, tokens) : _getDeclarationInfo.EMPTY_DECLARATION_INFO;
        this.injectCreateRequireForImportRequire = Boolean(options.injectCreateRequireForImportRequire);
      }
      process() {
        if (this.tokens.matches3(_types.TokenType._import, _types.TokenType.name, _types.TokenType.eq)) {
          return this.processImportEquals();
        }
        if (this.tokens.matches4(_types.TokenType._import, _types.TokenType.name, _types.TokenType.name, _types.TokenType.eq) && this.tokens.matchesContextualAtIndex(this.tokens.currentIndex() + 1, _keywords.ContextualKeyword._type)) {
          this.tokens.removeInitialToken();
          for (let i = 0; i < 7; i++) {
            this.tokens.removeToken();
          }
          return true;
        }
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType.eq)) {
          this.tokens.replaceToken("module.exports");
          return true;
        }
        if (this.tokens.matches5(_types.TokenType._export, _types.TokenType._import, _types.TokenType.name, _types.TokenType.name, _types.TokenType.eq) && this.tokens.matchesContextualAtIndex(this.tokens.currentIndex() + 2, _keywords.ContextualKeyword._type)) {
          this.tokens.removeInitialToken();
          for (let i = 0; i < 8; i++) {
            this.tokens.removeToken();
          }
          return true;
        }
        if (this.tokens.matches1(_types.TokenType._import)) {
          return this.processImport();
        }
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType._default)) {
          return this.processExportDefault();
        }
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType.braceL)) {
          return this.processNamedExports();
        }
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType.name) && this.tokens.matchesContextualAtIndex(this.tokens.currentIndex() + 1, _keywords.ContextualKeyword._type)) {
          this.tokens.removeInitialToken();
          this.tokens.removeToken();
          if (this.tokens.matches1(_types.TokenType.braceL)) {
            while (!this.tokens.matches1(_types.TokenType.braceR)) {
              this.tokens.removeToken();
            }
            this.tokens.removeToken();
          } else {
            this.tokens.removeToken();
            if (this.tokens.matches1(_types.TokenType._as)) {
              this.tokens.removeToken();
              this.tokens.removeToken();
            }
          }
          if (this.tokens.matchesContextual(_keywords.ContextualKeyword._from) && this.tokens.matches1AtIndex(this.tokens.currentIndex() + 1, _types.TokenType.string)) {
            this.tokens.removeToken();
            this.tokens.removeToken();
            _removeMaybeImportAttributes.removeMaybeImportAttributes.call(void 0, this.tokens);
          }
          return true;
        }
        return false;
      }
      processImportEquals() {
        const importName = this.tokens.identifierNameAtIndex(this.tokens.currentIndex() + 1);
        if (this.shouldAutomaticallyElideImportedName(importName)) {
          _elideImportEquals2.default.call(void 0, this.tokens);
        } else if (this.injectCreateRequireForImportRequire) {
          this.tokens.replaceToken("const");
          this.tokens.copyToken();
          this.tokens.copyToken();
          this.tokens.replaceToken(this.helperManager.getHelperName("require"));
        } else {
          this.tokens.replaceToken("const");
        }
        return true;
      }
      processImport() {
        if (this.tokens.matches2(_types.TokenType._import, _types.TokenType.parenL)) {
          return false;
        }
        const snapshot = this.tokens.snapshot();
        const allImportsRemoved = this.removeImportTypeBindings();
        if (allImportsRemoved) {
          this.tokens.restoreToSnapshot(snapshot);
          while (!this.tokens.matches1(_types.TokenType.string)) {
            this.tokens.removeToken();
          }
          this.tokens.removeToken();
          _removeMaybeImportAttributes.removeMaybeImportAttributes.call(void 0, this.tokens);
          if (this.tokens.matches1(_types.TokenType.semi)) {
            this.tokens.removeToken();
          }
        }
        return true;
      }
      /**
       * Remove type bindings from this import, leaving the rest of the import intact.
       *
       * Return true if this import was ONLY types, and thus is eligible for removal. This will bail out
       * of the replacement operation, so we can return early here.
       */
      removeImportTypeBindings() {
        this.tokens.copyExpectedToken(_types.TokenType._import);
        if (this.tokens.matchesContextual(_keywords.ContextualKeyword._type) && !this.tokens.matches1AtIndex(this.tokens.currentIndex() + 1, _types.TokenType.comma) && !this.tokens.matchesContextualAtIndex(this.tokens.currentIndex() + 1, _keywords.ContextualKeyword._from)) {
          return true;
        }
        if (this.tokens.matches1(_types.TokenType.string)) {
          this.tokens.copyToken();
          return false;
        }
        if (this.tokens.matchesContextual(_keywords.ContextualKeyword._module) && this.tokens.matchesContextualAtIndex(this.tokens.currentIndex() + 2, _keywords.ContextualKeyword._from)) {
          this.tokens.copyToken();
        }
        let foundNonTypeImport = false;
        let foundAnyNamedImport = false;
        let needsComma = false;
        if (this.tokens.matches1(_types.TokenType.name)) {
          if (this.shouldAutomaticallyElideImportedName(this.tokens.identifierName())) {
            this.tokens.removeToken();
            if (this.tokens.matches1(_types.TokenType.comma)) {
              this.tokens.removeToken();
            }
          } else {
            foundNonTypeImport = true;
            this.tokens.copyToken();
            if (this.tokens.matches1(_types.TokenType.comma)) {
              needsComma = true;
              this.tokens.removeToken();
            }
          }
        }
        if (this.tokens.matches1(_types.TokenType.star)) {
          if (this.shouldAutomaticallyElideImportedName(this.tokens.identifierNameAtRelativeIndex(2))) {
            this.tokens.removeToken();
            this.tokens.removeToken();
            this.tokens.removeToken();
          } else {
            if (needsComma) {
              this.tokens.appendCode(",");
            }
            foundNonTypeImport = true;
            this.tokens.copyExpectedToken(_types.TokenType.star);
            this.tokens.copyExpectedToken(_types.TokenType.name);
            this.tokens.copyExpectedToken(_types.TokenType.name);
          }
        } else if (this.tokens.matches1(_types.TokenType.braceL)) {
          if (needsComma) {
            this.tokens.appendCode(",");
          }
          this.tokens.copyToken();
          while (!this.tokens.matches1(_types.TokenType.braceR)) {
            foundAnyNamedImport = true;
            const specifierInfo = _getImportExportSpecifierInfo2.default.call(void 0, this.tokens);
            if (specifierInfo.isType || this.shouldAutomaticallyElideImportedName(specifierInfo.rightName)) {
              while (this.tokens.currentIndex() < specifierInfo.endIndex) {
                this.tokens.removeToken();
              }
              if (this.tokens.matches1(_types.TokenType.comma)) {
                this.tokens.removeToken();
              }
            } else {
              foundNonTypeImport = true;
              while (this.tokens.currentIndex() < specifierInfo.endIndex) {
                this.tokens.copyToken();
              }
              if (this.tokens.matches1(_types.TokenType.comma)) {
                this.tokens.copyToken();
              }
            }
          }
          this.tokens.copyExpectedToken(_types.TokenType.braceR);
        }
        if (this.keepUnusedImports) {
          return false;
        }
        if (this.isTypeScriptTransformEnabled) {
          return !foundNonTypeImport;
        } else if (this.isFlowTransformEnabled) {
          return foundAnyNamedImport && !foundNonTypeImport;
        } else {
          return false;
        }
      }
      shouldAutomaticallyElideImportedName(name28) {
        return this.isTypeScriptTransformEnabled && !this.keepUnusedImports && !this.nonTypeIdentifiers.has(name28);
      }
      processExportDefault() {
        if (_shouldElideDefaultExport2.default.call(
          void 0,
          this.isTypeScriptTransformEnabled,
          this.keepUnusedImports,
          this.tokens,
          this.declarationInfo
        )) {
          this.tokens.removeInitialToken();
          this.tokens.removeToken();
          this.tokens.removeToken();
          return true;
        }
        const alreadyHasName = this.tokens.matches4(_types.TokenType._export, _types.TokenType._default, _types.TokenType._function, _types.TokenType.name) || // export default async function
        this.tokens.matches5(_types.TokenType._export, _types.TokenType._default, _types.TokenType.name, _types.TokenType._function, _types.TokenType.name) && this.tokens.matchesContextualAtIndex(
          this.tokens.currentIndex() + 2,
          _keywords.ContextualKeyword._async
        ) || this.tokens.matches4(_types.TokenType._export, _types.TokenType._default, _types.TokenType._class, _types.TokenType.name) || this.tokens.matches5(_types.TokenType._export, _types.TokenType._default, _types.TokenType._abstract, _types.TokenType._class, _types.TokenType.name);
        if (!alreadyHasName && this.reactHotLoaderTransformer) {
          const defaultVarName = this.nameManager.claimFreeName("_default");
          this.tokens.replaceToken(`let ${defaultVarName}; export`);
          this.tokens.copyToken();
          this.tokens.appendCode(` ${defaultVarName} =`);
          this.reactHotLoaderTransformer.setExtractedDefaultExportName(defaultVarName);
          return true;
        }
        return false;
      }
      /**
       * Handle a statement with one of these forms:
       * export {a, type b};
       * export {c, type d} from 'foo';
       *
       * In both cases, any explicit type exports should be removed. In the first
       * case, we also need to handle implicit export elision for names declared as
       * types. In the second case, we must NOT do implicit named export elision,
       * but we must remove the runtime import if all exports are type exports.
       */
      processNamedExports() {
        if (!this.isTypeScriptTransformEnabled) {
          return false;
        }
        this.tokens.copyExpectedToken(_types.TokenType._export);
        this.tokens.copyExpectedToken(_types.TokenType.braceL);
        const isReExport = _isExportFrom2.default.call(void 0, this.tokens);
        let foundNonTypeExport = false;
        while (!this.tokens.matches1(_types.TokenType.braceR)) {
          const specifierInfo = _getImportExportSpecifierInfo2.default.call(void 0, this.tokens);
          if (specifierInfo.isType || !isReExport && this.shouldElideExportedName(specifierInfo.leftName)) {
            while (this.tokens.currentIndex() < specifierInfo.endIndex) {
              this.tokens.removeToken();
            }
            if (this.tokens.matches1(_types.TokenType.comma)) {
              this.tokens.removeToken();
            }
          } else {
            foundNonTypeExport = true;
            while (this.tokens.currentIndex() < specifierInfo.endIndex) {
              this.tokens.copyToken();
            }
            if (this.tokens.matches1(_types.TokenType.comma)) {
              this.tokens.copyToken();
            }
          }
        }
        this.tokens.copyExpectedToken(_types.TokenType.braceR);
        if (!this.keepUnusedImports && isReExport && !foundNonTypeExport) {
          this.tokens.removeToken();
          this.tokens.removeToken();
          _removeMaybeImportAttributes.removeMaybeImportAttributes.call(void 0, this.tokens);
        }
        return true;
      }
      /**
       * ESM elides all imports with the rule that we only elide if we see that it's
       * a type and never see it as a value. This is in contrast to CJS, which
       * elides imports that are completely unknown.
       */
      shouldElideExportedName(name28) {
        return this.isTypeScriptTransformEnabled && !this.keepUnusedImports && this.declarationInfo.typeDeclarations.has(name28) && !this.declarationInfo.valueDeclarations.has(name28);
      }
    };
    exports2.default = ESMImportTransformer;
  }
});

// node_modules/sucrase/dist/transformers/FlowTransformer.js
var require_FlowTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/FlowTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _keywords = require_keywords();
    var _types = require_types();
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var FlowTransformer = class extends _Transformer2.default {
      constructor(rootTransformer, tokens, isImportsTransformEnabled) {
        super();
        this.rootTransformer = rootTransformer;
        this.tokens = tokens;
        this.isImportsTransformEnabled = isImportsTransformEnabled;
        ;
      }
      process() {
        if (this.rootTransformer.processPossibleArrowParamEnd() || this.rootTransformer.processPossibleAsyncArrowWithTypeParams() || this.rootTransformer.processPossibleTypeRange()) {
          return true;
        }
        if (this.tokens.matches1(_types.TokenType._enum)) {
          this.processEnum();
          return true;
        }
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType._enum)) {
          this.processNamedExportEnum();
          return true;
        }
        if (this.tokens.matches3(_types.TokenType._export, _types.TokenType._default, _types.TokenType._enum)) {
          this.processDefaultExportEnum();
          return true;
        }
        return false;
      }
      /**
       * Handle a declaration like:
       * export enum E ...
       *
       * With this imports transform, this becomes:
       * const E = [[enum]]; exports.E = E;
       *
       * otherwise, it becomes:
       * export const E = [[enum]];
       */
      processNamedExportEnum() {
        if (this.isImportsTransformEnabled) {
          this.tokens.removeInitialToken();
          const enumName = this.tokens.identifierNameAtRelativeIndex(1);
          this.processEnum();
          this.tokens.appendCode(` exports.${enumName} = ${enumName};`);
        } else {
          this.tokens.copyToken();
          this.processEnum();
        }
      }
      /**
       * Handle a declaration like:
       * export default enum E
       *
       * With the imports transform, this becomes:
       * const E = [[enum]]; exports.default = E;
       *
       * otherwise, it becomes:
       * const E = [[enum]]; export default E;
       */
      processDefaultExportEnum() {
        this.tokens.removeInitialToken();
        this.tokens.removeToken();
        const enumName = this.tokens.identifierNameAtRelativeIndex(1);
        this.processEnum();
        if (this.isImportsTransformEnabled) {
          this.tokens.appendCode(` exports.default = ${enumName};`);
        } else {
          this.tokens.appendCode(` export default ${enumName};`);
        }
      }
      /**
       * Transpile flow enums to invoke the "flow-enums-runtime" library.
       *
       * Currently, the transpiled code always uses `require("flow-enums-runtime")`,
       * but if future flexibility is needed, we could expose a config option for
       * this string (similar to configurable JSX). Even when targeting ESM, the
       * default behavior of babel-plugin-transform-flow-enums is to use require
       * rather than injecting an import.
       *
       * Flow enums are quite a bit simpler than TS enums and have some convenient
       * constraints:
       * - Element initializers must be either always present or always absent. That
       *   means that we can use fixed lookahead on the first element (if any) and
       *   assume that all elements are like that.
       * - The right-hand side of an element initializer must be a literal value,
       *   not a complex expression and not referencing other elements. That means
       *   we can simply copy a single token.
       *
       * Enums can be broken up into three basic cases:
       *
       * Mirrored enums:
       * enum E {A, B}
       *   ->
       * const E = require("flow-enums-runtime").Mirrored(["A", "B"]);
       *
       * Initializer enums:
       * enum E {A = 1, B = 2}
       *   ->
       * const E = require("flow-enums-runtime")({A: 1, B: 2});
       *
       * Symbol enums:
       * enum E of symbol {A, B}
       *   ->
       * const E = require("flow-enums-runtime")({A: Symbol("A"), B: Symbol("B")});
       *
       * We can statically detect which of the three cases this is by looking at the
       * "of" declaration (if any) and seeing if the first element has an initializer.
       * Since the other transform details are so similar between the three cases, we
       * use a single implementation and vary the transform within processEnumElement
       * based on case.
       */
      processEnum() {
        this.tokens.replaceToken("const");
        this.tokens.copyExpectedToken(_types.TokenType.name);
        let isSymbolEnum = false;
        if (this.tokens.matchesContextual(_keywords.ContextualKeyword._of)) {
          this.tokens.removeToken();
          isSymbolEnum = this.tokens.matchesContextual(_keywords.ContextualKeyword._symbol);
          this.tokens.removeToken();
        }
        const hasInitializers = this.tokens.matches3(_types.TokenType.braceL, _types.TokenType.name, _types.TokenType.eq);
        this.tokens.appendCode(' = require("flow-enums-runtime")');
        const isMirrored = !isSymbolEnum && !hasInitializers;
        this.tokens.replaceTokenTrimmingLeftWhitespace(isMirrored ? ".Mirrored([" : "({");
        while (!this.tokens.matches1(_types.TokenType.braceR)) {
          if (this.tokens.matches1(_types.TokenType.ellipsis)) {
            this.tokens.removeToken();
            break;
          }
          this.processEnumElement(isSymbolEnum, hasInitializers);
          if (this.tokens.matches1(_types.TokenType.comma)) {
            this.tokens.copyToken();
          }
        }
        this.tokens.replaceToken(isMirrored ? "]);" : "});");
      }
      /**
       * Process an individual enum element, producing either an array element or an
       * object element based on what type of enum this is.
       */
      processEnumElement(isSymbolEnum, hasInitializers) {
        if (isSymbolEnum) {
          const elementName = this.tokens.identifierName();
          this.tokens.copyToken();
          this.tokens.appendCode(`: Symbol("${elementName}")`);
        } else if (hasInitializers) {
          this.tokens.copyToken();
          this.tokens.replaceTokenTrimmingLeftWhitespace(":");
          this.tokens.copyToken();
        } else {
          this.tokens.replaceToken(`"${this.tokens.identifierName()}"`);
        }
      }
    };
    exports2.default = FlowTransformer;
  }
});

// node_modules/sucrase/dist/transformers/JestHoistTransformer.js
var require_JestHoistTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/JestHoistTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    function _optionalChain(ops) {
      let lastAccessLHS = void 0;
      let value = ops[0];
      let i = 1;
      while (i < ops.length) {
        const op = ops[i];
        const fn = ops[i + 1];
        i += 2;
        if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
          return void 0;
        }
        if (op === "access" || op === "optionalAccess") {
          lastAccessLHS = value;
          value = fn(value);
        } else if (op === "call" || op === "optionalCall") {
          value = fn((...args) => value.call(lastAccessLHS, ...args));
          lastAccessLHS = void 0;
        }
      }
      return value;
    }
    var _types = require_types();
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var JEST_GLOBAL_NAME = "jest";
    var HOISTED_METHODS = ["mock", "unmock", "enableAutomock", "disableAutomock"];
    var JestHoistTransformer = class _JestHoistTransformer extends _Transformer2.default {
      __init() {
        this.hoistedFunctionNames = [];
      }
      constructor(rootTransformer, tokens, nameManager, importProcessor) {
        super();
        this.rootTransformer = rootTransformer;
        this.tokens = tokens;
        this.nameManager = nameManager;
        this.importProcessor = importProcessor;
        _JestHoistTransformer.prototype.__init.call(this);
        ;
      }
      process() {
        if (this.tokens.currentToken().scopeDepth === 0 && this.tokens.matches4(_types.TokenType.name, _types.TokenType.dot, _types.TokenType.name, _types.TokenType.parenL) && this.tokens.identifierName() === JEST_GLOBAL_NAME) {
          if (_optionalChain([this, "access", (_) => _.importProcessor, "optionalAccess", (_2) => _2.getGlobalNames, "call", (_3) => _3(), "optionalAccess", (_4) => _4.has, "call", (_5) => _5(JEST_GLOBAL_NAME)])) {
            return false;
          }
          return this.extractHoistedCalls();
        }
        return false;
      }
      getHoistedCode() {
        if (this.hoistedFunctionNames.length > 0) {
          return this.hoistedFunctionNames.map((name28) => `${name28}();`).join("");
        }
        return "";
      }
      /**
       * Extracts any methods calls on the jest-object that should be hoisted.
       *
       * According to the jest docs, https://jestjs.io/docs/en/jest-object#jestmockmodulename-factory-options,
       * mock, unmock, enableAutomock, disableAutomock, are the methods that should be hoisted.
       *
       * We do not apply the same checks of the arguments as babel-plugin-jest-hoist does.
       */
      extractHoistedCalls() {
        this.tokens.removeToken();
        let followsNonHoistedJestCall = false;
        while (this.tokens.matches3(_types.TokenType.dot, _types.TokenType.name, _types.TokenType.parenL)) {
          const methodName = this.tokens.identifierNameAtIndex(this.tokens.currentIndex() + 1);
          const shouldHoist = HOISTED_METHODS.includes(methodName);
          if (shouldHoist) {
            const hoistedFunctionName = this.nameManager.claimFreeName("__jestHoist");
            this.hoistedFunctionNames.push(hoistedFunctionName);
            this.tokens.replaceToken(`function ${hoistedFunctionName}(){${JEST_GLOBAL_NAME}.`);
            this.tokens.copyToken();
            this.tokens.copyToken();
            this.rootTransformer.processBalancedCode();
            this.tokens.copyExpectedToken(_types.TokenType.parenR);
            this.tokens.appendCode(";}");
            followsNonHoistedJestCall = false;
          } else {
            if (followsNonHoistedJestCall) {
              this.tokens.copyToken();
            } else {
              this.tokens.replaceToken(`${JEST_GLOBAL_NAME}.`);
            }
            this.tokens.copyToken();
            this.tokens.copyToken();
            this.rootTransformer.processBalancedCode();
            this.tokens.copyExpectedToken(_types.TokenType.parenR);
            followsNonHoistedJestCall = true;
          }
        }
        return true;
      }
    };
    exports2.default = JestHoistTransformer;
  }
});

// node_modules/sucrase/dist/transformers/NumericSeparatorTransformer.js
var require_NumericSeparatorTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/NumericSeparatorTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _types = require_types();
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var NumericSeparatorTransformer = class extends _Transformer2.default {
      constructor(tokens) {
        super();
        this.tokens = tokens;
        ;
      }
      process() {
        if (this.tokens.matches1(_types.TokenType.num)) {
          const code = this.tokens.currentTokenCode();
          if (code.includes("_")) {
            this.tokens.replaceToken(code.replace(/_/g, ""));
            return true;
          }
        }
        return false;
      }
    };
    exports2.default = NumericSeparatorTransformer;
  }
});

// node_modules/sucrase/dist/transformers/OptionalCatchBindingTransformer.js
var require_OptionalCatchBindingTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/OptionalCatchBindingTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _types = require_types();
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var OptionalCatchBindingTransformer = class extends _Transformer2.default {
      constructor(tokens, nameManager) {
        super();
        this.tokens = tokens;
        this.nameManager = nameManager;
        ;
      }
      process() {
        if (this.tokens.matches2(_types.TokenType._catch, _types.TokenType.braceL)) {
          this.tokens.copyToken();
          this.tokens.appendCode(` (${this.nameManager.claimFreeName("e")})`);
          return true;
        }
        return false;
      }
    };
    exports2.default = OptionalCatchBindingTransformer;
  }
});

// node_modules/sucrase/dist/transformers/OptionalChainingNullishTransformer.js
var require_OptionalChainingNullishTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/OptionalChainingNullishTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _types = require_types();
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var OptionalChainingNullishTransformer = class extends _Transformer2.default {
      constructor(tokens, nameManager) {
        super();
        this.tokens = tokens;
        this.nameManager = nameManager;
        ;
      }
      process() {
        if (this.tokens.matches1(_types.TokenType.nullishCoalescing)) {
          const token2 = this.tokens.currentToken();
          if (this.tokens.tokens[token2.nullishStartIndex].isAsyncOperation) {
            this.tokens.replaceTokenTrimmingLeftWhitespace(", async () => (");
          } else {
            this.tokens.replaceTokenTrimmingLeftWhitespace(", () => (");
          }
          return true;
        }
        if (this.tokens.matches1(_types.TokenType._delete)) {
          const nextToken = this.tokens.tokenAtRelativeIndex(1);
          if (nextToken.isOptionalChainStart) {
            this.tokens.removeInitialToken();
            return true;
          }
        }
        const token = this.tokens.currentToken();
        const chainStart = token.subscriptStartIndex;
        if (chainStart != null && this.tokens.tokens[chainStart].isOptionalChainStart && // Super subscripts can't be optional (since super is never null/undefined), and the syntax
        // relies on the subscript being intact, so leave this token alone.
        this.tokens.tokenAtRelativeIndex(-1).type !== _types.TokenType._super) {
          const param = this.nameManager.claimFreeName("_");
          let arrowStartSnippet;
          if (chainStart > 0 && this.tokens.matches1AtIndex(chainStart - 1, _types.TokenType._delete) && this.isLastSubscriptInChain()) {
            arrowStartSnippet = `${param} => delete ${param}`;
          } else {
            arrowStartSnippet = `${param} => ${param}`;
          }
          if (this.tokens.tokens[chainStart].isAsyncOperation) {
            arrowStartSnippet = `async ${arrowStartSnippet}`;
          }
          if (this.tokens.matches2(_types.TokenType.questionDot, _types.TokenType.parenL) || this.tokens.matches2(_types.TokenType.questionDot, _types.TokenType.lessThan)) {
            if (this.justSkippedSuper()) {
              this.tokens.appendCode(".bind(this)");
            }
            this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'optionalCall', ${arrowStartSnippet}`);
          } else if (this.tokens.matches2(_types.TokenType.questionDot, _types.TokenType.bracketL)) {
            this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'optionalAccess', ${arrowStartSnippet}`);
          } else if (this.tokens.matches1(_types.TokenType.questionDot)) {
            this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'optionalAccess', ${arrowStartSnippet}.`);
          } else if (this.tokens.matches1(_types.TokenType.dot)) {
            this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'access', ${arrowStartSnippet}.`);
          } else if (this.tokens.matches1(_types.TokenType.bracketL)) {
            this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'access', ${arrowStartSnippet}[`);
          } else if (this.tokens.matches1(_types.TokenType.parenL)) {
            if (this.justSkippedSuper()) {
              this.tokens.appendCode(".bind(this)");
            }
            this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'call', ${arrowStartSnippet}(`);
          } else {
            throw new Error("Unexpected subscript operator in optional chain.");
          }
          return true;
        }
        return false;
      }
      /**
       * Determine if the current token is the last of its chain, so that we know whether it's eligible
       * to have a delete op inserted.
       *
       * We can do this by walking forward until we determine one way or another. Each
       * isOptionalChainStart token must be paired with exactly one isOptionalChainEnd token after it in
       * a nesting way, so we can track depth and walk to the end of the chain (the point where the
       * depth goes negative) and see if any other subscript token is after us in the chain.
       */
      isLastSubscriptInChain() {
        let depth = 0;
        for (let i = this.tokens.currentIndex() + 1; ; i++) {
          if (i >= this.tokens.tokens.length) {
            throw new Error("Reached the end of the code while finding the end of the access chain.");
          }
          if (this.tokens.tokens[i].isOptionalChainStart) {
            depth++;
          } else if (this.tokens.tokens[i].isOptionalChainEnd) {
            depth--;
          }
          if (depth < 0) {
            return true;
          }
          if (depth === 0 && this.tokens.tokens[i].subscriptStartIndex != null) {
            return false;
          }
        }
      }
      /**
       * Determine if we are the open-paren in an expression like super.a()?.b.
       *
       * We can do this by walking backward to find the previous subscript. If that subscript was
       * preceded by a super, then we must be the subscript after it, so if this is a call expression,
       * we'll need to attach the right context.
       */
      justSkippedSuper() {
        let depth = 0;
        let index = this.tokens.currentIndex() - 1;
        while (true) {
          if (index < 0) {
            throw new Error(
              "Reached the start of the code while finding the start of the access chain."
            );
          }
          if (this.tokens.tokens[index].isOptionalChainStart) {
            depth--;
          } else if (this.tokens.tokens[index].isOptionalChainEnd) {
            depth++;
          }
          if (depth < 0) {
            return false;
          }
          if (depth === 0 && this.tokens.tokens[index].subscriptStartIndex != null) {
            return this.tokens.tokens[index - 1].type === _types.TokenType._super;
          }
          index--;
        }
      }
    };
    exports2.default = OptionalChainingNullishTransformer;
  }
});

// node_modules/sucrase/dist/transformers/ReactDisplayNameTransformer.js
var require_ReactDisplayNameTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/ReactDisplayNameTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _tokenizer = require_tokenizer2();
    var _types = require_types();
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var ReactDisplayNameTransformer = class extends _Transformer2.default {
      constructor(rootTransformer, tokens, importProcessor, options) {
        super();
        this.rootTransformer = rootTransformer;
        this.tokens = tokens;
        this.importProcessor = importProcessor;
        this.options = options;
        ;
      }
      process() {
        const startIndex = this.tokens.currentIndex();
        if (this.tokens.identifierName() === "createReactClass") {
          const newName = this.importProcessor && this.importProcessor.getIdentifierReplacement("createReactClass");
          if (newName) {
            this.tokens.replaceToken(`(0, ${newName})`);
          } else {
            this.tokens.copyToken();
          }
          this.tryProcessCreateClassCall(startIndex);
          return true;
        }
        if (this.tokens.matches3(_types.TokenType.name, _types.TokenType.dot, _types.TokenType.name) && this.tokens.identifierName() === "React" && this.tokens.identifierNameAtIndex(this.tokens.currentIndex() + 2) === "createClass") {
          const newName = this.importProcessor ? this.importProcessor.getIdentifierReplacement("React") || "React" : "React";
          if (newName) {
            this.tokens.replaceToken(newName);
            this.tokens.copyToken();
            this.tokens.copyToken();
          } else {
            this.tokens.copyToken();
            this.tokens.copyToken();
            this.tokens.copyToken();
          }
          this.tryProcessCreateClassCall(startIndex);
          return true;
        }
        return false;
      }
      /**
       * This is called with the token position at the open-paren.
       */
      tryProcessCreateClassCall(startIndex) {
        const displayName = this.findDisplayName(startIndex);
        if (!displayName) {
          return;
        }
        if (this.classNeedsDisplayName()) {
          this.tokens.copyExpectedToken(_types.TokenType.parenL);
          this.tokens.copyExpectedToken(_types.TokenType.braceL);
          this.tokens.appendCode(`displayName: '${displayName}',`);
          this.rootTransformer.processBalancedCode();
          this.tokens.copyExpectedToken(_types.TokenType.braceR);
          this.tokens.copyExpectedToken(_types.TokenType.parenR);
        }
      }
      findDisplayName(startIndex) {
        if (startIndex < 2) {
          return null;
        }
        if (this.tokens.matches2AtIndex(startIndex - 2, _types.TokenType.name, _types.TokenType.eq)) {
          return this.tokens.identifierNameAtIndex(startIndex - 2);
        }
        if (startIndex >= 2 && this.tokens.tokens[startIndex - 2].identifierRole === _tokenizer.IdentifierRole.ObjectKey) {
          return this.tokens.identifierNameAtIndex(startIndex - 2);
        }
        if (this.tokens.matches2AtIndex(startIndex - 2, _types.TokenType._export, _types.TokenType._default)) {
          return this.getDisplayNameFromFilename();
        }
        return null;
      }
      getDisplayNameFromFilename() {
        const filePath = this.options.filePath || "unknown";
        const pathSegments = filePath.split("/");
        const filename = pathSegments[pathSegments.length - 1];
        const dotIndex = filename.lastIndexOf(".");
        const baseFilename = dotIndex === -1 ? filename : filename.slice(0, dotIndex);
        if (baseFilename === "index" && pathSegments[pathSegments.length - 2]) {
          return pathSegments[pathSegments.length - 2];
        } else {
          return baseFilename;
        }
      }
      /**
       * We only want to add a display name when this is a function call containing
       * one argument, which is an object literal without `displayName` as an
       * existing key.
       */
      classNeedsDisplayName() {
        let index = this.tokens.currentIndex();
        if (!this.tokens.matches2(_types.TokenType.parenL, _types.TokenType.braceL)) {
          return false;
        }
        const objectStartIndex = index + 1;
        const objectContextId = this.tokens.tokens[objectStartIndex].contextId;
        if (objectContextId == null) {
          throw new Error("Expected non-null context ID on object open-brace.");
        }
        for (; index < this.tokens.tokens.length; index++) {
          const token = this.tokens.tokens[index];
          if (token.type === _types.TokenType.braceR && token.contextId === objectContextId) {
            index++;
            break;
          }
          if (this.tokens.identifierNameAtIndex(index) === "displayName" && this.tokens.tokens[index].identifierRole === _tokenizer.IdentifierRole.ObjectKey && token.contextId === objectContextId) {
            return false;
          }
        }
        if (index === this.tokens.tokens.length) {
          throw new Error("Unexpected end of input when processing React class.");
        }
        return this.tokens.matches1AtIndex(index, _types.TokenType.parenR) || this.tokens.matches2AtIndex(index, _types.TokenType.comma, _types.TokenType.parenR);
      }
    };
    exports2.default = ReactDisplayNameTransformer;
  }
});

// node_modules/sucrase/dist/transformers/ReactHotLoaderTransformer.js
var require_ReactHotLoaderTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/ReactHotLoaderTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _tokenizer = require_tokenizer2();
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var ReactHotLoaderTransformer = class _ReactHotLoaderTransformer extends _Transformer2.default {
      __init() {
        this.extractedDefaultExportName = null;
      }
      constructor(tokens, filePath) {
        super();
        this.tokens = tokens;
        this.filePath = filePath;
        _ReactHotLoaderTransformer.prototype.__init.call(this);
        ;
      }
      setExtractedDefaultExportName(extractedDefaultExportName) {
        this.extractedDefaultExportName = extractedDefaultExportName;
      }
      getPrefixCode() {
        return `
      (function () {
        var enterModule = require('react-hot-loader').enterModule;
        enterModule && enterModule(module);
      })();`.replace(/\s+/g, " ").trim();
      }
      getSuffixCode() {
        const topLevelNames = /* @__PURE__ */ new Set();
        for (const token of this.tokens.tokens) {
          if (!token.isType && _tokenizer.isTopLevelDeclaration.call(void 0, token) && token.identifierRole !== _tokenizer.IdentifierRole.ImportDeclaration) {
            topLevelNames.add(this.tokens.identifierNameForToken(token));
          }
        }
        const namesToRegister = Array.from(topLevelNames).map((name28) => ({
          variableName: name28,
          uniqueLocalName: name28
        }));
        if (this.extractedDefaultExportName) {
          namesToRegister.push({
            variableName: this.extractedDefaultExportName,
            uniqueLocalName: "default"
          });
        }
        return `
;(function () {
  var reactHotLoader = require('react-hot-loader').default;
  var leaveModule = require('react-hot-loader').leaveModule;
  if (!reactHotLoader) {
    return;
  }
${namesToRegister.map(
          ({ variableName, uniqueLocalName }) => `  reactHotLoader.register(${variableName}, "${uniqueLocalName}", ${JSON.stringify(
            this.filePath || ""
          )});`
        ).join("\n")}
  leaveModule(module);
})();`;
      }
      process() {
        return false;
      }
    };
    exports2.default = ReactHotLoaderTransformer;
  }
});

// node_modules/sucrase/dist/util/isIdentifier.js
var require_isIdentifier = __commonJS({
  "node_modules/sucrase/dist/util/isIdentifier.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var _identifier = require_identifier();
    var RESERVED_WORDS = /* @__PURE__ */ new Set([
      // Reserved keywords as of ECMAScript 2015
      "break",
      "case",
      "catch",
      "class",
      "const",
      "continue",
      "debugger",
      "default",
      "delete",
      "do",
      "else",
      "export",
      "extends",
      "finally",
      "for",
      "function",
      "if",
      "import",
      "in",
      "instanceof",
      "new",
      "return",
      "super",
      "switch",
      "this",
      "throw",
      "try",
      "typeof",
      "var",
      "void",
      "while",
      "with",
      "yield",
      // Future reserved keywords
      "enum",
      "implements",
      "interface",
      "let",
      "package",
      "private",
      "protected",
      "public",
      "static",
      "await",
      // Literals that cannot be used as identifiers
      "false",
      "null",
      "true"
    ]);
    function isIdentifier(name28) {
      if (name28.length === 0) {
        return false;
      }
      if (!_identifier.IS_IDENTIFIER_START[name28.charCodeAt(0)]) {
        return false;
      }
      for (let i = 1; i < name28.length; i++) {
        if (!_identifier.IS_IDENTIFIER_CHAR[name28.charCodeAt(i)]) {
          return false;
        }
      }
      return !RESERVED_WORDS.has(name28);
    }
    exports2.default = isIdentifier;
  }
});

// node_modules/sucrase/dist/transformers/TypeScriptTransformer.js
var require_TypeScriptTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/TypeScriptTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _types = require_types();
    var _isIdentifier = require_isIdentifier();
    var _isIdentifier2 = _interopRequireDefault(_isIdentifier);
    var _Transformer = require_Transformer();
    var _Transformer2 = _interopRequireDefault(_Transformer);
    var TypeScriptTransformer = class extends _Transformer2.default {
      constructor(rootTransformer, tokens, isImportsTransformEnabled) {
        super();
        this.rootTransformer = rootTransformer;
        this.tokens = tokens;
        this.isImportsTransformEnabled = isImportsTransformEnabled;
        ;
      }
      process() {
        if (this.rootTransformer.processPossibleArrowParamEnd() || this.rootTransformer.processPossibleAsyncArrowWithTypeParams() || this.rootTransformer.processPossibleTypeRange()) {
          return true;
        }
        if (this.tokens.matches1(_types.TokenType._public) || this.tokens.matches1(_types.TokenType._protected) || this.tokens.matches1(_types.TokenType._private) || this.tokens.matches1(_types.TokenType._abstract) || this.tokens.matches1(_types.TokenType._readonly) || this.tokens.matches1(_types.TokenType._override) || this.tokens.matches1(_types.TokenType.nonNullAssertion)) {
          this.tokens.removeInitialToken();
          return true;
        }
        if (this.tokens.matches1(_types.TokenType._enum) || this.tokens.matches2(_types.TokenType._const, _types.TokenType._enum)) {
          this.processEnum();
          return true;
        }
        if (this.tokens.matches2(_types.TokenType._export, _types.TokenType._enum) || this.tokens.matches3(_types.TokenType._export, _types.TokenType._const, _types.TokenType._enum)) {
          this.processEnum(true);
          return true;
        }
        return false;
      }
      processEnum(isExport = false) {
        this.tokens.removeInitialToken();
        while (this.tokens.matches1(_types.TokenType._const) || this.tokens.matches1(_types.TokenType._enum)) {
          this.tokens.removeToken();
        }
        const enumName = this.tokens.identifierName();
        this.tokens.removeToken();
        if (isExport && !this.isImportsTransformEnabled) {
          this.tokens.appendCode("export ");
        }
        this.tokens.appendCode(`var ${enumName}; (function (${enumName})`);
        this.tokens.copyExpectedToken(_types.TokenType.braceL);
        this.processEnumBody(enumName);
        this.tokens.copyExpectedToken(_types.TokenType.braceR);
        if (isExport && this.isImportsTransformEnabled) {
          this.tokens.appendCode(`)(${enumName} || (exports.${enumName} = ${enumName} = {}));`);
        } else {
          this.tokens.appendCode(`)(${enumName} || (${enumName} = {}));`);
        }
      }
      /**
       * Transform an enum into equivalent JS. This has complexity in a few places:
       * - TS allows string enums, numeric enums, and a mix of the two styles within an enum.
       * - Enum keys are allowed to be referenced in later enum values.
       * - Enum keys are allowed to be strings.
       * - When enum values are omitted, they should follow an auto-increment behavior.
       */
      processEnumBody(enumName) {
        let previousValueCode = null;
        while (true) {
          if (this.tokens.matches1(_types.TokenType.braceR)) {
            break;
          }
          const { nameStringCode, variableName } = this.extractEnumKeyInfo(this.tokens.currentToken());
          this.tokens.removeInitialToken();
          if (this.tokens.matches3(_types.TokenType.eq, _types.TokenType.string, _types.TokenType.comma) || this.tokens.matches3(_types.TokenType.eq, _types.TokenType.string, _types.TokenType.braceR)) {
            this.processStringLiteralEnumMember(enumName, nameStringCode, variableName);
          } else if (this.tokens.matches1(_types.TokenType.eq)) {
            this.processExplicitValueEnumMember(enumName, nameStringCode, variableName);
          } else {
            this.processImplicitValueEnumMember(
              enumName,
              nameStringCode,
              variableName,
              previousValueCode
            );
          }
          if (this.tokens.matches1(_types.TokenType.comma)) {
            this.tokens.removeToken();
          }
          if (variableName != null) {
            previousValueCode = variableName;
          } else {
            previousValueCode = `${enumName}[${nameStringCode}]`;
          }
        }
      }
      /**
       * Detect name information about this enum key, which will be used to determine which code to emit
       * and whether we should declare a variable as part of this declaration.
       *
       * Some cases to keep in mind:
       * - Enum keys can be implicitly referenced later, e.g. `X = 1, Y = X`. In Sucrase, we implement
       *   this by declaring a variable `X` so that later expressions can use it.
       * - In addition to the usual identifier key syntax, enum keys are allowed to be string literals,
       *   e.g. `"hello world" = 3,`. Template literal syntax is NOT allowed.
       * - Even if the enum key is defined as a string literal, it may still be referenced by identifier
       *   later, e.g. `"X" = 1, Y = X`. That means that we need to detect whether or not a string
       *   literal is identifier-like and emit a variable if so, even if the declaration did not use an
       *   identifier.
       * - Reserved keywords like `break` are valid enum keys, but are not valid to be referenced later
       *   and would be a syntax error if we emitted a variable, so we need to skip the variable
       *   declaration in those cases.
       *
       * The variableName return value captures these nuances: if non-null, we can and must emit a
       * variable declaration, and if null, we can't and shouldn't.
       */
      extractEnumKeyInfo(nameToken) {
        if (nameToken.type === _types.TokenType.name) {
          const name28 = this.tokens.identifierNameForToken(nameToken);
          return {
            nameStringCode: `"${name28}"`,
            variableName: _isIdentifier2.default.call(void 0, name28) ? name28 : null
          };
        } else if (nameToken.type === _types.TokenType.string) {
          const name28 = this.tokens.stringValueForToken(nameToken);
          return {
            nameStringCode: this.tokens.code.slice(nameToken.start, nameToken.end),
            variableName: _isIdentifier2.default.call(void 0, name28) ? name28 : null
          };
        } else {
          throw new Error("Expected name or string at beginning of enum element.");
        }
      }
      /**
       * Handle an enum member where the RHS is just a string literal (not omitted, not a number, and
       * not a complex expression). This is the typical form for TS string enums, and in this case, we
       * do *not* create a reverse mapping.
       *
       * This is called after deleting the key token, when the token processor is at the equals sign.
       *
       * Example 1:
       * someKey = "some value"
       * ->
       * const someKey = "some value"; MyEnum["someKey"] = someKey;
       *
       * Example 2:
       * "some key" = "some value"
       * ->
       * MyEnum["some key"] = "some value";
       */
      processStringLiteralEnumMember(enumName, nameStringCode, variableName) {
        if (variableName != null) {
          this.tokens.appendCode(`const ${variableName}`);
          this.tokens.copyToken();
          this.tokens.copyToken();
          this.tokens.appendCode(`; ${enumName}[${nameStringCode}] = ${variableName};`);
        } else {
          this.tokens.appendCode(`${enumName}[${nameStringCode}]`);
          this.tokens.copyToken();
          this.tokens.copyToken();
          this.tokens.appendCode(";");
        }
      }
      /**
       * Handle an enum member initialized with an expression on the right-hand side (other than a
       * string literal). In these cases, we should transform the expression and emit code that sets up
       * a reverse mapping.
       *
       * The TypeScript implementation of this operation distinguishes between expressions that can be
       * "constant folded" at compile time (i.e. consist of number literals and simple math operations
       * on those numbers) and ones that are dynamic. For constant expressions, it emits the resolved
       * numeric value, and auto-incrementing is only allowed in that case. Evaluating expressions at
       * compile time would add significant complexity to Sucrase, so Sucrase instead leaves the
       * expression as-is, and will later emit something like `MyEnum["previousKey"] + 1` to implement
       * auto-incrementing.
       *
       * This is called after deleting the key token, when the token processor is at the equals sign.
       *
       * Example 1:
       * someKey = 1 + 1
       * ->
       * const someKey = 1 + 1; MyEnum[MyEnum["someKey"] = someKey] = "someKey";
       *
       * Example 2:
       * "some key" = 1 + 1
       * ->
       * MyEnum[MyEnum["some key"] = 1 + 1] = "some key";
       */
      processExplicitValueEnumMember(enumName, nameStringCode, variableName) {
        const rhsEndIndex = this.tokens.currentToken().rhsEndIndex;
        if (rhsEndIndex == null) {
          throw new Error("Expected rhsEndIndex on enum assign.");
        }
        if (variableName != null) {
          this.tokens.appendCode(`const ${variableName}`);
          this.tokens.copyToken();
          while (this.tokens.currentIndex() < rhsEndIndex) {
            this.rootTransformer.processToken();
          }
          this.tokens.appendCode(
            `; ${enumName}[${enumName}[${nameStringCode}] = ${variableName}] = ${nameStringCode};`
          );
        } else {
          this.tokens.appendCode(`${enumName}[${enumName}[${nameStringCode}]`);
          this.tokens.copyToken();
          while (this.tokens.currentIndex() < rhsEndIndex) {
            this.rootTransformer.processToken();
          }
          this.tokens.appendCode(`] = ${nameStringCode};`);
        }
      }
      /**
       * Handle an enum member with no right-hand side expression. In this case, the value is the
       * previous value plus 1, or 0 if there was no previous value. We should also always emit a
       * reverse mapping.
       *
       * Example 1:
       * someKey2
       * ->
       * const someKey2 = someKey1 + 1; MyEnum[MyEnum["someKey2"] = someKey2] = "someKey2";
       *
       * Example 2:
       * "some key 2"
       * ->
       * MyEnum[MyEnum["some key 2"] = someKey1 + 1] = "some key 2";
       */
      processImplicitValueEnumMember(enumName, nameStringCode, variableName, previousValueCode) {
        let valueCode = previousValueCode != null ? `${previousValueCode} + 1` : "0";
        if (variableName != null) {
          this.tokens.appendCode(`const ${variableName} = ${valueCode}; `);
          valueCode = variableName;
        }
        this.tokens.appendCode(
          `${enumName}[${enumName}[${nameStringCode}] = ${valueCode}] = ${nameStringCode};`
        );
      }
    };
    exports2.default = TypeScriptTransformer;
  }
});

// node_modules/sucrase/dist/transformers/RootTransformer.js
var require_RootTransformer = __commonJS({
  "node_modules/sucrase/dist/transformers/RootTransformer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _keywords = require_keywords();
    var _types = require_types();
    var _getClassInfo = require_getClassInfo();
    var _getClassInfo2 = _interopRequireDefault(_getClassInfo);
    var _CJSImportTransformer = require_CJSImportTransformer();
    var _CJSImportTransformer2 = _interopRequireDefault(_CJSImportTransformer);
    var _ESMImportTransformer = require_ESMImportTransformer();
    var _ESMImportTransformer2 = _interopRequireDefault(_ESMImportTransformer);
    var _FlowTransformer = require_FlowTransformer();
    var _FlowTransformer2 = _interopRequireDefault(_FlowTransformer);
    var _JestHoistTransformer = require_JestHoistTransformer();
    var _JestHoistTransformer2 = _interopRequireDefault(_JestHoistTransformer);
    var _JSXTransformer = require_JSXTransformer();
    var _JSXTransformer2 = _interopRequireDefault(_JSXTransformer);
    var _NumericSeparatorTransformer = require_NumericSeparatorTransformer();
    var _NumericSeparatorTransformer2 = _interopRequireDefault(_NumericSeparatorTransformer);
    var _OptionalCatchBindingTransformer = require_OptionalCatchBindingTransformer();
    var _OptionalCatchBindingTransformer2 = _interopRequireDefault(_OptionalCatchBindingTransformer);
    var _OptionalChainingNullishTransformer = require_OptionalChainingNullishTransformer();
    var _OptionalChainingNullishTransformer2 = _interopRequireDefault(_OptionalChainingNullishTransformer);
    var _ReactDisplayNameTransformer = require_ReactDisplayNameTransformer();
    var _ReactDisplayNameTransformer2 = _interopRequireDefault(_ReactDisplayNameTransformer);
    var _ReactHotLoaderTransformer = require_ReactHotLoaderTransformer();
    var _ReactHotLoaderTransformer2 = _interopRequireDefault(_ReactHotLoaderTransformer);
    var _TypeScriptTransformer = require_TypeScriptTransformer();
    var _TypeScriptTransformer2 = _interopRequireDefault(_TypeScriptTransformer);
    var RootTransformer = class _RootTransformer {
      __init() {
        this.transformers = [];
      }
      __init2() {
        this.generatedVariables = [];
      }
      constructor(sucraseContext, transforms, enableLegacyBabel5ModuleInterop, options) {
        ;
        _RootTransformer.prototype.__init.call(this);
        _RootTransformer.prototype.__init2.call(this);
        this.nameManager = sucraseContext.nameManager;
        this.helperManager = sucraseContext.helperManager;
        const { tokenProcessor, importProcessor } = sucraseContext;
        this.tokens = tokenProcessor;
        this.isImportsTransformEnabled = transforms.includes("imports");
        this.isReactHotLoaderTransformEnabled = transforms.includes("react-hot-loader");
        this.disableESTransforms = Boolean(options.disableESTransforms);
        if (!options.disableESTransforms) {
          this.transformers.push(
            new (0, _OptionalChainingNullishTransformer2.default)(tokenProcessor, this.nameManager)
          );
          this.transformers.push(new (0, _NumericSeparatorTransformer2.default)(tokenProcessor));
          this.transformers.push(new (0, _OptionalCatchBindingTransformer2.default)(tokenProcessor, this.nameManager));
        }
        if (transforms.includes("jsx")) {
          if (options.jsxRuntime !== "preserve") {
            this.transformers.push(
              new (0, _JSXTransformer2.default)(this, tokenProcessor, importProcessor, this.nameManager, options)
            );
          }
          this.transformers.push(
            new (0, _ReactDisplayNameTransformer2.default)(this, tokenProcessor, importProcessor, options)
          );
        }
        let reactHotLoaderTransformer = null;
        if (transforms.includes("react-hot-loader")) {
          if (!options.filePath) {
            throw new Error("filePath is required when using the react-hot-loader transform.");
          }
          reactHotLoaderTransformer = new (0, _ReactHotLoaderTransformer2.default)(tokenProcessor, options.filePath);
          this.transformers.push(reactHotLoaderTransformer);
        }
        if (transforms.includes("imports")) {
          if (importProcessor === null) {
            throw new Error("Expected non-null importProcessor with imports transform enabled.");
          }
          this.transformers.push(
            new (0, _CJSImportTransformer2.default)(
              this,
              tokenProcessor,
              importProcessor,
              this.nameManager,
              this.helperManager,
              reactHotLoaderTransformer,
              enableLegacyBabel5ModuleInterop,
              Boolean(options.enableLegacyTypeScriptModuleInterop),
              transforms.includes("typescript"),
              transforms.includes("flow"),
              Boolean(options.preserveDynamicImport),
              Boolean(options.keepUnusedImports)
            )
          );
        } else {
          this.transformers.push(
            new (0, _ESMImportTransformer2.default)(
              tokenProcessor,
              this.nameManager,
              this.helperManager,
              reactHotLoaderTransformer,
              transforms.includes("typescript"),
              transforms.includes("flow"),
              Boolean(options.keepUnusedImports),
              options
            )
          );
        }
        if (transforms.includes("flow")) {
          this.transformers.push(
            new (0, _FlowTransformer2.default)(this, tokenProcessor, transforms.includes("imports"))
          );
        }
        if (transforms.includes("typescript")) {
          this.transformers.push(
            new (0, _TypeScriptTransformer2.default)(this, tokenProcessor, transforms.includes("imports"))
          );
        }
        if (transforms.includes("jest")) {
          this.transformers.push(
            new (0, _JestHoistTransformer2.default)(this, tokenProcessor, this.nameManager, importProcessor)
          );
        }
      }
      transform() {
        this.tokens.reset();
        this.processBalancedCode();
        const shouldAddUseStrict = this.isImportsTransformEnabled;
        let prefix = shouldAddUseStrict ? '"use strict";' : "";
        for (const transformer of this.transformers) {
          prefix += transformer.getPrefixCode();
        }
        prefix += this.helperManager.emitHelpers();
        prefix += this.generatedVariables.map((v) => ` var ${v};`).join("");
        for (const transformer of this.transformers) {
          prefix += transformer.getHoistedCode();
        }
        let suffix = "";
        for (const transformer of this.transformers) {
          suffix += transformer.getSuffixCode();
        }
        const result = this.tokens.finish();
        let { code } = result;
        if (code.startsWith("#!")) {
          let newlineIndex = code.indexOf("\n");
          if (newlineIndex === -1) {
            newlineIndex = code.length;
            code += "\n";
          }
          return {
            code: code.slice(0, newlineIndex + 1) + prefix + code.slice(newlineIndex + 1) + suffix,
            // The hashbang line has no tokens, so shifting the tokens to account
            // for prefix can happen normally.
            mappings: this.shiftMappings(result.mappings, prefix.length)
          };
        } else {
          return {
            code: prefix + code + suffix,
            mappings: this.shiftMappings(result.mappings, prefix.length)
          };
        }
      }
      processBalancedCode() {
        let braceDepth = 0;
        let parenDepth = 0;
        while (!this.tokens.isAtEnd()) {
          if (this.tokens.matches1(_types.TokenType.braceL) || this.tokens.matches1(_types.TokenType.dollarBraceL)) {
            braceDepth++;
          } else if (this.tokens.matches1(_types.TokenType.braceR)) {
            if (braceDepth === 0) {
              return;
            }
            braceDepth--;
          }
          if (this.tokens.matches1(_types.TokenType.parenL)) {
            parenDepth++;
          } else if (this.tokens.matches1(_types.TokenType.parenR)) {
            if (parenDepth === 0) {
              return;
            }
            parenDepth--;
          }
          this.processToken();
        }
      }
      processToken() {
        if (this.tokens.matches1(_types.TokenType._class)) {
          this.processClass();
          return;
        }
        for (const transformer of this.transformers) {
          const wasProcessed = transformer.process();
          if (wasProcessed) {
            return;
          }
        }
        this.tokens.copyToken();
      }
      /**
       * Skip past a class with a name and return that name.
       */
      processNamedClass() {
        if (!this.tokens.matches2(_types.TokenType._class, _types.TokenType.name)) {
          throw new Error("Expected identifier for exported class name.");
        }
        const name28 = this.tokens.identifierNameAtIndex(this.tokens.currentIndex() + 1);
        this.processClass();
        return name28;
      }
      processClass() {
        const classInfo = _getClassInfo2.default.call(void 0, this, this.tokens, this.nameManager, this.disableESTransforms);
        const needsCommaExpression = (classInfo.headerInfo.isExpression || !classInfo.headerInfo.className) && classInfo.staticInitializerNames.length + classInfo.instanceInitializerNames.length > 0;
        let className = classInfo.headerInfo.className;
        if (needsCommaExpression) {
          className = this.nameManager.claimFreeName("_class");
          this.generatedVariables.push(className);
          this.tokens.appendCode(` (${className} =`);
        }
        const classToken = this.tokens.currentToken();
        const contextId = classToken.contextId;
        if (contextId == null) {
          throw new Error("Expected class to have a context ID.");
        }
        this.tokens.copyExpectedToken(_types.TokenType._class);
        while (!this.tokens.matchesContextIdAndLabel(_types.TokenType.braceL, contextId)) {
          this.processToken();
        }
        this.processClassBody(classInfo, className);
        const staticInitializerStatements = classInfo.staticInitializerNames.map(
          (name28) => `${className}.${name28}()`
        );
        if (needsCommaExpression) {
          this.tokens.appendCode(
            `, ${staticInitializerStatements.map((s) => `${s}, `).join("")}${className})`
          );
        } else if (classInfo.staticInitializerNames.length > 0) {
          this.tokens.appendCode(` ${staticInitializerStatements.map((s) => `${s};`).join(" ")}`);
        }
      }
      /**
       * We want to just handle class fields in all contexts, since TypeScript supports them. Later,
       * when some JS implementations support class fields, this should be made optional.
       */
      processClassBody(classInfo, className) {
        const {
          headerInfo,
          constructorInsertPos,
          constructorInitializerStatements,
          fields,
          instanceInitializerNames,
          rangesToRemove
        } = classInfo;
        let fieldIndex = 0;
        let rangeToRemoveIndex = 0;
        const classContextId = this.tokens.currentToken().contextId;
        if (classContextId == null) {
          throw new Error("Expected non-null context ID on class.");
        }
        this.tokens.copyExpectedToken(_types.TokenType.braceL);
        if (this.isReactHotLoaderTransformEnabled) {
          this.tokens.appendCode(
            "__reactstandin__regenerateByEval(key, code) {this[key] = eval(code);}"
          );
        }
        const needsConstructorInit = constructorInitializerStatements.length + instanceInitializerNames.length > 0;
        if (constructorInsertPos === null && needsConstructorInit) {
          const constructorInitializersCode = this.makeConstructorInitCode(
            constructorInitializerStatements,
            instanceInitializerNames,
            className
          );
          if (headerInfo.hasSuperclass) {
            const argsName = this.nameManager.claimFreeName("args");
            this.tokens.appendCode(
              `constructor(...${argsName}) { super(...${argsName}); ${constructorInitializersCode}; }`
            );
          } else {
            this.tokens.appendCode(`constructor() { ${constructorInitializersCode}; }`);
          }
        }
        while (!this.tokens.matchesContextIdAndLabel(_types.TokenType.braceR, classContextId)) {
          if (fieldIndex < fields.length && this.tokens.currentIndex() === fields[fieldIndex].start) {
            let needsCloseBrace = false;
            if (this.tokens.matches1(_types.TokenType.bracketL)) {
              this.tokens.copyTokenWithPrefix(`${fields[fieldIndex].initializerName}() {this`);
            } else if (this.tokens.matches1(_types.TokenType.string) || this.tokens.matches1(_types.TokenType.num)) {
              this.tokens.copyTokenWithPrefix(`${fields[fieldIndex].initializerName}() {this[`);
              needsCloseBrace = true;
            } else {
              this.tokens.copyTokenWithPrefix(`${fields[fieldIndex].initializerName}() {this.`);
            }
            while (this.tokens.currentIndex() < fields[fieldIndex].end) {
              if (needsCloseBrace && this.tokens.currentIndex() === fields[fieldIndex].equalsIndex) {
                this.tokens.appendCode("]");
              }
              this.processToken();
            }
            this.tokens.appendCode("}");
            fieldIndex++;
          } else if (rangeToRemoveIndex < rangesToRemove.length && this.tokens.currentIndex() >= rangesToRemove[rangeToRemoveIndex].start) {
            if (this.tokens.currentIndex() < rangesToRemove[rangeToRemoveIndex].end) {
              this.tokens.removeInitialToken();
            }
            while (this.tokens.currentIndex() < rangesToRemove[rangeToRemoveIndex].end) {
              this.tokens.removeToken();
            }
            rangeToRemoveIndex++;
          } else if (this.tokens.currentIndex() === constructorInsertPos) {
            this.tokens.copyToken();
            if (needsConstructorInit) {
              this.tokens.appendCode(
                `;${this.makeConstructorInitCode(
                  constructorInitializerStatements,
                  instanceInitializerNames,
                  className
                )};`
              );
            }
            this.processToken();
          } else {
            this.processToken();
          }
        }
        this.tokens.copyExpectedToken(_types.TokenType.braceR);
      }
      makeConstructorInitCode(constructorInitializerStatements, instanceInitializerNames, className) {
        return [
          ...constructorInitializerStatements,
          ...instanceInitializerNames.map((name28) => `${className}.prototype.${name28}.call(this)`)
        ].join(";");
      }
      /**
       * Normally it's ok to simply remove type tokens, but we need to be more careful when dealing with
       * arrow function return types since they can confuse the parser. In that case, we want to move
       * the close-paren to the same line as the arrow.
       *
       * See https://github.com/alangpierce/sucrase/issues/391 for more details.
       */
      processPossibleArrowParamEnd() {
        if (this.tokens.matches2(_types.TokenType.parenR, _types.TokenType.colon) && this.tokens.tokenAtRelativeIndex(1).isType) {
          let nextNonTypeIndex = this.tokens.currentIndex() + 1;
          while (this.tokens.tokens[nextNonTypeIndex].isType) {
            nextNonTypeIndex++;
          }
          if (this.tokens.matches1AtIndex(nextNonTypeIndex, _types.TokenType.arrow)) {
            this.tokens.removeInitialToken();
            while (this.tokens.currentIndex() < nextNonTypeIndex) {
              this.tokens.removeToken();
            }
            this.tokens.replaceTokenTrimmingLeftWhitespace(") =>");
            return true;
          }
        }
        return false;
      }
      /**
       * An async arrow function might be of the form:
       *
       * async <
       *   T
       * >() => {}
       *
       * in which case, removing the type parameters will cause a syntax error. Detect this case and
       * move the open-paren earlier.
       */
      processPossibleAsyncArrowWithTypeParams() {
        if (!this.tokens.matchesContextual(_keywords.ContextualKeyword._async) && !this.tokens.matches1(_types.TokenType._async)) {
          return false;
        }
        const nextToken = this.tokens.tokenAtRelativeIndex(1);
        if (nextToken.type !== _types.TokenType.lessThan || !nextToken.isType) {
          return false;
        }
        let nextNonTypeIndex = this.tokens.currentIndex() + 1;
        while (this.tokens.tokens[nextNonTypeIndex].isType) {
          nextNonTypeIndex++;
        }
        if (this.tokens.matches1AtIndex(nextNonTypeIndex, _types.TokenType.parenL)) {
          this.tokens.replaceToken("async (");
          this.tokens.removeInitialToken();
          while (this.tokens.currentIndex() < nextNonTypeIndex) {
            this.tokens.removeToken();
          }
          this.tokens.removeToken();
          this.processBalancedCode();
          this.processToken();
          return true;
        }
        return false;
      }
      processPossibleTypeRange() {
        if (this.tokens.currentToken().isType) {
          this.tokens.removeInitialToken();
          while (this.tokens.currentToken().isType) {
            this.tokens.removeToken();
          }
          return true;
        }
        return false;
      }
      shiftMappings(mappings, prefixLength) {
        for (let i = 0; i < mappings.length; i++) {
          const mapping = mappings[i];
          if (mapping !== void 0) {
            mappings[i] = mapping + prefixLength;
          }
        }
        return mappings;
      }
    };
    exports2.default = RootTransformer;
  }
});

// node_modules/lines-and-columns/build/index.js
var require_build = __commonJS({
  "node_modules/lines-and-columns/build/index.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.LinesAndColumns = void 0;
    var LF = "\n";
    var CR = "\r";
    var LinesAndColumns = (
      /** @class */
      (function() {
        function LinesAndColumns2(string5) {
          this.string = string5;
          var offsets = [0];
          for (var offset = 0; offset < string5.length; ) {
            switch (string5[offset]) {
              case LF:
                offset += LF.length;
                offsets.push(offset);
                break;
              case CR:
                offset += CR.length;
                if (string5[offset] === LF) {
                  offset += LF.length;
                }
                offsets.push(offset);
                break;
              default:
                offset++;
                break;
            }
          }
          this.offsets = offsets;
        }
        LinesAndColumns2.prototype.locationForIndex = function(index) {
          if (index < 0 || index > this.string.length) {
            return null;
          }
          var line = 0;
          var offsets = this.offsets;
          while (offsets[line + 1] <= index) {
            line++;
          }
          var column = index - offsets[line];
          return { line, column };
        };
        LinesAndColumns2.prototype.indexForLocation = function(location) {
          var line = location.line, column = location.column;
          if (line < 0 || line >= this.offsets.length) {
            return null;
          }
          if (column < 0 || column > this.lengthOfLine(line)) {
            return null;
          }
          return this.offsets[line] + column;
        };
        LinesAndColumns2.prototype.lengthOfLine = function(line) {
          var offset = this.offsets[line];
          var nextOffset = line === this.offsets.length - 1 ? this.string.length : this.offsets[line + 1];
          return nextOffset - offset;
        };
        return LinesAndColumns2;
      })()
    );
    exports2.LinesAndColumns = LinesAndColumns;
    exports2["default"] = LinesAndColumns;
  }
});

// node_modules/sucrase/dist/util/formatTokens.js
var require_formatTokens = __commonJS({
  "node_modules/sucrase/dist/util/formatTokens.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _linesandcolumns = require_build();
    var _linesandcolumns2 = _interopRequireDefault(_linesandcolumns);
    var _types = require_types();
    function formatTokens(code, tokens) {
      if (tokens.length === 0) {
        return "";
      }
      const tokenKeys = Object.keys(tokens[0]).filter(
        (k) => k !== "type" && k !== "value" && k !== "start" && k !== "end" && k !== "loc"
      );
      const typeKeys = Object.keys(tokens[0].type).filter((k) => k !== "label" && k !== "keyword");
      const headings = ["Location", "Label", "Raw", ...tokenKeys, ...typeKeys];
      const lines = new (0, _linesandcolumns2.default)(code);
      const rows = [headings, ...tokens.map(getTokenComponents)];
      const padding = headings.map(() => 0);
      for (const components of rows) {
        for (let i = 0; i < components.length; i++) {
          padding[i] = Math.max(padding[i], components[i].length);
        }
      }
      return rows.map((components) => components.map((component, i) => component.padEnd(padding[i])).join(" ")).join("\n");
      function getTokenComponents(token) {
        const raw = code.slice(token.start, token.end);
        return [
          formatRange(token.start, token.end),
          _types.formatTokenType.call(void 0, token.type),
          truncate(String(raw), 14),
          // @ts-ignore: Intentional dynamic access by key.
          ...tokenKeys.map((key) => formatValue(token[key], key)),
          // @ts-ignore: Intentional dynamic access by key.
          ...typeKeys.map((key) => formatValue(token.type[key], key))
        ];
      }
      function formatValue(value, key) {
        if (value === true) {
          return key;
        } else if (value === false || value === null) {
          return "";
        } else {
          return String(value);
        }
      }
      function formatRange(start, end) {
        return `${formatPos(start)}-${formatPos(end)}`;
      }
      function formatPos(pos) {
        const location = lines.locationForIndex(pos);
        if (!location) {
          return "Unknown";
        } else {
          return `${location.line + 1}:${location.column + 1}`;
        }
      }
    }
    exports2.default = formatTokens;
    function truncate(s, length) {
      if (s.length > length) {
        return `${s.slice(0, length - 3)}...`;
      } else {
        return s;
      }
    }
  }
});

// node_modules/sucrase/dist/util/getTSImportedNames.js
var require_getTSImportedNames = __commonJS({
  "node_modules/sucrase/dist/util/getTSImportedNames.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _types = require_types();
    var _getImportExportSpecifierInfo = require_getImportExportSpecifierInfo();
    var _getImportExportSpecifierInfo2 = _interopRequireDefault(_getImportExportSpecifierInfo);
    function getTSImportedNames(tokens) {
      const importedNames = /* @__PURE__ */ new Set();
      for (let i = 0; i < tokens.tokens.length; i++) {
        if (tokens.matches1AtIndex(i, _types.TokenType._import) && !tokens.matches3AtIndex(i, _types.TokenType._import, _types.TokenType.name, _types.TokenType.eq)) {
          collectNamesForImport(tokens, i, importedNames);
        }
      }
      return importedNames;
    }
    exports2.default = getTSImportedNames;
    function collectNamesForImport(tokens, index, importedNames) {
      index++;
      if (tokens.matches1AtIndex(index, _types.TokenType.parenL)) {
        return;
      }
      if (tokens.matches1AtIndex(index, _types.TokenType.name)) {
        importedNames.add(tokens.identifierNameAtIndex(index));
        index++;
        if (tokens.matches1AtIndex(index, _types.TokenType.comma)) {
          index++;
        }
      }
      if (tokens.matches1AtIndex(index, _types.TokenType.star)) {
        index += 2;
        importedNames.add(tokens.identifierNameAtIndex(index));
        index++;
      }
      if (tokens.matches1AtIndex(index, _types.TokenType.braceL)) {
        index++;
        collectNamesForNamedImport(tokens, index, importedNames);
      }
    }
    function collectNamesForNamedImport(tokens, index, importedNames) {
      while (true) {
        if (tokens.matches1AtIndex(index, _types.TokenType.braceR)) {
          return;
        }
        const specifierInfo = _getImportExportSpecifierInfo2.default.call(void 0, tokens, index);
        index = specifierInfo.endIndex;
        if (!specifierInfo.isType) {
          importedNames.add(specifierInfo.rightName);
        }
        if (tokens.matches2AtIndex(index, _types.TokenType.comma, _types.TokenType.braceR)) {
          return;
        } else if (tokens.matches1AtIndex(index, _types.TokenType.braceR)) {
          return;
        } else if (tokens.matches1AtIndex(index, _types.TokenType.comma)) {
          index++;
        } else {
          throw new Error(`Unexpected token: ${JSON.stringify(tokens.tokens[index])}`);
        }
      }
    }
  }
});

// node_modules/sucrase/dist/index.js
var require_dist5 = __commonJS({
  "node_modules/sucrase/dist/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var _CJSImportProcessor = require_CJSImportProcessor();
    var _CJSImportProcessor2 = _interopRequireDefault(_CJSImportProcessor);
    var _computeSourceMap = require_computeSourceMap();
    var _computeSourceMap2 = _interopRequireDefault(_computeSourceMap);
    var _HelperManager = require_HelperManager();
    var _identifyShadowedGlobals = require_identifyShadowedGlobals();
    var _identifyShadowedGlobals2 = _interopRequireDefault(_identifyShadowedGlobals);
    var _NameManager = require_NameManager();
    var _NameManager2 = _interopRequireDefault(_NameManager);
    var _Options = require_Options();
    var _parser = require_parser2();
    var _TokenProcessor = require_TokenProcessor();
    var _TokenProcessor2 = _interopRequireDefault(_TokenProcessor);
    var _RootTransformer = require_RootTransformer();
    var _RootTransformer2 = _interopRequireDefault(_RootTransformer);
    var _formatTokens = require_formatTokens();
    var _formatTokens2 = _interopRequireDefault(_formatTokens);
    var _getTSImportedNames = require_getTSImportedNames();
    var _getTSImportedNames2 = _interopRequireDefault(_getTSImportedNames);
    function getVersion2() {
      return "3.35.1";
    }
    exports2.getVersion = getVersion2;
    function transform8(code, options) {
      _Options.validateOptions.call(void 0, options);
      try {
        const sucraseContext = getSucraseContext(code, options);
        const transformer = new (0, _RootTransformer2.default)(
          sucraseContext,
          options.transforms,
          Boolean(options.enableLegacyBabel5ModuleInterop),
          options
        );
        const transformerResult = transformer.transform();
        let result = { code: transformerResult.code };
        if (options.sourceMapOptions) {
          if (!options.filePath) {
            throw new Error("filePath must be specified when generating a source map.");
          }
          result = {
            ...result,
            sourceMap: _computeSourceMap2.default.call(
              void 0,
              transformerResult,
              options.filePath,
              options.sourceMapOptions,
              code,
              sucraseContext.tokenProcessor.tokens
            )
          };
        }
        return result;
      } catch (e) {
        if (options.filePath) {
          e.message = `Error transforming ${options.filePath}: ${e.message}`;
        }
        throw e;
      }
    }
    exports2.transform = transform8;
    function getFormattedTokens(code, options) {
      const tokens = getSucraseContext(code, options).tokenProcessor.tokens;
      return _formatTokens2.default.call(void 0, code, tokens);
    }
    exports2.getFormattedTokens = getFormattedTokens;
    function getSucraseContext(code, options) {
      const isJSXEnabled = options.transforms.includes("jsx");
      const isTypeScriptEnabled = options.transforms.includes("typescript");
      const isFlowEnabled = options.transforms.includes("flow");
      const disableESTransforms = options.disableESTransforms === true;
      const file3 = _parser.parse.call(void 0, code, isJSXEnabled, isTypeScriptEnabled, isFlowEnabled);
      const tokens = file3.tokens;
      const scopes = file3.scopes;
      const nameManager = new (0, _NameManager2.default)(code, tokens);
      const helperManager = new (0, _HelperManager.HelperManager)(nameManager);
      const tokenProcessor = new (0, _TokenProcessor2.default)(
        code,
        tokens,
        isFlowEnabled,
        disableESTransforms,
        helperManager
      );
      const enableLegacyTypeScriptModuleInterop = Boolean(options.enableLegacyTypeScriptModuleInterop);
      let importProcessor = null;
      if (options.transforms.includes("imports")) {
        importProcessor = new (0, _CJSImportProcessor2.default)(
          nameManager,
          tokenProcessor,
          enableLegacyTypeScriptModuleInterop,
          options,
          options.transforms.includes("typescript"),
          Boolean(options.keepUnusedImports),
          helperManager
        );
        importProcessor.preprocessTokens();
        _identifyShadowedGlobals2.default.call(void 0, tokenProcessor, scopes, importProcessor.getGlobalNames());
        if (options.transforms.includes("typescript") && !options.keepUnusedImports) {
          importProcessor.pruneTypeOnlyImports();
        }
      } else if (options.transforms.includes("typescript") && !options.keepUnusedImports) {
        _identifyShadowedGlobals2.default.call(void 0, tokenProcessor, scopes, _getTSImportedNames2.default.call(void 0, tokenProcessor));
      }
      return { tokenProcessor, scopes, nameManager, importProcessor, helperManager };
    }
  }
});

// src/lib/vendor.json
var vendor_default;
var init_vendor = __esm({
  "src/lib/vendor.json"() {
    vendor_default = {
      "atlascloud.ts": '/**\n * AirFlow AI\u4F9B\u5E94\u5546\u6A21\u677F - AtlasCloud MASS\n * @version 0.8\n *\n * \u8BF4\u660E\uFF1A\n * 1) \u6587\u672C\u63A5\u53E3\u4F7F\u7528 OpenAI \u517C\u5BB9\u57FA\u5730\u5740\uFF1Ahttps://api.atlascloud.ai/v1\n * 2) \u56FE\u7247/\u89C6\u9891\u4F7F\u7528 Atlas Cloud \u5A92\u4F53\u63A5\u53E3\uFF1Ahttps://api.atlascloud.ai/api/v1\n * 3) \u56FE\u7247/\u89C6\u9891\u4E3A\u5F02\u6B65\u4EFB\u52A1\uFF1A\u63D0\u4EA4\u540E\u8F6E\u8BE2 /api/v1/model/prediction/{id}\n */\n\n// ============================================================\n// \u7C7B\u578B\u5B9A\u4E49\n// ============================================================\n\ntype VideoMode =\n  | "singleImage"\n  | "startEndRequired"\n  | "endFrameOptional"\n  | "startFrameOptional"\n  | "text"\n  | (`videoReference:${number}` | `imageReference:${number}` | `audioReference:${number}`)[];\n\ninterface TextModel {\n  name: string;\n  modelName: string;\n  type: "text";\n  think: boolean;\n}\n\ninterface ImageModel {\n  name: string;\n  modelName: string;\n  type: "image";\n  mode: ("text" | "singleImage" | "multiReference")[];\n  associationSkills?: string;\n}\n\ninterface VideoModel {\n  name: string;\n  modelName: string;\n  type: "video";\n  mode: VideoMode[];\n  associationSkills?: string;\n  audio: "optional" | false | true;\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\n}\n\ninterface TTSModel {\n  name: string;\n  modelName: string;\n  type: "tts";\n  voices: { title: string; voice: string }[];\n}\n\ninterface VendorConfig {\n  id: string;\n  version: string;\n  name: string;\n  author: string;\n  description?: string;\n  icon?: string;\n  inputs: { key: string; label: string; type: "text" | "password" | "url"; required: boolean; placeholder?: string; disabled?: boolean }[];\n  inputValues: Record<string, string>;\n  models: (TextModel | ImageModel | VideoModel | TTSModel)[];\n}\n\ntype ReferenceList =\n  | { type: "image"; sourceType: "base64"; base64: string }\n  | { type: "audio"; sourceType: "base64"; base64: string }\n  | { type: "video"; sourceType: "base64"; base64: string };\n\ninterface ImageConfig {\n  prompt: string;\n  referenceList?: Extract<ReferenceList, { type: "image" }>[];\n  size: "1K" | "2K" | "4K";\n  aspectRatio: `${number}:${number}`;\n}\n\ninterface VideoConfig {\n  duration: number;\n  resolution: string;\n  aspectRatio: "16:9" | "9:16";\n  prompt: string;\n  referenceList?: ReferenceList[];\n  audio?: boolean;\n  mode: VideoMode[];\n}\n\ninterface TTSConfig {\n  text: string;\n  voice: string;\n  speechRate: number;\n  pitchRate: number;\n  volume: number;\n  referenceList?: Extract<ReferenceList, { type: "audio" }>[];\n}\n\ninterface PollResult {\n  completed: boolean;\n  data?: string;\n  error?: string;\n}\n\ntype AtlasVideoModelKind =\n  | "seedanceTextToVideo"\n  | "seedanceReferenceToVideo"\n  | "seedanceImageToVideo"\n  | "wanReferenceToVideo"\n  | "generic";\n\n// ============================================================\n// \u5168\u5C40\u58F0\u660E\n// ============================================================\n\ndeclare const axios: any;\ndeclare const logger: (msg: string) => void;\ndeclare const urlToBase64: (url: string) => Promise<string>;\ndeclare const pollTask: (fn: () => Promise<PollResult>, interval?: number, timeout?: number) => Promise<PollResult>;\ndeclare const createOpenAICompatible: any;\ndeclare const exports: {\n  vendor: VendorConfig;\n  textRequest: (m: TextModel, t: boolean, tl: 0 | 1 | 2 | 3) => any;\n  imageRequest: (c: ImageConfig, m: ImageModel) => Promise<string>;\n  videoRequest: (c: VideoConfig, m: VideoModel) => Promise<string>;\n  ttsRequest: (c: TTSConfig, m: TTSModel) => Promise<string>;\n  checkForUpdates?: () => Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }>;\n  updateVendor?: () => Promise<string>;\n};\n\n// ============================================================\n// \u4F9B\u5E94\u5546\u914D\u7F6E\n// ============================================================\n\nconst vendor: VendorConfig = {\n  id: "atlascloud",\n  version: "1.0",\n  author: "AtlasCloud",\n  name: "AtlasCloud MASS",\n  description: "AtlasCloud \u5168\u6A21\u6001\u5E73\u53F0\u63A5\u5165 AirFlow\u3002\u9ED8\u8BA4\u6309\u5B98\u65B9\u6587\u6863\u586B\u5199\u6587\u672C\u3001\u56FE\u7247\u3001\u89C6\u9891\u4E0E\u4EFB\u52A1\u8F6E\u8BE2\u8DEF\u5F84\u3002",\n  inputs: [\n    { key: "apiKey", label: "API\u5BC6\u94A5", type: "password", required: true, placeholder: "AtlasCloud API Key" },\n    { key: "chatBaseUrl", label: "\u6587\u672C\u57FA\u5730\u5740", type: "url", required: true, placeholder: "https://api.atlascloud.ai/v1", disabled: true },\n    { key: "mediaBaseUrl", label: "\u5A92\u4F53\u57FA\u5730\u5740", type: "url", required: true, placeholder: "https://api.atlascloud.ai/api/v1", disabled: true },\n  ],\n  inputValues: {\n    apiKey: "",\n    chatBaseUrl: "https://api.atlascloud.ai/v1",\n    mediaBaseUrl: "https://api.atlascloud.ai/api/v1",\n  },\n  models: [\n    { name: "DeepSeek V4 Pro", modelName: "deepseek-ai/deepseek-v4-pro", type: "text", think: false },\n    { name: "DeepSeek V4 Flash", modelName: "deepseek-ai/deepseek-v4-flash", type: "text", think: false },\n    { name: "Kimi K2.6", modelName: "moonshotai/kimi-k2.6", type: "text", think: false },\n    { name: "GLM 5.1", modelName: "zai-org/glm-5.1", type: "text", think: false },\n    { name: "MiniMax M2.7", modelName: "minimaxai/minimax-m2.7", type: "text", think: false },\n    { name: "GPT Image 2", modelName: "openai/gpt-image-2/text-to-image", type: "image", mode: ["text", "singleImage"] },\n    { name: "Nano Banana Pro", modelName: "google/nano-banana-pro/text-to-image", type: "image", mode: ["text", "singleImage", "multiReference"] },\n    { name: "Nano Banana 2", modelName: "google/nano-banana-2/text-to-image", type: "image", mode: ["text", "singleImage", "multiReference"] },\n    { name: "Seedream v5", modelName: "bytedance/seedream-v5.0-lite/sequential", type: "image", mode: ["text"] },\n    { name: "Qwen Image 2 Pro", modelName: "qwen/qwen-image-2.0-pro/text-to-image", type: "image", mode: ["text"] },\n    {\n      name: "Seedance 2.0 Audio-Visual",\n      modelName: "bytedance/seedance-2.0/text-to-video",\n      type: "video",\n      mode: ["text", "startFrameOptional", ["imageReference:9", "videoReference:3", "audioReference:3"]],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["480p", "720p"] }],\n    },\n    {\n      name: "Seedance 2.0 Reference-to-Video",\n      modelName: "bytedance/seedance-2.0/reference-to-video",\n      type: "video",\n      mode: ["singleImage"],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["480p", "720p", "1080p"] }],\n    },\n    {\n      name: "Seedance 2.0 Multi-Image-to-Video",\n      modelName: "bytedance/seedance-2.0/image-to-video",\n      type: "video",\n      mode: ["startFrameOptional", ["imageReference:4"]],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["480p", "720p", "1080p"] }],\n    },\n    {\n      name: "Seedance 2.0 Fast Audio-Visual",\n      modelName: "bytedance/seedance-2.0-fast/text-to-video",\n      type: "video",\n      mode: ["text", "startFrameOptional", ["imageReference:9", "videoReference:3", "audioReference:3"]],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["480p", "720p"] }],\n    },\n    {\n      name: "Seedance 2.0 Fast Reference-to-Video",\n      modelName: "bytedance/seedance-2.0-fast/reference-to-video",\n      type: "video",\n      mode: ["singleImage"],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["480p", "720p"] }],\n    },\n    {\n      name: "Wan-2.7 Reference-to-video",\n      modelName: "alibaba/wan-2.7/reference-to-video",\n      type: "video",\n      mode: ["singleImage"],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [2, 3, 4, 5, 6, 7, 8, 9, 10], resolution: ["720p", "1080p"] }],\n    },\n  ],\n};\n\n// ============================================================\n// \u8F85\u52A9\u5DE5\u5177\n// ============================================================\n\nconst getChatBaseUrl = () => vendor.inputValues.chatBaseUrl.replace(/\\/+$/, "");\n\nconst getMediaBaseUrl = () => vendor.inputValues.mediaBaseUrl.replace(/\\/+$/, "");\n\nconst joinUrl = (base: string, path: string) => `${base}${path.startsWith("/") ? "" : "/"}${path}`;\n\nconst getHeaders = () => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11 API Key");\n  return {\n    "Content-Type": "application/json",\n    Authorization: `Bearer ${vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "")}`,\n  };\n};\n\nconst readByPath = (obj: any, path: string): any => {\n  if (!obj || !path) return undefined;\n  const normalizedPath = path.replace(/\\[(\\d+)\\]/g, ".$1");\n  return normalizedPath.split(".").reduce((acc, key) => (acc == null ? undefined : acc[key]), obj);\n};\n\nconst pickFirstPath = (obj: any, paths: string[]): any => {\n  for (const path of paths) {\n    const value = readByPath(obj, path);\n    if (value !== undefined && value !== null && value !== "") return value;\n  }\n  return undefined;\n};\n\nconst extractTaskId = (data: any): string | undefined => {\n  return pickFirstPath(data, ["id", "taskId", "task_id", "data.id", "data.taskId", "data.task_id"]);\n};\n\nconst extractUrl = (data: any): string | undefined => {\n  return (\n    (Array.isArray(readByPath(data, "data.outputs")) ? readByPath(data, "data.outputs")[0] : undefined) ||\n    (Array.isArray(readByPath(data, "outputs")) ? readByPath(data, "outputs")[0] : undefined) ||\n    readByPath(data, "url") ||\n    readByPath(data, "video_url") ||\n    readByPath(data, "image_url") ||\n    readByPath(data, "data.url") ||\n    readByPath(data, "data.video_url") ||\n    readByPath(data, "data.image_url") ||\n    readByPath(data, "data.output.url") ||\n    readByPath(data, "data.output.video_url") ||\n    readByPath(data, "output.url")\n  );\n};\n\nconst extractB64 = (data: any): string | undefined => {\n  return pickFirstPath(data, ["b64_json", "data.b64_json", "data.0.b64_json", "data[0].b64_json"]);\n};\n\nconst extractStatus = (data: any): string => {\n  const statusRaw = pickFirstPath(data, ["status", "data.status", "data.state", "state"]);\n  return String(statusRaw || "").toLowerCase();\n};\n\nconst extractError = (data: any): string | undefined => {\n  return pickFirstPath(data, ["error.message", "message", "msg", "data.error.message", "data.message"]);\n};\n\nconst isDnsOrNetworkError = (err: any): boolean => {\n  const msg = String(err?.message || err || "");\n  return /ENOTFOUND|EAI_AGAIN|ECONNRESET|ETIMEDOUT|timeout/i.test(msg);\n};\n\nconst withNetworkRetry = async <T>(fn: () => Promise<T>, maxRetry = 3, waitMs = 1500): Promise<T> => {\n  let lastErr: any;\n  for (let i = 0; i < maxRetry; i += 1) {\n    try {\n      return await fn();\n    } catch (err) {\n      lastErr = err;\n      if (!isDnsOrNetworkError(err) || i === maxRetry - 1) throw err;\n      await new Promise((resolve) => setTimeout(resolve, waitMs * (i + 1)));\n    }\n  }\n  throw lastErr;\n};\n\nconst resolveAtlasImageModelName = (modelName: string, hasImageRefs: boolean): string => {\n  if (!hasImageRefs) return modelName;\n\n  switch (modelName) {\n    case "google/nano-banana-pro/text-to-image":\n      return "google/nano-banana-pro/edit";\n    case "google/nano-banana-2/text-to-image":\n      return "google/nano-banana-2/edit";\n    default:\n      return modelName;\n  }\n};\n\nconst resolveAtlasVideoModelKind = (modelName: string): AtlasVideoModelKind => {\n  if (modelName === "alibaba/wan-2.7/reference-to-video") return "wanReferenceToVideo";\n  if (/^bytedance\\/seedance-2\\.0(?:-fast)?\\/reference-to-video$/.test(modelName)) return "seedanceReferenceToVideo";\n  if (/^bytedance\\/seedance-2\\.0(?:-fast)?\\/image-to-video$/.test(modelName)) return "seedanceImageToVideo";\n  if (/^bytedance\\/seedance-2\\.0(?:-fast)?\\/text-to-video$/.test(modelName)) return "seedanceTextToVideo";\n  return "generic";\n};\n\nconst clampNumber = (value: unknown, min: number, max: number, fallback: number): number => {\n  const num = Number(value);\n  if (!Number.isFinite(num)) return fallback;\n  return Math.max(min, Math.min(max, num));\n};\n\nconst normalizeResolution = (value: unknown, allowed: string[], fallback: string): string => {\n  const lower = String(value || "").toLowerCase();\n  const matched = allowed.find((item) => item.toLowerCase() === lower);\n  if (matched) return matched;\n  if (/1080/.test(lower)) return allowed.find((item) => /1080/i.test(item)) || fallback;\n  if (/720/.test(lower)) return allowed.find((item) => /720/i.test(item)) || fallback;\n  if (/480/.test(lower)) return allowed.find((item) => /480/i.test(item)) || fallback;\n  return fallback;\n};\n\nconst getReferenceLimit = (\n  modes: VideoMode[],\n  prefix: "imageReference" | "videoReference" | "audioReference",\n): number | undefined => {\n  for (const mode of modes) {\n    if (!Array.isArray(mode)) continue;\n    for (const entry of mode) {\n      if (!entry.startsWith(`${prefix}:`)) continue;\n      const limit = Number(entry.split(":")[1]);\n      if (Number.isFinite(limit) && limit > 0) return limit;\n    }\n  }\n  return undefined;\n};\n\nconst limitReferences = (refs: string[], maxCount?: number): string[] => {\n  if (!maxCount || maxCount < 1) return refs;\n  return refs.slice(0, maxCount);\n};\n\nconst summarizeRefCount = (usedCount: number, rawCount: number): string => {\n  return usedCount === rawCount ? String(usedCount) : `${usedCount}/${rawCount}`;\n};\n\nconst buildAtlasVideoPayload = (config: VideoConfig, model: VideoModel) => {\n  const rawImageRefs = (config.referenceList || []).filter((r) => r.type === "image").map((r) => r.base64).filter(Boolean);\n  const rawVideoRefs = (config.referenceList || []).filter((r) => r.type === "video").map((r) => r.base64).filter(Boolean);\n  const rawAudioRefs = (config.referenceList || []).filter((r) => r.type === "audio").map((r) => r.base64).filter(Boolean);\n\n  const imageRefs = limitReferences(rawImageRefs, getReferenceLimit(model.mode, "imageReference"));\n  const videoRefs = limitReferences(rawVideoRefs, getReferenceLimit(model.mode, "videoReference"));\n  const audioRefs = limitReferences(rawAudioRefs, getReferenceLimit(model.mode, "audioReference"));\n  const kind = resolveAtlasVideoModelKind(model.modelName);\n  const ratio = config.aspectRatio || "16:9";\n  const shouldGenerateAudio = model.audio === true || (model.audio === "optional" && config.audio !== false);\n  const body: any = {\n    model: model.modelName,\n    prompt: config.prompt || "",\n  };\n\n  if (kind === "wanReferenceToVideo") {\n    if (imageRefs.length < 1) {\n      throw new Error(`${model.name} \u9700\u8981\u81F3\u5C11 1 \u5F20\u53C2\u8003\u56FE`);\n    }\n    body.images = [imageRefs[0]];\n    body.ratio = ratio;\n    body.duration = clampNumber(config.duration, 2, 10, 5);\n    body.resolution = normalizeResolution(config.resolution, ["720P", "1080P"], "720P");\n    body.prompt_extend = false;\n    body.seed = -1;\n  } else if (kind === "seedanceReferenceToVideo") {\n    if (imageRefs.length < 1) {\n      throw new Error(`${model.name} \u9700\u8981\u81F3\u5C11 1 \u5F20\u53C2\u8003\u56FE`);\n    }\n    if (shouldGenerateAudio) body.generate_audio = true;\n    body.images = [imageRefs[0]];\n    body.ratio = ratio;\n    body.duration = clampNumber(config.duration, 4, 15, 5);\n    body.resolution = normalizeResolution(config.resolution, ["480p", "720p", "1080p"], "720p");\n    body.watermark = false;\n  } else if (kind === "seedanceImageToVideo") {\n    if (imageRefs.length < 1) {\n      throw new Error(`${model.name} \u9700\u8981\u81F3\u5C11 1 \u5F20\u53C2\u8003\u56FE`);\n    }\n    if (shouldGenerateAudio) body.generate_audio = true;\n    body.images = imageRefs;\n    body.ratio = ratio;\n    body.duration = clampNumber(config.duration, 4, 15, 5);\n    body.resolution = normalizeResolution(config.resolution, ["480p", "720p", "1080p"], "720p");\n    body.watermark = false;\n  } else {\n    if (shouldGenerateAudio) body.generate_audio = true;\n    if (imageRefs.length > 0) body.reference_images = imageRefs;\n    if (videoRefs.length > 0) body.reference_videos = videoRefs;\n    if (audioRefs.length > 0) body.reference_audios = audioRefs;\n    body.ratio = ratio;\n    body.duration = clampNumber(config.duration, 4, 15, 5);\n    body.resolution = normalizeResolution(config.resolution, ["480p", "720p"], "720p");\n    body.watermark = false;\n  }\n\n  return {\n    body,\n    summary: `kind=${kind} imageRefs=${summarizeRefCount(imageRefs.length, rawImageRefs.length)} videoRefs=${summarizeRefCount(videoRefs.length, rawVideoRefs.length)} audioRefs=${summarizeRefCount(audioRefs.length, rawAudioRefs.length)} resolution=${body.resolution} duration=${body.duration}${shouldGenerateAudio ? " audio=on" : " audio=off"}`,\n  };\n};\n\n// ============================================================\n// \u9002\u914D\u5668\u51FD\u6570\n// ============================================================\n\nconst textRequest = (model: TextModel, think: boolean, thinkLevel: 0 | 1 | 2 | 3) => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11 API Key");\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\n  const effortMap: Record<number, string> = { 0: "minimal", 1: "low", 2: "medium", 3: "high" };\n\n  return createOpenAICompatible({\n    name: "atlascloud",\n    baseURL: getChatBaseUrl(),\n    apiKey,\n    fetch: async (url: string, options?: RequestInit) => {\n      const rawBody = JSON.parse((options?.body as string) ?? "{}");\n      const body = think\n        ? {\n          ...rawBody,\n          thinking: { type: "enabled" },\n          reasoning_effort: effortMap[thinkLevel],\n        }\n        : rawBody;\n      return await fetch(url, { ...options, body: JSON.stringify(body) });\n    },\n  }).chatModel(model.modelName);\n};\n\nconst imageRequest = async (config: ImageConfig, model: ImageModel): Promise<string> => {\n  const headers = getHeaders();\n  const url = joinUrl(getMediaBaseUrl(), "/model/generateImage");\n  const sizeToResolution: Record<ImageConfig["size"], string> = {\n    "1K": "1k",\n    "2K": "2k",\n    "4K": "4k",\n  };\n  const imageRefs = (config.referenceList || []).map((ref) => ref.base64).filter(Boolean);\n  const resolvedModelName = resolveAtlasImageModelName(model.modelName, imageRefs.length > 0);\n  const isNanoModel = /^google\\/nano-banana-(pro|2)\\//.test(resolvedModelName);\n  const supportsImageConditioning = /^(openai\\/gpt-image-2\\/text-to-image|google\\/nano-banana-(pro|2)\\/edit)$/.test(resolvedModelName);\n\n  const body: any = {\n    model: resolvedModelName,\n    prompt: config.prompt || "",\n  };\n  if (supportsImageConditioning && imageRefs.length > 0) {\n    body.images = imageRefs;\n  }\n  if (isNanoModel) {\n    body.aspect_ratio = config.aspectRatio || "16:9";\n    body.resolution = sizeToResolution[config.size || "1K"] || "1k";\n  }\n\n  logger(`[AtlasCloud \u56FE\u7247] \u63D0\u4EA4\u4EFB\u52A1: ${model.modelName} -> ${resolvedModelName}, refs=${imageRefs.length}`);\n  const submitResp = await axios.post(url, body, { headers });\n  const submitData = submitResp.data;\n\n  // \u540C\u6B65\u8FD4\u56DE\uFF08\u76F4\u63A5\u62FF\u56FE\uFF09\n  const syncB64 = extractB64(submitData);\n  if (syncB64) return syncB64;\n  const syncUrl = extractUrl(submitData);\n  if (syncUrl) return await urlToBase64(syncUrl);\n\n  // \u5F02\u6B65\u8FD4\u56DE\uFF08\u62FF taskId \u518D\u8F6E\u8BE2\uFF09\n  const taskId = extractTaskId(submitData);\n  if (!taskId) {\n    throw new Error(`\u56FE\u7247\u4EFB\u52A1\u63D0\u4EA4\u5931\u8D25\uFF1A\u672A\u83B7\u53D6\u5230\u4EFB\u52A1ID\u3002\u539F\u59CB\u54CD\u5E94\uFF1A${JSON.stringify(submitData).slice(0, 500)}`);\n  }\n\n  const pollResult = await pollTask(\n    async (): Promise<PollResult> => {\n      const resultUrl = joinUrl(getMediaBaseUrl(), `/model/prediction/${taskId}`);\n      const resultResp = await axios.get(resultUrl, { headers });\n      const data = resultResp.data;\n      const status = extractStatus(data);\n\n      if (["succeeded", "success", "done", "completed"].includes(status)) {\n        const b64 = extractB64(data);\n        if (b64) return { completed: true, data: b64 };\n        const mediaUrl = extractUrl(data);\n        if (mediaUrl) return { completed: true, data: mediaUrl };\n        return { completed: true, error: "\u4EFB\u52A1\u6210\u529F\u4F46\u672A\u8FD4\u56DE\u7ED3\u679C\u5730\u5740" };\n      }\n      if (["failed", "error", "cancelled", "canceled", "expired"].includes(status)) {\n        return { completed: true, error: extractError(data) || "\u56FE\u7247\u751F\u6210\u5931\u8D25" };\n      }\n      return { completed: false };\n    },\n    3000,\n    600000,\n  );\n\n  if (pollResult.error) throw new Error(pollResult.error);\n  if (!pollResult.data) throw new Error("\u56FE\u7247\u751F\u6210\u5931\u8D25\uFF1A\u8F6E\u8BE2\u672A\u8FD4\u56DE\u6570\u636E");\n  if (pollResult.data.startsWith("data:")) return pollResult.data;\n  if (pollResult.data.startsWith("http")) return await urlToBase64(pollResult.data);\n  return pollResult.data;\n};\n\nconst videoRequest = async (config: VideoConfig, model: VideoModel): Promise<string> => {\n  const headers = getHeaders();\n  const url = joinUrl(getMediaBaseUrl(), "/model/generateVideo");\n  const { body, summary } = buildAtlasVideoPayload(config, model);\n\n  logger(`[AtlasCloud \u89C6\u9891] \u63D0\u4EA4\u4EFB\u52A1: ${model.modelName}, ${summary}`);\n  const submitResp: any = await withNetworkRetry<any>(() => axios.post(url, body, { headers }), 3, 1500);\n  const submitData = submitResp.data;\n\n  const taskId = extractTaskId(submitData);\n  if (!taskId) {\n    const syncUrl = extractUrl(submitData);\n    if (syncUrl) return await urlToBase64(syncUrl);\n    throw new Error(`\u89C6\u9891\u4EFB\u52A1\u63D0\u4EA4\u5931\u8D25\uFF1A\u672A\u83B7\u53D6\u5230\u4EFB\u52A1ID\u3002\u539F\u59CB\u54CD\u5E94\uFF1A${JSON.stringify(submitData).slice(0, 500)}`);\n  }\n\n  const pollResult = await pollTask(\n    async (): Promise<PollResult> => {\n      const resultUrl = joinUrl(getMediaBaseUrl(), `/model/prediction/${taskId}`);\n      const resultResp: any = await withNetworkRetry<any>(() => axios.get(resultUrl, { headers }), 3, 1200);\n      const data = resultResp.data;\n      const status = extractStatus(data);\n\n      if (["succeeded", "success", "done", "completed"].includes(status)) {\n        const mediaUrl = extractUrl(data);\n        if (mediaUrl) return { completed: true, data: mediaUrl };\n        return { completed: true, error: "\u4EFB\u52A1\u6210\u529F\u4F46\u672A\u8FD4\u56DE\u89C6\u9891\u5730\u5740" };\n      }\n      if (["failed", "error", "cancelled", "canceled", "expired"].includes(status)) {\n        return { completed: true, error: extractError(data) || "\u89C6\u9891\u751F\u6210\u5931\u8D25" };\n      }\n      return { completed: false };\n    },\n    5000,\n    1800000,\n  );\n\n  if (pollResult.error) throw new Error(pollResult.error);\n  if (!pollResult.data) throw new Error("\u89C6\u9891\u751F\u6210\u5931\u8D25\uFF1A\u8F6E\u8BE2\u672A\u8FD4\u56DE\u6570\u636E");\n  return await urlToBase64(pollResult.data);\n};\n\nconst ttsRequest = async (_config: TTSConfig, _model: TTSModel): Promise<string> => {\n  // AtlasCloud \u5F53\u524D\u7248\u672C\u5148\u4E0D\u63A5 TTS\u3002\n  return "";\n};\n\nconst checkForUpdates = async (): Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }> => {\n  return {\n    hasUpdate: false,\n    latestVersion: vendor.version,\n    notice: "AtlasCloud MASS \u521D\u7A3F\u3002",\n  };\n};\n\nconst updateVendor = async (): Promise<string> => {\n  return "";\n};\n\n// ============================================================\n// \u5BFC\u51FA\n// ============================================================\n\nexports.vendor = vendor;\nexports.textRequest = textRequest;\nexports.imageRequest = imageRequest;\nexports.videoRequest = videoRequest;\nexports.ttsRequest = ttsRequest;\nexports.checkForUpdates = checkForUpdates;\nexports.updateVendor = updateVendor;\n\nexport { };\n',
      "deepseek.ts": '/**\n * AirFlow AI\u4F9B\u5E94\u5546\u6A21\u677F - DeepSeek\n * @version 2.0\n */\n\n// ============================================================\n// \u7C7B\u578B\u5B9A\u4E49\n// ============================================================\n\ntype VideoMode =\n  | "singleImage"\n  | "startEndRequired"\n  | "endFrameOptional"\n  | "startFrameOptional"\n  | "text"\n  | (`videoReference:${number}` | `imageReference:${number}` | `audioReference:${number}`)[];\n\ninterface TextModel {\n  name: string;\n  modelName: string;\n  type: "text";\n  think: boolean;\n}\n\ninterface ImageModel {\n  name: string;\n  modelName: string;\n  type: "image";\n  mode: ("text" | "singleImage" | "multiReference")[];\n  associationSkills?: string;\n}\n\ninterface VideoModel {\n  name: string;\n  modelName: string;\n  type: "video";\n  mode: VideoMode[];\n  associationSkills?: string;\n  audio: "optional" | false | true;\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\n}\n\ninterface TTSModel {\n  name: string;\n  modelName: string;\n  type: "tts";\n  voices: { title: string; voice: string }[];\n}\n\ninterface VendorConfig {\n  id: string;\n  version: string;\n  name: string;\n  author: string;\n  description?: string;\n  icon?: string;\n  inputs: { key: string; label: string; type: "text" | "password" | "url"; required: boolean; placeholder?: string }[];\n  inputValues: Record<string, string>;\n  models: (TextModel | ImageModel | VideoModel | TTSModel)[];\n}\n\ninterface ImageConfig {\n  prompt: string;\n  imageBase64: string[];\n  size: "1K" | "2K" | "4K";\n  aspectRatio: `${number}:${number}`;\n}\n\ninterface VideoConfig {\n  duration: number;\n  resolution: string;\n  aspectRatio: "16:9" | "9:16";\n  prompt: string;\n  imageBase64?: string[];\n  audio?: boolean;\n  mode: VideoMode[];\n}\n\ninterface TTSConfig {\n  text: string;\n  voice: string;\n  speechRate: number;\n  pitchRate: number;\n  volume: number;\n}\n\ninterface PollResult {\n  completed: boolean;\n  data?: string;\n  error?: string;\n}\n\n// ============================================================\n// \u5168\u5C40\u58F0\u660E\n// ============================================================\n\ndeclare const axios: any;\ndeclare const logger: (msg: string) => void;\ndeclare const jsonwebtoken: any;\ndeclare const zipImage: (base64: string, size: number) => Promise<string>;\ndeclare const zipImageResolution: (base64: string, w: number, h: number) => Promise<string>;\ndeclare const mergeImages: (base64Arr: string[], maxSize?: string) => Promise<string>;\ndeclare const urlToBase64: (url: string) => Promise<string>;\ndeclare const pollTask: (fn: () => Promise<PollResult>, interval?: number, timeout?: number) => Promise<PollResult>;\ndeclare const createOpenAI: any;\ndeclare const createDeepSeek: any;\ndeclare const createZhipu: any;\ndeclare const createQwen: any;\ndeclare const createAnthropic: any;\ndeclare const createOpenAICompatible: any;\ndeclare const createXai: any;\ndeclare const createMinimax: any;\ndeclare const createGoogleGenerativeAI: any;\ndeclare const exports: {\n  vendor: VendorConfig;\n  textRequest: (m: TextModel, t: boolean, tl: 0 | 1 | 2 | 3) => any;\n  imageRequest: (c: ImageConfig, m: ImageModel) => Promise<string>;\n  videoRequest: (c: VideoConfig, m: VideoModel) => Promise<string>;\n  ttsRequest: (c: TTSConfig, m: TTSModel) => Promise<string>;\n  checkForUpdates?: () => Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }>;\n  updateVendor?: () => Promise<string>;\n};\n\n// ============================================================\n// \u4F9B\u5E94\u5546\u914D\u7F6E\n// ============================================================\n\nconst vendor: VendorConfig = {\n  id: "deepseek",\n  version: "2.0",\n  author: "AirFlow",\n  name: "DeepSeek",\n  description:\n    "DeepSeek \u5B98\u65B9\u63A5\u53E3\u9002\u914D\uFF0C\u652F\u6301 V4 \u7CFB\u5217\u6A21\u578B\u4E0E\u601D\u8003\u6A21\u5F0F\uFF08\u601D\u7EF4\u94FE\u8F93\u51FA\uFF09\u3002\\n\\n[\u524D\u5F80\u5E73\u53F0](https://platform.deepseek.com/)",\n  icon: "",\n  inputs: [\n    { key: "apiKey", label: "API\u5BC6\u94A5", type: "password", required: true },\n    { key: "baseUrl", label: "\u8BF7\u6C42\u5730\u5740", type: "url", required: true, placeholder: "\u793A\u4F8B\uFF1Ahttps://api.deepseek.com" },\n  ],\n  inputValues: {\n    apiKey: "",\n    baseUrl: "https://api.deepseek.com/v1",\n  },\n  models: [\n    { name: "DeepSeek V4 Pro", modelName: "deepseek-v4-pro", type: "text", think: true },\n    { name: "DeepSeek V4 Flash", modelName: "deepseek-v4-flash", type: "text", think: true },\n  ],\n};\n\n// ============================================================\n// \u9002\u914D\u5668\u51FD\u6570\n// ============================================================\n\nconst textRequest = (model: TextModel, think: boolean, thinkLevel: 0 | 1 | 2 | 3) => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\n\n  // DeepSeek \u601D\u8003\u5F3A\u5EA6\u4EC5\u652F\u6301 high / max\uFF08low\u3001medium \u4F1A\u88AB\u6620\u5C04\u4E3A high\uFF0Cxhigh \u4F1A\u88AB\u6620\u5C04\u4E3A max\uFF09\n  // thinkLevel: 0/1/2 \u2192 high, 3 \u2192 max\n  const effortMap: Record<0 | 1 | 2 | 3, "high" | "max"> = {\n    0: "high",\n    1: "high",\n    2: "high",\n    3: "max",\n  };\n\n  const enableThinking = model.think && think;\n  const extraBody: Record<string, any> = {\n    thinking: { type: enableThinking ? "enabled" : "disabled" },\n  };\n  if (enableThinking) {\n    extraBody.reasoning_effort = effortMap[thinkLevel];\n  }\n\n  return createDeepSeek({\n    baseURL: vendor.inputValues.baseUrl,\n    apiKey,\n    extraBody,\n  }).chat(model.modelName);\n};\n\nconst imageRequest = async (config: ImageConfig, model: ImageModel): Promise<string> => {\n  return "";\n};\n\nconst videoRequest = async (config: VideoConfig, model: VideoModel): Promise<string> => {\n  return "";\n};\n\nconst ttsRequest = async (config: TTSConfig, model: TTSModel): Promise<string> => {\n  return "";\n};\n\nconst checkForUpdates = async (): Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }> => {\n  return { hasUpdate: false, latestVersion: "2.0", notice: "" };\n};\n\nconst updateVendor = async (): Promise<string> => {\n  return "";\n};\n\n// ============================================================\n// \u5BFC\u51FA\n// ============================================================\n\nexports.vendor = vendor;\nexports.textRequest = textRequest;\nexports.imageRequest = imageRequest;\nexports.videoRequest = videoRequest;\nexports.ttsRequest = ttsRequest;\nexports.checkForUpdates = checkForUpdates;\nexports.updateVendor = updateVendor;\n\nexport { };',
      "grsai.ts": '/**\r\n * AirFlow AI\u4F9B\u5E94\u5546\u6A21\u677F\r\n * @version 2.0\r\n */\r\n\r\n// ============================================================\r\n// \u7C7B\u578B\u5B9A\u4E49\r\n// ============================================================\r\n\r\ntype VideoMode =\r\n  | "singleImage" //\u5355\u56FE\u53C2\u8003\r\n  | "startEndRequired" //\u9996\u5C3E\u5E27\uFF08\u4E24\u5F20\u90FD\u5F97\u6709\uFF09\r\n  | "endFrameOptional" //\u9996\u5C3E\u5E27\uFF08\u5C3E\u5E27\u53EF\u9009\uFF09\r\n  | "startFrameOptional" //\u9996\u5C3E\u5E27\uFF08\u9996\u5E27\u53EF\u9009\uFF09\r\n  | "text" //\u6587\u672C\r\n  | (\r\n      | `videoReference:${number}`\r\n      | `imageReference:${number}`\r\n      | `audioReference:${number}`\r\n    )[]; //\u591A\u53C2\u8003\uFF08\u6570\u5B57\u4EE3\u8868\u9650\u5236\u6570\u91CF\uFF09\r\n\r\ninterface TextModel {\r\n  name: string;\r\n  modelName: string;\r\n  type: "text";\r\n  think: boolean;\r\n}\r\n\r\ninterface ImageModel {\r\n  name: string;\r\n  modelName: string;\r\n  type: "image";\r\n  mode: ("text" | "singleImage" | "multiReference")[];\r\n  associationSkills?: string;\r\n}\r\n\r\ninterface VideoModel {\r\n  name: string;\r\n  modelName: string;\r\n  type: "video";\r\n  mode: VideoMode[];\r\n  associationSkills?: string;\r\n  audio: "optional" | false | true;\r\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\r\n}\r\n\r\ninterface TTSModel {\r\n  name: string;\r\n  modelName: string;\r\n  type: "tts";\r\n  voices: { title: string; voice: string }[];\r\n}\r\n\r\ninterface VendorConfig {\r\n  id: string; //\u552F\u4E00ID\uFF0C\u4F5C\u4E3A\u6587\u4EF6\u540D\u5B58\u50A8\u7528\u6237\u78C1\u76D8\u4E0A\uFF0C\u7981\u6B62\u7B26\u53F7\r\n  version: string; //\u7248\u672C\u53F7\uFF0C\u683C\u5F0F\u4E3Ax.y\uFF0C\u9700\u9075\u5B88\u8BED\u4E49\u5316\u7248\u672C\u63A7\u5236\r\n  name: string; //\u4F9B\u5E94\u5546\u540D\u79F0\r\n  author: string; //\u4F5C\u8005\r\n  description?: string; //\u63CF\u8FF0\uFF0C\u652F\u6301Markdown\u683C\u5F0F\r\n  icon?: string; //\u56FE\u6807\uFF0C\u4EC5\u652F\u6301Base64\u683C\u5F0F\uFF0C\u5EFA\u8BAE\u5C3A\u5BF8\u4E3A128x128\u50CF\u7D20\r\n  inputs: {\r\n    key: string;\r\n    label: string;\r\n    type: "text" | "password" | "url";\r\n    required: boolean;\r\n    placeholder?: string;\r\n  }[];\r\n  inputValues: Record<string, string>;\r\n  models: (TextModel | ImageModel | VideoModel | TTSModel)[];\r\n}\r\n\r\ntype ReferenceList =\r\n  | { type: "image"; sourceType: "base64"; base64: string }\r\n  | { type: "audio"; sourceType: "base64"; base64: string }\r\n  | { type: "video"; sourceType: "base64"; base64: string };\r\n\r\ninterface ImageConfig {\r\n  prompt: string;\r\n  referenceList?: Extract<ReferenceList, { type: "image" }>[];\r\n  size: "1K" | "2K" | "4K";\r\n  aspectRatio: `${number}:${number}`;\r\n}\r\n\r\ninterface VideoConfig {\r\n  duration: number;\r\n  resolution: string;\r\n  aspectRatio: "16:9" | "9:16";\r\n  prompt: string;\r\n  referenceList?: ReferenceList[];\r\n  audio?: boolean;\r\n  mode: VideoMode[];\r\n}\r\n\r\ninterface TTSConfig {\r\n  text: string;\r\n  voice: string;\r\n  speechRate: number;\r\n  pitchRate: number;\r\n  volume: number;\r\n  referenceList?: Extract<ReferenceList, { type: "audio" }>[];\r\n}\r\n\r\ninterface PollResult {\r\n  completed: boolean;\r\n  data?: string;\r\n  error?: string;\r\n}\r\n\r\n// ============================================================\r\n// \u5168\u5C40\u58F0\u660E\r\n// ============================================================\r\n\r\ndeclare const axios: any; // HTTP\u8BF7\u6C42\u5E93\r\ndeclare const logger: (msg: string) => void; // \u65E5\u5FD7\u51FD\u6570\r\ndeclare const jsonwebtoken: any; // JWT\u5904\u7406\u5E93\r\ndeclare const zipImage: (base64: string, size: number) => Promise<string>; // \u56FE\u7247\u538B\u7F29\u51FD\u6570\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\ndeclare const zipImageResolution: (\r\n  base64: string,\r\n  w: number,\r\n  h: number,\r\n) => Promise<string>; // \u56FE\u7247\u5206\u8FA8\u7387\u8C03\u6574\u51FD\u6570\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\ndeclare const mergeImages: (\r\n  base64Arr: string[],\r\n  maxSize?: string,\r\n) => Promise<string>; // \u56FE\u7247\u5408\u6210\u51FD\u6570\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\ndeclare const urlToBase64: (url: string) => Promise<string>; // URL\u8F6CBase64\u51FD\u6570\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\ndeclare const pollTask: (\r\n  fn: () => Promise<PollResult>,\r\n  interval?: number,\r\n  timeout?: number,\r\n) => Promise<PollResult>; // \u8F6E\u8BE2\u51FD\u6570\uFF0Cfn\u4E3A\u5F02\u6B65\u51FD\u6570\uFF0Cinterval\u4E3A\u8F6E\u8BE2\u95F4\u9694\uFF0Ctimeout\u4E3A\u8D85\u65F6\u65F6\u95F4\uFF0C\u8FD4\u56DEfn\u7684\u7ED3\u679C\r\ndeclare const createOpenAI: any;\r\ndeclare const createDeepSeek: any;\r\ndeclare const createZhipu: any;\r\ndeclare const createQwen: any;\r\ndeclare const createAnthropic: any;\r\ndeclare const createOpenAICompatible: any;\r\ndeclare const createXai: any;\r\ndeclare const createMinimax: any;\r\ndeclare const createGoogleGenerativeAI: any;\r\ndeclare const exports: {\r\n  vendor: VendorConfig;\r\n  textRequest: (m: TextModel, t: boolean, tl: 0 | 1 | 2 | 3) => any; //\u6587\u672C\u6A21\u578B\r\n  imageRequest: (c: ImageConfig, m: ImageModel) => Promise<string>; //\u56FE\u7247\u6A21\u578B\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\n  videoRequest: (c: VideoConfig, m: VideoModel) => Promise<string>; //\u89C6\u9891\u6A21\u578B\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\n  ttsRequest: (c: TTSConfig, m: TTSModel) => Promise<string>; //\uFF08\u6682\u672A\u5F00\u653E\uFF09\u8BED\u97F3\u6A21\u578B\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\n  checkForUpdates?: () => Promise<{\r\n    hasUpdate: boolean;\r\n    latestVersion: string;\r\n    notice: string;\r\n  }>; //\u68C0\u67E5\u66F4\u65B0\u51FD\u6570\uFF0C\u8FD4\u56DE\u662F\u5426\u6709\u66F4\u65B0\u548C\u6700\u65B0\u7248\u672C\u53F7\u548C\u66F4\u516C\u544A\uFF08\u652F\u6301Markdown\u683C\u5F0F\uFF09\r\n  updateVendor?: () => Promise<string>; //\u66F4\u65B0\u51FD\u6570\uFF0C\u8FD4\u56DE\u6700\u65B0\u7684\u4EE3\u7801\u6587\u672C\r\n};\r\n\r\n// ============================================================\r\n// \u4F9B\u5E94\u5546\u914D\u7F6E\r\n// ============================================================\r\n\r\nconst vendor: VendorConfig = {\r\n  id: "grsai",\r\n  version: "2.1",\r\n  author: "AirFlow",\r\n  name: "Grsai",\r\n  description:\r\n    "Grsai AI\u5E73\u53F0\u9002\u914D\uFF0C\u652F\u6301\u6587\u751F\u56FE\u3001\u56FE\u751F\u56FE\u3001\u6587\u751F\u89C6\u9891\u3001Gemini\u517C\u5BB9\u6587\u672C\u6A21\u578B \\n [\u524D\u5F80\u4E2D\u8F6C\u5E73\u53F0](https://tf.grsai.ai/zh)",\r\n  inputs: [\r\n    { key: "apiKey", label: "API\u5BC6\u94A5", type: "password", required: true },\r\n    {\r\n      key: "baseUrl",\r\n      label: "\u8BF7\u6C42\u5730\u5740",\r\n      type: "url",\r\n      required: true,\r\n      placeholder: "\u793A\u4F8B\uFF1Ahttps://grsai.dakka.com.cn",\r\n    },\r\n  ],\r\n  inputValues: { apiKey: "", baseUrl: "https://grsai.dakka.com.cn" },\r\n  models: [\r\n    {\r\n      name: "GPT Image 2",\r\n      modelName: "gpt-image-2",\r\n      type: "image",\r\n      mode: ["text", "singleImage", "multiReference"],\r\n    },\r\n    {\r\n      name: "Nano Banana Fast",\r\n      modelName: "nano-banana-fast",\r\n      type: "image",\r\n      mode: ["text", "singleImage", "multiReference"],\r\n    },\r\n    {\r\n      name: "Nano Banana 2",\r\n      modelName: "nano-banana-2",\r\n      type: "image",\r\n      mode: ["text", "singleImage", "multiReference"],\r\n    },\r\n    {\r\n      name: "Nano Banana Pro",\r\n      modelName: "nano-banana-pro",\r\n      type: "image",\r\n      mode: ["text", "singleImage", "multiReference"],\r\n    },\r\n  ],\r\n};\r\n\r\n// ============================================================\r\n// \u8F85\u52A9\u5DE5\u5177\r\n// ============================================================\r\n\r\nconst getHeaders = () => {\r\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\r\n  return {\r\n    "Content-Type": "application/json",\r\n    Authorization: `Bearer ${apiKey}`,\r\n  };\r\n};\r\n\r\n// ============================================================\r\n// \u9002\u914D\u5668\u51FD\u6570\r\n// ============================================================\r\n\r\nconst textRequest = (\r\n  model: TextModel,\r\n  think: boolean,\r\n  thinkLevel: 0 | 1 | 2 | 3,\r\n) => {\r\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\r\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\r\n  return createGoogleGenerativeAI({\r\n    baseURL: `${vendor.inputValues.baseUrl}/v1beta`,\r\n    apiKey,\r\n  }).chat(model.modelName);\r\n};\r\n\r\nconst imageRequest = async (\r\n  config: ImageConfig,\r\n  model: ImageModel,\r\n): Promise<string> => {\r\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\r\n  const baseUrl = vendor.inputValues.baseUrl;\r\n  const headers = getHeaders();\r\n\r\n  // \u6784\u9020\u8BF7\u6C42\u53C2\u6570\r\n  const requestBody: any = {\r\n    model: model.modelName,\r\n    prompt: config.prompt,\r\n    aspectRatio: config.aspectRatio,\r\n    webHook: "-1",\r\n    shutProgress: true,\r\n  };\r\n\r\n  // \u8865\u5145\u6A21\u578B\u4E13\u5C5E\u53C2\u6570\r\n  if (model.modelName.startsWith("nano-banana")) {\r\n    requestBody.imageSize = config.size;\r\n  } else {\r\n    requestBody.size = config.aspectRatio;\r\n    requestBody.variants = 1;\r\n  }\r\n\r\n  // \u5904\u7406\u53C2\u8003\u56FE\r\n  if (config.referenceList && config.referenceList.length > 0) {\r\n    requestBody.urls = config.referenceList.map((img) => img.base64);\r\n  }\r\n\r\n  // \u9009\u62E9\u63A5\u53E3\u8DEF\u5F84\r\n  const apiPath = model.modelName.startsWith("nano-banana")\r\n    ? "/v1/draw/nano-banana"\r\n    : "/v1/draw/completions";\r\n\r\n  logger(`\u5F00\u59CB\u63D0\u4EA4\u56FE\u7247\u751F\u6210\u4EFB\u52A1\uFF0C\u6A21\u578B\uFF1A${model.modelName}`);\r\n  const submitResp = await axios.post(`${baseUrl}${apiPath}`, requestBody, {\r\n    headers,\r\n  });\r\n  if (submitResp.data.code !== 0)\r\n    throw new Error(`\u4EFB\u52A1\u63D0\u4EA4\u5931\u8D25\uFF1A${submitResp.data.msg}`);\r\n\r\n  const taskId = submitResp.data.data.id;\r\n  logger(`\u56FE\u7247\u4EFB\u52A1\u63D0\u4EA4\u6210\u529F\uFF0C\u4EFB\u52A1ID\uFF1A${taskId}`);\r\n\r\n  // \u8F6E\u8BE2\u7ED3\u679C\r\n  const pollResult = await pollTask(\r\n    async () => {\r\n      const resp = await axios.post(\r\n        `${baseUrl}/v1/draw/result`,\r\n        { id: taskId },\r\n        { headers },\r\n      );\r\n      if (resp.data.code !== 0)\r\n        return { completed: true, error: resp.data.msg };\r\n\r\n      const taskData = resp.data.data;\r\n      if (taskData.status === "failed")\r\n        return {\r\n          completed: true,\r\n          error: taskData.failure_reason || taskData.error,\r\n        };\r\n      if (taskData.status === "succeeded") {\r\n        const imgUrl = taskData.results?.[0]?.url || taskData.url;\r\n        return { completed: true, data: imgUrl };\r\n      }\r\n      logger(`\u56FE\u7247\u4EFB\u52A1\u751F\u6210\u4E2D\uFF0C\u8FDB\u5EA6\uFF1A${taskData.progress}%`);\r\n      return { completed: false };\r\n    },\r\n    3000,\r\n    600000,\r\n  );\r\n\r\n  if (pollResult.error) throw new Error(pollResult.error);\r\n  logger(`\u56FE\u7247\u751F\u6210\u5B8C\u6210\uFF0C\u5F00\u59CB\u8F6C\u6362Base64`);\r\n  return await urlToBase64(pollResult.data!);\r\n};\r\n\r\nconst videoRequest = async (\r\n  config: VideoConfig,\r\n  model: VideoModel,\r\n): Promise<string> => {\r\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\r\n  const baseUrl = vendor.inputValues.baseUrl;\r\n  const headers = getHeaders();\r\n\r\n  // \u6784\u9020\u8BF7\u6C42\u53C2\u6570\r\n  const requestBody: any = {\r\n    model: model.modelName,\r\n    prompt: config.prompt,\r\n    aspectRatio: config.aspectRatio,\r\n    webHook: "-1",\r\n    shutProgress: true,\r\n  };\r\n\r\n  // \u5904\u7406\u53C2\u8003\u8D44\u6E90\r\n  if (config.referenceList && config.referenceList.length > 0) {\r\n    const imageRefs = config.referenceList.filter(\r\n      (item) => item.type === "image",\r\n    ) as Extract<ReferenceList, { type: "image" }>[];\r\n    if (config.mode.includes("endFrameOptional") && imageRefs.length >= 1) {\r\n      requestBody.firstFrameUrl = imageRefs[0].base64;\r\n      if (imageRefs.length >= 2) requestBody.lastFrameUrl = imageRefs[1].base64;\r\n    } else if (\r\n      config.mode.some(\r\n        (m) => Array.isArray(m) && m.includes("imageReference:3"),\r\n      )\r\n    ) {\r\n      requestBody.urls = imageRefs.map((img) => img.base64);\r\n    }\r\n  }\r\n\r\n  logger(`\u5F00\u59CB\u63D0\u4EA4\u89C6\u9891\u751F\u6210\u4EFB\u52A1\uFF0C\u6A21\u578B\uFF1A${model.modelName}`);\r\n  const submitResp = await axios.post(`${baseUrl}/v1/video/veo`, requestBody, {\r\n    headers,\r\n  });\r\n  if (submitResp.data.code !== 0)\r\n    throw new Error(`\u4EFB\u52A1\u63D0\u4EA4\u5931\u8D25\uFF1A${submitResp.data.msg}`);\r\n\r\n  const taskId = submitResp.data.data.id;\r\n  logger(`\u89C6\u9891\u4EFB\u52A1\u63D0\u4EA4\u6210\u529F\uFF0C\u4EFB\u52A1ID\uFF1A${taskId}`);\r\n\r\n  // \u8F6E\u8BE2\u7ED3\u679C\r\n  const pollResult = await pollTask(\r\n    async () => {\r\n      const resp = await axios.post(\r\n        `${baseUrl}/v1/draw/result`,\r\n        { id: taskId },\r\n        { headers },\r\n      );\r\n      if (resp.data.code !== 0)\r\n        return { completed: true, error: resp.data.msg };\r\n\r\n      const taskData = resp.data.data;\r\n      if (taskData.status === "failed")\r\n        return {\r\n          completed: true,\r\n          error: taskData.failure_reason || taskData.error,\r\n        };\r\n      if (taskData.status === "succeeded") {\r\n        return { completed: true, data: taskData.url };\r\n      }\r\n      logger(`\u89C6\u9891\u4EFB\u52A1\u751F\u6210\u4E2D\uFF0C\u8FDB\u5EA6\uFF1A${taskData.progress}%`);\r\n      return { completed: false };\r\n    },\r\n    5000,\r\n    1800000,\r\n  );\r\n\r\n  if (pollResult.error) throw new Error(pollResult.error);\r\n  logger(`\u89C6\u9891\u751F\u6210\u5B8C\u6210\uFF0C\u5F00\u59CB\u8F6C\u6362Base64`);\r\n  return await urlToBase64(pollResult.data!);\r\n};\r\n\r\nconst ttsRequest = async (\r\n  config: TTSConfig,\r\n  model: TTSModel,\r\n): Promise<string> => {\r\n  return "";\r\n};\r\n\r\nconst checkForUpdates = async (): Promise<{\r\n  hasUpdate: boolean;\r\n  latestVersion: string;\r\n  notice: string;\r\n}> => {\r\n  return {\r\n    hasUpdate: false,\r\n    latestVersion: "1.0",\r\n    notice: "## \u65B0\u7248\u672C\u66F4\u65B0\u516C\u544A",\r\n  };\r\n};\r\n\r\nconst updateVendor = async (): Promise<string> => {\r\n  return "";\r\n};\r\n\r\n// ============================================================\r\n// \u5BFC\u51FA\r\n// ============================================================\r\n\r\nexports.vendor = vendor;\r\nexports.textRequest = textRequest;\r\nexports.imageRequest = imageRequest;\r\nexports.videoRequest = videoRequest;\r\nexports.ttsRequest = ttsRequest;\r\nexports.checkForUpdates = checkForUpdates;\r\nexports.updateVendor = updateVendor;\r\n\r\n// \u8FD9\u884C\u4EE3\u7801\u7528\u4E8E\u786E\u4FDD\u5F53\u524D\u6587\u4EF6\u88AB\u8BC6\u522B\u4E3A\u6A21\u5757\uFF0C\u907F\u514D\u5168\u5C40\u53D8\u91CF\u51B2\u7A81\r\nexport {};\r\n',
      "klingai.ts": '/**\n * AirFlow AI\u4F9B\u5E94\u5546\u6A21\u677F - \u53EF\u7075AI\n * @version 2.0\n */\n\n// ============================================================\n// \u7C7B\u578B\u5B9A\u4E49\n// ============================================================\n\ntype VideoMode =\n  | "singleImage"\n  | "startEndRequired"\n  | "endFrameOptional"\n  | "startFrameOptional"\n  | "text"\n  | (`videoReference:${number}` | `imageReference:${number}` | `audioReference:${number}`)[];\n\ninterface TextModel {\n  name: string;\n  modelName: string;\n  type: "text";\n  think: boolean;\n}\n\ninterface ImageModel {\n  name: string;\n  modelName: string;\n  type: "image";\n  mode: ("text" | "singleImage" | "multiReference")[];\n  associationSkills?: string;\n}\n\ninterface VideoModel {\n  name: string;\n  modelName: string;\n  type: "video";\n  mode: VideoMode[];\n  associationSkills?: string;\n  audio: "optional" | false | true;\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\n}\n\ninterface TTSModel {\n  name: string;\n  modelName: string;\n  type: "tts";\n  voices: { title: string; voice: string }[];\n}\n\ninterface VendorConfig {\n  id: string;\n  version: string;\n  name: string;\n  author: string;\n  description?: string;\n  icon?: string;\n  inputs: { key: string; label: string; type: "text" | "password" | "url"; required: boolean; placeholder?: string }[];\n  inputValues: Record<string, string>;\n  models: (TextModel | ImageModel | VideoModel | TTSModel)[];\n}\n\ntype ReferenceList =\n  | { type: "image"; sourceType: "base64"; base64: string }\n  | { type: "audio"; sourceType: "base64"; base64: string }\n  | { type: "video"; sourceType: "base64"; base64: string };\n\ninterface ImageConfig {\n  prompt: string;\n  referenceList?: Extract<ReferenceList, { type: "image" }>[];\n  size: "1K" | "2K" | "4K";\n  aspectRatio: `${number}:${number}`;\n}\n\ninterface VideoConfig {\n  duration: number;\n  resolution: string;\n  aspectRatio: "16:9" | "9:16";\n  prompt: string;\n  referenceList?: ReferenceList[];\n  audio?: boolean;\n  mode: VideoMode[];\n}\n\ninterface TTSConfig {\n  text: string;\n  voice: string;\n  speechRate: number;\n  pitchRate: number;\n  volume: number;\n  referenceList?: Extract<ReferenceList, { type: "audio" }>[];\n}\n\ninterface PollResult {\n  completed: boolean;\n  data?: string;\n  error?: string;\n}\n\n// ============================================================\n// \u5168\u5C40\u58F0\u660E\n// ============================================================\n\ndeclare const axios: any;\ndeclare const logger: (msg: string) => void;\ndeclare const jsonwebtoken: any;\ndeclare const zipImage: (base64: string, size: number) => Promise<string>;\ndeclare const zipImageResolution: (base64: string, w: number, h: number) => Promise<string>;\ndeclare const mergeImages: (base64Arr: string[], maxSize?: string) => Promise<string>;\ndeclare const urlToBase64: (url: string) => Promise<string>;\ndeclare const pollTask: (fn: () => Promise<PollResult>, interval?: number, timeout?: number) => Promise<PollResult>;\ndeclare const createOpenAI: any;\ndeclare const createDeepSeek: any;\ndeclare const createZhipu: any;\ndeclare const createQwen: any;\ndeclare const createAnthropic: any;\ndeclare const createOpenAICompatible: any;\ndeclare const createXai: any;\ndeclare const createMinimax: any;\ndeclare const createGoogleGenerativeAI: any;\ndeclare const exports: {\n  vendor: VendorConfig;\n  textRequest: (m: TextModel, t: boolean, tl: 0 | 1 | 2 | 3) => any;\n  imageRequest: (c: ImageConfig, m: ImageModel) => Promise<string>;\n  videoRequest: (c: VideoConfig, m: VideoModel) => Promise<string>;\n  ttsRequest: (c: TTSConfig, m: TTSModel) => Promise<string>;\n  checkForUpdates?: () => Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }>;\n  updateVendor?: () => Promise<string>;\n};\n\n// ============================================================\n// \u4F9B\u5E94\u5546\u914D\u7F6E\n// ============================================================\n\nconst vendor: VendorConfig = {\n  id: "klingai",\n  version: "2.0",\n  author: "AirFlow",\n  name: "\u53EF\u7075AI",\n  description:\n    "\u53EF\u7075AI\u89C6\u9891\u751F\u6210\\n\\n\u652F\u6301\u53EF\u7075\u5168\u7CFB\u5217\u89C6\u9891\u6A21\u578B\uFF0C\u5305\u62EC kling-video-o1\u3001kling-v3-omni\u3001kling-v3\u3001kling-v2-6\u3001kling-v2-5-turbo\u3001kling-v2-1\u3001kling-v2-master\u3001kling-v1-6\u3001kling-v1-5\u3001kling-v1 \u7B49\u3002\\n\\n\u9700\u8981\u5728[\u53EF\u7075AI\u5F00\u653E\u5E73\u53F0](https://klingai.com)\\n\\n\u83B7\u53D6 Access Key \u548C Secret Key\u3002",\n  inputs: [\n    { key: "accessKey", label: "Access Key", type: "password", required: true, placeholder: "\u8BF7\u8F93\u5165\u53EF\u7075AI\u7684Access Key" },\n    { key: "secretKey", label: "Secret Key", type: "password", required: true, placeholder: "\u8BF7\u8F93\u5165\u53EF\u7075AI\u7684Secret Key" },\n    { key: "baseUrl", label: "\u8BF7\u6C42\u5730\u5740", type: "url", required: true, placeholder: "\u9ED8\u8BA4\uFF1Ahttps://api-beijing.klingai.com" },\n  ],\n  inputValues: { accessKey: "", secretKey: "", baseUrl: "https://api-beijing.klingai.com" },\n  models: [\n    // kling-video-o1 (Omni)\n    {\n      name: "kling-video-o1 \u6807\u51C6",\n      modelName: "kling-video-o1:std",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired", ["imageReference:7", "videoReference:1"]],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["720p"] }],\n    },\n    {\n      name: "kling-video-o1 \u4E13\u5BB6",\n      modelName: "kling-video-o1:pro",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired", ["imageReference:7", "videoReference:1"]],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["720p"] }],\n    },\n    // kling-v3-omni (Omni)\n    {\n      name: "kling-v3-omni \u6807\u51C6",\n      modelName: "kling-v3-omni:std",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired", ["imageReference:7", "videoReference:1"]],\n      audio: false,\n      durationResolutionMap: [{ duration: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["720p"] }],\n    },\n    {\n      name: "kling-v3-omni \u4E13\u5BB6",\n      modelName: "kling-v3-omni:pro",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired", ["imageReference:7", "videoReference:1"]],\n      audio: false,\n      durationResolutionMap: [{ duration: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["720p"] }],\n    },\n    // kling-v3\n    {\n      name: "kling-v3 \u6807\u51C6",\n      modelName: "kling-v3:std",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired"],\n      audio: false,\n      durationResolutionMap: [{ duration: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["720p"] }],\n    },\n    {\n      name: "kling-v3 \u4E13\u5BB6",\n      modelName: "kling-v3:pro",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired"],\n      audio: false,\n      durationResolutionMap: [{ duration: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["720p"] }],\n    },\n    // kling-v2-6\n    {\n      name: "kling-v2-6 \u6807\u51C6",\n      modelName: "kling-v2-6:std",\n      type: "video",\n      mode: ["text", "singleImage"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["720p"] }],\n    },\n    {\n      name: "kling-v2-6 \u4E13\u5BB6",\n      modelName: "kling-v2-6:pro",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired"],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["1080p"] }],\n    },\n    // kling-v2-5-turbo\n    {\n      name: "kling-v2-5-turbo \u6807\u51C6",\n      modelName: "kling-v2-5-turbo:std",\n      type: "video",\n      mode: ["text", "singleImage"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["1080p"] }],\n    },\n    {\n      name: "kling-v2-5-turbo \u4E13\u5BB6",\n      modelName: "kling-v2-5-turbo:pro",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["1080p"] }],\n    },\n    // kling-v2-1\n    {\n      name: "kling-v2-1 \u6807\u51C6",\n      modelName: "kling-v2-1:std",\n      type: "video",\n      mode: ["singleImage"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["720p"] }],\n    },\n    {\n      name: "kling-v2-1 \u4E13\u5BB6",\n      modelName: "kling-v2-1:pro",\n      type: "video",\n      mode: ["singleImage", "startEndRequired"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["1080p"] }],\n    },\n    // kling-v2-1-master\n    {\n      name: "kling-v2-1 Master",\n      modelName: "kling-v2-1-master:pro",\n      type: "video",\n      mode: ["text", "singleImage"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["1080p"] }],\n    },\n    // kling-v2-master\n    {\n      name: "kling-v2 Master",\n      modelName: "kling-v2-master:pro",\n      type: "video",\n      mode: ["text", "singleImage"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["720p"] }],\n    },\n    // kling-v1-6\n    {\n      name: "kling-v1-6 \u6807\u51C6",\n      modelName: "kling-v1-6:std",\n      type: "video",\n      mode: ["text", "singleImage", ["imageReference:4"]],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["720p"] }],\n    },\n    {\n      name: "kling-v1-6 \u4E13\u5BB6",\n      modelName: "kling-v1-6:pro",\n      type: "video",\n      mode: ["text", "singleImage", "endFrameOptional", ["imageReference:4"]],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["1080p"] }],\n    },\n    // kling-v1-5\n    {\n      name: "kling-v1-5 \u6807\u51C6",\n      modelName: "kling-v1-5:std",\n      type: "video",\n      mode: ["singleImage"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["720p"] }],\n    },\n    {\n      name: "kling-v1-5 \u4E13\u5BB6",\n      modelName: "kling-v1-5:pro",\n      type: "video",\n      mode: ["singleImage", "endFrameOptional"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["1080p"] }],\n    },\n    // kling-v1\n    {\n      name: "kling-v1 \u6807\u51C6",\n      modelName: "kling-v1:std",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["720p"] }],\n    },\n    {\n      name: "kling-v1 \u4E13\u5BB6",\n      modelName: "kling-v1:pro",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired"],\n      audio: false,\n      durationResolutionMap: [{ duration: [5, 10], resolution: ["720p"] }],\n    },\n  ],\n};\n\n// ============================================================\n// \u8F85\u52A9\u5DE5\u5177\n// ============================================================\n\n/**\n * \u751F\u6210\u53EF\u7075AI\u7684JWT\u9274\u6743Token\n */\nconst generateAuthToken = (): string => {\n  const now = Math.floor(Date.now() / 1000);\n  const payload = {\n    iss: vendor.inputValues.accessKey,\n    exp: now + 1800,\n    nbf: now - 5,\n  };\n  return jsonwebtoken.sign(payload, vendor.inputValues.secretKey, {\n    algorithm: "HS256",\n    header: { alg: "HS256", typ: "JWT" },\n  });\n};\n\n/**\n * \u83B7\u53D6\u57FA\u7840\u8BF7\u6C42\u5730\u5740\n */\nconst getBaseUrl = (): string => {\n  return vendor.inputValues.baseUrl || "https://api-beijing.klingai.com";\n};\n\n/**\n * \u4ECE ReferenceList \u6761\u76EE\u4E2D\u63D0\u53D6\u53EF\u7528\u7684\u6570\u636E\u5B57\u7B26\u4E32\n * \u5BF9\u4E8E url \u7C7B\u578B\u8FD4\u56DE url\uFF0C\u5BF9\u4E8E base64 \u7C7B\u578B\u8FD4\u56DE\u7EAF base64\uFF08\u53BB\u6389 data: \u524D\u7F00\uFF09\n */\nconst extractRawBase64 = (ref: ReferenceList): string => {\n  return ref.base64.replace(/^data:[^;]+;base64,/, "");\n};\n\n/**\n * \u4ECE ReferenceList \u6761\u76EE\u4E2D\u63D0\u53D6\u5E26\u5934\u7684 base64 \u6216 url\n * \u7528\u4E8E omni-video \u63A5\u53E3\uFF0C\u8BE5\u63A5\u53E3\u7684 image_url \u652F\u6301\u5E26\u524D\u7F00\u7684 base64 \u548C url\n */\nconst extractImageUrl = (ref: ReferenceList): string => {\n  return ref.base64.startsWith("data:") ? ref.base64 : `data:image/jpeg;base64,${ref.base64}`;\n};\n\n/**\n * \u63D0\u4EA4\u4EFB\u52A1\u5E76\u8F6E\u8BE2\u83B7\u53D6\u7ED3\u679C\u7684\u901A\u7528\u51FD\u6570\n */\nconst submitAndPoll = async (submitUrl: string, queryUrlBase: string, requestBody: any): Promise<string> => {\n  const token = generateAuthToken();\n\n  logger(`\u5F00\u59CB\u63D0\u4EA4\u53EF\u7075AI\u89C6\u9891\u751F\u6210\u4EFB\u52A1: ${submitUrl}`);\n  logger(\n    `\u8BF7\u6C42\u53C2\u6570: ${JSON.stringify({\n      ...requestBody,\n      image: requestBody.image ? "[BASE64]" : undefined,\n      image_tail: requestBody.image_tail ? "[BASE64]" : undefined,\n      image_list: requestBody.image_list ? "[IMAGES]" : undefined,\n    })}`,\n  );\n\n  const submitResp = await axios.post(submitUrl, requestBody, {\n    headers: {\n      "Content-Type": "application/json",\n      Authorization: `Bearer ${token}`,\n    },\n  });\n\n  if (submitResp.data.code !== 0) {\n    throw new Error(`\u63D0\u4EA4\u4EFB\u52A1\u5931\u8D25: ${submitResp.data.message || JSON.stringify(submitResp.data)}`);\n  }\n\n  const taskId = submitResp.data.data.task_id;\n  logger(`\u4EFB\u52A1\u5DF2\u63D0\u4EA4\uFF0C\u4EFB\u52A1ID: ${taskId}`);\n\n  const result = await pollTask(\n    async () => {\n      const freshToken = generateAuthToken();\n      const queryResp = await axios.get(`${queryUrlBase}/${taskId}`, {\n        headers: {\n          Authorization: `Bearer ${freshToken}`,\n        },\n      });\n\n      if (queryResp.data.code !== 0) {\n        return { completed: true, error: `\u67E5\u8BE2\u4EFB\u52A1\u5931\u8D25: ${queryResp.data.message}` };\n      }\n\n      const taskData = queryResp.data.data;\n      const status = taskData.task_status;\n      logger(`\u8F6E\u8BE2\u4E2D... \u4EFB\u52A1\u72B6\u6001: ${status}`);\n\n      if (status === "succeed") {\n        const videoUrl = taskData.task_result?.videos?.[0]?.url;\n        if (!videoUrl) {\n          return { completed: true, error: "\u4EFB\u52A1\u5B8C\u6210\u4F46\u672A\u83B7\u53D6\u5230\u89C6\u9891URL" };\n        }\n        return { completed: true, data: videoUrl };\n      }\n\n      if (status === "failed") {\n        return { completed: true, error: `\u89C6\u9891\u751F\u6210\u5931\u8D25: ${taskData.task_status_msg || "\u672A\u77E5\u9519\u8BEF"}` };\n      }\n\n      return { completed: false };\n    },\n    5000,\n    600000,\n  );\n\n  if (result.error) throw new Error(result.error);\n  logger(`\u89C6\u9891\u751F\u6210\u5B8C\u6210\uFF0C\u6B63\u5728\u8F6C\u6362\u4E3ABase64...`);\n  return await urlToBase64(result.data!);\n};\n\n// ============================================================\n// \u9002\u914D\u5668\u51FD\u6570\n// ============================================================\n\nconst textRequest = (model: TextModel, think: boolean, thinkLevel: 0 | 1 | 2 | 3) => {\n  throw new Error("\u53EF\u7075AI\u4E0D\u652F\u6301\u6587\u672C\u6A21\u578B");\n};\n\nconst imageRequest = async (config: ImageConfig, model: ImageModel): Promise<string> => {\n  throw new Error("\u53EF\u7075AI\u4E0D\u652F\u6301\u56FE\u7247\u6A21\u578B");\n};\n\nconst videoRequest = async (config: VideoConfig, model: VideoModel): Promise<string> => {\n  if (!vendor.inputValues.accessKey) throw new Error("\u7F3A\u5C11Access Key");\n  if (!vendor.inputValues.secretKey) throw new Error("\u7F3A\u5C11Secret Key");\n\n  const baseUrl = getBaseUrl();\n\n  // \u89E3\u6790 modelName\uFF0C\u683C\u5F0F\uFF1Akling-video-o1:pro => modelName=kling-video-o1, mode=pro\n  const colonIdx = model.modelName.indexOf(":");\n  const modelName = colonIdx > -1 ? model.modelName.substring(0, colonIdx) : model.modelName;\n  const mode = colonIdx > -1 ? model.modelName.substring(colonIdx + 1) : "pro";\n\n  // \u5224\u65AD\u662F\u5426\u4E3A Omni \u6A21\u578B\n  const isOmniModel = modelName === "kling-video-o1" || modelName === "kling-v3-omni";\n\n  // \u5224\u65AD\u5F53\u524D\u9009\u4E2D\u7684\u89C6\u9891\u751F\u6210\u6A21\u5F0F\n  const currentMode = config.mode;\n  const isText = currentMode.includes("text");\n  const isSingleImage = currentMode.includes("singleImage");\n  const isStartEndRequired = currentMode.includes("startEndRequired");\n  const isEndFrameOptional = currentMode.includes("endFrameOptional");\n  const isStartFrameOptional = currentMode.includes("startFrameOptional");\n  const hasMultiRef = Array.isArray(currentMode) && currentMode.some((m) => Array.isArray(m));\n\n  // \u63D0\u53D6\u4E0D\u540C\u7C7B\u578B\u7684\u5F15\u7528\n  const imageRefs = (config.referenceList || []).filter((r) => r.type === "image");\n  const videoRefs = (config.referenceList || []).filter((r) => r.type === "video");\n\n  // =====================================================\n  // Omni \u6A21\u578B \u2014\u2014 \u4F7F\u7528 /v1/videos/omni-video \u63A5\u53E3\n  // =====================================================\n  if (isOmniModel) {\n    const requestBody: any = {\n      model_name: modelName,\n      mode: mode,\n      duration: String(config.duration),\n      sound: config.audio === true ? "on" : "off",\n    };\n\n    if (config.prompt) {\n      requestBody.prompt = config.prompt;\n    }\n\n    if (isSingleImage && imageRefs.length > 0) {\n      const imageUrl = extractImageUrl(imageRefs[0]);\n      requestBody.image_list = [{ image_url: imageUrl, type: "first_frame" }];\n      if (!requestBody.prompt) requestBody.prompt = "\u6839\u636E\u56FE\u7247\u751F\u6210\u89C6\u9891";\n    } else if (isStartEndRequired && imageRefs.length >= 2) {\n      const firstUrl = extractImageUrl(imageRefs[0]);\n      const endUrl = extractImageUrl(imageRefs[1]);\n      requestBody.image_list = [\n        { image_url: firstUrl, type: "first_frame" },\n        { image_url: endUrl, type: "end_frame" },\n      ];\n      if (!requestBody.prompt) requestBody.prompt = "\u6839\u636E\u9996\u5C3E\u5E27\u56FE\u7247\u751F\u6210\u8FC7\u6E21\u89C6\u9891";\n    } else if (isEndFrameOptional && imageRefs.length >= 1) {\n      const firstUrl = extractImageUrl(imageRefs[0]);\n      requestBody.image_list = [{ image_url: firstUrl, type: "first_frame" }];\n      if (imageRefs.length >= 2) {\n        const endUrl = extractImageUrl(imageRefs[1]);\n        requestBody.image_list.push({ image_url: endUrl, type: "end_frame" });\n      }\n      if (!requestBody.prompt) requestBody.prompt = "\u6839\u636E\u56FE\u7247\u751F\u6210\u89C6\u9891";\n    } else if (isStartFrameOptional && imageRefs.length >= 1) {\n      if (imageRefs.length >= 2) {\n        const firstUrl = extractImageUrl(imageRefs[0]);\n        const endUrl = extractImageUrl(imageRefs[1]);\n        requestBody.image_list = [\n          { image_url: firstUrl, type: "first_frame" },\n          { image_url: endUrl, type: "end_frame" },\n        ];\n      } else {\n        const endUrl = extractImageUrl(imageRefs[0]);\n        requestBody.image_list = [{ image_url: endUrl, type: "end_frame" }];\n      }\n      if (!requestBody.prompt) requestBody.prompt = "\u6839\u636E\u56FE\u7247\u751F\u6210\u89C6\u9891";\n    } else if (hasMultiRef && (imageRefs.length > 0 || videoRefs.length > 0)) {\n      requestBody.image_list = [];\n      for (let i = 0; i < imageRefs.length; i++) {\n        const imageUrl = extractImageUrl(imageRefs[i]);\n        requestBody.image_list.push({ image_url: imageUrl });\n      }\n      if (!requestBody.prompt) {\n        const refs = imageRefs.map((_, idx) => `<<<image_${idx + 1}>>>`).join("\u3001");\n        requestBody.prompt = `\u53C2\u8003${refs}\u751F\u6210\u89C6\u9891`;\n      }\n    }\n\n    // \u6587\u751F\u89C6\u9891\u6216\u65E0\u56FE\u7247\u8F93\u5165\u65F6\u9700\u8981\u8BBE\u7F6E\u5BBD\u9AD8\u6BD4\n    const hasImageInput = requestBody.image_list && requestBody.image_list.length > 0;\n    if (!hasImageInput) {\n      requestBody.aspect_ratio = config.aspectRatio || "16:9";\n      if (!requestBody.prompt) throw new Error("\u6587\u751F\u89C6\u9891\u6A21\u5F0F\u9700\u8981\u63D0\u4F9B\u63D0\u793A\u8BCD");\n    }\n\n    const apiPath = "/v1/videos/omni-video";\n    return await submitAndPoll(`${baseUrl}${apiPath}`, `${baseUrl}${apiPath}`, requestBody);\n  }\n\n  // =====================================================\n  // \u975E Omni \u6A21\u578B \u2014\u2014 \u6839\u636E\u6A21\u5F0F\u9009\u62E9\u4E0D\u540C\u63A5\u53E3\n  // =====================================================\n\n  // \u591A\u56FE\u53C2\u8003\u6A21\u5F0F \u2014\u2014 \u4F7F\u7528 /v1/videos/multi-image2video \u63A5\u53E3\uFF08\u4EC5 kling-v1-6 \u652F\u6301\uFF09\n  if (hasMultiRef && imageRefs.length > 0) {\n    const imageList = [];\n    for (let i = 0; i < imageRefs.length; i++) {\n      const rawBase64 = extractRawBase64(imageRefs[i]);\n      imageList.push({ image: rawBase64 });\n    }\n\n    const requestBody: any = {\n      model_name: modelName,\n      image_list: imageList,\n      prompt: config.prompt || "\u6839\u636E\u53C2\u8003\u56FE\u7247\u751F\u6210\u89C6\u9891",\n      mode: mode,\n      duration: String(config.duration),\n      aspect_ratio: config.aspectRatio || "16:9",\n    };\n\n    const apiPath = "/v1/videos/multi-image2video";\n    return await submitAndPoll(`${baseUrl}${apiPath}`, `${baseUrl}${apiPath}`, requestBody);\n  }\n\n  // \u6587\u751F\u89C6\u9891\u6A21\u5F0F \u2014\u2014 \u4F7F\u7528 /v1/videos/text2video \u63A5\u53E3\n  if (isText) {\n    if (!config.prompt) throw new Error("\u6587\u751F\u89C6\u9891\u6A21\u5F0F\u9700\u8981\u63D0\u4F9B\u63D0\u793A\u8BCD");\n\n    const requestBody: any = {\n      model_name: modelName,\n      prompt: config.prompt,\n      mode: mode,\n      duration: String(config.duration),\n      aspect_ratio: config.aspectRatio || "16:9",\n      sound: config.audio === true ? "on" : "off",\n    };\n\n    const apiPath = "/v1/videos/text2video";\n    return await submitAndPoll(`${baseUrl}${apiPath}`, `${baseUrl}${apiPath}`, requestBody);\n  }\n\n  // \u56FE\u751F\u89C6\u9891\u6A21\u5F0F\uFF08\u5355\u56FE / \u9996\u5C3E\u5E27 / \u5C3E\u5E27\u53EF\u9009\u7B49\uFF09\u2014\u2014 \u4F7F\u7528 /v1/videos/image2video \u63A5\u53E3\n  if ((isSingleImage || isStartEndRequired || isEndFrameOptional || isStartFrameOptional) && imageRefs.length > 0) {\n    const requestBody: any = {\n      model_name: modelName,\n      prompt: config.prompt || "\u6839\u636E\u56FE\u7247\u751F\u6210\u89C6\u9891",\n      mode: mode,\n      duration: String(config.duration),\n      sound: config.audio === true ? "on" : "off",\n    };\n\n    if (isSingleImage) {\n      requestBody.image = extractRawBase64(imageRefs[0]);\n    } else if (isStartEndRequired && imageRefs.length >= 2) {\n      requestBody.image = extractRawBase64(imageRefs[0]);\n      requestBody.image_tail = extractRawBase64(imageRefs[1]);\n    } else if (isEndFrameOptional) {\n      requestBody.image = extractRawBase64(imageRefs[0]);\n      if (imageRefs.length >= 2) {\n        requestBody.image_tail = extractRawBase64(imageRefs[1]);\n      }\n    } else if (isStartFrameOptional) {\n      if (imageRefs.length >= 2) {\n        requestBody.image = extractRawBase64(imageRefs[0]);\n        requestBody.image_tail = extractRawBase64(imageRefs[1]);\n      } else {\n        requestBody.image = extractRawBase64(imageRefs[0]);\n      }\n    }\n\n    const apiPath = "/v1/videos/image2video";\n    return await submitAndPoll(`${baseUrl}${apiPath}`, `${baseUrl}${apiPath}`, requestBody);\n  }\n\n  throw new Error("\u4E0D\u652F\u6301\u7684\u89C6\u9891\u751F\u6210\u6A21\u5F0F\u6216\u7F3A\u5C11\u5FC5\u8981\u7684\u8F93\u5165\u53C2\u6570");\n};\n\nconst ttsRequest = async (config: TTSConfig, model: TTSModel): Promise<string> => {\n  return "";\n};\n\n// ============================================================\n// \u5BFC\u51FA\n// ============================================================\n\nexports.vendor = vendor;\nexports.textRequest = textRequest;\nexports.imageRequest = imageRequest;\nexports.videoRequest = videoRequest;\nexports.ttsRequest = ttsRequest;\n\n// \u8FD9\u884C\u4EE3\u7801\u7528\u4E8E\u786E\u4FDD\u5F53\u524D\u6587\u4EF6\u88AB\u8BC6\u522B\u4E3A\u6A21\u5757\uFF0C\u907F\u514D\u5168\u5C40\u53D8\u91CF\u51B2\u7A81\nexport {};\n',
      "minimax.ts": '/**\n * AirFlow AI\u4F9B\u5E94\u5546\u6A21\u677F - MiniMax(\u6D77\u87BAAI)\n * @version 2.0\n */\n\n// ============================================================\n// \u7C7B\u578B\u5B9A\u4E49\n// ============================================================\n\ntype VideoMode =\n  | "singleImage"\n  | "startEndRequired"\n  | "endFrameOptional"\n  | "startFrameOptional"\n  | "text"\n  | (`videoReference:${number}` | `imageReference:${number}` | `audioReference:${number}`)[];\n\ninterface TextModel {\n  name: string;\n  modelName: string;\n  type: "text";\n  think: boolean;\n}\n\ninterface ImageModel {\n  name: string;\n  modelName: string;\n  type: "image";\n  mode: ("text" | "singleImage" | "multiReference")[];\n  associationSkills?: string;\n}\n\ninterface VideoModel {\n  name: string;\n  modelName: string;\n  type: "video";\n  mode: VideoMode[];\n  associationSkills?: string;\n  audio: "optional" | false | true;\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\n}\n\ninterface TTSModel {\n  name: string;\n  modelName: string;\n  type: "tts";\n  voices: { title: string; voice: string }[];\n}\n\ninterface VendorConfig {\n  id: string;\n  version: string;\n  name: string;\n  author: string;\n  description?: string;\n  icon?: string;\n  inputs: { key: string; label: string; type: "text" | "password" | "url"; required: boolean; placeholder?: string }[];\n  inputValues: Record<string, string>;\n  models: (TextModel | ImageModel | VideoModel | TTSModel)[];\n}\n\ntype ReferenceList =\n  | { type: "image"; sourceType: "base64"; base64: string }\n  | { type: "audio"; sourceType: "base64"; base64: string }\n  | { type: "video"; sourceType: "base64"; base64: string };\n\ninterface ImageConfig {\n  prompt: string;\n  referenceList?: Extract<ReferenceList, { type: "image" }>[];\n  size: "1K" | "2K" | "4K";\n  aspectRatio: `${number}:${number}`;\n}\n\ninterface VideoConfig {\n  duration: number;\n  resolution: string;\n  aspectRatio: "16:9" | "9:16";\n  prompt: string;\n  referenceList?: ReferenceList[];\n  audio?: boolean;\n  mode: VideoMode[];\n}\n\ninterface TTSConfig {\n  text: string;\n  voice: string;\n  speechRate: number;\n  pitchRate: number;\n  volume: number;\n  referenceList?: Extract<ReferenceList, { type: "audio" }>[];\n}\n\ninterface PollResult {\n  completed: boolean;\n  data?: string;\n  error?: string;\n}\n\n// ============================================================\n// \u5168\u5C40\u58F0\u660E\n// ============================================================\n\ndeclare const axios: any;\ndeclare const logger: (msg: string) => void;\ndeclare const jsonwebtoken: any;\ndeclare const zipImage: (base64: string, size: number) => Promise<string>;\ndeclare const zipImageResolution: (base64: string, w: number, h: number) => Promise<string>;\ndeclare const mergeImages: (base64Arr: string[], maxSize?: string) => Promise<string>;\ndeclare const urlToBase64: (url: string) => Promise<string>;\ndeclare const pollTask: (fn: () => Promise<PollResult>, interval?: number, timeout?: number) => Promise<PollResult>;\ndeclare const createOpenAI: any;\ndeclare const createDeepSeek: any;\ndeclare const createZhipu: any;\ndeclare const createQwen: any;\ndeclare const createAnthropic: any;\ndeclare const createOpenAICompatible: any;\ndeclare const createXai: any;\ndeclare const createMinimax: any;\ndeclare const createGoogleGenerativeAI: any;\ndeclare const exports: {\n  vendor: VendorConfig;\n  textRequest: (m: TextModel, t: boolean, tl: 0 | 1 | 2 | 3) => any;\n  uploadReference: (base64: string, fileType: "image" | "audio" | "video") => Promise<ReferenceList>;\n  imageRequest: (c: ImageConfig, m: ImageModel) => Promise<string>;\n  videoRequest: (c: VideoConfig, m: VideoModel) => Promise<string>;\n  ttsRequest: (c: TTSConfig, m: TTSModel) => Promise<string>;\n  checkForUpdates?: () => Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }>;\n  updateVendor?: () => Promise<string>;\n};\n\n// ============================================================\n// \u4F9B\u5E94\u5546\u914D\u7F6E\n// ============================================================\n\nconst vendor: VendorConfig = {\n  id: "minimax",\n  version: "2.1",\n  author: "AirFlow",\n  name: "MiniMax(\u6D77\u87BAAI)",\n  description: "MiniMax\u5B98\u65B9\u63A5\u53E3\u9002\u914D\uFF0C\u652F\u6301M\u7CFB\u5217\u63A8\u7406\u6587\u672C\u6A21\u578B\u3001\u6587\u751F\u56FE/\u56FE\u751F\u56FE\u3001\u89C6\u9891\u751F\u6210\uFF08\u6587\u751F\u89C6\u9891\u3001\u56FE\u751F\u89C6\u9891\u3001\u9996\u5C3E\u5E27\u751F\u6210\uFF09\u80FD\u529B \\n [\u524D\u5F80\u5E73\u53F0](https://minimaxi.com/)",\n  inputs: [\n    { key: "apiKey", label: "API\u5BC6\u94A5", type: "password", required: true },\n    { key: "baseUrl", label: "\u8BF7\u6C42\u5730\u5740", type: "url", required: true, placeholder: "\u793A\u4F8B\uFF1Ahttps://api.minimaxi.com" },\n  ],\n  inputValues: { apiKey: "", baseUrl: "https://api.minimaxi.com" },\n  models: [\n    // \u6587\u672C\u6A21\u578B\n    { name: "MiniMax-M2.7 (\u63A8\u7406\u7248)", modelName: "MiniMax-M2.7", type: "text", think: true },\n    { name: "MiniMax-M2.7 \u6781\u901F\u7248 (\u63A8\u7406\u7248)", modelName: "MiniMax-M2.7-highspeed", type: "text", think: true },\n    { name: "MiniMax-M2.5 (\u63A8\u7406\u7248)", modelName: "MiniMax-M2.5", type: "text", think: true },\n    { name: "MiniMax-M2.5 \u6781\u901F\u7248 (\u63A8\u7406\u7248)", modelName: "MiniMax-M2.5-highspeed", type: "text", think: true },\n    { name: "MiniMax-M2.1 (\u7F16\u7A0B\u7248)", modelName: "MiniMax-M2.1", type: "text", think: true },\n    { name: "MiniMax-M2.1 \u6781\u901F\u7248 (\u7F16\u7A0B\u7248)", modelName: "MiniMax-M2.1-highspeed", type: "text", think: true },\n    { name: "MiniMax-M2 (Agent\u7248)", modelName: "MiniMax-M2", type: "text", think: false },\n    // \u56FE\u7247\u6A21\u578B\n    { name: "\u6D77\u87BA\u56FE\u50CFV1", modelName: "image-01", type: "image", mode: ["text", "singleImage"] },\n    { name: "\u6D77\u87BA\u56FE\u50CFV1 Live\u7248", modelName: "image-01-live", type: "image", mode: ["text", "singleImage"], associationSkills: "\u652F\u6301\u81EA\u5B9A\u4E49\u753B\u98CE" },\n    // \u89C6\u9891\u6A21\u578B\n    {\n      name: "\u6D77\u87BA2.3",\n      modelName: "MiniMax-Hailuo-2.3",\n      type: "video",\n      mode: ["text", "singleImage"],\n      audio: false,\n      durationResolutionMap: [\n        { duration: [6], resolution: ["768P", "1080P"] },\n        { duration: [10], resolution: ["768P"] },\n      ],\n    },\n    {\n      name: "\u6D77\u87BA2.3\u6781\u901F\u7248",\n      modelName: "MiniMax-Hailuo-2.3-Fast",\n      type: "video",\n      mode: ["text", "singleImage"],\n      audio: false,\n      durationResolutionMap: [\n        { duration: [6], resolution: ["768P", "1080P"] },\n        { duration: [10], resolution: ["768P"] },\n      ],\n    },\n    {\n      name: "\u6D77\u87BA02",\n      modelName: "MiniMax-Hailuo-02",\n      type: "video",\n      mode: ["text", "singleImage", "startEndRequired"],\n      audio: false,\n      durationResolutionMap: [\n        { duration: [6], resolution: ["512P", "768P", "1080P"] },\n        { duration: [10], resolution: ["512P", "768P"] },\n      ],\n    },\n  ],\n};\n\n// ============================================================\n// \u8F85\u52A9\u5DE5\u5177\n// ============================================================\n\n/**\n * \u83B7\u53D6\u8BF7\u6C42\u5934\n */\nconst getHeaders = (): Record<string, string> => {\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\n  return {\n    Authorization: `Bearer ${apiKey}`,\n    "Content-Type": "application/json",\n  };\n};\n\n/**\n * \u83B7\u53D6\u57FA\u7840\u8BF7\u6C42\u5730\u5740\n */\nconst getBaseUrl = (): string => {\n  return vendor.inputValues.baseUrl.replace(/\\/$/, "");\n};\n\n/**\n * \u4ECE ReferenceList \u6761\u76EE\u4E2D\u63D0\u53D6\u6709\u5934 base64 \u5B57\u7B26\u4E32\n */\nconst extractBase64WithHead = (ref: ReferenceList): string => {\n  return ref.base64.startsWith("data:") ? ref.base64 : `data:image/png;base64,${ref.base64}`;\n};\n\n// ============================================================\n// \u9002\u914D\u5668\u51FD\u6570\n// ============================================================\n\nconst textRequest = (model: TextModel, think: boolean, thinkLevel: 0 | 1 | 2 | 3) => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\n  const baseUrl = getBaseUrl();\n\n  const openaiBaseUrl = `${baseUrl}/v1`;\n  const extraBody = model.think ? { reasoning_split: true } : {};\n  return createOpenAI({ baseURL: openaiBaseUrl, apiKey, extraBody }).chat(model.modelName);\n};\n\nconst uploadReference = async (base64: string, fileType: "image" | "audio" | "video"): Promise<ReferenceList> => {\n  // MiniMax\u7684\u56FE\u7247\u63A5\u53E3\u76F4\u63A5\u63A5\u53D7 base64\uFF0C\u538B\u7F29\u540E\u539F\u6837\u8FD4\u56DE\n  if (fileType === "image") {\n    const compressed = await zipImage(base64, 10 * 1024);\n    return { type: "image", sourceType: "base64", base64: compressed };\n  }\n  // \u89C6\u9891\u63A5\u53E3\u7684\u56FE\u7247\u53C2\u6570\u4E5F\u662F base64\uFF0C\u538B\u7F29\u523020MB\n  return { type: fileType, sourceType: "base64", base64 } as ReferenceList;\n};\n\nconst imageRequest = async (config: ImageConfig, model: ImageModel): Promise<string> => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const baseUrl = getBaseUrl();\n  const headers = getHeaders();\n\n  const reqBody: any = {\n    model: model.modelName,\n    prompt: config.prompt,\n    aspect_ratio: config.aspectRatio,\n    response_format: "base64",\n    n: 1,\n    prompt_optimizer: true,\n    aigc_watermark: false,\n  };\n\n  // \u5904\u7406\u56FE\u751F\u56FE\u53C2\u8003\n  const imageRefs = config.referenceList || [];\n  if (imageRefs.length > 0) {\n    const refBase64 = extractBase64WithHead(imageRefs[0]);\n    reqBody.subject_reference = [{ type: "character", image_file: refBase64 }];\n  }\n\n  logger("\u5F00\u59CB\u63D0\u4EA4MiniMax\u56FE\u50CF\u751F\u6210\u4EFB\u52A1");\n  const resp = await axios.post(`${baseUrl}/v1/image_generation`, reqBody, { headers });\n  if (resp.data.base_resp.status_code !== 0) {\n    throw new Error(`\u56FE\u50CF\u751F\u6210\u5931\u8D25\uFF1A${resp.data.base_resp.status_msg}`);\n  }\n  if (resp.data.metadata.success_count === 0) {\n    throw new Error("\u56FE\u50CF\u751F\u6210\u88AB\u5B89\u5168\u7B56\u7565\u62E6\u622A\uFF0C\u8BF7\u8C03\u6574prompt\u6216\u53C2\u8003\u56FE");\n  }\n\n  const imgBase64 = resp.data.data.image_base64[0];\n  return imgBase64.startsWith("data:") ? imgBase64 : `data:image/png;base64,${imgBase64}`;\n};\n\nconst videoRequest = async (config: VideoConfig, model: VideoModel): Promise<string> => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const baseUrl = getBaseUrl();\n  const headers = getHeaders();\n\n  const reqBody: any = {\n    model: model.modelName,\n    prompt: config.prompt,\n    duration: config.duration,\n    resolution: config.resolution,\n    aigc_watermark: false,\n    prompt_optimizer: true,\n  };\n\n  // \u63D0\u53D6\u56FE\u7247\u7C7B\u578B\u7684\u5F15\u7528\n  const imageRefs = (config.referenceList || []).filter((r) => r.type === "image");\n\n  if (imageRefs.length > 0) {\n    // \u538B\u7F29\u56FE\u7247\u523020MB\u4EE5\u5185\n    const compressedImages: string[] = [];\n    for (const ref of imageRefs) {\n      const base64 = extractBase64WithHead(ref);\n      const compressed = await zipImage(base64, 20 * 1024);\n      compressedImages.push(compressed);\n    }\n\n    if (config.mode.includes("startEndRequired")) {\n      if (compressedImages.length < 2) throw new Error("\u9996\u5C3E\u5E27\u6A21\u5F0F\u9700\u8981\u4E0A\u4F20\u4E24\u5F20\u56FE\u7247");\n      reqBody.first_frame_image = compressedImages[0];\n      reqBody.last_frame_image = compressedImages[1];\n    } else if (config.mode.includes("singleImage")) {\n      reqBody.first_frame_image = compressedImages[0];\n    }\n  }\n\n  logger("\u5F00\u59CB\u63D0\u4EA4MiniMax\u89C6\u9891\u751F\u6210\u4EFB\u52A1");\n  const submitResp = await axios.post(`${baseUrl}/v1/video_generation`, reqBody, { headers });\n  if (submitResp.data.base_resp.status_code !== 0) {\n    throw new Error(`\u4EFB\u52A1\u63D0\u4EA4\u5931\u8D25\uFF1A${submitResp.data.base_resp.status_msg}`);\n  }\n  const taskId = submitResp.data.task_id;\n  logger(`\u89C6\u9891\u4EFB\u52A1\u63D0\u4EA4\u6210\u529F\uFF0C\u4EFB\u52A1ID: ${taskId}`);\n\n  // \u8F6E\u8BE2\u4EFB\u52A1\u72B6\u6001\n  const pollResult = await pollTask(\n    async () => {\n      const queryResp = await axios.get(`${baseUrl}/v1/query/video_generation`, {\n        headers: getHeaders(),\n        params: { task_id: taskId },\n      });\n      if (queryResp.data.base_resp.status_code !== 0) {\n        return { completed: true, error: queryResp.data.base_resp.status_msg };\n      }\n      const status = queryResp.data.status;\n      if (status === "Success") {\n        return { completed: true, data: queryResp.data.file_id };\n      }\n      if (status === "Fail") {\n        return { completed: true, error: "\u89C6\u9891\u751F\u6210\u5931\u8D25" };\n      }\n      logger(`\u89C6\u9891\u4EFB\u52A1\u751F\u6210\u4E2D\uFF0C\u5F53\u524D\u72B6\u6001\uFF1A${status}`);\n      return { completed: false };\n    },\n    5000,\n    600000,\n  );\n\n  if (pollResult.error) throw new Error(pollResult.error);\n  const fileId = pollResult.data!;\n  logger(`\u89C6\u9891\u4EFB\u52A1\u751F\u6210\u6210\u529F\uFF0C\u6587\u4EF6ID: ${fileId}`);\n\n  // \u83B7\u53D6\u4E0B\u8F7D\u5730\u5740\n  const fileResp = await axios.get(`${baseUrl}/v1/files/retrieve`, {\n    headers: getHeaders(),\n    params: { file_id: fileId },\n  });\n  if (fileResp.data.base_resp.status_code !== 0) {\n    throw new Error(`\u83B7\u53D6\u6587\u4EF6\u5730\u5740\u5931\u8D25\uFF1A${fileResp.data.base_resp.status_msg}`);\n  }\n  const downloadUrl = fileResp.data.file.download_url;\n  logger(`\u89C6\u9891\u4E0B\u8F7D\u5730\u5740\u83B7\u53D6\u6210\u529F\uFF0C\u5F00\u59CB\u8F6CBase64`);\n\n  return await urlToBase64(downloadUrl);\n};\n\nconst ttsRequest = async (config: TTSConfig, model: TTSModel): Promise<string> => {\n  return "";\n};\n\nconst checkForUpdates = async (): Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }> => {\n  return {\n    hasUpdate: false,\n    latestVersion: "2.0",\n    notice:\n      "## \u65B0\u7248\u672C\u66F4\u65B0\u516C\u544A\\n1. \u9002\u914D\u65B0\u7248\u6A21\u677F\u67B6\u6784\uFF0C\u652F\u6301 ReferenceList \u7EDF\u4E00\u5F15\u7528\u7C7B\u578B\\n2. \u65B0\u589E uploadReference \u524D\u7F6E\u5904\u7406\u5668\\n3. \u4F18\u5316\u56FE\u7247\u538B\u7F29\u548C\u5F15\u7528\u63D0\u53D6\u903B\u8F91",\n  };\n};\n\nconst updateVendor = async (): Promise<string> => {\n  return "";\n};\n\n// ============================================================\n// \u5BFC\u51FA\n// ============================================================\n\nexports.vendor = vendor;\nexports.textRequest = textRequest;\nexports.uploadReference = uploadReference;\nexports.imageRequest = imageRequest;\nexports.videoRequest = videoRequest;\nexports.ttsRequest = ttsRequest;\nexports.checkForUpdates = checkForUpdates;\nexports.updateVendor = updateVendor;\n\n// \u8FD9\u884C\u4EE3\u7801\u7528\u4E8E\u786E\u4FDD\u5F53\u524D\u6587\u4EF6\u88AB\u8BC6\u522B\u4E3A\u6A21\u5757\uFF0C\u907F\u514D\u5168\u5C40\u53D8\u91CF\u51B2\u7A81\nexport {};',
      "null.ts": '/**\r\n * AirFlow AI\u4F9B\u5E94\u5546\u6A21\u677F\r\n * @version 2.0\r\n */\r\n\r\n// ============================================================\r\n// \u7C7B\u578B\u5B9A\u4E49\r\n// ============================================================\r\n\r\ntype VideoMode =\r\n  | "singleImage" //\u5355\u56FE\u53C2\u8003\r\n  | "startEndRequired" //\u9996\u5C3E\u5E27\uFF08\u4E24\u5F20\u90FD\u5F97\u6709\uFF09\r\n  | "endFrameOptional" //\u9996\u5C3E\u5E27\uFF08\u5C3E\u5E27\u53EF\u9009\uFF09\r\n  | "startFrameOptional" //\u9996\u5C3E\u5E27\uFF08\u9996\u5E27\u53EF\u9009\uFF09\r\n  | "text" //\u6587\u672C\r\n  | (`videoReference:${number}` | `imageReference:${number}` | `audioReference:${number}`)[]; //\u591A\u53C2\u8003\uFF08\u6570\u5B57\u4EE3\u8868\u9650\u5236\u6570\u91CF\uFF09\r\n\r\ninterface TextModel {\r\n  name: string;\r\n  modelName: string;\r\n  type: "text";\r\n  think: boolean;\r\n}\r\n\r\ninterface ImageModel {\r\n  name: string;\r\n  modelName: string;\r\n  type: "image";\r\n  mode: ("text" | "singleImage" | "multiReference")[];\r\n  associationSkills?: string;\r\n}\r\n\r\ninterface VideoModel {\r\n  name: string;\r\n  modelName: string;\r\n  type: "video";\r\n  mode: VideoMode[];\r\n  associationSkills?: string;\r\n  audio: "optional" | false | true;\r\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\r\n}\r\n\r\ninterface TTSModel {\r\n  name: string;\r\n  modelName: string;\r\n  type: "tts";\r\n  voices: { title: string; voice: string }[];\r\n}\r\n\r\ninterface VendorConfig {\r\n  id: string; //\u552F\u4E00ID\uFF0C\u4F5C\u4E3A\u6587\u4EF6\u540D\u5B58\u50A8\u7528\u6237\u78C1\u76D8\u4E0A\uFF0C\u7981\u6B62\u7B26\u53F7\r\n  version: string; //\u7248\u672C\u53F7\uFF0C\u683C\u5F0F\u4E3Ax.y\uFF0C\u9700\u9075\u5B88\u8BED\u4E49\u5316\u7248\u672C\u63A7\u5236\r\n  name: string; //\u4F9B\u5E94\u5546\u540D\u79F0\r\n  author: string; //\u4F5C\u8005\r\n  description?: string; //\u63CF\u8FF0\uFF0C\u652F\u6301Markdown\u683C\u5F0F\r\n  icon?: string; //\u56FE\u6807\uFF0C\u4EC5\u652F\u6301Base64\u683C\u5F0F\uFF0C\u5EFA\u8BAE\u5C3A\u5BF8\u4E3A128x128\u50CF\u7D20\r\n  inputs: { key: string; label: string; type: "text" | "password" | "url"; required: boolean; placeholder?: string }[];\r\n  inputValues: Record<string, string>;\r\n  models: (TextModel | ImageModel | VideoModel | TTSModel)[];\r\n}\r\n\r\ntype ReferenceList =\r\n  | { type: "image"; sourceType: "base64"; base64: string }\r\n  | { type: "audio"; sourceType: "base64"; base64: string }\r\n  | { type: "video"; sourceType: "base64"; base64: string };\r\n\r\ninterface ImageConfig {\r\n  prompt: string;\r\n  referenceList?: Extract<ReferenceList, { type: "image" }>[];\r\n  size: "1K" | "2K" | "4K";\r\n  aspectRatio: `${number}:${number}`;\r\n}\r\n\r\ninterface VideoConfig {\r\n  duration: number;\r\n  resolution: string;\r\n  aspectRatio: "16:9" | "9:16";\r\n  prompt: string;\r\n  referenceList?: ReferenceList[];\r\n  audio?: boolean;\r\n  mode: VideoMode[];\r\n}\r\n\r\ninterface TTSConfig {\r\n  text: string;\r\n  voice: string;\r\n  speechRate: number;\r\n  pitchRate: number;\r\n  volume: number;\r\n  referenceList?: Extract<ReferenceList, { type: "audio" }>[];\r\n}\r\n\r\ninterface PollResult {\r\n  completed: boolean;\r\n  data?: string;\r\n  error?: string;\r\n}\r\n\r\n// ============================================================\r\n// \u5168\u5C40\u58F0\u660E\r\n// ============================================================\r\n\r\ndeclare const axios: any; // HTTP\u8BF7\u6C42\u5E93\r\ndeclare const logger: (msg: string) => void; // \u65E5\u5FD7\u51FD\u6570\r\ndeclare const jsonwebtoken: any; // JWT\u5904\u7406\u5E93\r\ndeclare const zipImage: (base64: string, size: number) => Promise<string>; // \u56FE\u7247\u538B\u7F29\u51FD\u6570\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\ndeclare const zipImageResolution: (base64: string, w: number, h: number) => Promise<string>; // \u56FE\u7247\u5206\u8FA8\u7387\u8C03\u6574\u51FD\u6570\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\ndeclare const mergeImages: (base64Arr: string[], maxSize?: string) => Promise<string>; // \u56FE\u7247\u5408\u6210\u51FD\u6570\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\ndeclare const urlToBase64: (url: string) => Promise<string>; // URL\u8F6CBase64\u51FD\u6570\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\ndeclare const pollTask: (fn: () => Promise<PollResult>, interval?: number, timeout?: number) => Promise<PollResult>; // \u8F6E\u8BE2\u51FD\u6570\uFF0Cfn\u4E3A\u5F02\u6B65\u51FD\u6570\uFF0Cinterval\u4E3A\u8F6E\u8BE2\u95F4\u9694\uFF0Ctimeout\u4E3A\u8D85\u65F6\u65F6\u95F4\uFF0C\u8FD4\u56DEfn\u7684\u7ED3\u679C\r\ndeclare const createOpenAI: any;\r\ndeclare const createDeepSeek: any;\r\ndeclare const createZhipu: any;\r\ndeclare const createQwen: any;\r\ndeclare const createAnthropic: any;\r\ndeclare const createOpenAICompatible: any;\r\ndeclare const createXai: any;\r\ndeclare const createMinimax: any;\r\ndeclare const createGoogleGenerativeAI: any;\r\ndeclare const exports: {\r\n  vendor: VendorConfig;\r\n  textRequest: (m: TextModel, t: boolean, tl: 0 | 1 | 2 | 3) => any; //\u6587\u672C\u6A21\u578B\r\n  imageRequest: (c: ImageConfig, m: ImageModel) => Promise<string>; //\u56FE\u7247\u6A21\u578B\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\n  videoRequest: (c: VideoConfig, m: VideoModel) => Promise<string>; //\u89C6\u9891\u6A21\u578B\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\n  ttsRequest: (c: TTSConfig, m: TTSModel) => Promise<string>; //\uFF08\u6682\u672A\u5F00\u653E\uFF09\u8BED\u97F3\u6A21\u578B\uFF0C\u8FD4\u56DE\u6709\u5934base64\u5B57\u7B26\u4E32\r\n  checkForUpdates?: () => Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }>; //\u68C0\u67E5\u66F4\u65B0\u51FD\u6570\uFF0C\u8FD4\u56DE\u662F\u5426\u6709\u66F4\u65B0\u548C\u6700\u65B0\u7248\u672C\u53F7\u548C\u66F4\u516C\u544A\uFF08\u652F\u6301Markdown\u683C\u5F0F\uFF09\r\n  updateVendor?: () => Promise<string>; //\u66F4\u65B0\u51FD\u6570\uFF0C\u8FD4\u56DE\u6700\u65B0\u7684\u4EE3\u7801\u6587\u672C\r\n};\r\n\r\n// ============================================================\r\n// \u4F9B\u5E94\u5546\u914D\u7F6E\r\n// ============================================================\r\n\r\nconst vendor: VendorConfig = {\r\n  id: "null",\r\n  version: "2.0",\r\n  author: "AirFlow",\r\n  name: "\u7A7A\u6A21\u677F",\r\n  description: "## \u5F00\u53D1\u6A21\u677F\uFF0C\u60A8\u53EF\u4EE5\u4F7F\u7528\u6B64\u6A21\u677F\u8FDB\u884CVibe Coding",\r\n  inputs: [\r\n    { key: "apiKey", label: "API\u5BC6\u94A5", type: "password", required: true },\r\n    { key: "baseUrl", label: "\u8BF7\u6C42\u5730\u5740", type: "url", required: true, placeholder: "\u793A\u4F8B\uFF1Ahttps://api.openai.com/v1" },\r\n  ],\r\n  inputValues: { apiKey: "", baseUrl: "https://api.openai.com/v1" },\r\n  models: [{ name: "GPT-4o", modelName: "gpt-4o", type: "text", think: false }],\r\n};\r\n\r\n// ============================================================\r\n// \u9002\u914D\u5668\u51FD\u6570\r\n// ============================================================\r\n\r\nconst textRequest = (model: TextModel, think: boolean, thinkLevel: 0 | 1 | 2 | 3) => {\r\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\r\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\r\n  return createOpenAI({ baseURL: vendor.inputValues.baseUrl, apiKey }).chat(model.modelName);\r\n};\r\n\r\nconst imageRequest = async (config: ImageConfig, model: ImageModel): Promise<string> => {\r\n  return "";\r\n};\r\n\r\nconst videoRequest = async (config: VideoConfig, model: VideoModel): Promise<string> => {\r\n  return "";\r\n};\r\n\r\nconst ttsRequest = async (config: TTSConfig, model: TTSModel): Promise<string> => {\r\n  return "";\r\n};\r\n\r\nconst checkForUpdates = async (): Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }> => {\r\n  return { hasUpdate: false, latestVersion: "2.0", notice: "## \u65B0\u7248\u672C\u66F4\u65B0\u516C\u544A" };\r\n};\r\n\r\nconst updateVendor = async (): Promise<string> => {\r\n  return "";\r\n};\r\n\r\n// ============================================================\r\n// \u5BFC\u51FA\r\n// ============================================================\r\n\r\nexports.vendor = vendor;\r\nexports.textRequest = textRequest;\r\nexports.imageRequest = imageRequest;\r\nexports.videoRequest = videoRequest;\r\nexports.ttsRequest = ttsRequest;\r\nexports.checkForUpdates = checkForUpdates;\r\nexports.updateVendor = updateVendor;\r\n\r\n// \u8FD9\u884C\u4EE3\u7801\u7528\u4E8E\u786E\u4FDD\u5F53\u524D\u6587\u4EF6\u88AB\u8BC6\u522B\u4E3A\u6A21\u5757\uFF0C\u907F\u514D\u5168\u5C40\u53D8\u91CF\u51B2\u7A81\r\nexport {};\r\n\r\n/**\r\n * ============================================================\r\n * AI \u4EE3\u7801\u751F\u6210\u6307\u5357\r\n * ============================================================\r\n *\r\n * \u3010\u6982\u8FF0\u3011\r\n * \u672C\u6587\u4EF6\u662F AirFlow AI \u4F9B\u5E94\u5546\u9002\u914D\u6A21\u677F\u3002AI \u5728\u751F\u6210\u65B0\u4F9B\u5E94\u5546\u9002\u914D\u4EE3\u7801\u65F6\uFF0C\r\n * \u5FC5\u987B\u4E25\u683C\u9075\u5B88\u4EE5\u4E0B\u89C4\u5219\uFF0C\u5E76\u8981\u6C42\u7528\u6237\u63D0\u4F9B\u76EE\u6807\u5E73\u53F0\u7684 curl \u8C03\u7528\u793A\u4F8B\u6216 API \u6587\u6863\u4FE1\u606F\u4F5C\u4E3A\u8F93\u5165\u4F9D\u636E\u3002\r\n *\r\n * \u3010\u524D\u7F6E\u8981\u6C42\u3011\r\n * \u5728\u751F\u6210\u4EE3\u7801\u524D\uFF0C\u8BF7\u5411\u7528\u6237\u7D22\u8981\u4EE5\u4E0B\u4FE1\u606F\uFF08\u81F3\u5C11\u5176\u4E00\uFF09\uFF1A\r\n *   1. \u76EE\u6807 API \u7684 curl \u8BF7\u6C42\u793A\u4F8B\uFF08\u5305\u542B\u8BF7\u6C42\u5730\u5740\u3001Headers\u3001Body \u7ED3\u6784\u3001\u54CD\u5E94\u7ED3\u6784\uFF09\r\n *   2. \u76EE\u6807 API \u7684\u5B98\u65B9\u6587\u6863\u94FE\u63A5\u6216\u6587\u6863\u622A\u56FE/\u6587\u672C\u5185\u5BB9\r\n *   3. \u9700\u8981\u9002\u914D\u7684\u6A21\u578B\u7C7B\u578B\uFF08text / image / video / tts\uFF09\u53CA\u5176\u80FD\u529B\u8BF4\u660E\r\n * \u6CA1\u6709\u8DB3\u591F\u4FE1\u606F\u65F6\uFF0C\u5E94\u4E3B\u52A8\u8FFD\u95EE\uFF0C\u4E0D\u8981\u51ED\u7A7A\u7F16\u9020 API \u7ED3\u6784\u3002\r\n *\r\n * \u3010\u4EE3\u7801\u89C4\u5219\u3011\r\n *\r\n * 1. \u7981\u6B62\u5F15\u5165\u4EFB\u4F55\u5916\u90E8\u5305\r\n *    \u4E0D\u53EF\u4F7F\u7528 import / require\uFF0C\u4EC5\u80FD\u4F7F\u7528\u672C\u6587\u4EF6\u300C\u5168\u5C40\u58F0\u660E\u300D\u533A\u57DF\u4E2D\u5DF2\u58F0\u660E\u7684\u65B9\u6CD5\u548C\u5BF9\u8C61\uFF0C\r\n *    \u5305\u62EC\uFF1Aaxios\u3001logger\u3001jsonwebtoken\u3001zipImage\u3001zipImageResolution\u3001mergeImages\u3001\r\n *    urlToBase64\u3001pollTask\uFF0C\u4EE5\u53CA createOpenAI\u3001createDeepSeek\u3001createZhipu\u3001createQwen\u3001\r\n *    createAnthropic\u3001createOpenAICompatible\u3001createXai\u3001createMinimax\u3001\r\n *    createGoogleGenerativeAI \u7B49 AI SDK \u5DE5\u5382\u51FD\u6570\u3002\r\n *\r\n * 2. \u7981\u6B62\u5728 exports.* \u51FD\u6570\u5916\u90E8\u58F0\u660E\u79BB\u6563\u7684\u5168\u5927\u5199\u5E38\u91CF\r\n *    \u9519\u8BEF\u793A\u4F8B\uFF1Aconst API_URL = "https://..."; const MAX_RETRY = 3;\r\n *    \u5982\u679C\u786E\u5B9E\u9700\u8981\u53EF\u914D\u7F6E\u7684\u5E38\u91CF\u503C\uFF0C\u5FC5\u987B\u5C06\u5176\u58F0\u660E\u5728 vendor.inputValues \u4E2D\uFF0C\r\n *    \u901A\u8FC7 vendor.inputValues.xxx \u8BBF\u95EE\uFF0C\u8BA9\u7528\u6237\u53EF\u5728\u754C\u9762\u4E0A\u914D\u7F6E\u3002\r\n *    \u5982\u679C\u662F\u7EAF\u903B\u8F91\u5185\u90E8\u4F7F\u7528\u7684\u4E34\u65F6\u53D8\u91CF\uFF0C\u5E94\u5185\u8054\u5728\u5BF9\u5E94\u7684 exports.* \u51FD\u6570\u4F53\u5185\u90E8\uFF0C\u4F7F\u7528\u5C0F\u9A7C\u5CF0\u547D\u540D\u3002\r\n *\r\n * 3. \u903B\u8F91\u5C3D\u91CF\u805A\u5408\u5728 exports.* \u5BF9\u5E94\u7684\u51FD\u6570\u5185\u90E8\r\n *    \u6BCF\u4E2A\u9002\u914D\u51FD\u6570\uFF08textRequest / imageRequest / videoRequest / ttsRequest\uFF09\r\n *    \u5E94\u81EA\u5305\u542B\uFF0C\u5C06\u8BF7\u6C42\u6784\u9020\u3001\u53D1\u9001\u3001\u8F6E\u8BE2\u3001\u7ED3\u679C\u89E3\u6790\u7B49\u903B\u8F91\u5199\u5728\u51FD\u6570\u4F53\u5185\uFF0C\u907F\u514D\u62C6\u5206\u51FA\u5927\u91CF\u5916\u90E8\u8F85\u52A9\u51FD\u6570\u3002\r\n *    \u5982\u679C\u591A\u4E2A\u51FD\u6570\u786E\u5B9E\u5B58\u5728\u516C\u5171\u903B\u8F91\uFF08\u5982\u7B7E\u540D\u8BA1\u7B97\u3001Token \u751F\u6210\u3001\u8BF7\u6C42\u5934\u6784\u9020\uFF09\uFF0C\r\n *    \u53EF\u63D0\u53D6\u4E3A\u6587\u4EF6\u5185\u7684\u5C0F\u9A7C\u5CF0\u547D\u540D\u51FD\u6570\uFF0C\u653E\u5728\u300C\u9002\u914D\u5668\u51FD\u6570\u300D\u533A\u5757\u4E4B\u524D\u7684\u300C\u8F85\u52A9\u5DE5\u5177\u300D\u533A\u5757\u4E2D\uFF0C\r\n *    \u4E14\u4E0D\u53EF\u4F7F\u7528\u5168\u5927\u5199\u547D\u540D\u3002\r\n *\r\n * 4. \u547D\u540D\u89C4\u8303\r\n *    \u6240\u6709\u53D8\u91CF\u3001\u51FD\u6570\u4E00\u5F8B\u4F7F\u7528\u5C0F\u9A7C\u5CF0\u547D\u540D\uFF08camelCase\uFF09\uFF0C\u7981\u6B62\u4F7F\u7528 UPPER_SNAKE_CASE\u3002\r\n *\r\n * 5. \u4E0D\u9700\u8981\u91CD\u65B0\u58F0\u660E\u7C7B\u578B\r\n *    \u672C\u6587\u4EF6\u9876\u90E8\u5DF2\u5B8C\u6574\u5B9A\u4E49\u4E86\u6240\u6709\u63A5\u53E3\u548C\u7C7B\u578B\uFF08VendorConfig\u3001ImageConfig\u3001VideoConfig\u3001\r\n *    TTSConfig\u3001TextModel\u3001ImageModel\u3001VideoModel\u3001TTSModel\u3001ReferenceList\u3001PollResult \u7B49\uFF09\uFF0C\r\n *    AI \u751F\u6210\u4EE3\u7801\u65F6\u76F4\u63A5\u4F7F\u7528\u5373\u53EF\uFF0C\u4E0D\u8981\u91CD\u590D\u58F0\u660E\u3002\r\n *\r\n * 6. \u8FD4\u56DE\u503C\u89C4\u8303\r\n *    - textRequest(model)\uFF1A\u8FD4\u56DE AI SDK \u7684 chat model \u5B9E\u4F8B\uFF08\u901A\u8FC7 createOpenAI \u7B49\u5DE5\u5382\u51FD\u6570\u521B\u5EFA\uFF09\u3002\r\n *    - imageRequest(config, model)\uFF1A\u8FD4\u56DE\u6709\u5934 base64 \u5B57\u7B26\u4E32\uFF08\u5982 "data:image/png;base64,..."\uFF09\u3002\r\n *      config.referenceList \u4E3A Extract<ReferenceList, { type: "image" }>[] \u7C7B\u578B\uFF0C\r\n *      \u6BCF\u4E2A\u5F15\u7528\u6761\u76EE\u5747\u4E3A base64 \u5F62\u5F0F\uFF08sourceType \u56FA\u5B9A\u4E3A "base64"\uFF09\u3002\r\n *    - videoRequest(config, model)\uFF1A\u8FD4\u56DE\u6709\u5934 base64 \u5B57\u7B26\u4E32\uFF08\u5982 "data:video/mp4;base64,..."\uFF09\u3002\r\n *      config.referenceList \u4E3A ReferenceList[] \u7C7B\u578B\uFF0C\u53EF\u5305\u542B image / video / audio \u4E09\u79CD\u5F15\u7528\uFF0C\r\n *      \u6BCF\u4E2A\u5F15\u7528\u6761\u76EE\u5747\u4E3A base64 \u5F62\u5F0F\uFF08sourceType \u56FA\u5B9A\u4E3A "base64"\uFF09\u3002\r\n *      config.mode \u4E3A\u5F53\u524D\u6FC0\u6D3B\u7684\u89C6\u9891\u6A21\u5F0F\u6570\u7EC4\uFF0C\u9700\u6839\u636E mode \u51B3\u5B9A\u5982\u4F55\u4F7F\u7528 referenceList\u3002\r\n *    - ttsRequest(config, model)\uFF1A\u8FD4\u56DE\u6709\u5934 base64 \u5B57\u7B26\u4E32\uFF08\u5982 "data:audio/mp3;base64,..."\uFF09\u3002\r\n *      config.referenceList \u4E3A Extract<ReferenceList, { type: "audio" }>[] \u7C7B\u578B\uFF08\u97F3\u9891\u53C2\u8003\uFF09\u3002\r\n *    \u5F53 API \u8FD4\u56DE\u7684\u662F URL \u800C\u975E\u4E8C\u8FDB\u5236\u6570\u636E\u65F6\uFF0C\u4F7F\u7528 urlToBase64(url) \u8F6C\u6362\u3002\r\n *\r\n * 7. ReferenceList \u4E0E VideoMode \u8BF4\u660E\r\n *    ReferenceList \u662F\u7EDF\u4E00\u7684\u591A\u5A92\u4F53\u5F15\u7528\u7C7B\u578B\uFF0C\u6BCF\u4E2A\u6761\u76EE\u5305\u542B\uFF1A\r\n *      - type: "image" | "audio" | "video"\uFF08\u5A92\u4F53\u7C7B\u578B\uFF09\r\n *      - sourceType: "base64"\uFF08\u5F53\u524D\u6A21\u677F\u56FA\u5B9A\u4E3A base64\uFF09\r\n *      - base64\uFF08\u5BF9\u5E94\u7684\u6570\u636E\uFF09\r\n *\r\n *    VideoMode \u5B9A\u4E49\u4E86\u89C6\u9891\u6A21\u578B\u652F\u6301\u7684\u8F93\u5165\u6A21\u5F0F\uFF1A\r\n *      - "text"\uFF1A\u7EAF\u6587\u672C\u751F\u6210\u89C6\u9891\r\n *      - "singleImage"\uFF1A\u5355\u5F20\u9996\u5E27\u56FE\u7247\r\n *      - "startEndRequired"\uFF1A\u9996\u5C3E\u5E27\uFF08\u4E24\u5F20\u90FD\u5FC5\u987B\u63D0\u4F9B\uFF09\r\n *      - "endFrameOptional"\uFF1A\u9996\u5C3E\u5E27\uFF08\u5C3E\u5E27\u53EF\u9009\uFF09\r\n *      - "startFrameOptional"\uFF1A\u9996\u5C3E\u5E27\uFF08\u9996\u5E27\u53EF\u9009\uFF09\r\n *      - \u6570\u7EC4\u5F62\u5F0F\u5982 ["imageReference:9", "videoReference:3", "audioReference:3"]\uFF1A\r\n *        \u591A\u6A21\u6001\u53C2\u8003\u6A21\u5F0F\uFF0C\u6570\u5B57\u8868\u793A\u8BE5\u7C7B\u578B\u7684\u6700\u5927\u6570\u91CF\u9650\u5236\u3002\r\n *\r\n *    \u5728 videoRequest \u4E2D\uFF0Cconfig.mode \u8868\u793A\u5F53\u524D\u9009\u62E9\u7684\u6A21\u5F0F\uFF0C\u9700\u6839\u636E\u5176\u503C\u51B3\u5B9A\uFF1A\r\n *      - \u5982\u4F55\u4ECE config.referenceList \u4E2D\u63D0\u53D6\u5BF9\u5E94\u7C7B\u578B\u7684\u5F15\u7528\r\n *      - \u5982\u4F55\u6784\u9020 API \u8BF7\u6C42\u4F53\u4E2D\u7684\u56FE\u7247/\u89C6\u9891/\u97F3\u9891\u53C2\u6570\r\n *\r\n * 8. \u5F02\u6B65\u4EFB\u52A1\u5904\u7406\r\n *    \u5BF9\u4E8E\u89C6\u9891\u751F\u6210\u7B49\u9700\u8981\u8F6E\u8BE2\u7684\u5F02\u6B65\u4EFB\u52A1\uFF0C\u4F7F\u7528\u5168\u5C40\u7684 pollTask \u51FD\u6570\uFF1A\r\n *    const result = await pollTask(async () => {\r\n *      const resp = await axios.get(...);\r\n *      if (resp.data.status === "SUCCESS") return { completed: true, data: resp.data.url };\r\n *      if (resp.data.status === "FAILED") return { completed: true, error: resp.data.message };\r\n *      return { completed: false };\r\n *    }, 5000, 600000); // \u6BCF5\u79D2\u8F6E\u8BE2\uFF0C10\u5206\u949F\u8D85\u65F6\r\n *    if (result.error) throw new Error(result.error);\r\n *    return await urlToBase64(result.data!);\r\n *\r\n * 9. \u9519\u8BEF\u5904\u7406\r\n *    \u5728\u6BCF\u4E2A\u51FD\u6570\u5F00\u5934\u6821\u9A8C\u5FC5\u9700\u53C2\u6570\uFF08\u5982 API Key\uFF09\uFF0C\u7F3A\u5931\u65F6\u4F7F\u7528 throw new Error("...") \u629B\u51FA\u3002\r\n *    API \u8BF7\u6C42\u5931\u8D25\u65F6\uFF0C\u4ECE\u54CD\u5E94\u4E2D\u63D0\u53D6\u6709\u610F\u4E49\u7684\u9519\u8BEF\u4FE1\u606F\u629B\u51FA\uFF0C\u4E0D\u8981\u541E\u6389\u5F02\u5E38\u3002\r\n *\r\n * 10. \u65E5\u5FD7\u8F93\u51FA\r\n *     \u5728\u5173\u952E\u6B65\u9AA4\u4F7F\u7528 logger("...") \u8F93\u51FA\u65E5\u5FD7\uFF08\u5982"\u5F00\u59CB\u63D0\u4EA4\u4EFB\u52A1"\u3001"\u4EFB\u52A1ID: xxx"\u3001"\u8F6E\u8BE2\u4E2D..."\uFF09\uFF0C\r\n *     \u4FBF\u4E8E\u8C03\u8BD5\u3002\r\n *\r\n * 11. vendor \u914D\u7F6E\u586B\u5199\r\n *     - id\uFF1A\u7EAF\u82F1\u6587\u5C0F\u5199\uFF0C\u4F5C\u4E3A\u6587\u4EF6\u540D\u4F7F\u7528\uFF0C\u7981\u6B62\u7279\u6B8A\u7B26\u53F7\u548C\u7A7A\u683C\u3002\r\n *     - version\uFF1A\u8BED\u4E49\u5316\u7248\u672C\u683C\u5F0F "x.y"\u3002\r\n *     - inputs\uFF1A\u6839\u636E\u76EE\u6807 API \u6240\u9700\u7684\u8BA4\u8BC1\u4FE1\u606F\u914D\u7F6E\uFF08API Key\u3001Secret\u3001\u8BF7\u6C42\u5730\u5740\u7B49\uFF09\u3002\r\n *     - models\uFF1A\u6839\u636E\u76EE\u6807\u5E73\u53F0\u652F\u6301\u7684\u6A21\u578B\u5217\u8868\u586B\u5199\uFF0C\u6CE8\u610F\u6B63\u786E\u8BBE\u7F6E type \u548C\u5404\u6A21\u578B\u7279\u6709\u5B57\u6BB5\u3002\r\n *       - VideoModel \u7684 mode \u5BF9\u5E94 API \u652F\u6301\u7684\u8F93\u5165\u6A21\u5F0F\uFF08\u53C2\u89C1\u89C4\u5219 7 \u7684 VideoMode \u8BF4\u660E\uFF09\u3002\r\n *       - VideoModel \u7684 audio \u5B57\u6BB5\uFF1Atrue\uFF08\u59CB\u7EC8\u751F\u6210\u97F3\u9891\uFF09\u3001false\uFF08\u4E0D\u751F\u6210\uFF09\u3001"optional"\uFF08\u7528\u6237\u53EF\u9009\uFF09\u3002\r\n *       - VideoModel \u7684 durationResolutionMap \u5BF9\u5E94\u5404\u65F6\u957F\u4E0B\u53EF\u9009\u7684\u5206\u8FA8\u7387\u3002\r\n *       - VideoModel \u7684 associationSkills \u53EF\u9009\uFF0C\u7528\u4E8E\u63CF\u8FF0\u6A21\u578B\u7684\u7279\u6B8A\u80FD\u529B\u3002\r\n *       - ImageModel \u7684 mode \u5BF9\u5E94 API \u652F\u6301\u7684\u751F\u56FE\u6A21\u5F0F\uFF08"text" \u7EAF\u6587\u672C\u3001"singleImage" \u5355\u56FE\u53C2\u8003\u3001"multiReference" \u591A\u56FE\u53C2\u8003\uFF09\u3002\r\n *       - TTSModel \u7684 voices \u5BF9\u5E94\u53EF\u9009\u7684\u97F3\u8272\u5217\u8868\u3002\r\n *\r\n * 12. \u56FE\u7247\u5904\u7406\r\n *     - \u9700\u8981\u538B\u7F29\u56FE\u7247\u4F53\u79EF\u65F6\u4F7F\u7528 zipImage(base64, maxSizeKB)\u3002\r\n *     - \u9700\u8981\u8C03\u6574\u56FE\u7247\u5206\u8FA8\u7387\u65F6\u4F7F\u7528 zipImageResolution(base64, width, height)\u3002\r\n *     - \u9700\u8981\u5C06\u591A\u5F20\u56FE\u7247\u62FC\u5408\u4E3A\u4E00\u5F20\u65F6\u4F7F\u7528 mergeImages(base64Arr, maxSize)\u3002\r\n *     - \u4EE5\u4E0A\u51FD\u6570\u5747\u63A5\u6536\u548C\u8FD4\u56DE\u6709\u5934 base64 \u5B57\u7B26\u4E32\u3002\r\n *\r\n * 13. \u6587\u4EF6\u7ED3\u6784\r\n *     \u751F\u6210\u7684\u4EE3\u7801\u5FC5\u987B\u4FDD\u6301\u672C\u6A21\u677F\u7684\u6574\u4F53\u7ED3\u6784\uFF1A\r\n *     \u7C7B\u578B\u5B9A\u4E49\u533A \u2192 \u5168\u5C40\u58F0\u660E\u533A \u2192 \u4F9B\u5E94\u5546\u914D\u7F6E\u533A \u2192 [\u8F85\u52A9\u5DE5\u5177\u533A\uFF08\u53EF\u9009\uFF09] \u2192 \u9002\u914D\u5668\u51FD\u6570\u533A \u2192 \u5BFC\u51FA\u533A\r\n *     \u4E0D\u8981\u6253\u4E71\u987A\u5E8F\uFF0C\u4E0D\u8981\u5220\u9664\u5DF2\u6709\u7684\u7ED3\u6784\u6CE8\u91CA\u5206\u9694\u7EBF\u3002\r\n *     \u8F85\u52A9\u5DE5\u5177\u533A\u7528\u4E8E\u653E\u7F6E\u591A\u4E2A\u9002\u914D\u5668\u51FD\u6570\u5171\u4EAB\u7684\u5C0F\u9A7C\u5CF0\u547D\u540D\u8F85\u52A9\u51FD\u6570\uFF08\u5982 getHeaders\u3001getBaseUrl\uFF09\u3002\r\n *\r\n * 14. \u5BFC\u51FA\u89C4\u8303\r\n *     \u5FC5\u987B\u5BFC\u51FA\u4EE5\u4E0B\u5B57\u6BB5\uFF08\u901A\u8FC7 exports.xxx = xxx \u8D4B\u503C\uFF09\uFF1A\r\n *       - exports.vendor\uFF08\u5FC5\u987B\uFF09\r\n *       - exports.textRequest\uFF08\u5FC5\u987B\uFF09\r\n *       - exports.imageRequest\uFF08\u5FC5\u987B\uFF09\r\n *       - exports.videoRequest\uFF08\u5FC5\u987B\uFF09\r\n *       - exports.ttsRequest\uFF08\u5FC5\u987B\uFF09\r\n *       - exports.checkForUpdates\uFF08\u53EF\u9009\uFF09\r\n *       - exports.updateVendor\uFF08\u53EF\u9009\uFF09\r\n *     \u672A\u5B9E\u73B0\u7684\u9002\u914D\u5668\u51FD\u6570\u4FDD\u7559\u7A7A\u5B9E\u73B0\uFF08return ""\uFF09\uFF0C\u4E0D\u53EF\u7701\u7565\u5BFC\u51FA\u3002\r\n *     \u6587\u4EF6\u672B\u5C3E\u5FC5\u987B\u5305\u542B export {}; \u4EE5\u786E\u4FDD\u6587\u4EF6\u88AB\u8BC6\u522B\u4E3A\u6A21\u5757\u3002\r\n *\r\n * \u3010\u751F\u6210\u6D41\u7A0B\u3011\r\n * \u5F53\u7528\u6237\u8BF7\u6C42\u751F\u6210\u65B0\u7684\u4F9B\u5E94\u5546\u9002\u914D\u65F6\uFF1A\r\n *   1. \u786E\u8BA4\u7528\u6237\u5DF2\u63D0\u4F9B curl \u793A\u4F8B\u6216 API \u6587\u6863\u3002\r\n *   2. \u5206\u6790 API \u7684\u8BA4\u8BC1\u65B9\u5F0F\u3001\u7AEF\u70B9\u5730\u5740\u3001\u8BF7\u6C42/\u54CD\u5E94\u7ED3\u6784\u3002\r\n *   3. \u57FA\u4E8E\u672C\u6A21\u677F\u7ED3\u6784\uFF0C\u586B\u5145 vendor \u914D\u7F6E\u548C\u5BF9\u5E94\u7684\u9002\u914D\u5668\u51FD\u6570\u3002\r\n *   4. \u6839\u636E\u5F53\u524D\u6A21\u677F\u7684 ReferenceList \u5B9A\u4E49\uFF0C\u6309 base64 \u5F62\u5F0F\u6784\u9020\u548C\u6D88\u8D39 referenceList\u3002\r\n *   5. \u4EC5\u5B9E\u73B0\u7528\u6237\u9700\u8981\u7684\u6A21\u578B\u7C7B\u578B\uFF0C\u672A\u7528\u5230\u7684\u51FD\u6570\u4FDD\u7559\u7A7A\u5B9E\u73B0\uFF08return ""\uFF09\u3002\r\n *   6. \u751F\u6210\u5B8C\u6574\u53EF\u7528\u7684\u4EE3\u7801\uFF0C\u786E\u4FDD\u65E0\u8BED\u6CD5\u9519\u8BEF\u3001\u65E0\u9057\u6F0F\u5BFC\u51FA\u3002\r\n */\r\n',
      "openai.ts": '/**\n * AirFlow AI\u4F9B\u5E94\u5546\u6A21\u677F\n * @version 2.0\n */\n// ============================================================\n// \u7C7B\u578B\u5B9A\u4E49\n// ============================================================\ntype VideoMode =\n  | "singleImage"\n  | "startEndRequired"\n  | "endFrameOptional"\n  | "startFrameOptional"\n  | "text"\n  | (`videoReference:${number}` | `imageReference:${number}` | `audioReference:${number}`)[];\ninterface TextModel {\n  name: string;\n  modelName: string;\n  type: "text";\n  think: boolean;\n}\ninterface ImageModel {\n  name: string;\n  modelName: string;\n  type: "image";\n  mode: ("text" | "singleImage" | "multiReference")[];\n  associationSkills?: string;\n}\ninterface VideoModel {\n  name: string;\n  modelName: string;\n  type: "video";\n  mode: VideoMode[];\n  associationSkills?: string;\n  audio: "optional" | false | true;\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\n}\ninterface TTSModel {\n  name: string;\n  modelName: string;\n  type: "tts";\n  voices: { title: string; voice: string }[];\n}\ninterface VendorConfig {\n  id: string;\n  version: string;\n  name: string;\n  author: string;\n  description?: string;\n  icon?: string;\n  inputs: { key: string; label: string; type: "text" | "password" | "url"; required: boolean; placeholder?: string }[];\n  inputValues: Record<string, string>;\n  models: (TextModel | ImageModel | VideoModel | TTSModel)[];\n}\ninterface ImageConfig {\n  prompt: string;\n  imageBase64: string[];\n  size: "1K" | "2K" | "4K";\n  aspectRatio: `${number}:${number}`;\n}\ninterface VideoConfig {\n  duration: number;\n  resolution: string;\n  aspectRatio: "16:9" | "9:16";\n  prompt: string;\n  imageBase64?: string[];\n  audio?: boolean;\n  mode: VideoMode[];\n}\ninterface TTSConfig {\n  text: string;\n  voice: string;\n  speechRate: number;\n  pitchRate: number;\n  volume: number;\n}\ninterface PollResult {\n  completed: boolean;\n  data?: string;\n  error?: string;\n}\n// ============================================================\n// \u5168\u5C40\u58F0\u660E\n// ============================================================\ndeclare const axios: any;\ndeclare const logger: (msg: string) => void;\ndeclare const jsonwebtoken: any;\ndeclare const zipImage: (base64: string, size: number) => Promise<string>;\ndeclare const zipImageResolution: (base64: string, w: number, h: number) => Promise<string>;\ndeclare const mergeImages: (base64Arr: string[], maxSize?: string) => Promise<string>;\ndeclare const urlToBase64: (url: string) => Promise<string>;\ndeclare const pollTask: (fn: () => Promise<PollResult>, interval?: number, timeout?: number) => Promise<PollResult>;\ndeclare const createOpenAI: any;\ndeclare const createDeepSeek: any;\ndeclare const createZhipu: any;\ndeclare const createQwen: any;\ndeclare const createAnthropic: any;\ndeclare const createOpenAICompatible: any;\ndeclare const createXai: any;\ndeclare const createMinimax: any;\ndeclare const createGoogleGenerativeAI: any;\ndeclare const exports: {\n  vendor: VendorConfig;\n  textRequest: (m: TextModel, t: boolean, tl: 0 | 1 | 2 | 3) => any;\n  imageRequest: (c: ImageConfig, m: ImageModel) => Promise<string>;\n  videoRequest: (c: VideoConfig, m: VideoModel) => Promise<string>;\n  ttsRequest: (c: TTSConfig, m: TTSModel) => Promise<string>;\n  checkForUpdates?: () => Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }>;\n  updateVendor?: () => Promise<string>;\n};\n// ============================================================\n// \u4F9B\u5E94\u5546\u914D\u7F6E\n// ============================================================\nconst vendor: VendorConfig = {\n  id: "openai",\n  version: "2.0",\n  author: "AirFlow",\n  name: "OpenAI\u6807\u51C6\u63A5\u53E3",\n  description: "OpenAI\u6807\u51C6\u683C\u5F0F\u63A5\u53E3\uFF0C\u53EF\u4FEE\u6539\u8BF7\u6C42\u5730\u5740\u5E76\u624B\u52A8\u6DFB\u52A0\u6A21\u578B\u3002",\n  icon: "",\n  inputs: [\n    { key: "apiKey", label: "API\u5BC6\u94A5", type: "password", required: true },\n    { key: "baseUrl", label: "\u8BF7\u6C42\u5730\u5740", type: "url", required: true, placeholder: "\u4EE5v1\u7ED3\u675F\uFF0C\u793A\u4F8B\uFF1Ahttps://api.openai.com/v1" },\n  ],\n  inputValues: {\n    apiKey: "",\n    baseUrl: "https://api.openai.com/v1",\n  },\n  models: [\n    { name: "GPT-4o", modelName: "gpt-4o", type: "text", think: false },\n    { name: "GPT-4.1", modelName: "gpt-4.1", type: "text", think: false },\n    { name: "GPT-5.1", modelName: "gpt-5.1", type: "text", think: false },\n    { name: "GPT-5.2", modelName: "gpt-5.2", type: "text", think: false },\n    { name: "GPT-5.4", modelName: "gpt-5.4", type: "text", think: false },\n  ],\n};\n// ============================================================\n// \u9002\u914D\u5668\u51FD\u6570\n// ============================================================\nconst textRequest = (model: TextModel, think: boolean, thinkLevel: 0 | 1 | 2 | 3) => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\n  return createOpenAI({ baseURL: vendor.inputValues.baseUrl, apiKey }).chat(model.modelName);\n};\nconst imageRequest = async (config: ImageConfig, model: ImageModel): Promise<string> => {\n  return "";\n};\nconst videoRequest = async (config: VideoConfig, model: VideoModel): Promise<string> => {\n  return "";\n};\nconst ttsRequest = async (config: TTSConfig, model: TTSModel): Promise<string> => {\n  return "";\n};\nconst checkForUpdates = async (): Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }> => {\n  return { hasUpdate: false, latestVersion: "2.0", notice: "" };\n};\nconst updateVendor = async (): Promise<string> => {\n  return "";\n};\n// ============================================================\n// \u5BFC\u51FA\n// ============================================================\nexports.vendor = vendor;\nexports.textRequest = textRequest;\nexports.imageRequest = imageRequest;\nexports.videoRequest = videoRequest;\nexports.ttsRequest = ttsRequest;\nexports.checkForUpdates = checkForUpdates;\nexports.updateVendor = updateVendor;\nexport {};',
      "toonflow.ts": '/**\n * AirFlow\u5B98\u65B9\u4E2D\u8F6C\u5E73\u53F0 \u4F9B\u5E94\u5546\u9002\u914D\n * @version 2.0\n */\n\n// ============================================================\n// \u7C7B\u578B\u5B9A\u4E49\n// ============================================================\n\ntype VideoMode =\n  | "singleImage"\n  | "startEndRequired"\n  | "endFrameOptional"\n  | "startFrameOptional"\n  | "text"\n  | (`videoReference:${number}` | `imageReference:${number}` | `audioReference:${number}`)[];\n\ninterface TextModel {\n  name: string;\n  modelName: string;\n  type: "text";\n  think: boolean;\n}\n\ninterface ImageModel {\n  name: string;\n  modelName: string;\n  type: "image";\n  mode: ("text" | "singleImage" | "multiReference")[];\n  associationSkills?: string;\n}\n\ninterface VideoModel {\n  name: string;\n  modelName: string;\n  type: "video";\n  mode: VideoMode[];\n  associationSkills?: string;\n  audio: "optional" | false | true;\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\n}\n\ninterface TTSModel {\n  name: string;\n  modelName: string;\n  type: "tts";\n  voices: { title: string; voice: string }[];\n}\n\ninterface VendorConfig {\n  id: string;\n  version: string;\n  name: string;\n  author: string;\n  description?: string;\n  icon?: string;\n  inputs: { key: string; label: string; type: "text" | "password" | "url"; required: boolean; placeholder?: string }[];\n  inputValues: Record<string, string>;\n  models: (TextModel | ImageModel | VideoModel | TTSModel)[];\n}\n\ntype ReferenceList =\n  | { type: "image"; sourceType: "base64"; base64: string }\n  | { type: "audio"; sourceType: "base64"; base64: string }\n  | { type: "video"; sourceType: "base64"; base64: string };\n\ninterface ImageConfig {\n  prompt: string;\n  referenceList?: Extract<ReferenceList, { type: "image" }>[];\n  size: "1K" | "2K" | "4K";\n  aspectRatio: `${number}:${number}`;\n}\n\ninterface VideoConfig {\n  duration: number;\n  resolution: string;\n  aspectRatio: "16:9" | "9:16";\n  prompt: string;\n  referenceList?: ReferenceList[];\n  audio?: boolean;\n  mode: VideoMode[];\n}\n\ninterface TTSConfig {\n  text: string;\n  voice: string;\n  speechRate: number;\n  pitchRate: number;\n  volume: number;\n  referenceList?: Extract<ReferenceList, { type: "audio" }>[];\n}\n\ninterface PollResult {\n  completed: boolean;\n  data?: string;\n  error?: string;\n}\n\n// ============================================================\n// \u5168\u5C40\u58F0\u660E\n// ============================================================\n\ndeclare const axios: any;\ndeclare const logger: (msg: string) => void;\ndeclare const jsonwebtoken: any;\ndeclare const zipImage: (base64: string, size: number) => Promise<string>;\ndeclare const zipImageResolution: (base64: string, w: number, h: number) => Promise<string>;\ndeclare const mergeImages: (base64Arr: string[], maxSize?: string) => Promise<string>;\ndeclare const urlToBase64: (url: string) => Promise<string>;\ndeclare const pollTask: (fn: () => Promise<PollResult>, interval?: number, timeout?: number) => Promise<PollResult>;\ndeclare const createOpenAI: any;\ndeclare const createDeepSeek: any;\ndeclare const createZhipu: any;\ndeclare const createQwen: any;\ndeclare const createAnthropic: any;\ndeclare const createOpenAICompatible: any;\ndeclare const createXai: any;\ndeclare const createMinimax: any;\ndeclare const createGoogleGenerativeAI: any;\ndeclare const exports: {\n  vendor: VendorConfig;\n  textRequest: (m: TextModel, t: boolean, tl: 0 | 1 | 2 | 3) => any;\n  imageRequest: (c: ImageConfig, m: ImageModel) => Promise<string>;\n  videoRequest: (c: VideoConfig, m: VideoModel) => Promise<string>;\n  ttsRequest: (c: TTSConfig, m: TTSModel) => Promise<string>;\n  checkForUpdates?: () => Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }>;\n  updateVendor?: () => Promise<string>;\n};\n\n// ============================================================\n// \u4F9B\u5E94\u5546\u914D\u7F6E\n// ============================================================\n\nconst vendor: VendorConfig = {\n  id: "toonflow",\n  version: "2.0",\n  author: "AirFlow",\n  name: "AirFlow\u5B98\u65B9\u4E2D\u8F6C\u5E73\u53F0",\n  description:\n    "## AirFlow\u5B98\u65B9\u4E2D\u8F6C\u5E73\u53F0\\n\\nAirFlow\u5B98\u65B9\u4E2D\u8F6C\u5E73\u53F0\uFF0C\u63D0\u4F9B**\u6587\u672C\u3001\u56FE\u50CF\u3001\u89C6\u9891\u3001\u97F3\u9891**\u7B49\u591A\u6A21\u6001\u751F\u6210\u80FD\u529B\u7684\u4E2D\u8F6C\u670D\u52A1\uFF0C\u652F\u6301\u63A5\u5165\u591A\u4E2A\u5927\u6A21\u578B\u4F9B\u5E94\u5546\uFF0C\u65B9\u4FBF\u7528\u6237\u7EDF\u4E00\u7BA1\u7406\u548C\u8C03\u7528\u4E0D\u540C\u4F9B\u5E94\u5546\u7684\u751F\u6210\u80FD\u529B\u3002\\n\\n\u{1F517} [\u524D\u5F80\u4E2D\u8F6C\u5E73\u53F0](https://api.toonflow.net/)\\n\\n\u5982\u679C\u8FD9\u4E2A\u9879\u76EE\u5BF9\u4F60\u6709\u5E2E\u52A9\uFF0C\u53EF\u4EE5\u8003\u8651\u652F\u6301\u4E00\u4E0B\u6211\u4EEC\u7684\u5F00\u53D1\u5DE5\u4F5C \u2615",\n  icon: "",\n  inputs: [{ key: "apiKey", label: "API\u5BC6\u94A5", type: "password", required: true }],\n  inputValues: {\n    apiKey: "",\n    baseUrl: "https://api.toonflow.net/v1",\n  },\n  models: [\n    { name: "claude-sonnet-4-6", type: "text", modelName: "claude-sonnet-4-6", think: false },\n    { name: "claude-opus-4-6", type: "text", modelName: "claude-opus-4-6", think: false },\n    { name: "claude-sonnet-4-5-20250929", type: "text", modelName: "claude-sonnet-4-5-20250929", think: false },\n    { name: "claude-opus-4-5-20251101", type: "text", modelName: "claude-opus-4-5-20251101", think: false },\n    { name: "claude-haiku-4-5-20251001", type: "text", modelName: "claude-haiku-4-5-20251001", think: false },\n    { name: "gpt-5.4", type: "text", modelName: "gpt-5.4", think: false },\n    { name: "gpt-5.2", type: "text", modelName: "gpt-5.2", think: false },\n    { name: "MiniMax-M2.7", type: "text", modelName: "MiniMax-M2.7", think: true },\n    { name: "MiniMax-M2.5", type: "text", modelName: "MiniMax-M2.5", think: true },\n    {\n      name: "Wan2.6 I2V 1080P (\u652F\u6301\u771F\u4EBA)",\n      type: "video",\n      modelName: "Wan2.6-I2V-1080P",\n      mode: ["text", "startEndRequired"],\n      durationResolutionMap: [{ duration: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["1080p"] }],\n      audio: true,\n    },\n    {\n      name: "Wan2.6 I2V 720P (\u652F\u6301\u771F\u4EBA)",\n      type: "video",\n      modelName: "Wan2.6-I2V-720P",\n      mode: ["text", "startEndRequired"],\n      durationResolutionMap: [{ duration: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["720p"] }],\n      audio: true,\n    },\n    {\n      name: "Seedance 1.5 Pro",\n      type: "video",\n      modelName: "doubao-seedance-1-5-pro-251215",\n      mode: ["text", "endFrameOptional"],\n      durationResolutionMap: [{ duration: [4, 5, 6, 7, 8, 9, 10, 11, 12], resolution: ["480p", "720p", "1080p"] }],\n      audio: true,\n    },\n    {\n      name: "vidu2 turbo",\n      type: "video",\n      modelName: "ViduQ2-turbo",\n      mode: ["singleImage", "startEndRequired"],\n      durationResolutionMap: [{ duration: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], resolution: ["540p", "720p", "1080p"] }],\n      audio: false,\n    },\n    {\n      name: "ViduQ3 pro",\n      type: "video",\n      modelName: "ViduQ3-pro",\n      mode: ["singleImage", "startEndRequired"],\n      durationResolutionMap: [{ duration: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], resolution: ["540p", "720p", "1080p"] }],\n      audio: false,\n    },\n    {\n      name: "ViduQ2 pro",\n      type: "video",\n      modelName: "ViduQ2-pro",\n      mode: ["singleImage", "startEndRequired"],\n      durationResolutionMap: [{ duration: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], resolution: ["540p", "720p", "1080p"] }],\n      audio: false,\n    },\n    {\n      name: "Doubao Seedream 5.0 Lite",\n      type: "image",\n      modelName: "Doubao-Seedream-5.0-Lite",\n      mode: ["text", "singleImage", "multiReference"],\n    },\n    {\n      name: "Doubao Seedream 4.5",\n      type: "image",\n      modelName: "doubao-seedream-4-5-251128",\n      mode: ["text", "singleImage", "multiReference"],\n    },\n  ],\n};\n\n// ============================================================\n// \u8F85\u52A9\u5DE5\u5177\n// ============================================================\n\n// \u4ECE markdown \u5185\u5BB9\u4E2D\u63D0\u53D6\u7B2C\u4E00\u5F20\u56FE\u7247\nfunction extractFirstImageFromMd(content: string) {\n  const regex = /!\\[([^\\]]*)\\]\\((data:image\\/[^;]+;base64,[A-Za-z0-9+/=]+|https?:\\/\\/[^\\s)]+|\\/\\/[^\\s)]+|[^\\s)]+)\\)/;\n  const match = content.match(regex);\n  if (!match) return null;\n  const raw = match[2].trim();\n  const url = raw.startsWith("data:") ? raw : raw.split(/\\s+/)[0];\n  return { alt: match[1], url, type: url.startsWith("data:image") ? "base64" : "url" };\n}\n\n// ============================================================\n// \u9002\u914D\u5668\u51FD\u6570\n// ============================================================\n\nconst textRequest = (model: TextModel, think: boolean, thinkLevel: 0 | 1 | 2 | 3) => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\n  return createOpenAI({ baseURL: vendor.inputValues.baseUrl, apiKey }).chat(model.modelName);\n};\n\nconst imageRequest = async (config: ImageConfig, model: ImageModel): Promise<string> => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\n  const baseUrl = vendor.inputValues.baseUrl;\n  const lowerName = model.modelName.toLowerCase();\n  const imageBase64List = (config.referenceList ?? []).map((r) => r.base64);\n\n  // Gemini / nano \u7CFB\u6A21\u578B\uFF1A\u8D70 chat/completions \u63A5\u53E3\uFF0C\u4ECE\u8FD4\u56DE\u7684 markdown \u4E2D\u63D0\u53D6\u56FE\u7247\n  if (lowerName.includes("gemini") || lowerName.includes("nano")) {\n    const imageConfigGoogle: Record<string, string> = {\n      aspect_ratio: config.aspectRatio,\n      image_size: config.size,\n    };\n    const messages: any[] = [];\n    if (imageBase64List.length) {\n      messages.push({\n        role: "user",\n        content: imageBase64List.map((b) => ({ type: "image_url", image_url: { url: b } })),\n      });\n    }\n    messages.push({ role: "user", content: config.prompt + "\u8BF7\u76F4\u63A5\u8F93\u51FA\u56FE\u7247" });\n    const body = {\n      model: model.modelName,\n      messages,\n      extra_body: { google: { image_config: imageConfigGoogle } },\n    };\n    logger(`[imageRequest] \u4F7F\u7528 gemini \u9002\u914D\u5668\uFF0C\u6A21\u578B: ${model.modelName}`);\n    const response = await fetch(`${baseUrl}/chat/completions`, {\n      method: "POST",\n      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },\n      body: JSON.stringify(body),\n    });\n    if (!response.ok) {\n      const errorText = await response.text();\n      throw new Error(`\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${response.status}, \u9519\u8BEF\u4FE1\u606F: ${errorText}`);\n    }\n    const data = await response.json();\n    const imageResult = extractFirstImageFromMd(data.choices[0].message.content);\n    if (!imageResult) throw new Error("\u672A\u80FD\u4ECE\u54CD\u5E94\u4E2D\u63D0\u53D6\u56FE\u7247");\n    if (imageResult.type === "base64") return imageResult.url;\n    return await urlToBase64(imageResult.url);\n  }\n\n  // \u8C46\u5305 / seedream \u7CFB\u6A21\u578B\uFF1A\u8D70 images/generations \u63A5\u53E3\n  if (lowerName.includes("doubao") || lowerName.includes("seedream")) {\n    const effectiveSize = config.size === "1K" ? "2K" : config.size;\n    const sizeMap: Record<string, Record<string, string>> = {\n      "16:9": { "2K": "2848x1600", "4K": "4096x2304" },\n      "9:16": { "2K": "1600x2848", "4K": "2304x4096" },\n    };\n    const resolvedSize = sizeMap[config.aspectRatio]?.[effectiveSize];\n    const body: Record<string, any> = {\n      model: model.modelName,\n      prompt: config.prompt,\n      size: resolvedSize,\n      response_format: "url",\n      sequential_image_generation: "disabled",\n      stream: false,\n      watermark: false,\n      ...(imageBase64List.length && { image: imageBase64List }),\n    };\n    logger(`[imageRequest] \u4F7F\u7528 doubao \u9002\u914D\u5668\uFF0C\u6A21\u578B: ${model.modelName}`);\n    const response = await fetch(`${baseUrl}/images/generations`, {\n      method: "POST",\n      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },\n      body: JSON.stringify(body),\n    });\n    if (!response.ok) {\n      const errorText = await response.text();\n      throw new Error(`\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${response.status}, \u9519\u8BEF\u4FE1\u606F: ${errorText}`);\n    }\n    const data = await response.json();\n    const resultUrl = data.data[0].url;\n    return await urlToBase64(resultUrl);\n  }\n\n  throw new Error(`\u4E0D\u652F\u6301\u7684\u56FE\u50CF\u6A21\u578B: ${model.modelName}`);\n};\n\nconst videoRequest = async (config: VideoConfig, model: VideoModel): Promise<string> => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\n  const baseUrl = vendor.inputValues.baseUrl;\n  const lowerName = model.modelName.toLowerCase();\n\n  // \u5F53\u524D\u6FC0\u6D3B\u7684\u5355\u4E00 VideoMode\uFF08\u53D6\u7B2C\u4E00\u4E2A\u975E\u6570\u7EC4\u6A21\u5F0F\uFF0C\u6216\u6570\u7EC4\u6A21\u5F0F\uFF09\n  const activeMode = config.mode;\n  const imageRefs = (config.referenceList ?? []).filter((r) => r.type === "image").map((r) => r.base64);\n  const videoRefs = (config.referenceList ?? []).filter((r) => r.type === "video").map((r) => r.base64);\n  const audioRefs = (config.referenceList ?? []).filter((r) => r.type === "audio").map((r) => r.base64);\n\n  // \u6784\u5EFA\u6A21\u578B\u4E13\u5C5E metadata\n  let metadata: Record<string, any> = {};\n\n  if (lowerName.includes("wan")) {\n    // \u4E07\u8C61\u7CFB\u5217\n    if ((activeMode === "startEndRequired" || activeMode === "endFrameOptional" || activeMode === "startFrameOptional") && imageRefs.length >= 2) {\n      if (imageRefs[0]) metadata.first_frame_url = imageRefs[0];\n      if (imageRefs[1]) metadata.last_frame_url = imageRefs[1];\n    } else if (imageRefs.length) {\n      metadata.img_url = imageRefs[0];\n    }\n    if (typeof config.audio === "boolean") metadata.audio = config.audio;\n\n    // \u4E07\u8C61\u9700\u8981\u989D\u5916\u4F20 size \u5B57\u6BB5\n    const wanSizeMap: Record<string, Record<string, string>> = {\n      "480p": { "16:9": "832*480", "9:16": "480*832" },\n      "720p": { "16:9": "1280*720", "9:16": "720*1280" },\n      "1080p": { "16:9": "1920*1080", "9:16": "1080*1920" },\n    };\n    const wanSize = wanSizeMap[config.resolution]?.[config.aspectRatio];\n    const body: Record<string, any> = {\n      model: model.modelName,\n      prompt: config.prompt,\n      duration: config.duration,\n      size: wanSize,\n      metadata,\n    };\n    logger(`[videoRequest] \u63D0\u4EA4\u4E07\u8C61\u89C6\u9891\u4EFB\u52A1\uFF0C\u6A21\u578B: ${model.modelName}`);\n    const response = await fetch(`${baseUrl}/video/generations`, {\n      method: "POST",\n      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },\n      body: JSON.stringify(body),\n    });\n    if (!response.ok) {\n      const errorText = await response.text();\n      throw new Error(`\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${response.status}, \u9519\u8BEF\u4FE1\u606F: ${errorText}`);\n    }\n    const data = await response.json();\n    const taskId = data.id;\n    logger(`[videoRequest] \u4E07\u8C61\u4EFB\u52A1ID: ${taskId}`);\n    const res = await pollTask(async () => {\n      const queryResponse = await fetch(`${baseUrl}/video/generations/${taskId}`, {\n        method: "GET",\n        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },\n      });\n      if (!queryResponse.ok) {\n        const errorText = await queryResponse.text();\n        throw new Error(`\u8F6E\u8BE2\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${queryResponse.status}, \u9519\u8BEF\u4FE1\u606F: ${errorText}`);\n      }\n      const queryData = await queryResponse.json();\n      const status = queryData?.status ?? queryData?.data?.status;\n      switch (status) {\n        case "completed":\n        case "SUCCESS":\n        case "success":\n          return { completed: true, data: queryData.data.result_url };\n        case "FAILURE":\n        case "failed":\n          return { completed: true, error: queryData?.data?.fail_reason ?? "\u89C6\u9891\u751F\u6210\u5931\u8D25" };\n        default:\n          return { completed: false };\n      }\n    });\n    if (res.error) throw new Error(res.error);\n    return await urlToBase64(res.data!);\n  }\n\n  if (lowerName.includes("doubao") || lowerName.includes("seedance")) {\n    // \u8C46\u5305/Seedance \u7CFB\u5217\n    metadata = {\n      ...(typeof config.audio === "boolean" && { generate_audio: config.audio }),\n      ratio: config.aspectRatio,\n      image_roles: [] as string[],\n      references: [] as string[],\n    };\n    if (Array.isArray(activeMode)) {\n      // \u591A\u53C2\u8003\u6A21\u5F0F\n      imageRefs.forEach((b) => metadata.references.push(b));\n      videoRefs.forEach((b) => metadata.references.push(b));\n      audioRefs.forEach((b) => metadata.references.push(b));\n    } else if (activeMode === "startEndRequired" || activeMode === "endFrameOptional" || activeMode === "startFrameOptional") {\n      imageRefs.forEach((_, i) => (metadata.image_roles as string[]).push(i === 0 ? "first_frame" : "last_frame"));\n    } else if (activeMode === "singleImage") {\n      imageRefs.forEach(() => (metadata.image_roles as string[]).push("reference_image"));\n    }\n  } else if (lowerName.includes("vidu")) {\n    // Vidu \u7CFB\u5217\n    metadata = {\n      aspect_ratio: config.aspectRatio,\n      audio: config.audio ?? false,\n      off_peak: false,\n    };\n  } else if (lowerName.includes("kling")) {\n    // \u53EF\u7075\u7CFB\u5217\n    metadata = { aspect_ratio: config.aspectRatio };\n    if (Array.isArray(activeMode)) {\n      metadata.reference = [...imageRefs, ...videoRefs, ...audioRefs];\n    } else if (activeMode === "endFrameOptional" && imageRefs.length) {\n      metadata.image_tail = imageRefs[0];\n    } else if (activeMode === "startEndRequired" && imageRefs.length >= 2) {\n      metadata.image_list = [\n        { image_url: imageRefs[0], type: "first_frame" },\n        { image_url: imageRefs[1], type: "last_frame" },\n      ];\n    } else if (activeMode === "singleImage" && imageRefs.length) {\n      metadata.image = imageRefs[0];\n    }\n  }\n\n  // \u516C\u5171\u8BF7\u6C42\u4F53\uFF08\u975E\u4E07\u8C61\u901A\u7528\u8DEF\u5F84\uFF09\n  const publicBody: Record<string, any> = {\n    model: model.modelName,\n    ...(!Array.isArray(activeMode) && imageRefs.length ? { images: imageRefs } : {}),\n    prompt: config.prompt,\n    duration: config.duration,\n    metadata,\n  };\n\n  logger(`[videoRequest] \u63D0\u4EA4\u89C6\u9891\u4EFB\u52A1\uFF0C\u6A21\u578B: ${model.modelName}`);\n  const response = await fetch(`${baseUrl}/video/generations`, {\n    method: "POST",\n    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },\n    body: JSON.stringify(publicBody),\n  });\n  if (!response.ok) {\n    const errorText = await response.text();\n    throw new Error(`\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${response.status}, \u9519\u8BEF\u4FE1\u606F: ${errorText}`);\n  }\n  const data = await response.json();\n  const taskId = data.id;\n  logger(`[videoRequest] \u4EFB\u52A1ID: ${taskId}`);\n\n  const res = await pollTask(async () => {\n    const queryResponse = await fetch(`${baseUrl}/video/generations/${taskId}`, {\n      method: "GET",\n      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },\n    });\n    if (!queryResponse.ok) {\n      const errorText = await queryResponse.text();\n      throw new Error(`\u8F6E\u8BE2\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${queryResponse.status}, \u9519\u8BEF\u4FE1\u606F: ${errorText}`);\n    }\n    const queryData = await queryResponse.json();\n    const status = queryData?.status ?? queryData?.data?.status;\n    switch (status) {\n      case "completed":\n      case "SUCCESS":\n      case "success":\n        return { completed: true, data: queryData.data.result_url };\n      case "FAILURE":\n      case "failed":\n        return { completed: true, error: queryData?.data?.fail_reason ?? "\u89C6\u9891\u751F\u6210\u5931\u8D25" };\n      default:\n        return { completed: false };\n    }\n  });\n\n  if (res.error) throw new Error(res.error);\n  return await urlToBase64(res.data!);\n};\n\nconst ttsRequest = async (config: TTSConfig, model: TTSModel): Promise<string> => {\n  return "";\n};\n\nconst checkForUpdates = async (): Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }> => {\n  return { hasUpdate: false, latestVersion: "2.0", notice: "" };\n};\n\nconst updateVendor = async (): Promise<string> => {\n  return "";\n};\n\n// ============================================================\n// \u5BFC\u51FA\n// ============================================================\n\nexports.vendor = vendor;\nexports.textRequest = textRequest;\nexports.imageRequest = imageRequest;\nexports.videoRequest = videoRequest;\nexports.ttsRequest = ttsRequest;\nexports.checkForUpdates = checkForUpdates;\nexports.updateVendor = updateVendor;\n\nexport {};\n',
      "vidu.ts": '//\u5982\u9700\u9065\u6D4BAI\u8BF7\u4F7F\u7528\u5728toonflow\u5B89\u88C5\u76EE\u5F55\u8FD0\u884Cnpx @ai-sdk/devtools \uFF08\u8981\u6C42\u5728\u5176\u4ED6\u8BBE\u7F6E\u4E2D\u6253\u5F00\u9065\u6D4B\u529F\u80FD\uFF0C\u4E14toonflow\u6709\u6743\u9650\u5728\u5B89\u88C5\u76EE\u5F55\u521B\u5EFA.devtools\u6587\u4EF6\u5939\uFF09\n// ==================== \u7C7B\u578B\u5B9A\u4E49 ====================\n// \u6587\u672C\u6A21\u578B\ninterface TextModel {\n  name: string; // \u663E\u793A\u540D\u79F0\n  modelName: string;\n  type: "text";\n  think: boolean; // \u524D\u7AEF\u663E\u793A\u7528\n}\n\n// \u56FE\u50CF\u6A21\u578B\ninterface ImageModel {\n  name: string; // \u663E\u793A\u540D\u79F0\n  modelName: string;\n  type: "image";\n  mode: ("text" | "singleImage" | "multiReference")[];\n  associationSkills?: string; // \u5173\u8054\u6280\u80FD\uFF0C\u591A\u4E2A\u6280\u80FD\u7528\u9017\u53F7\u5206\u9694\n}\n// \u89C6\u9891\u6A21\u578B\ninterface VideoModel {\n  name: string; // \u663E\u793A\u540D\u79F0\n  modelName: string; //\u5168\u5C40\u552F\u4E00\n  type: "video";\n  mode: (\n    | "singleImage" // \u5355\u56FE\n    | "startEndRequired" // \u9996\u5C3E\u5E27\uFF08\u4E24\u5F20\u90FD\u5F97\u6709\uFF09\n    | "endFrameOptional" // \u9996\u5C3E\u5E27\uFF08\u5C3E\u5E27\u53EF\u9009\uFF09\n    | "startFrameOptional" // \u9996\u5C3E\u5E27\uFF08\u9996\u5E27\u53EF\u9009\uFF09\n    | "text" // \u6587\u672C\u751F\u89C6\u9891\n    | ("videoReference" | "imageReference" | "audioReference" | "textReference")[] // \u6DF7\u5408\u53C2\u8003\n  )[];\n  associationSkills?: string; // \u5173\u8054\u6280\u80FD\uFF0C\u591A\u4E2A\u6280\u80FD\u7528\u9017\u53F7\u5206\u9694\n  audio: "optional" | false | true; // \u97F3\u9891\u914D\u7F6E\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\n}\n\ninterface TTSModel {\n  name: string; // \u663E\u793A\u540D\u79F0\n  modelName: string;\n  type: "tts";\n  voices: {\n    title: string; //\u663E\u793A\u540D\u79F0\n    voice: string; //\u8BF4\u8BDD\u4EBA\n  }[];\n}\n// \u4F9B\u5E94\u5546\u914D\u7F6E\ninterface VendorConfig {\n  id: string; //\u4F9B\u5E94\u5546\u552F\u4E00\u6807\u8BC6\uFF0C\u5FC5\u987B\u5168\u5C40\u552F\u4E00\n  author: string;\n  description?: string; //md5\u683C\u5F0F\n  name: string;\n  icon?: string; //\u4EC5\u652F\u6301base64\u683C\u5F0F\n  inputs: {\n    key: string;\n    label: string;\n    type: "text" | "password" | "url";\n    required: boolean;\n    placeholder?: string;\n  }[];\n  inputValues: Record<string, string>;\n  models: (TextModel | ImageModel | VideoModel)[];\n}\n// ==================== \u5168\u5C40\u5DE5\u5177\u51FD\u6570 ====================\n//Axios\u5B9E\u4F8B\n//\u538B\u7F29\u56FE\u7247\u5927\u5C0F(1MB = 1 * 1024 * 1024)\ndeclare const zipImage: (completeBase64: string, size: number) => Promise<string>;\n//\u538B\u7F29\u56FE\u7247\u5206\u8FA8\u7387\ndeclare const zipImageResolution: (completeBase64: string, width: number, height: number) => Promise<string>;\n//\u591A\u56FE\u62FC\u63A5\u4E58\u5355\u56FE maxSize  \u6700\u5927\u8F93\u51FA\u5927\u5C0F\uFF0C\u9ED8\u8BA4\u4E3A 10mb\ndeclare const mergeImages: (completeBase64: string[], maxSize?: string) => Promise<string>;\n//Url\u8F6CBase64\ndeclare const urlToBase64: (url: string) => Promise<string>;\n//\u8F6E\u8BE2\u51FD\u6570\ndeclare const pollTask: (\n  fn: () => Promise<{ completed: boolean; data?: string; error?: string }>,\n  interval?: number,\n  timeout?: number,\n) => Promise<{ completed: boolean; data?: string; error?: string }>;\ndeclare const axios: any;\ndeclare const createOpenAI: any;\ndeclare const createDeepSeek: any;\ndeclare const createZhipu: any;\ndeclare const createQwen: any;\ndeclare const createAnthropic: any;\ndeclare const createOpenAICompatible: any;\ndeclare const createXai: any;\ndeclare const createMinimax: any;\ndeclare const createGoogleGenerativeAI: any;\ndeclare const logger: (logstring: string) => void;\ndeclare const jsonwebtoken: any;\n// ==================== \u4F9B\u5E94\u5546\u6570\u636E ====================\nconst vendor: VendorConfig = {\n  id: "vidu",\n  author: "\u642C\u7816\u7684Coder",\n  description:\n    "Vidu \u5B98\u65B9\u89C6\u9891\u751F\u6210\u5E73\u53F0\u3002 [\u524D\u5F80\u5E73\u53F0](https://platform.vidu.cn/login/)",\n  name: "Vidu \u5F00\u653E\u5E73\u53F0",\n  inputs: [\n    { key: "apiKey", label: "API\u5BC6\u94A5", type: "password", required: true, placeholder: "\u8BF7\u5230Vidu\u5B98\u65B9\u7533\u8BF7" },\n    { key: "baseUrl", label: "\u63A5\u53E3\u8DEF\u5F84", type: "url", required: true, placeholder: "https://api.vidu.cn/ent/v2" },\n  ],\n  inputValues: {\n    apiKey: "",\n    baseUrl: "https://api.vidu.cn/ent/v2",\n  },\n  models: [\n    {\n      name: "ViduQ3 turbo",\n      type: "video",\n      modelName: "ViduQ3-turbo",\n      durationResolutionMap: [{ duration: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], resolution: ["540p", "720p", "1080p"] }],\n      mode: ["singleImage", "startEndRequired", "text"],\n      audio: true,\n    },\n    {\n      name: "ViduQ3 pro",\n      type: "video",\n      modelName: "ViduQ3-pro",\n      durationResolutionMap: [{ duration: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], resolution: ["540p", "720p", "1080p"] }],\n      mode: ["singleImage", "startEndRequired", "text"],\n      audio: true,\n    },\n    {\n      name: "ViduQ2 pro fast",\n      type: "video",\n      modelName: "ViduQ2-pro-fast",\n      durationResolutionMap: [{ duration: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], resolution: ["720p", "1080p"] }],\n      mode: ["singleImage", "startEndRequired"],\n      audio: true,\n    },\n    {\n      name: "viduQ2 turbo",\n      type: "video",\n      modelName: "ViduQ2-turbo",\n      durationResolutionMap: [{ duration: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], resolution: ["540p", "720p", "1080p"] }],\n      mode: ["singleImage", "startEndRequired"],\n      audio: true,\n    },\n    {\n      name: "ViduQ2 pro",\n      type: "video",\n      modelName: "ViduQ2-pro",\n      durationResolutionMap: [{ duration: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], resolution: ["540p", "720p", "1080p"] }],\n      mode: ["singleImage", "startEndRequired"], //\u53C2\u8003\u751F\u89C6\u9891\u65E0\u6709\u6548\u8BBE\u7F6E\u503C\n      audio: true,\n    },\n    {\n      name: "ViduQ2",\n      type: "video",\n      modelName: "ViduQ2",\n      durationResolutionMap: [{ duration: [5], resolution: ["1080p"] }],\n      mode: ["text"],\n      audio: true,\n    },\n    {\n      name: "ViduQ1",\n      type: "video",\n      modelName: "ViduQ1",\n      durationResolutionMap: [{ duration: [5], resolution: ["1080p"] }],\n      mode: ["singleImage", "startEndRequired", "text"],\n      audio: true,\n    },\n    {\n      name: "ViduQ1 classic",\n      type: "video",\n      modelName: "viduQ1-classic",\n      durationResolutionMap: [{ duration: [5], resolution: ["1080p"] }],\n      mode: ["singleImage", "startEndRequired"],\n      audio: true,\n    },\n    {\n      name: "Vidu2.0",\n      type: "video",\n      modelName: "vidu2.0",\n      durationResolutionMap: [{ duration: [4, 8], resolution: ["360p", "720p", "1080p"] }],\n      mode: ["singleImage", "startEndRequired"],\n      audio: true,\n    },\n    {\n      name: "viduq1 for image",\n      type: "image",\n      modelName: "viduq1",\n      mode: ["text"],\n    },\n    {\n      name: "viduq2 for image",\n      type: "image",\n      modelName: "viduq2",\n      mode: ["text", "singleImage", "multiReference"],\n    },\n  ],\n};\nexports.vendor = vendor;\n\n// ==================== \u9002\u914D\u5668\u51FD\u6570 ====================\n\n// \u6587\u672C\u8BF7\u6C42\u51FD\u6570\nconst textRequest: (textModel: TextModel) => { url: string; model: string } = (textModel) => {\n  throw new Error("\u5F53\u524D\u4F9B\u5E94\u5546\u4EC5\u652F\u6301\u89C6\u9891\u5927\u6A21\u578B\uFF0C\u8C22\u8C22\uFF01");\n};\nexports.textRequest = textRequest;\n\n//\u56FE\u7247\u8BF7\u6C42\u51FD\u6570\ninterface ImageConfig {\n  prompt: string; //\u56FE\u7247\u63D0\u793A\u8BCD\n  imageBase64: string[]; //\u8F93\u5165\u7684\u56FE\u7247\u63D0\u793A\u8BCD\n  size: "1K" | "2K" | "4K"; // \u56FE\u7247\u5C3A\u5BF8\n  aspectRatio: `${number}:${number}`; // \u957F\u5BBD\u6BD4\n}\nconst imageRequest = async (imageConfig: ImageConfig, imageModel: ImageModel) => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const apiKey = vendor.inputValues.apiKey.replace("Token ", "");\n\n  const size = imageConfig.size === "1K" ? "2K" : imageConfig.size;\n  const sizeMap: Record<string, Record<string, string>> = {\n    "16:9": {\n      "1k": "1920x1080",\n      "2K": "2848x1600",\n      "4K": "4096x2304",\n    },\n    "9:16": {\n      "1k": "1920x1080",\n      "2K": "1600x2848",\n      "4K": "2304x4096",\n    },\n  };\n\n  const body: Record<string, any> = {\n    model: imageModel.modelName,\n    prompt: imageConfig.prompt,\n    aspect_ratio: sizeMap[imageConfig.aspectRatio][size],\n    seed: 0,\n    resolution: size,\n    ...(imageConfig.imageBase64 && { image: imageConfig.imageBase64 }),\n  };\n\n  const createImageUrl = vendor.inputValues.baseUrl + "/reference2image";\n  const response = await fetch(createImageUrl, {\n    method: "POST",\n    headers: { Authorization: `Token ${apiKey}`, "Content-Type": "application/json" },\n    body: JSON.stringify(body),\n  });\n  if (!response.ok) {\n    const errorText = await response.text(); // \u83B7\u53D6\u9519\u8BEF\u4FE1\u606F\n    console.error("\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801:", response.status, ", \u9519\u8BEF\u4FE1\u606F:", errorText);\n    throw new Error(`\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${response.status}, \u9519\u8BEF\u4FE1\u606F: ${errorText}`);\n  }\n  const data = await response.json();\n  const res = await checkTaskResult(data.task_id);\n  if (!res.data) {\n    throw new Error("\u56FE\u7247\u672A\u80FD\u751F\u6210");\n  }\n  const list = JSON.parse(JSON.stringify(res.data));\n  return list[0].url;\n};\nexports.imageRequest = imageRequest;\n\ninterface VideoConfig {\n  duration: number;\n  resolution: string;\n  aspectRatio: "16:9" | "9:16";\n  prompt: string;\n  imageBase64?: string[];\n  audio?: boolean;\n  mode:\n    | "singleImage" // \u5355\u56FE\n    | "multiImage" // \u591A\u56FE\u6A21\u5F0F\n    | "gridImage" // \u7F51\u683C\u5355\u56FE\uFF08\u4F20\u5165\u4E00\u5F20\u56FE\u7247\uFF0C\u4F46\u8BE5\u56FE\u7247\u662F\u7F51\u683C\u56FE\uFF09\n    | "startEndRequired" // \u9996\u5C3E\u5E27\uFF08\u4E24\u5F20\u90FD\u5F97\u6709\uFF09\n    | "endFrameOptional" // \u9996\u5C3E\u5E27\uFF08\u5C3E\u5E27\u53EF\u9009\uFF09\n    | "startFrameOptional" // \u9996\u5C3E\u5E27\uFF08\u9996\u5E27\u53EF\u9009\uFF09\n    | "text" // \u6587\u672C\u751F\u89C6\u9891\n    | ("video" | "image" | "audio" | "text")[]; // \u6DF7\u5408\u53C2\u8003\n}\n\n// \u6784\u5EFA \u5404\u4E2A\u5E73\u53F0\u7684metadata\u53C2\u6570\n\nconst buildViduMetadata = (videoConfig: VideoConfig) => ({\n  aspect_ratio: videoConfig.aspectRatio,\n  audio: videoConfig.audio ?? false,\n  off_peak: false,\n});\n\ntype MetadataBuilder = (config: VideoConfig) => Record<string, any>;\nconst METADATA_BUILDERS: Array<[string, MetadataBuilder]> = [["vidu", buildViduMetadata]];\nconst buildModelMetadata = (modelName: string, videoConfig: VideoConfig) => {\n  const lowerName = modelName.toLowerCase();\n  const match = METADATA_BUILDERS.find(([key]) => lowerName.includes(key));\n  return match ? match[1](videoConfig) : {};\n};\n// \u68C0\u67E5\u751F\u6210\u7269\u7ED3\u679C\nconst checkTaskResult = async (taskId: string) => {\n  const queryUrl = vendor.inputValues.baseUrl + "/tasks/{id}/creations";\n  const apiKey = vendor.inputValues.apiKey;\n  const res = await pollTask(async () => {\n    const queryResponse = await fetch(queryUrl.replace("{id}", taskId), {\n      method: "GET",\n      headers: { Authorization: `Token ${apiKey}`, "Content-Type": "application/json" },\n    });\n    if (!queryResponse.ok) {\n      const errorText = await queryResponse.text(); // \u83B7\u53D6\u9519\u8BEF\u4FE1\u606F\n      console.error("\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801:", queryResponse.status, ", \u9519\u8BEF\u4FE1\u606F:", errorText);\n      throw new Error(`\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${queryResponse.status}, \u9519\u8BEF\u4FE1\u606F: ${errorText}`);\n    }\n    const queryData = await queryResponse.json();\n    const status = queryData?.state ?? queryData?.data?.state;\n    const fail_reason = queryData?.data?.err_code ?? queryData?.data;\n    switch (status) {\n      case "completed":\n      case "SUCCESS":\n      case "success":\n        return { completed: true, data: queryData.creations };\n      case "FAILURE":\n      case "failed":\n        return { completed: false, error: fail_reason || "\u751F\u6210\u5931\u8D25" };\n      default:\n        return { completed: false };\n    }\n  });\n  if (res.error) throw new Error(res.error);\n  return res;\n};\n\nconst videoRequest = async (videoConfig: VideoConfig, videoModel: VideoModel) => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const apiKey = vendor.inputValues.apiKey.replace("Token ", "");\n\n  // \u6784\u5EFA\u6BCF\u4E2A\u6A21\u578B\u5BF9\u5E94\u7684\u9644\u52A0\u53C2\u6570\n  const metadata = buildModelMetadata(videoModel.modelName, videoConfig);\n\n  //\u516C\u5171\u8BF7\u6C42\u53C2\u6570\n  const publicBody = {\n    model: videoModel.modelName,\n    ...(videoConfig.imageBase64 && videoConfig.imageBase64.length ? { images: videoConfig.imageBase64 } : {}),\n    prompt: videoConfig.prompt,\n    size: videoConfig.resolution,\n    duration: videoConfig.duration,\n    metadata: metadata,\n  };\n\n  const requestUrl = vendor.inputValues.baseUrl + "/start-end2video";\n  const response = await fetch(requestUrl, {\n    method: "POST",\n    headers: { Authorization: `Token ${apiKey}`, "Content-Type": "application/json" },\n    body: JSON.stringify(publicBody),\n  });\n  if (!response.ok) {\n    const errorText = await response.text(); // \u83B7\u53D6\u9519\u8BEF\u4FE1\u606F\n    console.error("\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801:", response.status, ", \u9519\u8BEF\u4FE1\u606F:", errorText);\n    throw new Error(`\u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${response.status}, \u9519\u8BEF\u4FE1\u606F: ${errorText}`);\n  }\n  const data = await response.json();\n  const taskId = data.id;\n  const result = await checkTaskResult(taskId);\n  return result.data;\n};\nexports.videoRequest = videoRequest;\n\ninterface TTSConfig {\n  text: string;\n  voice: string;\n  speechRate: number;\n  pitchRate: number;\n  volume: number;\n}\nconst ttsRequest = async (ttsConfig: TTSConfig, ttsModel: TTSModel) => {\n  throw new Error("Vidu \u6682\u4E0D\u652F\u6301\u8BED\u97F3\u5408\u6210\uFF08TTS\uFF09");\n};\n',
      "volcengine.ts": '/**\n * AirFlow AI\u4F9B\u5E94\u5546\u6A21\u677F - \u706B\u5C71\u5F15\u64CE(\u8C46\u5305)\n * @version 2.0\n */\n\n// ============================================================\n// \u7C7B\u578B\u5B9A\u4E49\n// ============================================================\n\ntype VideoMode =\n  | "singleImage"\n  | "startEndRequired"\n  | "endFrameOptional"\n  | "startFrameOptional"\n  | "text"\n  | (`videoReference:${number}` | `imageReference:${number}` | `audioReference:${number}`)[];\n\ninterface TextModel {\n  name: string;\n  modelName: string;\n  type: "text";\n  think: boolean;\n}\n\ninterface ImageModel {\n  name: string;\n  modelName: string;\n  type: "image";\n  mode: ("text" | "singleImage" | "multiReference")[];\n  associationSkills?: string;\n}\n\ninterface VideoModel {\n  name: string;\n  modelName: string;\n  type: "video";\n  mode: VideoMode[];\n  associationSkills?: string;\n  audio: "optional" | false | true;\n  durationResolutionMap: { duration: number[]; resolution: string[] }[];\n}\n\ninterface TTSModel {\n  name: string;\n  modelName: string;\n  type: "tts";\n  voices: { title: string; voice: string }[];\n}\n\ninterface VendorConfig {\n  id: string;\n  version: string;\n  name: string;\n  author: string;\n  description?: string;\n  icon?: string;\n  inputs: { key: string; label: string; type: "text" | "password" | "url"; required: boolean; placeholder?: string }[];\n  inputValues: Record<string, string>;\n  models: (TextModel | ImageModel | VideoModel | TTSModel)[];\n}\n\ntype ReferenceList =\n  | { type: "image"; sourceType: "base64"; base64: string }\n  | { type: "audio"; sourceType: "base64"; base64: string }\n  | { type: "video"; sourceType: "base64"; base64: string };\n\ninterface ImageConfig {\n  prompt: string;\n  referenceList?: Extract<ReferenceList, { type: "image" }>[];\n  size: "1K" | "2K" | "4K";\n  aspectRatio: `${number}:${number}`;\n}\n\ninterface VideoConfig {\n  duration: number;\n  resolution: string;\n  aspectRatio: "16:9" | "9:16";\n  prompt: string;\n  referenceList?: ReferenceList[];\n  audio?: boolean;\n  mode: VideoMode[];\n}\n\ninterface TTSConfig {\n  text: string;\n  voice: string;\n  speechRate: number;\n  pitchRate: number;\n  volume: number;\n  referenceList?: Extract<ReferenceList, { type: "audio" }>[];\n}\n\ninterface PollResult {\n  completed: boolean;\n  data?: string;\n  error?: string;\n}\n\n// ============================================================\n// \u5168\u5C40\u58F0\u660E\n// ============================================================\n\ndeclare const axios: any;\ndeclare const logger: (msg: string) => void;\ndeclare const jsonwebtoken: any;\ndeclare const zipImage: (base64: string, size: number) => Promise<string>;\ndeclare const zipImageResolution: (base64: string, w: number, h: number) => Promise<string>;\ndeclare const mergeImages: (base64Arr: string[], maxSize?: string) => Promise<string>;\ndeclare const urlToBase64: (url: string) => Promise<string>;\ndeclare const pollTask: (fn: () => Promise<PollResult>, interval?: number, timeout?: number) => Promise<PollResult>;\ndeclare const createOpenAI: any;\ndeclare const createDeepSeek: any;\ndeclare const createZhipu: any;\ndeclare const createQwen: any;\ndeclare const createAnthropic: any;\ndeclare const createOpenAICompatible: any;\ndeclare const createXai: any;\ndeclare const createMinimax: any;\ndeclare const createGoogleGenerativeAI: any;\ndeclare const exports: {\n  vendor: VendorConfig;\n  textRequest: (m: TextModel, t: boolean, tl: 0 | 1 | 2 | 3) => any;\n  imageRequest: (c: ImageConfig, m: ImageModel) => Promise<string>;\n  videoRequest: (c: VideoConfig, m: VideoModel) => Promise<string>;\n  ttsRequest: (c: TTSConfig, m: TTSModel) => Promise<string>;\n  checkForUpdates?: () => Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }>;\n  updateVendor?: () => Promise<string>;\n};\n\n// ============================================================\n// \u4F9B\u5E94\u5546\u914D\u7F6E\n// ============================================================\n\nconst vendor: VendorConfig = {\n  id: "volcengine",\n  version: "2.3",\n  author: "leeqi",\n  name: "\u706B\u5C71\u5F15\u64CE(\u8C46\u5305)",\n  description: "\u706B\u5C71\u5F15\u64CE\u8C46\u5305\u5927\u6A21\u578B\uFF0C\u652F\u6301\u6587\u672C\u3001\u56FE\u7247\u751F\u6210\u3001\u89C6\u9891\u751F\u6210\u7B49\u80FD\u529B\u3002\\n\\n\u9700\u8981\u5728[\u706B\u5C71\u5F15\u64CE\u63A7\u5236\u53F0](https://console.volcengine.com/ark)\u83B7\u53D6API\u5BC6\u94A5\u3002",\n  icon: "",\n  inputs: [\n    { key: "apiKey", label: "API\u5BC6\u94A5", type: "password", required: true, placeholder: "\u706B\u5C71\u5F15\u64CEAPI Key" },\n    { key: "baseUrl", label: "\u8BF7\u6C42\u5730\u5740", type: "url", required: true, placeholder: "\u4EE5v3\u7ED3\u675F\uFF0C\u793A\u4F8B\uFF1Ahttps://ark.cn-beijing.volces.com/api/v3" },\n  ],\n  inputValues: {\n    apiKey: "",\n    baseUrl: "https://ark.cn-beijing.volces.com/api/v3",\n  },\n  models: [\n    // ===================== \u6587\u672C\u6A21\u578B - \u63A8\u8350 =====================\n    { name: "Doubao-Seed-2.0-Pro", modelName: "doubao-seed-2-0-pro-260215", type: "text", think: true },\n    { name: "Doubao-Seed-2.0-Lite", modelName: "doubao-seed-2-0-lite-260215", type: "text", think: true },\n    { name: "Doubao-Seed-2.0-Mini", modelName: "doubao-seed-2-0-mini-260215", type: "text", think: true },\n    { name: "Doubao-Seed-2.0-Code-Preview", modelName: "doubao-seed-2-0-code-preview-260215", type: "text", think: true },\n    { name: "Doubao-Seed-Character", modelName: "doubao-seed-character-251128", type: "text", think: false },\n    // ===================== \u6587\u672C\u6A21\u578B - \u5F80\u671F =====================\n    { name: "Doubao-Seed-1.8", modelName: "doubao-seed-1-8-251228", type: "text", think: true },\n    { name: "Doubao-Seed-Code-Preview", modelName: "doubao-seed-code-preview-251028", type: "text", think: true },\n    { name: "Doubao-Seed-1.6-Lite", modelName: "doubao-seed-1-6-lite-251015", type: "text", think: true },\n    { name: "Doubao-Seed-1.6-Flash(0828)", modelName: "doubao-seed-1-6-flash-250828", type: "text", think: true },\n    { name: "Doubao-Seed-1.6-Vision", modelName: "doubao-seed-1-6-vision-250815", type: "text", think: true },\n    { name: "Doubao-Seed-1.6(1015)", modelName: "doubao-seed-1-6-251015", type: "text", think: true },\n    { name: "Doubao-Seed-1.6(0615)", modelName: "doubao-seed-1-6-250615", type: "text", think: true },\n    { name: "Doubao-Seed-1.6-Flash(0615)", modelName: "doubao-seed-1-6-flash-250615", type: "text", think: true },\n    { name: "Doubao-Seed-Translation", modelName: "doubao-seed-translation-250915", type: "text", think: false },\n    { name: "Doubao-1.5-Pro-32K", modelName: "doubao-1-5-pro-32k-250115", type: "text", think: false },\n    { name: "Doubao-1.5-Pro-32K-Character(0715)", modelName: "doubao-1-5-pro-32k-character-250715", type: "text", think: false },\n    { name: "Doubao-1.5-Pro-32K-Character(0228)", modelName: "doubao-1-5-pro-32k-character-250228", type: "text", think: false },\n    { name: "Doubao-1.5-Lite-32K", modelName: "doubao-1-5-lite-32k-250115", type: "text", think: false },\n    { name: "Doubao-1.5-Vision-Pro-32K", modelName: "doubao-1-5-vision-pro-32k-250115", type: "text", think: false },\n    // ===================== \u6587\u672C\u6A21\u578B - \u7B2C\u4E09\u65B9(\u706B\u5C71\u5F15\u64CE\u6258\u7BA1) =====================\n    { name: "GLM-4-7", modelName: "glm-4-7-251222", type: "text", think: true },\n    { name: "DeepSeek-V3-2", modelName: "deepseek-v3-2-251201", type: "text", think: true },\n    { name: "DeepSeek-V3-1-Terminus", modelName: "deepseek-v3-1-terminus", type: "text", think: true },\n    { name: "DeepSeek-V3(0324)", modelName: "deepseek-v3-250324", type: "text", think: false },\n    { name: "DeepSeek-R1(0528)", modelName: "deepseek-r1-250528", type: "text", think: true },\n    { name: "Qwen3-32B", modelName: "qwen3-32b-20250429", type: "text", think: false },\n    { name: "Qwen3-14B", modelName: "qwen3-14b-20250429", type: "text", think: false },\n    { name: "Qwen3-8B", modelName: "qwen3-8b-20250429", type: "text", think: false },\n    { name: "Qwen3-0.6B", modelName: "qwen3-0-6b-20250429", type: "text", think: false },\n    { name: "Qwen2.5-72B", modelName: "qwen2-5-72b-20240919", type: "text", think: false },\n    { name: "GLM-4.5-Air", modelName: "glm-4-5-air", type: "text", think: false },\n    // ===================== \u56FE\u7247\u751F\u6210\u6A21\u578B =====================\n    {\n      name: "Seedream-5.0",\n      modelName: "doubao-seedream-5-0-260128",\n      type: "image",\n      mode: ["text", "singleImage", "multiReference"],\n    },\n    {\n      name: "Seedream-5.0-Lite",\n      modelName: "doubao-seedream-5-0-lite-260128",\n      type: "image",\n      mode: ["text", "singleImage", "multiReference"],\n    },\n    {\n      name: "Seedream-4.5",\n      modelName: "doubao-seedream-4-5-251128",\n      type: "image",\n      mode: ["text", "singleImage", "multiReference"],\n    },\n    {\n      name: "Seedream-4.0",\n      modelName: "doubao-seedream-4-0-250828",\n      type: "image",\n      mode: ["text", "singleImage", "multiReference"],\n    },\n    {\n      name: "Seedream-3.0-T2I",\n      modelName: "doubao-seedream-3-0-t2i-250415",\n      type: "image",\n      mode: ["text"],\n    },\n    // ===================== \u89C6\u9891\u751F\u6210\u6A21\u578B =====================\n    {\n      name: "Seedance-2.0(\u97F3\u753B\u540C\u751F)",\n      modelName: "doubao-seedance-2-0-260128",\n      type: "video",\n      mode: ["text", "startFrameOptional", ["imageReference:9", "videoReference:3", "audioReference:3"]],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["480p", "720p"] }],\n    },\n    {\n      name: "Seedance-2.0-Fast(\u97F3\u753B\u540C\u751F)",\n      modelName: "doubao-seedance-2-0-fast-260128",\n      type: "video",\n      mode: ["text", "startFrameOptional", ["imageReference:9", "videoReference:3", "audioReference:3"]],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], resolution: ["480p", "720p"] }],\n    },\n    {\n      name: "Seedance-1.5-Pro(\u97F3\u753B\u540C\u751F)",\n      modelName: "doubao-seedance-1-5-pro-251215",\n      type: "video",\n      mode: ["text", "startFrameOptional"],\n      audio: "optional",\n      durationResolutionMap: [{ duration: [4, 5, 6, 7, 8, 9, 10, 11, 12], resolution: ["480p", "720p", "1080p"] }],\n    },\n    {\n      name: "Seedance-1.0-Pro",\n      modelName: "doubao-seedance-1-0-pro-250528",\n      type: "video",\n      mode: ["text", "startFrameOptional"],\n      audio: false,\n      durationResolutionMap: [{ duration: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], resolution: ["480p", "720p", "1080p"] }],\n    },\n    {\n      name: "Seedance-1.0-Pro-Fast",\n      modelName: "doubao-seedance-1-0-pro-fast-251015",\n      type: "video",\n      mode: ["text", "singleImage"],\n      audio: false,\n      durationResolutionMap: [{ duration: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], resolution: ["480p", "720p", "1080p"] }],\n    },\n    {\n      name: "Seedance-1.0-Lite-T2V",\n      modelName: "doubao-seedance-1-0-lite-t2v-250428",\n      type: "video",\n      mode: ["text"],\n      audio: false,\n      durationResolutionMap: [{ duration: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], resolution: ["480p", "720p", "1080p"] }],\n    },\n    {\n      name: "Seedance-1.0-Lite-I2V",\n      modelName: "doubao-seedance-1-0-lite-i2v-250428",\n      type: "video",\n      mode: ["startFrameOptional", ["imageReference:4"]],\n      audio: false,\n      durationResolutionMap: [{ duration: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], resolution: ["480p", "720p", "1080p"] }],\n    },\n  ],\n};\n\n// ============================================================\n// \u8F85\u52A9\u5DE5\u5177\n// ============================================================\n\nconst getHeaders = () => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  return {\n    "Content-Type": "application/json",\n    Authorization: `Bearer ${vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "")}`,\n  };\n};\n\nconst getBaseUrl = () => vendor.inputValues.baseUrl.replace(/\\/+$/, "");\n\n// ============================================================\n// \u9002\u914D\u5668\u51FD\u6570\n// ============================================================\n\nconst textRequest = (model: TextModel, think: boolean, thinkLevel: 0 | 1 | 2 | 3) => {\n  if (!vendor.inputValues.apiKey) throw new Error("\u7F3A\u5C11API Key");\n  const apiKey = vendor.inputValues.apiKey.replace(/^Bearer\\s+/i, "");\n\n  const effortMap: Record<number, string> = {\n    0: "minimal",\n    1: "low",\n    2: "medium",\n    3: "high",\n  };\n\n  return createOpenAICompatible({\n    name: "volcengine",\n    baseURL: getBaseUrl(),\n    apiKey,\n    fetch: async (url: string, options?: RequestInit) => {\n      const rawBody = JSON.parse((options?.body as string) ?? "{}");\n      const modifiedBody = {\n        ...rawBody,\n        thinking: {\n          type: "enabled",\n        },\n        reasoning_effort: effortMap[thinkLevel],\n      };\n      return await fetch(url, {\n        ...options,\n        body: JSON.stringify(modifiedBody),\n      });\n    },\n  }).chatModel(model.modelName);\n};\n\nconst imageRequest = async (config: ImageConfig, model: ImageModel): Promise<string> => {\n  const baseUrl = getBaseUrl();\n  const headers = getHeaders();\n\n  const body: any = {\n    model: model.modelName,\n    prompt: config.prompt || "",\n    response_format: "url",\n    watermark: false,\n  };\n\n  const isOldModel = model.modelName.includes("seedream-3-0");\n  const is5Lite = model.modelName.includes("seedream-5-0-lite");\n\n  // sequential_image_generation \u4EC5 seedream 5.0-lite/4.5/4.0 \u652F\u6301\n  if (!isOldModel) {\n    body.sequential_image_generation = "disabled";\n  }\n\n  // \u53C2\u8003\u56FE\u7247\uFF1A\u5355\u56FE\u4E3A string\uFF0C\u591A\u56FE\u4E3A array\uFF08seedream-3.0-t2i \u4E0D\u652F\u6301 image \u53C2\u6570\uFF09\n  if (!isOldModel && config.referenceList && config.referenceList.length > 0) {\n    const images = config.referenceList.map((ref) => ref.base64);\n    body.image = images.length === 1 ? images[0] : images;\n  }\n\n  // \u5C3A\u5BF8\u5904\u7406\uFF1A\u4F18\u5148\u4F7F\u7528\u63A8\u8350\u50CF\u7D20\u503C\uFF0C\u672A\u5339\u914D\u5219\u76F4\u63A5\u4F20\u5206\u8FA8\u7387\u5B57\u7B26\u4E32\u8BA9\u6A21\u578B\u81EA\u884C\u51B3\u5B9A\n  const [w, h] = config.aspectRatio.split(":").map(Number);\n  const sizeTable: Record<string, Record<string, string>> = {\n    "1K": {\n      "1:1": "1024x1024",\n      "4:3": "1152x864",\n      "3:4": "864x1152",\n      "16:9": "1280x720",\n      "9:16": "720x1280",\n      "3:2": "1248x832",\n      "2:3": "832x1248",\n      "21:9": "1512x648",\n    },\n    "2K": {\n      "1:1": "2048x2048",\n      "4:3": "2304x1728",\n      "3:4": "1728x2304",\n      "16:9": "2848x1600",\n      "9:16": "1600x2848",\n      "3:2": "2496x1664",\n      "2:3": "1664x2496",\n      "21:9": "3136x1344",\n    },\n    "4K": {\n      "1:1": "4096x4096",\n      "4:3": "4704x3520",\n      "3:4": "3520x4704",\n      "16:9": "5504x3040",\n      "9:16": "3040x5504",\n      "3:2": "4992x3328",\n      "2:3": "3328x4992",\n      "21:9": "6240x2656",\n    },\n  };\n\n  const sizeKey = config.size || "2K";\n  const ratioKey = config.aspectRatio;\n  const table = sizeTable[sizeKey];\n\n  if (table && table[ratioKey]) {\n    // \u63A8\u8350\u50CF\u7D20\u503C\u5339\u914D\u5230\u4E86\uFF0C\u4F46\u9700\u8981\u68C0\u67E5\u662F\u5426\u6EE1\u8DB3\u6A21\u578B\u6700\u4F4E\u50CF\u7D20\u8981\u6C42\n    const [pw, ph] = table[ratioKey].split("x").map(Number);\n    const totalPixels = pw * ph;\n    if (isOldModel) {\n      // seedream-3.0-t2i: \u50CF\u7D20\u8303\u56F4 [512x512, 2048x2048]\n      body.size = table[ratioKey];\n    } else if (totalPixels < 3686400) {\n      // 1K \u50CF\u7D20\u503C\u4E0D\u6EE1\u8DB3\u65B0\u6A21\u578B\u6700\u4F4E\u8981\u6C42\uFF0C\u76F4\u63A5\u4F20 "2K" \u8BA9\u6A21\u578B\u81EA\u884C\u51B3\u5B9A\n      body.size = "2K";\n    } else if (is5Lite && totalPixels > 10404496) {\n      // seedream-5.0-lite \u6700\u9AD8 10404496\uFF0C4K \u8D85\u9650\uFF0C\u56DE\u9000\u4F20 "2K"\n      body.size = "2K";\n    } else {\n      body.size = table[ratioKey];\n    }\n  } else if (isOldModel) {\n    // seedream-3.0-t2i: \u50CF\u7D20\u8303\u56F4 [512x512, 2048x2048]\uFF0C\u76F4\u63A5\u6309\u6BD4\u4F8B\u8BA1\u7B97\n    const base = sizeKey === "1K" ? 1024 : 2048;\n    const calcW = Math.min(2048, Math.round(base * Math.sqrt(w / h)));\n    const calcH = Math.min(2048, Math.round(base * Math.sqrt(h / w)));\n    body.size = `${Math.max(512, calcW)}x${Math.max(512, calcH)}`;\n  } else {\n    // \u65B0\u6A21\u578B\u672A\u5339\u914D\u63A8\u8350\u503C\u65F6\uFF0C\u76F4\u63A5\u4F20\u5206\u8FA8\u7387\u5B57\u7B26\u4E32\uFF08\u65B9\u5F0F1\uFF09\uFF0C\u7531\u6A21\u578B\u6839\u636E prompt \u81EA\u884C\u51B3\u5B9A\u5C3A\u5BF8\n    // seedream 5.0-lite \u652F\u6301 "2K"/"3K"\uFF0Cseedream 4.5 \u652F\u6301 "2K"/"4K"\uFF0Cseedream 4.0 \u652F\u6301 "1K"/"2K"/"4K"\n    if (is5Lite) {\n      body.size = sizeKey === "4K" ? "3K" : sizeKey === "1K" ? "2K" : sizeKey;\n    } else {\n      body.size = sizeKey === "1K" ? "2K" : sizeKey;\n    }\n  }\n\n  logger(`[\u56FE\u7247\u751F\u6210] \u8BF7\u6C42\u6A21\u578B: ${model.modelName}, \u5C3A\u5BF8: ${body.size}`);\n\n  const response = await axios.post(`${baseUrl}/images/generations`, body, { headers });\n  const data = response.data;\n\n  if (data?.error) {\n    throw new Error(`\u56FE\u7247\u751F\u6210\u5931\u8D25\uFF1A${data.error.message || data.error.code}`);\n  }\n\n  // \u4ECE data \u6570\u7EC4\u4E2D\u63D0\u53D6\u7B2C\u4E00\u5F20\u6210\u529F\u7684\u56FE\u7247\n  if (data?.data && data.data.length > 0) {\n    for (const item of data.data) {\n      if (item.url) {\n        return await urlToBase64(item.url);\n      }\n      if (item.b64_json) {\n        return item.b64_json;\n      }\n      if (item.error) {\n        throw new Error(`\u56FE\u7247\u751F\u6210\u5931\u8D25\uFF1A${item.error.message || item.error.code}`);\n      }\n    }\n  }\n\n  throw new Error("\u56FE\u7247\u751F\u6210\u5931\u8D25\uFF1A\u672A\u8FD4\u56DE\u6709\u6548\u7ED3\u679C");\n};\n\nconst videoRequest = async (config: VideoConfig, model: VideoModel): Promise<string> => {\n  const baseUrl = getBaseUrl();\n  const headers = getHeaders();\n\n  const content: any[] = [];\n\n  if (config.prompt) {\n    content.push({ type: "text", text: config.prompt });\n  }\n\n  if (typeof config.mode === "string") {\n    switch (config.mode) {\n      case "singleImage": {\n        const firstImage = config.referenceList?.find((r) => r.type === "image");\n        if (firstImage) {\n          content.push({\n            type: "image_url",\n            image_url: { url: firstImage.base64 },\n            role: "first_frame",\n          });\n        }\n        break;\n      }\n      case "startFrameOptional": {\n        const images = config.referenceList?.filter((r) => r.type === "image") ?? [];\n        if (images.length > 0) {\n          content.push({\n            type: "image_url",\n            image_url: { url: images[0].base64 },\n            role: "first_frame",\n          });\n          if (images.length > 1) {\n            content.push({\n              type: "image_url",\n              image_url: { url: images[1].base64 },\n              role: "last_frame",\n            });\n          }\n        }\n        break;\n      }\n      case "startEndRequired": {\n        const images = config.referenceList?.filter((r) => r.type === "image") ?? [];\n        if (images.length >= 2) {\n          content.push({\n            type: "image_url",\n            image_url: { url: images[0].base64 },\n            role: "first_frame",\n          });\n          content.push({\n            type: "image_url",\n            image_url: { url: images[1].base64 },\n            role: "last_frame",\n          });\n        }\n        break;\n      }\n      case "endFrameOptional": {\n        const images = config.referenceList?.filter((r) => r.type === "image") ?? [];\n        if (images.length > 0) {\n          content.push({\n            type: "image_url",\n            image_url: { url: images[0].base64 },\n            role: "first_frame",\n          });\n          if (images.length > 1) {\n            content.push({\n              type: "image_url",\n              image_url: { url: images[1].base64 },\n              role: "last_frame",\n            });\n          }\n        }\n        break;\n      }\n      case "text":\n      default:\n        break;\n    }\n  } else if (Array.isArray(config.mode)) {\n    // \u591A\u6A21\u6001\u53C2\u8003\u6A21\u5F0F\uFF1A\u6309\u7C7B\u578B\u5206\u522B\u63D0\u53D6\u5E76\u6DFB\u52A0\n    const imageRefs = config.referenceList?.filter((r) => r.type === "image") ?? [];\n    const videoRefs = config.referenceList?.filter((r) => r.type === "video") ?? [];\n    const audioRefs = config.referenceList?.filter((r) => r.type === "audio") ?? [];\n\n    for (const refDef of config.mode) {\n      if (typeof refDef === "string") {\n        if (refDef.startsWith("imageReference:")) {\n          const maxCount = parseInt(refDef.split(":")[1], 10);\n          for (const ref of imageRefs.slice(0, maxCount)) {\n            content.push({\n              type: "image_url",\n              image_url: { url: ref.base64 },\n              role: "reference_image",\n            });\n          }\n        } else if (refDef.startsWith("videoReference:")) {\n          const maxCount = parseInt(refDef.split(":")[1], 10);\n          for (const ref of videoRefs.slice(0, maxCount)) {\n            content.push({\n              type: "video_url",\n              video_url: { url: ref.base64 },\n              role: "reference_video",\n            });\n          }\n        } else if (refDef.startsWith("audioReference:")) {\n          const maxCount = parseInt(refDef.split(":")[1], 10);\n          for (const ref of audioRefs.slice(0, maxCount)) {\n            content.push({\n              type: "audio_url",\n              audio_url: { url: ref.base64 },\n              role: "reference_audio",\n            });\n          }\n        }\n      }\n    }\n  }\n\n  const body: any = {\n    model: model.modelName,\n    content,\n    ratio: config.aspectRatio,\n    duration: config.duration,\n    resolution: config.resolution || "720p",\n    watermark: false,\n  };\n\n  if (model.audio === "optional") {\n    body.generate_audio = config.audio !== false;\n  } else if (model.audio === true) {\n    body.generate_audio = true;\n  } else {\n    body.generate_audio = false;\n  }\n\n  logger(`[\u89C6\u9891\u751F\u6210] \u63D0\u4EA4\u4EFB\u52A1, \u6A21\u578B: ${model.modelName}, \u65F6\u957F: ${config.duration}s, \u5206\u8FA8\u7387: ${config.resolution}`);\n\n  const createResponse = await axios.post(`${baseUrl}/contents/generations/tasks`, body, { headers });\n  const taskId = createResponse.data?.id;\n\n  if (!taskId) {\n    throw new Error("\u89C6\u9891\u751F\u6210\u4EFB\u52A1\u521B\u5EFA\u5931\u8D25\uFF1A\u672A\u8FD4\u56DE\u4EFB\u52A1ID");\n  }\n\n  logger(`[\u89C6\u9891\u751F\u6210] \u4EFB\u52A1\u5DF2\u521B\u5EFA, ID: ${taskId}`);\n\n  const result = await pollTask(\n    async (): Promise<PollResult> => {\n      const queryResponse = await axios.get(`${baseUrl}/contents/generations/tasks/${taskId}`, { headers });\n      const task = queryResponse.data;\n\n      logger(`[\u89C6\u9891\u751F\u6210] \u4EFB\u52A1\u72B6\u6001: ${task.status}`);\n\n      switch (task.status) {\n        case "succeeded":\n          if (task.content?.video_url) {\n            return { completed: true, data: task.content.video_url };\n          }\n          return { completed: true, error: "\u4EFB\u52A1\u6210\u529F\u4F46\u672A\u8FD4\u56DE\u89C6\u9891URL" };\n        case "failed":\n          return { completed: true, error: task.error?.message || "\u89C6\u9891\u751F\u6210\u5931\u8D25" };\n        case "expired":\n          return { completed: true, error: "\u89C6\u9891\u751F\u6210\u4EFB\u52A1\u8D85\u65F6" };\n        case "cancelled":\n          return { completed: true, error: "\u89C6\u9891\u751F\u6210\u4EFB\u52A1\u5DF2\u53D6\u6D88" };\n        default:\n          return { completed: false };\n      }\n    },\n    10000,\n    600000 * 3,\n  );\n\n  if (result.error) {\n    throw new Error(result.error);\n  }\n\n  return await urlToBase64(result.data!);\n};\n\nconst ttsRequest = async (config: TTSConfig, model: TTSModel): Promise<string> => {\n  return "";\n};\n\nconst checkForUpdates = async (): Promise<{ hasUpdate: boolean; latestVersion: string; notice: string }> => {\n  return { hasUpdate: false, latestVersion: "2.0", notice: "" };\n};\n\nconst updateVendor = async (): Promise<string> => {\n  return "";\n};\n\n// ============================================================\n// \u5BFC\u51FA\n// ============================================================\n\nexports.vendor = vendor;\nexports.textRequest = textRequest;\nexports.imageRequest = imageRequest;\nexports.videoRequest = videoRequest;\nexports.ttsRequest = ttsRequest;\nexports.checkForUpdates = checkForUpdates;\nexports.updateVendor = updateVendor;\n\nexport {};\n'
    };
  }
});

// src/lib/password.ts
function isHashedPassword(password) {
  return Boolean(password?.startsWith(`${PASSWORD_PREFIX}$`));
}
async function hashPassword(password) {
  const salt = import_crypto2.default.randomBytes(16).toString("hex");
  const key = await scryptAsync(password, salt, KEY_LENGTH);
  return `${PASSWORD_PREFIX}$${salt}$${key.toString("hex")}`;
}
async function verifyPassword(input, stored) {
  if (!stored) return false;
  if (!isHashedPassword(stored)) return input === stored;
  const [, salt, storedKey] = stored.split("$");
  if (!salt || !storedKey) return false;
  const inputKey = await scryptAsync(input, salt, KEY_LENGTH);
  const storedBuffer = Buffer.from(storedKey, "hex");
  if (inputKey.length !== storedBuffer.length) return false;
  return import_crypto2.default.timingSafeEqual(inputKey, storedBuffer);
}
var import_crypto2, import_util, scryptAsync, PASSWORD_PREFIX, KEY_LENGTH;
var init_password = __esm({
  "src/lib/password.ts"() {
    "use strict";
    import_crypto2 = __toESM(require("crypto"));
    import_util = require("util");
    scryptAsync = (0, import_util.promisify)(import_crypto2.default.scrypt);
    PASSWORD_PREFIX = "scrypt";
    KEY_LENGTH = 64;
  }
});

// src/lib/fixDB.ts
async function tempOnsert(tsCode) {
  const jsCode = (0, import_sucrase.transform)(tsCode, { transforms: ["typescript"] }).code;
  const exports2 = utils_default.vm(jsCode);
  const vendor = exports2.vendor;
  const data = await db_default("o_vendorConfig").where("id", vendor.id).first();
  if (data) return;
  await db_default("o_vendorConfig").insert({
    id: vendor.id,
    inputValues: JSON.stringify(vendor.inputValues ?? {}),
    models: JSON.stringify([]),
    enable: vendor.id == "toonflow" ? 1 : 0
  });
  utils_default.vendor.writeCode(vendor.id, tsCode);
}
var import_path4, import_fs2, import_sucrase, vendorData, fixDB_default;
var init_fixDB = __esm({
  "src/lib/fixDB.ts"() {
    "use strict";
    init_utils3();
    import_path4 = __toESM(require("path"));
    import_fs2 = __toESM(require("fs"));
    init_db();
    import_sucrase = __toESM(require_dist5());
    init_vendor();
    init_password();
    vendorData = vendor_default;
    fixDB_default = async (knex3) => {
      const addColumn = async (table, column, type) => {
        if (!await knex3.schema.hasTable(table)) return;
        if (!await knex3.schema.hasColumn(table, column)) {
          await knex3.schema.alterTable(table, (t) => t[type](column));
        }
      };
      const dropColumn = async (table, column) => {
        if (!await knex3.schema.hasTable(table)) return;
        if (await knex3.schema.hasColumn(table, column)) {
          await knex3.schema.alterTable(table, (t) => t.dropColumn(column));
        }
      };
      const alterColumnType = async (table, column, type) => {
        if (!await knex3.schema.hasTable(table)) return;
        if (await knex3.schema.hasColumn(table, column)) {
          await knex3.schema.alterTable(table, (t) => {
            t[type](column).alter();
          });
        }
      };
      await db_default("o_novel").where("eventState", 0).update({
        eventState: -1,
        errorReason: "\u8F6F\u4EF6\u9000\u51FA\u5BFC\u81F4\u5931\u8D25"
      });
      await db_default("o_script").where("extractState", 0).update({
        extractState: -1,
        errorReason: "\u8F6F\u4EF6\u9000\u51FA\u5BFC\u81F4\u5931\u8D25"
      });
      await db_default("o_assets").where("promptState", "\u751F\u6210\u4E2D").update({
        promptState: "\u751F\u6210\u5931\u8D25",
        promptErrorReason: "\u8F6F\u4EF6\u9000\u51FA\u5BFC\u81F4\u5931\u8D25"
      });
      await db_default("o_image").where("state", "\u751F\u6210\u4E2D").update({
        state: "\u751F\u6210\u5931\u8D25",
        errorReason: "\u8F6F\u4EF6\u9000\u51FA\u5BFC\u81F4\u5931\u8D25"
      });
      await db_default("o_storyboard").where("state", "\u751F\u6210\u4E2D").update({
        state: "\u751F\u6210\u5931\u8D25",
        reason: "\u8F6F\u4EF6\u9000\u51FA\u5BFC\u81F4\u5931\u8D25"
      });
      await db_default("o_video").where("state", "\u751F\u6210\u4E2D").update({
        state: "\u751F\u6210\u5931\u8D25",
        errorReason: "\u8F6F\u4EF6\u9000\u51FA\u5BFC\u81F4\u5931\u8D25"
      });
      if (await knex3.schema.hasTable("o_user")) {
        await addColumn("o_user", "phone", "text");
        const adminUser = await db_default("o_user").where("id", 1).first();
        if (!adminUser) {
          await db_default("o_user").insert({ id: 1, name: "admin", password: await hashPassword("admin123") });
        }
        const users = await db_default("o_user").select("id", "password");
        for (const user of users) {
          if (user.password && !isHashedPassword(user.password)) {
            await db_default("o_user").where("id", user.id).update({ password: await hashPassword(user.password) });
          }
        }
        try {
          await knex3.raw("CREATE UNIQUE INDEX IF NOT EXISTS idx_o_user_name_unique ON o_user(name)");
          await knex3.raw("CREATE UNIQUE INDEX IF NOT EXISTS idx_o_user_phone_unique ON o_user(phone) WHERE phone IS NOT NULL AND phone != ''");
        } catch (err) {
          console.warn("[DB] \u521B\u5EFA\u7528\u6237\u552F\u4E00\u7D22\u5F15\u5931\u8D25:", utils_default.error(err).message);
        }
      }
      if (!await knex3.schema.hasTable("o_smsCode")) {
        await knex3.schema.createTable("o_smsCode", (table) => {
          table.integer("id").notNullable();
          table.text("phone").notNullable();
          table.text("purpose").notNullable();
          table.text("codeHash").notNullable();
          table.integer("expiresAt").notNullable();
          table.integer("used").defaultTo(0);
          table.integer("attempts").defaultTo(0);
          table.integer("createTime").notNullable();
          table.integer("sentAt").notNullable();
          table.primary(["id"]);
          table.unique(["id"]);
        });
      }
      if (!await knex3.schema.hasTable("o_userVendorConfig")) {
        await knex3.schema.createTable("o_userVendorConfig", (table) => {
          table.integer("userId").notNullable();
          table.string("vendorId").notNullable();
          table.text("inputValues");
          table.text("models");
          table.integer("enable");
          table.primary(["userId", "vendorId"]);
        });
      }
      if (!await knex3.schema.hasTable("o_userAgentDeploy")) {
        await knex3.schema.createTable("o_userAgentDeploy", (table) => {
          table.integer("userId").notNullable();
          table.string("key").notNullable();
          table.string("model");
          table.string("modelName");
          table.text("vendorId");
          table.integer("temperature");
          table.integer("maxOutputTokens");
          table.boolean("disabled").defaultTo(false);
          table.primary(["userId", "key"]);
        });
      }
      if (!await knex3.schema.hasTable("o_userSetting")) {
        await knex3.schema.createTable("o_userSetting", (table) => {
          table.integer("userId").notNullable();
          table.string("key").notNullable();
          table.text("value");
          table.primary(["userId", "key"]);
        });
      }
      if (!await knex3.schema.hasTable("o_userPrompt")) {
        await knex3.schema.createTable("o_userPrompt", (table) => {
          table.integer("userId").notNullable();
          table.integer("promptId").notNullable();
          table.text("useData");
          table.primary(["userId", "promptId"]);
        });
      }
      if (!await knex3.schema.hasTable("o_userModelPrompt")) {
        await knex3.schema.createTable("o_userModelPrompt", (table) => {
          table.integer("userId").notNullable();
          table.text("vendorId").notNullable();
          table.text("model").notNullable();
          table.string("fileName");
          table.text("path");
          table.primary(["userId", "vendorId", "model"]);
        });
      }
      await addColumn("o_project", "userId", "integer");
      if (await knex3.schema.hasTable("o_project") && await knex3.schema.hasColumn("o_project", "userId")) {
        await db_default("o_project").whereNull("userId").orWhere("userId", 0).update({ userId: 1 });
      }
      await addColumn("o_prompt", "useData", "text");
      await addColumn("o_agentDeploy", "type", "string");
      await addColumn("o_agentDeploy", "temperature", "integer");
      await addColumn("o_agentDeploy", "maxOutputTokens", "integer");
      await addColumn("o_assets", "audioBindState", "integer");
      await addColumn("o_modelPrompt", "fileName", "string");
      await addColumn("o_modelPrompt", "path", "string");
      const userVendorRows = await db_default("o_userVendorConfig").count({ count: "*" });
      if (Number(userVendorRows[0]?.count ?? 0) === 0) {
        const vendorConfigs = await db_default("o_vendorConfig").select("*");
        for (const vendor of vendorConfigs) {
          if (!vendor.id) continue;
          await db_default("o_userVendorConfig").insert({
            userId: 1,
            vendorId: vendor.id,
            inputValues: vendor.inputValues ?? "{}",
            models: vendor.models ?? "[]",
            enable: vendor.enable ?? 0
          });
        }
      }
      await db_default("o_vendorConfig").update({ inputValues: "{}" });
      const userPromptRows = await db_default("o_userPrompt").count({ count: "*" });
      if (Number(userPromptRows[0]?.count ?? 0) === 0) {
        const prompts = await db_default("o_prompt").whereNotNull("useData").select("id", "useData");
        for (const prompt of prompts) {
          if (!prompt.id || !prompt.useData) continue;
          await db_default("o_userPrompt").insert({ userId: 1, promptId: prompt.id, useData: prompt.useData });
        }
        await db_default("o_prompt").update({ useData: null });
      }
      const userModelPromptRows = await db_default("o_userModelPrompt").count({ count: "*" });
      if (Number(userModelPromptRows[0]?.count ?? 0) === 0) {
        const modelPrompts = await db_default("o_modelPrompt").select("vendorId", "model", "fileName", "path");
        for (const item of modelPrompts) {
          if (!item.vendorId || !item.model) continue;
          await db_default("o_userModelPrompt").insert({
            userId: 1,
            vendorId: item.vendorId,
            model: item.model,
            fileName: item.fileName,
            path: item.path
          });
        }
      }
      const vendorDataSelect = await db_default("o_vendorConfig").whereIn("id", ["deepseek", "atlascloud"]).select("*");
      if (!vendorDataSelect.find((i) => i.id == "deepseek")) {
        await db_default("o_vendorConfig").insert({
          id: "deepseek",
          inputValues: "{}",
          models: "[]",
          enable: 0
        });
      }
      if (!vendorDataSelect.find((i) => i.id == "atlascloud")) {
        await db_default("o_vendorConfig").insert({
          id: "atlascloud",
          inputValues: "{}",
          models: "[]",
          enable: 0
        });
      }
      const existAudioPrompt = await db_default("o_prompt").where("type", "audioBindPrompt").first();
      if (!existAudioPrompt)
        await db_default("o_prompt").insert({
          name: "\u97F3\u8272\u7ED1\u5B9A",
          type: "audioBindPrompt",
          data: `\u4F60\u662F\u4E00\u4E2A\u97F3\u8272\u5339\u914D\u52A9\u624B\u3002
\u4F60\u7684\u4EFB\u52A1\u662F\uFF1A\u6839\u636E\u7ED9\u5B9A\u89D2\u8272\u8D44\u4EA7\u7684\u540D\u79F0\u4E0E\u63CF\u8FF0\uFF0C\u4ECE\u5019\u9009\u97F3\u9891\u5217\u8868\u4E2D\u9009\u51FA\u6700\u5408\u9002\u7684\u97F3\u8272\u3002
\u5339\u914D\u89C4\u5219\uFF1A
1. \u4F18\u5148\u6839\u636E\u89D2\u8272\u6027\u522B\u3001\u5E74\u9F84\u3001\u6027\u683C\u7B49\u7279\u5F81\u4E0E\u97F3\u8272\u63CF\u8FF0\u8FDB\u884C\u8BED\u4E49\u5339\u914D\uFF1B
2. \u540C\u4E00\u89D2\u8272\u4EC5\u53EF\u5339\u914D\u4E00\u4E2A\u97F3\u8272\uFF1B
3. \u82E5\u5019\u9009\u5217\u8868\u4E2D\u6CA1\u6709\u5408\u9002\u7684\u97F3\u8272\uFF0C\u5219\u65E0\u9700\u8FD4\u56DE audioId\uFF1B`
        });
      const agentUserMode = await db_default("o_setting").where("key", "agentUseMode").first();
      if (!agentUserMode) {
        const allDeployData = await db_default("o_agentDeploy").leftJoin("o_vendorConfig", "o_vendorConfig.id", "o_agentDeploy.vendorId").select("o_agentDeploy.*");
        const advancedData = allDeployData.filter((item) => item.key?.includes(":"));
        const notValModelData = advancedData.filter((item) => !item.modelName);
        await db_default("o_setting").insert({
          key: "agentUseMode",
          value: notValModelData.length ? "0" : "1"
        });
      }
      const advancedAgentList = [
        { key: "scriptAgent:decisionAgent", name: "\u5267\u672CAgent:\u51B3\u7B56\u5C42", desc: "\u51B3\u7B56\u5C42" },
        { key: "scriptAgent:supervisionAgent", name: "\u5267\u672CAgent:\u76D1\u7763\u5C42", desc: "\u76D1\u7763\u5C42" },
        { key: "scriptAgent:storySkeletonAgent", name: "\u5267\u672CAgent:\u6545\u4E8B\u9AA8\u67B6", desc: "\u6545\u4E8B\u9AA8\u67B6\u751F\u6210" },
        { key: "scriptAgent:adaptationStrategyAgent", name: "\u5267\u672CAgent:\u6539\u7F16\u7B56\u7565", desc: "\u6539\u7F16\u7B56\u7565\u751F\u6210" },
        { key: "scriptAgent:scriptAgent", name: "\u5267\u672CAgent:\u5267\u672C\u751F\u6210", desc: "\u5267\u672C\u751F\u6210" },
        { key: "productionAgent:decisionAgent", name: "\u751F\u4EA7Agent:\u51B3\u7B56\u5C42", desc: "\u51B3\u7B56\u5C42" },
        { key: "productionAgent:supervisionAgent", name: "\u751F\u4EA7Agent:\u76D1\u7763\u5C42", desc: "\u76D1\u7763\u5C42" },
        { key: "productionAgent:deriveAssetsAgent", name: "\u751F\u4EA7Agent:\u884D\u751F\u8D44\u4EA7", desc: "\u884D\u751F\u8D44\u4EA7" },
        { key: "productionAgent:generateAssetsAgent", name: "\u751F\u4EA7Agent:\u751F\u6210\u8D44\u4EA7", desc: "\u751F\u6210\u8D44\u4EA7" },
        { key: "productionAgent:directorPlanAgent", name: "\u751F\u4EA7Agent:\u5BFC\u6F14\u89C4\u5212", desc: "\u5BFC\u6F14\u89C4\u5212" },
        { key: "productionAgent:storyboardGenAgent", name: "\u751F\u4EA7Agent:\u5206\u955C\u751F\u6210", desc: "\u5206\u955C\u751F\u6210" },
        { key: "productionAgent:storyboardPanelAgent", name: "\u751F\u4EA7Agent:\u5206\u955C\u9762\u677F", desc: "\u5206\u955C\u9762\u677F\u751F\u6210" },
        { key: "productionAgent:storyboardTableAgent", name: "\u751F\u4EA7Agent:\u5206\u955C\u8868\u683C", desc: "\u5206\u955C\u8868\u683C\u751F\u6210" }
      ];
      for (const agent of advancedAgentList) {
        const exists = await db_default("o_agentDeploy").where("key", agent.key).select("*").first();
        if (!exists) {
          await db_default("o_agentDeploy").insert({
            model: "",
            modelName: "",
            vendorId: null,
            key: agent.key,
            name: agent.name,
            desc: agent.desc,
            temperature: 1,
            maxOutputTokens: 0,
            disabled: false
          });
        }
      }
      await db_default("o_prompt").where("type", "scriptAssetExtraction").update({
        data: `---
name: universal_agent
description: \u4E13\u6CE8\u4E8E\u4ECE\u5267\u672C\u5185\u5BB9\u4E2D\u63D0\u53D6\u6240\u4F7F\u7528\u7684\u8D44\u4EA7\uFF08\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177\uFF09\u5E76\u751F\u6210\u7ED3\u6784\u5316\u8D44\u4EA7\u5217\u8868\u7684\u52A9\u624B\u3002
---

# Script Assets Extract

\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684\u5267\u672C\u5185\u5BB9\u5206\u6790\u52A9\u624B\uFF0C\u4E13\u6CE8\u4E8E\u4ECE\u5267\u672C\u6587\u672C\u4E2D\u8BC6\u522B\u548C\u63D0\u53D6\u6240\u6709\u6D89\u53CA\u7684\u8D44\u4EA7\uFF08\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177\uFF09\uFF0C\u5E76\u4E3A\u6BCF\u9879\u8D44\u4EA7\u751F\u6210\u53EF\u4F9B\u4E0B\u6E38\u5236\u4F5C\u6D41\u7A0B\u4F7F\u7528\u7684\u7ED3\u6784\u5316\u63CF\u8FF0\u548C\u63D0\u793A\u8BCD\u3002

## \u4F55\u65F6\u4F7F\u7528

\u7528\u6237\u63D0\u4F9B\u5267\u672C\u5185\u5BB9\uFF0C\u4F60\u9700\u8981\u9010\u6BB5\u9605\u8BFB\u5E76\u63D0\u53D6\u5176\u4E2D\u6D89\u53CA\u7684\u6240\u6709\u8D44\u4EA7\uFF08\u4EBA\u7269\u89D2\u8272\u3001\u573A\u666F\u5730\u70B9\u3001\u9053\u5177\u7269\u4EF6\uFF09\uFF0C\u8F93\u51FA\u4E3A\u7ED3\u6784\u5316\u7684\u8D44\u4EA7\u5217\u8868\u3002\u4EA7\u51FA\u7684\u8D44\u4EA7\u63CF\u8FF0\u5C06\u7528\u4E8E\u540E\u7EED AI \u56FE\u7247\u751F\u6210\u548C\u5236\u4F5C\u6D41\u7A0B\u3002

## \u4E0E\u7CFB\u7EDF\u7684\u5BF9\u5E94\u5173\u7CFB

- \u8D44\u4EA7\u7C7B\u578B\uFF1A
  - \`role\` \u2014 \u89D2\u8272\uFF08\u5BF9\u5E94 \`o_assets.type = "role"\`\uFF09
  - \`scene\` \u2014 \u573A\u666F\uFF08\u5BF9\u5E94 \`o_assets.type = "scene"\`\uFF09
  - \`tool\` \u2014 \u9053\u5177\uFF08\u5BF9\u5E94 \`o_assets.type = "tool"\`\uFF09
- \u4E0B\u6E38\u7528\u9014\uFF1A\u8D44\u4EA7\u63D0\u793A\u8BCD\u751F\u6210 \u2192 AI \u8D44\u4EA7\u56FE\u751F\u6210 \u2192 \u5206\u955C\u5236\u4F5C

## \u8F93\u51FA\u8981\u6C42

**\u5FC5\u987B\u901A\u8FC7\u8C03\u7528 \`resultTool\` \u5DE5\u5177\u8FD4\u56DE\u7ED3\u679C**\uFF0C\u7981\u6B62\u4EE5\u7EAF\u6587\u672C\u3001Markdown \u8868\u683C\u6216 JSON \u4EE3\u7801\u5757\u7B49\u5F62\u5F0F\u76F4\u63A5\u8F93\u51FA\u8D44\u4EA7\u5217\u8868\u3002
\`resultTool\` \u7684 schema \u4F1A\u5BF9\u5B57\u6BB5\u7C7B\u578B\u548C\u679A\u4E3E\u503C\u505A\u5F3A\u6821\u9A8C\uFF0C\u8C03\u7528\u65F6\u8BF7\u4E25\u683C\u6309\u7167\u4E0B\u65B9\u5B57\u6BB5\u5B9A\u4E49\u586B\u5199\uFF0C\u786E\u4FDD\u6570\u636E\u7ED3\u6784\u6B63\u786E\u3001\u5B57\u6BB5\u5B8C\u6574\u3001\u7C7B\u578B\u5339\u914D\u3002

\u6BCF\u4E2A\u8D44\u4EA7\u5BF9\u8C61\u5305\u542B\u4EE5\u4E0B\u5B57\u6BB5\uFF1A

| \u5B57\u6BB5 | \u7C7B\u578B | \u5FC5\u586B | \u8BF4\u660E |
| ---- | ---- | ---- | ---- |
| \`name\` | string | \u662F | \u8D44\u4EA7\u540D\u79F0\uFF0C\u4F7F\u7528\u5267\u672C\u4E2D\u7684\u539F\u59CB\u79F0\u547C,\u4E0D\u505A\u5176\u4ED6\u591A\u4F59\u63CF\u8FF0 |
| \`desc\` | string | \u662F | \u8D44\u4EA7\u63CF\u8FF0\uFF0C30-80 \u5B57\u7684\u89C6\u89C9\u5316\u63CF\u8FF0 |
| \`prompt\` | string | \u662F | \u751F\u6210\u63D0\u793A\u8BCD\uFF0C\u82F1\u6587\uFF0C\u7528\u4E8E AI \u56FE\u7247\u751F\u6210 |
| \`type\` | enum | \u662F | \u8D44\u4EA7\u7C7B\u578B\uFF1A\`role\` / \`scene\` / \`tool\`  |

## \u63D0\u53D6\u89C4\u5219

### \u89D2\u8272\uFF08role\uFF09

- \u63D0\u53D6\u5267\u672C\u4E2D\u51FA\u73B0\u7684\u6240\u6709\u6709\u540D\u5B57\u7684\u89D2\u8272
- \`desc\`\uFF1A\u5305\u542B\u6027\u522B\u3001\u5916\u8C8C\u7279\u5F81\u3001\u670D\u9970\u98CE\u683C\u3001\u4F53\u6001\u6C14\u8D28\u7B49\u89C6\u89C9\u8981\u7D20\uFF0C\u9700\u5728\u63CF\u8FF0\u5F00\u5934\u660E\u786E\u6807\u6CE8\u89D2\u8272\u6027\u522B\uFF08\u5982"\u7537\u6027\uFF0C\u2026\u2026"\u6216"\u5973\u6027\uFF0C\u2026\u2026"\uFF09
- \`prompt\`\uFF1A\u82F1\u6587\u63D0\u793A\u8BCD\uFF0C\u63CF\u8FF0\u89D2\u8272\u7684\u5916\u89C2\u7279\u5F81\uFF0C\u9700\u4EE5\u6027\u522B\u8BCD\u5F00\u5934\uFF08\u5982 \`a young man, ...\` \u6216 \`a young woman, ...\`\uFF09\uFF0C\u9002\u7528\u4E8E AI \u89D2\u8272\u56FE\u751F\u6210
- \u540C\u4E00\u89D2\u8272\u6709\u591A\u4E2A\u79F0\u547C\u65F6\uFF0C\u53D6\u6700\u5E38\u7528\u7684\u4F5C\u4E3A \`name\`
- \u65E0\u540D\u9F99\u5957\uFF08\u5982"\u8DEF\u4EBA\u7532"\u3001"\u58EB\u5175"\uFF09\u53EF\u8DF3\u8FC7\uFF0C\u9664\u975E\u5176\u9020\u578B\u5BF9\u5267\u60C5\u6709\u91CD\u8981\u89C6\u89C9\u610F\u4E49

### \u573A\u666F\uFF08scene\uFF09

- \u63D0\u53D6\u5267\u672C\u4E2D\u51FA\u73B0\u7684\u6240\u6709\u573A\u666F/\u5730\u70B9
- \`desc\`\uFF1A\u5305\u542B\u7A7A\u95F4\u7ED3\u6784\u3001\u5149\u7167\u6C1B\u56F4\u3001\u5173\u952E\u9648\u8BBE\u3001\u8272\u8C03\u57FA\u8C03\u7B49\u89C6\u89C9\u8981\u7D20
- \`prompt\`\uFF1A\u82F1\u6587\u63D0\u793A\u8BCD\uFF0C\u63CF\u8FF0\u573A\u666F\u7684\u6574\u4F53\u89C6\u89C9\u98CE\u683C\uFF0C\u9002\u7528\u4E8E AI \u573A\u666F\u56FE\u751F\u6210
- \u540C\u4E00\u573A\u666F\u7684\u4E0D\u540C\u72B6\u6001\uFF08\u5982\u767D\u5929/\u591C\u665A\uFF09\u4E0D\u91CD\u590D\u63D0\u53D6\uFF0C\u5728 \`desc\` \u4E2D\u6CE8\u660E\u5373\u53EF

### \u9053\u5177\uFF08tool\uFF09

- \u63D0\u53D6\u5267\u672C\u4E2D\u51FA\u73B0\u7684\u91CD\u8981\u9053\u5177/\u7269\u54C1
- \`desc\`\uFF1A\u5305\u542B\u5916\u89C2\u5F62\u72B6\u3001\u989C\u8272\u6750\u8D28\u3001\u5C3A\u5BF8\u53C2\u8003\u3001\u7279\u6B8A\u6548\u679C\u7B49\u89C6\u89C9\u8981\u7D20
- \`prompt\`\uFF1A\u82F1\u6587\u63D0\u793A\u8BCD\uFF0C\u63CF\u8FF0\u9053\u5177\u7684\u5916\u89C2\u7EC6\u8282\uFF0C\u9002\u7528\u4E8E AI \u9053\u5177\u56FE\u751F\u6210
- \u4EC5\u63D0\u53D6\u6709\u72EC\u7ACB\u89C6\u89C9\u610F\u4E49\u6216\u5267\u60C5\u529F\u80FD\u7684\u9053\u5177\uFF0C\u901A\u7528\u7269\u54C1\u53EF\u8DF3\u8FC7


## \u63D0\u793A\u8BCD\uFF08prompt\uFF09\u751F\u6210\u89C4\u8303

- \u91C7\u7528\u9017\u53F7\u5206\u9694\u7684\u5173\u952E\u8BCD/\u77ED\u8BED\u683C\u5F0F
- \u4F18\u5148\u63CF\u8FF0**\u89C6\u89C9\u7279\u5F81**\uFF0C\u907F\u514D\u62BD\u8C61\u6982\u5FF5
- \u5305\u542B\u98CE\u683C\u5173\u952E\u8BCD\uFF08\u5982 anime style, manga style \u7B49\uFF0C\u6839\u636E\u9879\u76EE\u98CE\u683C\u51B3\u5B9A\uFF09
- \u89D2\u8272 prompt \u793A\u4F8B\uFF1A\`a young man, sharp eyebrows, black hair, pale skin, wearing a gray Taoist robe, slender build, cold expression\`
- \u573A\u666F prompt \u793A\u4F8B\uFF1A\`dark cave interior, glowing crystals on walls, misty atmosphere, dim blue lighting, stone altar in center\`
- \u9053\u5177 prompt \u793A\u4F8B\uFF1A\`ancient jade pendant, oval shape, translucent green, carved dragon pattern, glowing faintly\`

## \u63D0\u53D6\u6D41\u7A0B

1. \u901A\u8BFB\u5267\u672C\u5168\u6587\uFF0C\u8BC6\u522B\u6240\u6709\u51FA\u73B0\u7684\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177
2. \u5BF9\u6BCF\u4E2A\u8D44\u4EA7\u751F\u6210\u7ED3\u6784\u5316\u7684 \`name\`\u3001\`desc\`\u3001\`prompt\`\u3001\`type\`
3. \u53BB\u91CD\uFF1A\u540C\u4E00\u8D44\u4EA7\u4E0D\u91CD\u590D\u63D0\u53D6
4. **\u5FC5\u987B\u901A\u8FC7\u8C03\u7528 \`resultTool\` \u5DE5\u5177\u8F93\u51FA\u5B8C\u6574\u8D44\u4EA7\u5217\u8868**\uFF0C\u4E0D\u8981\u5206\u591A\u6B21\u8C03\u7528\uFF0C\u4E00\u6B21\u6027\u5C06\u6240\u6709\u8D44\u4EA7\u653E\u5165 \`assetsList\` \u6570\u7EC4\u4E2D\u63D0\u4EA4

## \u63D0\u53D6\u539F\u5219

1. **\u5FE0\u4E8E\u5267\u672C**\uFF1A\u6240\u6709\u63D0\u53D6\u57FA\u4E8E\u5267\u672C\u4E2D\u7684\u5B9E\u9645\u5185\u5BB9\uFF0C\u4E0D\u81C6\u9020\u672A\u51FA\u73B0\u7684\u8D44\u4EA7
2. **\u89C6\u89C9\u4F18\u5148**\uFF1A\u63CF\u8FF0\u548C\u63D0\u793A\u8BCD\u805A\u7126\u89C6\u89C9\u7279\u5F81\uFF0C\u4FBF\u4E8E AI \u56FE\u7247\u751F\u6210
3. **\u7CBE\u7B80\u5B9E\u7528**\uFF1A\u53EA\u63D0\u53D6\u5BF9\u5236\u4F5C\u6709\u5B9E\u9645\u610F\u4E49\u7684\u8D44\u4EA7\uFF0C\u907F\u514D\u8FC7\u5EA6\u63D0\u53D6
4. **\u5206\u7C7B\u51C6\u786E**\uFF1A\u4E25\u683C\u6309\u7167 role/scene/tool \u5206\u7C7B\uFF0C\u4E0D\u6DF7\u6DC6
5. **\u63D0\u793A\u8BCD\u8D28\u91CF**\uFF1A\u82F1\u6587\u63D0\u793A\u8BCD\u5E94\u5177\u4F53\u3001\u53EF\u6267\u884C\uFF0C\u80FD\u76F4\u63A5\u7528\u4E8E AI \u56FE\u7247\u751F\u6210

## \u6CE8\u610F\u4E8B\u9879

- \u8D44\u4EA7\u5217\u8868\u4E2D**\u4E0D\u8981\u5305\u542B\u5267\u672C\u5185\u5BB9\u672C\u8EAB**\uFF0C\u4EC5\u63D0\u53D6\u6240\u4F7F\u7528\u5230\u7684\u8D44\u4EA7
- \u89D2\u8272\u7684\u968F\u8EAB\u7269\u54C1\u5982\u679C\u6709\u72EC\u7ACB\u5267\u60C5\u529F\u80FD\uFF0C\u5E94\u5355\u72EC\u4F5C\u4E3A\u9053\u5177\u63D0\u53D6
- \u573A\u666F\u4E2D\u7684\u56FA\u5B9A\u9648\u8BBE\u4E0D\u9700\u8981\u5355\u72EC\u63D0\u53D6\u4E3A\u9053\u5177\uFF0C\u9664\u975E\u8BE5\u7269\u4EF6\u6709\u72EC\u7ACB\u5267\u60C5\u4F5C\u7528`
      });
      await db_default("o_prompt").where("type", "videoPromptGeneration").update({
        data: `# \u89C6\u9891\u63D0\u793A\u8BCD\u751F\u6210 Skill

\u4F60\u662F**\u89C6\u9891\u63D0\u793A\u8BCD\u751F\u6210 Agent**\uFF0C\u4E13\u95E8\u8D1F\u8D23\u6839\u636E\u6307\u5B9A\u7684 AI \u89C6\u9891\u6A21\u578B\uFF0C\u8BFB\u53D6\u5206\u955C\u4FE1\u606F\u5E76\u8F93\u51FA\u8BE5\u6A21\u578B\u5BF9\u5E94\u683C\u5F0F\u7684\u89C6\u9891\u63D0\u793A\u8BCD\u3002

---

## \u8F93\u5165\u683C\u5F0F

### 1. \u6A21\u578B\u4E0E\u6A21\u5F0F\uFF08\u5FC5\u9009\uFF09


#### \u6A21\u5F0F\u8DEF\u7531\u89C4\u5219

| \u6761\u4EF6 | \u5339\u914D\u6A21\u5F0F | \u8BF4\u660E |
|------|----------|------|
| \u6A21\u578B\u540D\u4E3A \`seedance-2-0\` + \`\u591A\u53C2:\u662F\` / \`seedance 2.0\` + \`\u591A\u53C2:\u662F\` / \`\u5373\u68A62.0\` + \`\u591A\u53C2:\u662F\` | **seedance-2-0*\uFF0C\u4E0D\u5305\u542B\u5176\u4ED6\u7248\u672C\u6BD4\u5982seedance-1-5/seedance-1-0 | \u652F\u6301\u89D2\u8272/\u573A\u666F/\u5206\u955C\u56FE\u591A\u53C2\u5F15\u7528 |
| \u6A21\u578B\u540D\u4E3A \`Wan2.6\` / \`wan 2.6\` / \`\u4E07\u8C612.6\` | **Wan 2.6** | \u56FA\u5B9A\u6A21\u5F0F\uFF0C\u5355\u56FE\uFF08\u9996\u5E27\uFF09+ \u53D9\u4E8B\u6587\u672C\uFF0C\u65E0\u5C3E\u5E27 |
| \u5176\u4ED6\u4EFB\u4F55\u6A21\u578B + \`\u591A\u53C2:\u662F\` | **\u901A\u7528\u591A\u53C2\u6A21\u5F0F** | \u652F\u6301\u89D2\u8272/\u573A\u666F/\u5206\u955C\u56FE\u591A\u53C2\u5F15\u7528 |
| \u5176\u4ED6\u4EFB\u4F55\u6A21\u578B/seedance-1-5/seedance-1-0 + \`\u591A\u53C2:\u5426\` | **\u901A\u7528\u9996\u5C3E\u5E27\u6A21\u5F0F** | \u9996\u5E27/\u9996\u5C3E\u5E27 + \u7EAF\u6587\u672C\u63CF\u8FF0 |

> \u6A21\u578B\u540D\u4EC5\u7528\u4E8E\u8BB0\u5F55\uFF0C\u5B9E\u9645\u63D0\u793A\u8BCD\u683C\u5F0F\u7531\u5339\u914D\u5230\u7684\u6A21\u5F0F\u51B3\u5B9A\u3002Seedance 2.0 \u548C Wan 2.6 \u662F\u6307\u5B9A\u6A21\u578B\u540D\u5373\u786E\u5B9A\u6A21\u5F0F\u7684\u7279\u4F8B\u3002

### 2. \u8D44\u4EA7\u4FE1\u606F

\`\`\`
\u8D44\u4EA7\u4FE1\u606F[id, type, name], [id, type, name], ...
\`\`\`

- \`id\`\uFF1A\u8D44\u4EA7\u552F\u4E00\u6807\u8BC6\uFF08\u5982 \`A001\`\uFF09
- \`type\`\uFF1A\u8D44\u4EA7\u7C7B\u578B\uFF0C\u53D6\u503C \`role\`\uFF08\u89D2\u8272\uFF09/ \`scene\`\uFF08\u573A\u666F\uFF09/ \`prop\`\uFF08\u9053\u5177\uFF09
- \`name\`\uFF1A\u8D44\u4EA7\u540D\u79F0\uFF08\u5982 \`\u6C88\u8F9E\`\u3001\`\u57CE\u697C\`\u3001\`\u957F\u5251\`\uFF09

### 3. \u5206\u955C\u4FE1\u606F

\u5206\u955C\u4EE5 \`<storyboardItem>\` XML \u6807\u7B7E\u5217\u8868\u7684\u5F62\u5F0F\u4F20\u5165\uFF0C\u6BCF\u6761\u5206\u955C\u7ED3\u6784\u5982\u4E0B\uFF1A

\`\`\`xml
<storyboardItem
  videoDesc='\uFF08\u753B\u9762\u63CF\u8FF0\u3001\u573A\u666F\u3001\u5173\u8054\u8D44\u4EA7\u540D\u79F0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u3001\u5173\u8054\u8D44\u4EA7ID\uFF09'
  prompt='\u5F85\u751F\u6210'
  track='\u5206\u7EC4'
  duration='\u89C6\u9891\u63A8\u8350\u65F6\u95F4'
  associateAssetsIds="[\u8BE5\u5206\u955C\u6240\u9700\u7684\u8D44\u4EA7ID\u5217\u8868]"
  shouldGenerateImage="true"
></storyboardItem>
\`\`\`

#### \u8F93\u5165\u5B57\u6BB5\u8BF4\u660E

| \u5C5E\u6027 | \u8BF4\u660E | \u6765\u6E90 |
|------|------|------|
| \`videoDesc\` | **\u6838\u5FC3\u8F93\u5165**\uFF1A\u5206\u955C\u7684\u7ED3\u6784\u5316\u753B\u9762\u63CF\u8FF0\uFF0C\u5305\u542B\u753B\u9762\u63CF\u8FF0\u3001\u573A\u666F\u3001\u5173\u8054\u8D44\u4EA7\u540D\u79F0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u3001\u5173\u8054\u8D44\u4EA7ID | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |
| \`prompt\` | **\u5DF2\u6709\u5B57\u6BB5**\uFF1A\u4E0A\u6E38\u751F\u6210\u7684\u5206\u955C\u56FE\u63D0\u793A\u8BCD\uFF0C\u4F5C\u4E3A\u8F85\u52A9\u53C2\u8003\u4E0A\u4E0B\u6587\uFF0C**\u4E0D\u4FEE\u6539** | \u4E0A\u6E38\u7CFB\u7EDF\u5DF2\u586B\u5199 |
| \`track\` | \u5206\u955C\u5206\u7EC4\u6807\u8BC6 | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |
| \`duration\` | \u89C6\u9891\u63A8\u8350\u65F6\u957F\uFF08\u79D2\uFF09 | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |
| \`associateAssetsIds\` | \u8BE5\u5206\u955C\u5173\u8054\u7684\u8D44\u4EA7ID\u5217\u8868 | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |
| \`shouldGenerateImage\` | \u662F\u5426\u9700\u8981\u751F\u6210\u5206\u955C\u56FE\u7247\uFF0C\u9ED8\u8BA4 \`true\` | \u7528\u6237/\u4E0A\u6E38\u7CFB\u7EDF\u586B\u5199 |

---

## \u4EFB\u52A1\u76EE\u6807

\u8BFB\u53D6\u6240\u6709 \`<storyboardItem>\` \u7684\u5C5E\u6027\uFF0C\u7ED3\u5408\u8D44\u4EA7\u4FE1\u606F\uFF0C\u6839\u636E\u6307\u5B9A\u6A21\u578B\u7684\u63D0\u793A\u8BCD\u683C\u5F0F\uFF0C\u5C06\u5168\u90E8\u5206\u955C\u6574\u5408\u4E3A\u4E00\u4E2A\u5B8C\u6574\u7684\u89C6\u9891\u63D0\u793A\u8BCD\u3002

---

## \u8F93\u51FA\u683C\u5F0F

\u5C06\u6240\u6709\u5206\u955C\u6574\u5408\u4E3A**\u4E00\u4E2A\u5B8C\u6574\u7684\u89C6\u9891\u63D0\u793A\u8BCD**\u8F93\u51FA\uFF08\u975E\u9010\u6761\u72EC\u7ACB\uFF09\uFF1A

| \u6A21\u5F0F | \u6574\u5408\u65B9\u5F0F |
|------|----------|
| **\u901A\u7528\u591A\u53C2\u6A21\u5F0F** | \`[References]\` \u6C47\u603B\u6240\u6709 \`@\u56FEN \` \u5F15\u7528\uFF1B\`[Instruction]\` \u6309\u65F6\u95F4\u987A\u5E8F\u63CF\u8FF0\u5B8C\u6574\u53D9\u4E8B |
| **\u901A\u7528\u9996\u5C3E\u5E27\u6A21\u5F0F** | \u7EAF\u6587\u672C\u4E94\u7EF4\u5EA6\uFF08Visual / Motion / Camera / Audio / Narrative\uFF09\uFF0C\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528\uFF0C\u6309\u65F6\u95F4\u8F74\u8FDE\u7EED\u7F16\u6392\uFF08\`[Motion]\` 0s \u2192 \u603B\u65F6\u957F\uFF0C\u6BCF\u6BB5\u6700\u4F4E 1 \u79D2\uFF09\uFF0C\u5168\u7A0B\u5355\u4E00\u8FDE\u8D2F\u955C\u5934\uFF0C\u4E0D\u5207\u955C |
| **Seedance 2.0** | \`\u751F\u6210\u4E00\u4E2A\u7531\u4EE5\u4E0B N \u4E2A\u5206\u955C\u7EC4\u6210\u7684\u89C6\u9891\`\uFF0C\u6BCF\u6761\u5BF9\u5E94 \`\u5206\u955CN{N}s\` \u6BB5\u843D |
| **Wan 2.6** | \u5355\u56FE\u9996\u5E27\u6A21\u5F0F\uFF0C\u6BCF\u6B21\u4EC5\u8F93\u5165\u4E00\u6761\u5206\u955C\uFF0C\u8F93\u51FA\u4E00\u6BB5\u53D9\u4E8B\u5F0F\u82F1\u6587\u63D0\u793A\u8BCD\uFF08\u4E09\u6BB5\u5F0F\uFF1A\u98CE\u683C\u57FA\u8C03 \u2192 \u4E3B\u4F53\u52A8\u4F5C+\u573A\u666F\u73AF\u5883+\u5149\u7EBF\u6C1B\u56F4 \u2192 \u955C\u5934\u6536\u5C3E\uFF09\uFF0C\u4E0D\u4F7F\u7528 \`@\u56FEN \` \u5F15\u7528 |

- \u4EC5\u8F93\u51FA\u89C6\u9891\u63D0\u793A\u8BCD\u6587\u672C\uFF0C\u4E0D\u8F93\u51FA XML \u6807\u7B7E\uFF0C\u4E0D\u9644\u52A0\u89E3\u91CA

---

## videoDesc \u89E3\u6790\u89C4\u5219

\u4ECE \`videoDesc\` \u62EC\u53F7\u5185\u6309\u987F\u53F7\u5206\u9694\u63D0\u53D6\u4EE5\u4E0B\u7ED3\u6784\u5316\u5B57\u6BB5\uFF1A

\`\`\`
\uFF08{\u753B\u9762\u63CF\u8FF0}\u3001{\u573A\u666F}\u3001{\u5173\u8054\u8D44\u4EA7\u540D\u79F0}\u3001{\u65F6\u957F}\u3001{\u666F\u522B}\u3001{\u8FD0\u955C}\u3001{\u89D2\u8272\u52A8\u4F5C}\u3001{\u60C5\u7EEA}\u3001{\u5149\u5F71\u6C1B\u56F4}\u3001{\u53F0\u8BCD}\u3001{\u97F3\u6548}\u3001{\u5173\u8054\u8D44\u4EA7ID}\uFF09
\`\`\`

| \u5E8F\u53F7 | \u5B57\u6BB5 | \u7528\u9014 | \u793A\u4F8B |
|------|------|------|------|
| 1 | \u753B\u9762\u63CF\u8FF0 | prompt \u7684\u53D9\u4E8B\u4E3B\u5E72 | \u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730 |
| 2 | \u573A\u666F | \u5339\u914D\u573A\u666F\u8D44\u4EA7 | \u57CE\u697C |
| 3 | \u5173\u8054\u8D44\u4EA7\u540D\u79F0 | \u5339\u914D\u89D2\u8272/\u9053\u5177\u8D44\u4EA7 | \u6C88\u8F9E/\u57CE\u697C |
| 4 | \u65F6\u957F | \u63A7\u5236\u65F6\u957F\u53C2\u6570 | 4s |
| 5 | \u666F\u522B | \u63A7\u5236\u955C\u5934\u666F\u522B | \u5168\u666F |
| 6 | \u8FD0\u955C | \u63A7\u5236\u8FD0\u955C\u65B9\u5F0F | \u9759\u6B62 |
| 7 | \u89D2\u8272\u52A8\u4F5C | prompt \u52A8\u4F5C\u63CF\u5199 | \u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C |
| 8 | \u60C5\u7EEA | prompt \u60C5\u7EEA\u6C1B\u56F4 | \u575A\u5B9A\u51B3\u7EDD |
| 9 | \u5149\u5F71\u6C1B\u56F4 | prompt \u5149\u5F71\u63CF\u5199 | \u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149 |
| 10 | \u53F0\u8BCD | prompt \u53F0\u8BCD/\u97F3\u9891\u6BB5 | \u65E0\u53F0\u8BCD / \u5177\u4F53\u53F0\u8BCD\u5185\u5BB9 |
| 11 | \u97F3\u6548 | prompt \u97F3\u6548\u63CF\u5199 | \u98CE\u58F0\u8863\u8882\u58F0 |
| 12 | \u5173\u8054\u8D44\u4EA7ID | \u7528\u4E8E\u8D44\u4EA7ID\u2194\u89D2\u8272\u6807\u7B7E\u6620\u5C04 | A001/A002 |

---

## \u8D44\u4EA7\u5F15\u7528\u7F16\u53F7\u89C4\u5219

\u6240\u6709\u6A21\u578B\u7EDF\u4E00\u4F7F\u7528 \`@\u56FEN \` \u683C\u5F0F\u5F15\u7528\u8D44\u4EA7\u548C\u5206\u955C\u56FE\uFF0C\u7F16\u53F7\u6309\u8F93\u5165\u987A\u5E8F\u8FDE\u7EED\u9012\u589E\uFF1A

1. **\u8D44\u4EA7**\uFF1A\u6309\u8D44\u4EA7\u4FE1\u606F\u4E2D \`[id, type, name]\` \u7684\u51FA\u73B0\u987A\u5E8F\uFF0C\u4ECE \`@\u56FE1 \` \u5F00\u59CB\u7F16\u53F7\uFF08\u4E0D\u533A\u5206 role / scene / prop\uFF09\u3002**\u8D44\u4EA7\u7C7B\u578B\u7684\u51FA\u73B0\u987A\u5E8F\u4E0D\u56FA\u5B9A**\u2014\u2014\u53EF\u80FD\u5148 scene \u540E character\uFF0C\u4E5F\u53EF\u80FD prop \u5728\u524D\u3001character \u5728\u540E\uFF0C\u6216\u4EFB\u610F\u4EA4\u66FF\u51FA\u73B0\uFF0C\u7F16\u53F7\u4E25\u683C\u6309\u8F93\u5165\u4F4D\u7F6E\u5206\u914D\uFF0C\u4E0D\u6309\u7C7B\u578B\u5F52\u7EC4
2. **\u5206\u955C\u56FE**\uFF1A\u6BCF\u6761 \`<storyboardItem>\` \u5BF9\u5E94\u4E00\u5F20\u5206\u955C\u56FE\uFF0C\u7F16\u53F7\u63A5\u7EED\u8D44\u4EA7\u4E4B\u540E
3. **\u8DF3\u8FC7\u65E0\u5206\u955C\u56FE\u7684\u6761\u76EE**\uFF1A\u5F53 \`shouldGenerateImage="false"\` \u65F6\uFF0C\u8BE5\u5206\u955C\u672A\u751F\u6210\u56FE\u7247\uFF0C**\u4E0D\u5206\u914D**\u5206\u955C\u56FE\u7F16\u53F7\uFF0C\u540E\u7EED\u7F16\u53F7\u987A\u5EF6

#### \u793A\u4F8B

\u8F93\u5165 3 \u4E2A\u8D44\u4EA7 + 2 \u6761\u5206\u955C\uFF1A
\`\`\`
\u8D44\u4EA7\u4FE1\u606F[A001, role, \u6C88\u8F9E], [A002, role, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem ...>  <!-- \u5206\u955C1 -->
<storyboardItem ...>  <!-- \u5206\u955C2 -->
\`\`\`

\u7F16\u53F7\u7ED3\u679C\uFF1A

| \u8F93\u5165\u9879 | \u5F15\u7528\u6807\u7B7E | \u8BF4\u660E |
|--------|----------|------|
| [A001, role, \u6C88\u8F9E] | \`@\u56FE1 \` | \u89D2\u8272\xB7\u6C88\u8F9E \u53C2\u8003\u56FE |
| [A002, role, \u82CF\u9526] | \`@\u56FE2 \` | \u89D2\u8272\xB7\u82CF\u9526 \u53C2\u8003\u56FE |
| [A003, scene, \u57CE\u697C] | \`@\u56FE3 \` | \u573A\u666F\xB7\u57CE\u697C \u53C2\u8003\u56FE |
| storyboardItem \u7B2C1\u6761 | \`@\u56FE4 \` | \u5206\u955C\u56FE1 |
| storyboardItem \u7B2C2\u6761 | \`@\u56FE5 \` | \u5206\u955C\u56FE2 |

**\u6DF7\u5408\u987A\u5E8F\u793A\u4F8B**

\u8F93\u5165 3 \u4E2A\u8D44\u4EA7\uFF08\u573A\u666F\u5728\u524D\uFF09+ 2 \u6761\u5206\u955C\uFF1A
\`\`\`
\u8D44\u4EA7\u4FE1\u606F[A003, scene, \u57CE\u697C], [A001, role, \u6C88\u8F9E], [A002, role, \u82CF\u9526]
\`\`\`
\`\`\`xml
<storyboardItem ...>  <!-- \u5206\u955C1 -->
<storyboardItem ...>  <!-- \u5206\u955C2 -->
\`\`\`

\u7F16\u53F7\u7ED3\u679C\uFF1A

| \u8F93\u5165\u9879 | \u5F15\u7528\u6807\u7B7E | \u8BF4\u660E |
|--------|----------|------|
| [A003, scene, \u57CE\u697C] | \`@\u56FE1 \` | \u573A\u666F\xB7\u57CE\u697C \u53C2\u8003\u56FE |
| [A001, role, \u6C88\u8F9E] | \`@\u56FE2 \` | \u89D2\u8272\xB7\u6C88\u8F9E \u53C2\u8003\u56FE |
| [A002, role, \u82CF\u9526] | \`@\u56FE3 \` | \u89D2\u8272\xB7\u82CF\u9526 \u53C2\u8003\u56FE |
| storyboardItem \u7B2C1\u6761 | \`@\u56FE4 \` | \u5206\u955C\u56FE1 |
| storyboardItem \u7B2C2\u6761 | \`@\u56FE5 \` | \u5206\u955C\u56FE2 |

> **\u5173\u952E**\uFF1A\u6B64\u4F8B\u4E2D \`@\u56FE1 \` \u662F\u573A\u666F\u800C\u975E\u89D2\u8272\uFF0C\`@\u56FE2 \` \`@\u56FE3 \` \u624D\u662F\u89D2\u8272\u3002\u751F\u6210\u63D0\u793A\u8BCD\u65F6\uFF0C\u5FC5\u987B\u6839\u636E\u8D44\u4EA7\u7684\u5B9E\u9645 \`type\` \u5B57\u6BB5\u786E\u5B9A\u5F15\u7528\u65B9\u5F0F\uFF0C\u800C\u975E\u6839\u636E\u7F16\u53F7\u5927\u5C0F\u5047\u5B9A\u7C7B\u578B\u3002

---

## \u6A21\u578B\u63D0\u793A\u8BCD\u751F\u6210\u89C4\u5219

### \u4E00\u3001\u901A\u7528\u591A\u53C2\u6A21\u5F0F

#### \u6838\u5FC3\u539F\u5219
- MVL \u591A\u6A21\u6001\u878D\u5408\uFF1A\u81EA\u7136\u8BED\u8A00 + \u56FE\u50CF\u5F15\u7528\u5728\u540C\u4E00\u8BED\u4E49\u7A7A\u95F4
- \u5206\u955C\u56FE\u5E8F\u5217\u8D1F\u8D23\u52A8\u4F5C/\u65F6\u95F4\u8F74/\u6784\u56FE\uFF0C\u573A\u666F\u53C2\u8003\u56FE\u8D1F\u8D23\u73AF\u5883\u4E00\u81F4\u6027
- \u6240\u6709\u8D44\u4EA7\u548C\u5206\u955C\u56FE\u7EDF\u4E00\u7528 \`@\u56FEN \` \u5F15\u7528
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728 Instruction \u4E2D\u4F53\u73B0\u53F0\u8BCD\u76F8\u5173\u63CF\u8FF0
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08dialogue\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08inner monologue OS\uFF09\u3001\u753B\u5916\u97F3\uFF08voiceover VO\uFF09\uFF0C\u5728 Instruction \u4E2D\u7528\u62EC\u53F7\u6807\u6CE8

#### prompt \u751F\u6210\u6A21\u677F

> **\u6CE8\u610F**\uFF1A\`[References]\` \u4E2D\u7684 \`@\u56FEN\` \u7F16\u53F7\u4E25\u683C\u6309\u8D44\u4EA7\u8F93\u5165\u987A\u5E8F\u5206\u914D\uFF0C\u89D2\u8272/\u573A\u666F/\u9053\u5177\u53EF\u80FD\u51FA\u73B0\u5728\u4EFB\u610F\u7F16\u53F7\u4F4D\u7F6E\u3002\u751F\u6210\u65F6\u9700\u6839\u636E\u6BCF\u4E2A\u8D44\u4EA7\u7684 \`type\` \u5B57\u6BB5\u786E\u5B9A\u5176\u5F15\u7528\u65B9\u5F0F\uFF0C\u4E0D\u53EF\u5047\u5B9A\u56FA\u5B9A\u7684\u7C7B\u578B-\u7F16\u53F7\u5BF9\u5E94\u5173\u7CFB\u3002

\`\`\`
[References]
@\u56FE{\u8D44\u4EA71\u7F16\u53F7} : [{\u8D44\u4EA71\u540D\u79F0}\u53C2\u8003\u56FE]   \u2190 \u53EF\u80FD\u662F role/scene/prop \u4E2D\u7684\u4EFB\u610F\u7C7B\u578B
@\u56FE{\u8D44\u4EA72\u7F16\u53F7} : [{\u8D44\u4EA72\u540D\u79F0}\u53C2\u8003\u56FE]
@\u56FE{\u8D44\u4EA73\u7F16\u53F7} : [{\u8D44\u4EA73\u540D\u79F0}\u53C2\u8003\u56FE]
...
@\u56FE{\u5206\u955C\u56FE\u7F16\u53F7} : [\u5206\u955C\u56FE1]            \u2190 \u5206\u955C\u56FE\u7F16\u53F7\u63A5\u7EED\u8D44\u4EA7\u4E4B\u540E

[Instruction]
Based on the storyboard @\u56FE{\u5206\u955C\u56FE\u7F16\u53F7} :
@\u56FE{\u89D2\u8272\u8D44\u4EA7\u7F16\u53F7} {\u52A8\u4F5C/\u72B6\u6001\u63CF\u8FF0\uFF08\u82F1\u6587\uFF09},
set in the {\u573A\u666F\u63CF\u8FF0\uFF08\u82F1\u6587\uFF09} of @\u56FE{\u573A\u666F\u8D44\u4EA7\u7F16\u53F7} ,
{\u955C\u5934/\u8FD0\u955C\u63CF\u8FF0\uFF08\u82F1\u6587\uFF09},
{\u60C5\u611F\u57FA\u8C03\uFF08\u82F1\u6587\uFF09},
{\u53F0\u8BCD\u63CF\u8FF0\uFF08\u82F1\u6587\uFF0C\u542B dialogue/OS/VO \u6807\u6CE8\uFF09/ No dialogue},
{\u97F3\u6548\u63CF\u8FF0\uFF08\u82F1\u6587\uFF09}.
\`\`\`

#### \u751F\u6210\u7EA6\u675F
1. **Instruction \u5FC5\u987B\u7528\u82F1\u6587**
2. **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u4FE1\u606F
3. **\u89D2\u8272\u52A8\u4F5C**\u4ECE videoDesc \u7684\u300C\u89D2\u8272\u52A8\u4F5C\u300D\u5B57\u6BB5\u63D0\u53D6\uFF0C\u7FFB\u8BD1\u4E3A\u7B80\u6D01\u82F1\u6587\u52A8\u4F5C\u63CF\u8FF0
4. **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728 Instruction \u4E2D\u4F53\u73B0\u53F0\u8BCD\u5185\u5BB9\uFF08\u4FDD\u6301\u539F\u59CB\u8BED\u8A00\uFF0C\u4E0D\u7FFB\u8BD1\uFF09
5. **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u666E\u901A\u5BF9\u767D\u6807\u6CE8 \`(dialogue)\`\uFF1B\u5185\u5FC3\u72EC\u767D\u6807\u6CE8 \`(inner monologue, OS)\`\uFF1B\u753B\u5916\u97F3\u6807\u6CE8 \`(voiceover, VO)\`
6. **\u955C\u5934\u98CE\u683C**\u4F7F\u7528\u6807\u51C6\u6807\u7B7E\uFF1A\`cinematic\` / \`wide-angle\` / \`close-up\` / \`slow motion\` / \`surround shooting\` / \`handheld\`
7. **\u7A7A\u95F4\u5173\u7CFB**\u4F7F\u7528\u6807\u51C6\u52A8\u8BCD\uFF1A\`wearing\` / \`holding\` / \`standing on\` / \`following behind\` / \`sitting in\`
8. \u5355\u6761\u5206\u955C\u5BF9\u5E94\u5355\u4E2A \`@\u56FEN \`\uFF0C\u4E0D\u505A\u591A\u5E27\u8DE8\u955C\u63CF\u8FF0
9. \u65E0\u9700\u63CF\u8FF0\u89D2\u8272\u5916\u89C2\uFF08\u7531\u53C2\u8003\u56FE\u8D1F\u8D23\uFF09
10. \u65E0\u65F6\u957F\u6807\u6CE8\uFF08\u7531\u6A21\u578B\u63A8\u65AD\uFF09
11. **\u65E0\u5206\u955C\u56FE\u65F6**\uFF1A\u5F53 \`shouldGenerateImage="false"\` \u65F6\uFF0C\u8BE5\u5206\u955C\u65E0\u5206\u955C\u56FE\uFF0C\`[References]\` \u4E2D\u4E0D\u5217\u51FA\u8BE5\u5206\u955C\u56FE\uFF0C\`[Instruction]\` \u4E2D\u4E0D\u4F7F\u7528 \`@\u56FEN \` \u5F15\u7528\u8BE5\u5206\u955C\u56FE\uFF0C\u6539\u4E3A\u7EAF\u6587\u672C\u63CF\u8FF0\u753B\u9762\u5185\u5BB9

#### KlingOmni \u5B8C\u6574\u793A\u4F8B

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1AKlingOmni
\u8D44\u4EA7\u4FE1\u606F[A001, role, \u6C88\u8F9E], [A002, role, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730\u3001\u57CE\u697C\u3001\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u5168\u666F\u3001\u9759\u6B62\u3001\u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C\u3001\u575A\u5B9A\u51B3\u7EDD\u3001\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149\u3001\u65E0\u53F0\u8BCD\u3001\u98CE\u58F0\u8863\u8882\u58F0\u3001A001/A003\uFF09' prompt='\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u57CE\u697C\u4E4B\u4E0A\uFF0C\u6C88\u8F9E\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u98D8\u626C\uFF0C\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
<storyboardItem videoDesc='\uFF08\u82CF\u9526\u767B\u4E0A\u57CE\u697C\u8D70\u5411\u6C88\u8F9E\u3001\u57CE\u697C\u3001\u82CF\u9526/\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u4E2D\u666F\u3001\u8DDF\u8E2A\u3001\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u6C88\u8F9E\u3001\u62C5\u5FE7\u3001\u9EC4\u660F\u4F59\u6656\u6E10\u6697\u3001\u65E0\u53F0\u8BCD\u3001\u811A\u6B65\u58F0\u98CE\u58F0\u3001A001/A002/A003\uFF09' prompt='\u4E2D\u666F\uFF0C\u8DDF\u8E2A\uFF0C\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u57CE\u697C\u4E0A\u7684\u6C88\u8F9E...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A002&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
[References]
@\u56FE1 : [\u6C88\u8F9E\u53C2\u8003\u56FE]
@\u56FE2 : [\u82CF\u9526\u53C2\u8003\u56FE]
@\u56FE3 : [\u57CE\u697C\u53C2\u8003\u56FE]
@\u56FE4 : [\u5206\u955C\u56FE1]
@\u56FE5 : [\u5206\u955C\u56FE2]

[Instruction]
Based on the storyboard from @\u56FE4 to @\u56FE5 :
@\u56FE1 standing alone atop the city wall, hands clasped behind back, robes billowing in the wind, gazing across the vast land,
@\u56FE2 ascending the steps toward @\u56FE1 , expression worried,
set in the ancient city wall environment of @\u56FE3 ,
wide shot transitioning to medium tracking shot, cinematic,
resolute determination shifting to concerned anticipation, dusk cold-toned side-backlit atmosphere fading,
no dialogue,
wind howling, fabric flapping, footsteps on stone.
\`\`\`

---

### \u4E8C\u3001\u901A\u7528\u9996\u5C3E\u5E27\u6A21\u5F0F

#### \u6838\u5FC3\u539F\u5219
- **\u7EAF\u6587\u672C\u63D0\u793A\u8BCD**\uFF1A\u63D0\u793A\u8BCD\u5185**\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528**\uFF08\u4E0D\u5F15\u7528\u89D2\u8272\u8D44\u4EA7\u3001\u573A\u666F\u8D44\u4EA7\u3001\u4E5F\u4E0D\u5F15\u7528\u5206\u955C\u56FE\uFF09\uFF0C\u5168\u90E8\u5185\u5BB9\u7528\u7EAF\u6587\u672C\u63CF\u8FF0
- **\u4E94\u7EF4\u5EA6\u7ED3\u6784**\uFF1AVisual / Motion / Camera / Audio / Narrative
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728 \`[Audio]\` \u4E2D\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u5185\u5BB9
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08dialogue, lip-sync active\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08inner monologue OS, silent lips\uFF09\u3001\u753B\u5916\u97F3\uFF08voiceover VO, silent lips\uFF09\uFF0C\u5E76\u5728 \`[Audio]\` \u4E2D\u660E\u786E\u6807\u6CE8
- **\u4E0D\u8BF4\u8BDD\u7684\u4E3B\u4F53\u6807\u6CE8 \`silent\`** \u2014 \u9632\u6B62\u8BEF\u751F\u53E3\u578B
- **\u5168\u7A0B\u5355\u4E00\u8FDE\u8D2F\u955C\u5934**\uFF1A\u4ECE\u5934\u5230\u5C3E\u4E00\u4E2A\u955C\u5934\uFF0C\u4E0D\u5B58\u5728\u5207\u955C
- **\u65F6\u95F4\u8F74\u5206\u6BB5**\uFF1A\u6BCF\u6BB5\u6700\u4F4E 1 \u79D2\uFF0C\u7528 \`0s-Xs\` \u6807\u6CE8

#### prompt \u751F\u6210\u6A21\u677F

\`\`\`
[Visual]
{\u4E3B\u4F53A\u540D}: {\u5916\u89C2\u7B80\u8FF0}, {\u7AD9\u4F4D/\u59FF\u6001}, {\u8BF4\u8BDD\u72B6\u6001 speaking/silent}.
{\u4E3B\u4F53B\u540D}: {\u5916\u89C2\u7B80\u8FF0}, {\u7AD9\u4F4D/\u59FF\u6001}, {\u8BF4\u8BDD\u72B6\u6001}.
{\u573A\u666F\u63CF\u8FF0}, {\u9053\u5177\u63CF\u8FF0}.
{\u89C6\u89C9\u98CE\u683C\u6807\u7B7E}.

[Motion]
0s-{X}s: {\u4E3B\u4F53A\u540D} {\u52A8\u4F5C\u63CF\u8FF0\u6BB51}.
{X}s-{Y}s: {\u4E3B\u4F53B\u540D} {\u52A8\u4F5C\u63CF\u8FF0\u6BB52}.

[Camera]
{\u955C\u5934\u7C7B\u578B}, {\u8FD0\u955C\u65B9\u5F0F}, {\u5168\u7A0B\u5355\u4E00\u8FDE\u8D2F\u955C\u5934\u63CF\u8FF0}.

[Audio]
{Xs-Ys}: "{\u53F0\u8BCD\u5185\u5BB9}" \u2014 {\u8BF4\u8BDD\u8005\u540D} ({dialogue / inner monologue OS / voiceover VO}), {lip-sync active / silent lips}.
{\u97F3\u6548\u63CF\u8FF0}.

[Narrative]
{\u60C5\u8282\u70B9\u6982\u8FF0}, {\u53D9\u4E8B\u4F4D\u7F6E}.
\`\`\`

#### \u751F\u6210\u7EA6\u675F
1. **\u5168\u90E8\u7528\u82F1\u6587**
2. **\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528**\uFF1A\u63D0\u793A\u8BCD\u5185\u4E0D\u5F15\u7528\u89D2\u8272\u8D44\u4EA7\u3001\u573A\u666F\u8D44\u4EA7\u3001\u5206\u955C\u56FE\uFF0C\u5168\u90E8\u5185\u5BB9\u7528\u7EAF\u6587\u672C\u63CF\u8FF0
3. **\u4E3B\u4F53\u7528\u6587\u5B57\u63CF\u8FF0**\uFF1A\u5728 [Visual] \u4E2D\u7B80\u8981\u63CF\u8FF0\u4E3B\u4F53\u5916\u89C2\u7279\u5F81\uFF08\u5982\u670D\u9970\u3001\u53D1\u578B\u7B49\u5173\u952E\u8FA8\u8BC6\u7279\u5F81\uFF09
4. **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u4FE1\u606F
5. **\u6BCF\u4E2A\u4E3B\u4F53\u5FC5\u987B\u6807\u6CE8\u8BF4\u8BDD\u72B6\u6001**\uFF1A\`speaking\` / \`silent\` / \`speaking simultaneously\`
6. **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728 \`[Audio]\` \u4E2D\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u5185\u5BB9\uFF08\u4FDD\u6301\u539F\u59CB\u8BED\u8A00\uFF0C\u4E0D\u7FFB\u8BD1\uFF09
7. **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u666E\u901A\u5BF9\u767D\u6807\u6CE8 \`dialogue, lip-sync active\`\uFF1B\u5185\u5FC3\u72EC\u767D\u6807\u6CE8 \`inner monologue (OS), silent lips\`\uFF1B\u753B\u5916\u97F3\u6807\u6CE8 \`voiceover (VO), silent lips\`
8. **Motion \u65F6\u95F4\u8F74**\u6BCF\u6BB5\u6700\u4F4E 1 \u79D2\uFF0C\u4E0D\u8D85\u8FC7\u603B\u65F6\u957F
9. **\u5168\u7A0B\u5355\u4E00\u8FDE\u8D2F\u955C\u5934**\uFF1ACamera \u6BB5\u843D\u63CF\u8FF0\u4ECE\u5934\u5230\u5C3E\u7684\u4E00\u4E2A\u955C\u5934\uFF0C\u7EDD\u4E0D\u5207\u955C
10. **\u89C6\u89C9\u98CE\u683C**\u53C2\u8003 Assistant \u4E2D\u7684\u300C\u89C6\u89C9\u98CE\u683C\u7EA6\u675F\u300D\u90E8\u5206\u5185\u5BB9
11. **\u955C\u5934\u7C7B\u578B**\u4ECE\u4EE5\u4E0B\u9009\u53D6\uFF1A\`Wide establishing shot / Over-the-shoulder / Medium shot / Close-up / Wide shot / POV / Dutch angle / Crane up / Dolly right / Whip pan / Handheld / Slow motion\`

#### Seedance 1.5 Pro \u5B8C\u6574\u793A\u4F8B

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1ASeedance1.5
\u8D44\u4EA7\u4FE1\u606F[A001, role, \u6C88\u8F9E], [A002, role, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730\u3001\u57CE\u697C\u3001\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u5168\u666F\u3001\u9759\u6B62\u3001\u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C\u3001\u575A\u5B9A\u51B3\u7EDD\u3001\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149\u3001\u65E0\u53F0\u8BCD\u3001\u98CE\u58F0\u8863\u8882\u58F0\u3001A001/A003\uFF09' prompt='\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u57CE\u697C\u4E4B\u4E0A\uFF0C\u6C88\u8F9E\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u98D8\u626C\uFF0C\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
<storyboardItem videoDesc='\uFF08\u82CF\u9526\u767B\u4E0A\u57CE\u697C\u8D70\u5411\u6C88\u8F9E\u3001\u57CE\u697C\u3001\u82CF\u9526/\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u4E2D\u666F\u3001\u8DDF\u8E2A\u3001\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u6C88\u8F9E\u3001\u62C5\u5FE7\u3001\u9EC4\u660F\u4F59\u6656\u6E10\u6697\u3001\u65E0\u53F0\u8BCD\u3001\u811A\u6B65\u58F0\u98CE\u58F0\u3001A001/A002/A003\uFF09' prompt='\u4E2D\u666F\uFF0C\u8DDF\u8E2A\uFF0C\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u57CE\u697C\u4E0A\u7684\u6C88\u8F9E...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A002&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
[Visual]
Shen Ci: male, dark flowing robes, hair tied up, standing alone atop city wall, hands clasped behind back, robes billowing, silent.
Su Jin: female, light-colored dress, hair partially down, ascending steps toward Shen Ci, expression worried, silent.
Ancient city wall, vast open land beyond, dusk sky fading.
Cinematic, photorealistic, 4K, high contrast, desaturated tones, shallow depth of field.

[Motion]
0s-4s: Shen Ci stands still on city wall edge, robes flutter in wind, hair sways gently. Gaze fixed on distant horizon.
4s-8s: Su Jin climbs the last few steps onto the wall, walks toward Shen Ci. Shen Ci remains still, unaware. Su Jin slows as she approaches.

[Camera]
Wide establishing shot, static for first 4 seconds capturing the lone figure. Then smooth transition to medium tracking shot following the woman ascending steps, single continuous take throughout, no cuts.

[Audio]
0s-4s: Wind howling across wall, fabric flapping rhythmically. No dialogue.
4s-8s: Footsteps on stone, robes rustling. No dialogue.
Shen Ci \u2014 silent. Su Jin \u2014 silent.

[Narrative]
Lone figure on city wall, then arrival of a companion. Tension between determination and concern. Single continuous take.
\`\`\`

---

### \u4E09\u3001Seedance 2.0

#### \u6838\u5FC3\u539F\u5219
- **\u7ED3\u6784\u531612\u7EF4\u7F16\u7801**\uFF1A\u7EDF\u4E00\u7528 \`@\u56FEN \` \u5F15\u7528\u8D44\u4EA7\u548C\u5206\u955C\u56FE\uFF0C\u65F6\u957F \`{N}s\`
- **\u6700\u524D\u9762\u5148\u5B9A\u4E49\u56FE\u7247\u6620\u5C04**\uFF1A\u5148\u8F93\u51FA\u201C\u56FE\u7247\u5B9A\u4E49\u201D\u6BB5\uFF0C\u96C6\u4E2D\u58F0\u660E \`@\u56FEN : \u4E3B\u4F53\u540D\u5B57/\u573A\u666F\u540D\u5B57\uFF0C\u7B80\u8FF0\`\uFF1B\u540E\u7EED\u5206\u955C\u6B63\u6587\u53EA\u4F7F\u7528\u4E3B\u4F53\u540D\u5B57\uFF0C\u4E0D\u518D\u5199 \`@\u56FEN \`
- **\u97F3\u8272\u53C2\u65709\u7EF4\u5EA6\u7CBE\u7EC6\u63CF\u8FF0**\uFF08\u6709\u53F0\u8BCD\u65F6\u5FC5\u586B\uFF09
- **\u79D2\u7EA7\u65F6\u957F\u63A7\u5236**\uFF1A\u5355\u5206\u955C\u65F6\u957F\u6700\u4F4E 1s
- **\u4E2D\u6587\u63D0\u793A\u8BCD**
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u6BCF\u6761\u5206\u955C\u7684\u63CF\u8FF0\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u548C\u97F3\u8272\u63CF\u8FF0
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08\u76F4\u63A5\u4F7F\u7528\u300C\u8BF4\uFF1A\u300D\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08\u4F7F\u7528\u300C\u5185\u5FC3OS\uFF1A\u300D\uFF09\u3001\u753B\u5916\u97F3\uFF08\u4F7F\u7528\u300C\u753B\u5916\u97F3VO\uFF1A\u300D\uFF09\uFF0C\u5E76\u5339\u914D\u5BF9\u5E94\u7684\u5634\u578B\u72B6\u6001\u63CF\u8FF0

#### prompt \u751F\u6210\u6A21\u677F

> **\u6CE8\u610F**\uFF1A\`@\u56FE{\u7F16\u53F7}\` \u4EC5\u7528\u4E8E\u6700\u524D\u9762\u7684\u201C\u56FE\u7247\u5B9A\u4E49\u201D\u6BB5\u3002\u5206\u955C\u6B63\u6587\u4E2D\u7981\u6B62\u518D\u5199 \`@\u56FE{\u7F16\u53F7}\`\uFF0C\u7EDF\u4E00\u6539\u7528\u4E3B\u4F53\u540D\u5B57/\u573A\u666F\u540D\u5B57\u3002

**\u5355\u5206\u955C\u6A21\u677F\uFF1A**
\`\`\`
\u753B\u9762\u98CE\u683C\u548C\u7C7B\u578B: {\u98CE\u683C}, {\u8272\u8C03}, {\u7C7B\u578B}

\u56FE\u7247\u5B9A\u4E49:
@\u56FE1: {\u8D44\u4EA71\u540D\u5B57}\uFF0C{\u7B80\u8FF0}
@\u56FE2: {\u8D44\u4EA72\u540D\u5B57}\uFF0C{\u7B80\u8FF0}
@\u56FEN: {\u8D44\u4EA7N\u540D\u5B57}\uFF0C{\u7B80\u8FF0}
...

\u751F\u6210\u4E00\u4E2A\u7531\u4EE5\u4E0B 1 \u4E2A\u5206\u955C\u7EC4\u6210\u7684\u89C6\u9891:

\u573A\u666F:
\u5206\u955C\u8FC7\u6E21: \u65E0

\u5206\u955C1 {N}s: \u65F6\u95F4\uFF1A{\u65E5/\u591C/\u6668/\u9EC4\u660F}\uFF0C\u573A\u666F\uFF1A{\u573A\u666F\u540D\u5B57}\uFF0C\u955C\u5934\uFF1A{\u666F\u522B}\uFF0C{\u89D2\u5EA6}\uFF0C{\u8FD0\u955C}\uFF0C{\u89D2\u8272\u540D\u5B57} {\u52A8\u4F5C/\u8868\u60C5/\u89C6\u7EBF\u671D\u5411/\u7AD9\u4F4D\u63CF\u8FF0}\u3002{\u53F0\u8BCD\u4E0E\u97F3\u8272\u63CF\u8FF0\uFF08\u5982\u6709\uFF09}\u3002{\u80CC\u666F\u73AF\u5883\u8865\u5145}\u3002{\u5149\u5F71\u6C1B\u56F4}\u3002{\u8FD0\u955C\u8865\u5145}\u3002
\`\`\`

**\u591A\u5206\u955C\u6A21\u677F\uFF1A**
\`\`\`
\u753B\u9762\u98CE\u683C\u548C\u7C7B\u578B: {\u98CE\u683C}, {\u8272\u8C03}, {\u7C7B\u578B}

\u56FE\u7247\u5B9A\u4E49:
@\u56FE1: {\u8D44\u4EA71\u540D\u5B57}\uFF0C{\u7B80\u8FF0}
@\u56FE2: {\u8D44\u4EA72\u540D\u5B57}\uFF0C{\u7B80\u8FF0}
@\u56FEN: {\u8D44\u4EA7N\u540D\u5B57}\uFF0C{\u7B80\u8FF0}
...

\u751F\u6210\u4E00\u4E2A\u7531\u4EE5\u4E0B {N} \u4E2A\u5206\u955C\u7EC4\u6210\u7684\u89C6\u9891:

\u573A\u666F:
\u5206\u955C\u8FC7\u6E21: {\u5168\u5C40\u8FC7\u6E21\u63CF\u8FF0}

\u5206\u955C1 {N}s: \u65F6\u95F4\uFF1A{...}\uFF0C\u573A\u666F\uFF1A{\u573A\u666F\u540D\u5B57}\uFF0C\u955C\u5934\uFF1A{...}\uFF0C{\u89D2\u8272\u540D\u5B57} {...}\u3002{...}\u3002
\u5206\u955C2{N}s: ...
...
\`\`\`

#### \u97F3\u8272\u751F\u6210\u89C4\u5219\uFF08\u6709\u53F0\u8BCD\u65F6\u5FC5\u586B\uFF09

\u53F0\u8BCD\u683C\u5F0F\uFF1A\`{\u89D2\u8272\u540D\u5B57} \u8BF4\uFF1A\u300C{\u53F0\u8BCD\u5185\u5BB9}\u300D\u97F3\u8272\uFF1A{9\u7EF4\u5EA6\u63CF\u8FF0}\`

9\u7EF4\u5EA6\u6309\u987A\u5E8F\u586B\u5199\uFF1A
\`\`\`
{\u6027\u522B}\uFF0C{\u5E74\u9F84\u97F3\u8272}\uFF0C{\u97F3\u8C03}\uFF0C{\u97F3\u8272\u8D28\u611F}\uFF0C{\u58F0\u97F3\u539A\u5EA6}\uFF0C{\u53D1\u97F3\u65B9\u5F0F}\uFF0C{\u6C14\u606F}\uFF0C{\u8BED\u901F}\uFF0C{\u7279\u6B8A\u8D28\u611F}
\`\`\`

> \u5F53 desc \u4E2D\u672A\u660E\u786E\u97F3\u8272\u4FE1\u606F\u65F6\uFF0C\u6839\u636E\u89D2\u8272\u7C7B\u578B\u4ECE\u4EE5\u4E0B\u53C2\u8003\u8868\u63A8\u65AD\uFF1A

| \u89D2\u8272\u7C7B\u578B\u7279\u5F81 | \u9ED8\u8BA4\u97F3\u8272 |
|------------|---------|
| \u7537\u6027\u6743\u5A01/\u9738\u6C14\u89D2\u8272 | \u7537\u58F0\uFF0C\u4E2D\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4F4E\u6C89\uFF0C\u97F3\u8272\u6D51\u539A\u6709\u529B\uFF0C\u58F0\u97F3\u539A\u91CD\uFF0C\u53D1\u97F3\u6807\u51C6\uFF0C\u6C14\u606F\u6781\u5176\u6C89\u7A33\uFF0C\u8BED\u901F\u504F\u6162 |
| \u5973\u6027\u6E29\u67D4/\u751C\u7F8E\u89D2\u8272 | \u5973\u58F0\uFF0C\u9752\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4E2D\u7B49\u504F\u9AD8\uFF0C\u97F3\u8272\u8D28\u611F\u660E\u4EAE\u6E05\u8106\uFF0C\u58F0\u97F3\u6E05\u4EAE\u67D4\u548C\uFF0C\u6C14\u606F\u5145\u6C9B\u5E73\u7A33\uFF0C\u5E26\u6E29\u5A49\u771F\u8BDA\u611F |
| \u7537\u6027\u5E74\u8F7B/\u666E\u901A\u89D2\u8272 | \u7537\u58F0\uFF0C\u9752\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4E2D\u7B49\uFF0C\u97F3\u8272\u5E72\u51C0\uFF0C\u58F0\u97F3\u539A\u5EA6\u9002\u4E2D\uFF0C\u53D1\u97F3\u6E05\u6670\uFF0C\u6C14\u606F\u5E73\u7A33\uFF0C\u8BED\u901F\u9002\u4E2D |
| \u5973\u6027\u6D3B\u6CFC/\u5916\u5411\u89D2\u8272 | \u5973\u58F0\uFF0C\u9752\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u504F\u9AD8\uFF0C\u97F3\u8272\u6E05\u8106\u6D3B\u6CFC\uFF0C\u58F0\u97F3\u8F7B\u76C8\uFF0C\u6C14\u606F\u5145\u6C9B\uFF0C\u8BED\u901F\u504F\u5FEB\uFF0C\u5E26\u7B11\u610F\u548C\u611F\u67D3\u529B |
| \u53CD\u6D3E/\u51B7\u9177\u89D2\u8272 | \u7537\u58F0\uFF0C\u4E2D\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4F4E\u6C89\uFF0C\u97F3\u8272\u8D28\u611F\u5E72\u71E5\u504F\u6697\uFF0C\u58F0\u97F3\u5E26\u6C99\u783E\u611F\uFF0C\u6C14\u606F\u5E73\u7A33\uFF0C\u8BED\u901F\u6781\u6162\uFF0C\u6709\u5A01\u80C1\u611F |

#### \u65E0\u53F0\u8BCD\u5206\u955C\u5904\u7406
- \u4E0D\u5199 \`\u8BF4\uFF1A\` \u548C\u97F3\u8272\u6BB5\u843D
- \u5728\u52A8\u4F5C\u63CF\u8FF0\u540E\u6807\u6CE8 \`\u65E0\u53F0\u8BCD\`

#### \u53F0\u8BCD\u7C7B\u578B\u683C\u5F0F

| \u53F0\u8BCD\u7C7B\u578B | \u683C\u5F0F | \u5634\u578B\u63CF\u8FF0 |
|----------|------|----------|
| \u666E\u901A\u5BF9\u767D | \`{\u89D2\u8272\u540D\u5B57} \u8BF4\uFF1A\u300C{\u53F0\u8BCD}\u300D\u97F3\u8272\uFF1A{9\u7EF4\u5EA6}\` | \u89D2\u8272\u5634\u90E8\u5F00\u5408\u8BF4\u8BDD |
| \u5185\u5FC3\u72EC\u767D | \`{\u89D2\u8272\u540D\u5B57} \u5185\u5FC3OS\uFF1A\u300C{\u53F0\u8BCD}\u300D\u97F3\u8272\uFF1A{9\u7EF4\u5EA6}\` | \u89D2\u8272\u5634\u90E8\u7D27\u95ED\u4E0D\u52A8 |
| \u753B\u5916\u97F3 | \`{\u89D2\u8272\u540D\u5B57} \u753B\u5916\u97F3VO\uFF1A\u300C{\u53F0\u8BCD}\u300D\u97F3\u8272\uFF1A{9\u7EF4\u5EA6}\` | \u89D2\u8272\u5634\u90E8\u7D27\u95ED\u4E0D\u52A8\uFF08\u6216\u89D2\u8272\u4E0D\u5728\u753B\u9762\u4E2D\uFF09 |

#### \u751F\u6210\u7EA6\u675F
1. **\u4E2D\u6587\u63D0\u793A\u8BCD**
2. **\u76F4\u63A5\u8F93\u51FA\u89C6\u9891\u63D0\u793A\u8BCD**\uFF1A\u7981\u6B62\u8F93\u51FA\u4EFB\u4F55\u5206\u6790\u8FC7\u7A0B\u3001\u63A8\u7406\u6B65\u9AA4\u3001\u6A21\u578B\u5339\u914D\u8BF4\u660E\u3001\u8D44\u4EA7\u7F16\u53F7\u8868\u3001\u5206\u9694\u7EBF\u7B49\u975E\u63D0\u793A\u8BCD\u5185\u5BB9\u3002\u7B2C\u4E00\u884C\u5FC5\u987B\u662F \`\u753B\u9762\u98CE\u683C\u548C\u7C7B\u578B:\`
3. **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u6BCF\u6761\u5206\u955C\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u4FE1\u606F
4. **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u548C\u97F3\u8272
5. **\u53F0\u8BCD\u7C7B\u578B\u6B63\u786E\u6807\u6CE8**\uFF1A\u666E\u901A\u5BF9\u767D\u7528\u300C\u8BF4\uFF1A\u300D\uFF0C\u5185\u5FC3\u72EC\u767D\u7528\u300C\u5185\u5FC3OS\uFF1A\u300D\uFF0C\u753B\u5916\u97F3\u7528\u300C\u753B\u5916\u97F3VO\uFF1A\u300D
6. **\u5148\u56FE\u7247\u5B9A\u4E49\uFF0C\u540E\u5199\u5206\u955C**\uFF1A\u6700\u524D\u9762\u5FC5\u987B\u5148\u8F93\u51FA"\u56FE\u7247\u5B9A\u4E49"\u6BB5\uFF0C\u5217\u51FA \`@\u56FEN : \u540D\u5B57\uFF0C\u63CF\u8FF0\`
7. **\u5206\u955C\u6B63\u6587\u7981\u7528 \`@\u56FEN \`**\uFF1A\u6B63\u6587\u7EDF\u4E00\u4F7F\u7528\u89D2\u8272\u540D/\u573A\u666F\u540D\uFF0C\u4E0D\u5199 \`@\u56FE1/@\u56FE2\` \u7B49\u7F16\u53F7
8. **\u5355\u5206\u955C\u65F6\u957F\u6700\u4F4E 1s**
9. **\u65F6\u957F\u5355\u4F4D**\uFF1A\u76F4\u63A5\u4F7F\u7528 videoDesc \u4E2D\u7684\u79D2\u6570\uFF0C\u683C\u5F0F\u4E3A \`{N}s\`\uFF08\u5982 \`4s\`\uFF09\uFF0C\u6700\u4F4E 1s

#### Seedance 2.0 \u5B8C\u6574\u793A\u4F8B

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1ASeedance2.0
\u8D44\u4EA7\u4FE1\u606F[A001, role, \u6C88\u8F9E], [A002, role, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730\u3001\u57CE\u697C\u3001\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u5168\u666F\u3001\u9759\u6B62\u3001\u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C\u3001\u575A\u5B9A\u51B3\u7EDD\u3001\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149\u3001\u65E0\u53F0\u8BCD\u3001\u98CE\u58F0\u8863\u8882\u58F0\u3001A001/A003\uFF09' prompt='\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u57CE\u697C\u4E4B\u4E0A\uFF0C\u6C88\u8F9E\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u98D8\u626C\uFF0C\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
<storyboardItem videoDesc='\uFF08\u82CF\u9526\u767B\u4E0A\u57CE\u697C\u8D70\u5411\u6C88\u8F9E\u3001\u57CE\u697C\u3001\u82CF\u9526/\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u4E2D\u666F\u3001\u8DDF\u8E2A\u3001\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u6C88\u8F9E\u3001\u62C5\u5FE7\u3001\u9EC4\u660F\u4F59\u6656\u6E10\u6697\u3001\u82CF\u9526\u8BF4\uFF1A\u4F60\u53C8\u4E00\u4E2A\u4EBA\u5728\u8FD9\u91CC\u3001\u811A\u6B65\u58F0\u98CE\u58F0\u3001A001/A002/A003\uFF09' prompt='\u4E2D\u666F\uFF0C\u8DDF\u8E2A\uFF0C\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u57CE\u697C\u4E0A\u7684\u6C88\u8F9E...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A002&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
\u753B\u9762\u98CE\u683C\u548C\u7C7B\u578B: \u771F\u4EBA\u5199\u5B9E, \u7535\u5F71\u98CE\u683C, \u51B7\u8C03, \u53E4\u98CE

\u53C2\u8003\u5B9A\u4E49:
@\u56FE1: \u6C88\u8F9E\uFF0C\u9ED1\u8272\u957F\u888D\uFF0C\u6C14\u8D28\u51B7\u5CFB\u7684\u9752\u5E74\u7537\u6027
@\u56FE2: \u82CF\u9526\uFF0C\u6D45\u8272\u8863\u88D9\uFF0C\u795E\u60C5\u7EC6\u817B\u7684\u9752\u5E74\u5973\u6027
@\u56FE3: \u57CE\u697C\uFF0C\u53E4\u4EE3\u7816\u77F3\u57CE\u697C\u4E0E\u53F0\u9636\u573A\u666F

\u751F\u6210\u4E00\u4E2A\u7531\u4EE5\u4E0B 2 \u4E2A\u5206\u955C\u7EC4\u6210\u7684\u89C6\u9891:

\u573A\u666F:
\u5206\u955C\u8FC7\u6E21: \u955C\u5934\u5E73\u6ED1\u5207\u6362\uFF0C\u4ECE\u5168\u666F\u8FC7\u6E21\u5230\u4E2D\u666F\u8DDF\u8E2A\uFF0C\u7126\u70B9\u4ECE\u6C88\u8F9E\u72EC\u5904\u8F6C\u5411\u82CF\u9526\u5230\u6765\u3002

\u5206\u955C1 4s: \u65F6\u95F4\uFF1A\u9EC4\u660F\uFF0C\u573A\u666F\uFF1A\u57CE\u697C\uFF0C\u955C\u5934\uFF1A\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u9759\u6B62\u955C\u5934\uFF0C\u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u4E4B\u4E0A\uFF0C\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u968F\u98CE\u98D8\u626C\uFF0C\u76EE\u5149\u8FDC\u773A\u82CD\u832B\u5927\u5730\uFF0C\u795E\u60C5\u8083\u7136\u9762\u5BB9\u6C89\u7740\uFF0C\u773C\u795E\u575A\u5B9A\u76EE\u5149\u6E05\u51BD\uFF0C\u7709\u773C\u6C89\u9759\u6C14\u8D28\u51DB\u7136\u3002\u65E0\u53F0\u8BCD\u3002\u80CC\u666F\u662F\u53E4\u57CE\u697C\u7816\u77F3\u7EB9\u7406\u6E05\u6670\uFF0C\u8FDC\u65B9\u5927\u5730\u82CD\u832B\u8FBD\u9614\uFF0C\u5929\u9645\u7EBF\u51B7\u6696\u4EA4\u66FF\u3002\u9EC4\u660F\u659C\u5C04\u4F59\u6656\u4FA7\u9006\u5149\uFF0C\u51B7\u8C03\u4E3A\u4E3B\uFF0C\u957F\u5F71\u62C9\u4F38\uFF0C\u8F6E\u5ED3\u5149\u5FAE\u52FE\u52D2\u4EBA\u7269\u8FB9\u7F18\uFF0C\u5149\u611F\u8BD7\u610F\u3002\u955C\u5934\u9759\u6B62\u3002

\u5206\u955C2 4s: \u65F6\u95F4\uFF1A\u9EC4\u660F\uFF0C\u573A\u666F\uFF1A\u57CE\u697C\uFF0C\u955C\u5934\uFF1A\u4E2D\u666F\uFF0C\u5E73\u89C6\uFF0C\u8DDF\u8E2A\u62CD\u6444\uFF0C\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\uFF0C\u8D70\u5411\u57CE\u697C\u4E0A\u7684\u6C88\u8F9E\uFF0C\u9762\u90E8\u671D\u5411\u6C88\u8F9E\u65B9\u5411\uFF0C\u795E\u60C5\u5FAE\u6123\u9762\u8272\u5FAE\u53D8\uFF0C\u773C\u795E\u4E2D\u5E26\u7740\u62C5\u5FE7\uFF0C\u82CF\u9526\u8BF4\uFF1A\u300C\u4F60\u53C8\u4E00\u4E2A\u4EBA\u5728\u8FD9\u91CC\u3002\u300D\u97F3\u8272\uFF1A\u5973\u58F0\uFF0C\u9752\u5E74\u97F3\u8272\uFF0C\u97F3\u8C03\u4E2D\u7B49\u504F\u9AD8\uFF0C\u97F3\u8272\u8D28\u611F\u660E\u4EAE\u6E05\u8106\uFF0C\u58F0\u97F3\u6E05\u4EAE\u67D4\u548C\uFF0C\u53D1\u97F3\u65B9\u5F0F\u5E72\u51C0\uFF0C\u6C14\u606F\u5145\u6C9B\u5E73\u7A33\uFF0C\u8BED\u901F\u9002\u4E2D\uFF0C\u5E26\u6E29\u5A49\u771F\u8BDA\u611F\u3002\u80CC\u666F\u57CE\u697C\u53F0\u9636\u7EB9\u7406\u6E05\u6670\uFF0C\u4F59\u6656\u6E10\u6697\uFF0C\u5929\u9645\u7EBF\u51B7\u6696\u4EA4\u66FF\u52A0\u6DF1\u3002\u955C\u5934\u8DDF\u8E2A\u82CF\u9526\u79FB\u52A8\u3002
\`\`\`

---

### \u56DB\u3001Wan 2.6

#### \u6838\u5FC3\u539F\u5219
- **\u5355\u56FE\u9996\u5E27\u6A21\u5F0F**\uFF1A\u5F52\u7C7B\u4E3A\u9996\u5C3E\u5E27\u6A21\u5F0F\uFF0C\u4F46\u4EC5\u6709\u9996\u5E27\uFF08\u5206\u955C\u56FE\uFF09\uFF0C\u65E0\u5C3E\u5E27
- **\u5355\u6761\u5206\u955C\u8F93\u5165/\u8F93\u51FA**\uFF1A\u6BCF\u6B21\u4EC5\u8F93\u5165\u4E00\u6761 \`<storyboardItem>\` \u53CA\u5176\u5173\u8054\u8D44\u4EA7\u4FE1\u606F\uFF0C\u8F93\u51FA\u4E5F\u4EC5\u4E3A\u4E00\u6BB5\u5B8C\u6574\u7684\u53D9\u4E8B\u5F0F\u63D0\u793A\u8BCD
- **\u53D9\u4E8B\u5F0F\u82F1\u6587\u63D0\u793A\u8BCD**\uFF1A\u50CF\u5199\u5C0F\u8BF4\u4E00\u6837\u63CF\u5199\u753B\u9762\uFF0C\u4E0D\u4F7F\u7528\u6807\u7B7E\u7F57\u5217\uFF08\u4E0D\u5199 \`4K, cinematic, high quality\` \u8FD9\u7C7B\u5806\u780C\uFF09
- **\u4E09\u6BB5\u5F0F\u7ED3\u6784**\uFF1A\u98CE\u683C\u57FA\u8C03 \u2192 \u4E3B\u4F53\u52A8\u4F5C + \u573A\u666F\u73AF\u5883 + \u5149\u7EBF\u6C1B\u56F4 \u2192 \u955C\u5934\u6536\u5C3E
- **\u7EAF\u6587\u672C\u63D0\u793A\u8BCD**\uFF1A\u63D0\u793A\u8BCD\u5185**\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528**\uFF0C\u5168\u90E8\u5185\u5BB9\u7528\u7EAF\u6587\u672C\u63CF\u8FF0
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728\u63D0\u793A\u8BCD\u4E2D\u4F53\u73B0\u53F0\u8BCD\u76F8\u5173\u63CF\u8FF0
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08dialogue\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08inner monologue OS\uFF09\u3001\u753B\u5916\u97F3\uFF08voiceover VO\uFF09\uFF0C\u5728\u63D0\u793A\u8BCD\u4E2D\u7528\u62EC\u53F7\u6807\u6CE8

#### prompt \u751F\u6210\u6A21\u677F

\u6BCF\u6B21\u8F93\u5165\u4E00\u6761\u5206\u955C\uFF0C\u8F93\u51FA\u4E00\u6BB5\u5B8C\u6574\u63D0\u793A\u8BCD\uFF08\u65E0\u7F16\u53F7\u524D\u7F00\uFF09\uFF0C\u683C\u5F0F\u5982\u4E0B\uFF1A

\`\`\`
{\u98CE\u683C\u57FA\u8C03\u4E00\u53E5\u8BDD\u5B9A\u6027},
{\u4E3B\u4F53\u540D} {\u5916\u89C2\u7B80\u8FF0}, {\u5177\u4F53\u52A8\u4F5C/\u59FF\u6001\u63CF\u8FF0}, {\u60C5\u7EEA/\u8868\u60C5\u7528\u52A8\u4F5C\u6697\u793A}.
{\u573A\u666F\u80CC\u666F\u4E3B\u4F53}, {\u5177\u4F53\u73AF\u5883\u7269\u4EF6}, {\u7A7A\u95F4\u611F}, {\u65F6\u95F4/\u5929\u6C14}.
{\u5149\u7EBF\u65B9\u5411/\u8272\u6E29} {\u8D28\u611F\u63CF\u8FF0}, {\u60C5\u7EEA\u6697\u793A\u5149\u5F71}.
{\u53F0\u8BCD\u63CF\u8FF0\uFF08\u5982\u6709\uFF0C\u542B dialogue/OS/VO \u6807\u6CE8\uFF09/ No dialogue}.
{\u97F3\u6548\u63CF\u8FF0}.
{\u62CD\u6444\u65B9\u5F0F}, {\u666F\u522B}, {\u89C6\u89D2}, {\u8FD0\u955C\u65B9\u5F0F}.
\`\`\`

#### \u53D9\u4E8B\u5F0F\u5199\u6CD5\u8981\u70B9

| \u539F\u5219 | \u8BF4\u660E | \u793A\u4F8B |
|------|------|------|
| \u98CE\u683C\u57FA\u8C03\u653E\u6700\u524D | \u4E00\u53E5\u8BDD\u5B9A\u6027\u6574\u4F53\u6C14\u8D28 | \`A cinematic epic scene\` / \`A melancholic cinematic scene\` |
| \u4E3B\u4F53+\u52A8\u4F5C\u7D27\u5BC6\u7ED1\u5B9A | \u4E3B\u4F53\u540E\u9762\u76F4\u63A5\u8DDF\u52A8\u4F5C\uFF0C\u5916\u89C2\u7EC6\u8282\u5D4C\u5165\u4E3B\u4F53\u63CF\u8FF0 | \`A young man in dark flowing robes stands alone atop the city wall, hands clasped behind back\` |
| \u60C5\u7EEA\u7528\u52A8\u4F5C\u6697\u793A | \u4E0D\u76F4\u63A5\u9648\u8FF0\u300C\u4ED6\u5F88\u60B2\u4F24\u300D | \u274C \`He is sad.\` \u2192 \u2705 \`head drops slowly, shoulders slumped\` |
| \u73AF\u5883\u878D\u5165\u53D9\u4E8B | \u4E0D\u7F57\u5217\u73AF\u5883\u5C5E\u6027 | \u274C \`The sky is blue. The grass is green.\` \u2192 \u2705 \`hazy blue sky stretches over the emerald valley\` |
| \u5149\u7EBF\u5355\u72EC\u6210\u53E5 | \u5149\u7EBF\u65B9\u5411+\u8272\u6E29+\u8D28\u611F+\u60C5\u7EEA | \`Warm golden hour light streams from behind, casting long shadows across the stone floor\` |
| \u955C\u5934\u8BED\u8A00\u6536\u5C3E | \u4E00\u53E5\u8BDD\u70B9\u775B | \`Captured in a wide establishing shot from a low-angle perspective, static camera\` |
| \u7981\u6B62\u6807\u7B7E\u5806\u780C | \u4E0D\u5199 \`4K, cinematic, high quality\` | \`cinematic\` \u878D\u5165\u98CE\u683C\u57FA\u8C03\u5373\u53EF |

#### \u751F\u6210\u7EA6\u675F
1. **\u5168\u90E8\u7528\u82F1\u6587**
2. **\u4E0D\u4F7F\u7528\u4EFB\u4F55 \`@\u56FEN \` \u5F15\u7528**\uFF1A\u63D0\u793A\u8BCD\u5185\u4E0D\u5F15\u7528\u89D2\u8272\u8D44\u4EA7\u3001\u573A\u666F\u8D44\u4EA7\u3001\u5206\u955C\u56FE\uFF0C\u5168\u90E8\u5185\u5BB9\u7528\u7EAF\u6587\u672C\u63CF\u8FF0
3. **\u53D9\u4E8B\u5F0F\u63CF\u5199**\uFF1A\u50CF\u5199\u5C0F\u8BF4\u4E00\u6837\u6784\u5EFA\u753B\u9762\uFF0C\u7981\u6B62\u6807\u7B7E\u7F57\u5217\u548C\u914D\u7F6E\u6E05\u5355\u5F0F\u5199\u6CD5
4. **\u4E3B\u4F53\u7528\u6587\u5B57\u63CF\u8FF0**\uFF1A\u7B80\u8981\u63CF\u8FF0\u4E3B\u4F53\u5916\u89C2\u7279\u5F81\uFF08\u5982\u670D\u9970\u3001\u53D1\u578B\u7B49\u5173\u952E\u8FA8\u8BC6\u7279\u5F81\uFF09\uFF0C\u5D4C\u5165\u4E3B\u4F53\u63CF\u8FF0\u4E2D
5. **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u4FE1\u606F
6. **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728\u63D0\u793A\u8BCD\u4E2D\u5B8C\u6574\u8F93\u51FA\u53F0\u8BCD\u5185\u5BB9\uFF08\u4FDD\u6301\u539F\u59CB\u8BED\u8A00\uFF0C\u4E0D\u7FFB\u8BD1\uFF09
7. **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF1A\u666E\u901A\u5BF9\u767D\u6807\u6CE8 \`(dialogue)\`\uFF1B\u5185\u5FC3\u72EC\u767D\u6807\u6CE8 \`(inner monologue, OS)\`\uFF1B\u753B\u5916\u97F3\u6807\u6CE8 \`(voiceover, VO)\`
8. **\u5355\u6761\u8F93\u5165/\u8F93\u51FA**\uFF1A\u6BCF\u6B21\u4EC5\u5904\u7406\u4E00\u6761\u5206\u955C\uFF0C\u8F93\u51FA\u4E00\u6BB5\u63D0\u793A\u8BCD\uFF0C\u65E0\u7F16\u53F7\u524D\u7F00
9. **\u65E0\u9700\u6807\u6CE8\u65F6\u957F**\uFF1A\u65F6\u957F\u7531\u6A21\u578B\u4FA7\u63A7\u5236\uFF0C\u63D0\u793A\u8BCD\u4E2D\u4E0D\u5199\u65F6\u957F\u53C2\u6570
10. **\u955C\u5934\u63CF\u8FF0\u878D\u5165\u53D9\u4E8B**\uFF1A\u4E0D\u7528\u65B9\u62EC\u53F7\u6807\u7B7E\uFF0C\u7528\u5B8C\u6574\u53E5\u5B50\u63CF\u8FF0\u955C\u5934
11. **\u89C6\u89C9\u98CE\u683C**\u53C2\u8003 Assistant \u4E2D\u7684\u300C\u89C6\u89C9\u98CE\u683C\u7EA6\u675F\u300D\u90E8\u5206\u5185\u5BB9

#### Wan 2.6 \u5B8C\u6574\u793A\u4F8B

**\u793A\u4F8B1\uFF1A\u65E0\u53F0\u8BCD\u5206\u955C**

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1AWan2.6
\u8D44\u4EA7\u4FE1\u606F[A001, role, \u6C88\u8F9E], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u6C88\u8F9E\u72EC\u7ACB\u57CE\u697C\u8FDC\u773A\u82CD\u832B\u5927\u5730\u3001\u57CE\u697C\u3001\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u5168\u666F\u3001\u9759\u6B62\u3001\u8D1F\u624B\u800C\u7ACB\u8863\u8882\u968F\u98CE\u98D8\u626C\u3001\u575A\u5B9A\u51B3\u7EDD\u3001\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149\u3001\u65E0\u53F0\u8BCD\u3001\u98CE\u58F0\u8863\u8882\u58F0\u3001A001/A003\uFF09' prompt='\u5168\u666F\uFF0C\u5E73\u89C6\u7565\u4EF0\uFF0C\u57CE\u697C\u4E4B\u4E0A\uFF0C\u6C88\u8F9E\u8D1F\u624B\u800C\u7ACB\uFF0C\u8863\u8882\u98D8\u626C\uFF0C\u9EC4\u660F\u51B7\u8C03\u4FA7\u9006\u5149...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
A cinematic epic scene with a cold, desaturn\`ated palette,
A lone man in dark flowing robes stands atop an ancient city wall, hands clasped behind his back, robes and hair billowing in the wind, gaze fixed on the vast land stretching to the horizon, jaw set firm, eyes unwavering.
The weathered stone battlements frame the endless expanse below, rolling terrain fading into haze beneath a heavy dusk sky, clouds layered in muted golds and slate greys.
Cold side-backlight from the setting sun carves a sharp silhouette, long shadows stretching across the stone floor, a faint warm rim outlining the figure against the cool atmosphere.
No dialogue.
Wind howling across the open wall, fabric flapping rhythmically.
Captured in a wide establishing shot from a slightly low angle, static camera, single continuous take.
\`\`\`

**\u793A\u4F8B2\uFF1A\u6709\u53F0\u8BCD\u5206\u955C**

\u8F93\u5165\uFF1A
\`\`\`
\u6A21\u578B\uFF1AWan2.6
\u8D44\u4EA7\u4FE1\u606F[A001, role, \u6C88\u8F9E], [A002, role, \u82CF\u9526], [A003, scene, \u57CE\u697C]
\`\`\`
\`\`\`xml
<storyboardItem videoDesc='\uFF08\u82CF\u9526\u767B\u4E0A\u57CE\u697C\u8D70\u5411\u6C88\u8F9E\u3001\u57CE\u697C\u3001\u82CF\u9526/\u6C88\u8F9E/\u57CE\u697C\u30014s\u3001\u4E2D\u666F\u3001\u8DDF\u8E2A\u3001\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u6C88\u8F9E\u3001\u62C5\u5FE7\u3001\u9EC4\u660F\u4F59\u6656\u6E10\u6697\u3001\u82CF\u9526\u8BF4\uFF1A\u4F60\u53C8\u4E00\u4E2A\u4EBA\u5728\u8FD9\u91CC\u3001\u811A\u6B65\u58F0\u98CE\u58F0\u3001A001/A002/A003\uFF09' prompt='\u4E2D\u666F\uFF0C\u8DDF\u8E2A\uFF0C\u82CF\u9526\u62FE\u7EA7\u800C\u4E0A\u8D70\u5411\u57CE\u697C\u4E0A\u7684\u6C88\u8F9E...' track='main' duration='4' associateAssetsIds="[&quot;A001&quot;,&quot;A002&quot;,&quot;A003&quot;]" shouldGenerateImage="true" ></storyboardItem>
\`\`\`

\u8F93\u51FA\uFF1A
\`\`\`
A melancholic cinematic scene, dusk tones deepening,
A young woman in a light-colored dress ascends the final stone steps onto the city wall, her gaze locked on the lone figure ahead, brow slightly furrowed, pace slowing as she approaches, lips parting softly.
The ancient city wall stretches behind her, weathered stairs leading up from below, the distant skyline dimming as the last traces of golden hour fade into twilight.
Fading warm light mingles with rising cool blue tones, the contrast between the two figures softened by the diffused remnants of sunset.
"\u4F60\u53C8\u4E00\u4E2A\u4EBA\u5728\u8FD9\u91CC\u3002" \u2014 Su Jin (dialogue).
Footsteps on stone, wind sweeping across the battlements, fabric rustling.
A medium tracking shot follows the woman from behind as she ascends and approaches, handheld camera with subtle movement, single continuous take.
\`\`\`

---

## \u666F\u522B \u2192 \u955C\u5934\u6807\u7B7E\u6620\u5C04

| videoDesc \u4E2D\u7684\u666F\u522B | KlingOmni\uFF08\u82F1\u6587\u6807\u7B7E\uFF09 | Seedance 1.5\uFF08\u82F1\u6587\u6807\u7B7E\uFF09 | Seedance 2.0\uFF08\u4E2D\u6587\u63CF\u8FF0\uFF09 | Wan 2.6\uFF08\u82F1\u6587\u53D9\u4E8B\u5F0F\uFF09 |
|------|------|------|------|------|
| \u8FDC\u666F | extreme wide shot | Extreme wide shot | \u8FDC\u666F | an extreme wide shot capturing the vast expanse |
| \u5168\u666F | wide shot | Wide establishing shot | \u5168\u666F | a wide establishing shot |
| \u4E2D\u666F | medium shot | Medium shot | \u4E2D\u666F | a medium shot |
| \u8FD1\u666F | close-up | Close-up | \u8FD1\u666F | a close-up shot |
| \u7279\u5199 | close-up | Close-up | \u7279\u5199 | a close-up capturing fine detail |
| \u5927\u7279\u5199 | extreme close-up | Extreme close-up | \u5927\u7279\u5199 | an extreme close-up |

## \u8FD0\u955C \u2192 \u955C\u5934\u6807\u7B7E\u6620\u5C04

| videoDesc \u4E2D\u7684\u8FD0\u955C | KlingOmni\uFF08\u82F1\u6587\u6807\u7B7E\uFF09 | Seedance 1.5\uFF08\u82F1\u6587\u6807\u7B7E\uFF09 | Seedance 2.0\uFF08\u4E2D\u6587\u63CF\u8FF0\uFF09 | Wan 2.6\uFF08\u82F1\u6587\u53D9\u4E8B\u5F0F\uFF09 |
|------|------|------|------|------|
| \u9759\u6B62 | static camera | Static, no camera movement | \u955C\u5934\u9759\u6B62 | static camera, locked off |
| \u63A8\u8FDB | dolly in / push in | Slow dolly forward | \u955C\u5934\u7F13\u6162\u5411\u524D\u63A8\u8FDB | camera slowly pushing in |
| \u62C9\u8FDC | dolly out / pull back | Slow dolly backward pull | \u955C\u5934\u7F13\u6162\u5411\u540E\u62C9\u8FDC | camera gently pulling back |
| \u8DDF\u8E2A | tracking shot | Tracking shot, handheld | \u8DDF\u8E2A\u62CD\u6444 | tracking shot following the subject |
| \u6447\u955C | pan left/right | Slow pan | \u955C\u5934\u7F13\u6162\u6447\u79FB | smooth pan across the scene |
| \u7529\u955C | whip pan | Whip pan | \u5FEB\u901F\u7529\u955C | whip pan |
| \u5347\u964D | crane up/down | Crane up/down | \u955C\u5934\u5347\u964D | crane rising / descending |
| \u73AF\u7ED5 | surround shooting | Orbiting shot | \u73AF\u7ED5\u62CD\u6444 | orbiting around the subject |

---

## \u6267\u884C\u6D41\u7A0B

1. **\u89E3\u6790\u8F93\u5165**\uFF1A\u63D0\u53D6\u6A21\u578B\u540D\u548C\u591A\u53C2\u6807\u5FD7\uFF0C\u6309\u8DEF\u7531\u89C4\u5219\u5339\u914D\u6A21\u5F0F\uFF1B\u63D0\u53D6\u8D44\u4EA7\u5217\u8868
2. **\u6784\u5EFA @\u56FEN \u7F16\u53F7\u8868**\uFF1A\u8D44\u4EA7\u6309\u8F93\u5165\u987A\u5E8F\u4ECE \`@\u56FE1 \` \u8D77\u7F16\u53F7\uFF0C\u5206\u955C\u56FE\u63A5\u7EED\u7F16\u53F7\uFF1B\`shouldGenerateImage="false"\` \u7684\u5206\u955C\u4E0D\u5206\u914D\u5206\u955C\u56FE\u7F16\u53F7
3. **\u9010\u6761\u89E3\u6790 \`<storyboardItem>\`**\uFF1A\u6309 videoDesc \u89E3\u6790\u89C4\u5219\u63D0\u53D612\u4E2A\u5B57\u6BB5\uFF0C\u7ED3\u5408 \`duration\`\u3001\`associateAssetsIds\` \u5EFA\u7ACB\u6807\u7B7E\u6620\u5C04
4. **\u6574\u5408\u4E3A\u4E00\u4E2A\u5B8C\u6574\u7684\u89C6\u9891\u63D0\u793A\u8BCD**\uFF1A\u6309\u76EE\u6807\u6A21\u578B\u683C\u5F0F\u7F16\u6392\u5168\u90E8\u5206\u955C
5. **\u8F93\u51FA\u89C6\u9891\u63D0\u793A\u8BCD**

---

## \u7EA6\u675F

- **\u4EC5\u8F93\u51FA\u89C6\u9891\u63D0\u793A\u8BCD**\uFF1A\u4E0D\u9644\u52A0\u4EFB\u4F55\u89E3\u91CA\u3001\u6CE8\u91CA\u3001\u5206\u6790\u8FC7\u7A0B\u3001\u63A8\u7406\u6B65\u9AA4\u3001\u6A21\u578B\u5339\u914D\u8BF4\u660E\u3001\u8D44\u4EA7\u7F16\u53F7\u8868\u3001\u5206\u9694\u7EBF\uFF08\`---\`\uFF09\u6216\u989D\u5916\u8BF4\u660E\uFF0C\u53EA\u8F93\u51FA\u89C6\u9891\u63D0\u793A\u8BCD\u6587\u672C\u3002\u7981\u6B62\u5728\u63D0\u793A\u8BCD\u524D\u540E\u8F93\u51FA\u4EFB\u4F55\u975E\u63D0\u793A\u8BCD\u5185\u5BB9
- **\u4E25\u683C\u9075\u5FAA videoDesc**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1A\u63D0\u793A\u8BCD\u5185\u5BB9\u4E25\u683C\u57FA\u4E8E videoDesc \u4E2D\u7684\u753B\u9762\u63CF\u8FF0\u3001\u65F6\u957F\u3001\u666F\u522B\u3001\u8FD0\u955C\u3001\u89D2\u8272\u52A8\u4F5C\u3001\u60C5\u7EEA\u3001\u5149\u5F71\u6C1B\u56F4\u3001\u53F0\u8BCD\u3001\u97F3\u6548\u5B57\u6BB5\u751F\u6210\uFF0C\u4E0D\u7F16\u9020\u989D\u5916\u5185\u5BB9
- **\u53F0\u8BCD\u4E0D\u53EF\u7F3A\u5931**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1AvideoDesc \u4E2D\u6709\u53F0\u8BCD\u7684\u5206\u955C\uFF0C\u5FC5\u987B\u5728\u63D0\u793A\u8BCD\u4E2D\u5B8C\u6574\u4F53\u73B0\u53F0\u8BCD\u5185\u5BB9\uFF0C\u4E0D\u5F97\u9057\u6F0F
- **\u53F0\u8BCD\u4FDD\u6301\u539F\u59CB\u8F93\u5165**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1A\u53F0\u8BCD\u5185\u5BB9\u4E25\u7981\u7FFB\u8BD1\uFF0C\u5FC5\u987B\u4FDD\u6301 videoDesc \u4E2D\u7684\u539F\u59CB\u8BED\u8A00\u539F\u6837\u8F93\u51FA
- **\u53F0\u8BCD\u7C7B\u578B\u6807\u6CE8**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1A\u5FC5\u987B\u533A\u5206\u666E\u901A\u5BF9\u767D\uFF08dialogue / \u8BF4\uFF09\u3001\u5185\u5FC3\u72EC\u767D\uFF08OS / \u5185\u5FC3OS\uFF09\u3001\u753B\u5916\u97F3\uFF08VO / \u753B\u5916\u97F3VO\uFF09\uFF0C\u5E76\u5728\u63D0\u793A\u8BCD\u4E2D\u6B63\u786E\u6807\u6CE8
- **\u65F6\u95F4\u8DE8\u5EA6\u6700\u4F4E 1 \u79D2**\uFF08\u5168\u6A21\u5F0F\u901A\u7528\uFF09\uFF1A\u6240\u6709\u6A21\u5F0F\u4E2D\u6D89\u53CA\u65F6\u95F4\u5206\u6BB5\uFF08Motion \u65F6\u95F4\u8F74 / Seedance 2.0 \u5206\u955C\u65F6\u957F {N}s\uFF09\u7684\u6700\u5C0F\u7C92\u5EA6\u4E3A 1 \u79D2\uFF081s\uFF09\uFF0C\u7981\u6B62\u51FA\u73B0 0.5 \u79D2\u7B49\u4F4E\u4E8E 1 \u79D2\u7684\u95F4\u9694
- **\u89C6\u89C9\u98CE\u683C**\uFF1A\u98CE\u683C\u76F8\u5173\u63CF\u8FF0\u53C2\u8003 Assistant \u4E2D\u7684\u300C\u89C6\u89C9\u98CE\u683C\u7EA6\u675F\u300D\u90E8\u5206\u5185\u5BB9\uFF0C\u4E0D\u5728\u672C Skill \u5185\u81EA\u884C\u5B9A\u4E49\u98CE\u683C
- **\u4E25\u683C\u6309\u5339\u914D\u5230\u7684\u6A21\u5F0F\u683C\u5F0F**\uFF0C\u4E0D\u6DF7\u7528\u4E0D\u540C\u6A21\u5F0F\u7684\u683C\u5F0F
- **\u4E0D\u4FEE\u6539\u539F\u59CB\u8F93\u5165**\uFF1A\u4E0D\u6539\u5199 \`<storyboardItem>\` \u7684\u4EFB\u4F55\u5B57\u6BB5\uFF1B\`prompt\` \u5DF2\u6709\u7684\u5206\u955C\u56FE\u63D0\u793A\u8BCD\u4EC5\u4F5C\u753B\u9762\u53C2\u8003
- **\u4E0D\u7F16\u9020\u8D44\u4EA7\u6216\u53F0\u8BCD**\uFF1A\u53EA\u4F7F\u7528\u8F93\u5165\u4E2D\u7684\u8D44\u4EA7\u4FE1\u606F\uFF1B\u65E0\u53F0\u8BCD\u5219\u6807\u6CE8\u300C\u65E0\u53F0\u8BCD\u300D/ \`No dialogue\`
- **\u65F6\u957F\u5355\u4F4D**\uFF1ASeedance 2.0 \u7684\u5206\u955C\u65F6\u957F\u76F4\u63A5\u4F7F\u7528\u79D2\uFF0C\u683C\u5F0F\u4E3A \`{N}s\`\uFF08\u5982 \`4s\`\uFF09\uFF0C\u6700\u4F4E 1s
`
      });
      const data = await knex3("o_vendorConfig").select("*");
      for (const item of data) {
        let { id, code } = item;
        const filename = `${id}.ts`;
        const rootDir = utils_default.getPath("vendor");
        if (!code && import_fs2.default.existsSync(import_path4.default.join(rootDir, filename))) continue;
        if (!import_fs2.default.existsSync(rootDir)) import_fs2.default.mkdirSync(rootDir, { recursive: true });
        if (!import_fs2.default.existsSync(import_path4.default.join(rootDir, filename))) {
          code = vendorData[filename] || code;
          code = code ?? "";
          import_fs2.default.writeFileSync(import_path4.default.join(rootDir, filename), code);
        }
      }
      const defList = Object.keys(vendorData).map((filename) => filename.replace(/\.ts$/, ""));
      const existingIds = data.map((i) => i.id);
      for (const id of defList) {
        if (!existingIds.includes(id)) {
          const tsCode = vendorData[`${id}.ts`];
          if (tsCode) await tempOnsert(tsCode);
        }
      }
      await dropColumn("o_vendorConfig", "author");
      await dropColumn("o_vendorConfig", "description");
      await dropColumn("o_vendorConfig", "name");
      await dropColumn("o_vendorConfig", "icon");
      await dropColumn("o_vendorConfig", "inputs");
      await dropColumn("o_vendorConfig", "createTime");
      const volcengineVer = await utils_default.vendor.getVendor("volcengine").version;
      if (Number(volcengineVer) < 2.3) {
        utils_default.vendor.writeCode("volcengine", vendorData["volcengine.ts"]);
      }
      const minimaxVer = await utils_default.vendor.getVendor("minimax").version;
      if (Number(minimaxVer) < 2.1) {
        utils_default.vendor.writeCode("minimax", vendorData["minimax.ts"]);
      }
    };
  }
});

// node_modules/@rmp135/sql-ts/dist/ConfigTasks.js
function applyConfigDefaults(config3) {
  const defaultConfig = {
    filename: "Database",
    globalOptionality: "dynamic",
    columnOptionality: {},
    tableEnums: {},
    columnSortOrder: "alphabetical",
    tables: [],
    excludedTables: [],
    schemas: [],
    interfaceNameFormat: "${table}Entity",
    enumNameFormat: "${name}",
    enumNumericKeyFormat: "_${key}",
    additionalProperties: {},
    schemaAsNamespace: false,
    typeOverrides: {},
    typeMap: {},
    template: path6.join(path6.dirname((0, import_url.fileURLToPath)(import_meta.url)), "./template.handlebars"),
    custom: {}
  };
  return Object.assign(defaultConfig, config3);
}
var path6, import_url, import_meta;
var init_ConfigTasks = __esm({
  "node_modules/@rmp135/sql-ts/dist/ConfigTasks.js"() {
    "use strict";
    path6 = __toESM(require("path"), 1);
    import_url = require("url");
    import_meta = {};
  }
});

// node_modules/change-case/dist/index.js
function split(value) {
  let result = value.trim();
  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
  let start = 0;
  let end = result.length;
  while (result.charAt(start) === "\0")
    start++;
  if (start === end)
    return [];
  while (result.charAt(end - 1) === "\0")
    end--;
  return result.slice(start, end).split(/\0/g);
}
function splitSeparateNumbers(value) {
  const words = split(value);
  for (let i = 0; i < words.length; i++) {
    const word = words[i];
    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
    if (match) {
      const offset = match.index + (match[1] ?? match[2]).length;
      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
    }
  }
  return words;
}
function camelCase(input, options) {
  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
  const lower = lowerFactory(options?.locale);
  const upper = upperFactory(options?.locale);
  const transform8 = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
  return prefix + words.map((word, index) => {
    if (index === 0)
      return lower(word);
    return transform8(word, index);
  }).join(options?.delimiter ?? "") + suffix;
}
function pascalCase(input, options) {
  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
  const lower = lowerFactory(options?.locale);
  const upper = upperFactory(options?.locale);
  const transform8 = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
  return prefix + words.map(transform8).join(options?.delimiter ?? "") + suffix;
}
function lowerFactory(locale) {
  return locale === false ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
}
function upperFactory(locale) {
  return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
}
function capitalCaseTransformFactory(lower, upper) {
  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
}
function pascalCaseTransformFactory(lower, upper) {
  return (word, index) => {
    const char0 = word[0];
    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
    return initial + lower(word.slice(1));
  };
}
function splitPrefixSuffix(input, options = {}) {
  const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
  const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
  const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
  let prefixIndex = 0;
  let suffixIndex = input.length;
  while (prefixIndex < input.length) {
    const char = input.charAt(prefixIndex);
    if (!prefixCharacters.includes(char))
      break;
    prefixIndex++;
  }
  while (suffixIndex > prefixIndex) {
    const index = suffixIndex - 1;
    const char = input.charAt(index);
    if (!suffixCharacters.includes(char))
      break;
    suffixIndex = index;
  }
  return [
    input.slice(0, prefixIndex),
    splitFn(input.slice(prefixIndex, suffixIndex)),
    input.slice(suffixIndex)
  ];
}
var SPLIT_LOWER_UPPER_RE, SPLIT_UPPER_UPPER_RE, SPLIT_SEPARATE_NUMBER_RE, DEFAULT_STRIP_REGEXP, SPLIT_REPLACE_VALUE, DEFAULT_PREFIX_SUFFIX_CHARACTERS;
var init_dist = __esm({
  "node_modules/change-case/dist/index.js"() {
    "use strict";
    SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
    SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
    SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u;
    DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
    SPLIT_REPLACE_VALUE = "$1\0$2";
    DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
  }
});

// node_modules/@rmp135/sql-ts/dist/SharedTasks.js
function convertCase(name28, caseType) {
  switch (caseType) {
    case "pascal":
      return pascalCase(name28, { mergeAmbiguousCharacters: true });
    case "camel":
      return camelCase(name28, { mergeAmbiguousCharacters: true });
    case "lower":
      return name28.toLowerCase();
    case "upper":
      return name28.toUpperCase();
    default:
      return name28;
  }
}
function resolveAdapterName(dialect) {
  const aliases = {
    "postgresql": "postgres",
    "pg": "postgres",
    "sqlite3": "sqlite",
    "mysql2": "mysql"
  };
  return aliases[dialect] ?? dialect;
}
var init_SharedTasks = __esm({
  "node_modules/@rmp135/sql-ts/dist/SharedTasks.js"() {
    "use strict";
    init_dist();
  }
});

// node_modules/@rmp135/sql-ts/dist/Adapters/SharedAdapterTasks.js
async function getTableEnums(db2, config3) {
  const tableEnums = config3.tableEnums;
  const allEnums = await Promise.all(Object.entries(tableEnums).map(async ([key, enums]) => {
    const [schemaName, tableName] = key.split(".");
    const rawRows = await db2(tableName).select(`${enums.key} as Key`, `${enums.value} as Value`);
    const rows = rawRows.reduce((acc, row) => {
      acc[row.Key] = row.Value;
      return acc;
    }, {});
    return {
      name: tableName,
      schema: schemaName,
      values: rows
    };
  }));
  return await Promise.all(allEnums);
}
var init_SharedAdapterTasks = __esm({
  "node_modules/@rmp135/sql-ts/dist/Adapters/SharedAdapterTasks.js"() {
    "use strict";
  }
});

// node_modules/@rmp135/sql-ts/dist/Adapters/mysql.js
async function getAllEnums(db2, config3) {
  return await getTableEnums(db2, config3);
}
async function getAllTables(db2, schemas) {
  const sql = `
    SELECT
      TABLE_NAME AS name,
      TABLE_SCHEMA AS 'schema',
      COALESCE(NULLIF(TABLE_COMMENT, 'VIEW'), '') AS comment
    FROM INFORMATION_SCHEMA.TABLES
    WHERE TABLE_SCHEMA NOT IN('mysql', 'information_schema', 'performance_schema', 'sys')
    ${schemas.length > 0 ? " AND TABLE_SCHEMA IN (:schemas)" : ""}`;
  return (await db2.raw(sql, { schemas }))[0];
}
async function getAllColumns(db2, config3, table, schema) {
  const sql = `
    SELECT
      column_name as name,
      is_nullable as isNullable,
      column_comment as comment,
      COLUMN_DEFAULT AS defaultValue,
      CASE WHEN LOCATE('auto_increment', extra) <> 0 OR COLUMN_DEFAULT IS NOT NULL THEN 1 ELSE 0 END isOptional,
      CASE WHEN EXISTS(
        SELECT NULL FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
        WHERE CONSTRAINT_NAME = 'PRIMARY'
        AND kcu.TABLE_NAME = :table
        AND kcu.TABLE_SCHEMA = :schema
        AND kcu.COLUMN_NAME = c.COLUMN_NAME
      ) THEN 1 ELSE 0 END isPrimaryKey,
      data_type AS type,
      column_type AS fullType
      FROM information_schema.columns c
      WHERE TABLE_NAME = :table
      AND c.TABLE_SCHEMA = :schema
      ORDER BY ORDINAL_POSITION
    `;
  return (await db2.raw(sql, { table, schema }))[0].map((c) => ({
    name: c.name,
    type: c.fullType == "tinyint(1)" ? c.fullType : c.type,
    // tinyint(1) typically aliased as a boolean
    nullable: c.isNullable == "YES",
    optional: c.isOptional === 1 || c.isNullable == "YES",
    columnType: c.type == "enum" ? "StringEnum" : "Standard",
    isPrimaryKey: c.isPrimaryKey == 1,
    comment: c.comment,
    stringEnumValues: c.type == "enum" ? parseEnumString(c.fullType) : void 0,
    defaultValue: c.defaultValue?.toString() ?? null
  }));
}
function parseEnumString(enumString) {
  return enumString.replace(/enum\('/, "").slice(0, -2).replace(/''/g, "'").replace(/\\\\'/g, "\\").split(/','/).map(
    (value) => value.replace(/^'/, "").replace(/'$/, "")
    // Remove trailing single quote
  );
}
var mysql_default;
var init_mysql = __esm({
  "node_modules/@rmp135/sql-ts/dist/Adapters/mysql.js"() {
    "use strict";
    init_SharedAdapterTasks();
    mysql_default = {
      getAllEnums,
      getAllTables,
      getAllColumns,
      parseEnumString
    };
  }
});

// node_modules/@rmp135/sql-ts/dist/Adapters/mssql.js
var mssql_default;
var init_mssql = __esm({
  "node_modules/@rmp135/sql-ts/dist/Adapters/mssql.js"() {
    "use strict";
    init_SharedAdapterTasks();
    mssql_default = {
      async getAllEnums(db2, config3) {
        return await getTableEnums(db2, config3);
      },
      async getAllTables(db2, schemas) {
        const sql = `
      SELECT
        TABLE_NAME name,
        TABLE_SCHEMA [schema],
        COALESCE(EP.value, '') comment
        FROM INFORMATION_SCHEMA.TABLES
        OUTER APPLY (
          SELECT TOP 1 value FROM fn_listextendedproperty (NULL, 'schema', TABLE_SCHEMA, 'table', TABLE_NAME, null, null) EP WHERE EP.name = 'MS_Description'
          UNION
          SELECT TOP 1 value FROM fn_listextendedproperty (NULL, 'schema', TABLE_SCHEMA, 'view', TABLE_NAME, null, null) EP WHERE EP.name = 'MS_Description'
        ) EP 
      ${schemas.length > 0 ? `WHERE TABLE_SCHEMA IN (${schemas.map((_) => "?").join(",")})` : ""}`;
        return await db2.raw(sql, schemas);
      },
      async getAllColumns(db2, config3, table, schema) {
        const sql = `
      SELECT
				COLUMN_NAME as name,
				IS_NULLABLE AS isNullable,
				DATA_TYPE as type,
        COLUMN_DEFAULT as defaultValue,
				CASE WHEN EXISTS(
					SELECT NULL FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS t
					JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE k 
					ON k.CONSTRAINT_NAME = t.CONSTRAINT_NAME 
					AND k.TABLE_NAME = t.TABLE_NAME 
					AND k.TABLE_SCHEMA = t.TABLE_SCHEMA
					WHERE t.TABLE_NAME = c.TABLE_NAME
					AND k.COLUMN_NAME = c.COLUMN_NAME
					AND k.TABLE_SCHEMA = c.TABLE_SCHEMA
					AND t.CONSTRAINT_TYPE = 'PRIMARY KEY'
				) THEN 1 ELSE 0 END AS isPrimaryKey,
				CASE WHEN COLUMNPROPERTY(object_id(TABLE_SCHEMA+'.'+TABLE_NAME), COLUMN_NAME, 'IsIdentity') = 1 OR COLUMN_DEFAULT IS NOT NULL THEN 1 ELSE 0 END AS isOptional,
        COALESCE(EP.value, '') comment
        FROM INFORMATION_SCHEMA.COLUMNS c
        OUTER APPLY (SELECT TOP 1 value FROM fn_listextendedproperty (NULL, 'schema', TABLE_SCHEMA, 'table', TABLE_NAME, 'column', COLUMN_NAME) EP WHERE EP.name = 'MS_Description') EP 
        WHERE c.TABLE_NAME = :table
        AND c.TABLE_SCHEMA = :schema
      `;
        return (await db2.raw(sql, { table, schema })).map((c) => ({
          name: c.name,
          type: c.type,
          nullable: c.isNullable === "YES",
          optional: c.isOptional === 1 || c.isNullable == "YES",
          columnType: "Standard",
          isPrimaryKey: c.isPrimaryKey == 1,
          comment: c.comment,
          defaultValue: c.defaultValue?.toString() ?? null
        }));
      }
    };
  }
});

// node_modules/lodash-es/_freeGlobal.js
var freeGlobal, freeGlobal_default;
var init_freeGlobal = __esm({
  "node_modules/lodash-es/_freeGlobal.js"() {
    "use strict";
    freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    freeGlobal_default = freeGlobal;
  }
});

// node_modules/lodash-es/_root.js
var freeSelf, root, root_default;
var init_root = __esm({
  "node_modules/lodash-es/_root.js"() {
    "use strict";
    init_freeGlobal();
    freeSelf = typeof self == "object" && self && self.Object === Object && self;
    root = freeGlobal_default || freeSelf || Function("return this")();
    root_default = root;
  }
});

// node_modules/lodash-es/_Symbol.js
var Symbol2, Symbol_default;
var init_Symbol = __esm({
  "node_modules/lodash-es/_Symbol.js"() {
    "use strict";
    init_root();
    Symbol2 = root_default.Symbol;
    Symbol_default = Symbol2;
  }
});

// node_modules/lodash-es/_getRawTag.js
function getRawTag(value) {
  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
  try {
    value[symToStringTag] = void 0;
    var unmasked = true;
  } catch (e) {
  }
  var result = nativeObjectToString.call(value);
  if (unmasked) {
    if (isOwn) {
      value[symToStringTag] = tag;
    } else {
      delete value[symToStringTag];
    }
  }
  return result;
}
var objectProto, hasOwnProperty, nativeObjectToString, symToStringTag, getRawTag_default;
var init_getRawTag = __esm({
  "node_modules/lodash-es/_getRawTag.js"() {
    "use strict";
    init_Symbol();
    objectProto = Object.prototype;
    hasOwnProperty = objectProto.hasOwnProperty;
    nativeObjectToString = objectProto.toString;
    symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
    getRawTag_default = getRawTag;
  }
});

// node_modules/lodash-es/_objectToString.js
function objectToString(value) {
  return nativeObjectToString2.call(value);
}
var objectProto2, nativeObjectToString2, objectToString_default;
var init_objectToString = __esm({
  "node_modules/lodash-es/_objectToString.js"() {
    "use strict";
    objectProto2 = Object.prototype;
    nativeObjectToString2 = objectProto2.toString;
    objectToString_default = objectToString;
  }
});

// node_modules/lodash-es/_baseGetTag.js
function baseGetTag(value) {
  if (value == null) {
    return value === void 0 ? undefinedTag : nullTag;
  }
  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
}
var nullTag, undefinedTag, symToStringTag2, baseGetTag_default;
var init_baseGetTag = __esm({
  "node_modules/lodash-es/_baseGetTag.js"() {
    "use strict";
    init_Symbol();
    init_getRawTag();
    init_objectToString();
    nullTag = "[object Null]";
    undefinedTag = "[object Undefined]";
    symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
    baseGetTag_default = baseGetTag;
  }
});

// node_modules/lodash-es/isObjectLike.js
function isObjectLike(value) {
  return value != null && typeof value == "object";
}
var isObjectLike_default;
var init_isObjectLike = __esm({
  "node_modules/lodash-es/isObjectLike.js"() {
    "use strict";
    isObjectLike_default = isObjectLike;
  }
});

// node_modules/lodash-es/isSymbol.js
function isSymbol(value) {
  return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
}
var symbolTag, isSymbol_default;
var init_isSymbol = __esm({
  "node_modules/lodash-es/isSymbol.js"() {
    "use strict";
    init_baseGetTag();
    init_isObjectLike();
    symbolTag = "[object Symbol]";
    isSymbol_default = isSymbol;
  }
});

// node_modules/lodash-es/_arrayMap.js
function arrayMap(array4, iteratee) {
  var index = -1, length = array4 == null ? 0 : array4.length, result = Array(length);
  while (++index < length) {
    result[index] = iteratee(array4[index], index, array4);
  }
  return result;
}
var arrayMap_default;
var init_arrayMap = __esm({
  "node_modules/lodash-es/_arrayMap.js"() {
    "use strict";
    arrayMap_default = arrayMap;
  }
});

// node_modules/lodash-es/isArray.js
var isArray, isArray_default;
var init_isArray = __esm({
  "node_modules/lodash-es/isArray.js"() {
    "use strict";
    isArray = Array.isArray;
    isArray_default = isArray;
  }
});

// node_modules/lodash-es/_baseToString.js
function baseToString(value) {
  if (typeof value == "string") {
    return value;
  }
  if (isArray_default(value)) {
    return arrayMap_default(value, baseToString) + "";
  }
  if (isSymbol_default(value)) {
    return symbolToString ? symbolToString.call(value) : "";
  }
  var result = value + "";
  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
}
var INFINITY, symbolProto, symbolToString, baseToString_default;
var init_baseToString = __esm({
  "node_modules/lodash-es/_baseToString.js"() {
    "use strict";
    init_Symbol();
    init_arrayMap();
    init_isArray();
    init_isSymbol();
    INFINITY = 1 / 0;
    symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
    symbolToString = symbolProto ? symbolProto.toString : void 0;
    baseToString_default = baseToString;
  }
});

// node_modules/lodash-es/isObject.js
function isObject(value) {
  var type = typeof value;
  return value != null && (type == "object" || type == "function");
}
var isObject_default;
var init_isObject = __esm({
  "node_modules/lodash-es/isObject.js"() {
    "use strict";
    isObject_default = isObject;
  }
});

// node_modules/lodash-es/identity.js
function identity(value) {
  return value;
}
var identity_default;
var init_identity = __esm({
  "node_modules/lodash-es/identity.js"() {
    "use strict";
    identity_default = identity;
  }
});

// node_modules/lodash-es/isFunction.js
function isFunction(value) {
  if (!isObject_default(value)) {
    return false;
  }
  var tag = baseGetTag_default(value);
  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
}
var asyncTag, funcTag, genTag, proxyTag, isFunction_default;
var init_isFunction = __esm({
  "node_modules/lodash-es/isFunction.js"() {
    "use strict";
    init_baseGetTag();
    init_isObject();
    asyncTag = "[object AsyncFunction]";
    funcTag = "[object Function]";
    genTag = "[object GeneratorFunction]";
    proxyTag = "[object Proxy]";
    isFunction_default = isFunction;
  }
});

// node_modules/lodash-es/_coreJsData.js
var coreJsData, coreJsData_default;
var init_coreJsData = __esm({
  "node_modules/lodash-es/_coreJsData.js"() {
    "use strict";
    init_root();
    coreJsData = root_default["__core-js_shared__"];
    coreJsData_default = coreJsData;
  }
});

// node_modules/lodash-es/_isMasked.js
function isMasked(func) {
  return !!maskSrcKey && maskSrcKey in func;
}
var maskSrcKey, isMasked_default;
var init_isMasked = __esm({
  "node_modules/lodash-es/_isMasked.js"() {
    "use strict";
    init_coreJsData();
    maskSrcKey = (function() {
      var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
      return uid ? "Symbol(src)_1." + uid : "";
    })();
    isMasked_default = isMasked;
  }
});

// node_modules/lodash-es/_toSource.js
function toSource(func) {
  if (func != null) {
    try {
      return funcToString.call(func);
    } catch (e) {
    }
    try {
      return func + "";
    } catch (e) {
    }
  }
  return "";
}
var funcProto, funcToString, toSource_default;
var init_toSource = __esm({
  "node_modules/lodash-es/_toSource.js"() {
    "use strict";
    funcProto = Function.prototype;
    funcToString = funcProto.toString;
    toSource_default = toSource;
  }
});

// node_modules/lodash-es/_baseIsNative.js
function baseIsNative(value) {
  if (!isObject_default(value) || isMasked_default(value)) {
    return false;
  }
  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
  return pattern.test(toSource_default(value));
}
var reRegExpChar, reIsHostCtor, funcProto2, objectProto3, funcToString2, hasOwnProperty2, reIsNative, baseIsNative_default;
var init_baseIsNative = __esm({
  "node_modules/lodash-es/_baseIsNative.js"() {
    "use strict";
    init_isFunction();
    init_isMasked();
    init_isObject();
    init_toSource();
    reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
    reIsHostCtor = /^\[object .+?Constructor\]$/;
    funcProto2 = Function.prototype;
    objectProto3 = Object.prototype;
    funcToString2 = funcProto2.toString;
    hasOwnProperty2 = objectProto3.hasOwnProperty;
    reIsNative = RegExp(
      "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
    );
    baseIsNative_default = baseIsNative;
  }
});

// node_modules/lodash-es/_getValue.js
function getValue(object4, key) {
  return object4 == null ? void 0 : object4[key];
}
var getValue_default;
var init_getValue = __esm({
  "node_modules/lodash-es/_getValue.js"() {
    "use strict";
    getValue_default = getValue;
  }
});

// node_modules/lodash-es/_getNative.js
function getNative(object4, key) {
  var value = getValue_default(object4, key);
  return baseIsNative_default(value) ? value : void 0;
}
var getNative_default;
var init_getNative = __esm({
  "node_modules/lodash-es/_getNative.js"() {
    "use strict";
    init_baseIsNative();
    init_getValue();
    getNative_default = getNative;
  }
});

// node_modules/lodash-es/_WeakMap.js
var WeakMap2, WeakMap_default;
var init_WeakMap = __esm({
  "node_modules/lodash-es/_WeakMap.js"() {
    "use strict";
    init_getNative();
    init_root();
    WeakMap2 = getNative_default(root_default, "WeakMap");
    WeakMap_default = WeakMap2;
  }
});

// node_modules/lodash-es/noop.js
function noop() {
}
var noop_default;
var init_noop = __esm({
  "node_modules/lodash-es/noop.js"() {
    "use strict";
    noop_default = noop;
  }
});

// node_modules/lodash-es/_baseFindIndex.js
function baseFindIndex(array4, predicate, fromIndex, fromRight) {
  var length = array4.length, index = fromIndex + (fromRight ? 1 : -1);
  while (fromRight ? index-- : ++index < length) {
    if (predicate(array4[index], index, array4)) {
      return index;
    }
  }
  return -1;
}
var baseFindIndex_default;
var init_baseFindIndex = __esm({
  "node_modules/lodash-es/_baseFindIndex.js"() {
    "use strict";
    baseFindIndex_default = baseFindIndex;
  }
});

// node_modules/lodash-es/_baseIsNaN.js
function baseIsNaN(value) {
  return value !== value;
}
var baseIsNaN_default;
var init_baseIsNaN = __esm({
  "node_modules/lodash-es/_baseIsNaN.js"() {
    "use strict";
    baseIsNaN_default = baseIsNaN;
  }
});

// node_modules/lodash-es/_strictIndexOf.js
function strictIndexOf(array4, value, fromIndex) {
  var index = fromIndex - 1, length = array4.length;
  while (++index < length) {
    if (array4[index] === value) {
      return index;
    }
  }
  return -1;
}
var strictIndexOf_default;
var init_strictIndexOf = __esm({
  "node_modules/lodash-es/_strictIndexOf.js"() {
    "use strict";
    strictIndexOf_default = strictIndexOf;
  }
});

// node_modules/lodash-es/_baseIndexOf.js
function baseIndexOf(array4, value, fromIndex) {
  return value === value ? strictIndexOf_default(array4, value, fromIndex) : baseFindIndex_default(array4, baseIsNaN_default, fromIndex);
}
var baseIndexOf_default;
var init_baseIndexOf = __esm({
  "node_modules/lodash-es/_baseIndexOf.js"() {
    "use strict";
    init_baseFindIndex();
    init_baseIsNaN();
    init_strictIndexOf();
    baseIndexOf_default = baseIndexOf;
  }
});

// node_modules/lodash-es/_arrayIncludes.js
function arrayIncludes(array4, value) {
  var length = array4 == null ? 0 : array4.length;
  return !!length && baseIndexOf_default(array4, value, 0) > -1;
}
var arrayIncludes_default;
var init_arrayIncludes = __esm({
  "node_modules/lodash-es/_arrayIncludes.js"() {
    "use strict";
    init_baseIndexOf();
    arrayIncludes_default = arrayIncludes;
  }
});

// node_modules/lodash-es/_isIndex.js
function isIndex(value, length) {
  var type = typeof value;
  length = length == null ? MAX_SAFE_INTEGER : length;
  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
}
var MAX_SAFE_INTEGER, reIsUint, isIndex_default;
var init_isIndex = __esm({
  "node_modules/lodash-es/_isIndex.js"() {
    "use strict";
    MAX_SAFE_INTEGER = 9007199254740991;
    reIsUint = /^(?:0|[1-9]\d*)$/;
    isIndex_default = isIndex;
  }
});

// node_modules/lodash-es/eq.js
function eq(value, other) {
  return value === other || value !== value && other !== other;
}
var eq_default;
var init_eq = __esm({
  "node_modules/lodash-es/eq.js"() {
    "use strict";
    eq_default = eq;
  }
});

// node_modules/lodash-es/isLength.js
function isLength(value) {
  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
}
var MAX_SAFE_INTEGER2, isLength_default;
var init_isLength = __esm({
  "node_modules/lodash-es/isLength.js"() {
    "use strict";
    MAX_SAFE_INTEGER2 = 9007199254740991;
    isLength_default = isLength;
  }
});

// node_modules/lodash-es/isArrayLike.js
function isArrayLike(value) {
  return value != null && isLength_default(value.length) && !isFunction_default(value);
}
var isArrayLike_default;
var init_isArrayLike = __esm({
  "node_modules/lodash-es/isArrayLike.js"() {
    "use strict";
    init_isFunction();
    init_isLength();
    isArrayLike_default = isArrayLike;
  }
});

// node_modules/lodash-es/_isPrototype.js
function isPrototype(value) {
  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto4;
  return value === proto;
}
var objectProto4, isPrototype_default;
var init_isPrototype = __esm({
  "node_modules/lodash-es/_isPrototype.js"() {
    "use strict";
    objectProto4 = Object.prototype;
    isPrototype_default = isPrototype;
  }
});

// node_modules/lodash-es/_baseTimes.js
function baseTimes(n, iteratee) {
  var index = -1, result = Array(n);
  while (++index < n) {
    result[index] = iteratee(index);
  }
  return result;
}
var baseTimes_default;
var init_baseTimes = __esm({
  "node_modules/lodash-es/_baseTimes.js"() {
    "use strict";
    baseTimes_default = baseTimes;
  }
});

// node_modules/lodash-es/_baseIsArguments.js
function baseIsArguments(value) {
  return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
}
var argsTag, baseIsArguments_default;
var init_baseIsArguments = __esm({
  "node_modules/lodash-es/_baseIsArguments.js"() {
    "use strict";
    init_baseGetTag();
    init_isObjectLike();
    argsTag = "[object Arguments]";
    baseIsArguments_default = baseIsArguments;
  }
});

// node_modules/lodash-es/isArguments.js
var objectProto5, hasOwnProperty3, propertyIsEnumerable, isArguments, isArguments_default;
var init_isArguments = __esm({
  "node_modules/lodash-es/isArguments.js"() {
    "use strict";
    init_baseIsArguments();
    init_isObjectLike();
    objectProto5 = Object.prototype;
    hasOwnProperty3 = objectProto5.hasOwnProperty;
    propertyIsEnumerable = objectProto5.propertyIsEnumerable;
    isArguments = baseIsArguments_default(/* @__PURE__ */ (function() {
      return arguments;
    })()) ? baseIsArguments_default : function(value) {
      return isObjectLike_default(value) && hasOwnProperty3.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
    };
    isArguments_default = isArguments;
  }
});

// node_modules/lodash-es/stubFalse.js
function stubFalse() {
  return false;
}
var stubFalse_default;
var init_stubFalse = __esm({
  "node_modules/lodash-es/stubFalse.js"() {
    "use strict";
    stubFalse_default = stubFalse;
  }
});

// node_modules/lodash-es/isBuffer.js
var freeExports, freeModule, moduleExports, Buffer2, nativeIsBuffer, isBuffer, isBuffer_default;
var init_isBuffer = __esm({
  "node_modules/lodash-es/isBuffer.js"() {
    "use strict";
    init_root();
    init_stubFalse();
    freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
    freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
    moduleExports = freeModule && freeModule.exports === freeExports;
    Buffer2 = moduleExports ? root_default.Buffer : void 0;
    nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
    isBuffer = nativeIsBuffer || stubFalse_default;
    isBuffer_default = isBuffer;
  }
});

// node_modules/lodash-es/_baseIsTypedArray.js
function baseIsTypedArray(value) {
  return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[baseGetTag_default(value)];
}
var argsTag2, arrayTag, boolTag, dateTag, errorTag, funcTag2, mapTag, numberTag, objectTag, regexpTag, setTag, stringTag, weakMapTag, arrayBufferTag, dataViewTag, float32Tag, float64Tag, int8Tag, int16Tag, int32Tag, uint8Tag, uint8ClampedTag, uint16Tag, uint32Tag, typedArrayTags, baseIsTypedArray_default;
var init_baseIsTypedArray = __esm({
  "node_modules/lodash-es/_baseIsTypedArray.js"() {
    "use strict";
    init_baseGetTag();
    init_isLength();
    init_isObjectLike();
    argsTag2 = "[object Arguments]";
    arrayTag = "[object Array]";
    boolTag = "[object Boolean]";
    dateTag = "[object Date]";
    errorTag = "[object Error]";
    funcTag2 = "[object Function]";
    mapTag = "[object Map]";
    numberTag = "[object Number]";
    objectTag = "[object Object]";
    regexpTag = "[object RegExp]";
    setTag = "[object Set]";
    stringTag = "[object String]";
    weakMapTag = "[object WeakMap]";
    arrayBufferTag = "[object ArrayBuffer]";
    dataViewTag = "[object DataView]";
    float32Tag = "[object Float32Array]";
    float64Tag = "[object Float64Array]";
    int8Tag = "[object Int8Array]";
    int16Tag = "[object Int16Array]";
    int32Tag = "[object Int32Array]";
    uint8Tag = "[object Uint8Array]";
    uint8ClampedTag = "[object Uint8ClampedArray]";
    uint16Tag = "[object Uint16Array]";
    uint32Tag = "[object Uint32Array]";
    typedArrayTags = {};
    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
    typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag2] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
    baseIsTypedArray_default = baseIsTypedArray;
  }
});

// node_modules/lodash-es/_baseUnary.js
function baseUnary(func) {
  return function(value) {
    return func(value);
  };
}
var baseUnary_default;
var init_baseUnary = __esm({
  "node_modules/lodash-es/_baseUnary.js"() {
    "use strict";
    baseUnary_default = baseUnary;
  }
});

// node_modules/lodash-es/_nodeUtil.js
var freeExports2, freeModule2, moduleExports2, freeProcess, nodeUtil, nodeUtil_default;
var init_nodeUtil = __esm({
  "node_modules/lodash-es/_nodeUtil.js"() {
    "use strict";
    init_freeGlobal();
    freeExports2 = typeof exports == "object" && exports && !exports.nodeType && exports;
    freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
    moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
    freeProcess = moduleExports2 && freeGlobal_default.process;
    nodeUtil = (function() {
      try {
        var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
        if (types) {
          return types;
        }
        return freeProcess && freeProcess.binding && freeProcess.binding("util");
      } catch (e) {
      }
    })();
    nodeUtil_default = nodeUtil;
  }
});

// node_modules/lodash-es/isTypedArray.js
var nodeIsTypedArray, isTypedArray, isTypedArray_default;
var init_isTypedArray = __esm({
  "node_modules/lodash-es/isTypedArray.js"() {
    "use strict";
    init_baseIsTypedArray();
    init_baseUnary();
    init_nodeUtil();
    nodeIsTypedArray = nodeUtil_default && nodeUtil_default.isTypedArray;
    isTypedArray = nodeIsTypedArray ? baseUnary_default(nodeIsTypedArray) : baseIsTypedArray_default;
    isTypedArray_default = isTypedArray;
  }
});

// node_modules/lodash-es/_arrayLikeKeys.js
function arrayLikeKeys(value, inherited) {
  var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes_default(value.length, String) : [], length = result.length;
  for (var key in value) {
    if ((inherited || hasOwnProperty4.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
    isIndex_default(key, length)))) {
      result.push(key);
    }
  }
  return result;
}
var objectProto6, hasOwnProperty4, arrayLikeKeys_default;
var init_arrayLikeKeys = __esm({
  "node_modules/lodash-es/_arrayLikeKeys.js"() {
    "use strict";
    init_baseTimes();
    init_isArguments();
    init_isArray();
    init_isBuffer();
    init_isIndex();
    init_isTypedArray();
    objectProto6 = Object.prototype;
    hasOwnProperty4 = objectProto6.hasOwnProperty;
    arrayLikeKeys_default = arrayLikeKeys;
  }
});

// node_modules/lodash-es/_overArg.js
function overArg(func, transform8) {
  return function(arg) {
    return func(transform8(arg));
  };
}
var overArg_default;
var init_overArg = __esm({
  "node_modules/lodash-es/_overArg.js"() {
    "use strict";
    overArg_default = overArg;
  }
});

// node_modules/lodash-es/_nativeKeys.js
var nativeKeys, nativeKeys_default;
var init_nativeKeys = __esm({
  "node_modules/lodash-es/_nativeKeys.js"() {
    "use strict";
    init_overArg();
    nativeKeys = overArg_default(Object.keys, Object);
    nativeKeys_default = nativeKeys;
  }
});

// node_modules/lodash-es/_baseKeys.js
function baseKeys(object4) {
  if (!isPrototype_default(object4)) {
    return nativeKeys_default(object4);
  }
  var result = [];
  for (var key in Object(object4)) {
    if (hasOwnProperty5.call(object4, key) && key != "constructor") {
      result.push(key);
    }
  }
  return result;
}
var objectProto7, hasOwnProperty5, baseKeys_default;
var init_baseKeys = __esm({
  "node_modules/lodash-es/_baseKeys.js"() {
    "use strict";
    init_isPrototype();
    init_nativeKeys();
    objectProto7 = Object.prototype;
    hasOwnProperty5 = objectProto7.hasOwnProperty;
    baseKeys_default = baseKeys;
  }
});

// node_modules/lodash-es/keys.js
function keys(object4) {
  return isArrayLike_default(object4) ? arrayLikeKeys_default(object4) : baseKeys_default(object4);
}
var keys_default;
var init_keys = __esm({
  "node_modules/lodash-es/keys.js"() {
    "use strict";
    init_arrayLikeKeys();
    init_baseKeys();
    init_isArrayLike();
    keys_default = keys;
  }
});

// node_modules/lodash-es/_isKey.js
function isKey(value, object4) {
  if (isArray_default(value)) {
    return false;
  }
  var type = typeof value;
  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) {
    return true;
  }
  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object4 != null && value in Object(object4);
}
var reIsDeepProp, reIsPlainProp, isKey_default;
var init_isKey = __esm({
  "node_modules/lodash-es/_isKey.js"() {
    "use strict";
    init_isArray();
    init_isSymbol();
    reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
    reIsPlainProp = /^\w*$/;
    isKey_default = isKey;
  }
});

// node_modules/lodash-es/_nativeCreate.js
var nativeCreate, nativeCreate_default;
var init_nativeCreate = __esm({
  "node_modules/lodash-es/_nativeCreate.js"() {
    "use strict";
    init_getNative();
    nativeCreate = getNative_default(Object, "create");
    nativeCreate_default = nativeCreate;
  }
});

// node_modules/lodash-es/_hashClear.js
function hashClear() {
  this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
  this.size = 0;
}
var hashClear_default;
var init_hashClear = __esm({
  "node_modules/lodash-es/_hashClear.js"() {
    "use strict";
    init_nativeCreate();
    hashClear_default = hashClear;
  }
});

// node_modules/lodash-es/_hashDelete.js
function hashDelete(key) {
  var result = this.has(key) && delete this.__data__[key];
  this.size -= result ? 1 : 0;
  return result;
}
var hashDelete_default;
var init_hashDelete = __esm({
  "node_modules/lodash-es/_hashDelete.js"() {
    "use strict";
    hashDelete_default = hashDelete;
  }
});

// node_modules/lodash-es/_hashGet.js
function hashGet(key) {
  var data = this.__data__;
  if (nativeCreate_default) {
    var result = data[key];
    return result === HASH_UNDEFINED ? void 0 : result;
  }
  return hasOwnProperty6.call(data, key) ? data[key] : void 0;
}
var HASH_UNDEFINED, objectProto8, hasOwnProperty6, hashGet_default;
var init_hashGet = __esm({
  "node_modules/lodash-es/_hashGet.js"() {
    "use strict";
    init_nativeCreate();
    HASH_UNDEFINED = "__lodash_hash_undefined__";
    objectProto8 = Object.prototype;
    hasOwnProperty6 = objectProto8.hasOwnProperty;
    hashGet_default = hashGet;
  }
});

// node_modules/lodash-es/_hashHas.js
function hashHas(key) {
  var data = this.__data__;
  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty7.call(data, key);
}
var objectProto9, hasOwnProperty7, hashHas_default;
var init_hashHas = __esm({
  "node_modules/lodash-es/_hashHas.js"() {
    "use strict";
    init_nativeCreate();
    objectProto9 = Object.prototype;
    hasOwnProperty7 = objectProto9.hasOwnProperty;
    hashHas_default = hashHas;
  }
});

// node_modules/lodash-es/_hashSet.js
function hashSet(key, value) {
  var data = this.__data__;
  this.size += this.has(key) ? 0 : 1;
  data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
  return this;
}
var HASH_UNDEFINED2, hashSet_default;
var init_hashSet = __esm({
  "node_modules/lodash-es/_hashSet.js"() {
    "use strict";
    init_nativeCreate();
    HASH_UNDEFINED2 = "__lodash_hash_undefined__";
    hashSet_default = hashSet;
  }
});

// node_modules/lodash-es/_Hash.js
function Hash(entries) {
  var index = -1, length = entries == null ? 0 : entries.length;
  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}
var Hash_default;
var init_Hash = __esm({
  "node_modules/lodash-es/_Hash.js"() {
    "use strict";
    init_hashClear();
    init_hashDelete();
    init_hashGet();
    init_hashHas();
    init_hashSet();
    Hash.prototype.clear = hashClear_default;
    Hash.prototype["delete"] = hashDelete_default;
    Hash.prototype.get = hashGet_default;
    Hash.prototype.has = hashHas_default;
    Hash.prototype.set = hashSet_default;
    Hash_default = Hash;
  }
});

// node_modules/lodash-es/_listCacheClear.js
function listCacheClear() {
  this.__data__ = [];
  this.size = 0;
}
var listCacheClear_default;
var init_listCacheClear = __esm({
  "node_modules/lodash-es/_listCacheClear.js"() {
    "use strict";
    listCacheClear_default = listCacheClear;
  }
});

// node_modules/lodash-es/_assocIndexOf.js
function assocIndexOf(array4, key) {
  var length = array4.length;
  while (length--) {
    if (eq_default(array4[length][0], key)) {
      return length;
    }
  }
  return -1;
}
var assocIndexOf_default;
var init_assocIndexOf = __esm({
  "node_modules/lodash-es/_assocIndexOf.js"() {
    "use strict";
    init_eq();
    assocIndexOf_default = assocIndexOf;
  }
});

// node_modules/lodash-es/_listCacheDelete.js
function listCacheDelete(key) {
  var data = this.__data__, index = assocIndexOf_default(data, key);
  if (index < 0) {
    return false;
  }
  var lastIndex = data.length - 1;
  if (index == lastIndex) {
    data.pop();
  } else {
    splice.call(data, index, 1);
  }
  --this.size;
  return true;
}
var arrayProto, splice, listCacheDelete_default;
var init_listCacheDelete = __esm({
  "node_modules/lodash-es/_listCacheDelete.js"() {
    "use strict";
    init_assocIndexOf();
    arrayProto = Array.prototype;
    splice = arrayProto.splice;
    listCacheDelete_default = listCacheDelete;
  }
});

// node_modules/lodash-es/_listCacheGet.js
function listCacheGet(key) {
  var data = this.__data__, index = assocIndexOf_default(data, key);
  return index < 0 ? void 0 : data[index][1];
}
var listCacheGet_default;
var init_listCacheGet = __esm({
  "node_modules/lodash-es/_listCacheGet.js"() {
    "use strict";
    init_assocIndexOf();
    listCacheGet_default = listCacheGet;
  }
});

// node_modules/lodash-es/_listCacheHas.js
function listCacheHas(key) {
  return assocIndexOf_default(this.__data__, key) > -1;
}
var listCacheHas_default;
var init_listCacheHas = __esm({
  "node_modules/lodash-es/_listCacheHas.js"() {
    "use strict";
    init_assocIndexOf();
    listCacheHas_default = listCacheHas;
  }
});

// node_modules/lodash-es/_listCacheSet.js
function listCacheSet(key, value) {
  var data = this.__data__, index = assocIndexOf_default(data, key);
  if (index < 0) {
    ++this.size;
    data.push([key, value]);
  } else {
    data[index][1] = value;
  }
  return this;
}
var listCacheSet_default;
var init_listCacheSet = __esm({
  "node_modules/lodash-es/_listCacheSet.js"() {
    "use strict";
    init_assocIndexOf();
    listCacheSet_default = listCacheSet;
  }
});

// node_modules/lodash-es/_ListCache.js
function ListCache(entries) {
  var index = -1, length = entries == null ? 0 : entries.length;
  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}
var ListCache_default;
var init_ListCache = __esm({
  "node_modules/lodash-es/_ListCache.js"() {
    "use strict";
    init_listCacheClear();
    init_listCacheDelete();
    init_listCacheGet();
    init_listCacheHas();
    init_listCacheSet();
    ListCache.prototype.clear = listCacheClear_default;
    ListCache.prototype["delete"] = listCacheDelete_default;
    ListCache.prototype.get = listCacheGet_default;
    ListCache.prototype.has = listCacheHas_default;
    ListCache.prototype.set = listCacheSet_default;
    ListCache_default = ListCache;
  }
});

// node_modules/lodash-es/_Map.js
var Map2, Map_default;
var init_Map = __esm({
  "node_modules/lodash-es/_Map.js"() {
    "use strict";
    init_getNative();
    init_root();
    Map2 = getNative_default(root_default, "Map");
    Map_default = Map2;
  }
});

// node_modules/lodash-es/_mapCacheClear.js
function mapCacheClear() {
  this.size = 0;
  this.__data__ = {
    "hash": new Hash_default(),
    "map": new (Map_default || ListCache_default)(),
    "string": new Hash_default()
  };
}
var mapCacheClear_default;
var init_mapCacheClear = __esm({
  "node_modules/lodash-es/_mapCacheClear.js"() {
    "use strict";
    init_Hash();
    init_ListCache();
    init_Map();
    mapCacheClear_default = mapCacheClear;
  }
});

// node_modules/lodash-es/_isKeyable.js
function isKeyable(value) {
  var type = typeof value;
  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
}
var isKeyable_default;
var init_isKeyable = __esm({
  "node_modules/lodash-es/_isKeyable.js"() {
    "use strict";
    isKeyable_default = isKeyable;
  }
});

// node_modules/lodash-es/_getMapData.js
function getMapData(map3, key) {
  var data = map3.__data__;
  return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
}
var getMapData_default;
var init_getMapData = __esm({
  "node_modules/lodash-es/_getMapData.js"() {
    "use strict";
    init_isKeyable();
    getMapData_default = getMapData;
  }
});

// node_modules/lodash-es/_mapCacheDelete.js
function mapCacheDelete(key) {
  var result = getMapData_default(this, key)["delete"](key);
  this.size -= result ? 1 : 0;
  return result;
}
var mapCacheDelete_default;
var init_mapCacheDelete = __esm({
  "node_modules/lodash-es/_mapCacheDelete.js"() {
    "use strict";
    init_getMapData();
    mapCacheDelete_default = mapCacheDelete;
  }
});

// node_modules/lodash-es/_mapCacheGet.js
function mapCacheGet(key) {
  return getMapData_default(this, key).get(key);
}
var mapCacheGet_default;
var init_mapCacheGet = __esm({
  "node_modules/lodash-es/_mapCacheGet.js"() {
    "use strict";
    init_getMapData();
    mapCacheGet_default = mapCacheGet;
  }
});

// node_modules/lodash-es/_mapCacheHas.js
function mapCacheHas(key) {
  return getMapData_default(this, key).has(key);
}
var mapCacheHas_default;
var init_mapCacheHas = __esm({
  "node_modules/lodash-es/_mapCacheHas.js"() {
    "use strict";
    init_getMapData();
    mapCacheHas_default = mapCacheHas;
  }
});

// node_modules/lodash-es/_mapCacheSet.js
function mapCacheSet(key, value) {
  var data = getMapData_default(this, key), size = data.size;
  data.set(key, value);
  this.size += data.size == size ? 0 : 1;
  return this;
}
var mapCacheSet_default;
var init_mapCacheSet = __esm({
  "node_modules/lodash-es/_mapCacheSet.js"() {
    "use strict";
    init_getMapData();
    mapCacheSet_default = mapCacheSet;
  }
});

// node_modules/lodash-es/_MapCache.js
function MapCache(entries) {
  var index = -1, length = entries == null ? 0 : entries.length;
  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}
var MapCache_default;
var init_MapCache = __esm({
  "node_modules/lodash-es/_MapCache.js"() {
    "use strict";
    init_mapCacheClear();
    init_mapCacheDelete();
    init_mapCacheGet();
    init_mapCacheHas();
    init_mapCacheSet();
    MapCache.prototype.clear = mapCacheClear_default;
    MapCache.prototype["delete"] = mapCacheDelete_default;
    MapCache.prototype.get = mapCacheGet_default;
    MapCache.prototype.has = mapCacheHas_default;
    MapCache.prototype.set = mapCacheSet_default;
    MapCache_default = MapCache;
  }
});

// node_modules/lodash-es/memoize.js
function memoize(func, resolver) {
  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  var memoized = function() {
    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
    if (cache.has(key)) {
      return cache.get(key);
    }
    var result = func.apply(this, args);
    memoized.cache = cache.set(key, result) || cache;
    return result;
  };
  memoized.cache = new (memoize.Cache || MapCache_default)();
  return memoized;
}
var FUNC_ERROR_TEXT, memoize_default;
var init_memoize = __esm({
  "node_modules/lodash-es/memoize.js"() {
    "use strict";
    init_MapCache();
    FUNC_ERROR_TEXT = "Expected a function";
    memoize.Cache = MapCache_default;
    memoize_default = memoize;
  }
});

// node_modules/lodash-es/_memoizeCapped.js
function memoizeCapped(func) {
  var result = memoize_default(func, function(key) {
    if (cache.size === MAX_MEMOIZE_SIZE) {
      cache.clear();
    }
    return key;
  });
  var cache = result.cache;
  return result;
}
var MAX_MEMOIZE_SIZE, memoizeCapped_default;
var init_memoizeCapped = __esm({
  "node_modules/lodash-es/_memoizeCapped.js"() {
    "use strict";
    init_memoize();
    MAX_MEMOIZE_SIZE = 500;
    memoizeCapped_default = memoizeCapped;
  }
});

// node_modules/lodash-es/_stringToPath.js
var rePropName, reEscapeChar, stringToPath, stringToPath_default;
var init_stringToPath = __esm({
  "node_modules/lodash-es/_stringToPath.js"() {
    "use strict";
    init_memoizeCapped();
    rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
    reEscapeChar = /\\(\\)?/g;
    stringToPath = memoizeCapped_default(function(string5) {
      var result = [];
      if (string5.charCodeAt(0) === 46) {
        result.push("");
      }
      string5.replace(rePropName, function(match, number5, quote, subString) {
        result.push(quote ? subString.replace(reEscapeChar, "$1") : number5 || match);
      });
      return result;
    });
    stringToPath_default = stringToPath;
  }
});

// node_modules/lodash-es/toString.js
function toString(value) {
  return value == null ? "" : baseToString_default(value);
}
var toString_default;
var init_toString = __esm({
  "node_modules/lodash-es/toString.js"() {
    "use strict";
    init_baseToString();
    toString_default = toString;
  }
});

// node_modules/lodash-es/_castPath.js
function castPath(value, object4) {
  if (isArray_default(value)) {
    return value;
  }
  return isKey_default(value, object4) ? [value] : stringToPath_default(toString_default(value));
}
var castPath_default;
var init_castPath = __esm({
  "node_modules/lodash-es/_castPath.js"() {
    "use strict";
    init_isArray();
    init_isKey();
    init_stringToPath();
    init_toString();
    castPath_default = castPath;
  }
});

// node_modules/lodash-es/_toKey.js
function toKey(value) {
  if (typeof value == "string" || isSymbol_default(value)) {
    return value;
  }
  var result = value + "";
  return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
}
var INFINITY2, toKey_default;
var init_toKey = __esm({
  "node_modules/lodash-es/_toKey.js"() {
    "use strict";
    init_isSymbol();
    INFINITY2 = 1 / 0;
    toKey_default = toKey;
  }
});

// node_modules/lodash-es/_baseGet.js
function baseGet(object4, path33) {
  path33 = castPath_default(path33, object4);
  var index = 0, length = path33.length;
  while (object4 != null && index < length) {
    object4 = object4[toKey_default(path33[index++])];
  }
  return index && index == length ? object4 : void 0;
}
var baseGet_default;
var init_baseGet = __esm({
  "node_modules/lodash-es/_baseGet.js"() {
    "use strict";
    init_castPath();
    init_toKey();
    baseGet_default = baseGet;
  }
});

// node_modules/lodash-es/get.js
function get(object4, path33, defaultValue) {
  var result = object4 == null ? void 0 : baseGet_default(object4, path33);
  return result === void 0 ? defaultValue : result;
}
var get_default;
var init_get = __esm({
  "node_modules/lodash-es/get.js"() {
    "use strict";
    init_baseGet();
    get_default = get;
  }
});

// node_modules/lodash-es/_arrayPush.js
function arrayPush(array4, values) {
  var index = -1, length = values.length, offset = array4.length;
  while (++index < length) {
    array4[offset + index] = values[index];
  }
  return array4;
}
var arrayPush_default;
var init_arrayPush = __esm({
  "node_modules/lodash-es/_arrayPush.js"() {
    "use strict";
    arrayPush_default = arrayPush;
  }
});

// node_modules/lodash-es/_stackClear.js
function stackClear() {
  this.__data__ = new ListCache_default();
  this.size = 0;
}
var stackClear_default;
var init_stackClear = __esm({
  "node_modules/lodash-es/_stackClear.js"() {
    "use strict";
    init_ListCache();
    stackClear_default = stackClear;
  }
});

// node_modules/lodash-es/_stackDelete.js
function stackDelete(key) {
  var data = this.__data__, result = data["delete"](key);
  this.size = data.size;
  return result;
}
var stackDelete_default;
var init_stackDelete = __esm({
  "node_modules/lodash-es/_stackDelete.js"() {
    "use strict";
    stackDelete_default = stackDelete;
  }
});

// node_modules/lodash-es/_stackGet.js
function stackGet(key) {
  return this.__data__.get(key);
}
var stackGet_default;
var init_stackGet = __esm({
  "node_modules/lodash-es/_stackGet.js"() {
    "use strict";
    stackGet_default = stackGet;
  }
});

// node_modules/lodash-es/_stackHas.js
function stackHas(key) {
  return this.__data__.has(key);
}
var stackHas_default;
var init_stackHas = __esm({
  "node_modules/lodash-es/_stackHas.js"() {
    "use strict";
    stackHas_default = stackHas;
  }
});

// node_modules/lodash-es/_stackSet.js
function stackSet(key, value) {
  var data = this.__data__;
  if (data instanceof ListCache_default) {
    var pairs = data.__data__;
    if (!Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
      pairs.push([key, value]);
      this.size = ++data.size;
      return this;
    }
    data = this.__data__ = new MapCache_default(pairs);
  }
  data.set(key, value);
  this.size = data.size;
  return this;
}
var LARGE_ARRAY_SIZE, stackSet_default;
var init_stackSet = __esm({
  "node_modules/lodash-es/_stackSet.js"() {
    "use strict";
    init_ListCache();
    init_Map();
    init_MapCache();
    LARGE_ARRAY_SIZE = 200;
    stackSet_default = stackSet;
  }
});

// node_modules/lodash-es/_Stack.js
function Stack(entries) {
  var data = this.__data__ = new ListCache_default(entries);
  this.size = data.size;
}
var Stack_default;
var init_Stack = __esm({
  "node_modules/lodash-es/_Stack.js"() {
    "use strict";
    init_ListCache();
    init_stackClear();
    init_stackDelete();
    init_stackGet();
    init_stackHas();
    init_stackSet();
    Stack.prototype.clear = stackClear_default;
    Stack.prototype["delete"] = stackDelete_default;
    Stack.prototype.get = stackGet_default;
    Stack.prototype.has = stackHas_default;
    Stack.prototype.set = stackSet_default;
    Stack_default = Stack;
  }
});

// node_modules/lodash-es/_arrayFilter.js
function arrayFilter(array4, predicate) {
  var index = -1, length = array4 == null ? 0 : array4.length, resIndex = 0, result = [];
  while (++index < length) {
    var value = array4[index];
    if (predicate(value, index, array4)) {
      result[resIndex++] = value;
    }
  }
  return result;
}
var arrayFilter_default;
var init_arrayFilter = __esm({
  "node_modules/lodash-es/_arrayFilter.js"() {
    "use strict";
    arrayFilter_default = arrayFilter;
  }
});

// node_modules/lodash-es/stubArray.js
function stubArray() {
  return [];
}
var stubArray_default;
var init_stubArray = __esm({
  "node_modules/lodash-es/stubArray.js"() {
    "use strict";
    stubArray_default = stubArray;
  }
});

// node_modules/lodash-es/_getSymbols.js
var objectProto10, propertyIsEnumerable2, nativeGetSymbols, getSymbols, getSymbols_default;
var init_getSymbols = __esm({
  "node_modules/lodash-es/_getSymbols.js"() {
    "use strict";
    init_arrayFilter();
    init_stubArray();
    objectProto10 = Object.prototype;
    propertyIsEnumerable2 = objectProto10.propertyIsEnumerable;
    nativeGetSymbols = Object.getOwnPropertySymbols;
    getSymbols = !nativeGetSymbols ? stubArray_default : function(object4) {
      if (object4 == null) {
        return [];
      }
      object4 = Object(object4);
      return arrayFilter_default(nativeGetSymbols(object4), function(symbol30) {
        return propertyIsEnumerable2.call(object4, symbol30);
      });
    };
    getSymbols_default = getSymbols;
  }
});

// node_modules/lodash-es/_baseGetAllKeys.js
function baseGetAllKeys(object4, keysFunc, symbolsFunc) {
  var result = keysFunc(object4);
  return isArray_default(object4) ? result : arrayPush_default(result, symbolsFunc(object4));
}
var baseGetAllKeys_default;
var init_baseGetAllKeys = __esm({
  "node_modules/lodash-es/_baseGetAllKeys.js"() {
    "use strict";
    init_arrayPush();
    init_isArray();
    baseGetAllKeys_default = baseGetAllKeys;
  }
});

// node_modules/lodash-es/_getAllKeys.js
function getAllKeys(object4) {
  return baseGetAllKeys_default(object4, keys_default, getSymbols_default);
}
var getAllKeys_default;
var init_getAllKeys = __esm({
  "node_modules/lodash-es/_getAllKeys.js"() {
    "use strict";
    init_baseGetAllKeys();
    init_getSymbols();
    init_keys();
    getAllKeys_default = getAllKeys;
  }
});

// node_modules/lodash-es/_DataView.js
var DataView2, DataView_default;
var init_DataView = __esm({
  "node_modules/lodash-es/_DataView.js"() {
    "use strict";
    init_getNative();
    init_root();
    DataView2 = getNative_default(root_default, "DataView");
    DataView_default = DataView2;
  }
});

// node_modules/lodash-es/_Promise.js
var Promise2, Promise_default;
var init_Promise = __esm({
  "node_modules/lodash-es/_Promise.js"() {
    "use strict";
    init_getNative();
    init_root();
    Promise2 = getNative_default(root_default, "Promise");
    Promise_default = Promise2;
  }
});

// node_modules/lodash-es/_Set.js
var Set2, Set_default;
var init_Set = __esm({
  "node_modules/lodash-es/_Set.js"() {
    "use strict";
    init_getNative();
    init_root();
    Set2 = getNative_default(root_default, "Set");
    Set_default = Set2;
  }
});

// node_modules/lodash-es/_getTag.js
var mapTag2, objectTag2, promiseTag, setTag2, weakMapTag2, dataViewTag2, dataViewCtorString, mapCtorString, promiseCtorString, setCtorString, weakMapCtorString, getTag, getTag_default;
var init_getTag = __esm({
  "node_modules/lodash-es/_getTag.js"() {
    "use strict";
    init_DataView();
    init_Map();
    init_Promise();
    init_Set();
    init_WeakMap();
    init_baseGetTag();
    init_toSource();
    mapTag2 = "[object Map]";
    objectTag2 = "[object Object]";
    promiseTag = "[object Promise]";
    setTag2 = "[object Set]";
    weakMapTag2 = "[object WeakMap]";
    dataViewTag2 = "[object DataView]";
    dataViewCtorString = toSource_default(DataView_default);
    mapCtorString = toSource_default(Map_default);
    promiseCtorString = toSource_default(Promise_default);
    setCtorString = toSource_default(Set_default);
    weakMapCtorString = toSource_default(WeakMap_default);
    getTag = baseGetTag_default;
    if (DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != dataViewTag2 || Map_default && getTag(new Map_default()) != mapTag2 || Promise_default && getTag(Promise_default.resolve()) != promiseTag || Set_default && getTag(new Set_default()) != setTag2 || WeakMap_default && getTag(new WeakMap_default()) != weakMapTag2) {
      getTag = function(value) {
        var result = baseGetTag_default(value), Ctor = result == objectTag2 ? value.constructor : void 0, ctorString = Ctor ? toSource_default(Ctor) : "";
        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString:
              return dataViewTag2;
            case mapCtorString:
              return mapTag2;
            case promiseCtorString:
              return promiseTag;
            case setCtorString:
              return setTag2;
            case weakMapCtorString:
              return weakMapTag2;
          }
        }
        return result;
      };
    }
    getTag_default = getTag;
  }
});

// node_modules/lodash-es/_Uint8Array.js
var Uint8Array2, Uint8Array_default;
var init_Uint8Array = __esm({
  "node_modules/lodash-es/_Uint8Array.js"() {
    "use strict";
    init_root();
    Uint8Array2 = root_default.Uint8Array;
    Uint8Array_default = Uint8Array2;
  }
});

// node_modules/lodash-es/_setCacheAdd.js
function setCacheAdd(value) {
  this.__data__.set(value, HASH_UNDEFINED3);
  return this;
}
var HASH_UNDEFINED3, setCacheAdd_default;
var init_setCacheAdd = __esm({
  "node_modules/lodash-es/_setCacheAdd.js"() {
    "use strict";
    HASH_UNDEFINED3 = "__lodash_hash_undefined__";
    setCacheAdd_default = setCacheAdd;
  }
});

// node_modules/lodash-es/_setCacheHas.js
function setCacheHas(value) {
  return this.__data__.has(value);
}
var setCacheHas_default;
var init_setCacheHas = __esm({
  "node_modules/lodash-es/_setCacheHas.js"() {
    "use strict";
    setCacheHas_default = setCacheHas;
  }
});

// node_modules/lodash-es/_SetCache.js
function SetCache(values) {
  var index = -1, length = values == null ? 0 : values.length;
  this.__data__ = new MapCache_default();
  while (++index < length) {
    this.add(values[index]);
  }
}
var SetCache_default;
var init_SetCache = __esm({
  "node_modules/lodash-es/_SetCache.js"() {
    "use strict";
    init_MapCache();
    init_setCacheAdd();
    init_setCacheHas();
    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd_default;
    SetCache.prototype.has = setCacheHas_default;
    SetCache_default = SetCache;
  }
});

// node_modules/lodash-es/_arraySome.js
function arraySome(array4, predicate) {
  var index = -1, length = array4 == null ? 0 : array4.length;
  while (++index < length) {
    if (predicate(array4[index], index, array4)) {
      return true;
    }
  }
  return false;
}
var arraySome_default;
var init_arraySome = __esm({
  "node_modules/lodash-es/_arraySome.js"() {
    "use strict";
    arraySome_default = arraySome;
  }
});

// node_modules/lodash-es/_cacheHas.js
function cacheHas(cache, key) {
  return cache.has(key);
}
var cacheHas_default;
var init_cacheHas = __esm({
  "node_modules/lodash-es/_cacheHas.js"() {
    "use strict";
    cacheHas_default = cacheHas;
  }
});

// node_modules/lodash-es/_equalArrays.js
function equalArrays(array4, other, bitmask, customizer, equalFunc, stack) {
  var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array4.length, othLength = other.length;
  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
    return false;
  }
  var arrStacked = stack.get(array4);
  var othStacked = stack.get(other);
  if (arrStacked && othStacked) {
    return arrStacked == other && othStacked == array4;
  }
  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache_default() : void 0;
  stack.set(array4, other);
  stack.set(other, array4);
  while (++index < arrLength) {
    var arrValue = array4[index], othValue = other[index];
    if (customizer) {
      var compared = isPartial ? customizer(othValue, arrValue, index, other, array4, stack) : customizer(arrValue, othValue, index, array4, other, stack);
    }
    if (compared !== void 0) {
      if (compared) {
        continue;
      }
      result = false;
      break;
    }
    if (seen) {
      if (!arraySome_default(other, function(othValue2, othIndex) {
        if (!cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
          return seen.push(othIndex);
        }
      })) {
        result = false;
        break;
      }
    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
      result = false;
      break;
    }
  }
  stack["delete"](array4);
  stack["delete"](other);
  return result;
}
var COMPARE_PARTIAL_FLAG, COMPARE_UNORDERED_FLAG, equalArrays_default;
var init_equalArrays = __esm({
  "node_modules/lodash-es/_equalArrays.js"() {
    "use strict";
    init_SetCache();
    init_arraySome();
    init_cacheHas();
    COMPARE_PARTIAL_FLAG = 1;
    COMPARE_UNORDERED_FLAG = 2;
    equalArrays_default = equalArrays;
  }
});

// node_modules/lodash-es/_mapToArray.js
function mapToArray(map3) {
  var index = -1, result = Array(map3.size);
  map3.forEach(function(value, key) {
    result[++index] = [key, value];
  });
  return result;
}
var mapToArray_default;
var init_mapToArray = __esm({
  "node_modules/lodash-es/_mapToArray.js"() {
    "use strict";
    mapToArray_default = mapToArray;
  }
});

// node_modules/lodash-es/_setToArray.js
function setToArray(set3) {
  var index = -1, result = Array(set3.size);
  set3.forEach(function(value) {
    result[++index] = value;
  });
  return result;
}
var setToArray_default;
var init_setToArray = __esm({
  "node_modules/lodash-es/_setToArray.js"() {
    "use strict";
    setToArray_default = setToArray;
  }
});

// node_modules/lodash-es/_equalByTag.js
function equalByTag(object4, other, tag, bitmask, customizer, equalFunc, stack) {
  switch (tag) {
    case dataViewTag3:
      if (object4.byteLength != other.byteLength || object4.byteOffset != other.byteOffset) {
        return false;
      }
      object4 = object4.buffer;
      other = other.buffer;
    case arrayBufferTag2:
      if (object4.byteLength != other.byteLength || !equalFunc(new Uint8Array_default(object4), new Uint8Array_default(other))) {
        return false;
      }
      return true;
    case boolTag2:
    case dateTag2:
    case numberTag2:
      return eq_default(+object4, +other);
    case errorTag2:
      return object4.name == other.name && object4.message == other.message;
    case regexpTag2:
    case stringTag2:
      return object4 == other + "";
    case mapTag3:
      var convert = mapToArray_default;
    case setTag3:
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG2;
      convert || (convert = setToArray_default);
      if (object4.size != other.size && !isPartial) {
        return false;
      }
      var stacked = stack.get(object4);
      if (stacked) {
        return stacked == other;
      }
      bitmask |= COMPARE_UNORDERED_FLAG2;
      stack.set(object4, other);
      var result = equalArrays_default(convert(object4), convert(other), bitmask, customizer, equalFunc, stack);
      stack["delete"](object4);
      return result;
    case symbolTag2:
      if (symbolValueOf) {
        return symbolValueOf.call(object4) == symbolValueOf.call(other);
      }
  }
  return false;
}
var COMPARE_PARTIAL_FLAG2, COMPARE_UNORDERED_FLAG2, boolTag2, dateTag2, errorTag2, mapTag3, numberTag2, regexpTag2, setTag3, stringTag2, symbolTag2, arrayBufferTag2, dataViewTag3, symbolProto2, symbolValueOf, equalByTag_default;
var init_equalByTag = __esm({
  "node_modules/lodash-es/_equalByTag.js"() {
    "use strict";
    init_Symbol();
    init_Uint8Array();
    init_eq();
    init_equalArrays();
    init_mapToArray();
    init_setToArray();
    COMPARE_PARTIAL_FLAG2 = 1;
    COMPARE_UNORDERED_FLAG2 = 2;
    boolTag2 = "[object Boolean]";
    dateTag2 = "[object Date]";
    errorTag2 = "[object Error]";
    mapTag3 = "[object Map]";
    numberTag2 = "[object Number]";
    regexpTag2 = "[object RegExp]";
    setTag3 = "[object Set]";
    stringTag2 = "[object String]";
    symbolTag2 = "[object Symbol]";
    arrayBufferTag2 = "[object ArrayBuffer]";
    dataViewTag3 = "[object DataView]";
    symbolProto2 = Symbol_default ? Symbol_default.prototype : void 0;
    symbolValueOf = symbolProto2 ? symbolProto2.valueOf : void 0;
    equalByTag_default = equalByTag;
  }
});

// node_modules/lodash-es/_equalObjects.js
function equalObjects(object4, other, bitmask, customizer, equalFunc, stack) {
  var isPartial = bitmask & COMPARE_PARTIAL_FLAG3, objProps = getAllKeys_default(object4), objLength = objProps.length, othProps = getAllKeys_default(other), othLength = othProps.length;
  if (objLength != othLength && !isPartial) {
    return false;
  }
  var index = objLength;
  while (index--) {
    var key = objProps[index];
    if (!(isPartial ? key in other : hasOwnProperty8.call(other, key))) {
      return false;
    }
  }
  var objStacked = stack.get(object4);
  var othStacked = stack.get(other);
  if (objStacked && othStacked) {
    return objStacked == other && othStacked == object4;
  }
  var result = true;
  stack.set(object4, other);
  stack.set(other, object4);
  var skipCtor = isPartial;
  while (++index < objLength) {
    key = objProps[index];
    var objValue = object4[key], othValue = other[key];
    if (customizer) {
      var compared = isPartial ? customizer(othValue, objValue, key, other, object4, stack) : customizer(objValue, othValue, key, object4, other, stack);
    }
    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
      result = false;
      break;
    }
    skipCtor || (skipCtor = key == "constructor");
  }
  if (result && !skipCtor) {
    var objCtor = object4.constructor, othCtor = other.constructor;
    if (objCtor != othCtor && ("constructor" in object4 && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
      result = false;
    }
  }
  stack["delete"](object4);
  stack["delete"](other);
  return result;
}
var COMPARE_PARTIAL_FLAG3, objectProto11, hasOwnProperty8, equalObjects_default;
var init_equalObjects = __esm({
  "node_modules/lodash-es/_equalObjects.js"() {
    "use strict";
    init_getAllKeys();
    COMPARE_PARTIAL_FLAG3 = 1;
    objectProto11 = Object.prototype;
    hasOwnProperty8 = objectProto11.hasOwnProperty;
    equalObjects_default = equalObjects;
  }
});

// node_modules/lodash-es/_baseIsEqualDeep.js
function baseIsEqualDeep(object4, other, bitmask, customizer, equalFunc, stack) {
  var objIsArr = isArray_default(object4), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag2 : getTag_default(object4), othTag = othIsArr ? arrayTag2 : getTag_default(other);
  objTag = objTag == argsTag3 ? objectTag3 : objTag;
  othTag = othTag == argsTag3 ? objectTag3 : othTag;
  var objIsObj = objTag == objectTag3, othIsObj = othTag == objectTag3, isSameTag = objTag == othTag;
  if (isSameTag && isBuffer_default(object4)) {
    if (!isBuffer_default(other)) {
      return false;
    }
    objIsArr = true;
    objIsObj = false;
  }
  if (isSameTag && !objIsObj) {
    stack || (stack = new Stack_default());
    return objIsArr || isTypedArray_default(object4) ? equalArrays_default(object4, other, bitmask, customizer, equalFunc, stack) : equalByTag_default(object4, other, objTag, bitmask, customizer, equalFunc, stack);
  }
  if (!(bitmask & COMPARE_PARTIAL_FLAG4)) {
    var objIsWrapped = objIsObj && hasOwnProperty9.call(object4, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty9.call(other, "__wrapped__");
    if (objIsWrapped || othIsWrapped) {
      var objUnwrapped = objIsWrapped ? object4.value() : object4, othUnwrapped = othIsWrapped ? other.value() : other;
      stack || (stack = new Stack_default());
      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
    }
  }
  if (!isSameTag) {
    return false;
  }
  stack || (stack = new Stack_default());
  return equalObjects_default(object4, other, bitmask, customizer, equalFunc, stack);
}
var COMPARE_PARTIAL_FLAG4, argsTag3, arrayTag2, objectTag3, objectProto12, hasOwnProperty9, baseIsEqualDeep_default;
var init_baseIsEqualDeep = __esm({
  "node_modules/lodash-es/_baseIsEqualDeep.js"() {
    "use strict";
    init_Stack();
    init_equalArrays();
    init_equalByTag();
    init_equalObjects();
    init_getTag();
    init_isArray();
    init_isBuffer();
    init_isTypedArray();
    COMPARE_PARTIAL_FLAG4 = 1;
    argsTag3 = "[object Arguments]";
    arrayTag2 = "[object Array]";
    objectTag3 = "[object Object]";
    objectProto12 = Object.prototype;
    hasOwnProperty9 = objectProto12.hasOwnProperty;
    baseIsEqualDeep_default = baseIsEqualDeep;
  }
});

// node_modules/lodash-es/_baseIsEqual.js
function baseIsEqual(value, other, bitmask, customizer, stack) {
  if (value === other) {
    return true;
  }
  if (value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other)) {
    return value !== value && other !== other;
  }
  return baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
}
var baseIsEqual_default;
var init_baseIsEqual = __esm({
  "node_modules/lodash-es/_baseIsEqual.js"() {
    "use strict";
    init_baseIsEqualDeep();
    init_isObjectLike();
    baseIsEqual_default = baseIsEqual;
  }
});

// node_modules/lodash-es/_baseIsMatch.js
function baseIsMatch(object4, source, matchData, customizer) {
  var index = matchData.length, length = index, noCustomizer = !customizer;
  if (object4 == null) {
    return !length;
  }
  object4 = Object(object4);
  while (index--) {
    var data = matchData[index];
    if (noCustomizer && data[2] ? data[1] !== object4[data[0]] : !(data[0] in object4)) {
      return false;
    }
  }
  while (++index < length) {
    data = matchData[index];
    var key = data[0], objValue = object4[key], srcValue = data[1];
    if (noCustomizer && data[2]) {
      if (objValue === void 0 && !(key in object4)) {
        return false;
      }
    } else {
      var stack = new Stack_default();
      if (customizer) {
        var result = customizer(objValue, srcValue, key, object4, source, stack);
      }
      if (!(result === void 0 ? baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG5 | COMPARE_UNORDERED_FLAG3, customizer, stack) : result)) {
        return false;
      }
    }
  }
  return true;
}
var COMPARE_PARTIAL_FLAG5, COMPARE_UNORDERED_FLAG3, baseIsMatch_default;
var init_baseIsMatch = __esm({
  "node_modules/lodash-es/_baseIsMatch.js"() {
    "use strict";
    init_Stack();
    init_baseIsEqual();
    COMPARE_PARTIAL_FLAG5 = 1;
    COMPARE_UNORDERED_FLAG3 = 2;
    baseIsMatch_default = baseIsMatch;
  }
});

// node_modules/lodash-es/_isStrictComparable.js
function isStrictComparable(value) {
  return value === value && !isObject_default(value);
}
var isStrictComparable_default;
var init_isStrictComparable = __esm({
  "node_modules/lodash-es/_isStrictComparable.js"() {
    "use strict";
    init_isObject();
    isStrictComparable_default = isStrictComparable;
  }
});

// node_modules/lodash-es/_getMatchData.js
function getMatchData(object4) {
  var result = keys_default(object4), length = result.length;
  while (length--) {
    var key = result[length], value = object4[key];
    result[length] = [key, value, isStrictComparable_default(value)];
  }
  return result;
}
var getMatchData_default;
var init_getMatchData = __esm({
  "node_modules/lodash-es/_getMatchData.js"() {
    "use strict";
    init_isStrictComparable();
    init_keys();
    getMatchData_default = getMatchData;
  }
});

// node_modules/lodash-es/_matchesStrictComparable.js
function matchesStrictComparable(key, srcValue) {
  return function(object4) {
    if (object4 == null) {
      return false;
    }
    return object4[key] === srcValue && (srcValue !== void 0 || key in Object(object4));
  };
}
var matchesStrictComparable_default;
var init_matchesStrictComparable = __esm({
  "node_modules/lodash-es/_matchesStrictComparable.js"() {
    "use strict";
    matchesStrictComparable_default = matchesStrictComparable;
  }
});

// node_modules/lodash-es/_baseMatches.js
function baseMatches(source) {
  var matchData = getMatchData_default(source);
  if (matchData.length == 1 && matchData[0][2]) {
    return matchesStrictComparable_default(matchData[0][0], matchData[0][1]);
  }
  return function(object4) {
    return object4 === source || baseIsMatch_default(object4, source, matchData);
  };
}
var baseMatches_default;
var init_baseMatches = __esm({
  "node_modules/lodash-es/_baseMatches.js"() {
    "use strict";
    init_baseIsMatch();
    init_getMatchData();
    init_matchesStrictComparable();
    baseMatches_default = baseMatches;
  }
});

// node_modules/lodash-es/_baseHasIn.js
function baseHasIn(object4, key) {
  return object4 != null && key in Object(object4);
}
var baseHasIn_default;
var init_baseHasIn = __esm({
  "node_modules/lodash-es/_baseHasIn.js"() {
    "use strict";
    baseHasIn_default = baseHasIn;
  }
});

// node_modules/lodash-es/_hasPath.js
function hasPath(object4, path33, hasFunc) {
  path33 = castPath_default(path33, object4);
  var index = -1, length = path33.length, result = false;
  while (++index < length) {
    var key = toKey_default(path33[index]);
    if (!(result = object4 != null && hasFunc(object4, key))) {
      break;
    }
    object4 = object4[key];
  }
  if (result || ++index != length) {
    return result;
  }
  length = object4 == null ? 0 : object4.length;
  return !!length && isLength_default(length) && isIndex_default(key, length) && (isArray_default(object4) || isArguments_default(object4));
}
var hasPath_default;
var init_hasPath = __esm({
  "node_modules/lodash-es/_hasPath.js"() {
    "use strict";
    init_castPath();
    init_isArguments();
    init_isArray();
    init_isIndex();
    init_isLength();
    init_toKey();
    hasPath_default = hasPath;
  }
});

// node_modules/lodash-es/hasIn.js
function hasIn(object4, path33) {
  return object4 != null && hasPath_default(object4, path33, baseHasIn_default);
}
var hasIn_default;
var init_hasIn = __esm({
  "node_modules/lodash-es/hasIn.js"() {
    "use strict";
    init_baseHasIn();
    init_hasPath();
    hasIn_default = hasIn;
  }
});

// node_modules/lodash-es/_baseMatchesProperty.js
function baseMatchesProperty(path33, srcValue) {
  if (isKey_default(path33) && isStrictComparable_default(srcValue)) {
    return matchesStrictComparable_default(toKey_default(path33), srcValue);
  }
  return function(object4) {
    var objValue = get_default(object4, path33);
    return objValue === void 0 && objValue === srcValue ? hasIn_default(object4, path33) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
  };
}
var COMPARE_PARTIAL_FLAG6, COMPARE_UNORDERED_FLAG4, baseMatchesProperty_default;
var init_baseMatchesProperty = __esm({
  "node_modules/lodash-es/_baseMatchesProperty.js"() {
    "use strict";
    init_baseIsEqual();
    init_get();
    init_hasIn();
    init_isKey();
    init_isStrictComparable();
    init_matchesStrictComparable();
    init_toKey();
    COMPARE_PARTIAL_FLAG6 = 1;
    COMPARE_UNORDERED_FLAG4 = 2;
    baseMatchesProperty_default = baseMatchesProperty;
  }
});

// node_modules/lodash-es/_baseProperty.js
function baseProperty(key) {
  return function(object4) {
    return object4 == null ? void 0 : object4[key];
  };
}
var baseProperty_default;
var init_baseProperty = __esm({
  "node_modules/lodash-es/_baseProperty.js"() {
    "use strict";
    baseProperty_default = baseProperty;
  }
});

// node_modules/lodash-es/_basePropertyDeep.js
function basePropertyDeep(path33) {
  return function(object4) {
    return baseGet_default(object4, path33);
  };
}
var basePropertyDeep_default;
var init_basePropertyDeep = __esm({
  "node_modules/lodash-es/_basePropertyDeep.js"() {
    "use strict";
    init_baseGet();
    basePropertyDeep_default = basePropertyDeep;
  }
});

// node_modules/lodash-es/property.js
function property(path33) {
  return isKey_default(path33) ? baseProperty_default(toKey_default(path33)) : basePropertyDeep_default(path33);
}
var property_default;
var init_property = __esm({
  "node_modules/lodash-es/property.js"() {
    "use strict";
    init_baseProperty();
    init_basePropertyDeep();
    init_isKey();
    init_toKey();
    property_default = property;
  }
});

// node_modules/lodash-es/_baseIteratee.js
function baseIteratee(value) {
  if (typeof value == "function") {
    return value;
  }
  if (value == null) {
    return identity_default;
  }
  if (typeof value == "object") {
    return isArray_default(value) ? baseMatchesProperty_default(value[0], value[1]) : baseMatches_default(value);
  }
  return property_default(value);
}
var baseIteratee_default;
var init_baseIteratee = __esm({
  "node_modules/lodash-es/_baseIteratee.js"() {
    "use strict";
    init_baseMatches();
    init_baseMatchesProperty();
    init_identity();
    init_isArray();
    init_property();
    baseIteratee_default = baseIteratee;
  }
});

// node_modules/lodash-es/_arrayIncludesWith.js
function arrayIncludesWith(array4, value, comparator) {
  var index = -1, length = array4 == null ? 0 : array4.length;
  while (++index < length) {
    if (comparator(value, array4[index])) {
      return true;
    }
  }
  return false;
}
var arrayIncludesWith_default;
var init_arrayIncludesWith = __esm({
  "node_modules/lodash-es/_arrayIncludesWith.js"() {
    "use strict";
    arrayIncludesWith_default = arrayIncludesWith;
  }
});

// node_modules/lodash-es/_createSet.js
var INFINITY3, createSet, createSet_default;
var init_createSet = __esm({
  "node_modules/lodash-es/_createSet.js"() {
    "use strict";
    init_Set();
    init_noop();
    init_setToArray();
    INFINITY3 = 1 / 0;
    createSet = !(Set_default && 1 / setToArray_default(new Set_default([, -0]))[1] == INFINITY3) ? noop_default : function(values) {
      return new Set_default(values);
    };
    createSet_default = createSet;
  }
});

// node_modules/lodash-es/_baseUniq.js
function baseUniq(array4, iteratee, comparator) {
  var index = -1, includes = arrayIncludes_default, length = array4.length, isCommon = true, result = [], seen = result;
  if (comparator) {
    isCommon = false;
    includes = arrayIncludesWith_default;
  } else if (length >= LARGE_ARRAY_SIZE2) {
    var set3 = iteratee ? null : createSet_default(array4);
    if (set3) {
      return setToArray_default(set3);
    }
    isCommon = false;
    includes = cacheHas_default;
    seen = new SetCache_default();
  } else {
    seen = iteratee ? [] : result;
  }
  outer:
    while (++index < length) {
      var value = array4[index], computed = iteratee ? iteratee(value) : value;
      value = comparator || value !== 0 ? value : 0;
      if (isCommon && computed === computed) {
        var seenIndex = seen.length;
        while (seenIndex--) {
          if (seen[seenIndex] === computed) {
            continue outer;
          }
        }
        if (iteratee) {
          seen.push(computed);
        }
        result.push(value);
      } else if (!includes(seen, computed, comparator)) {
        if (seen !== result) {
          seen.push(computed);
        }
        result.push(value);
      }
    }
  return result;
}
var LARGE_ARRAY_SIZE2, baseUniq_default;
var init_baseUniq = __esm({
  "node_modules/lodash-es/_baseUniq.js"() {
    "use strict";
    init_SetCache();
    init_arrayIncludes();
    init_arrayIncludesWith();
    init_cacheHas();
    init_createSet();
    init_setToArray();
    LARGE_ARRAY_SIZE2 = 200;
    baseUniq_default = baseUniq;
  }
});

// node_modules/lodash-es/uniqBy.js
function uniqBy(array4, iteratee) {
  return array4 && array4.length ? baseUniq_default(array4, baseIteratee_default(iteratee, 2)) : [];
}
var uniqBy_default;
var init_uniqBy = __esm({
  "node_modules/lodash-es/uniqBy.js"() {
    "use strict";
    init_baseIteratee();
    init_baseUniq();
    uniqBy_default = uniqBy;
  }
});

// node_modules/lodash-es/lodash.js
var init_lodash = __esm({
  "node_modules/lodash-es/lodash.js"() {
    "use strict";
    init_uniqBy();
  }
});

// node_modules/@rmp135/sql-ts/dist/Adapters/postgres.js
var postgres_default;
var init_postgres = __esm({
  "node_modules/@rmp135/sql-ts/dist/Adapters/postgres.js"() {
    "use strict";
    init_lodash();
    init_SharedAdapterTasks();
    postgres_default = {
      async getAllEnums(db2, config3) {
        const sql = `
    SELECT 
      pg_namespace.nspname AS schema, 
      pg_enum.enumsortorder AS order, 
      pg_type.typname AS name, 
      pg_enum.enumlabel AS value 
    FROM pg_type
    JOIN pg_enum ON pg_enum.enumtypid = pg_type.oid
    JOIN pg_namespace ON pg_namespace.oid = pg_type.typnamespace
    ${config3.schemas.length > 0 ? ` WHERE pg_namespace.nspname = ANY(:schemas)` : ""}
    `;
        const ungroupedEnums = (await db2.raw(sql, { schemas: config3.schemas })).rows;
        const groupedEnums = uniqBy_default(ungroupedEnums, (e) => `${e.name}.${e.schema}`).map((row) => ({
          name: row.name,
          schema: row.schema,
          values: Object.fromEntries(ungroupedEnums.filter((e) => e.schema == row.schema && e.name == row.name).sort((a, b) => a.order - b.order).map((e) => [e.value, e.value]))
        }));
        const tableEnums = await getTableEnums(db2, config3);
        return groupedEnums.concat(tableEnums);
      },
      async getAllTables(db2, schemas) {
        const sql = `
      WITH schemas AS (
        SELECT nspname AS name, oid AS oid
        FROM pg_namespace
        WHERE nspname <> 'information_schema' AND nspname NOT LIKE 'pg_%'
        ${schemas.length > 0 ? ` AND nspname = ANY(:schemas)` : ""}
        )
        SELECT schemas.name AS schema,
            pg_class.relname AS name,
            COALESCE(pg_catalog.OBJ_DESCRIPTION( pg_class.oid , 'pg_class' ), '') AS comment
        FROM pg_class
            JOIN schemas ON schemas.oid = pg_class.relnamespace
        WHERE pg_class.relkind IN ('r', 'p', 'v', 'm')
        AND NOT pg_class.relispartition
    `;
        const results = await db2.raw(sql, { schemas });
        return results.rows;
      },
      async getAllColumns(db2, config3, table, schema) {
        const sql = `
      SELECT
        typns.nspname typeschema,
        pg_type.typname,
        pg_attribute.attname AS name,
        pg_namespace.nspname AS schema,
        pg_catalog.format_type(pg_attribute.atttypid, null) as type,
        pg_attribute.attnotnull AS notNullable,
        pg_attribute.atthasdef OR pg_attribute.attidentity <> '' AS hasDefault,
        pg_class.relname AS table,
        pg_type.typcategory AS typcategory,
        pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) defaultvalue,
        COALESCE(pg_catalog.col_description(pg_class.oid, pg_attribute.attnum), '') as comment,
        CASE WHEN EXISTS (
          SELECT null 
          FROM pg_index
          WHERE pg_index.indrelid = pg_attribute.attrelid
          AND  pg_attribute.attnum = any(pg_index.indkey)
          AND pg_index.indisprimary
        ) THEN 1 ELSE 0 END isPrimaryKey
      FROM pg_attribute
      JOIN pg_class ON pg_class.oid = pg_attribute.attrelid
      LEFT JOIN pg_attrdef ON pg_attrdef.adrelid = pg_class.oid
          AND pg_attribute.attnum = pg_attrdef.adnum
      JOIN pg_type ON pg_type.oid = pg_attribute.atttypid
      JOIN pg_namespace ON pg_namespace.oid = pg_class.relnamespace
      JOIN pg_namespace AS typns ON typns.oid = pg_type.typnamespace
      where pg_attribute.attnum > 0
      AND pg_class.relname = :table
      AND pg_namespace.nspname = :schema
    `;
        return (await db2.raw(sql, { table, schema })).rows.map((c) => ({
          name: c.name,
          type: c.typname,
          nullable: !c.notnullable,
          optional: c.hasdefault || !c.notnullable,
          columnType: c.typcategory == "E" ? "NumericEnum" : "Standard",
          isPrimaryKey: c.isprimarykey == 1,
          enumSchema: c.typeschema,
          comment: c.comment,
          defaultValue: c.defaultvalue?.toString() ?? null
        }));
      }
    };
  }
});

// node_modules/@rmp135/sql-ts/dist/Adapters/sqlite.js
var sqlite_default;
var init_sqlite = __esm({
  "node_modules/@rmp135/sql-ts/dist/Adapters/sqlite.js"() {
    "use strict";
    init_SharedAdapterTasks();
    sqlite_default = {
      async getAllEnums(db2, config3) {
        return await getTableEnums(db2, config3);
      },
      async getAllTables(db2, schemas) {
        const sql = `
      SELECT tbl_name from sqlite_master
      WHERE tbl_name <> 'sqlite_sequence'
      AND type IN ('table', 'view')
    `;
        return (await db2.raw(sql)).map((t) => ({ name: t.tbl_name, schema: "main", comment: "" }));
      },
      async getAllColumns(db2, config3, table, schema) {
        return (await db2.raw(`pragma table_info(${table})`)).map((c) => ({
          name: c.name,
          nullable: c.notnull === 0,
          type: (c.type.includes("(") ? c.type.split("(")[0] : c.type).toLowerCase(),
          optional: c.dflt_value !== null || c.notnull === 0 || c.pk !== 0,
          columnType: "Standard",
          isPrimaryKey: c.pk !== 0,
          comment: "",
          defaultValue: c.dflt_value?.toString() ?? null
        }));
      }
    };
  }
});

// node_modules/@rmp135/sql-ts/dist/AdapterFactory.js
function buildAdapter(adapterName) {
  const dialect = resolveAdapterName(adapterName);
  const adapter2 = adapters[dialect];
  if (!adapter2) {
    throw new Error(`Unable to find adapter for dialect '${dialect}'.`);
  }
  return adapter2;
}
var adapters;
var init_AdapterFactory = __esm({
  "node_modules/@rmp135/sql-ts/dist/AdapterFactory.js"() {
    "use strict";
    init_SharedTasks();
    init_mysql();
    init_mssql();
    init_postgres();
    init_sqlite();
    adapters = {
      "mysql": mysql_default,
      "mssql": mssql_default,
      "postgres": postgres_default,
      "sqlite": sqlite_default
    };
  }
});

// node_modules/@rmp135/sql-ts/dist/TypeMap.js
var TypeMap_default;
var init_TypeMap = __esm({
  "node_modules/@rmp135/sql-ts/dist/TypeMap.js"() {
    "use strict";
    TypeMap_default = {
      global: {
        string: ["nchar", "nvarchar", "varchar", "char", "tinytext", "text", "longtext", "mediumtext", "ntext", "citext", "varbinary", "uuid", "uniqueidentifier", "character varying", "bigint", "xml"],
        "string[]": ["_text", "_uuid"],
        number: ["tinyint", "int", "numeric", "integer", "real", "smallint", "decimal", "float", "float4", "float8", "double precision", "double", "dec", "fixed", "year", "serial", "bigserial", "int2", "int4", "money", "smallmoney"],
        Date: ["datetime", "timestamp", "date", "time", "timestamptz", "datetime2", "smalldatetime", "datetimeoffset"],
        boolean: ["bit", "boolean", "bool"],
        Object: ["json", "TVP"],
        Buffer: ["binary", "varbinary", "image", "UDT"]
      },
      postgres: {
        string: ["numeric", "decimal", "int8", "money", "bpchar", "character_data"],
        "string[]": ["_char", "_varchar", "_bpchar", "_character_data"]
      },
      mssql: {
        string: ["timestamp"],
        boolean: ["tinyint(1)"]
      }
    };
  }
});

// node_modules/@rmp135/sql-ts/dist/SchemaTasks.js
function generateSchemaName(name28) {
  if (name28 == null)
    return name28;
  return name28.replace(/\W/g, "").replace(/^\d+/g, "");
}
var init_SchemaTasks = __esm({
  "node_modules/@rmp135/sql-ts/dist/SchemaTasks.js"() {
    "use strict";
  }
});

// node_modules/@rmp135/sql-ts/dist/EnumTasks.js
async function getAllEnums2(db2, config3) {
  const adapter2 = buildAdapter(db2.client.dialect);
  return (await adapter2.getAllEnums(db2, config3)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({
    name: e.name,
    schema: generateSchemaName(e.schema),
    convertedName: generateEnumName(e.name, config3),
    values: Object.keys(e.values).sort((a, b) => a.localeCompare(b)).map((ee) => ({
      originalKey: ee,
      convertedKey: generateEnumKey(ee, config3),
      value: e.values[ee]
    }))
  }));
}
function generateEnumName(name28, config3) {
  let newName = name28.replace(/\W/g, "").replace(/^\d+/g, "");
  newName = convertCase(newName, config3.enumNameCasing);
  return config3.enumNameFormat.replace("${name}", newName);
}
function generateEnumKey(name28, config3) {
  const newKey = convertCase(name28, config3.enumKeyCasing);
  return isNaN(Number(newKey)) ? newKey : config3.enumNumericKeyFormat.replace("${key}", newKey);
}
var init_EnumTasks = __esm({
  "node_modules/@rmp135/sql-ts/dist/EnumTasks.js"() {
    "use strict";
    init_AdapterFactory();
    init_SharedTasks();
    init_SchemaTasks();
  }
});

// node_modules/@rmp135/sql-ts/dist/ColumnTasks.js
async function getColumnsForTable(db2, table, config3) {
  const adapter2 = buildAdapter(db2.client.dialect);
  const columns = await adapter2.getAllColumns(db2, config3, table.name, table.schema);
  if (config3.columnSortOrder === "alphabetical") {
    columns.sort((a, b) => a.name.localeCompare(b.name));
  }
  return columns.map((column) => ({
    ...column,
    propertyName: convertCase(column.name.replace(/ /g, ""), config3.columnNameCasing),
    propertyType: convertType(column, table, config3, db2.client.dialect),
    optional: getOptionality(column, table, config3)
  }));
}
function getOptionality(column, table, config3) {
  let optionality = config3.globalOptionality;
  const columnName = generateFullColumnName(table.name, table.schema, column.name);
  if (config3.columnOptionality[columnName]) {
    optionality = config3.columnOptionality[columnName];
  }
  if (optionality == "optional") {
    return true;
  } else if (optionality == "required") {
    return false;
  }
  return column.optional;
}
function generateFullColumnName(tableName, schemaName, columnName) {
  let result = tableName;
  if (schemaName != null && schemaName !== "") {
    result = `${schemaName}.${result}`;
  }
  return `${result}.${columnName}`;
}
function convertType(column, table, config3, dialect) {
  switch (column.columnType) {
    case "NumericEnum":
      return convertNumericEnumType(column, config3);
    case "StringEnum":
      return convertStringEnumType(column);
    default:
      return convertStandardType(column, table, config3, dialect);
  }
}
function convertStandardType(column, table, config3, dialect) {
  const fullname = generateFullColumnName(table.name, table.schema, column.name);
  let convertedType = null;
  const overrides = config3.typeOverrides;
  const userTypeMap = config3.typeMap;
  convertedType = overrides[fullname];
  if (convertedType == null) {
    convertedType = Object.keys(userTypeMap).find((t) => userTypeMap[t].includes(column.type));
  }
  if (convertedType == null) {
    const resolvedDialect = resolveAdapterName(dialect);
    const perDBTypeMap = TypeMap_default[resolvedDialect];
    if (perDBTypeMap != null) {
      convertedType = Object.keys(perDBTypeMap).find((f) => perDBTypeMap[f].includes(column.type));
    }
  }
  if (convertedType == null) {
    let globalMap = TypeMap_default["global"];
    convertedType = Object.keys(globalMap).find((f) => globalMap[f].includes(column.type));
  }
  return convertedType == null ? "any" : convertedType;
}
function convertNumericEnumType(column, config3) {
  const enumName = generateEnumName(column.type, config3);
  if (column.enumSchema != null && config3.schemaAsNamespace) {
    const schemaName = generateSchemaName(column.enumSchema);
    return `${schemaName}.${enumName}`;
  }
  return enumName;
}
function convertStringEnumType(column) {
  return column.stringEnumValues.map((v) => `'${v}'`).join(" | ");
}
var init_ColumnTasks = __esm({
  "node_modules/@rmp135/sql-ts/dist/ColumnTasks.js"() {
    "use strict";
    init_AdapterFactory();
    init_SharedTasks();
    init_TypeMap();
    init_EnumTasks();
    init_SchemaTasks();
  }
});

// node_modules/pluralize/pluralize.js
var require_pluralize = __commonJS({
  "node_modules/pluralize/pluralize.js"(exports2, module2) {
    "use strict";
    (function(root2, pluralize2) {
      if (typeof require === "function" && typeof exports2 === "object" && typeof module2 === "object") {
        module2.exports = pluralize2();
      } else if (typeof define === "function" && define.amd) {
        define(function() {
          return pluralize2();
        });
      } else {
        root2.pluralize = pluralize2();
      }
    })(exports2, function() {
      var pluralRules = [];
      var singularRules = [];
      var uncountables = {};
      var irregularPlurals = {};
      var irregularSingles = {};
      function sanitizeRule(rule) {
        if (typeof rule === "string") {
          return new RegExp("^" + rule + "$", "i");
        }
        return rule;
      }
      function restoreCase(word, token) {
        if (word === token) return token;
        if (word === word.toLowerCase()) return token.toLowerCase();
        if (word === word.toUpperCase()) return token.toUpperCase();
        if (word[0] === word[0].toUpperCase()) {
          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
        }
        return token.toLowerCase();
      }
      function interpolate(str, args) {
        return str.replace(/\$(\d{1,2})/g, function(match, index) {
          return args[index] || "";
        });
      }
      function replace(word, rule) {
        return word.replace(rule[0], function(match, index) {
          var result = interpolate(rule[1], arguments);
          if (match === "") {
            return restoreCase(word[index - 1], result);
          }
          return restoreCase(match, result);
        });
      }
      function sanitizeWord(token, word, rules) {
        if (!token.length || uncountables.hasOwnProperty(token)) {
          return word;
        }
        var len = rules.length;
        while (len--) {
          var rule = rules[len];
          if (rule[0].test(word)) return replace(word, rule);
        }
        return word;
      }
      function replaceWord(replaceMap, keepMap, rules) {
        return function(word) {
          var token = word.toLowerCase();
          if (keepMap.hasOwnProperty(token)) {
            return restoreCase(word, token);
          }
          if (replaceMap.hasOwnProperty(token)) {
            return restoreCase(word, replaceMap[token]);
          }
          return sanitizeWord(token, word, rules);
        };
      }
      function checkWord(replaceMap, keepMap, rules, bool) {
        return function(word) {
          var token = word.toLowerCase();
          if (keepMap.hasOwnProperty(token)) return true;
          if (replaceMap.hasOwnProperty(token)) return false;
          return sanitizeWord(token, token, rules) === token;
        };
      }
      function pluralize2(word, count, inclusive) {
        var pluralized = count === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
        return (inclusive ? count + " " : "") + pluralized;
      }
      pluralize2.plural = replaceWord(
        irregularSingles,
        irregularPlurals,
        pluralRules
      );
      pluralize2.isPlural = checkWord(
        irregularSingles,
        irregularPlurals,
        pluralRules
      );
      pluralize2.singular = replaceWord(
        irregularPlurals,
        irregularSingles,
        singularRules
      );
      pluralize2.isSingular = checkWord(
        irregularPlurals,
        irregularSingles,
        singularRules
      );
      pluralize2.addPluralRule = function(rule, replacement) {
        pluralRules.push([sanitizeRule(rule), replacement]);
      };
      pluralize2.addSingularRule = function(rule, replacement) {
        singularRules.push([sanitizeRule(rule), replacement]);
      };
      pluralize2.addUncountableRule = function(word) {
        if (typeof word === "string") {
          uncountables[word.toLowerCase()] = true;
          return;
        }
        pluralize2.addPluralRule(word, "$0");
        pluralize2.addSingularRule(word, "$0");
      };
      pluralize2.addIrregularRule = function(single, plural) {
        plural = plural.toLowerCase();
        single = single.toLowerCase();
        irregularSingles[single] = plural;
        irregularPlurals[plural] = single;
      };
      [
        // Pronouns.
        ["I", "we"],
        ["me", "us"],
        ["he", "they"],
        ["she", "they"],
        ["them", "them"],
        ["myself", "ourselves"],
        ["yourself", "yourselves"],
        ["itself", "themselves"],
        ["herself", "themselves"],
        ["himself", "themselves"],
        ["themself", "themselves"],
        ["is", "are"],
        ["was", "were"],
        ["has", "have"],
        ["this", "these"],
        ["that", "those"],
        // Words ending in with a consonant and `o`.
        ["echo", "echoes"],
        ["dingo", "dingoes"],
        ["volcano", "volcanoes"],
        ["tornado", "tornadoes"],
        ["torpedo", "torpedoes"],
        // Ends with `us`.
        ["genus", "genera"],
        ["viscus", "viscera"],
        // Ends with `ma`.
        ["stigma", "stigmata"],
        ["stoma", "stomata"],
        ["dogma", "dogmata"],
        ["lemma", "lemmata"],
        ["schema", "schemata"],
        ["anathema", "anathemata"],
        // Other irregular rules.
        ["ox", "oxen"],
        ["axe", "axes"],
        ["die", "dice"],
        ["yes", "yeses"],
        ["foot", "feet"],
        ["eave", "eaves"],
        ["goose", "geese"],
        ["tooth", "teeth"],
        ["quiz", "quizzes"],
        ["human", "humans"],
        ["proof", "proofs"],
        ["carve", "carves"],
        ["valve", "valves"],
        ["looey", "looies"],
        ["thief", "thieves"],
        ["groove", "grooves"],
        ["pickaxe", "pickaxes"],
        ["passerby", "passersby"]
      ].forEach(function(rule) {
        return pluralize2.addIrregularRule(rule[0], rule[1]);
      });
      [
        [/s?$/i, "s"],
        [/[^\u0000-\u007F]$/i, "$0"],
        [/([^aeiou]ese)$/i, "$1"],
        [/(ax|test)is$/i, "$1es"],
        [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
        [/(e[mn]u)s?$/i, "$1s"],
        [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
        [/(seraph|cherub)(?:im)?$/i, "$1im"],
        [/(her|at|gr)o$/i, "$1oes"],
        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
        [/sis$/i, "ses"],
        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
        [/([^aeiouy]|qu)y$/i, "$1ies"],
        [/([^ch][ieo][ln])ey$/i, "$1ies"],
        [/(x|ch|ss|sh|zz)$/i, "$1es"],
        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
        [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
        [/(pe)(?:rson|ople)$/i, "$1ople"],
        [/(child)(?:ren)?$/i, "$1ren"],
        [/eaux$/i, "$0"],
        [/m[ae]n$/i, "men"],
        ["thou", "you"]
      ].forEach(function(rule) {
        return pluralize2.addPluralRule(rule[0], rule[1]);
      });
      [
        [/s$/i, ""],
        [/(ss)$/i, "$1"],
        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
        [/ies$/i, "y"],
        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
        [/\b(mon|smil)ies$/i, "$1ey"],
        [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
        [/(seraph|cherub)im$/i, "$1"],
        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
        [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
        [/(test)(?:is|es)$/i, "$1is"],
        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
        [/(alumn|alg|vertebr)ae$/i, "$1a"],
        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
        [/(matr|append)ices$/i, "$1ix"],
        [/(pe)(rson|ople)$/i, "$1rson"],
        [/(child)ren$/i, "$1"],
        [/(eau)x?$/i, "$1"],
        [/men$/i, "man"]
      ].forEach(function(rule) {
        return pluralize2.addSingularRule(rule[0], rule[1]);
      });
      [
        // Singular words with no plurals.
        "adulthood",
        "advice",
        "agenda",
        "aid",
        "aircraft",
        "alcohol",
        "ammo",
        "analytics",
        "anime",
        "athletics",
        "audio",
        "bison",
        "blood",
        "bream",
        "buffalo",
        "butter",
        "carp",
        "cash",
        "chassis",
        "chess",
        "clothing",
        "cod",
        "commerce",
        "cooperation",
        "corps",
        "debris",
        "diabetes",
        "digestion",
        "elk",
        "energy",
        "equipment",
        "excretion",
        "expertise",
        "firmware",
        "flounder",
        "fun",
        "gallows",
        "garbage",
        "graffiti",
        "hardware",
        "headquarters",
        "health",
        "herpes",
        "highjinks",
        "homework",
        "housework",
        "information",
        "jeans",
        "justice",
        "kudos",
        "labour",
        "literature",
        "machinery",
        "mackerel",
        "mail",
        "media",
        "mews",
        "moose",
        "music",
        "mud",
        "manga",
        "news",
        "only",
        "personnel",
        "pike",
        "plankton",
        "pliers",
        "police",
        "pollution",
        "premises",
        "rain",
        "research",
        "rice",
        "salmon",
        "scissors",
        "series",
        "sewage",
        "shambles",
        "shrimp",
        "software",
        "species",
        "staff",
        "swine",
        "tennis",
        "traffic",
        "transportation",
        "trout",
        "tuna",
        "wealth",
        "welfare",
        "whiting",
        "wildebeest",
        "wildlife",
        "you",
        /pok[eé]mon$/i,
        // Regexes.
        /[^aeiou]ese$/i,
        // "chinese", "japanese"
        /deer$/i,
        // "deer", "reindeer"
        /fish$/i,
        // "fish", "blowfish", "angelfish"
        /measles$/i,
        /o[iu]s$/i,
        // "carnivorous"
        /pox$/i,
        // "chickpox", "smallpox"
        /sheep$/i
      ].forEach(pluralize2.addUncountableRule);
      return pluralize2;
    });
  }
});

// node_modules/@rmp135/sql-ts/dist/TableTasks.js
async function getAllTables2(db2, config3) {
  const adapter2 = buildAdapter(db2.client.dialect);
  const allTables = (await adapter2.getAllTables(db2, config3.schemas)).filter((table) => config3.tables.length === 0 || config3.tables.includes(`${table.schema}.${table.name}`)).filter((table) => !config3.excludedTables.includes(`${table.schema}.${table.name}`)).sort((a, b) => a.name.localeCompare(b.name));
  return await Promise.all(allTables.map(async (table) => ({
    columns: await getColumnsForTable(db2, table, config3),
    interfaceName: generateInterfaceName(table.name, config3),
    name: table.name,
    schema: generateSchemaName(table.schema),
    additionalProperties: getAdditionalProperties(table.name, table.schema, config3),
    extends: getExtends(table.name, table.schema, config3),
    comment: table.comment
  })));
}
function getAdditionalProperties(tableName, schemaName, config3) {
  const fullName = `${schemaName}.${tableName}`;
  return config3.additionalProperties[fullName] ?? [];
}
function getExtends(tableName, schemaName, config3) {
  const fullName = `${schemaName}.${tableName}`;
  if (config3.extends === void 0)
    return "";
  return config3.extends[fullName];
}
function generateInterfaceName(name28, config3) {
  name28 = name28.replace(/ /g, "_");
  name28 = convertCase(name28, config3.tableNameCasing);
  if (config3.singularTableNames) {
    name28 = import_pluralize.default.singular(name28);
  }
  return config3.interfaceNameFormat.replace("${table}", name28);
}
var import_pluralize;
var init_TableTasks = __esm({
  "node_modules/@rmp135/sql-ts/dist/TableTasks.js"() {
    "use strict";
    init_AdapterFactory();
    init_ColumnTasks();
    init_SharedTasks();
    init_SchemaTasks();
    import_pluralize = __toESM(require_pluralize(), 1);
  }
});

// node_modules/handlebars/dist/cjs/handlebars/utils.js
var require_utils12 = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/utils.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.extend = extend4;
    exports2.indexOf = indexOf;
    exports2.escapeExpression = escapeExpression;
    exports2.isEmpty = isEmpty;
    exports2.createFrame = createFrame;
    exports2.blockParams = blockParams;
    exports2.appendContextPath = appendContextPath;
    var escape2 = {
      "&": "&amp;",
      "<": "&lt;",
      ">": "&gt;",
      '"': "&quot;",
      "'": "&#x27;",
      "`": "&#x60;",
      "=": "&#x3D;"
    };
    var badChars = /[&<>"'`=]/g;
    var possible = /[&<>"'`=]/;
    function escapeChar(chr) {
      return escape2[chr];
    }
    function extend4(obj) {
      for (var i = 1; i < arguments.length; i++) {
        for (var key in arguments[i]) {
          if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
            obj[key] = arguments[i][key];
          }
        }
      }
      return obj;
    }
    var toString4 = Object.prototype.toString;
    exports2.toString = toString4;
    var isFunction4 = function isFunction5(value) {
      return typeof value === "function";
    };
    if (isFunction4(/x/)) {
      exports2.isFunction = isFunction4 = function(value) {
        return typeof value === "function" && toString4.call(value) === "[object Function]";
      };
    }
    exports2.isFunction = isFunction4;
    var isArray3 = Array.isArray || function(value) {
      return value && typeof value === "object" ? toString4.call(value) === "[object Array]" : false;
    };
    exports2.isArray = isArray3;
    function indexOf(array4, value) {
      for (var i = 0, len = array4.length; i < len; i++) {
        if (array4[i] === value) {
          return i;
        }
      }
      return -1;
    }
    function escapeExpression(string5) {
      if (typeof string5 !== "string") {
        if (string5 && string5.toHTML) {
          return string5.toHTML();
        } else if (string5 == null) {
          return "";
        } else if (!string5) {
          return string5 + "";
        }
        string5 = "" + string5;
      }
      if (!possible.test(string5)) {
        return string5;
      }
      return string5.replace(badChars, escapeChar);
    }
    function isEmpty(value) {
      if (!value && value !== 0) {
        return true;
      } else if (isArray3(value) && value.length === 0) {
        return true;
      } else {
        return false;
      }
    }
    function createFrame(object4) {
      var frame = extend4({}, object4);
      frame._parent = object4;
      return frame;
    }
    function blockParams(params, ids) {
      params.path = ids;
      return params;
    }
    function appendContextPath(contextPath, id) {
      return (contextPath ? contextPath + "." : "") + id;
    }
  }
});

// node_modules/handlebars/dist/cjs/handlebars/exception.js
var require_exception = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/exception.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    var errorProps = ["description", "fileName", "lineNumber", "endLineNumber", "message", "name", "number", "stack"];
    function Exception(message, node) {
      var loc = node && node.loc, line = void 0, endLineNumber = void 0, column = void 0, endColumn = void 0;
      if (loc) {
        line = loc.start.line;
        endLineNumber = loc.end.line;
        column = loc.start.column;
        endColumn = loc.end.column;
        message += " - " + line + ":" + column;
      }
      var tmp = Error.prototype.constructor.call(this, message);
      for (var idx = 0; idx < errorProps.length; idx++) {
        this[errorProps[idx]] = tmp[errorProps[idx]];
      }
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, Exception);
      }
      try {
        if (loc) {
          this.lineNumber = line;
          this.endLineNumber = endLineNumber;
          if (Object.defineProperty) {
            Object.defineProperty(this, "column", {
              value: column,
              enumerable: true
            });
            Object.defineProperty(this, "endColumn", {
              value: endColumn,
              enumerable: true
            });
          } else {
            this.column = column;
            this.endColumn = endColumn;
          }
        }
      } catch (nop) {
      }
    }
    Exception.prototype = new Error();
    exports2["default"] = Exception;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/helpers/block-helper-missing.js
var require_block_helper_missing = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/helpers/block-helper-missing.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    var _utils = require_utils12();
    exports2["default"] = function(instance) {
      instance.registerHelper("blockHelperMissing", function(context2, options) {
        var inverse = options.inverse, fn = options.fn;
        if (context2 === true) {
          return fn(this);
        } else if (context2 === false || context2 == null) {
          return inverse(this);
        } else if (_utils.isArray(context2)) {
          if (context2.length > 0) {
            if (options.ids) {
              options.ids = [options.name];
            }
            return instance.helpers.each(context2, options);
          } else {
            return inverse(this);
          }
        } else {
          if (options.data && options.ids) {
            var data = _utils.createFrame(options.data);
            data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);
            options = { data };
          }
          return fn(context2, options);
        }
      });
    };
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/helpers/each.js
var require_each2 = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/helpers/each.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _utils = require_utils12();
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    exports2["default"] = function(instance) {
      instance.registerHelper("each", function(context2, options) {
        if (!options) {
          throw new _exception2["default"]("Must pass iterator to #each");
        }
        var fn = options.fn, inverse = options.inverse, i = 0, ret = "", data = void 0, contextPath = void 0;
        if (options.data && options.ids) {
          contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + ".";
        }
        if (_utils.isFunction(context2)) {
          context2 = context2.call(this);
        }
        if (options.data) {
          data = _utils.createFrame(options.data);
        }
        function execIteration(field, index, last) {
          if (data) {
            data.key = field;
            data.index = index;
            data.first = index === 0;
            data.last = !!last;
            if (contextPath) {
              data.contextPath = contextPath + field;
            }
          }
          ret = ret + fn(context2[field], {
            data,
            blockParams: _utils.blockParams([context2[field], field], [contextPath + field, null])
          });
        }
        if (context2 && typeof context2 === "object") {
          if (_utils.isArray(context2)) {
            for (var j = context2.length; i < j; i++) {
              if (i in context2) {
                execIteration(i, i, i === context2.length - 1);
              }
            }
          } else if (typeof Symbol === "function" && context2[Symbol.iterator]) {
            var newContext = [];
            var iterator2 = context2[Symbol.iterator]();
            for (var it = iterator2.next(); !it.done; it = iterator2.next()) {
              newContext.push(it.value);
            }
            context2 = newContext;
            for (var j = context2.length; i < j; i++) {
              execIteration(i, i, i === context2.length - 1);
            }
          } else {
            (function() {
              var priorKey = void 0;
              Object.keys(context2).forEach(function(key) {
                if (priorKey !== void 0) {
                  execIteration(priorKey, i - 1);
                }
                priorKey = key;
                i++;
              });
              if (priorKey !== void 0) {
                execIteration(priorKey, i - 1, true);
              }
            })();
          }
        }
        if (i === 0) {
          ret = inverse(this);
        }
        return ret;
      });
    };
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/helpers/helper-missing.js
var require_helper_missing = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/helpers/helper-missing.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    exports2["default"] = function(instance) {
      instance.registerHelper("helperMissing", function() {
        if (arguments.length === 1) {
          return void 0;
        } else {
          throw new _exception2["default"]('Missing helper: "' + arguments[arguments.length - 1].name + '"');
        }
      });
    };
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/helpers/if.js
var require_if = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/helpers/if.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _utils = require_utils12();
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    exports2["default"] = function(instance) {
      instance.registerHelper("if", function(conditional, options) {
        if (arguments.length != 2) {
          throw new _exception2["default"]("#if requires exactly one argument");
        }
        if (_utils.isFunction(conditional)) {
          conditional = conditional.call(this);
        }
        if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) {
          return options.inverse(this);
        } else {
          return options.fn(this);
        }
      });
      instance.registerHelper("unless", function(conditional, options) {
        if (arguments.length != 2) {
          throw new _exception2["default"]("#unless requires exactly one argument");
        }
        return instance.helpers["if"].call(this, conditional, {
          fn: options.inverse,
          inverse: options.fn,
          hash: options.hash
        });
      });
    };
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/helpers/log.js
var require_log = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/helpers/log.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = function(instance) {
      instance.registerHelper("log", function() {
        var args = [void 0], options = arguments[arguments.length - 1];
        for (var i = 0; i < arguments.length - 1; i++) {
          args.push(arguments[i]);
        }
        var level = 1;
        if (options.hash.level != null) {
          level = options.hash.level;
        } else if (options.data && options.data.level != null) {
          level = options.data.level;
        }
        args[0] = level;
        instance.log.apply(instance, args);
      });
    };
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/helpers/lookup.js
var require_lookup = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/helpers/lookup.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = function(instance) {
      instance.registerHelper("lookup", function(obj, field, options) {
        if (!obj) {
          return obj;
        }
        return options.lookupProperty(obj, field);
      });
    };
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/helpers/with.js
var require_with = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/helpers/with.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _utils = require_utils12();
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    exports2["default"] = function(instance) {
      instance.registerHelper("with", function(context2, options) {
        if (arguments.length != 2) {
          throw new _exception2["default"]("#with requires exactly one argument");
        }
        if (_utils.isFunction(context2)) {
          context2 = context2.call(this);
        }
        var fn = options.fn;
        if (!_utils.isEmpty(context2)) {
          var data = options.data;
          if (options.data && options.ids) {
            data = _utils.createFrame(options.data);
            data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]);
          }
          return fn(context2, {
            data,
            blockParams: _utils.blockParams([context2], [data && data.contextPath])
          });
        } else {
          return options.inverse(this);
        }
      });
    };
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/helpers.js
var require_helpers3 = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/helpers.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.registerDefaultHelpers = registerDefaultHelpers;
    exports2.moveHelperToHooks = moveHelperToHooks;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _helpersBlockHelperMissing = require_block_helper_missing();
    var _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing);
    var _helpersEach = require_each2();
    var _helpersEach2 = _interopRequireDefault(_helpersEach);
    var _helpersHelperMissing = require_helper_missing();
    var _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing);
    var _helpersIf = require_if();
    var _helpersIf2 = _interopRequireDefault(_helpersIf);
    var _helpersLog = require_log();
    var _helpersLog2 = _interopRequireDefault(_helpersLog);
    var _helpersLookup = require_lookup();
    var _helpersLookup2 = _interopRequireDefault(_helpersLookup);
    var _helpersWith = require_with();
    var _helpersWith2 = _interopRequireDefault(_helpersWith);
    function registerDefaultHelpers(instance) {
      _helpersBlockHelperMissing2["default"](instance);
      _helpersEach2["default"](instance);
      _helpersHelperMissing2["default"](instance);
      _helpersIf2["default"](instance);
      _helpersLog2["default"](instance);
      _helpersLookup2["default"](instance);
      _helpersWith2["default"](instance);
    }
    function moveHelperToHooks(instance, helperName, keepHelper) {
      if (instance.helpers[helperName]) {
        instance.hooks[helperName] = instance.helpers[helperName];
        if (!keepHelper) {
          instance.helpers[helperName] = void 0;
        }
      }
    }
  }
});

// node_modules/handlebars/dist/cjs/handlebars/decorators/inline.js
var require_inline = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/decorators/inline.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    var _utils = require_utils12();
    exports2["default"] = function(instance) {
      instance.registerDecorator("inline", function(fn, props, container, options) {
        var ret = fn;
        if (!props.partials) {
          props.partials = {};
          ret = function(context2, options2) {
            var original = container.partials;
            container.partials = _utils.extend({}, original, props.partials);
            var ret2 = fn(context2, options2);
            container.partials = original;
            return ret2;
          };
        }
        props.partials[options.args[0]] = options.fn;
        return ret;
      });
    };
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/decorators.js
var require_decorators = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/decorators.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.registerDefaultDecorators = registerDefaultDecorators;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _decoratorsInline = require_inline();
    var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline);
    function registerDefaultDecorators(instance) {
      _decoratorsInline2["default"](instance);
    }
  }
});

// node_modules/handlebars/dist/cjs/handlebars/logger.js
var require_logger2 = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/logger.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    var _utils = require_utils12();
    var logger3 = {
      methodMap: ["debug", "info", "warn", "error"],
      level: "info",
      // Maps a given level value to the `methodMap` indexes above.
      lookupLevel: function lookupLevel(level) {
        if (typeof level === "string") {
          var levelMap = _utils.indexOf(logger3.methodMap, level.toLowerCase());
          if (levelMap >= 0) {
            level = levelMap;
          } else {
            level = parseInt(level, 10);
          }
        }
        return level;
      },
      // Can be overridden in the host environment
      log: function log(level) {
        level = logger3.lookupLevel(level);
        if (typeof console !== "undefined" && logger3.lookupLevel(logger3.level) <= level) {
          var method = logger3.methodMap[level];
          if (!console[method]) {
            method = "log";
          }
          for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            message[_key - 1] = arguments[_key];
          }
          console[method].apply(console, message);
        }
      }
    };
    exports2["default"] = logger3;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/internal/proto-access.js
var require_proto_access = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/internal/proto-access.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.createProtoAccessControl = createProtoAccessControl;
    exports2.resultIsAllowed = resultIsAllowed;
    exports2.resetLoggedProperties = resetLoggedProperties;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _utils = require_utils12();
    var _logger = require_logger2();
    var _logger2 = _interopRequireDefault(_logger);
    var loggedProperties = /* @__PURE__ */ Object.create(null);
    function createProtoAccessControl(runtimeOptions) {
      var propertyWhiteList = /* @__PURE__ */ Object.create(null);
      propertyWhiteList["__proto__"] = false;
      _utils.extend(propertyWhiteList, runtimeOptions.allowedProtoProperties);
      var methodWhiteList = /* @__PURE__ */ Object.create(null);
      methodWhiteList["constructor"] = false;
      methodWhiteList["__defineGetter__"] = false;
      methodWhiteList["__defineSetter__"] = false;
      methodWhiteList["__lookupGetter__"] = false;
      methodWhiteList["__lookupSetter__"] = false;
      _utils.extend(methodWhiteList, runtimeOptions.allowedProtoMethods);
      return {
        properties: {
          whitelist: propertyWhiteList,
          defaultValue: runtimeOptions.allowProtoPropertiesByDefault
        },
        methods: {
          whitelist: methodWhiteList,
          defaultValue: runtimeOptions.allowProtoMethodsByDefault
        }
      };
    }
    function resultIsAllowed(result, protoAccessControl, propertyName) {
      if (typeof result === "function") {
        return checkWhiteList(protoAccessControl.methods, propertyName);
      } else {
        return checkWhiteList(protoAccessControl.properties, propertyName);
      }
    }
    function checkWhiteList(protoAccessControlForType, propertyName) {
      if (protoAccessControlForType.whitelist[propertyName] !== void 0) {
        return protoAccessControlForType.whitelist[propertyName] === true;
      }
      if (protoAccessControlForType.defaultValue !== void 0) {
        return protoAccessControlForType.defaultValue;
      }
      logUnexpecedPropertyAccessOnce(propertyName);
      return false;
    }
    function logUnexpecedPropertyAccessOnce(propertyName) {
      if (loggedProperties[propertyName] !== true) {
        loggedProperties[propertyName] = true;
        _logger2["default"].log("error", 'Handlebars: Access has been denied to resolve the property "' + propertyName + '" because it is not an "own property" of its parent.\nYou can add a runtime option to disable the check or this warning:\nSee https://handlebarsjs.com/api-reference/runtime-options.html#options-to-control-prototype-access for details');
      }
    }
    function resetLoggedProperties() {
      Object.keys(loggedProperties).forEach(function(propertyName) {
        delete loggedProperties[propertyName];
      });
    }
  }
});

// node_modules/handlebars/dist/cjs/handlebars/base.js
var require_base2 = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/base.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.HandlebarsEnvironment = HandlebarsEnvironment;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _utils = require_utils12();
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    var _helpers = require_helpers3();
    var _decorators = require_decorators();
    var _logger = require_logger2();
    var _logger2 = _interopRequireDefault(_logger);
    var _internalProtoAccess = require_proto_access();
    var VERSION16 = "4.7.9";
    exports2.VERSION = VERSION16;
    var COMPILER_REVISION = 8;
    exports2.COMPILER_REVISION = COMPILER_REVISION;
    var LAST_COMPATIBLE_COMPILER_REVISION = 7;
    exports2.LAST_COMPATIBLE_COMPILER_REVISION = LAST_COMPATIBLE_COMPILER_REVISION;
    var REVISION_CHANGES = {
      1: "<= 1.0.rc.2",
      // 1.0.rc.2 is actually rev2 but doesn't report it
      2: "== 1.0.0-rc.3",
      3: "== 1.0.0-rc.4",
      4: "== 1.x.x",
      5: "== 2.0.0-alpha.x",
      6: ">= 2.0.0-beta.1",
      7: ">= 4.0.0 <4.3.0",
      8: ">= 4.3.0"
    };
    exports2.REVISION_CHANGES = REVISION_CHANGES;
    var objectType2 = "[object Object]";
    function HandlebarsEnvironment(helpers, partials, decorators) {
      this.helpers = helpers || {};
      this.partials = partials || {};
      this.decorators = decorators || {};
      _helpers.registerDefaultHelpers(this);
      _decorators.registerDefaultDecorators(this);
    }
    HandlebarsEnvironment.prototype = {
      constructor: HandlebarsEnvironment,
      logger: _logger2["default"],
      log: _logger2["default"].log,
      registerHelper: function registerHelper(name28, fn) {
        if (_utils.toString.call(name28) === objectType2) {
          if (fn) {
            throw new _exception2["default"]("Arg not supported with multiple helpers");
          }
          _utils.extend(this.helpers, name28);
        } else {
          this.helpers[name28] = fn;
        }
      },
      unregisterHelper: function unregisterHelper(name28) {
        delete this.helpers[name28];
      },
      registerPartial: function registerPartial(name28, partial3) {
        if (_utils.toString.call(name28) === objectType2) {
          _utils.extend(this.partials, name28);
        } else {
          if (typeof partial3 === "undefined") {
            throw new _exception2["default"]('Attempting to register a partial called "' + name28 + '" as undefined');
          }
          this.partials[name28] = partial3;
        }
      },
      unregisterPartial: function unregisterPartial(name28) {
        delete this.partials[name28];
      },
      registerDecorator: function registerDecorator(name28, fn) {
        if (_utils.toString.call(name28) === objectType2) {
          if (fn) {
            throw new _exception2["default"]("Arg not supported with multiple decorators");
          }
          _utils.extend(this.decorators, name28);
        } else {
          this.decorators[name28] = fn;
        }
      },
      unregisterDecorator: function unregisterDecorator(name28) {
        delete this.decorators[name28];
      },
      /**
       * Reset the memory of illegal property accesses that have already been logged.
       * @deprecated should only be used in handlebars test-cases
       */
      resetLoggedPropertyAccesses: function resetLoggedPropertyAccesses() {
        _internalProtoAccess.resetLoggedProperties();
      }
    };
    var log = _logger2["default"].log;
    exports2.log = log;
    exports2.createFrame = _utils.createFrame;
    exports2.logger = _logger2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/safe-string.js
var require_safe_string = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/safe-string.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function SafeString(string5) {
      this.string = string5;
    }
    SafeString.prototype.toString = SafeString.prototype.toHTML = function() {
      return "" + this.string;
    };
    exports2["default"] = SafeString;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/internal/wrapHelper.js
var require_wrapHelper = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/internal/wrapHelper.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.wrapHelper = wrapHelper;
    function wrapHelper(helper, transformOptionsFn) {
      if (typeof helper !== "function") {
        return helper;
      }
      var wrapper = function wrapper2() {
        var options = arguments[arguments.length - 1];
        arguments[arguments.length - 1] = transformOptionsFn(options);
        return helper.apply(this, arguments);
      };
      return wrapper;
    }
  }
});

// node_modules/handlebars/dist/cjs/handlebars/runtime.js
var require_runtime = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/runtime.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.checkRevision = checkRevision;
    exports2.template = template;
    exports2.wrapProgram = wrapProgram;
    exports2.resolvePartial = resolvePartial;
    exports2.invokePartial = invokePartial;
    exports2.noop = noop4;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
          }
        }
        newObj["default"] = obj;
        return newObj;
      }
    }
    var _utils = require_utils12();
    var Utils = _interopRequireWildcard(_utils);
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    var _base = require_base2();
    var _helpers = require_helpers3();
    var _internalWrapHelper = require_wrapHelper();
    var _internalProtoAccess = require_proto_access();
    function checkRevision(compilerInfo) {
      var compilerRevision = compilerInfo && compilerInfo[0] || 1, currentRevision = _base.COMPILER_REVISION;
      if (compilerRevision >= _base.LAST_COMPATIBLE_COMPILER_REVISION && compilerRevision <= _base.COMPILER_REVISION) {
        return;
      }
      if (compilerRevision < _base.LAST_COMPATIBLE_COMPILER_REVISION) {
        var runtimeVersions = _base.REVISION_CHANGES[currentRevision], compilerVersions = _base.REVISION_CHANGES[compilerRevision];
        throw new _exception2["default"]("Template was precompiled with an older version of Handlebars than the current runtime. Please update your precompiler to a newer version (" + runtimeVersions + ") or downgrade your runtime to an older version (" + compilerVersions + ").");
      } else {
        throw new _exception2["default"]("Template was precompiled with a newer version of Handlebars than the current runtime. Please update your runtime to a newer version (" + compilerInfo[1] + ").");
      }
    }
    function template(templateSpec, env2) {
      if (!env2) {
        throw new _exception2["default"]("No environment passed to template");
      }
      if (!templateSpec || !templateSpec.main) {
        throw new _exception2["default"]("Unknown template object: " + typeof templateSpec);
      }
      templateSpec.main.decorator = templateSpec.main_d;
      env2.VM.checkRevision(templateSpec.compiler);
      var templateWasPrecompiledWithCompilerV7 = templateSpec.compiler && templateSpec.compiler[0] === 7;
      function invokePartialWrapper(partial3, context2, options) {
        if (options.hash) {
          context2 = Utils.extend({}, context2, options.hash);
          if (options.ids) {
            options.ids[0] = true;
          }
        }
        partial3 = env2.VM.resolvePartial.call(this, partial3, context2, options);
        options.hooks = this.hooks;
        options.protoAccessControl = this.protoAccessControl;
        var result = env2.VM.invokePartial.call(this, partial3, context2, options);
        if (result == null && env2.compile) {
          options.partials[options.name] = env2.compile(partial3, templateSpec.compilerOptions, env2);
          result = options.partials[options.name](context2, options);
        }
        if (result != null) {
          if (options.indent) {
            var lines = result.split("\n");
            for (var i = 0, l = lines.length; i < l; i++) {
              if (!lines[i] && i + 1 === l) {
                break;
              }
              lines[i] = options.indent + lines[i];
            }
            result = lines.join("\n");
          }
          return result;
        } else {
          throw new _exception2["default"]("The partial " + options.name + " could not be compiled when running in runtime-only mode");
        }
      }
      var container = {
        strict: function strict(obj, name28, loc) {
          if (!obj || !(name28 in obj)) {
            throw new _exception2["default"]('"' + name28 + '" not defined in ' + obj, {
              loc
            });
          }
          return container.lookupProperty(obj, name28);
        },
        lookupProperty: function lookupProperty(parent, propertyName) {
          var result = parent[propertyName];
          if (result == null) {
            return result;
          }
          if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
            return result;
          }
          if (_internalProtoAccess.resultIsAllowed(result, container.protoAccessControl, propertyName)) {
            return result;
          }
          return void 0;
        },
        lookup: function lookup(depths, name28) {
          var len = depths.length;
          for (var i = 0; i < len; i++) {
            var result = depths[i] && container.lookupProperty(depths[i], name28);
            if (result != null) {
              return result;
            }
          }
        },
        lambda: function lambda(current, context2) {
          return typeof current === "function" ? current.call(context2) : current;
        },
        escapeExpression: Utils.escapeExpression,
        invokePartial: invokePartialWrapper,
        fn: function fn(i) {
          var ret2 = templateSpec[i];
          ret2.decorator = templateSpec[i + "_d"];
          return ret2;
        },
        programs: [],
        program: function program(i, data, declaredBlockParams, blockParams, depths) {
          var programWrapper = this.programs[i], fn = this.fn(i);
          if (data || depths || blockParams || declaredBlockParams) {
            programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
          } else if (!programWrapper) {
            programWrapper = this.programs[i] = wrapProgram(this, i, fn);
          }
          return programWrapper;
        },
        data: function data(value, depth) {
          while (value && depth--) {
            value = value._parent;
          }
          return value;
        },
        mergeIfNeeded: function mergeIfNeeded(param, common) {
          var obj = param || common;
          if (param && common && param !== common) {
            obj = Utils.extend({}, common, param);
          }
          return obj;
        },
        // An empty object to use as replacement for null-contexts
        nullContext: Object.seal({}),
        noop: env2.VM.noop,
        compilerInfo: templateSpec.compiler
      };
      function ret(context2) {
        var options = arguments.length <= 1 || arguments[1] === void 0 ? {} : arguments[1];
        var data = options.data;
        ret._setup(options);
        if (!options.partial && templateSpec.useData) {
          data = initData(context2, data);
        }
        var depths = void 0, blockParams = templateSpec.useBlockParams ? [] : void 0;
        if (templateSpec.useDepths) {
          if (options.depths) {
            depths = context2 != options.depths[0] ? [context2].concat(options.depths) : options.depths;
          } else {
            depths = [context2];
          }
        }
        function main(context3) {
          return "" + templateSpec.main(container, context3, container.helpers, container.partials, data, blockParams, depths);
        }
        main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);
        return main(context2, options);
      }
      ret.isTop = true;
      ret._setup = function(options) {
        if (!options.partial) {
          var mergedHelpers = {};
          addHelpers(mergedHelpers, env2.helpers, container);
          addHelpers(mergedHelpers, options.helpers, container);
          container.helpers = mergedHelpers;
          if (templateSpec.usePartial) {
            container.partials = container.mergeIfNeeded(options.partials, env2.partials);
          }
          if (templateSpec.usePartial || templateSpec.useDecorators) {
            container.decorators = Utils.extend({}, env2.decorators, options.decorators);
          }
          container.hooks = {};
          container.protoAccessControl = _internalProtoAccess.createProtoAccessControl(options);
          var keepHelperInHelpers = options.allowCallsToHelperMissing || templateWasPrecompiledWithCompilerV7;
          _helpers.moveHelperToHooks(container, "helperMissing", keepHelperInHelpers);
          _helpers.moveHelperToHooks(container, "blockHelperMissing", keepHelperInHelpers);
        } else {
          container.protoAccessControl = options.protoAccessControl;
          container.helpers = options.helpers;
          container.partials = options.partials;
          container.decorators = options.decorators;
          container.hooks = options.hooks;
        }
      };
      ret._child = function(i, data, blockParams, depths) {
        if (templateSpec.useBlockParams && !blockParams) {
          throw new _exception2["default"]("must pass block params");
        }
        if (templateSpec.useDepths && !depths) {
          throw new _exception2["default"]("must pass parent depths");
        }
        return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
      };
      return ret;
    }
    function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
      function prog(context2) {
        var options = arguments.length <= 1 || arguments[1] === void 0 ? {} : arguments[1];
        var currentDepths = depths;
        if (depths && context2 != depths[0] && !(context2 === container.nullContext && depths[0] === null)) {
          currentDepths = [context2].concat(depths);
        }
        return fn(container, context2, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
      }
      prog = executeDecorators(fn, prog, container, depths, data, blockParams);
      prog.program = i;
      prog.depth = depths ? depths.length : 0;
      prog.blockParams = declaredBlockParams || 0;
      return prog;
    }
    function resolvePartial(partial3, context2, options) {
      if (!partial3) {
        if (options.name === "@partial-block") {
          partial3 = lookupOwnProperty(options.data, "partial-block");
        } else {
          partial3 = lookupOwnProperty(options.partials, options.name);
        }
      } else if (!partial3.call && !options.name) {
        options.name = partial3;
        partial3 = lookupOwnProperty(options.partials, partial3);
      }
      return partial3;
    }
    function invokePartial(partial3, context2, options) {
      var currentPartialBlock = lookupOwnProperty(options.data, "partial-block");
      options.partial = true;
      if (options.ids) {
        options.data.contextPath = options.ids[0] || options.data.contextPath;
      }
      var partialBlock = void 0;
      if (options.fn && options.fn !== noop4) {
        (function() {
          options.data = _base.createFrame(options.data);
          var fn = options.fn;
          partialBlock = options.data["partial-block"] = function partialBlockWrapper(context3) {
            var options2 = arguments.length <= 1 || arguments[1] === void 0 ? {} : arguments[1];
            options2.data = _base.createFrame(options2.data);
            options2.data["partial-block"] = currentPartialBlock;
            return fn(context3, options2);
          };
          if (fn.partials) {
            options.partials = Utils.extend({}, options.partials, fn.partials);
          }
        })();
      }
      if (partial3 === void 0 && partialBlock) {
        partial3 = partialBlock;
      }
      if (partial3 === void 0) {
        throw new _exception2["default"]("The partial " + options.name + " could not be found");
      } else if (partial3 instanceof Function) {
        return partial3(context2, options);
      }
    }
    function noop4() {
      return "";
    }
    function lookupOwnProperty(obj, name28) {
      if (obj && Object.prototype.hasOwnProperty.call(obj, name28)) {
        return obj[name28];
      }
    }
    function initData(context2, data) {
      if (!data || !("root" in data)) {
        data = data ? _base.createFrame(data) : {};
        data.root = context2;
      }
      return data;
    }
    function executeDecorators(fn, prog, container, depths, data, blockParams) {
      if (fn.decorator) {
        var props = {};
        prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);
        Utils.extend(prog, props);
      }
      return prog;
    }
    function addHelpers(mergedHelpers, helpers, container) {
      if (!helpers) return;
      Object.keys(helpers).forEach(function(helperName) {
        var helper = helpers[helperName];
        mergedHelpers[helperName] = passLookupPropertyOption(helper, container);
      });
    }
    function passLookupPropertyOption(helper, container) {
      var lookupProperty = container.lookupProperty;
      return _internalWrapHelper.wrapHelper(helper, function(options) {
        options.lookupProperty = lookupProperty;
        return options;
      });
    }
  }
});

// node_modules/handlebars/dist/cjs/handlebars/no-conflict.js
var require_no_conflict = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/no-conflict.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    exports2["default"] = function(Handlebars2) {
      (function() {
        if (typeof globalThis === "object") return;
        Object.prototype.__defineGetter__("__magic__", function() {
          return this;
        });
        __magic__.globalThis = __magic__;
        delete Object.prototype.__magic__;
      })();
      var $Handlebars = globalThis.Handlebars;
      Handlebars2.noConflict = function() {
        if (globalThis.Handlebars === Handlebars2) {
          globalThis.Handlebars = $Handlebars;
        }
        return Handlebars2;
      };
    };
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars.runtime.js
var require_handlebars_runtime = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars.runtime.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
          }
        }
        newObj["default"] = obj;
        return newObj;
      }
    }
    var _handlebarsBase = require_base2();
    var base = _interopRequireWildcard(_handlebarsBase);
    var _handlebarsSafeString = require_safe_string();
    var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString);
    var _handlebarsException = require_exception();
    var _handlebarsException2 = _interopRequireDefault(_handlebarsException);
    var _handlebarsUtils = require_utils12();
    var Utils = _interopRequireWildcard(_handlebarsUtils);
    var _handlebarsRuntime = require_runtime();
    var runtime = _interopRequireWildcard(_handlebarsRuntime);
    var _handlebarsNoConflict = require_no_conflict();
    var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict);
    function create() {
      var hb = new base.HandlebarsEnvironment();
      Utils.extend(hb, base);
      hb.SafeString = _handlebarsSafeString2["default"];
      hb.Exception = _handlebarsException2["default"];
      hb.Utils = Utils;
      hb.escapeExpression = Utils.escapeExpression;
      hb.VM = runtime;
      hb.template = function(spec) {
        return runtime.template(spec, hb);
      };
      return hb;
    }
    var inst = create();
    inst.create = create;
    _handlebarsNoConflict2["default"](inst);
    inst["default"] = inst;
    exports2["default"] = inst;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/ast.js
var require_ast = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/ast.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    var AST = {
      // Public API used to evaluate derived attributes regarding AST nodes
      helpers: {
        // a mustache is definitely a helper if:
        // * it is an eligible helper, and
        // * it has at least one parameter or hash segment
        helperExpression: function helperExpression(node) {
          return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
        },
        scopedId: function scopedId(path33) {
          return /^\.|this\b/.test(path33.original);
        },
        // an ID is simple if it only has one part, and that part is not
        // `..` or `this`.
        simpleId: function simpleId(path33) {
          return path33.parts.length === 1 && !AST.helpers.scopedId(path33) && !path33.depth;
        }
      }
    };
    exports2["default"] = AST;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/parser.js
var require_parser3 = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/parser.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    var handlebars = (function() {
      var parser = {
        trace: function trace2() {
        },
        yy: {},
        symbols_: { "error": 2, "root": 3, "program": 4, "EOF": 5, "program_repetition0": 6, "statement": 7, "mustache": 8, "block": 9, "rawBlock": 10, "partial": 11, "partialBlock": 12, "content": 13, "COMMENT": 14, "CONTENT": 15, "openRawBlock": 16, "rawBlock_repetition0": 17, "END_RAW_BLOCK": 18, "OPEN_RAW_BLOCK": 19, "helperName": 20, "openRawBlock_repetition0": 21, "openRawBlock_option0": 22, "CLOSE_RAW_BLOCK": 23, "openBlock": 24, "block_option0": 25, "closeBlock": 26, "openInverse": 27, "block_option1": 28, "OPEN_BLOCK": 29, "openBlock_repetition0": 30, "openBlock_option0": 31, "openBlock_option1": 32, "CLOSE": 33, "OPEN_INVERSE": 34, "openInverse_repetition0": 35, "openInverse_option0": 36, "openInverse_option1": 37, "openInverseChain": 38, "OPEN_INVERSE_CHAIN": 39, "openInverseChain_repetition0": 40, "openInverseChain_option0": 41, "openInverseChain_option1": 42, "inverseAndProgram": 43, "INVERSE": 44, "inverseChain": 45, "inverseChain_option0": 46, "OPEN_ENDBLOCK": 47, "OPEN": 48, "mustache_repetition0": 49, "mustache_option0": 50, "OPEN_UNESCAPED": 51, "mustache_repetition1": 52, "mustache_option1": 53, "CLOSE_UNESCAPED": 54, "OPEN_PARTIAL": 55, "partialName": 56, "partial_repetition0": 57, "partial_option0": 58, "openPartialBlock": 59, "OPEN_PARTIAL_BLOCK": 60, "openPartialBlock_repetition0": 61, "openPartialBlock_option0": 62, "param": 63, "sexpr": 64, "OPEN_SEXPR": 65, "sexpr_repetition0": 66, "sexpr_option0": 67, "CLOSE_SEXPR": 68, "hash": 69, "hash_repetition_plus0": 70, "hashSegment": 71, "ID": 72, "EQUALS": 73, "blockParams": 74, "OPEN_BLOCK_PARAMS": 75, "blockParams_repetition_plus0": 76, "CLOSE_BLOCK_PARAMS": 77, "path": 78, "dataName": 79, "STRING": 80, "NUMBER": 81, "BOOLEAN": 82, "UNDEFINED": 83, "NULL": 84, "DATA": 85, "pathSegments": 86, "SEP": 87, "$accept": 0, "$end": 1 },
        terminals_: { 2: "error", 5: "EOF", 14: "COMMENT", 15: "CONTENT", 18: "END_RAW_BLOCK", 19: "OPEN_RAW_BLOCK", 23: "CLOSE_RAW_BLOCK", 29: "OPEN_BLOCK", 33: "CLOSE", 34: "OPEN_INVERSE", 39: "OPEN_INVERSE_CHAIN", 44: "INVERSE", 47: "OPEN_ENDBLOCK", 48: "OPEN", 51: "OPEN_UNESCAPED", 54: "CLOSE_UNESCAPED", 55: "OPEN_PARTIAL", 60: "OPEN_PARTIAL_BLOCK", 65: "OPEN_SEXPR", 68: "CLOSE_SEXPR", 72: "ID", 73: "EQUALS", 75: "OPEN_BLOCK_PARAMS", 77: "CLOSE_BLOCK_PARAMS", 80: "STRING", 81: "NUMBER", 82: "BOOLEAN", 83: "UNDEFINED", 84: "NULL", 85: "DATA", 87: "SEP" },
        productions_: [0, [3, 2], [4, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [13, 1], [10, 3], [16, 5], [9, 4], [9, 4], [24, 6], [27, 6], [38, 6], [43, 2], [45, 3], [45, 1], [26, 3], [8, 5], [8, 5], [11, 5], [12, 3], [59, 5], [63, 1], [63, 1], [64, 5], [69, 1], [71, 3], [74, 3], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [56, 1], [56, 1], [79, 2], [78, 1], [86, 3], [86, 1], [6, 0], [6, 2], [17, 0], [17, 2], [21, 0], [21, 2], [22, 0], [22, 1], [25, 0], [25, 1], [28, 0], [28, 1], [30, 0], [30, 2], [31, 0], [31, 1], [32, 0], [32, 1], [35, 0], [35, 2], [36, 0], [36, 1], [37, 0], [37, 1], [40, 0], [40, 2], [41, 0], [41, 1], [42, 0], [42, 1], [46, 0], [46, 1], [49, 0], [49, 2], [50, 0], [50, 1], [52, 0], [52, 2], [53, 0], [53, 1], [57, 0], [57, 2], [58, 0], [58, 1], [61, 0], [61, 2], [62, 0], [62, 1], [66, 0], [66, 2], [67, 0], [67, 1], [70, 1], [70, 2], [76, 1], [76, 2]],
        performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
          var $0 = $$.length - 1;
          switch (yystate) {
            case 1:
              return $$[$0 - 1];
              break;
            case 2:
              this.$ = yy.prepareProgram($$[$0]);
              break;
            case 3:
              this.$ = $$[$0];
              break;
            case 4:
              this.$ = $$[$0];
              break;
            case 5:
              this.$ = $$[$0];
              break;
            case 6:
              this.$ = $$[$0];
              break;
            case 7:
              this.$ = $$[$0];
              break;
            case 8:
              this.$ = $$[$0];
              break;
            case 9:
              this.$ = {
                type: "CommentStatement",
                value: yy.stripComment($$[$0]),
                strip: yy.stripFlags($$[$0], $$[$0]),
                loc: yy.locInfo(this._$)
              };
              break;
            case 10:
              this.$ = {
                type: "ContentStatement",
                original: $$[$0],
                value: $$[$0],
                loc: yy.locInfo(this._$)
              };
              break;
            case 11:
              this.$ = yy.prepareRawBlock($$[$0 - 2], $$[$0 - 1], $$[$0], this._$);
              break;
            case 12:
              this.$ = { path: $$[$0 - 3], params: $$[$0 - 2], hash: $$[$0 - 1] };
              break;
            case 13:
              this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], false, this._$);
              break;
            case 14:
              this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], true, this._$);
              break;
            case 15:
              this.$ = { open: $$[$0 - 5], path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) };
              break;
            case 16:
              this.$ = { path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) };
              break;
            case 17:
              this.$ = { path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) };
              break;
            case 18:
              this.$ = { strip: yy.stripFlags($$[$0 - 1], $$[$0 - 1]), program: $$[$0] };
              break;
            case 19:
              var inverse = yy.prepareBlock($$[$0 - 2], $$[$0 - 1], $$[$0], $$[$0], false, this._$), program = yy.prepareProgram([inverse], $$[$0 - 1].loc);
              program.chained = true;
              this.$ = { strip: $$[$0 - 2].strip, program, chain: true };
              break;
            case 20:
              this.$ = $$[$0];
              break;
            case 21:
              this.$ = { path: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 2], $$[$0]) };
              break;
            case 22:
              this.$ = yy.prepareMustache($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0 - 4], yy.stripFlags($$[$0 - 4], $$[$0]), this._$);
              break;
            case 23:
              this.$ = yy.prepareMustache($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0 - 4], yy.stripFlags($$[$0 - 4], $$[$0]), this._$);
              break;
            case 24:
              this.$ = {
                type: "PartialStatement",
                name: $$[$0 - 3],
                params: $$[$0 - 2],
                hash: $$[$0 - 1],
                indent: "",
                strip: yy.stripFlags($$[$0 - 4], $$[$0]),
                loc: yy.locInfo(this._$)
              };
              break;
            case 25:
              this.$ = yy.preparePartialBlock($$[$0 - 2], $$[$0 - 1], $$[$0], this._$);
              break;
            case 26:
              this.$ = { path: $$[$0 - 3], params: $$[$0 - 2], hash: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 4], $$[$0]) };
              break;
            case 27:
              this.$ = $$[$0];
              break;
            case 28:
              this.$ = $$[$0];
              break;
            case 29:
              this.$ = {
                type: "SubExpression",
                path: $$[$0 - 3],
                params: $$[$0 - 2],
                hash: $$[$0 - 1],
                loc: yy.locInfo(this._$)
              };
              break;
            case 30:
              this.$ = { type: "Hash", pairs: $$[$0], loc: yy.locInfo(this._$) };
              break;
            case 31:
              this.$ = { type: "HashPair", key: yy.id($$[$0 - 2]), value: $$[$0], loc: yy.locInfo(this._$) };
              break;
            case 32:
              this.$ = yy.id($$[$0 - 1]);
              break;
            case 33:
              this.$ = $$[$0];
              break;
            case 34:
              this.$ = $$[$0];
              break;
            case 35:
              this.$ = { type: "StringLiteral", value: $$[$0], original: $$[$0], loc: yy.locInfo(this._$) };
              break;
            case 36:
              this.$ = { type: "NumberLiteral", value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };
              break;
            case 37:
              this.$ = { type: "BooleanLiteral", value: $$[$0] === "true", original: $$[$0] === "true", loc: yy.locInfo(this._$) };
              break;
            case 38:
              this.$ = { type: "UndefinedLiteral", original: void 0, value: void 0, loc: yy.locInfo(this._$) };
              break;
            case 39:
              this.$ = { type: "NullLiteral", original: null, value: null, loc: yy.locInfo(this._$) };
              break;
            case 40:
              this.$ = $$[$0];
              break;
            case 41:
              this.$ = $$[$0];
              break;
            case 42:
              this.$ = yy.preparePath(true, $$[$0], this._$);
              break;
            case 43:
              this.$ = yy.preparePath(false, $$[$0], this._$);
              break;
            case 44:
              $$[$0 - 2].push({ part: yy.id($$[$0]), original: $$[$0], separator: $$[$0 - 1] });
              this.$ = $$[$0 - 2];
              break;
            case 45:
              this.$ = [{ part: yy.id($$[$0]), original: $$[$0] }];
              break;
            case 46:
              this.$ = [];
              break;
            case 47:
              $$[$0 - 1].push($$[$0]);
              break;
            case 48:
              this.$ = [];
              break;
            case 49:
              $$[$0 - 1].push($$[$0]);
              break;
            case 50:
              this.$ = [];
              break;
            case 51:
              $$[$0 - 1].push($$[$0]);
              break;
            case 58:
              this.$ = [];
              break;
            case 59:
              $$[$0 - 1].push($$[$0]);
              break;
            case 64:
              this.$ = [];
              break;
            case 65:
              $$[$0 - 1].push($$[$0]);
              break;
            case 70:
              this.$ = [];
              break;
            case 71:
              $$[$0 - 1].push($$[$0]);
              break;
            case 78:
              this.$ = [];
              break;
            case 79:
              $$[$0 - 1].push($$[$0]);
              break;
            case 82:
              this.$ = [];
              break;
            case 83:
              $$[$0 - 1].push($$[$0]);
              break;
            case 86:
              this.$ = [];
              break;
            case 87:
              $$[$0 - 1].push($$[$0]);
              break;
            case 90:
              this.$ = [];
              break;
            case 91:
              $$[$0 - 1].push($$[$0]);
              break;
            case 94:
              this.$ = [];
              break;
            case 95:
              $$[$0 - 1].push($$[$0]);
              break;
            case 98:
              this.$ = [$$[$0]];
              break;
            case 99:
              $$[$0 - 1].push($$[$0]);
              break;
            case 100:
              this.$ = [$$[$0]];
              break;
            case 101:
              $$[$0 - 1].push($$[$0]);
              break;
          }
        },
        table: [{ 3: 1, 4: 2, 5: [2, 46], 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 1: [3] }, { 5: [1, 4] }, { 5: [2, 2], 7: 5, 8: 6, 9: 7, 10: 8, 11: 9, 12: 10, 13: 11, 14: [1, 12], 15: [1, 20], 16: 17, 19: [1, 23], 24: 15, 27: 16, 29: [1, 21], 34: [1, 22], 39: [2, 2], 44: [2, 2], 47: [2, 2], 48: [1, 13], 51: [1, 14], 55: [1, 18], 59: 19, 60: [1, 24] }, { 1: [2, 1] }, { 5: [2, 47], 14: [2, 47], 15: [2, 47], 19: [2, 47], 29: [2, 47], 34: [2, 47], 39: [2, 47], 44: [2, 47], 47: [2, 47], 48: [2, 47], 51: [2, 47], 55: [2, 47], 60: [2, 47] }, { 5: [2, 3], 14: [2, 3], 15: [2, 3], 19: [2, 3], 29: [2, 3], 34: [2, 3], 39: [2, 3], 44: [2, 3], 47: [2, 3], 48: [2, 3], 51: [2, 3], 55: [2, 3], 60: [2, 3] }, { 5: [2, 4], 14: [2, 4], 15: [2, 4], 19: [2, 4], 29: [2, 4], 34: [2, 4], 39: [2, 4], 44: [2, 4], 47: [2, 4], 48: [2, 4], 51: [2, 4], 55: [2, 4], 60: [2, 4] }, { 5: [2, 5], 14: [2, 5], 15: [2, 5], 19: [2, 5], 29: [2, 5], 34: [2, 5], 39: [2, 5], 44: [2, 5], 47: [2, 5], 48: [2, 5], 51: [2, 5], 55: [2, 5], 60: [2, 5] }, { 5: [2, 6], 14: [2, 6], 15: [2, 6], 19: [2, 6], 29: [2, 6], 34: [2, 6], 39: [2, 6], 44: [2, 6], 47: [2, 6], 48: [2, 6], 51: [2, 6], 55: [2, 6], 60: [2, 6] }, { 5: [2, 7], 14: [2, 7], 15: [2, 7], 19: [2, 7], 29: [2, 7], 34: [2, 7], 39: [2, 7], 44: [2, 7], 47: [2, 7], 48: [2, 7], 51: [2, 7], 55: [2, 7], 60: [2, 7] }, { 5: [2, 8], 14: [2, 8], 15: [2, 8], 19: [2, 8], 29: [2, 8], 34: [2, 8], 39: [2, 8], 44: [2, 8], 47: [2, 8], 48: [2, 8], 51: [2, 8], 55: [2, 8], 60: [2, 8] }, { 5: [2, 9], 14: [2, 9], 15: [2, 9], 19: [2, 9], 29: [2, 9], 34: [2, 9], 39: [2, 9], 44: [2, 9], 47: [2, 9], 48: [2, 9], 51: [2, 9], 55: [2, 9], 60: [2, 9] }, { 20: 25, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 36, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 4: 37, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 39: [2, 46], 44: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 4: 38, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 44: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 15: [2, 48], 17: 39, 18: [2, 48] }, { 20: 41, 56: 40, 64: 42, 65: [1, 43], 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 4: 44, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 5: [2, 10], 14: [2, 10], 15: [2, 10], 18: [2, 10], 19: [2, 10], 29: [2, 10], 34: [2, 10], 39: [2, 10], 44: [2, 10], 47: [2, 10], 48: [2, 10], 51: [2, 10], 55: [2, 10], 60: [2, 10] }, { 20: 45, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 46, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 47, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 41, 56: 48, 64: 42, 65: [1, 43], 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 33: [2, 78], 49: 49, 65: [2, 78], 72: [2, 78], 80: [2, 78], 81: [2, 78], 82: [2, 78], 83: [2, 78], 84: [2, 78], 85: [2, 78] }, { 23: [2, 33], 33: [2, 33], 54: [2, 33], 65: [2, 33], 68: [2, 33], 72: [2, 33], 75: [2, 33], 80: [2, 33], 81: [2, 33], 82: [2, 33], 83: [2, 33], 84: [2, 33], 85: [2, 33] }, { 23: [2, 34], 33: [2, 34], 54: [2, 34], 65: [2, 34], 68: [2, 34], 72: [2, 34], 75: [2, 34], 80: [2, 34], 81: [2, 34], 82: [2, 34], 83: [2, 34], 84: [2, 34], 85: [2, 34] }, { 23: [2, 35], 33: [2, 35], 54: [2, 35], 65: [2, 35], 68: [2, 35], 72: [2, 35], 75: [2, 35], 80: [2, 35], 81: [2, 35], 82: [2, 35], 83: [2, 35], 84: [2, 35], 85: [2, 35] }, { 23: [2, 36], 33: [2, 36], 54: [2, 36], 65: [2, 36], 68: [2, 36], 72: [2, 36], 75: [2, 36], 80: [2, 36], 81: [2, 36], 82: [2, 36], 83: [2, 36], 84: [2, 36], 85: [2, 36] }, { 23: [2, 37], 33: [2, 37], 54: [2, 37], 65: [2, 37], 68: [2, 37], 72: [2, 37], 75: [2, 37], 80: [2, 37], 81: [2, 37], 82: [2, 37], 83: [2, 37], 84: [2, 37], 85: [2, 37] }, { 23: [2, 38], 33: [2, 38], 54: [2, 38], 65: [2, 38], 68: [2, 38], 72: [2, 38], 75: [2, 38], 80: [2, 38], 81: [2, 38], 82: [2, 38], 83: [2, 38], 84: [2, 38], 85: [2, 38] }, { 23: [2, 39], 33: [2, 39], 54: [2, 39], 65: [2, 39], 68: [2, 39], 72: [2, 39], 75: [2, 39], 80: [2, 39], 81: [2, 39], 82: [2, 39], 83: [2, 39], 84: [2, 39], 85: [2, 39] }, { 23: [2, 43], 33: [2, 43], 54: [2, 43], 65: [2, 43], 68: [2, 43], 72: [2, 43], 75: [2, 43], 80: [2, 43], 81: [2, 43], 82: [2, 43], 83: [2, 43], 84: [2, 43], 85: [2, 43], 87: [1, 50] }, { 72: [1, 35], 86: 51 }, { 23: [2, 45], 33: [2, 45], 54: [2, 45], 65: [2, 45], 68: [2, 45], 72: [2, 45], 75: [2, 45], 80: [2, 45], 81: [2, 45], 82: [2, 45], 83: [2, 45], 84: [2, 45], 85: [2, 45], 87: [2, 45] }, { 52: 52, 54: [2, 82], 65: [2, 82], 72: [2, 82], 80: [2, 82], 81: [2, 82], 82: [2, 82], 83: [2, 82], 84: [2, 82], 85: [2, 82] }, { 25: 53, 38: 55, 39: [1, 57], 43: 56, 44: [1, 58], 45: 54, 47: [2, 54] }, { 28: 59, 43: 60, 44: [1, 58], 47: [2, 56] }, { 13: 62, 15: [1, 20], 18: [1, 61] }, { 33: [2, 86], 57: 63, 65: [2, 86], 72: [2, 86], 80: [2, 86], 81: [2, 86], 82: [2, 86], 83: [2, 86], 84: [2, 86], 85: [2, 86] }, { 33: [2, 40], 65: [2, 40], 72: [2, 40], 80: [2, 40], 81: [2, 40], 82: [2, 40], 83: [2, 40], 84: [2, 40], 85: [2, 40] }, { 33: [2, 41], 65: [2, 41], 72: [2, 41], 80: [2, 41], 81: [2, 41], 82: [2, 41], 83: [2, 41], 84: [2, 41], 85: [2, 41] }, { 20: 64, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 26: 65, 47: [1, 66] }, { 30: 67, 33: [2, 58], 65: [2, 58], 72: [2, 58], 75: [2, 58], 80: [2, 58], 81: [2, 58], 82: [2, 58], 83: [2, 58], 84: [2, 58], 85: [2, 58] }, { 33: [2, 64], 35: 68, 65: [2, 64], 72: [2, 64], 75: [2, 64], 80: [2, 64], 81: [2, 64], 82: [2, 64], 83: [2, 64], 84: [2, 64], 85: [2, 64] }, { 21: 69, 23: [2, 50], 65: [2, 50], 72: [2, 50], 80: [2, 50], 81: [2, 50], 82: [2, 50], 83: [2, 50], 84: [2, 50], 85: [2, 50] }, { 33: [2, 90], 61: 70, 65: [2, 90], 72: [2, 90], 80: [2, 90], 81: [2, 90], 82: [2, 90], 83: [2, 90], 84: [2, 90], 85: [2, 90] }, { 20: 74, 33: [2, 80], 50: 71, 63: 72, 64: 75, 65: [1, 43], 69: 73, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 72: [1, 79] }, { 23: [2, 42], 33: [2, 42], 54: [2, 42], 65: [2, 42], 68: [2, 42], 72: [2, 42], 75: [2, 42], 80: [2, 42], 81: [2, 42], 82: [2, 42], 83: [2, 42], 84: [2, 42], 85: [2, 42], 87: [1, 50] }, { 20: 74, 53: 80, 54: [2, 84], 63: 81, 64: 75, 65: [1, 43], 69: 82, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 26: 83, 47: [1, 66] }, { 47: [2, 55] }, { 4: 84, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 39: [2, 46], 44: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 47: [2, 20] }, { 20: 85, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 4: 86, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 26: 87, 47: [1, 66] }, { 47: [2, 57] }, { 5: [2, 11], 14: [2, 11], 15: [2, 11], 19: [2, 11], 29: [2, 11], 34: [2, 11], 39: [2, 11], 44: [2, 11], 47: [2, 11], 48: [2, 11], 51: [2, 11], 55: [2, 11], 60: [2, 11] }, { 15: [2, 49], 18: [2, 49] }, { 20: 74, 33: [2, 88], 58: 88, 63: 89, 64: 75, 65: [1, 43], 69: 90, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 65: [2, 94], 66: 91, 68: [2, 94], 72: [2, 94], 80: [2, 94], 81: [2, 94], 82: [2, 94], 83: [2, 94], 84: [2, 94], 85: [2, 94] }, { 5: [2, 25], 14: [2, 25], 15: [2, 25], 19: [2, 25], 29: [2, 25], 34: [2, 25], 39: [2, 25], 44: [2, 25], 47: [2, 25], 48: [2, 25], 51: [2, 25], 55: [2, 25], 60: [2, 25] }, { 20: 92, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 31: 93, 33: [2, 60], 63: 94, 64: 75, 65: [1, 43], 69: 95, 70: 76, 71: 77, 72: [1, 78], 75: [2, 60], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 33: [2, 66], 36: 96, 63: 97, 64: 75, 65: [1, 43], 69: 98, 70: 76, 71: 77, 72: [1, 78], 75: [2, 66], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 22: 99, 23: [2, 52], 63: 100, 64: 75, 65: [1, 43], 69: 101, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 33: [2, 92], 62: 102, 63: 103, 64: 75, 65: [1, 43], 69: 104, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 33: [1, 105] }, { 33: [2, 79], 65: [2, 79], 72: [2, 79], 80: [2, 79], 81: [2, 79], 82: [2, 79], 83: [2, 79], 84: [2, 79], 85: [2, 79] }, { 33: [2, 81] }, { 23: [2, 27], 33: [2, 27], 54: [2, 27], 65: [2, 27], 68: [2, 27], 72: [2, 27], 75: [2, 27], 80: [2, 27], 81: [2, 27], 82: [2, 27], 83: [2, 27], 84: [2, 27], 85: [2, 27] }, { 23: [2, 28], 33: [2, 28], 54: [2, 28], 65: [2, 28], 68: [2, 28], 72: [2, 28], 75: [2, 28], 80: [2, 28], 81: [2, 28], 82: [2, 28], 83: [2, 28], 84: [2, 28], 85: [2, 28] }, { 23: [2, 30], 33: [2, 30], 54: [2, 30], 68: [2, 30], 71: 106, 72: [1, 107], 75: [2, 30] }, { 23: [2, 98], 33: [2, 98], 54: [2, 98], 68: [2, 98], 72: [2, 98], 75: [2, 98] }, { 23: [2, 45], 33: [2, 45], 54: [2, 45], 65: [2, 45], 68: [2, 45], 72: [2, 45], 73: [1, 108], 75: [2, 45], 80: [2, 45], 81: [2, 45], 82: [2, 45], 83: [2, 45], 84: [2, 45], 85: [2, 45], 87: [2, 45] }, { 23: [2, 44], 33: [2, 44], 54: [2, 44], 65: [2, 44], 68: [2, 44], 72: [2, 44], 75: [2, 44], 80: [2, 44], 81: [2, 44], 82: [2, 44], 83: [2, 44], 84: [2, 44], 85: [2, 44], 87: [2, 44] }, { 54: [1, 109] }, { 54: [2, 83], 65: [2, 83], 72: [2, 83], 80: [2, 83], 81: [2, 83], 82: [2, 83], 83: [2, 83], 84: [2, 83], 85: [2, 83] }, { 54: [2, 85] }, { 5: [2, 13], 14: [2, 13], 15: [2, 13], 19: [2, 13], 29: [2, 13], 34: [2, 13], 39: [2, 13], 44: [2, 13], 47: [2, 13], 48: [2, 13], 51: [2, 13], 55: [2, 13], 60: [2, 13] }, { 38: 55, 39: [1, 57], 43: 56, 44: [1, 58], 45: 111, 46: 110, 47: [2, 76] }, { 33: [2, 70], 40: 112, 65: [2, 70], 72: [2, 70], 75: [2, 70], 80: [2, 70], 81: [2, 70], 82: [2, 70], 83: [2, 70], 84: [2, 70], 85: [2, 70] }, { 47: [2, 18] }, { 5: [2, 14], 14: [2, 14], 15: [2, 14], 19: [2, 14], 29: [2, 14], 34: [2, 14], 39: [2, 14], 44: [2, 14], 47: [2, 14], 48: [2, 14], 51: [2, 14], 55: [2, 14], 60: [2, 14] }, { 33: [1, 113] }, { 33: [2, 87], 65: [2, 87], 72: [2, 87], 80: [2, 87], 81: [2, 87], 82: [2, 87], 83: [2, 87], 84: [2, 87], 85: [2, 87] }, { 33: [2, 89] }, { 20: 74, 63: 115, 64: 75, 65: [1, 43], 67: 114, 68: [2, 96], 69: 116, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 33: [1, 117] }, { 32: 118, 33: [2, 62], 74: 119, 75: [1, 120] }, { 33: [2, 59], 65: [2, 59], 72: [2, 59], 75: [2, 59], 80: [2, 59], 81: [2, 59], 82: [2, 59], 83: [2, 59], 84: [2, 59], 85: [2, 59] }, { 33: [2, 61], 75: [2, 61] }, { 33: [2, 68], 37: 121, 74: 122, 75: [1, 120] }, { 33: [2, 65], 65: [2, 65], 72: [2, 65], 75: [2, 65], 80: [2, 65], 81: [2, 65], 82: [2, 65], 83: [2, 65], 84: [2, 65], 85: [2, 65] }, { 33: [2, 67], 75: [2, 67] }, { 23: [1, 123] }, { 23: [2, 51], 65: [2, 51], 72: [2, 51], 80: [2, 51], 81: [2, 51], 82: [2, 51], 83: [2, 51], 84: [2, 51], 85: [2, 51] }, { 23: [2, 53] }, { 33: [1, 124] }, { 33: [2, 91], 65: [2, 91], 72: [2, 91], 80: [2, 91], 81: [2, 91], 82: [2, 91], 83: [2, 91], 84: [2, 91], 85: [2, 91] }, { 33: [2, 93] }, { 5: [2, 22], 14: [2, 22], 15: [2, 22], 19: [2, 22], 29: [2, 22], 34: [2, 22], 39: [2, 22], 44: [2, 22], 47: [2, 22], 48: [2, 22], 51: [2, 22], 55: [2, 22], 60: [2, 22] }, { 23: [2, 99], 33: [2, 99], 54: [2, 99], 68: [2, 99], 72: [2, 99], 75: [2, 99] }, { 73: [1, 108] }, { 20: 74, 63: 125, 64: 75, 65: [1, 43], 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 5: [2, 23], 14: [2, 23], 15: [2, 23], 19: [2, 23], 29: [2, 23], 34: [2, 23], 39: [2, 23], 44: [2, 23], 47: [2, 23], 48: [2, 23], 51: [2, 23], 55: [2, 23], 60: [2, 23] }, { 47: [2, 19] }, { 47: [2, 77] }, { 20: 74, 33: [2, 72], 41: 126, 63: 127, 64: 75, 65: [1, 43], 69: 128, 70: 76, 71: 77, 72: [1, 78], 75: [2, 72], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 5: [2, 24], 14: [2, 24], 15: [2, 24], 19: [2, 24], 29: [2, 24], 34: [2, 24], 39: [2, 24], 44: [2, 24], 47: [2, 24], 48: [2, 24], 51: [2, 24], 55: [2, 24], 60: [2, 24] }, { 68: [1, 129] }, { 65: [2, 95], 68: [2, 95], 72: [2, 95], 80: [2, 95], 81: [2, 95], 82: [2, 95], 83: [2, 95], 84: [2, 95], 85: [2, 95] }, { 68: [2, 97] }, { 5: [2, 21], 14: [2, 21], 15: [2, 21], 19: [2, 21], 29: [2, 21], 34: [2, 21], 39: [2, 21], 44: [2, 21], 47: [2, 21], 48: [2, 21], 51: [2, 21], 55: [2, 21], 60: [2, 21] }, { 33: [1, 130] }, { 33: [2, 63] }, { 72: [1, 132], 76: 131 }, { 33: [1, 133] }, { 33: [2, 69] }, { 15: [2, 12], 18: [2, 12] }, { 14: [2, 26], 15: [2, 26], 19: [2, 26], 29: [2, 26], 34: [2, 26], 47: [2, 26], 48: [2, 26], 51: [2, 26], 55: [2, 26], 60: [2, 26] }, { 23: [2, 31], 33: [2, 31], 54: [2, 31], 68: [2, 31], 72: [2, 31], 75: [2, 31] }, { 33: [2, 74], 42: 134, 74: 135, 75: [1, 120] }, { 33: [2, 71], 65: [2, 71], 72: [2, 71], 75: [2, 71], 80: [2, 71], 81: [2, 71], 82: [2, 71], 83: [2, 71], 84: [2, 71], 85: [2, 71] }, { 33: [2, 73], 75: [2, 73] }, { 23: [2, 29], 33: [2, 29], 54: [2, 29], 65: [2, 29], 68: [2, 29], 72: [2, 29], 75: [2, 29], 80: [2, 29], 81: [2, 29], 82: [2, 29], 83: [2, 29], 84: [2, 29], 85: [2, 29] }, { 14: [2, 15], 15: [2, 15], 19: [2, 15], 29: [2, 15], 34: [2, 15], 39: [2, 15], 44: [2, 15], 47: [2, 15], 48: [2, 15], 51: [2, 15], 55: [2, 15], 60: [2, 15] }, { 72: [1, 137], 77: [1, 136] }, { 72: [2, 100], 77: [2, 100] }, { 14: [2, 16], 15: [2, 16], 19: [2, 16], 29: [2, 16], 34: [2, 16], 44: [2, 16], 47: [2, 16], 48: [2, 16], 51: [2, 16], 55: [2, 16], 60: [2, 16] }, { 33: [1, 138] }, { 33: [2, 75] }, { 33: [2, 32] }, { 72: [2, 101], 77: [2, 101] }, { 14: [2, 17], 15: [2, 17], 19: [2, 17], 29: [2, 17], 34: [2, 17], 39: [2, 17], 44: [2, 17], 47: [2, 17], 48: [2, 17], 51: [2, 17], 55: [2, 17], 60: [2, 17] }],
        defaultActions: { 4: [2, 1], 54: [2, 55], 56: [2, 20], 60: [2, 57], 73: [2, 81], 82: [2, 85], 86: [2, 18], 90: [2, 89], 101: [2, 53], 104: [2, 93], 110: [2, 19], 111: [2, 77], 116: [2, 97], 119: [2, 63], 122: [2, 69], 135: [2, 75], 136: [2, 32] },
        parseError: function parseError(str, hash3) {
          throw new Error(str);
        },
        parse: function parse4(input) {
          var self2 = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
          this.lexer.setInput(input);
          this.lexer.yy = this.yy;
          this.yy.lexer = this.lexer;
          this.yy.parser = this;
          if (typeof this.lexer.yylloc == "undefined") this.lexer.yylloc = {};
          var yyloc = this.lexer.yylloc;
          lstack.push(yyloc);
          var ranges = this.lexer.options && this.lexer.options.ranges;
          if (typeof this.yy.parseError === "function") this.parseError = this.yy.parseError;
          function popStack(n) {
            stack.length = stack.length - 2 * n;
            vstack.length = vstack.length - n;
            lstack.length = lstack.length - n;
          }
          function lex() {
            var token;
            token = self2.lexer.lex() || 1;
            if (typeof token !== "number") {
              token = self2.symbols_[token] || token;
            }
            return token;
          }
          var symbol30, preErrorSymbol, state, action, a, r, yyval = {}, p3, len, newState, expected;
          while (true) {
            state = stack[stack.length - 1];
            if (this.defaultActions[state]) {
              action = this.defaultActions[state];
            } else {
              if (symbol30 === null || typeof symbol30 == "undefined") {
                symbol30 = lex();
              }
              action = table[state] && table[state][symbol30];
            }
            if (typeof action === "undefined" || !action.length || !action[0]) {
              var errStr = "";
              if (!recovering) {
                expected = [];
                for (p3 in table[state]) if (this.terminals_[p3] && p3 > 2) {
                  expected.push("'" + this.terminals_[p3] + "'");
                }
                if (this.lexer.showPosition) {
                  errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol30] || symbol30) + "'";
                } else {
                  errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol30 == 1 ? "end of input" : "'" + (this.terminals_[symbol30] || symbol30) + "'");
                }
                this.parseError(errStr, { text: this.lexer.match, token: this.terminals_[symbol30] || symbol30, line: this.lexer.yylineno, loc: yyloc, expected });
              }
            }
            if (action[0] instanceof Array && action.length > 1) {
              throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol30);
            }
            switch (action[0]) {
              case 1:
                stack.push(symbol30);
                vstack.push(this.lexer.yytext);
                lstack.push(this.lexer.yylloc);
                stack.push(action[1]);
                symbol30 = null;
                if (!preErrorSymbol) {
                  yyleng = this.lexer.yyleng;
                  yytext = this.lexer.yytext;
                  yylineno = this.lexer.yylineno;
                  yyloc = this.lexer.yylloc;
                  if (recovering > 0) recovering--;
                } else {
                  symbol30 = preErrorSymbol;
                  preErrorSymbol = null;
                }
                break;
              case 2:
                len = this.productions_[action[1]][1];
                yyval.$ = vstack[vstack.length - len];
                yyval._$ = { first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column };
                if (ranges) {
                  yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
                }
                r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
                if (typeof r !== "undefined") {
                  return r;
                }
                if (len) {
                  stack = stack.slice(0, -1 * len * 2);
                  vstack = vstack.slice(0, -1 * len);
                  lstack = lstack.slice(0, -1 * len);
                }
                stack.push(this.productions_[action[1]][0]);
                vstack.push(yyval.$);
                lstack.push(yyval._$);
                newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                stack.push(newState);
                break;
              case 3:
                return true;
            }
          }
          return true;
        }
      };
      var lexer = (function() {
        var lexer2 = {
          EOF: 1,
          parseError: function parseError(str, hash3) {
            if (this.yy.parser) {
              this.yy.parser.parseError(str, hash3);
            } else {
              throw new Error(str);
            }
          },
          setInput: function setInput(input) {
            this._input = input;
            this._more = this._less = this.done = false;
            this.yylineno = this.yyleng = 0;
            this.yytext = this.matched = this.match = "";
            this.conditionStack = ["INITIAL"];
            this.yylloc = { first_line: 1, first_column: 0, last_line: 1, last_column: 0 };
            if (this.options.ranges) this.yylloc.range = [0, 0];
            this.offset = 0;
            return this;
          },
          input: function input() {
            var ch = this._input[0];
            this.yytext += ch;
            this.yyleng++;
            this.offset++;
            this.match += ch;
            this.matched += ch;
            var lines = ch.match(/(?:\r\n?|\n).*/g);
            if (lines) {
              this.yylineno++;
              this.yylloc.last_line++;
            } else {
              this.yylloc.last_column++;
            }
            if (this.options.ranges) this.yylloc.range[1]++;
            this._input = this._input.slice(1);
            return ch;
          },
          unput: function unput(ch) {
            var len = ch.length;
            var lines = ch.split(/(?:\r\n?|\n)/g);
            this._input = ch + this._input;
            this.yytext = this.yytext.substr(0, this.yytext.length - len - 1);
            this.offset -= len;
            var oldLines = this.match.split(/(?:\r\n?|\n)/g);
            this.match = this.match.substr(0, this.match.length - 1);
            this.matched = this.matched.substr(0, this.matched.length - 1);
            if (lines.length - 1) this.yylineno -= lines.length - 1;
            var r = this.yylloc.range;
            this.yylloc = {
              first_line: this.yylloc.first_line,
              last_line: this.yylineno + 1,
              first_column: this.yylloc.first_column,
              last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
            };
            if (this.options.ranges) {
              this.yylloc.range = [r[0], r[0] + this.yyleng - len];
            }
            return this;
          },
          more: function more() {
            this._more = true;
            return this;
          },
          less: function less(n) {
            this.unput(this.match.slice(n));
          },
          pastInput: function pastInput() {
            var past = this.matched.substr(0, this.matched.length - this.match.length);
            return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
          },
          upcomingInput: function upcomingInput() {
            var next = this.match;
            if (next.length < 20) {
              next += this._input.substr(0, 20 - next.length);
            }
            return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "");
          },
          showPosition: function showPosition() {
            var pre = this.pastInput();
            var c = new Array(pre.length + 1).join("-");
            return pre + this.upcomingInput() + "\n" + c + "^";
          },
          next: function next() {
            if (this.done) {
              return this.EOF;
            }
            if (!this._input) this.done = true;
            var token, match, tempMatch, index, col, lines;
            if (!this._more) {
              this.yytext = "";
              this.match = "";
            }
            var rules = this._currentRules();
            for (var i = 0; i < rules.length; i++) {
              tempMatch = this._input.match(this.rules[rules[i]]);
              if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                match = tempMatch;
                index = i;
                if (!this.options.flex) break;
              }
            }
            if (match) {
              lines = match[0].match(/(?:\r\n?|\n).*/g);
              if (lines) this.yylineno += lines.length;
              this.yylloc = {
                first_line: this.yylloc.last_line,
                last_line: this.yylineno + 1,
                first_column: this.yylloc.last_column,
                last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
              };
              this.yytext += match[0];
              this.match += match[0];
              this.matches = match;
              this.yyleng = this.yytext.length;
              if (this.options.ranges) {
                this.yylloc.range = [this.offset, this.offset += this.yyleng];
              }
              this._more = false;
              this._input = this._input.slice(match[0].length);
              this.matched += match[0];
              token = this.performAction.call(this, this.yy, this, rules[index], this.conditionStack[this.conditionStack.length - 1]);
              if (this.done && this._input) this.done = false;
              if (token) return token;
              else return;
            }
            if (this._input === "") {
              return this.EOF;
            } else {
              return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), { text: "", token: null, line: this.yylineno });
            }
          },
          lex: function lex() {
            var r = this.next();
            if (typeof r !== "undefined") {
              return r;
            } else {
              return this.lex();
            }
          },
          begin: function begin(condition) {
            this.conditionStack.push(condition);
          },
          popState: function popState() {
            return this.conditionStack.pop();
          },
          _currentRules: function _currentRules() {
            return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
          },
          topState: function topState() {
            return this.conditionStack[this.conditionStack.length - 2];
          },
          pushState: function begin(condition) {
            this.begin(condition);
          }
        };
        lexer2.options = {};
        lexer2.performAction = function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
          function strip(start, end) {
            return yy_.yytext = yy_.yytext.substring(start, yy_.yyleng - end + start);
          }
          var YYSTATE = YY_START;
          switch ($avoiding_name_collisions) {
            case 0:
              if (yy_.yytext.slice(-2) === "\\\\") {
                strip(0, 1);
                this.begin("mu");
              } else if (yy_.yytext.slice(-1) === "\\") {
                strip(0, 1);
                this.begin("emu");
              } else {
                this.begin("mu");
              }
              if (yy_.yytext) return 15;
              break;
            case 1:
              return 15;
              break;
            case 2:
              this.popState();
              return 15;
              break;
            case 3:
              this.begin("raw");
              return 15;
              break;
            case 4:
              this.popState();
              if (this.conditionStack[this.conditionStack.length - 1] === "raw") {
                return 15;
              } else {
                strip(5, 9);
                return "END_RAW_BLOCK";
              }
              break;
            case 5:
              return 15;
              break;
            case 6:
              this.popState();
              return 14;
              break;
            case 7:
              return 65;
              break;
            case 8:
              return 68;
              break;
            case 9:
              return 19;
              break;
            case 10:
              this.popState();
              this.begin("raw");
              return 23;
              break;
            case 11:
              return 55;
              break;
            case 12:
              return 60;
              break;
            case 13:
              return 29;
              break;
            case 14:
              return 47;
              break;
            case 15:
              this.popState();
              return 44;
              break;
            case 16:
              this.popState();
              return 44;
              break;
            case 17:
              return 34;
              break;
            case 18:
              return 39;
              break;
            case 19:
              return 51;
              break;
            case 20:
              return 48;
              break;
            case 21:
              this.unput(yy_.yytext);
              this.popState();
              this.begin("com");
              break;
            case 22:
              this.popState();
              return 14;
              break;
            case 23:
              return 48;
              break;
            case 24:
              return 73;
              break;
            case 25:
              return 72;
              break;
            case 26:
              return 72;
              break;
            case 27:
              return 87;
              break;
            case 28:
              break;
            case 29:
              this.popState();
              return 54;
              break;
            case 30:
              this.popState();
              return 33;
              break;
            case 31:
              yy_.yytext = strip(1, 2).replace(/\\"/g, '"');
              return 80;
              break;
            case 32:
              yy_.yytext = strip(1, 2).replace(/\\'/g, "'");
              return 80;
              break;
            case 33:
              return 85;
              break;
            case 34:
              return 82;
              break;
            case 35:
              return 82;
              break;
            case 36:
              return 83;
              break;
            case 37:
              return 84;
              break;
            case 38:
              return 81;
              break;
            case 39:
              return 75;
              break;
            case 40:
              return 77;
              break;
            case 41:
              return 72;
              break;
            case 42:
              yy_.yytext = yy_.yytext.replace(/\\([\\\]])/g, "$1");
              return 72;
              break;
            case 43:
              return "INVALID";
              break;
            case 44:
              return 5;
              break;
          }
        };
        lexer2.rules = [/^(?:[^\x00]*?(?=(\{\{)))/, /^(?:[^\x00]+)/, /^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/, /^(?:\{\{\{\{(?=[^\/]))/, /^(?:\{\{\{\{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.])\}\}\}\})/, /^(?:[^\x00]+?(?=(\{\{\{\{)))/, /^(?:[\s\S]*?--(~)?\}\})/, /^(?:\()/, /^(?:\))/, /^(?:\{\{\{\{)/, /^(?:\}\}\}\})/, /^(?:\{\{(~)?>)/, /^(?:\{\{(~)?#>)/, /^(?:\{\{(~)?#\*?)/, /^(?:\{\{(~)?\/)/, /^(?:\{\{(~)?\^\s*(~)?\}\})/, /^(?:\{\{(~)?\s*else\s*(~)?\}\})/, /^(?:\{\{(~)?\^)/, /^(?:\{\{(~)?\s*else\b)/, /^(?:\{\{(~)?\{)/, /^(?:\{\{(~)?&)/, /^(?:\{\{(~)?!--)/, /^(?:\{\{(~)?![\s\S]*?\}\})/, /^(?:\{\{(~)?\*?)/, /^(?:=)/, /^(?:\.\.)/, /^(?:\.(?=([=~}\s\/.)|])))/, /^(?:[\/.])/, /^(?:\s+)/, /^(?:\}(~)?\}\})/, /^(?:(~)?\}\})/, /^(?:"(\\["]|[^"])*")/, /^(?:'(\\[']|[^'])*')/, /^(?:@)/, /^(?:true(?=([~}\s)])))/, /^(?:false(?=([~}\s)])))/, /^(?:undefined(?=([~}\s)])))/, /^(?:null(?=([~}\s)])))/, /^(?:-?[0-9]+(?:\.[0-9]+)?(?=([~}\s)])))/, /^(?:as\s+\|)/, /^(?:\|)/, /^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)|]))))/, /^(?:\[(\\\]|[^\]])*\])/, /^(?:.)/, /^(?:$)/];
        lexer2.conditions = { "mu": { "rules": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44], "inclusive": false }, "emu": { "rules": [2], "inclusive": false }, "com": { "rules": [6], "inclusive": false }, "raw": { "rules": [3, 4, 5], "inclusive": false }, "INITIAL": { "rules": [0, 1, 44], "inclusive": true } };
        return lexer2;
      })();
      parser.lexer = lexer;
      function Parser() {
        this.yy = {};
      }
      Parser.prototype = parser;
      parser.Parser = Parser;
      return new Parser();
    })();
    exports2["default"] = handlebars;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/visitor.js
var require_visitor = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/visitor.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    function Visitor() {
      this.parents = [];
    }
    Visitor.prototype = {
      constructor: Visitor,
      mutating: false,
      // Visits a given value. If mutating, will replace the value if necessary.
      acceptKey: function acceptKey(node, name28) {
        var value = this.accept(node[name28]);
        if (this.mutating) {
          if (value && !Visitor.prototype[value.type]) {
            throw new _exception2["default"]('Unexpected node type "' + value.type + '" found when accepting ' + name28 + " on " + node.type);
          }
          node[name28] = value;
        }
      },
      // Performs an accept operation with added sanity check to ensure
      // required keys are not removed.
      acceptRequired: function acceptRequired(node, name28) {
        this.acceptKey(node, name28);
        if (!node[name28]) {
          throw new _exception2["default"](node.type + " requires " + name28);
        }
      },
      // Traverses a given array. If mutating, empty respnses will be removed
      // for child elements.
      acceptArray: function acceptArray(array4) {
        for (var i = 0, l = array4.length; i < l; i++) {
          this.acceptKey(array4, i);
          if (!array4[i]) {
            array4.splice(i, 1);
            i--;
            l--;
          }
        }
      },
      accept: function accept(object4) {
        if (!object4) {
          return;
        }
        if (!this[object4.type]) {
          throw new _exception2["default"]("Unknown type: " + object4.type, object4);
        }
        if (this.current) {
          this.parents.unshift(this.current);
        }
        this.current = object4;
        var ret = this[object4.type](object4);
        this.current = this.parents.shift();
        if (!this.mutating || ret) {
          return ret;
        } else if (ret !== false) {
          return object4;
        }
      },
      Program: function Program(program) {
        this.acceptArray(program.body);
      },
      MustacheStatement: visitSubExpression,
      Decorator: visitSubExpression,
      BlockStatement: visitBlock,
      DecoratorBlock: visitBlock,
      PartialStatement: visitPartial,
      PartialBlockStatement: function PartialBlockStatement(partial3) {
        visitPartial.call(this, partial3);
        this.acceptKey(partial3, "program");
      },
      ContentStatement: function ContentStatement() {
      },
      CommentStatement: function CommentStatement() {
      },
      SubExpression: visitSubExpression,
      PathExpression: function PathExpression() {
      },
      StringLiteral: function StringLiteral() {
      },
      NumberLiteral: function NumberLiteral() {
      },
      BooleanLiteral: function BooleanLiteral() {
      },
      UndefinedLiteral: function UndefinedLiteral() {
      },
      NullLiteral: function NullLiteral() {
      },
      Hash: function Hash2(hash3) {
        this.acceptArray(hash3.pairs);
      },
      HashPair: function HashPair(pair) {
        this.acceptRequired(pair, "value");
      }
    };
    function visitSubExpression(mustache) {
      this.acceptRequired(mustache, "path");
      this.acceptArray(mustache.params);
      this.acceptKey(mustache, "hash");
    }
    function visitBlock(block) {
      visitSubExpression.call(this, block);
      this.acceptKey(block, "program");
      this.acceptKey(block, "inverse");
    }
    function visitPartial(partial3) {
      this.acceptRequired(partial3, "name");
      this.acceptArray(partial3.params);
      this.acceptKey(partial3, "hash");
    }
    exports2["default"] = Visitor;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/whitespace-control.js
var require_whitespace_control = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/whitespace-control.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _visitor = require_visitor();
    var _visitor2 = _interopRequireDefault(_visitor);
    function WhitespaceControl() {
      var options = arguments.length <= 0 || arguments[0] === void 0 ? {} : arguments[0];
      this.options = options;
    }
    WhitespaceControl.prototype = new _visitor2["default"]();
    WhitespaceControl.prototype.Program = function(program) {
      var doStandalone = !this.options.ignoreStandalone;
      var isRoot = !this.isRootSeen;
      this.isRootSeen = true;
      var body = program.body;
      for (var i = 0, l = body.length; i < l; i++) {
        var current = body[i], strip = this.accept(current);
        if (!strip) {
          continue;
        }
        var _isPrevWhitespace = isPrevWhitespace(body, i, isRoot), _isNextWhitespace = isNextWhitespace(body, i, isRoot), openStandalone = strip.openStandalone && _isPrevWhitespace, closeStandalone = strip.closeStandalone && _isNextWhitespace, inlineStandalone = strip.inlineStandalone && _isPrevWhitespace && _isNextWhitespace;
        if (strip.close) {
          omitRight(body, i, true);
        }
        if (strip.open) {
          omitLeft(body, i, true);
        }
        if (doStandalone && inlineStandalone) {
          omitRight(body, i);
          if (omitLeft(body, i)) {
            if (current.type === "PartialStatement") {
              current.indent = /([ \t]+$)/.exec(body[i - 1].original)[1];
            }
          }
        }
        if (doStandalone && openStandalone) {
          omitRight((current.program || current.inverse).body);
          omitLeft(body, i);
        }
        if (doStandalone && closeStandalone) {
          omitRight(body, i);
          omitLeft((current.inverse || current.program).body);
        }
      }
      return program;
    };
    WhitespaceControl.prototype.BlockStatement = WhitespaceControl.prototype.DecoratorBlock = WhitespaceControl.prototype.PartialBlockStatement = function(block) {
      this.accept(block.program);
      this.accept(block.inverse);
      var program = block.program || block.inverse, inverse = block.program && block.inverse, firstInverse = inverse, lastInverse = inverse;
      if (inverse && inverse.chained) {
        firstInverse = inverse.body[0].program;
        while (lastInverse.chained) {
          lastInverse = lastInverse.body[lastInverse.body.length - 1].program;
        }
      }
      var strip = {
        open: block.openStrip.open,
        close: block.closeStrip.close,
        // Determine the standalone candiacy. Basically flag our content as being possibly standalone
        // so our parent can determine if we actually are standalone
        openStandalone: isNextWhitespace(program.body),
        closeStandalone: isPrevWhitespace((firstInverse || program).body)
      };
      if (block.openStrip.close) {
        omitRight(program.body, null, true);
      }
      if (inverse) {
        var inverseStrip = block.inverseStrip;
        if (inverseStrip.open) {
          omitLeft(program.body, null, true);
        }
        if (inverseStrip.close) {
          omitRight(firstInverse.body, null, true);
        }
        if (block.closeStrip.open) {
          omitLeft(lastInverse.body, null, true);
        }
        if (!this.options.ignoreStandalone && isPrevWhitespace(program.body) && isNextWhitespace(firstInverse.body)) {
          omitLeft(program.body);
          omitRight(firstInverse.body);
        }
      } else if (block.closeStrip.open) {
        omitLeft(program.body, null, true);
      }
      return strip;
    };
    WhitespaceControl.prototype.Decorator = WhitespaceControl.prototype.MustacheStatement = function(mustache) {
      return mustache.strip;
    };
    WhitespaceControl.prototype.PartialStatement = WhitespaceControl.prototype.CommentStatement = function(node) {
      var strip = node.strip || {};
      return {
        inlineStandalone: true,
        open: strip.open,
        close: strip.close
      };
    };
    function isPrevWhitespace(body, i, isRoot) {
      if (i === void 0) {
        i = body.length;
      }
      var prev = body[i - 1], sibling = body[i - 2];
      if (!prev) {
        return isRoot;
      }
      if (prev.type === "ContentStatement") {
        return (sibling || !isRoot ? /\r?\n\s*?$/ : /(^|\r?\n)\s*?$/).test(prev.original);
      }
    }
    function isNextWhitespace(body, i, isRoot) {
      if (i === void 0) {
        i = -1;
      }
      var next = body[i + 1], sibling = body[i + 2];
      if (!next) {
        return isRoot;
      }
      if (next.type === "ContentStatement") {
        return (sibling || !isRoot ? /^\s*?\r?\n/ : /^\s*?(\r?\n|$)/).test(next.original);
      }
    }
    function omitRight(body, i, multiple) {
      var current = body[i == null ? 0 : i + 1];
      if (!current || current.type !== "ContentStatement" || !multiple && current.rightStripped) {
        return;
      }
      var original = current.value;
      current.value = current.value.replace(multiple ? /^\s+/ : /^[ \t]*\r?\n?/, "");
      current.rightStripped = current.value !== original;
    }
    function omitLeft(body, i, multiple) {
      var current = body[i == null ? body.length - 1 : i - 1];
      if (!current || current.type !== "ContentStatement" || !multiple && current.leftStripped) {
        return;
      }
      var original = current.value;
      current.value = current.value.replace(multiple ? /\s+$/ : /[ \t]+$/, "");
      current.leftStripped = current.value !== original;
      return current.leftStripped;
    }
    exports2["default"] = WhitespaceControl;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/helpers.js
var require_helpers4 = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/helpers.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.SourceLocation = SourceLocation;
    exports2.id = id;
    exports2.stripFlags = stripFlags;
    exports2.stripComment = stripComment;
    exports2.preparePath = preparePath;
    exports2.prepareMustache = prepareMustache;
    exports2.prepareRawBlock = prepareRawBlock;
    exports2.prepareBlock = prepareBlock;
    exports2.prepareProgram = prepareProgram;
    exports2.preparePartialBlock = preparePartialBlock;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    function validateClose(open, close) {
      close = close.path ? close.path.original : close;
      if (open.path.original !== close) {
        var errorNode = { loc: open.path.loc };
        throw new _exception2["default"](open.path.original + " doesn't match " + close, errorNode);
      }
    }
    function SourceLocation(source, locInfo) {
      this.source = source;
      this.start = {
        line: locInfo.first_line,
        column: locInfo.first_column
      };
      this.end = {
        line: locInfo.last_line,
        column: locInfo.last_column
      };
    }
    function id(token) {
      if (/^\[.*\]$/.test(token)) {
        return token.substring(1, token.length - 1);
      } else {
        return token;
      }
    }
    function stripFlags(open, close) {
      return {
        open: open.charAt(2) === "~",
        close: close.charAt(close.length - 3) === "~"
      };
    }
    function stripComment(comment) {
      return comment.replace(/^\{\{~?!-?-?/, "").replace(/-?-?~?\}\}$/, "");
    }
    function preparePath(data, parts, loc) {
      loc = this.locInfo(loc);
      var original = data ? "@" : "", dig = [], depth = 0;
      for (var i = 0, l = parts.length; i < l; i++) {
        var part = parts[i].part, isLiteral = parts[i].original !== part;
        original += (parts[i].separator || "") + part;
        if (!isLiteral && (part === ".." || part === "." || part === "this")) {
          if (dig.length > 0) {
            throw new _exception2["default"]("Invalid path: " + original, { loc });
          } else if (part === "..") {
            depth++;
          }
        } else {
          dig.push(part);
        }
      }
      return {
        type: "PathExpression",
        data,
        depth,
        parts: dig,
        original,
        loc
      };
    }
    function prepareMustache(path33, params, hash3, open, strip, locInfo) {
      var escapeFlag = open.charAt(3) || open.charAt(2), escaped = escapeFlag !== "{" && escapeFlag !== "&";
      var decorator = /\*/.test(open);
      return {
        type: decorator ? "Decorator" : "MustacheStatement",
        path: path33,
        params,
        hash: hash3,
        escaped,
        strip,
        loc: this.locInfo(locInfo)
      };
    }
    function prepareRawBlock(openRawBlock, contents, close, locInfo) {
      validateClose(openRawBlock, close);
      locInfo = this.locInfo(locInfo);
      var program = {
        type: "Program",
        body: contents,
        strip: {},
        loc: locInfo
      };
      return {
        type: "BlockStatement",
        path: openRawBlock.path,
        params: openRawBlock.params,
        hash: openRawBlock.hash,
        program,
        openStrip: {},
        inverseStrip: {},
        closeStrip: {},
        loc: locInfo
      };
    }
    function prepareBlock(openBlock, program, inverseAndProgram, close, inverted, locInfo) {
      if (close && close.path) {
        validateClose(openBlock, close);
      }
      var decorator = /\*/.test(openBlock.open);
      program.blockParams = openBlock.blockParams;
      var inverse = void 0, inverseStrip = void 0;
      if (inverseAndProgram) {
        if (decorator) {
          throw new _exception2["default"]("Unexpected inverse block on decorator", inverseAndProgram);
        }
        if (inverseAndProgram.chain) {
          inverseAndProgram.program.body[0].closeStrip = close.strip;
        }
        inverseStrip = inverseAndProgram.strip;
        inverse = inverseAndProgram.program;
      }
      if (inverted) {
        inverted = inverse;
        inverse = program;
        program = inverted;
      }
      return {
        type: decorator ? "DecoratorBlock" : "BlockStatement",
        path: openBlock.path,
        params: openBlock.params,
        hash: openBlock.hash,
        program,
        inverse,
        openStrip: openBlock.strip,
        inverseStrip,
        closeStrip: close && close.strip,
        loc: this.locInfo(locInfo)
      };
    }
    function prepareProgram(statements, loc) {
      if (!loc && statements.length) {
        var firstLoc = statements[0].loc, lastLoc = statements[statements.length - 1].loc;
        if (firstLoc && lastLoc) {
          loc = {
            source: firstLoc.source,
            start: {
              line: firstLoc.start.line,
              column: firstLoc.start.column
            },
            end: {
              line: lastLoc.end.line,
              column: lastLoc.end.column
            }
          };
        }
      }
      return {
        type: "Program",
        body: statements,
        strip: {},
        loc
      };
    }
    function preparePartialBlock(open, program, close, locInfo) {
      validateClose(open, close);
      return {
        type: "PartialBlockStatement",
        name: open.path,
        params: open.params,
        hash: open.hash,
        program,
        openStrip: open.strip,
        closeStrip: close && close.strip,
        loc: this.locInfo(locInfo)
      };
    }
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/base.js
var require_base3 = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/base.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.parseWithoutProcessing = parseWithoutProcessing;
    exports2.parse = parse4;
    function _interopRequireWildcard(obj) {
      if (obj && obj.__esModule) {
        return obj;
      } else {
        var newObj = {};
        if (obj != null) {
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
          }
        }
        newObj["default"] = obj;
        return newObj;
      }
    }
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _parser = require_parser3();
    var _parser2 = _interopRequireDefault(_parser);
    var _whitespaceControl = require_whitespace_control();
    var _whitespaceControl2 = _interopRequireDefault(_whitespaceControl);
    var _helpers = require_helpers4();
    var Helpers = _interopRequireWildcard(_helpers);
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    var _utils = require_utils12();
    exports2.parser = _parser2["default"];
    var yy = {};
    _utils.extend(yy, Helpers);
    function parseWithoutProcessing(input, options) {
      if (input.type === "Program") {
        validateInputAst(input);
        return input;
      }
      _parser2["default"].yy = yy;
      yy.locInfo = function(locInfo) {
        return new yy.SourceLocation(options && options.srcName, locInfo);
      };
      var ast = _parser2["default"].parse(input);
      return ast;
    }
    function parse4(input, options) {
      var ast = parseWithoutProcessing(input, options);
      var strip = new _whitespaceControl2["default"](options);
      return strip.accept(ast);
    }
    function validateInputAst(ast) {
      validateAstNode(ast);
    }
    function validateAstNode(node) {
      if (node == null) {
        return;
      }
      if (Array.isArray(node)) {
        node.forEach(validateAstNode);
        return;
      }
      if (typeof node !== "object") {
        return;
      }
      if (node.type === "PathExpression") {
        if (!isValidDepth(node.depth)) {
          throw new _exception2["default"]("Invalid AST: PathExpression.depth must be an integer");
        }
        if (!Array.isArray(node.parts)) {
          throw new _exception2["default"]("Invalid AST: PathExpression.parts must be an array");
        }
        for (var i = 0; i < node.parts.length; i++) {
          if (typeof node.parts[i] !== "string") {
            throw new _exception2["default"]("Invalid AST: PathExpression.parts must only contain strings");
          }
        }
      } else if (node.type === "NumberLiteral") {
        if (typeof node.value !== "number" || !isFinite(node.value)) {
          throw new _exception2["default"]("Invalid AST: NumberLiteral.value must be a number");
        }
      } else if (node.type === "BooleanLiteral") {
        if (typeof node.value !== "boolean") {
          throw new _exception2["default"]("Invalid AST: BooleanLiteral.value must be a boolean");
        }
      }
      Object.keys(node).forEach(function(propertyName) {
        if (propertyName === "loc") {
          return;
        }
        validateAstNode(node[propertyName]);
      });
    }
    function isValidDepth(depth) {
      return typeof depth === "number" && isFinite(depth) && Math.floor(depth) === depth && depth >= 0;
    }
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/compiler.js
var require_compiler3 = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/compiler.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.Compiler = Compiler;
    exports2.precompile = precompile;
    exports2.compile = compile;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    var _utils = require_utils12();
    var _ast = require_ast();
    var _ast2 = _interopRequireDefault(_ast);
    var slice = [].slice;
    function Compiler() {
    }
    Compiler.prototype = {
      compiler: Compiler,
      equals: function equals(other) {
        var len = this.opcodes.length;
        if (other.opcodes.length !== len) {
          return false;
        }
        for (var i = 0; i < len; i++) {
          var opcode = this.opcodes[i], otherOpcode = other.opcodes[i];
          if (opcode.opcode !== otherOpcode.opcode || !argEquals(opcode.args, otherOpcode.args)) {
            return false;
          }
        }
        len = this.children.length;
        for (var i = 0; i < len; i++) {
          if (!this.children[i].equals(other.children[i])) {
            return false;
          }
        }
        return true;
      },
      guid: 0,
      compile: function compile2(program, options) {
        this.sourceNode = [];
        this.opcodes = [];
        this.children = [];
        this.options = options;
        this.stringParams = options.stringParams;
        this.trackIds = options.trackIds;
        options.blockParams = options.blockParams || [];
        options.knownHelpers = _utils.extend(/* @__PURE__ */ Object.create(null), {
          helperMissing: true,
          blockHelperMissing: true,
          each: true,
          "if": true,
          unless: true,
          "with": true,
          log: true,
          lookup: true
        }, options.knownHelpers);
        return this.accept(program);
      },
      compileProgram: function compileProgram(program) {
        var childCompiler = new this.compiler(), result = childCompiler.compile(program, this.options), guid4 = this.guid++;
        this.usePartial = this.usePartial || result.usePartial;
        this.children[guid4] = result;
        this.useDepths = this.useDepths || result.useDepths;
        return guid4;
      },
      accept: function accept(node) {
        if (!this[node.type]) {
          throw new _exception2["default"]("Unknown type: " + node.type, node);
        }
        this.sourceNode.unshift(node);
        var ret = this[node.type](node);
        this.sourceNode.shift();
        return ret;
      },
      Program: function Program(program) {
        this.options.blockParams.unshift(program.blockParams);
        var body = program.body, bodyLength = body.length;
        for (var i = 0; i < bodyLength; i++) {
          this.accept(body[i]);
        }
        this.options.blockParams.shift();
        this.isSimple = bodyLength === 1;
        this.blockParams = program.blockParams ? program.blockParams.length : 0;
        return this;
      },
      BlockStatement: function BlockStatement(block) {
        transformLiteralToPath(block);
        var program = block.program, inverse = block.inverse;
        program = program && this.compileProgram(program);
        inverse = inverse && this.compileProgram(inverse);
        var type = this.classifySexpr(block);
        if (type === "helper") {
          this.helperSexpr(block, program, inverse);
        } else if (type === "simple") {
          this.simpleSexpr(block);
          this.opcode("pushProgram", program);
          this.opcode("pushProgram", inverse);
          this.opcode("emptyHash");
          this.opcode("blockValue", block.path.original);
        } else {
          this.ambiguousSexpr(block, program, inverse);
          this.opcode("pushProgram", program);
          this.opcode("pushProgram", inverse);
          this.opcode("emptyHash");
          this.opcode("ambiguousBlockValue");
        }
        this.opcode("append");
      },
      DecoratorBlock: function DecoratorBlock(decorator) {
        var program = decorator.program && this.compileProgram(decorator.program);
        var params = this.setupFullMustacheParams(decorator, program, void 0), path33 = decorator.path;
        this.useDecorators = true;
        this.opcode("registerDecorator", params.length, path33.original);
      },
      PartialStatement: function PartialStatement(partial3) {
        this.usePartial = true;
        var program = partial3.program;
        if (program) {
          program = this.compileProgram(partial3.program);
        }
        var params = partial3.params;
        if (params.length > 1) {
          throw new _exception2["default"]("Unsupported number of partial arguments: " + params.length, partial3);
        } else if (!params.length) {
          if (this.options.explicitPartialContext) {
            this.opcode("pushLiteral", "undefined");
          } else {
            params.push({ type: "PathExpression", parts: [], depth: 0 });
          }
        }
        var partialName = partial3.name.original, isDynamic = partial3.name.type === "SubExpression";
        if (isDynamic) {
          this.accept(partial3.name);
        }
        this.setupFullMustacheParams(partial3, program, void 0, true);
        var indent = partial3.indent || "";
        if (this.options.preventIndent && indent) {
          this.opcode("appendContent", indent);
          indent = "";
        }
        this.opcode("invokePartial", isDynamic, partialName, indent);
        this.opcode("append");
      },
      PartialBlockStatement: function PartialBlockStatement(partialBlock) {
        this.PartialStatement(partialBlock);
      },
      MustacheStatement: function MustacheStatement(mustache) {
        this.SubExpression(mustache);
        if (mustache.escaped && !this.options.noEscape) {
          this.opcode("appendEscaped");
        } else {
          this.opcode("append");
        }
      },
      Decorator: function Decorator(decorator) {
        this.DecoratorBlock(decorator);
      },
      ContentStatement: function ContentStatement(content) {
        if (content.value) {
          this.opcode("appendContent", content.value);
        }
      },
      CommentStatement: function CommentStatement() {
      },
      SubExpression: function SubExpression(sexpr) {
        transformLiteralToPath(sexpr);
        var type = this.classifySexpr(sexpr);
        if (type === "simple") {
          this.simpleSexpr(sexpr);
        } else if (type === "helper") {
          this.helperSexpr(sexpr);
        } else {
          this.ambiguousSexpr(sexpr);
        }
      },
      ambiguousSexpr: function ambiguousSexpr(sexpr, program, inverse) {
        var path33 = sexpr.path, name28 = path33.parts[0], isBlock = program != null || inverse != null;
        this.opcode("getContext", path33.depth);
        this.opcode("pushProgram", program);
        this.opcode("pushProgram", inverse);
        path33.strict = true;
        this.accept(path33);
        this.opcode("invokeAmbiguous", name28, isBlock);
      },
      simpleSexpr: function simpleSexpr(sexpr) {
        var path33 = sexpr.path;
        path33.strict = true;
        this.accept(path33);
        this.opcode("resolvePossibleLambda");
      },
      helperSexpr: function helperSexpr(sexpr, program, inverse) {
        var params = this.setupFullMustacheParams(sexpr, program, inverse), path33 = sexpr.path, name28 = path33.parts[0];
        if (this.options.knownHelpers[name28]) {
          this.opcode("invokeKnownHelper", params.length, name28);
        } else if (this.options.knownHelpersOnly) {
          throw new _exception2["default"]("You specified knownHelpersOnly, but used the unknown helper " + name28, sexpr);
        } else {
          path33.strict = true;
          path33.falsy = true;
          this.accept(path33);
          this.opcode("invokeHelper", params.length, path33.original, _ast2["default"].helpers.simpleId(path33));
        }
      },
      PathExpression: function PathExpression(path33) {
        this.addDepth(path33.depth);
        this.opcode("getContext", path33.depth);
        var name28 = path33.parts[0], scoped = _ast2["default"].helpers.scopedId(path33), blockParamId = !path33.depth && !scoped && this.blockParamIndex(name28);
        if (blockParamId) {
          this.opcode("lookupBlockParam", blockParamId, path33.parts);
        } else if (!name28) {
          this.opcode("pushContext");
        } else if (path33.data) {
          this.options.data = true;
          this.opcode("lookupData", path33.depth, path33.parts, path33.strict);
        } else {
          this.opcode("lookupOnContext", path33.parts, path33.falsy, path33.strict, scoped);
        }
      },
      StringLiteral: function StringLiteral(string5) {
        this.opcode("pushString", string5.value);
      },
      NumberLiteral: function NumberLiteral(number5) {
        this.opcode("pushLiteral", number5.value);
      },
      BooleanLiteral: function BooleanLiteral(bool) {
        this.opcode("pushLiteral", bool.value);
      },
      UndefinedLiteral: function UndefinedLiteral() {
        this.opcode("pushLiteral", "undefined");
      },
      NullLiteral: function NullLiteral() {
        this.opcode("pushLiteral", "null");
      },
      Hash: function Hash2(hash3) {
        var pairs = hash3.pairs, i = 0, l = pairs.length;
        this.opcode("pushHash");
        for (; i < l; i++) {
          this.pushParam(pairs[i].value);
        }
        while (i--) {
          this.opcode("assignToHash", pairs[i].key);
        }
        this.opcode("popHash");
      },
      // HELPERS
      opcode: function opcode(name28) {
        this.opcodes.push({
          opcode: name28,
          args: slice.call(arguments, 1),
          loc: this.sourceNode[0].loc
        });
      },
      addDepth: function addDepth(depth) {
        if (!depth) {
          return;
        }
        this.useDepths = true;
      },
      classifySexpr: function classifySexpr(sexpr) {
        var isSimple = _ast2["default"].helpers.simpleId(sexpr.path);
        var isBlockParam = isSimple && !!this.blockParamIndex(sexpr.path.parts[0]);
        var isHelper = !isBlockParam && _ast2["default"].helpers.helperExpression(sexpr);
        var isEligible = !isBlockParam && (isHelper || isSimple);
        if (isEligible && !isHelper) {
          var _name = sexpr.path.parts[0], options = this.options;
          if (options.knownHelpers[_name]) {
            isHelper = true;
          } else if (options.knownHelpersOnly) {
            isEligible = false;
          }
        }
        if (isHelper) {
          return "helper";
        } else if (isEligible) {
          return "ambiguous";
        } else {
          return "simple";
        }
      },
      pushParams: function pushParams(params) {
        for (var i = 0, l = params.length; i < l; i++) {
          this.pushParam(params[i]);
        }
      },
      pushParam: function pushParam(val) {
        var value = val.value != null ? val.value : val.original || "";
        if (this.stringParams) {
          if (value.replace) {
            value = value.replace(/^(\.?\.\/)*/g, "").replace(/\//g, ".");
          }
          if (val.depth) {
            this.addDepth(val.depth);
          }
          this.opcode("getContext", val.depth || 0);
          this.opcode("pushStringParam", value, val.type);
          if (val.type === "SubExpression") {
            this.accept(val);
          }
        } else {
          if (this.trackIds) {
            var blockParamIndex = void 0;
            if (val.parts && !_ast2["default"].helpers.scopedId(val) && !val.depth) {
              blockParamIndex = this.blockParamIndex(val.parts[0]);
            }
            if (blockParamIndex) {
              var blockParamChild = val.parts.slice(1).join(".");
              this.opcode("pushId", "BlockParam", blockParamIndex, blockParamChild);
            } else {
              value = val.original || value;
              if (value.replace) {
                value = value.replace(/^this(?:\.|$)/, "").replace(/^\.\//, "").replace(/^\.$/, "");
              }
              this.opcode("pushId", val.type, value);
            }
          }
          this.accept(val);
        }
      },
      setupFullMustacheParams: function setupFullMustacheParams(sexpr, program, inverse, omitEmpty) {
        var params = sexpr.params;
        this.pushParams(params);
        this.opcode("pushProgram", program);
        this.opcode("pushProgram", inverse);
        if (sexpr.hash) {
          this.accept(sexpr.hash);
        } else {
          this.opcode("emptyHash", omitEmpty);
        }
        return params;
      },
      blockParamIndex: function blockParamIndex(name28) {
        for (var depth = 0, len = this.options.blockParams.length; depth < len; depth++) {
          var blockParams = this.options.blockParams[depth], param = blockParams && _utils.indexOf(blockParams, name28);
          if (blockParams && param >= 0) {
            return [depth, param];
          }
        }
      }
    };
    function precompile(input, options, env2) {
      if (input == null || typeof input !== "string" && input.type !== "Program") {
        throw new _exception2["default"]("You must pass a string or Handlebars AST to Handlebars.precompile. You passed " + input);
      }
      options = options || {};
      if (!("data" in options)) {
        options.data = true;
      }
      if (options.compat) {
        options.useDepths = true;
      }
      var ast = env2.parse(input, options), environment = new env2.Compiler().compile(ast, options);
      return new env2.JavaScriptCompiler().compile(environment, options);
    }
    function compile(input, options, env2) {
      if (options === void 0) options = {};
      if (input == null || typeof input !== "string" && input.type !== "Program") {
        throw new _exception2["default"]("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input);
      }
      options = _utils.extend({}, options);
      if (!("data" in options)) {
        options.data = true;
      }
      if (options.compat) {
        options.useDepths = true;
      }
      var compiled = void 0;
      function compileInput() {
        var ast = env2.parse(input, options), environment = new env2.Compiler().compile(ast, options), templateSpec = new env2.JavaScriptCompiler().compile(environment, options, void 0, true);
        return env2.template(templateSpec);
      }
      function ret(context2, execOptions) {
        if (!compiled) {
          compiled = compileInput();
        }
        return compiled.call(this, context2, execOptions);
      }
      ret._setup = function(setupOptions) {
        if (!compiled) {
          compiled = compileInput();
        }
        return compiled._setup(setupOptions);
      };
      ret._child = function(i, data, blockParams, depths) {
        if (!compiled) {
          compiled = compileInput();
        }
        return compiled._child(i, data, blockParams, depths);
      };
      return ret;
    }
    function argEquals(a, b) {
      if (a === b) {
        return true;
      }
      if (_utils.isArray(a) && _utils.isArray(b) && a.length === b.length) {
        for (var i = 0; i < a.length; i++) {
          if (!argEquals(a[i], b[i])) {
            return false;
          }
        }
        return true;
      }
    }
    function transformLiteralToPath(sexpr) {
      if (!sexpr.path.parts) {
        var literal3 = sexpr.path;
        sexpr.path = {
          type: "PathExpression",
          data: false,
          depth: 0,
          parts: [literal3.original + ""],
          original: literal3.original + "",
          loc: literal3.loc
        };
      }
    }
  }
});

// node_modules/source-map/lib/base64.js
var require_base64 = __commonJS({
  "node_modules/source-map/lib/base64.js"(exports2) {
    "use strict";
    var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
    exports2.encode = function(number5) {
      if (0 <= number5 && number5 < intToCharMap.length) {
        return intToCharMap[number5];
      }
      throw new TypeError("Must be between 0 and 63: " + number5);
    };
    exports2.decode = function(charCode) {
      var bigA = 65;
      var bigZ = 90;
      var littleA = 97;
      var littleZ = 122;
      var zero = 48;
      var nine = 57;
      var plus = 43;
      var slash = 47;
      var littleOffset = 26;
      var numberOffset = 52;
      if (bigA <= charCode && charCode <= bigZ) {
        return charCode - bigA;
      }
      if (littleA <= charCode && charCode <= littleZ) {
        return charCode - littleA + littleOffset;
      }
      if (zero <= charCode && charCode <= nine) {
        return charCode - zero + numberOffset;
      }
      if (charCode == plus) {
        return 62;
      }
      if (charCode == slash) {
        return 63;
      }
      return -1;
    };
  }
});

// node_modules/source-map/lib/base64-vlq.js
var require_base64_vlq = __commonJS({
  "node_modules/source-map/lib/base64-vlq.js"(exports2) {
    "use strict";
    var base644 = require_base64();
    var VLQ_BASE_SHIFT = 5;
    var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
    var VLQ_BASE_MASK = VLQ_BASE - 1;
    var VLQ_CONTINUATION_BIT = VLQ_BASE;
    function toVLQSigned(aValue) {
      return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
    }
    function fromVLQSigned(aValue) {
      var isNegative = (aValue & 1) === 1;
      var shifted = aValue >> 1;
      return isNegative ? -shifted : shifted;
    }
    exports2.encode = function base64VLQ_encode(aValue) {
      var encoded = "";
      var digit;
      var vlq = toVLQSigned(aValue);
      do {
        digit = vlq & VLQ_BASE_MASK;
        vlq >>>= VLQ_BASE_SHIFT;
        if (vlq > 0) {
          digit |= VLQ_CONTINUATION_BIT;
        }
        encoded += base644.encode(digit);
      } while (vlq > 0);
      return encoded;
    };
    exports2.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
      var strLen = aStr.length;
      var result = 0;
      var shift = 0;
      var continuation, digit;
      do {
        if (aIndex >= strLen) {
          throw new Error("Expected more digits in base 64 VLQ value.");
        }
        digit = base644.decode(aStr.charCodeAt(aIndex++));
        if (digit === -1) {
          throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
        }
        continuation = !!(digit & VLQ_CONTINUATION_BIT);
        digit &= VLQ_BASE_MASK;
        result = result + (digit << shift);
        shift += VLQ_BASE_SHIFT;
      } while (continuation);
      aOutParam.value = fromVLQSigned(result);
      aOutParam.rest = aIndex;
    };
  }
});

// node_modules/source-map/lib/util.js
var require_util3 = __commonJS({
  "node_modules/source-map/lib/util.js"(exports2) {
    "use strict";
    function getArg(aArgs, aName, aDefaultValue) {
      if (aName in aArgs) {
        return aArgs[aName];
      } else if (arguments.length === 3) {
        return aDefaultValue;
      } else {
        throw new Error('"' + aName + '" is a required argument.');
      }
    }
    exports2.getArg = getArg;
    var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
    var dataUrlRegexp = /^data:.+\,.+$/;
    function urlParse(aUrl) {
      var match = aUrl.match(urlRegexp);
      if (!match) {
        return null;
      }
      return {
        scheme: match[1],
        auth: match[2],
        host: match[3],
        port: match[4],
        path: match[5]
      };
    }
    exports2.urlParse = urlParse;
    function urlGenerate(aParsedUrl) {
      var url4 = "";
      if (aParsedUrl.scheme) {
        url4 += aParsedUrl.scheme + ":";
      }
      url4 += "//";
      if (aParsedUrl.auth) {
        url4 += aParsedUrl.auth + "@";
      }
      if (aParsedUrl.host) {
        url4 += aParsedUrl.host;
      }
      if (aParsedUrl.port) {
        url4 += ":" + aParsedUrl.port;
      }
      if (aParsedUrl.path) {
        url4 += aParsedUrl.path;
      }
      return url4;
    }
    exports2.urlGenerate = urlGenerate;
    function normalize(aPath) {
      var path33 = aPath;
      var url4 = urlParse(aPath);
      if (url4) {
        if (!url4.path) {
          return aPath;
        }
        path33 = url4.path;
      }
      var isAbsolute = exports2.isAbsolute(path33);
      var parts = path33.split(/\/+/);
      for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
        part = parts[i];
        if (part === ".") {
          parts.splice(i, 1);
        } else if (part === "..") {
          up++;
        } else if (up > 0) {
          if (part === "") {
            parts.splice(i + 1, up);
            up = 0;
          } else {
            parts.splice(i, 2);
            up--;
          }
        }
      }
      path33 = parts.join("/");
      if (path33 === "") {
        path33 = isAbsolute ? "/" : ".";
      }
      if (url4) {
        url4.path = path33;
        return urlGenerate(url4);
      }
      return path33;
    }
    exports2.normalize = normalize;
    function join2(aRoot, aPath) {
      if (aRoot === "") {
        aRoot = ".";
      }
      if (aPath === "") {
        aPath = ".";
      }
      var aPathUrl = urlParse(aPath);
      var aRootUrl = urlParse(aRoot);
      if (aRootUrl) {
        aRoot = aRootUrl.path || "/";
      }
      if (aPathUrl && !aPathUrl.scheme) {
        if (aRootUrl) {
          aPathUrl.scheme = aRootUrl.scheme;
        }
        return urlGenerate(aPathUrl);
      }
      if (aPathUrl || aPath.match(dataUrlRegexp)) {
        return aPath;
      }
      if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
        aRootUrl.host = aPath;
        return urlGenerate(aRootUrl);
      }
      var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
      if (aRootUrl) {
        aRootUrl.path = joined;
        return urlGenerate(aRootUrl);
      }
      return joined;
    }
    exports2.join = join2;
    exports2.isAbsolute = function(aPath) {
      return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
    };
    function relative(aRoot, aPath) {
      if (aRoot === "") {
        aRoot = ".";
      }
      aRoot = aRoot.replace(/\/$/, "");
      var level = 0;
      while (aPath.indexOf(aRoot + "/") !== 0) {
        var index = aRoot.lastIndexOf("/");
        if (index < 0) {
          return aPath;
        }
        aRoot = aRoot.slice(0, index);
        if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
          return aPath;
        }
        ++level;
      }
      return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
    }
    exports2.relative = relative;
    var supportsNullProto = (function() {
      var obj = /* @__PURE__ */ Object.create(null);
      return !("__proto__" in obj);
    })();
    function identity2(s) {
      return s;
    }
    function toSetString(aStr) {
      if (isProtoString(aStr)) {
        return "$" + aStr;
      }
      return aStr;
    }
    exports2.toSetString = supportsNullProto ? identity2 : toSetString;
    function fromSetString(aStr) {
      if (isProtoString(aStr)) {
        return aStr.slice(1);
      }
      return aStr;
    }
    exports2.fromSetString = supportsNullProto ? identity2 : fromSetString;
    function isProtoString(s) {
      if (!s) {
        return false;
      }
      var length = s.length;
      if (length < 9) {
        return false;
      }
      if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
        return false;
      }
      for (var i = length - 10; i >= 0; i--) {
        if (s.charCodeAt(i) !== 36) {
          return false;
        }
      }
      return true;
    }
    function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
      var cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0 || onlyCompareOriginal) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByOriginalPositions = compareByOriginalPositions;
    function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
      var cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0 || onlyCompareGenerated) {
        return cmp;
      }
      cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
    function strcmp(aStr1, aStr2) {
      if (aStr1 === aStr2) {
        return 0;
      }
      if (aStr1 === null) {
        return 1;
      }
      if (aStr2 === null) {
        return -1;
      }
      if (aStr1 > aStr2) {
        return 1;
      }
      return -1;
    }
    function compareByGeneratedPositionsInflated(mappingA, mappingB) {
      var cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp !== 0) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp !== 0) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    exports2.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
    function parseSourceMapInput(str) {
      return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
    }
    exports2.parseSourceMapInput = parseSourceMapInput;
    function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
      sourceURL = sourceURL || "";
      if (sourceRoot) {
        if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
          sourceRoot += "/";
        }
        sourceURL = sourceRoot + sourceURL;
      }
      if (sourceMapURL) {
        var parsed = urlParse(sourceMapURL);
        if (!parsed) {
          throw new Error("sourceMapURL could not be parsed");
        }
        if (parsed.path) {
          var index = parsed.path.lastIndexOf("/");
          if (index >= 0) {
            parsed.path = parsed.path.substring(0, index + 1);
          }
        }
        sourceURL = join2(urlGenerate(parsed), sourceURL);
      }
      return normalize(sourceURL);
    }
    exports2.computeSourceURL = computeSourceURL;
  }
});

// node_modules/source-map/lib/array-set.js
var require_array_set = __commonJS({
  "node_modules/source-map/lib/array-set.js"(exports2) {
    "use strict";
    var util4 = require_util3();
    var has = Object.prototype.hasOwnProperty;
    var hasNativeMap = typeof Map !== "undefined";
    function ArraySet() {
      this._array = [];
      this._set = hasNativeMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null);
    }
    ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
      var set3 = new ArraySet();
      for (var i = 0, len = aArray.length; i < len; i++) {
        set3.add(aArray[i], aAllowDuplicates);
      }
      return set3;
    };
    ArraySet.prototype.size = function ArraySet_size() {
      return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
    };
    ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
      var sStr = hasNativeMap ? aStr : util4.toSetString(aStr);
      var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
      var idx = this._array.length;
      if (!isDuplicate || aAllowDuplicates) {
        this._array.push(aStr);
      }
      if (!isDuplicate) {
        if (hasNativeMap) {
          this._set.set(aStr, idx);
        } else {
          this._set[sStr] = idx;
        }
      }
    };
    ArraySet.prototype.has = function ArraySet_has(aStr) {
      if (hasNativeMap) {
        return this._set.has(aStr);
      } else {
        var sStr = util4.toSetString(aStr);
        return has.call(this._set, sStr);
      }
    };
    ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
      if (hasNativeMap) {
        var idx = this._set.get(aStr);
        if (idx >= 0) {
          return idx;
        }
      } else {
        var sStr = util4.toSetString(aStr);
        if (has.call(this._set, sStr)) {
          return this._set[sStr];
        }
      }
      throw new Error('"' + aStr + '" is not in the set.');
    };
    ArraySet.prototype.at = function ArraySet_at(aIdx) {
      if (aIdx >= 0 && aIdx < this._array.length) {
        return this._array[aIdx];
      }
      throw new Error("No element indexed by " + aIdx);
    };
    ArraySet.prototype.toArray = function ArraySet_toArray() {
      return this._array.slice();
    };
    exports2.ArraySet = ArraySet;
  }
});

// node_modules/source-map/lib/mapping-list.js
var require_mapping_list = __commonJS({
  "node_modules/source-map/lib/mapping-list.js"(exports2) {
    "use strict";
    var util4 = require_util3();
    function generatedPositionAfter(mappingA, mappingB) {
      var lineA = mappingA.generatedLine;
      var lineB = mappingB.generatedLine;
      var columnA = mappingA.generatedColumn;
      var columnB = mappingB.generatedColumn;
      return lineB > lineA || lineB == lineA && columnB >= columnA || util4.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
    }
    function MappingList() {
      this._array = [];
      this._sorted = true;
      this._last = { generatedLine: -1, generatedColumn: 0 };
    }
    MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
      this._array.forEach(aCallback, aThisArg);
    };
    MappingList.prototype.add = function MappingList_add(aMapping) {
      if (generatedPositionAfter(this._last, aMapping)) {
        this._last = aMapping;
        this._array.push(aMapping);
      } else {
        this._sorted = false;
        this._array.push(aMapping);
      }
    };
    MappingList.prototype.toArray = function MappingList_toArray() {
      if (!this._sorted) {
        this._array.sort(util4.compareByGeneratedPositionsInflated);
        this._sorted = true;
      }
      return this._array;
    };
    exports2.MappingList = MappingList;
  }
});

// node_modules/source-map/lib/source-map-generator.js
var require_source_map_generator = __commonJS({
  "node_modules/source-map/lib/source-map-generator.js"(exports2) {
    "use strict";
    var base64VLQ = require_base64_vlq();
    var util4 = require_util3();
    var ArraySet = require_array_set().ArraySet;
    var MappingList = require_mapping_list().MappingList;
    function SourceMapGenerator(aArgs) {
      if (!aArgs) {
        aArgs = {};
      }
      this._file = util4.getArg(aArgs, "file", null);
      this._sourceRoot = util4.getArg(aArgs, "sourceRoot", null);
      this._skipValidation = util4.getArg(aArgs, "skipValidation", false);
      this._sources = new ArraySet();
      this._names = new ArraySet();
      this._mappings = new MappingList();
      this._sourcesContents = null;
    }
    SourceMapGenerator.prototype._version = 3;
    SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
      var sourceRoot = aSourceMapConsumer.sourceRoot;
      var generator = new SourceMapGenerator({
        file: aSourceMapConsumer.file,
        sourceRoot
      });
      aSourceMapConsumer.eachMapping(function(mapping) {
        var newMapping = {
          generated: {
            line: mapping.generatedLine,
            column: mapping.generatedColumn
          }
        };
        if (mapping.source != null) {
          newMapping.source = mapping.source;
          if (sourceRoot != null) {
            newMapping.source = util4.relative(sourceRoot, newMapping.source);
          }
          newMapping.original = {
            line: mapping.originalLine,
            column: mapping.originalColumn
          };
          if (mapping.name != null) {
            newMapping.name = mapping.name;
          }
        }
        generator.addMapping(newMapping);
      });
      aSourceMapConsumer.sources.forEach(function(sourceFile) {
        var sourceRelative = sourceFile;
        if (sourceRoot !== null) {
          sourceRelative = util4.relative(sourceRoot, sourceFile);
        }
        if (!generator._sources.has(sourceRelative)) {
          generator._sources.add(sourceRelative);
        }
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content != null) {
          generator.setSourceContent(sourceFile, content);
        }
      });
      return generator;
    };
    SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
      var generated = util4.getArg(aArgs, "generated");
      var original = util4.getArg(aArgs, "original", null);
      var source = util4.getArg(aArgs, "source", null);
      var name28 = util4.getArg(aArgs, "name", null);
      if (!this._skipValidation) {
        this._validateMapping(generated, original, source, name28);
      }
      if (source != null) {
        source = String(source);
        if (!this._sources.has(source)) {
          this._sources.add(source);
        }
      }
      if (name28 != null) {
        name28 = String(name28);
        if (!this._names.has(name28)) {
          this._names.add(name28);
        }
      }
      this._mappings.add({
        generatedLine: generated.line,
        generatedColumn: generated.column,
        originalLine: original != null && original.line,
        originalColumn: original != null && original.column,
        source,
        name: name28
      });
    };
    SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
      var source = aSourceFile;
      if (this._sourceRoot != null) {
        source = util4.relative(this._sourceRoot, source);
      }
      if (aSourceContent != null) {
        if (!this._sourcesContents) {
          this._sourcesContents = /* @__PURE__ */ Object.create(null);
        }
        this._sourcesContents[util4.toSetString(source)] = aSourceContent;
      } else if (this._sourcesContents) {
        delete this._sourcesContents[util4.toSetString(source)];
        if (Object.keys(this._sourcesContents).length === 0) {
          this._sourcesContents = null;
        }
      }
    };
    SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
      var sourceFile = aSourceFile;
      if (aSourceFile == null) {
        if (aSourceMapConsumer.file == null) {
          throw new Error(
            `SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`
          );
        }
        sourceFile = aSourceMapConsumer.file;
      }
      var sourceRoot = this._sourceRoot;
      if (sourceRoot != null) {
        sourceFile = util4.relative(sourceRoot, sourceFile);
      }
      var newSources = new ArraySet();
      var newNames = new ArraySet();
      this._mappings.unsortedForEach(function(mapping) {
        if (mapping.source === sourceFile && mapping.originalLine != null) {
          var original = aSourceMapConsumer.originalPositionFor({
            line: mapping.originalLine,
            column: mapping.originalColumn
          });
          if (original.source != null) {
            mapping.source = original.source;
            if (aSourceMapPath != null) {
              mapping.source = util4.join(aSourceMapPath, mapping.source);
            }
            if (sourceRoot != null) {
              mapping.source = util4.relative(sourceRoot, mapping.source);
            }
            mapping.originalLine = original.line;
            mapping.originalColumn = original.column;
            if (original.name != null) {
              mapping.name = original.name;
            }
          }
        }
        var source = mapping.source;
        if (source != null && !newSources.has(source)) {
          newSources.add(source);
        }
        var name28 = mapping.name;
        if (name28 != null && !newNames.has(name28)) {
          newNames.add(name28);
        }
      }, this);
      this._sources = newSources;
      this._names = newNames;
      aSourceMapConsumer.sources.forEach(function(sourceFile2) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile2);
        if (content != null) {
          if (aSourceMapPath != null) {
            sourceFile2 = util4.join(aSourceMapPath, sourceFile2);
          }
          if (sourceRoot != null) {
            sourceFile2 = util4.relative(sourceRoot, sourceFile2);
          }
          this.setSourceContent(sourceFile2, content);
        }
      }, this);
    };
    SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
      if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
        throw new Error(
          "original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values."
        );
      }
      if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
        return;
      } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
        return;
      } else {
        throw new Error("Invalid mapping: " + JSON.stringify({
          generated: aGenerated,
          source: aSource,
          original: aOriginal,
          name: aName
        }));
      }
    };
    SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
      var previousGeneratedColumn = 0;
      var previousGeneratedLine = 1;
      var previousOriginalColumn = 0;
      var previousOriginalLine = 0;
      var previousName = 0;
      var previousSource = 0;
      var result = "";
      var next;
      var mapping;
      var nameIdx;
      var sourceIdx;
      var mappings = this._mappings.toArray();
      for (var i = 0, len = mappings.length; i < len; i++) {
        mapping = mappings[i];
        next = "";
        if (mapping.generatedLine !== previousGeneratedLine) {
          previousGeneratedColumn = 0;
          while (mapping.generatedLine !== previousGeneratedLine) {
            next += ";";
            previousGeneratedLine++;
          }
        } else {
          if (i > 0) {
            if (!util4.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
              continue;
            }
            next += ",";
          }
        }
        next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
        previousGeneratedColumn = mapping.generatedColumn;
        if (mapping.source != null) {
          sourceIdx = this._sources.indexOf(mapping.source);
          next += base64VLQ.encode(sourceIdx - previousSource);
          previousSource = sourceIdx;
          next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
          previousOriginalLine = mapping.originalLine - 1;
          next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
          previousOriginalColumn = mapping.originalColumn;
          if (mapping.name != null) {
            nameIdx = this._names.indexOf(mapping.name);
            next += base64VLQ.encode(nameIdx - previousName);
            previousName = nameIdx;
          }
        }
        result += next;
      }
      return result;
    };
    SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
      return aSources.map(function(source) {
        if (!this._sourcesContents) {
          return null;
        }
        if (aSourceRoot != null) {
          source = util4.relative(aSourceRoot, source);
        }
        var key = util4.toSetString(source);
        return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
      }, this);
    };
    SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
      var map3 = {
        version: this._version,
        sources: this._sources.toArray(),
        names: this._names.toArray(),
        mappings: this._serializeMappings()
      };
      if (this._file != null) {
        map3.file = this._file;
      }
      if (this._sourceRoot != null) {
        map3.sourceRoot = this._sourceRoot;
      }
      if (this._sourcesContents) {
        map3.sourcesContent = this._generateSourcesContent(map3.sources, map3.sourceRoot);
      }
      return map3;
    };
    SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
      return JSON.stringify(this.toJSON());
    };
    exports2.SourceMapGenerator = SourceMapGenerator;
  }
});

// node_modules/source-map/lib/binary-search.js
var require_binary_search = __commonJS({
  "node_modules/source-map/lib/binary-search.js"(exports2) {
    "use strict";
    exports2.GREATEST_LOWER_BOUND = 1;
    exports2.LEAST_UPPER_BOUND = 2;
    function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
      var mid = Math.floor((aHigh - aLow) / 2) + aLow;
      var cmp = aCompare(aNeedle, aHaystack[mid], true);
      if (cmp === 0) {
        return mid;
      } else if (cmp > 0) {
        if (aHigh - mid > 1) {
          return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
        }
        if (aBias == exports2.LEAST_UPPER_BOUND) {
          return aHigh < aHaystack.length ? aHigh : -1;
        } else {
          return mid;
        }
      } else {
        if (mid - aLow > 1) {
          return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
        }
        if (aBias == exports2.LEAST_UPPER_BOUND) {
          return mid;
        } else {
          return aLow < 0 ? -1 : aLow;
        }
      }
    }
    exports2.search = function search(aNeedle, aHaystack, aCompare, aBias) {
      if (aHaystack.length === 0) {
        return -1;
      }
      var index = recursiveSearch(
        -1,
        aHaystack.length,
        aNeedle,
        aHaystack,
        aCompare,
        aBias || exports2.GREATEST_LOWER_BOUND
      );
      if (index < 0) {
        return -1;
      }
      while (index - 1 >= 0) {
        if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
          break;
        }
        --index;
      }
      return index;
    };
  }
});

// node_modules/source-map/lib/quick-sort.js
var require_quick_sort = __commonJS({
  "node_modules/source-map/lib/quick-sort.js"(exports2) {
    "use strict";
    function swap(ary, x, y) {
      var temp = ary[x];
      ary[x] = ary[y];
      ary[y] = temp;
    }
    function randomIntInRange(low, high) {
      return Math.round(low + Math.random() * (high - low));
    }
    function doQuickSort(ary, comparator, p3, r) {
      if (p3 < r) {
        var pivotIndex = randomIntInRange(p3, r);
        var i = p3 - 1;
        swap(ary, pivotIndex, r);
        var pivot = ary[r];
        for (var j = p3; j < r; j++) {
          if (comparator(ary[j], pivot) <= 0) {
            i += 1;
            swap(ary, i, j);
          }
        }
        swap(ary, i + 1, j);
        var q = i + 1;
        doQuickSort(ary, comparator, p3, q - 1);
        doQuickSort(ary, comparator, q + 1, r);
      }
    }
    exports2.quickSort = function(ary, comparator) {
      doQuickSort(ary, comparator, 0, ary.length - 1);
    };
  }
});

// node_modules/source-map/lib/source-map-consumer.js
var require_source_map_consumer = __commonJS({
  "node_modules/source-map/lib/source-map-consumer.js"(exports2) {
    "use strict";
    var util4 = require_util3();
    var binarySearch = require_binary_search();
    var ArraySet = require_array_set().ArraySet;
    var base64VLQ = require_base64_vlq();
    var quickSort = require_quick_sort().quickSort;
    function SourceMapConsumer(aSourceMap, aSourceMapURL) {
      var sourceMap = aSourceMap;
      if (typeof aSourceMap === "string") {
        sourceMap = util4.parseSourceMapInput(aSourceMap);
      }
      return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
    }
    SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
      return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
    };
    SourceMapConsumer.prototype._version = 3;
    SourceMapConsumer.prototype.__generatedMappings = null;
    Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
      configurable: true,
      enumerable: true,
      get: function() {
        if (!this.__generatedMappings) {
          this._parseMappings(this._mappings, this.sourceRoot);
        }
        return this.__generatedMappings;
      }
    });
    SourceMapConsumer.prototype.__originalMappings = null;
    Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
      configurable: true,
      enumerable: true,
      get: function() {
        if (!this.__originalMappings) {
          this._parseMappings(this._mappings, this.sourceRoot);
        }
        return this.__originalMappings;
      }
    });
    SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
      var c = aStr.charAt(index);
      return c === ";" || c === ",";
    };
    SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
      throw new Error("Subclasses must implement _parseMappings");
    };
    SourceMapConsumer.GENERATED_ORDER = 1;
    SourceMapConsumer.ORIGINAL_ORDER = 2;
    SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
    SourceMapConsumer.LEAST_UPPER_BOUND = 2;
    SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
      var context2 = aContext || null;
      var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
      var mappings;
      switch (order) {
        case SourceMapConsumer.GENERATED_ORDER:
          mappings = this._generatedMappings;
          break;
        case SourceMapConsumer.ORIGINAL_ORDER:
          mappings = this._originalMappings;
          break;
        default:
          throw new Error("Unknown order of iteration.");
      }
      var sourceRoot = this.sourceRoot;
      mappings.map(function(mapping) {
        var source = mapping.source === null ? null : this._sources.at(mapping.source);
        source = util4.computeSourceURL(sourceRoot, source, this._sourceMapURL);
        return {
          source,
          generatedLine: mapping.generatedLine,
          generatedColumn: mapping.generatedColumn,
          originalLine: mapping.originalLine,
          originalColumn: mapping.originalColumn,
          name: mapping.name === null ? null : this._names.at(mapping.name)
        };
      }, this).forEach(aCallback, context2);
    };
    SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
      var line = util4.getArg(aArgs, "line");
      var needle = {
        source: util4.getArg(aArgs, "source"),
        originalLine: line,
        originalColumn: util4.getArg(aArgs, "column", 0)
      };
      needle.source = this._findSourceIndex(needle.source);
      if (needle.source < 0) {
        return [];
      }
      var mappings = [];
      var index = this._findMapping(
        needle,
        this._originalMappings,
        "originalLine",
        "originalColumn",
        util4.compareByOriginalPositions,
        binarySearch.LEAST_UPPER_BOUND
      );
      if (index >= 0) {
        var mapping = this._originalMappings[index];
        if (aArgs.column === void 0) {
          var originalLine = mapping.originalLine;
          while (mapping && mapping.originalLine === originalLine) {
            mappings.push({
              line: util4.getArg(mapping, "generatedLine", null),
              column: util4.getArg(mapping, "generatedColumn", null),
              lastColumn: util4.getArg(mapping, "lastGeneratedColumn", null)
            });
            mapping = this._originalMappings[++index];
          }
        } else {
          var originalColumn = mapping.originalColumn;
          while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
            mappings.push({
              line: util4.getArg(mapping, "generatedLine", null),
              column: util4.getArg(mapping, "generatedColumn", null),
              lastColumn: util4.getArg(mapping, "lastGeneratedColumn", null)
            });
            mapping = this._originalMappings[++index];
          }
        }
      }
      return mappings;
    };
    exports2.SourceMapConsumer = SourceMapConsumer;
    function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
      var sourceMap = aSourceMap;
      if (typeof aSourceMap === "string") {
        sourceMap = util4.parseSourceMapInput(aSourceMap);
      }
      var version3 = util4.getArg(sourceMap, "version");
      var sources = util4.getArg(sourceMap, "sources");
      var names = util4.getArg(sourceMap, "names", []);
      var sourceRoot = util4.getArg(sourceMap, "sourceRoot", null);
      var sourcesContent = util4.getArg(sourceMap, "sourcesContent", null);
      var mappings = util4.getArg(sourceMap, "mappings");
      var file3 = util4.getArg(sourceMap, "file", null);
      if (version3 != this._version) {
        throw new Error("Unsupported version: " + version3);
      }
      if (sourceRoot) {
        sourceRoot = util4.normalize(sourceRoot);
      }
      sources = sources.map(String).map(util4.normalize).map(function(source) {
        return sourceRoot && util4.isAbsolute(sourceRoot) && util4.isAbsolute(source) ? util4.relative(sourceRoot, source) : source;
      });
      this._names = ArraySet.fromArray(names.map(String), true);
      this._sources = ArraySet.fromArray(sources, true);
      this._absoluteSources = this._sources.toArray().map(function(s) {
        return util4.computeSourceURL(sourceRoot, s, aSourceMapURL);
      });
      this.sourceRoot = sourceRoot;
      this.sourcesContent = sourcesContent;
      this._mappings = mappings;
      this._sourceMapURL = aSourceMapURL;
      this.file = file3;
    }
    BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
    BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
    BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
      var relativeSource = aSource;
      if (this.sourceRoot != null) {
        relativeSource = util4.relative(this.sourceRoot, relativeSource);
      }
      if (this._sources.has(relativeSource)) {
        return this._sources.indexOf(relativeSource);
      }
      var i;
      for (i = 0; i < this._absoluteSources.length; ++i) {
        if (this._absoluteSources[i] == aSource) {
          return i;
        }
      }
      return -1;
    };
    BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
      var smc = Object.create(BasicSourceMapConsumer.prototype);
      var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
      var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
      smc.sourceRoot = aSourceMap._sourceRoot;
      smc.sourcesContent = aSourceMap._generateSourcesContent(
        smc._sources.toArray(),
        smc.sourceRoot
      );
      smc.file = aSourceMap._file;
      smc._sourceMapURL = aSourceMapURL;
      smc._absoluteSources = smc._sources.toArray().map(function(s) {
        return util4.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
      });
      var generatedMappings = aSourceMap._mappings.toArray().slice();
      var destGeneratedMappings = smc.__generatedMappings = [];
      var destOriginalMappings = smc.__originalMappings = [];
      for (var i = 0, length = generatedMappings.length; i < length; i++) {
        var srcMapping = generatedMappings[i];
        var destMapping = new Mapping();
        destMapping.generatedLine = srcMapping.generatedLine;
        destMapping.generatedColumn = srcMapping.generatedColumn;
        if (srcMapping.source) {
          destMapping.source = sources.indexOf(srcMapping.source);
          destMapping.originalLine = srcMapping.originalLine;
          destMapping.originalColumn = srcMapping.originalColumn;
          if (srcMapping.name) {
            destMapping.name = names.indexOf(srcMapping.name);
          }
          destOriginalMappings.push(destMapping);
        }
        destGeneratedMappings.push(destMapping);
      }
      quickSort(smc.__originalMappings, util4.compareByOriginalPositions);
      return smc;
    };
    BasicSourceMapConsumer.prototype._version = 3;
    Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", {
      get: function() {
        return this._absoluteSources.slice();
      }
    });
    function Mapping() {
      this.generatedLine = 0;
      this.generatedColumn = 0;
      this.source = null;
      this.originalLine = null;
      this.originalColumn = null;
      this.name = null;
    }
    BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
      var generatedLine = 1;
      var previousGeneratedColumn = 0;
      var previousOriginalLine = 0;
      var previousOriginalColumn = 0;
      var previousSource = 0;
      var previousName = 0;
      var length = aStr.length;
      var index = 0;
      var cachedSegments = {};
      var temp = {};
      var originalMappings = [];
      var generatedMappings = [];
      var mapping, str, segment, end, value;
      while (index < length) {
        if (aStr.charAt(index) === ";") {
          generatedLine++;
          index++;
          previousGeneratedColumn = 0;
        } else if (aStr.charAt(index) === ",") {
          index++;
        } else {
          mapping = new Mapping();
          mapping.generatedLine = generatedLine;
          for (end = index; end < length; end++) {
            if (this._charIsMappingSeparator(aStr, end)) {
              break;
            }
          }
          str = aStr.slice(index, end);
          segment = cachedSegments[str];
          if (segment) {
            index += str.length;
          } else {
            segment = [];
            while (index < end) {
              base64VLQ.decode(aStr, index, temp);
              value = temp.value;
              index = temp.rest;
              segment.push(value);
            }
            if (segment.length === 2) {
              throw new Error("Found a source, but no line and column");
            }
            if (segment.length === 3) {
              throw new Error("Found a source and line, but no column");
            }
            cachedSegments[str] = segment;
          }
          mapping.generatedColumn = previousGeneratedColumn + segment[0];
          previousGeneratedColumn = mapping.generatedColumn;
          if (segment.length > 1) {
            mapping.source = previousSource + segment[1];
            previousSource += segment[1];
            mapping.originalLine = previousOriginalLine + segment[2];
            previousOriginalLine = mapping.originalLine;
            mapping.originalLine += 1;
            mapping.originalColumn = previousOriginalColumn + segment[3];
            previousOriginalColumn = mapping.originalColumn;
            if (segment.length > 4) {
              mapping.name = previousName + segment[4];
              previousName += segment[4];
            }
          }
          generatedMappings.push(mapping);
          if (typeof mapping.originalLine === "number") {
            originalMappings.push(mapping);
          }
        }
      }
      quickSort(generatedMappings, util4.compareByGeneratedPositionsDeflated);
      this.__generatedMappings = generatedMappings;
      quickSort(originalMappings, util4.compareByOriginalPositions);
      this.__originalMappings = originalMappings;
    };
    BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
      if (aNeedle[aLineName] <= 0) {
        throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
      }
      if (aNeedle[aColumnName] < 0) {
        throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
      }
      return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
    };
    BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
      for (var index = 0; index < this._generatedMappings.length; ++index) {
        var mapping = this._generatedMappings[index];
        if (index + 1 < this._generatedMappings.length) {
          var nextMapping = this._generatedMappings[index + 1];
          if (mapping.generatedLine === nextMapping.generatedLine) {
            mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
            continue;
          }
        }
        mapping.lastGeneratedColumn = Infinity;
      }
    };
    BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
      var needle = {
        generatedLine: util4.getArg(aArgs, "line"),
        generatedColumn: util4.getArg(aArgs, "column")
      };
      var index = this._findMapping(
        needle,
        this._generatedMappings,
        "generatedLine",
        "generatedColumn",
        util4.compareByGeneratedPositionsDeflated,
        util4.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
      );
      if (index >= 0) {
        var mapping = this._generatedMappings[index];
        if (mapping.generatedLine === needle.generatedLine) {
          var source = util4.getArg(mapping, "source", null);
          if (source !== null) {
            source = this._sources.at(source);
            source = util4.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
          }
          var name28 = util4.getArg(mapping, "name", null);
          if (name28 !== null) {
            name28 = this._names.at(name28);
          }
          return {
            source,
            line: util4.getArg(mapping, "originalLine", null),
            column: util4.getArg(mapping, "originalColumn", null),
            name: name28
          };
        }
      }
      return {
        source: null,
        line: null,
        column: null,
        name: null
      };
    };
    BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
      if (!this.sourcesContent) {
        return false;
      }
      return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
        return sc == null;
      });
    };
    BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
      if (!this.sourcesContent) {
        return null;
      }
      var index = this._findSourceIndex(aSource);
      if (index >= 0) {
        return this.sourcesContent[index];
      }
      var relativeSource = aSource;
      if (this.sourceRoot != null) {
        relativeSource = util4.relative(this.sourceRoot, relativeSource);
      }
      var url4;
      if (this.sourceRoot != null && (url4 = util4.urlParse(this.sourceRoot))) {
        var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
        if (url4.scheme == "file" && this._sources.has(fileUriAbsPath)) {
          return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
        }
        if ((!url4.path || url4.path == "/") && this._sources.has("/" + relativeSource)) {
          return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
        }
      }
      if (nullOnMissing) {
        return null;
      } else {
        throw new Error('"' + relativeSource + '" is not in the SourceMap.');
      }
    };
    BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
      var source = util4.getArg(aArgs, "source");
      source = this._findSourceIndex(source);
      if (source < 0) {
        return {
          line: null,
          column: null,
          lastColumn: null
        };
      }
      var needle = {
        source,
        originalLine: util4.getArg(aArgs, "line"),
        originalColumn: util4.getArg(aArgs, "column")
      };
      var index = this._findMapping(
        needle,
        this._originalMappings,
        "originalLine",
        "originalColumn",
        util4.compareByOriginalPositions,
        util4.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
      );
      if (index >= 0) {
        var mapping = this._originalMappings[index];
        if (mapping.source === needle.source) {
          return {
            line: util4.getArg(mapping, "generatedLine", null),
            column: util4.getArg(mapping, "generatedColumn", null),
            lastColumn: util4.getArg(mapping, "lastGeneratedColumn", null)
          };
        }
      }
      return {
        line: null,
        column: null,
        lastColumn: null
      };
    };
    exports2.BasicSourceMapConsumer = BasicSourceMapConsumer;
    function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
      var sourceMap = aSourceMap;
      if (typeof aSourceMap === "string") {
        sourceMap = util4.parseSourceMapInput(aSourceMap);
      }
      var version3 = util4.getArg(sourceMap, "version");
      var sections = util4.getArg(sourceMap, "sections");
      if (version3 != this._version) {
        throw new Error("Unsupported version: " + version3);
      }
      this._sources = new ArraySet();
      this._names = new ArraySet();
      var lastOffset = {
        line: -1,
        column: 0
      };
      this._sections = sections.map(function(s) {
        if (s.url) {
          throw new Error("Support for url field in sections not implemented.");
        }
        var offset = util4.getArg(s, "offset");
        var offsetLine = util4.getArg(offset, "line");
        var offsetColumn = util4.getArg(offset, "column");
        if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
          throw new Error("Section offsets must be ordered and non-overlapping.");
        }
        lastOffset = offset;
        return {
          generatedOffset: {
            // The offset fields are 0-based, but we use 1-based indices when
            // encoding/decoding from VLQ.
            generatedLine: offsetLine + 1,
            generatedColumn: offsetColumn + 1
          },
          consumer: new SourceMapConsumer(util4.getArg(s, "map"), aSourceMapURL)
        };
      });
    }
    IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
    IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
    IndexedSourceMapConsumer.prototype._version = 3;
    Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", {
      get: function() {
        var sources = [];
        for (var i = 0; i < this._sections.length; i++) {
          for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
            sources.push(this._sections[i].consumer.sources[j]);
          }
        }
        return sources;
      }
    });
    IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
      var needle = {
        generatedLine: util4.getArg(aArgs, "line"),
        generatedColumn: util4.getArg(aArgs, "column")
      };
      var sectionIndex = binarySearch.search(
        needle,
        this._sections,
        function(needle2, section2) {
          var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine;
          if (cmp) {
            return cmp;
          }
          return needle2.generatedColumn - section2.generatedOffset.generatedColumn;
        }
      );
      var section = this._sections[sectionIndex];
      if (!section) {
        return {
          source: null,
          line: null,
          column: null,
          name: null
        };
      }
      return section.consumer.originalPositionFor({
        line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
        column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
        bias: aArgs.bias
      });
    };
    IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
      return this._sections.every(function(s) {
        return s.consumer.hasContentsOfAllSources();
      });
    };
    IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
      for (var i = 0; i < this._sections.length; i++) {
        var section = this._sections[i];
        var content = section.consumer.sourceContentFor(aSource, true);
        if (content) {
          return content;
        }
      }
      if (nullOnMissing) {
        return null;
      } else {
        throw new Error('"' + aSource + '" is not in the SourceMap.');
      }
    };
    IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
      for (var i = 0; i < this._sections.length; i++) {
        var section = this._sections[i];
        if (section.consumer._findSourceIndex(util4.getArg(aArgs, "source")) === -1) {
          continue;
        }
        var generatedPosition = section.consumer.generatedPositionFor(aArgs);
        if (generatedPosition) {
          var ret = {
            line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
            column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
          };
          return ret;
        }
      }
      return {
        line: null,
        column: null
      };
    };
    IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
      this.__generatedMappings = [];
      this.__originalMappings = [];
      for (var i = 0; i < this._sections.length; i++) {
        var section = this._sections[i];
        var sectionMappings = section.consumer._generatedMappings;
        for (var j = 0; j < sectionMappings.length; j++) {
          var mapping = sectionMappings[j];
          var source = section.consumer._sources.at(mapping.source);
          source = util4.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
          this._sources.add(source);
          source = this._sources.indexOf(source);
          var name28 = null;
          if (mapping.name) {
            name28 = section.consumer._names.at(mapping.name);
            this._names.add(name28);
            name28 = this._names.indexOf(name28);
          }
          var adjustedMapping = {
            source,
            generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
            generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
            originalLine: mapping.originalLine,
            originalColumn: mapping.originalColumn,
            name: name28
          };
          this.__generatedMappings.push(adjustedMapping);
          if (typeof adjustedMapping.originalLine === "number") {
            this.__originalMappings.push(adjustedMapping);
          }
        }
      }
      quickSort(this.__generatedMappings, util4.compareByGeneratedPositionsDeflated);
      quickSort(this.__originalMappings, util4.compareByOriginalPositions);
    };
    exports2.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
  }
});

// node_modules/source-map/lib/source-node.js
var require_source_node = __commonJS({
  "node_modules/source-map/lib/source-node.js"(exports2) {
    "use strict";
    var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
    var util4 = require_util3();
    var REGEX_NEWLINE = /(\r?\n)/;
    var NEWLINE_CODE = 10;
    var isSourceNode = "$$$isSourceNode$$$";
    function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
      this.children = [];
      this.sourceContents = {};
      this.line = aLine == null ? null : aLine;
      this.column = aColumn == null ? null : aColumn;
      this.source = aSource == null ? null : aSource;
      this.name = aName == null ? null : aName;
      this[isSourceNode] = true;
      if (aChunks != null) this.add(aChunks);
    }
    SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
      var node = new SourceNode();
      var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
      var remainingLinesIndex = 0;
      var shiftNextLine = function() {
        var lineContents = getNextLine();
        var newLine = getNextLine() || "";
        return lineContents + newLine;
        function getNextLine() {
          return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0;
        }
      };
      var lastGeneratedLine = 1, lastGeneratedColumn = 0;
      var lastMapping = null;
      aSourceMapConsumer.eachMapping(function(mapping) {
        if (lastMapping !== null) {
          if (lastGeneratedLine < mapping.generatedLine) {
            addMappingWithCode(lastMapping, shiftNextLine());
            lastGeneratedLine++;
            lastGeneratedColumn = 0;
          } else {
            var nextLine = remainingLines[remainingLinesIndex] || "";
            var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
            remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
            lastGeneratedColumn = mapping.generatedColumn;
            addMappingWithCode(lastMapping, code);
            lastMapping = mapping;
            return;
          }
        }
        while (lastGeneratedLine < mapping.generatedLine) {
          node.add(shiftNextLine());
          lastGeneratedLine++;
        }
        if (lastGeneratedColumn < mapping.generatedColumn) {
          var nextLine = remainingLines[remainingLinesIndex] || "";
          node.add(nextLine.substr(0, mapping.generatedColumn));
          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
          lastGeneratedColumn = mapping.generatedColumn;
        }
        lastMapping = mapping;
      }, this);
      if (remainingLinesIndex < remainingLines.length) {
        if (lastMapping) {
          addMappingWithCode(lastMapping, shiftNextLine());
        }
        node.add(remainingLines.splice(remainingLinesIndex).join(""));
      }
      aSourceMapConsumer.sources.forEach(function(sourceFile) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content != null) {
          if (aRelativePath != null) {
            sourceFile = util4.join(aRelativePath, sourceFile);
          }
          node.setSourceContent(sourceFile, content);
        }
      });
      return node;
      function addMappingWithCode(mapping, code) {
        if (mapping === null || mapping.source === void 0) {
          node.add(code);
        } else {
          var source = aRelativePath ? util4.join(aRelativePath, mapping.source) : mapping.source;
          node.add(new SourceNode(
            mapping.originalLine,
            mapping.originalColumn,
            source,
            code,
            mapping.name
          ));
        }
      }
    };
    SourceNode.prototype.add = function SourceNode_add(aChunk) {
      if (Array.isArray(aChunk)) {
        aChunk.forEach(function(chunk) {
          this.add(chunk);
        }, this);
      } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
        if (aChunk) {
          this.children.push(aChunk);
        }
      } else {
        throw new TypeError(
          "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
        );
      }
      return this;
    };
    SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
      if (Array.isArray(aChunk)) {
        for (var i = aChunk.length - 1; i >= 0; i--) {
          this.prepend(aChunk[i]);
        }
      } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
        this.children.unshift(aChunk);
      } else {
        throw new TypeError(
          "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
        );
      }
      return this;
    };
    SourceNode.prototype.walk = function SourceNode_walk(aFn) {
      var chunk;
      for (var i = 0, len = this.children.length; i < len; i++) {
        chunk = this.children[i];
        if (chunk[isSourceNode]) {
          chunk.walk(aFn);
        } else {
          if (chunk !== "") {
            aFn(chunk, {
              source: this.source,
              line: this.line,
              column: this.column,
              name: this.name
            });
          }
        }
      }
    };
    SourceNode.prototype.join = function SourceNode_join(aSep) {
      var newChildren;
      var i;
      var len = this.children.length;
      if (len > 0) {
        newChildren = [];
        for (i = 0; i < len - 1; i++) {
          newChildren.push(this.children[i]);
          newChildren.push(aSep);
        }
        newChildren.push(this.children[i]);
        this.children = newChildren;
      }
      return this;
    };
    SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
      var lastChild = this.children[this.children.length - 1];
      if (lastChild[isSourceNode]) {
        lastChild.replaceRight(aPattern, aReplacement);
      } else if (typeof lastChild === "string") {
        this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
      } else {
        this.children.push("".replace(aPattern, aReplacement));
      }
      return this;
    };
    SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
      this.sourceContents[util4.toSetString(aSourceFile)] = aSourceContent;
    };
    SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
      for (var i = 0, len = this.children.length; i < len; i++) {
        if (this.children[i][isSourceNode]) {
          this.children[i].walkSourceContents(aFn);
        }
      }
      var sources = Object.keys(this.sourceContents);
      for (var i = 0, len = sources.length; i < len; i++) {
        aFn(util4.fromSetString(sources[i]), this.sourceContents[sources[i]]);
      }
    };
    SourceNode.prototype.toString = function SourceNode_toString() {
      var str = "";
      this.walk(function(chunk) {
        str += chunk;
      });
      return str;
    };
    SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
      var generated = {
        code: "",
        line: 1,
        column: 0
      };
      var map3 = new SourceMapGenerator(aArgs);
      var sourceMappingActive = false;
      var lastOriginalSource = null;
      var lastOriginalLine = null;
      var lastOriginalColumn = null;
      var lastOriginalName = null;
      this.walk(function(chunk, original) {
        generated.code += chunk;
        if (original.source !== null && original.line !== null && original.column !== null) {
          if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
            map3.addMapping({
              source: original.source,
              original: {
                line: original.line,
                column: original.column
              },
              generated: {
                line: generated.line,
                column: generated.column
              },
              name: original.name
            });
          }
          lastOriginalSource = original.source;
          lastOriginalLine = original.line;
          lastOriginalColumn = original.column;
          lastOriginalName = original.name;
          sourceMappingActive = true;
        } else if (sourceMappingActive) {
          map3.addMapping({
            generated: {
              line: generated.line,
              column: generated.column
            }
          });
          lastOriginalSource = null;
          sourceMappingActive = false;
        }
        for (var idx = 0, length = chunk.length; idx < length; idx++) {
          if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
            generated.line++;
            generated.column = 0;
            if (idx + 1 === length) {
              lastOriginalSource = null;
              sourceMappingActive = false;
            } else if (sourceMappingActive) {
              map3.addMapping({
                source: original.source,
                original: {
                  line: original.line,
                  column: original.column
                },
                generated: {
                  line: generated.line,
                  column: generated.column
                },
                name: original.name
              });
            }
          } else {
            generated.column++;
          }
        }
      });
      this.walkSourceContents(function(sourceFile, sourceContent) {
        map3.setSourceContent(sourceFile, sourceContent);
      });
      return { code: generated.code, map: map3 };
    };
    exports2.SourceNode = SourceNode;
  }
});

// node_modules/source-map/source-map.js
var require_source_map = __commonJS({
  "node_modules/source-map/source-map.js"(exports2) {
    "use strict";
    exports2.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
    exports2.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
    exports2.SourceNode = require_source_node().SourceNode;
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/code-gen.js
var require_code_gen = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/code-gen.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    var _utils = require_utils12();
    var SourceNode = void 0;
    try {
      if (typeof define !== "function" || !define.amd) {
        SourceMap = require_source_map();
        SourceNode = SourceMap.SourceNode;
      }
    } catch (err) {
    }
    var SourceMap;
    if (!SourceNode) {
      SourceNode = function(line, column, srcFile, chunks) {
        this.src = "";
        if (chunks) {
          this.add(chunks);
        }
      };
      SourceNode.prototype = {
        add: function add(chunks) {
          if (_utils.isArray(chunks)) {
            chunks = chunks.join("");
          }
          this.src += chunks;
        },
        prepend: function prepend(chunks) {
          if (_utils.isArray(chunks)) {
            chunks = chunks.join("");
          }
          this.src = chunks + this.src;
        },
        toStringWithSourceMap: function toStringWithSourceMap() {
          return { code: this.toString() };
        },
        toString: function toString4() {
          return this.src;
        }
      };
    }
    function castChunk(chunk, codeGen, loc) {
      if (_utils.isArray(chunk)) {
        var ret = [];
        for (var i = 0, len = chunk.length; i < len; i++) {
          ret.push(codeGen.wrap(chunk[i], loc));
        }
        return ret;
      } else if (typeof chunk === "boolean" || typeof chunk === "number") {
        return chunk + "";
      }
      return chunk;
    }
    function CodeGen(srcFile) {
      this.srcFile = srcFile;
      this.source = [];
    }
    CodeGen.prototype = {
      isEmpty: function isEmpty() {
        return !this.source.length;
      },
      prepend: function prepend(source, loc) {
        this.source.unshift(this.wrap(source, loc));
      },
      push: function push(source, loc) {
        this.source.push(this.wrap(source, loc));
      },
      merge: function merge4() {
        var source = this.empty();
        this.each(function(line) {
          source.add(["  ", line, "\n"]);
        });
        return source;
      },
      each: function each(iter) {
        for (var i = 0, len = this.source.length; i < len; i++) {
          iter(this.source[i]);
        }
      },
      empty: function empty() {
        var loc = this.currentLocation || { start: {} };
        return new SourceNode(loc.start.line, loc.start.column, this.srcFile);
      },
      wrap: function wrap(chunk) {
        var loc = arguments.length <= 1 || arguments[1] === void 0 ? this.currentLocation || { start: {} } : arguments[1];
        if (chunk instanceof SourceNode) {
          return chunk;
        }
        chunk = castChunk(chunk, this, loc);
        return new SourceNode(loc.start.line, loc.start.column, this.srcFile, chunk);
      },
      functionCall: function functionCall(fn, type, params) {
        params = this.generateList(params);
        return this.wrap([fn, type ? "." + type + "(" : "(", params, ")"]);
      },
      quotedString: function quotedString(str) {
        return '"' + (str + "").replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029") + '"';
      },
      objectLiteral: function objectLiteral(obj) {
        var _this = this;
        var pairs = [];
        Object.keys(obj).forEach(function(key) {
          var value = castChunk(obj[key], _this);
          if (value !== "undefined") {
            pairs.push([_this.quotedString(key), ":", value]);
          }
        });
        var ret = this.generateList(pairs);
        ret.prepend("{");
        ret.add("}");
        return ret;
      },
      generateList: function generateList(entries) {
        var ret = this.empty();
        for (var i = 0, len = entries.length; i < len; i++) {
          if (i) {
            ret.add(",");
          }
          ret.add(castChunk(entries[i], this));
        }
        return ret;
      },
      generateArray: function generateArray(entries) {
        var ret = this.generateList(entries);
        ret.prepend("[");
        ret.add("]");
        return ret;
      }
    };
    exports2["default"] = CodeGen;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/javascript-compiler.js
var require_javascript_compiler = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/javascript-compiler.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _base = require_base2();
    var _exception = require_exception();
    var _exception2 = _interopRequireDefault(_exception);
    var _utils = require_utils12();
    var _codeGen = require_code_gen();
    var _codeGen2 = _interopRequireDefault(_codeGen);
    function Literal(value) {
      this.value = value;
    }
    function JavaScriptCompiler() {
    }
    JavaScriptCompiler.prototype = {
      // PUBLIC API: You can override these methods in a subclass to provide
      // alternative compiled forms for name lookup and buffering semantics
      nameLookup: function nameLookup(parent, name28) {
        return this.internalNameLookup(parent, name28);
      },
      depthedLookup: function depthedLookup(name28) {
        return [this.aliasable("container.lookup"), "(depths, ", JSON.stringify(name28), ")"];
      },
      compilerInfo: function compilerInfo() {
        var revision = _base.COMPILER_REVISION, versions = _base.REVISION_CHANGES[revision];
        return [revision, versions];
      },
      appendToBuffer: function appendToBuffer(source, location, explicit) {
        if (!_utils.isArray(source)) {
          source = [source];
        }
        source = this.source.wrap(source, location);
        if (this.environment.isSimple) {
          return ["return ", source, ";"];
        } else if (explicit) {
          return ["buffer += ", source, ";"];
        } else {
          source.appendToBuffer = true;
          return source;
        }
      },
      initializeBuffer: function initializeBuffer() {
        return this.quotedString("");
      },
      // END PUBLIC API
      internalNameLookup: function internalNameLookup(parent, name28) {
        this.lookupPropertyFunctionIsUsed = true;
        return ["lookupProperty(", parent, ",", JSON.stringify(name28), ")"];
      },
      lookupPropertyFunctionIsUsed: false,
      compile: function compile(environment, options, context2, asObject) {
        this.environment = environment;
        this.options = options;
        this.stringParams = this.options.stringParams;
        this.trackIds = this.options.trackIds;
        this.precompile = !asObject;
        this.name = this.environment.name;
        this.isChild = !!context2;
        this.context = context2 || {
          decorators: [],
          programs: [],
          environments: []
        };
        this.preamble();
        this.stackSlot = 0;
        this.stackVars = [];
        this.aliases = {};
        this.registers = { list: [] };
        this.hashes = [];
        this.compileStack = [];
        this.inlineStack = [];
        this.blockParams = [];
        this.compileChildren(environment, options);
        this.useDepths = this.useDepths || environment.useDepths || environment.useDecorators || this.options.compat;
        this.useBlockParams = this.useBlockParams || environment.useBlockParams;
        var opcodes = environment.opcodes, opcode = void 0, firstLoc = void 0, i = void 0, l = void 0;
        for (i = 0, l = opcodes.length; i < l; i++) {
          opcode = opcodes[i];
          this.source.currentLocation = opcode.loc;
          firstLoc = firstLoc || opcode.loc;
          this[opcode.opcode].apply(this, opcode.args);
        }
        this.source.currentLocation = firstLoc;
        this.pushSource("");
        if (this.stackSlot || this.inlineStack.length || this.compileStack.length) {
          throw new _exception2["default"]("Compile completed with content left on stack");
        }
        if (!this.decorators.isEmpty()) {
          this.useDecorators = true;
          this.decorators.prepend(["var decorators = container.decorators, ", this.lookupPropertyFunctionVarDeclaration(), ";\n"]);
          this.decorators.push("return fn;");
          if (asObject) {
            this.decorators = Function.apply(this, ["fn", "props", "container", "depth0", "data", "blockParams", "depths", this.decorators.merge()]);
          } else {
            this.decorators.prepend("function(fn, props, container, depth0, data, blockParams, depths) {\n");
            this.decorators.push("}\n");
            this.decorators = this.decorators.merge();
          }
        } else {
          this.decorators = void 0;
        }
        var fn = this.createFunctionContext(asObject);
        if (!this.isChild) {
          var ret = {
            compiler: this.compilerInfo(),
            main: fn
          };
          if (this.decorators) {
            ret.main_d = this.decorators;
            ret.useDecorators = true;
          }
          var _context = this.context;
          var programs = _context.programs;
          var decorators = _context.decorators;
          for (i = 0, l = programs.length; i < l; i++) {
            ret[i] = programs[i];
            if (decorators[i]) {
              ret[i + "_d"] = decorators[i];
              ret.useDecorators = true;
            }
          }
          if (this.environment.usePartial) {
            ret.usePartial = true;
          }
          if (this.options.data) {
            ret.useData = true;
          }
          if (this.useDepths) {
            ret.useDepths = true;
          }
          if (this.useBlockParams) {
            ret.useBlockParams = true;
          }
          if (this.options.compat) {
            ret.compat = true;
          }
          if (!asObject) {
            ret.compiler = JSON.stringify(ret.compiler);
            this.source.currentLocation = { start: { line: 1, column: 0 } };
            ret = this.objectLiteral(ret);
            if (options.srcName) {
              ret = ret.toStringWithSourceMap({ file: options.destName });
              ret.map = ret.map && ret.map.toString();
            } else {
              ret = ret.toString();
            }
          } else {
            ret.compilerOptions = this.options;
          }
          return ret;
        } else {
          return fn;
        }
      },
      preamble: function preamble() {
        this.lastContext = 0;
        this.source = new _codeGen2["default"](this.options.srcName);
        this.decorators = new _codeGen2["default"](this.options.srcName);
      },
      createFunctionContext: function createFunctionContext(asObject) {
        var _this = this;
        var varDeclarations = "";
        var locals = this.stackVars.concat(this.registers.list);
        if (locals.length > 0) {
          varDeclarations += ", " + locals.join(", ");
        }
        var aliasCount = 0;
        Object.keys(this.aliases).forEach(function(alias) {
          var node = _this.aliases[alias];
          if (node.children && node.referenceCount > 1) {
            varDeclarations += ", alias" + ++aliasCount + "=" + alias;
            node.children[0] = "alias" + aliasCount;
          }
        });
        if (this.lookupPropertyFunctionIsUsed) {
          varDeclarations += ", " + this.lookupPropertyFunctionVarDeclaration();
        }
        var params = ["container", "depth0", "helpers", "partials", "data"];
        if (this.useBlockParams || this.useDepths) {
          params.push("blockParams");
        }
        if (this.useDepths) {
          params.push("depths");
        }
        var source = this.mergeSource(varDeclarations);
        if (asObject) {
          params.push(source);
          return Function.apply(this, params);
        } else {
          return this.source.wrap(["function(", params.join(","), ") {\n  ", source, "}"]);
        }
      },
      mergeSource: function mergeSource(varDeclarations) {
        var isSimple = this.environment.isSimple, appendOnly = !this.forceBuffer, appendFirst = void 0, sourceSeen = void 0, bufferStart = void 0, bufferEnd = void 0;
        this.source.each(function(line) {
          if (line.appendToBuffer) {
            if (bufferStart) {
              line.prepend("  + ");
            } else {
              bufferStart = line;
            }
            bufferEnd = line;
          } else {
            if (bufferStart) {
              if (!sourceSeen) {
                appendFirst = true;
              } else {
                bufferStart.prepend("buffer += ");
              }
              bufferEnd.add(";");
              bufferStart = bufferEnd = void 0;
            }
            sourceSeen = true;
            if (!isSimple) {
              appendOnly = false;
            }
          }
        });
        if (appendOnly) {
          if (bufferStart) {
            bufferStart.prepend("return ");
            bufferEnd.add(";");
          } else if (!sourceSeen) {
            this.source.push('return "";');
          }
        } else {
          varDeclarations += ", buffer = " + (appendFirst ? "" : this.initializeBuffer());
          if (bufferStart) {
            bufferStart.prepend("return buffer + ");
            bufferEnd.add(";");
          } else {
            this.source.push("return buffer;");
          }
        }
        if (varDeclarations) {
          this.source.prepend("var " + varDeclarations.substring(2) + (appendFirst ? "" : ";\n"));
        }
        return this.source.merge();
      },
      lookupPropertyFunctionVarDeclaration: function lookupPropertyFunctionVarDeclaration() {
        return "\n      lookupProperty = container.lookupProperty || function(parent, propertyName) {\n        if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {\n          return parent[propertyName];\n        }\n        return undefined\n    }\n    ".trim();
      },
      // [blockValue]
      //
      // On stack, before: hash, inverse, program, value
      // On stack, after: return value of blockHelperMissing
      //
      // The purpose of this opcode is to take a block of the form
      // `{{#this.foo}}...{{/this.foo}}`, resolve the value of `foo`, and
      // replace it on the stack with the result of properly
      // invoking blockHelperMissing.
      blockValue: function blockValue(name28) {
        var blockHelperMissing = this.aliasable("container.hooks.blockHelperMissing"), params = [this.contextName(0)];
        this.setupHelperArgs(name28, 0, params);
        var blockName = this.popStack();
        params.splice(1, 0, blockName);
        this.push(this.source.functionCall(blockHelperMissing, "call", params));
      },
      // [ambiguousBlockValue]
      //
      // On stack, before: hash, inverse, program, value
      // Compiler value, before: lastHelper=value of last found helper, if any
      // On stack, after, if no lastHelper: same as [blockValue]
      // On stack, after, if lastHelper: value
      ambiguousBlockValue: function ambiguousBlockValue() {
        var blockHelperMissing = this.aliasable("container.hooks.blockHelperMissing"), params = [this.contextName(0)];
        this.setupHelperArgs("", 0, params, true);
        this.flushInline();
        var current = this.topStack();
        params.splice(1, 0, current);
        this.pushSource(["if (!", this.lastHelper, ") { ", current, " = ", this.source.functionCall(blockHelperMissing, "call", params), "}"]);
      },
      // [appendContent]
      //
      // On stack, before: ...
      // On stack, after: ...
      //
      // Appends the string value of `content` to the current buffer
      appendContent: function appendContent(content) {
        if (this.pendingContent) {
          content = this.pendingContent + content;
        } else {
          this.pendingLocation = this.source.currentLocation;
        }
        this.pendingContent = content;
      },
      // [append]
      //
      // On stack, before: value, ...
      // On stack, after: ...
      //
      // Coerces `value` to a String and appends it to the current buffer.
      //
      // If `value` is truthy, or 0, it is coerced into a string and appended
      // Otherwise, the empty string is appended
      append: function append2() {
        if (this.isInline()) {
          this.replaceStack(function(current) {
            return [" != null ? ", current, ' : ""'];
          });
          this.pushSource(this.appendToBuffer(this.popStack()));
        } else {
          var local = this.popStack();
          this.pushSource(["if (", local, " != null) { ", this.appendToBuffer(local, void 0, true), " }"]);
          if (this.environment.isSimple) {
            this.pushSource(["else { ", this.appendToBuffer("''", void 0, true), " }"]);
          }
        }
      },
      // [appendEscaped]
      //
      // On stack, before: value, ...
      // On stack, after: ...
      //
      // Escape `value` and append it to the buffer
      appendEscaped: function appendEscaped() {
        this.pushSource(this.appendToBuffer([this.aliasable("container.escapeExpression"), "(", this.popStack(), ")"]));
      },
      // [getContext]
      //
      // On stack, before: ...
      // On stack, after: ...
      // Compiler value, after: lastContext=depth
      //
      // Set the value of the `lastContext` compiler value to the depth
      getContext: function getContext3(depth) {
        this.lastContext = depth;
      },
      // [pushContext]
      //
      // On stack, before: ...
      // On stack, after: currentContext, ...
      //
      // Pushes the value of the current context onto the stack.
      pushContext: function pushContext() {
        this.pushStackLiteral(this.contextName(this.lastContext));
      },
      // [lookupOnContext]
      //
      // On stack, before: ...
      // On stack, after: currentContext[name], ...
      //
      // Looks up the value of `name` on the current context and pushes
      // it onto the stack.
      lookupOnContext: function lookupOnContext(parts, falsy, strict, scoped) {
        var i = 0;
        if (!scoped && this.options.compat && !this.lastContext) {
          this.push(this.depthedLookup(parts[i++]));
        } else {
          this.pushContext();
        }
        this.resolvePath("context", parts, i, falsy, strict);
      },
      // [lookupBlockParam]
      //
      // On stack, before: ...
      // On stack, after: blockParam[name], ...
      //
      // Looks up the value of `parts` on the given block param and pushes
      // it onto the stack.
      lookupBlockParam: function lookupBlockParam(blockParamId, parts) {
        this.useBlockParams = true;
        this.push(["blockParams[", blockParamId[0], "][", blockParamId[1], "]"]);
        this.resolvePath("context", parts, 1);
      },
      // [lookupData]
      //
      // On stack, before: ...
      // On stack, after: data, ...
      //
      // Push the data lookup operator
      lookupData: function lookupData(depth, parts, strict) {
        if (!depth) {
          this.pushStackLiteral("data");
        } else {
          this.pushStackLiteral("container.data(data, " + depth + ")");
        }
        this.resolvePath("data", parts, 0, true, strict);
      },
      resolvePath: function resolvePath(type, parts, startPartIndex, falsy, strict) {
        var _this2 = this;
        if (this.options.strict || this.options.assumeObjects) {
          this.push(strictLookup(this.options.strict && strict, this, parts, startPartIndex, type));
          return;
        }
        var len = parts.length;
        var _loop = function(i2) {
          _this2.replaceStack(function(current) {
            var lookup = _this2.nameLookup(current, parts[i2], type);
            if (!falsy) {
              return [" != null ? ", lookup, " : ", current];
            } else {
              return [" && ", lookup];
            }
          });
        };
        for (var i = startPartIndex; i < len; i++) {
          _loop(i);
        }
      },
      // [resolvePossibleLambda]
      //
      // On stack, before: value, ...
      // On stack, after: resolved value, ...
      //
      // If the `value` is a lambda, replace it on the stack by
      // the return value of the lambda
      resolvePossibleLambda: function resolvePossibleLambda() {
        this.push([this.aliasable("container.lambda"), "(", this.popStack(), ", ", this.contextName(0), ")"]);
      },
      // [pushStringParam]
      //
      // On stack, before: ...
      // On stack, after: string, currentContext, ...
      //
      // This opcode is designed for use in string mode, which
      // provides the string value of a parameter along with its
      // depth rather than resolving it immediately.
      pushStringParam: function pushStringParam(string5, type) {
        this.pushContext();
        this.pushString(type);
        if (type !== "SubExpression") {
          if (typeof string5 === "string") {
            this.pushString(string5);
          } else {
            this.pushStackLiteral(string5);
          }
        }
      },
      emptyHash: function emptyHash(omitEmpty) {
        if (this.trackIds) {
          this.push("{}");
        }
        if (this.stringParams) {
          this.push("{}");
          this.push("{}");
        }
        this.pushStackLiteral(omitEmpty ? "undefined" : "{}");
      },
      pushHash: function pushHash() {
        if (this.hash) {
          this.hashes.push(this.hash);
        }
        this.hash = { values: {}, types: [], contexts: [], ids: [] };
      },
      popHash: function popHash() {
        var hash3 = this.hash;
        this.hash = this.hashes.pop();
        if (this.trackIds) {
          this.push(this.objectLiteral(hash3.ids));
        }
        if (this.stringParams) {
          this.push(this.objectLiteral(hash3.contexts));
          this.push(this.objectLiteral(hash3.types));
        }
        this.push(this.objectLiteral(hash3.values));
      },
      // [pushString]
      //
      // On stack, before: ...
      // On stack, after: quotedString(string), ...
      //
      // Push a quoted version of `string` onto the stack
      pushString: function pushString(string5) {
        this.pushStackLiteral(this.quotedString(string5));
      },
      // [pushLiteral]
      //
      // On stack, before: ...
      // On stack, after: value, ...
      //
      // Pushes a value onto the stack. This operation prevents
      // the compiler from creating a temporary variable to hold
      // it.
      pushLiteral: function pushLiteral(value) {
        this.pushStackLiteral(value);
      },
      // [pushProgram]
      //
      // On stack, before: ...
      // On stack, after: program(guid), ...
      //
      // Push a program expression onto the stack. This takes
      // a compile-time guid and converts it into a runtime-accessible
      // expression.
      pushProgram: function pushProgram(guid4) {
        if (guid4 != null) {
          this.pushStackLiteral(this.programExpression(guid4));
        } else {
          this.pushStackLiteral(null);
        }
      },
      // [registerDecorator]
      //
      // On stack, before: hash, program, params..., ...
      // On stack, after: ...
      //
      // Pops off the decorator's parameters, invokes the decorator,
      // and inserts the decorator into the decorators list.
      registerDecorator: function registerDecorator(paramSize, name28) {
        var foundDecorator = this.nameLookup("decorators", name28, "decorator"), options = this.setupHelperArgs(name28, paramSize);
        this.decorators.push(["var decorator = ", foundDecorator, ";"]);
        this.decorators.push(['if (typeof decorator !== "function") { throw new Error(', this.quotedString('Missing decorator: "' + name28 + '"'), "); }"]);
        this.decorators.push(["fn = ", this.decorators.functionCall("decorator", "", ["fn", "props", "container", options]), " || fn;"]);
      },
      // [invokeHelper]
      //
      // On stack, before: hash, inverse, program, params..., ...
      // On stack, after: result of helper invocation
      //
      // Pops off the helper's parameters, invokes the helper,
      // and pushes the helper's return value onto the stack.
      //
      // If the helper is not found, `helperMissing` is called.
      invokeHelper: function invokeHelper(paramSize, name28, isSimple) {
        var nonHelper = this.popStack(), helper = this.setupHelper(paramSize, name28);
        var possibleFunctionCalls = [];
        if (isSimple) {
          possibleFunctionCalls.push(helper.name);
        }
        possibleFunctionCalls.push(nonHelper);
        if (!this.options.strict) {
          possibleFunctionCalls.push(this.aliasable("container.hooks.helperMissing"));
        }
        var functionLookupCode = ["(", this.itemsSeparatedBy(possibleFunctionCalls, "||"), ")"];
        var functionCall = this.source.functionCall(functionLookupCode, "call", helper.callParams);
        this.push(functionCall);
      },
      itemsSeparatedBy: function itemsSeparatedBy(items, separator) {
        var result = [];
        result.push(items[0]);
        for (var i = 1; i < items.length; i++) {
          result.push(separator, items[i]);
        }
        return result;
      },
      // [invokeKnownHelper]
      //
      // On stack, before: hash, inverse, program, params..., ...
      // On stack, after: result of helper invocation
      //
      // This operation is used when the helper is known to exist,
      // so a `helperMissing` fallback is not required.
      invokeKnownHelper: function invokeKnownHelper(paramSize, name28) {
        var helper = this.setupHelper(paramSize, name28);
        this.push(this.source.functionCall(helper.name, "call", helper.callParams));
      },
      // [invokeAmbiguous]
      //
      // On stack, before: hash, inverse, program, params..., ...
      // On stack, after: result of disambiguation
      //
      // This operation is used when an expression like `{{foo}}`
      // is provided, but we don't know at compile-time whether it
      // is a helper or a path.
      //
      // This operation emits more code than the other options,
      // and can be avoided by passing the `knownHelpers` and
      // `knownHelpersOnly` flags at compile-time.
      invokeAmbiguous: function invokeAmbiguous(name28, helperCall) {
        this.useRegister("helper");
        var nonHelper = this.popStack();
        this.emptyHash();
        var helper = this.setupHelper(0, name28, helperCall);
        var helperName = this.lastHelper = this.nameLookup("helpers", name28, "helper");
        var lookup = ["(", "(helper = ", helperName, " || ", nonHelper, ")"];
        if (!this.options.strict) {
          lookup[0] = "(helper = ";
          lookup.push(" != null ? helper : ", this.aliasable("container.hooks.helperMissing"));
        }
        this.push(["(", lookup, helper.paramsInit ? ["),(", helper.paramsInit] : [], "),", "(typeof helper === ", this.aliasable('"function"'), " ? ", this.source.functionCall("helper", "call", helper.callParams), " : helper))"]);
      },
      // [invokePartial]
      //
      // On stack, before: context, ...
      // On stack after: result of partial invocation
      //
      // This operation pops off a context, invokes a partial with that context,
      // and pushes the result of the invocation back.
      invokePartial: function invokePartial(isDynamic, name28, indent) {
        var params = [], options = this.setupParams(name28, 1, params);
        if (isDynamic) {
          name28 = this.popStack();
          delete options.name;
        }
        if (indent) {
          options.indent = JSON.stringify(indent);
        }
        options.helpers = "helpers";
        options.partials = "partials";
        options.decorators = "container.decorators";
        if (!isDynamic) {
          params.unshift(this.nameLookup("partials", name28, "partial"));
        } else {
          params.unshift(name28);
        }
        if (this.options.compat) {
          options.depths = "depths";
        }
        options = this.objectLiteral(options);
        params.push(options);
        this.push(this.source.functionCall("container.invokePartial", "", params));
      },
      // [assignToHash]
      //
      // On stack, before: value, ..., hash, ...
      // On stack, after: ..., hash, ...
      //
      // Pops a value off the stack and assigns it to the current hash
      assignToHash: function assignToHash(key) {
        var value = this.popStack(), context2 = void 0, type = void 0, id = void 0;
        if (this.trackIds) {
          id = this.popStack();
        }
        if (this.stringParams) {
          type = this.popStack();
          context2 = this.popStack();
        }
        var hash3 = this.hash;
        if (context2) {
          hash3.contexts[key] = context2;
        }
        if (type) {
          hash3.types[key] = type;
        }
        if (id) {
          hash3.ids[key] = id;
        }
        hash3.values[key] = value;
      },
      pushId: function pushId(type, name28, child) {
        if (type === "BlockParam") {
          this.pushStackLiteral("blockParams[" + name28[0] + "].path[" + name28[1] + "]" + (child ? " + " + JSON.stringify("." + child) : ""));
        } else if (type === "PathExpression") {
          this.pushString(name28);
        } else if (type === "SubExpression") {
          this.pushStackLiteral("true");
        } else {
          this.pushStackLiteral("null");
        }
      },
      // HELPERS
      compiler: JavaScriptCompiler,
      compileChildren: function compileChildren(environment, options) {
        var children = environment.children, child = void 0, compiler = void 0;
        for (var i = 0, l = children.length; i < l; i++) {
          child = children[i];
          compiler = new this.compiler();
          var existing = this.matchExistingProgram(child);
          if (existing == null) {
            var index = this.context.programs.push("") - 1;
            child.index = index;
            child.name = "program" + index;
            this.context.programs[index] = compiler.compile(child, options, this.context, !this.precompile);
            this.context.decorators[index] = compiler.decorators;
            this.context.environments[index] = child;
            this.useDepths = this.useDepths || compiler.useDepths;
            this.useBlockParams = this.useBlockParams || compiler.useBlockParams;
            child.useDepths = this.useDepths;
            child.useBlockParams = this.useBlockParams;
          } else {
            child.index = existing.index;
            child.name = "program" + existing.index;
            this.useDepths = this.useDepths || existing.useDepths;
            this.useBlockParams = this.useBlockParams || existing.useBlockParams;
          }
        }
      },
      matchExistingProgram: function matchExistingProgram(child) {
        for (var i = 0, len = this.context.environments.length; i < len; i++) {
          var environment = this.context.environments[i];
          if (environment && environment.equals(child)) {
            return environment;
          }
        }
      },
      programExpression: function programExpression(guid4) {
        var child = this.environment.children[guid4], programParams = [child.index, "data", child.blockParams];
        if (this.useBlockParams || this.useDepths) {
          programParams.push("blockParams");
        }
        if (this.useDepths) {
          programParams.push("depths");
        }
        return "container.program(" + programParams.join(", ") + ")";
      },
      useRegister: function useRegister(name28) {
        if (!this.registers[name28]) {
          this.registers[name28] = true;
          this.registers.list.push(name28);
        }
      },
      push: function push(expr) {
        if (!(expr instanceof Literal)) {
          expr = this.source.wrap(expr);
        }
        this.inlineStack.push(expr);
        return expr;
      },
      pushStackLiteral: function pushStackLiteral(item) {
        this.push(new Literal(item));
      },
      pushSource: function pushSource(source) {
        if (this.pendingContent) {
          this.source.push(this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation));
          this.pendingContent = void 0;
        }
        if (source) {
          this.source.push(source);
        }
      },
      replaceStack: function replaceStack(callback) {
        var prefix = ["("], stack = void 0, createdStack = void 0, usedLiteral = void 0;
        if (!this.isInline()) {
          throw new _exception2["default"]("replaceStack on non-inline");
        }
        var top = this.popStack(true);
        if (top instanceof Literal) {
          stack = [top.value];
          prefix = ["(", stack];
          usedLiteral = true;
        } else {
          createdStack = true;
          var _name = this.incrStack();
          prefix = ["((", this.push(_name), " = ", top, ")"];
          stack = this.topStack();
        }
        var item = callback.call(this, stack);
        if (!usedLiteral) {
          this.popStack();
        }
        if (createdStack) {
          this.stackSlot--;
        }
        this.push(prefix.concat(item, ")"));
      },
      incrStack: function incrStack() {
        this.stackSlot++;
        if (this.stackSlot > this.stackVars.length) {
          this.stackVars.push("stack" + this.stackSlot);
        }
        return this.topStackName();
      },
      topStackName: function topStackName() {
        return "stack" + this.stackSlot;
      },
      flushInline: function flushInline() {
        var inlineStack = this.inlineStack;
        this.inlineStack = [];
        for (var i = 0, len = inlineStack.length; i < len; i++) {
          var entry = inlineStack[i];
          if (entry instanceof Literal) {
            this.compileStack.push(entry);
          } else {
            var stack = this.incrStack();
            this.pushSource([stack, " = ", entry, ";"]);
            this.compileStack.push(stack);
          }
        }
      },
      isInline: function isInline() {
        return this.inlineStack.length;
      },
      popStack: function popStack(wrapped) {
        var inline = this.isInline(), item = (inline ? this.inlineStack : this.compileStack).pop();
        if (!wrapped && item instanceof Literal) {
          return item.value;
        } else {
          if (!inline) {
            if (!this.stackSlot) {
              throw new _exception2["default"]("Invalid stack pop");
            }
            this.stackSlot--;
          }
          return item;
        }
      },
      topStack: function topStack() {
        var stack = this.isInline() ? this.inlineStack : this.compileStack, item = stack[stack.length - 1];
        if (item instanceof Literal) {
          return item.value;
        } else {
          return item;
        }
      },
      contextName: function contextName(context2) {
        if (this.useDepths && context2) {
          return "depths[" + context2 + "]";
        } else {
          return "depth" + context2;
        }
      },
      quotedString: function quotedString(str) {
        return this.source.quotedString(str);
      },
      objectLiteral: function objectLiteral(obj) {
        return this.source.objectLiteral(obj);
      },
      aliasable: function aliasable(name28) {
        var ret = this.aliases[name28];
        if (ret) {
          ret.referenceCount++;
          return ret;
        }
        ret = this.aliases[name28] = this.source.wrap(name28);
        ret.aliasable = true;
        ret.referenceCount = 1;
        return ret;
      },
      setupHelper: function setupHelper(paramSize, name28, blockHelper) {
        var params = [], paramsInit = this.setupHelperArgs(name28, paramSize, params, blockHelper);
        var foundHelper = this.nameLookup("helpers", name28, "helper"), callContext = this.aliasable(this.contextName(0) + " != null ? " + this.contextName(0) + " : (container.nullContext || {})");
        return {
          params,
          paramsInit,
          name: foundHelper,
          callParams: [callContext].concat(params)
        };
      },
      setupParams: function setupParams(helper, paramSize, params) {
        var options = {}, contexts = [], types = [], ids = [], objectArgs = !params, param = void 0;
        if (objectArgs) {
          params = [];
        }
        options.name = this.quotedString(helper);
        options.hash = this.popStack();
        if (this.trackIds) {
          options.hashIds = this.popStack();
        }
        if (this.stringParams) {
          options.hashTypes = this.popStack();
          options.hashContexts = this.popStack();
        }
        var inverse = this.popStack(), program = this.popStack();
        if (program || inverse) {
          options.fn = program || "container.noop";
          options.inverse = inverse || "container.noop";
        }
        var i = paramSize;
        while (i--) {
          param = this.popStack();
          params[i] = param;
          if (this.trackIds) {
            ids[i] = this.popStack();
          }
          if (this.stringParams) {
            types[i] = this.popStack();
            contexts[i] = this.popStack();
          }
        }
        if (objectArgs) {
          options.args = this.source.generateArray(params);
        }
        if (this.trackIds) {
          options.ids = this.source.generateArray(ids);
        }
        if (this.stringParams) {
          options.types = this.source.generateArray(types);
          options.contexts = this.source.generateArray(contexts);
        }
        if (this.options.data) {
          options.data = "data";
        }
        if (this.useBlockParams) {
          options.blockParams = "blockParams";
        }
        return options;
      },
      setupHelperArgs: function setupHelperArgs(helper, paramSize, params, useRegister) {
        var options = this.setupParams(helper, paramSize, params);
        options.loc = JSON.stringify(this.source.currentLocation);
        options = this.objectLiteral(options);
        if (useRegister) {
          this.useRegister("options");
          params.push("options");
          return ["options=", options];
        } else if (params) {
          params.push(options);
          return "";
        } else {
          return options;
        }
      }
    };
    (function() {
      var reservedWords = "break else new var case finally return void catch for switch while continue function this with default if throw delete in try do instanceof typeof abstract enum int short boolean export interface static byte extends long super char final native synchronized class float package throws const goto private transient debugger implements protected volatile double import public let yield await null true false".split(" ");
      var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
      for (var i = 0, l = reservedWords.length; i < l; i++) {
        compilerWords[reservedWords[i]] = true;
      }
    })();
    JavaScriptCompiler.isValidJavaScriptVariableName = function(name28) {
      return !JavaScriptCompiler.RESERVED_WORDS[name28] && /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name28);
    };
    function strictLookup(requireTerminal, compiler, parts, startPartIndex, type) {
      var stack = compiler.popStack(), len = parts.length;
      if (requireTerminal) {
        len--;
      }
      for (var i = startPartIndex; i < len; i++) {
        stack = compiler.nameLookup(stack, parts[i], type);
      }
      if (requireTerminal) {
        return [compiler.aliasable("container.strict"), "(", stack, ", ", compiler.quotedString(parts[len]), ", ", JSON.stringify(compiler.source.currentLocation), " )"];
      } else {
        return stack;
      }
    }
    exports2["default"] = JavaScriptCompiler;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars.js
var require_handlebars = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars.js"(exports2, module2) {
    "use strict";
    exports2.__esModule = true;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _handlebarsRuntime = require_handlebars_runtime();
    var _handlebarsRuntime2 = _interopRequireDefault(_handlebarsRuntime);
    var _handlebarsCompilerAst = require_ast();
    var _handlebarsCompilerAst2 = _interopRequireDefault(_handlebarsCompilerAst);
    var _handlebarsCompilerBase = require_base3();
    var _handlebarsCompilerCompiler = require_compiler3();
    var _handlebarsCompilerJavascriptCompiler = require_javascript_compiler();
    var _handlebarsCompilerJavascriptCompiler2 = _interopRequireDefault(_handlebarsCompilerJavascriptCompiler);
    var _handlebarsCompilerVisitor = require_visitor();
    var _handlebarsCompilerVisitor2 = _interopRequireDefault(_handlebarsCompilerVisitor);
    var _handlebarsNoConflict = require_no_conflict();
    var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict);
    var _create = _handlebarsRuntime2["default"].create;
    function create() {
      var hb = _create();
      hb.compile = function(input, options) {
        return _handlebarsCompilerCompiler.compile(input, options, hb);
      };
      hb.precompile = function(input, options) {
        return _handlebarsCompilerCompiler.precompile(input, options, hb);
      };
      hb.AST = _handlebarsCompilerAst2["default"];
      hb.Compiler = _handlebarsCompilerCompiler.Compiler;
      hb.JavaScriptCompiler = _handlebarsCompilerJavascriptCompiler2["default"];
      hb.Parser = _handlebarsCompilerBase.parser;
      hb.parse = _handlebarsCompilerBase.parse;
      hb.parseWithoutProcessing = _handlebarsCompilerBase.parseWithoutProcessing;
      return hb;
    }
    var inst = create();
    inst.create = create;
    _handlebarsNoConflict2["default"](inst);
    inst.Visitor = _handlebarsCompilerVisitor2["default"];
    inst["default"] = inst;
    exports2["default"] = inst;
    module2.exports = exports2["default"];
  }
});

// node_modules/handlebars/dist/cjs/handlebars/compiler/printer.js
var require_printer = __commonJS({
  "node_modules/handlebars/dist/cjs/handlebars/compiler/printer.js"(exports2) {
    "use strict";
    exports2.__esModule = true;
    exports2.print = print;
    exports2.PrintVisitor = PrintVisitor;
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { "default": obj };
    }
    var _visitor = require_visitor();
    var _visitor2 = _interopRequireDefault(_visitor);
    function print(ast) {
      return new PrintVisitor().accept(ast);
    }
    function PrintVisitor() {
      this.padding = 0;
    }
    PrintVisitor.prototype = new _visitor2["default"]();
    PrintVisitor.prototype.pad = function(string5) {
      var out = "";
      for (var i = 0, l = this.padding; i < l; i++) {
        out += "  ";
      }
      out += string5 + "\n";
      return out;
    };
    PrintVisitor.prototype.Program = function(program) {
      var out = "", body = program.body, i = void 0, l = void 0;
      if (program.blockParams) {
        var blockParams = "BLOCK PARAMS: [";
        for (i = 0, l = program.blockParams.length; i < l; i++) {
          blockParams += " " + program.blockParams[i];
        }
        blockParams += " ]";
        out += this.pad(blockParams);
      }
      for (i = 0, l = body.length; i < l; i++) {
        out += this.accept(body[i]);
      }
      this.padding--;
      return out;
    };
    PrintVisitor.prototype.MustacheStatement = function(mustache) {
      return this.pad("{{ " + this.SubExpression(mustache) + " }}");
    };
    PrintVisitor.prototype.Decorator = function(mustache) {
      return this.pad("{{ DIRECTIVE " + this.SubExpression(mustache) + " }}");
    };
    PrintVisitor.prototype.BlockStatement = PrintVisitor.prototype.DecoratorBlock = function(block) {
      var out = "";
      out += this.pad((block.type === "DecoratorBlock" ? "DIRECTIVE " : "") + "BLOCK:");
      this.padding++;
      out += this.pad(this.SubExpression(block));
      if (block.program) {
        out += this.pad("PROGRAM:");
        this.padding++;
        out += this.accept(block.program);
        this.padding--;
      }
      if (block.inverse) {
        if (block.program) {
          this.padding++;
        }
        out += this.pad("{{^}}");
        this.padding++;
        out += this.accept(block.inverse);
        this.padding--;
        if (block.program) {
          this.padding--;
        }
      }
      this.padding--;
      return out;
    };
    PrintVisitor.prototype.PartialStatement = function(partial3) {
      var content = "PARTIAL:" + partial3.name.original;
      if (partial3.params[0]) {
        content += " " + this.accept(partial3.params[0]);
      }
      if (partial3.hash) {
        content += " " + this.accept(partial3.hash);
      }
      return this.pad("{{> " + content + " }}");
    };
    PrintVisitor.prototype.PartialBlockStatement = function(partial3) {
      var content = "PARTIAL BLOCK:" + partial3.name.original;
      if (partial3.params[0]) {
        content += " " + this.accept(partial3.params[0]);
      }
      if (partial3.hash) {
        content += " " + this.accept(partial3.hash);
      }
      content += " " + this.pad("PROGRAM:");
      this.padding++;
      content += this.accept(partial3.program);
      this.padding--;
      return this.pad("{{> " + content + " }}");
    };
    PrintVisitor.prototype.ContentStatement = function(content) {
      return this.pad("CONTENT[ '" + content.value + "' ]");
    };
    PrintVisitor.prototype.CommentStatement = function(comment) {
      return this.pad("{{! '" + comment.value + "' }}");
    };
    PrintVisitor.prototype.SubExpression = function(sexpr) {
      var params = sexpr.params, paramStrings = [], hash3 = void 0;
      for (var i = 0, l = params.length; i < l; i++) {
        paramStrings.push(this.accept(params[i]));
      }
      params = "[" + paramStrings.join(", ") + "]";
      hash3 = sexpr.hash ? " " + this.accept(sexpr.hash) : "";
      return this.accept(sexpr.path) + " " + params + hash3;
    };
    PrintVisitor.prototype.PathExpression = function(id) {
      var path33 = id.parts.join("/");
      return (id.data ? "@" : "") + "PATH:" + path33;
    };
    PrintVisitor.prototype.StringLiteral = function(string5) {
      return '"' + string5.value + '"';
    };
    PrintVisitor.prototype.NumberLiteral = function(number5) {
      return "NUMBER{" + number5.value + "}";
    };
    PrintVisitor.prototype.BooleanLiteral = function(bool) {
      return "BOOLEAN{" + bool.value + "}";
    };
    PrintVisitor.prototype.UndefinedLiteral = function() {
      return "UNDEFINED";
    };
    PrintVisitor.prototype.NullLiteral = function() {
      return "NULL";
    };
    PrintVisitor.prototype.Hash = function(hash3) {
      var pairs = hash3.pairs, joinedPairs = [];
      for (var i = 0, l = pairs.length; i < l; i++) {
        joinedPairs.push(this.accept(pairs[i]));
      }
      return "HASH{" + joinedPairs.join(", ") + "}";
    };
    PrintVisitor.prototype.HashPair = function(pair) {
      return pair.key + "=" + this.accept(pair.value);
    };
  }
});

// node_modules/handlebars/lib/index.js
var require_lib6 = __commonJS({
  "node_modules/handlebars/lib/index.js"(exports2, module2) {
    "use strict";
    var handlebars = require_handlebars()["default"];
    var printer = require_printer();
    handlebars.PrintVisitor = printer.PrintVisitor;
    handlebars.print = printer.print;
    module2.exports = handlebars;
    function extension(module3, filename) {
      var fs34 = require("fs");
      var templateString = fs34.readFileSync(filename, "utf8");
      module3.exports = handlebars.compile(templateString);
    }
    if (typeof require !== "undefined" && require.extensions) {
      require.extensions[".handlebars"] = extension;
      require.extensions[".hbs"] = extension;
    }
  }
});

// node_modules/@rmp135/sql-ts/dist/DatabaseTasks.js
function convertDatabaseToTypescript(database, config3) {
  const templateString = fs3.readFileSync(config3.template, "utf-8");
  const compiler = import_handlebars.default.compile(templateString, { noEscape: true });
  import_handlebars.default.registerHelper("handleNumeric", handleNumeric);
  return compiler({
    database,
    config: config3
  });
}
function handleNumeric(value) {
  return !isNaN(Number(value)) ? value.toString() : new import_handlebars.default.SafeString(`'${value}'`).toString();
}
async function generateDatabase(config3, db2) {
  const tables = await getAllTables2(db2, config3);
  const enums = await getAllEnums2(db2, config3);
  const schemas = new Set(tables.map((table) => table.schema));
  const database = {
    schemas: Array.from(schemas).map((schema) => ({
      name: schema,
      namespaceName: schema,
      tables: tables.filter((table) => table.schema === schema),
      enums: enums.filter((enumm) => enumm.schema === schema)
    })),
    custom: config3.custom
  };
  return database;
}
var import_handlebars, fs3;
var init_DatabaseTasks = __esm({
  "node_modules/@rmp135/sql-ts/dist/DatabaseTasks.js"() {
    "use strict";
    init_TableTasks();
    init_EnumTasks();
    import_handlebars = __toESM(require_lib6(), 1);
    fs3 = __toESM(require("fs"), 1);
  }
});

// node_modules/@rmp135/sql-ts/dist/ConnectionFactory.js
async function createAndRun(config3, func) {
  let db2;
  try {
    db2 = (0, import_knex.default)(config3);
    return await func(db2);
  } finally {
    await db2?.destroy();
  }
}
var import_knex;
var init_ConnectionFactory = __esm({
  "node_modules/@rmp135/sql-ts/dist/ConnectionFactory.js"() {
    "use strict";
    import_knex = __toESM(require_knex(), 1);
  }
});

// node_modules/@rmp135/sql-ts/dist/Client.js
var Client;
var init_Client = __esm({
  "node_modules/@rmp135/sql-ts/dist/Client.js"() {
    "use strict";
    init_ConfigTasks();
    init_DatabaseTasks();
    init_ConnectionFactory();
    Client = class _Client {
      config;
      databaseProvider;
      databaseMappings = [];
      constructor() {
      }
      /**
       * Creates a new Client with the given sql-ts configuration
       * @param config The configuration object for the database
       * @returns A Client with the given configuration
       */
      static fromConfig(config3) {
        const client = new _Client();
        client.config = applyConfigDefaults(config3);
        return client;
      }
      /**
       * Creates a new Client with the given database definition from {@link ClientWithDatabase.toObject}
       * @param schema The database definition to use
       * @param config The sql-ts configuration object
       * @returns A Client with the given database schema
       */
      static fromObject(schema, config3) {
        const client = new _Client();
        client.config = applyConfigDefaults(config3);
        client.databaseProvider = () => Promise.resolve(schema);
        return client;
      }
      fetchDatabase(db2) {
        this.databaseProvider = async () => {
          if (db2 == null) {
            return await createAndRun(this.config, (tempdb) => generateDatabase(this.config, tempdb));
          }
          return await generateDatabase(this.config, db2);
        };
        return this;
      }
      mapTable(identifer, func) {
        this.databaseMappings.push((database) => {
          for (const schema of database.schemas) {
            schema.tables = schema.tables.map((table) => `${schema.name}.${table.name}` === identifer ? func(table, schema) : table);
          }
        });
        return this;
      }
      mapTables(func) {
        this.databaseMappings.push((database) => {
          for (const schema of database.schemas) {
            schema.tables = schema.tables.map((table) => func(table, schema));
          }
        });
        return this;
      }
      mapColumn(identifier, func) {
        this.databaseMappings.push((database) => {
          for (const schema of database.schemas) {
            for (const table of schema.tables) {
              table.columns = table.columns.map((column) => `${schema.name}.${table.name}.${column.name}` === identifier ? func(column, table, schema) : column);
            }
          }
        });
        return this;
      }
      mapColumns(func) {
        this.databaseMappings.push((database) => {
          for (const schema of database.schemas) {
            for (const table of schema.tables) {
              table.columns = table.columns.map((column) => func(column, table, schema));
            }
          }
        });
        return this;
      }
      mapSchema(identifier, func) {
        this.databaseMappings.push((database) => {
          database.schemas = database.schemas.map((schema) => schema.name === identifier ? func(schema) : schema);
        });
        return this;
      }
      mapSchemas(func) {
        this.databaseMappings.push((database) => {
          database.schemas = database.schemas.map((schema) => func(schema));
        });
        return this;
      }
      async toTypescript() {
        const schema = await this.toObject();
        return convertDatabaseToTypescript(schema, this.config);
      }
      async toObject() {
        const database = await this.databaseProvider();
        for (const mapping of this.databaseMappings) {
          mapping(database);
        }
        return database;
      }
    };
  }
});

// node_modules/@rmp135/sql-ts/dist/index.js
var dist_exports = {};
__export(dist_exports, {
  Client: () => Client
});
var init_dist2 = __esm({
  "node_modules/@rmp135/sql-ts/dist/index.js"() {
    "use strict";
    init_Client();
  }
});

// src/utils/db.ts
async function initKnexType(knexDb) {
  const { Client: Client2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
  const outFile = "src/types/database.d.ts";
  const dbClient2 = Client2.fromConfig({
    interfaceNameFormat: "${table}",
    typeMap: {
      number: ["bigint"],
      string: ["text", "varchar", "char"]
    }
  }).fetchDatabase(knexDb);
  const declarations = await dbClient2.toTypescript();
  const dbObject = await dbClient2.toObject();
  const customHeader = `//\u8BE5\u6587\u4EF6\u7531\u811A\u672C\u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539`;
  let declBody = declarations.replace(/^\/\*[\s\S]*?\*\/\s*/, "");
  declBody = declBody.replace(/(\n\s*)\/\*([^*][\s\S]*?)\*\//g, "$1/**$2*/");
  const tableInterfaces = dbObject.schemas.flatMap((schema) => schema.tables.map((table) => table.interfaceName));
  const aggregateTypes = `
export interface DB {
${tableInterfaces.map((name28) => `  ${JSON.stringify(name28)}: ${name28};`).join("\n")}
}
`;
  const hashSource = JSON.stringify({
    tableInterfaces,
    declBody
  });
  const hash3 = import_crypto3.default.createHash("md5").update(hashSource).digest("hex");
  const content = `// @db-hash ${hash3}
${customHeader}

` + declBody + aggregateTypes;
  let needWrite = true;
  try {
    const current = await (0, import_promises2.readFile)(outFile, "utf8");
    const match = current.match(/^\/\/\s*@db-hash\s*([a-zA-Z0-9]+)\n/);
    const currentHash = match ? match[1] : null;
    if (currentHash === hash3) {
      needWrite = false;
    }
  } catch (err) {
    needWrite = true;
  }
  if (needWrite) await (0, import_promises2.writeFile)(outFile, content, "utf8");
}
var import_promises2, import_fs3, import_path5, import_knex2, import_crypto3, dbPath, dbDir, db, dbClient, db_default;
var init_db = __esm({
  "src/utils/db.ts"() {
    "use strict";
    import_promises2 = require("fs/promises");
    init_getPath();
    import_fs3 = __toESM(require("fs"));
    import_path5 = __toESM(require("path"));
    import_knex2 = __toESM(require_knex());
    init_initDB();
    import_crypto3 = __toESM(require("crypto"));
    init_fixDB();
    dbPath = getPath_default("db2.sqlite");
    console.log("\u6570\u636E\u5E93\u76EE\u5F55:", dbPath);
    dbDir = import_path5.default.dirname(dbPath);
    if (!import_fs3.default.existsSync(dbDir)) {
      import_fs3.default.mkdirSync(dbDir, { recursive: true });
    }
    if (!import_fs3.default.existsSync(dbPath)) {
      import_fs3.default.writeFileSync(dbPath, "");
    }
    db = (0, import_knex2.default)({
      client: "better-sqlite3",
      connection: {
        filename: dbPath
      },
      useNullAsDefault: true
    });
    (async () => {
      await initDB_default(db);
      await fixDB_default(db);
      if (process.env.NODE_ENV == "dev") initKnexType(db);
    })();
    dbClient = Object.assign((table) => db(table), db);
    dbClient.schema = db.schema;
    db_default = dbClient;
  }
});

// src/utils/oss.ts
function normalizeUserPath(userPath) {
  const trimmedPath = userPath.replace(/^[/\\]+/, "");
  return trimmedPath.split("/").join(import_node_path2.default.sep);
}
function resolveSafeLocalPath(userPath, rootDir) {
  const safePath = normalizeUserPath(userPath);
  const absPath = import_node_path2.default.join(rootDir, safePath);
  if (!isPathInside(absPath, rootDir)) {
    throw new Error(`${userPath} \u4E0D\u5728 OSS \u6839\u76EE\u5F55\u5185`);
  }
  return absPath;
}
var import_promises3, import_node_path2, import_sharp, OSS, oss_default;
var init_oss = __esm({
  "src/utils/oss.ts"() {
    "use strict";
    init_is_path_inside();
    init_getPath();
    import_promises3 = __toESM(require("node:fs/promises"));
    import_node_path2 = __toESM(require("node:path"));
    import_sharp = __toESM(require("sharp"));
    OSS = class {
      rootDir;
      initPromise;
      constructor() {
        this.rootDir = getPath_default("oss");
        this.initPromise = import_promises3.default.mkdir(this.rootDir, { recursive: true }).then(() => {
        });
      }
      /**
       * 等待根目录初始化完成。用于保证所有文件操作在目录已创建后执行。
       * @private
       */
      async ensureInit() {
        await this.initPromise;
      }
      /**
       * 获取指定相对路径文件的访问 URL。
       * @param userRelPath 用户传入的相对文件路径（使用 / 作为分隔符）
       * @returns 文件的 http 链接（本地服务地址）
       */
      async getFileUrl(userRelPath, prefix) {
        if (!prefix) prefix = "oss";
        await this.ensureInit();
        const safePath = normalizeUserPath(userRelPath);
        let url4 = `/${prefix}/`;
        if (process.env.ossURL && process.env.ossURL !== "") url4 = process.env.ossURL + `/${prefix}/`;
        if (process.env.NODE_ENV == "dev") url4 = `http://localhost:10588/${prefix}/`;
        if (isEletron()) url4 = `http://localhost:${process.env.PORT}/${prefix}/`;
        return `${url4}${safePath.split(import_node_path2.default.sep).join("/")}`;
      }
      /**
       * 读取指定路径的文件内容为 Buffer。
       * @param userRelPath 用户传入的相对文件路径（使用 / 作为分隔符）
       * @returns 文件内容的 Buffer
       * @throws 路径不在 OSS 根目录内、文件不存在等错误
       */
      async getFile(userRelPath) {
        await this.ensureInit();
        return import_promises3.default.readFile(resolveSafeLocalPath(userRelPath, this.rootDir));
      }
      /**
       * 读取图片文件并转换为 base64 编码的 Data URL。
       * @param userRelPath 用户传入的相对文件路径（使用 / 作为分隔符）
       * @returns base64 编码的 Data URL (例如: data:image/png;base64,iVBORw0KGgo...)
       * @throws 路径不在 OSS 根目录内、文件不存在、不是图片文件等错误
       */
      async getImageBase64(userRelPath) {
        await this.ensureInit();
        const absPath = resolveSafeLocalPath(userRelPath, this.rootDir);
        const stat = await import_promises3.default.stat(absPath);
        if (!stat.isFile()) {
          throw new Error(`${userRelPath} \u4E0D\u662F\u6587\u4EF6`);
        }
        const ext = import_node_path2.default.extname(userRelPath).toLowerCase();
        const mimeTypes = {
          ".jpg": "image/jpeg",
          ".jpeg": "image/jpeg",
          ".png": "image/png",
          ".gif": "image/gif",
          ".webp": "image/webp",
          ".bmp": "image/bmp",
          ".svg": "image/svg+xml",
          ".ico": "image/x-icon",
          ".tiff": "image/tiff",
          ".tif": "image/tiff",
          ".mp4": "video/mp4",
          ".mp3": "audio/mpeg"
        };
        const mimeType = mimeTypes[ext];
        if (!mimeType) {
          throw new Error(`\u4E0D\u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F: ${ext}\u3002\u652F\u6301\u7684\u683C\u5F0F: ${Object.keys(mimeTypes).join(", ")}`);
        }
        const data = await import_promises3.default.readFile(absPath);
        const base644 = data.toString("base64");
        return `data:${mimeType};base64,${base644}`;
      }
      /**
       * 删除指定路径的文件。
       * @param userRelPath 用户传入的相对文件路径（使用 / 作为分隔符）
       * @throws 路径不在 OSS 根目录内、文件不存在等错误
       */
      async deleteFile(userRelPath) {
        await this.ensureInit();
        await import_promises3.default.unlink(resolveSafeLocalPath(userRelPath, this.rootDir));
      }
      /**
       * 删除指定路径的文件夹及其所有内容。
       * @param userRelPath 用户传入的相对文件夹路径（使用 / 作为分隔符）
       * @throws 路径不在 OSS 根目录内、文件夹不存在、目标是文件而非文件夹等错误
       */
      async deleteDirectory(userRelPath) {
        await this.ensureInit();
        const absPath = resolveSafeLocalPath(userRelPath, this.rootDir);
        const stat = await import_promises3.default.stat(absPath);
        if (!stat.isDirectory()) {
          throw new Error(`${userRelPath} \u4E0D\u662F\u6587\u4EF6\u5939`);
        }
        await import_promises3.default.rm(absPath, { recursive: true, force: true });
      }
      /**
       * 将数据写入指定路径的新文件或覆盖已有文件。
       * 写入前自动创建所需的父文件夹。
       * @param userRelPath 用户传入的相对文件路径（使用 / 作为分隔符）
       * @param data 要写入的数据，可以为 Buffer 或字符串
       * @throws 路径不在 OSS 根目录内等错误
       */
      async writeFile(userRelPath, data) {
        await this.ensureInit();
        const absPath = resolveSafeLocalPath(userRelPath, this.rootDir);
        await import_promises3.default.mkdir(import_node_path2.default.dirname(absPath), { recursive: true });
        const buffer = typeof data === "string" ? Buffer.from(data.replace(/^data:[^;]+;base64,/, ""), "base64") : data;
        await import_promises3.default.writeFile(absPath, buffer);
      }
      /**
       * 检查指定路径文件是否存在。
       * @param userRelPath 用户传入的相对文件路径（使用 / 作为分隔符）
       * @returns 文件存在返回 true，否则 false
       */
      async fileExists(userRelPath) {
        await this.ensureInit();
        try {
          const stat = await import_promises3.default.stat(resolveSafeLocalPath(userRelPath, this.rootDir));
          return stat.isFile();
        } catch {
          return false;
        }
      }
      /**
       * 获取图片的缩略图 URL（最长边不超过 512px，等比缩放）。
       * 缩略图保存在原路径同目录下的 smallImage 子文件夹中。
       * 若缩略图已存在则直接返回其 URL；若不存在则同步生成并保存后返回缩略图 URL，
       * 生成失败时返回原图 URL。
       * @param userRelPath 用户传入的相对文件路径（使用 / 作为分隔符）
       * @returns 缩略图 URL（已存在或生成成功）或原图 URL（生成失败时）
       */
      async getSmallImageUrl(userRelPath) {
        const smallImageRelPath = `smallImage/${userRelPath.replace(/^[/\\]+/, "")}`;
        if (await this.fileExists(smallImageRelPath)) {
          return this.getFileUrl(smallImageRelPath);
        }
        const originalUrl = await this.getFileUrl(userRelPath);
        try {
          await this.ensureInit();
          const srcAbsPath = resolveSafeLocalPath(userRelPath, this.rootDir);
          const dstAbsPath = resolveSafeLocalPath(smallImageRelPath, this.rootDir);
          await import_promises3.default.mkdir(import_node_path2.default.dirname(dstAbsPath), { recursive: true });
          await (0, import_sharp.default)(srcAbsPath).resize(512, 512, { fit: "inside", withoutEnlargement: true }).toFile(dstAbsPath);
          console.info(`[${dstAbsPath}]\u5C0F\u56FE\u5199\u5165\u6210\u529F`);
          return this.getFileUrl(smallImageRelPath);
        } catch (e) {
          console.warn("[OSS] \u751F\u6210\u7F29\u7565\u56FE\u5931\u8D25:", e);
          return originalUrl;
        }
      }
    };
    oss_default = new OSS();
  }
});

// src/utils/getConfig.ts
async function getConfig(aiType, manufacturer) {
  const config3 = await utils_default.db("t_config").where("type", aiType).modify((qb) => {
    if (manufacturer) {
      qb.where("manufacturer", manufacturer);
    }
  }).first();
  if (!config3) throw new Error(errorMessages[aiType]);
  const result = {
    model: config3?.model ?? "",
    apiKey: config3?.apiKey ?? "",
    manufacturer: config3?.manufacturer ?? ""
  };
  if (needBaseURL.includes(aiType)) {
    return { ...result, baseURL: config3.baseUrl };
  }
  return result;
}
var errorMessages, needBaseURL;
var init_getConfig = __esm({
  "src/utils/getConfig.ts"() {
    "use strict";
    init_utils3();
    errorMessages = {
      text: "\u6587\u672C\u6A21\u578B\u914D\u7F6E\u4E0D\u5B58\u5728",
      image: "\u56FE\u50CF\u6A21\u578B\u914D\u7F6E\u4E0D\u5B58\u5728",
      video: "\u89C6\u9891\u6A21\u578B\u914D\u7F6E\u4E0D\u5B58\u5728"
    };
    needBaseURL = ["text", "video", "image"];
  }
});

// node_modules/axios/lib/helpers/bind.js
function bind(fn, thisArg) {
  return function wrap() {
    return fn.apply(thisArg, arguments);
  };
}
var init_bind = __esm({
  "node_modules/axios/lib/helpers/bind.js"() {
    "use strict";
  }
});

// node_modules/axios/lib/utils.js
function isBuffer2(val) {
  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction2(val.constructor.isBuffer) && val.constructor.isBuffer(val);
}
function isArrayBufferView(val) {
  let result;
  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
    result = ArrayBuffer.isView(val);
  } else {
    result = val && val.buffer && isArrayBuffer(val.buffer);
  }
  return result;
}
function getGlobal() {
  if (typeof globalThis !== "undefined") return globalThis;
  if (typeof self !== "undefined") return self;
  if (typeof window !== "undefined") return window;
  if (typeof global !== "undefined") return global;
  return {};
}
function forEach(obj, fn, { allOwnKeys = false } = {}) {
  if (obj === null || typeof obj === "undefined") {
    return;
  }
  let i;
  let l;
  if (typeof obj !== "object") {
    obj = [obj];
  }
  if (isArray2(obj)) {
    for (i = 0, l = obj.length; i < l; i++) {
      fn.call(null, obj[i], i, obj);
    }
  } else {
    if (isBuffer2(obj)) {
      return;
    }
    const keys2 = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
    const len = keys2.length;
    let key;
    for (i = 0; i < len; i++) {
      key = keys2[i];
      fn.call(null, obj[key], key, obj);
    }
  }
}
function findKey(obj, key) {
  if (isBuffer2(obj)) {
    return null;
  }
  key = key.toLowerCase();
  const keys2 = Object.keys(obj);
  let i = keys2.length;
  let _key;
  while (i-- > 0) {
    _key = keys2[i];
    if (key === _key.toLowerCase()) {
      return _key;
    }
  }
  return null;
}
function merge() {
  const { caseless, skipUndefined } = isContextDefined(this) && this || {};
  const result = {};
  const assignValue = (val, key) => {
    if (key === "__proto__" || key === "constructor" || key === "prototype") {
      return;
    }
    const targetKey = caseless && findKey(result, key) || key;
    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
      result[targetKey] = merge(result[targetKey], val);
    } else if (isPlainObject(val)) {
      result[targetKey] = merge({}, val);
    } else if (isArray2(val)) {
      result[targetKey] = val.slice();
    } else if (!skipUndefined || !isUndefined(val)) {
      result[targetKey] = val;
    }
  };
  for (let i = 0, l = arguments.length; i < l; i++) {
    arguments[i] && forEach(arguments[i], assignValue);
  }
  return result;
}
function isSpecCompliantForm(thing) {
  return !!(thing && isFunction2(thing.append) && thing[toStringTag] === "FormData" && thing[iterator]);
}
var toString2, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest, typeOfTest, isArray2, isUndefined, isArrayBuffer, isString, isFunction2, isNumber, isObject2, isBoolean, isPlainObject, isEmptyObject, isDate, isFile, isReactNativeBlob, isReactNative, isBlob, isFileList, isStream, G, FormDataCtor, isFormData, isURLSearchParams, isReadableStream, isRequest, isResponse, isHeaders, trim, _global, isContextDefined, extend, stripBOM, inherits, toFlatObject, endsWith, toArray, isTypedArray2, forEachEntry, matchAll, isHTMLForm, toCamelCase, hasOwnProperty10, isRegExp, reduceDescriptors, freezeMethods, toObjectSet, noop2, toFiniteNumber, toJSONObject, isAsyncFn, isThenable, _setImmediate, asap, isIterable, utils_default2;
var init_utils = __esm({
  "node_modules/axios/lib/utils.js"() {
    "use strict";
    init_bind();
    ({ toString: toString2 } = Object.prototype);
    ({ getPrototypeOf } = Object);
    ({ iterator, toStringTag } = Symbol);
    kindOf = /* @__PURE__ */ ((cache) => (thing) => {
      const str = toString2.call(thing);
      return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
    })(/* @__PURE__ */ Object.create(null));
    kindOfTest = (type) => {
      type = type.toLowerCase();
      return (thing) => kindOf(thing) === type;
    };
    typeOfTest = (type) => (thing) => typeof thing === type;
    ({ isArray: isArray2 } = Array);
    isUndefined = typeOfTest("undefined");
    isArrayBuffer = kindOfTest("ArrayBuffer");
    isString = typeOfTest("string");
    isFunction2 = typeOfTest("function");
    isNumber = typeOfTest("number");
    isObject2 = (thing) => thing !== null && typeof thing === "object";
    isBoolean = (thing) => thing === true || thing === false;
    isPlainObject = (val) => {
      if (kindOf(val) !== "object") {
        return false;
      }
      const prototype2 = getPrototypeOf(val);
      return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(toStringTag in val) && !(iterator in val);
    };
    isEmptyObject = (val) => {
      if (!isObject2(val) || isBuffer2(val)) {
        return false;
      }
      try {
        return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
      } catch (e) {
        return false;
      }
    };
    isDate = kindOfTest("Date");
    isFile = kindOfTest("File");
    isReactNativeBlob = (value) => {
      return !!(value && typeof value.uri !== "undefined");
    };
    isReactNative = (formData) => formData && typeof formData.getParts !== "undefined";
    isBlob = kindOfTest("Blob");
    isFileList = kindOfTest("FileList");
    isStream = (val) => isObject2(val) && isFunction2(val.pipe);
    G = getGlobal();
    FormDataCtor = typeof G.FormData !== "undefined" ? G.FormData : void 0;
    isFormData = (thing) => {
      let kind;
      return thing && (FormDataCtor && thing instanceof FormDataCtor || isFunction2(thing.append) && ((kind = kindOf(thing)) === "formdata" || // detect form-data instance
      kind === "object" && isFunction2(thing.toString) && thing.toString() === "[object FormData]"));
    };
    isURLSearchParams = kindOfTest("URLSearchParams");
    [isReadableStream, isRequest, isResponse, isHeaders] = [
      "ReadableStream",
      "Request",
      "Response",
      "Headers"
    ].map(kindOfTest);
    trim = (str) => {
      return str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
    };
    _global = (() => {
      if (typeof globalThis !== "undefined") return globalThis;
      return typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global;
    })();
    isContextDefined = (context2) => !isUndefined(context2) && context2 !== _global;
    extend = (a, b, thisArg, { allOwnKeys } = {}) => {
      forEach(
        b,
        (val, key) => {
          if (thisArg && isFunction2(val)) {
            Object.defineProperty(a, key, {
              value: bind(val, thisArg),
              writable: true,
              enumerable: true,
              configurable: true
            });
          } else {
            Object.defineProperty(a, key, {
              value: val,
              writable: true,
              enumerable: true,
              configurable: true
            });
          }
        },
        { allOwnKeys }
      );
      return a;
    };
    stripBOM = (content) => {
      if (content.charCodeAt(0) === 65279) {
        content = content.slice(1);
      }
      return content;
    };
    inherits = (constructor, superConstructor, props, descriptors) => {
      constructor.prototype = Object.create(superConstructor.prototype, descriptors);
      Object.defineProperty(constructor.prototype, "constructor", {
        value: constructor,
        writable: true,
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(constructor, "super", {
        value: superConstructor.prototype
      });
      props && Object.assign(constructor.prototype, props);
    };
    toFlatObject = (sourceObj, destObj, filter6, propFilter) => {
      let props;
      let i;
      let prop;
      const merged = {};
      destObj = destObj || {};
      if (sourceObj == null) return destObj;
      do {
        props = Object.getOwnPropertyNames(sourceObj);
        i = props.length;
        while (i-- > 0) {
          prop = props[i];
          if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
            destObj[prop] = sourceObj[prop];
            merged[prop] = true;
          }
        }
        sourceObj = filter6 !== false && getPrototypeOf(sourceObj);
      } while (sourceObj && (!filter6 || filter6(sourceObj, destObj)) && sourceObj !== Object.prototype);
      return destObj;
    };
    endsWith = (str, searchString, position) => {
      str = String(str);
      if (position === void 0 || position > str.length) {
        position = str.length;
      }
      position -= searchString.length;
      const lastIndex = str.indexOf(searchString, position);
      return lastIndex !== -1 && lastIndex === position;
    };
    toArray = (thing) => {
      if (!thing) return null;
      if (isArray2(thing)) return thing;
      let i = thing.length;
      if (!isNumber(i)) return null;
      const arr = new Array(i);
      while (i-- > 0) {
        arr[i] = thing[i];
      }
      return arr;
    };
    isTypedArray2 = /* @__PURE__ */ ((TypedArray) => {
      return (thing) => {
        return TypedArray && thing instanceof TypedArray;
      };
    })(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array));
    forEachEntry = (obj, fn) => {
      const generator = obj && obj[iterator];
      const _iterator = generator.call(obj);
      let result;
      while ((result = _iterator.next()) && !result.done) {
        const pair = result.value;
        fn.call(obj, pair[0], pair[1]);
      }
    };
    matchAll = (regExp, str) => {
      let matches;
      const arr = [];
      while ((matches = regExp.exec(str)) !== null) {
        arr.push(matches);
      }
      return arr;
    };
    isHTMLForm = kindOfTest("HTMLFormElement");
    toCamelCase = (str) => {
      return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p22) {
        return p1.toUpperCase() + p22;
      });
    };
    hasOwnProperty10 = (({ hasOwnProperty: hasOwnProperty11 }) => (obj, prop) => hasOwnProperty11.call(obj, prop))(Object.prototype);
    isRegExp = kindOfTest("RegExp");
    reduceDescriptors = (obj, reducer) => {
      const descriptors = Object.getOwnPropertyDescriptors(obj);
      const reducedDescriptors = {};
      forEach(descriptors, (descriptor, name28) => {
        let ret;
        if ((ret = reducer(descriptor, name28, obj)) !== false) {
          reducedDescriptors[name28] = ret || descriptor;
        }
      });
      Object.defineProperties(obj, reducedDescriptors);
    };
    freezeMethods = (obj) => {
      reduceDescriptors(obj, (descriptor, name28) => {
        if (isFunction2(obj) && ["arguments", "caller", "callee"].indexOf(name28) !== -1) {
          return false;
        }
        const value = obj[name28];
        if (!isFunction2(value)) return;
        descriptor.enumerable = false;
        if ("writable" in descriptor) {
          descriptor.writable = false;
          return;
        }
        if (!descriptor.set) {
          descriptor.set = () => {
            throw Error("Can not rewrite read-only method '" + name28 + "'");
          };
        }
      });
    };
    toObjectSet = (arrayOrString, delimiter) => {
      const obj = {};
      const define2 = (arr) => {
        arr.forEach((value) => {
          obj[value] = true;
        });
      };
      isArray2(arrayOrString) ? define2(arrayOrString) : define2(String(arrayOrString).split(delimiter));
      return obj;
    };
    noop2 = () => {
    };
    toFiniteNumber = (value, defaultValue) => {
      return value != null && Number.isFinite(value = +value) ? value : defaultValue;
    };
    toJSONObject = (obj) => {
      const stack = new Array(10);
      const visit4 = (source, i) => {
        if (isObject2(source)) {
          if (stack.indexOf(source) >= 0) {
            return;
          }
          if (isBuffer2(source)) {
            return source;
          }
          if (!("toJSON" in source)) {
            stack[i] = source;
            const target = isArray2(source) ? [] : {};
            forEach(source, (value, key) => {
              const reducedValue = visit4(value, i + 1);
              !isUndefined(reducedValue) && (target[key] = reducedValue);
            });
            stack[i] = void 0;
            return target;
          }
        }
        return source;
      };
      return visit4(obj, 0);
    };
    isAsyncFn = kindOfTest("AsyncFunction");
    isThenable = (thing) => thing && (isObject2(thing) || isFunction2(thing)) && isFunction2(thing.then) && isFunction2(thing.catch);
    _setImmediate = ((setImmediateSupported, postMessageSupported) => {
      if (setImmediateSupported) {
        return setImmediate;
      }
      return postMessageSupported ? ((token, callbacks) => {
        _global.addEventListener(
          "message",
          ({ source, data }) => {
            if (source === _global && data === token) {
              callbacks.length && callbacks.shift()();
            }
          },
          false
        );
        return (cb) => {
          callbacks.push(cb);
          _global.postMessage(token, "*");
        };
      })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
    })(typeof setImmediate === "function", isFunction2(_global.postMessage));
    asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
    isIterable = (thing) => thing != null && isFunction2(thing[iterator]);
    utils_default2 = {
      isArray: isArray2,
      isArrayBuffer,
      isBuffer: isBuffer2,
      isFormData,
      isArrayBufferView,
      isString,
      isNumber,
      isBoolean,
      isObject: isObject2,
      isPlainObject,
      isEmptyObject,
      isReadableStream,
      isRequest,
      isResponse,
      isHeaders,
      isUndefined,
      isDate,
      isFile,
      isReactNativeBlob,
      isReactNative,
      isBlob,
      isRegExp,
      isFunction: isFunction2,
      isStream,
      isURLSearchParams,
      isTypedArray: isTypedArray2,
      isFileList,
      forEach,
      merge,
      extend,
      trim,
      stripBOM,
      inherits,
      toFlatObject,
      kindOf,
      kindOfTest,
      endsWith,
      toArray,
      forEachEntry,
      matchAll,
      isHTMLForm,
      hasOwnProperty: hasOwnProperty10,
      hasOwnProp: hasOwnProperty10,
      // an alias to avoid ESLint no-prototype-builtins detection
      reduceDescriptors,
      freezeMethods,
      toObjectSet,
      toCamelCase,
      noop: noop2,
      toFiniteNumber,
      findKey,
      global: _global,
      isContextDefined,
      isSpecCompliantForm,
      toJSONObject,
      isAsyncFn,
      isThenable,
      setImmediate: _setImmediate,
      asap,
      isIterable
    };
  }
});

// node_modules/axios/lib/core/AxiosError.js
var AxiosError, AxiosError_default;
var init_AxiosError = __esm({
  "node_modules/axios/lib/core/AxiosError.js"() {
    "use strict";
    init_utils();
    AxiosError = class _AxiosError extends Error {
      static from(error73, code, config3, request, response, customProps) {
        const axiosError = new _AxiosError(error73.message, code || error73.code, config3, request, response);
        axiosError.cause = error73;
        axiosError.name = error73.name;
        if (error73.status != null && axiosError.status == null) {
          axiosError.status = error73.status;
        }
        customProps && Object.assign(axiosError, customProps);
        return axiosError;
      }
      /**
       * Create an Error with the specified message, config, error code, request and response.
       *
       * @param {string} message The error message.
       * @param {string} [code] The error code (for example, 'ECONNABORTED').
       * @param {Object} [config] The config.
       * @param {Object} [request] The request.
       * @param {Object} [response] The response.
       *
       * @returns {Error} The created error.
       */
      constructor(message, code, config3, request, response) {
        super(message);
        Object.defineProperty(this, "message", {
          value: message,
          enumerable: true,
          writable: true,
          configurable: true
        });
        this.name = "AxiosError";
        this.isAxiosError = true;
        code && (this.code = code);
        config3 && (this.config = config3);
        request && (this.request = request);
        if (response) {
          this.response = response;
          this.status = response.status;
        }
      }
      toJSON() {
        return {
          // Standard
          message: this.message,
          name: this.name,
          // Microsoft
          description: this.description,
          number: this.number,
          // Mozilla
          fileName: this.fileName,
          lineNumber: this.lineNumber,
          columnNumber: this.columnNumber,
          stack: this.stack,
          // Axios
          config: utils_default2.toJSONObject(this.config),
          code: this.code,
          status: this.status
        };
      }
    };
    AxiosError.ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
    AxiosError.ERR_BAD_OPTION = "ERR_BAD_OPTION";
    AxiosError.ECONNABORTED = "ECONNABORTED";
    AxiosError.ETIMEDOUT = "ETIMEDOUT";
    AxiosError.ERR_NETWORK = "ERR_NETWORK";
    AxiosError.ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
    AxiosError.ERR_DEPRECATED = "ERR_DEPRECATED";
    AxiosError.ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
    AxiosError.ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
    AxiosError.ERR_CANCELED = "ERR_CANCELED";
    AxiosError.ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
    AxiosError.ERR_INVALID_URL = "ERR_INVALID_URL";
    AxiosError_default = AxiosError;
  }
});

// node_modules/delayed-stream/lib/delayed_stream.js
var require_delayed_stream = __commonJS({
  "node_modules/delayed-stream/lib/delayed_stream.js"(exports2, module2) {
    "use strict";
    var Stream = require("stream").Stream;
    var util4 = require("util");
    module2.exports = DelayedStream;
    function DelayedStream() {
      this.source = null;
      this.dataSize = 0;
      this.maxDataSize = 1024 * 1024;
      this.pauseStream = true;
      this._maxDataSizeExceeded = false;
      this._released = false;
      this._bufferedEvents = [];
    }
    util4.inherits(DelayedStream, Stream);
    DelayedStream.create = function(source, options) {
      var delayedStream = new this();
      options = options || {};
      for (var option in options) {
        delayedStream[option] = options[option];
      }
      delayedStream.source = source;
      var realEmit = source.emit;
      source.emit = function() {
        delayedStream._handleEmit(arguments);
        return realEmit.apply(source, arguments);
      };
      source.on("error", function() {
      });
      if (delayedStream.pauseStream) {
        source.pause();
      }
      return delayedStream;
    };
    Object.defineProperty(DelayedStream.prototype, "readable", {
      configurable: true,
      enumerable: true,
      get: function() {
        return this.source.readable;
      }
    });
    DelayedStream.prototype.setEncoding = function() {
      return this.source.setEncoding.apply(this.source, arguments);
    };
    DelayedStream.prototype.resume = function() {
      if (!this._released) {
        this.release();
      }
      this.source.resume();
    };
    DelayedStream.prototype.pause = function() {
      this.source.pause();
    };
    DelayedStream.prototype.release = function() {
      this._released = true;
      this._bufferedEvents.forEach(function(args) {
        this.emit.apply(this, args);
      }.bind(this));
      this._bufferedEvents = [];
    };
    DelayedStream.prototype.pipe = function() {
      var r = Stream.prototype.pipe.apply(this, arguments);
      this.resume();
      return r;
    };
    DelayedStream.prototype._handleEmit = function(args) {
      if (this._released) {
        this.emit.apply(this, args);
        return;
      }
      if (args[0] === "data") {
        this.dataSize += args[1].length;
        this._checkIfMaxDataSizeExceeded();
      }
      this._bufferedEvents.push(args);
    };
    DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
      if (this._maxDataSizeExceeded) {
        return;
      }
      if (this.dataSize <= this.maxDataSize) {
        return;
      }
      this._maxDataSizeExceeded = true;
      var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
      this.emit("error", new Error(message));
    };
  }
});

// node_modules/combined-stream/lib/combined_stream.js
var require_combined_stream = __commonJS({
  "node_modules/combined-stream/lib/combined_stream.js"(exports2, module2) {
    "use strict";
    var util4 = require("util");
    var Stream = require("stream").Stream;
    var DelayedStream = require_delayed_stream();
    module2.exports = CombinedStream;
    function CombinedStream() {
      this.writable = false;
      this.readable = true;
      this.dataSize = 0;
      this.maxDataSize = 2 * 1024 * 1024;
      this.pauseStreams = true;
      this._released = false;
      this._streams = [];
      this._currentStream = null;
      this._insideLoop = false;
      this._pendingNext = false;
    }
    util4.inherits(CombinedStream, Stream);
    CombinedStream.create = function(options) {
      var combinedStream = new this();
      options = options || {};
      for (var option in options) {
        combinedStream[option] = options[option];
      }
      return combinedStream;
    };
    CombinedStream.isStreamLike = function(stream4) {
      return typeof stream4 !== "function" && typeof stream4 !== "string" && typeof stream4 !== "boolean" && typeof stream4 !== "number" && !Buffer.isBuffer(stream4);
    };
    CombinedStream.prototype.append = function(stream4) {
      var isStreamLike = CombinedStream.isStreamLike(stream4);
      if (isStreamLike) {
        if (!(stream4 instanceof DelayedStream)) {
          var newStream = DelayedStream.create(stream4, {
            maxDataSize: Infinity,
            pauseStream: this.pauseStreams
          });
          stream4.on("data", this._checkDataSize.bind(this));
          stream4 = newStream;
        }
        this._handleErrors(stream4);
        if (this.pauseStreams) {
          stream4.pause();
        }
      }
      this._streams.push(stream4);
      return this;
    };
    CombinedStream.prototype.pipe = function(dest, options) {
      Stream.prototype.pipe.call(this, dest, options);
      this.resume();
      return dest;
    };
    CombinedStream.prototype._getNext = function() {
      this._currentStream = null;
      if (this._insideLoop) {
        this._pendingNext = true;
        return;
      }
      this._insideLoop = true;
      try {
        do {
          this._pendingNext = false;
          this._realGetNext();
        } while (this._pendingNext);
      } finally {
        this._insideLoop = false;
      }
    };
    CombinedStream.prototype._realGetNext = function() {
      var stream4 = this._streams.shift();
      if (typeof stream4 == "undefined") {
        this.end();
        return;
      }
      if (typeof stream4 !== "function") {
        this._pipeNext(stream4);
        return;
      }
      var getStream = stream4;
      getStream(function(stream5) {
        var isStreamLike = CombinedStream.isStreamLike(stream5);
        if (isStreamLike) {
          stream5.on("data", this._checkDataSize.bind(this));
          this._handleErrors(stream5);
        }
        this._pipeNext(stream5);
      }.bind(this));
    };
    CombinedStream.prototype._pipeNext = function(stream4) {
      this._currentStream = stream4;
      var isStreamLike = CombinedStream.isStreamLike(stream4);
      if (isStreamLike) {
        stream4.on("end", this._getNext.bind(this));
        stream4.pipe(this, { end: false });
        return;
      }
      var value = stream4;
      this.write(value);
      this._getNext();
    };
    CombinedStream.prototype._handleErrors = function(stream4) {
      var self2 = this;
      stream4.on("error", function(err) {
        self2._emitError(err);
      });
    };
    CombinedStream.prototype.write = function(data) {
      this.emit("data", data);
    };
    CombinedStream.prototype.pause = function() {
      if (!this.pauseStreams) {
        return;
      }
      if (this.pauseStreams && this._currentStream && typeof this._currentStream.pause == "function") this._currentStream.pause();
      this.emit("pause");
    };
    CombinedStream.prototype.resume = function() {
      if (!this._released) {
        this._released = true;
        this.writable = true;
        this._getNext();
      }
      if (this.pauseStreams && this._currentStream && typeof this._currentStream.resume == "function") this._currentStream.resume();
      this.emit("resume");
    };
    CombinedStream.prototype.end = function() {
      this._reset();
      this.emit("end");
    };
    CombinedStream.prototype.destroy = function() {
      this._reset();
      this.emit("close");
    };
    CombinedStream.prototype._reset = function() {
      this.writable = false;
      this._streams = [];
      this._currentStream = null;
    };
    CombinedStream.prototype._checkDataSize = function() {
      this._updateDataSize();
      if (this.dataSize <= this.maxDataSize) {
        return;
      }
      var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
      this._emitError(new Error(message));
    };
    CombinedStream.prototype._updateDataSize = function() {
      this.dataSize = 0;
      var self2 = this;
      this._streams.forEach(function(stream4) {
        if (!stream4.dataSize) {
          return;
        }
        self2.dataSize += stream4.dataSize;
      });
      if (this._currentStream && this._currentStream.dataSize) {
        this.dataSize += this._currentStream.dataSize;
      }
    };
    CombinedStream.prototype._emitError = function(err) {
      this._reset();
      this.emit("error", err);
    };
  }
});

// node_modules/form-data/node_modules/mime-db/db.json
var require_db3 = __commonJS({
  "node_modules/form-data/node_modules/mime-db/db.json"(exports2, module2) {
    module2.exports = {
      "application/1d-interleaved-parityfec": {
        source: "iana"
      },
      "application/3gpdash-qoe-report+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/3gpp-ims+xml": {
        source: "iana",
        compressible: true
      },
      "application/3gpphal+json": {
        source: "iana",
        compressible: true
      },
      "application/3gpphalforms+json": {
        source: "iana",
        compressible: true
      },
      "application/a2l": {
        source: "iana"
      },
      "application/ace+cbor": {
        source: "iana"
      },
      "application/activemessage": {
        source: "iana"
      },
      "application/activity+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-costmap+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-costmapfilter+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-directory+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointcost+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointcostparams+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointprop+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-endpointpropparams+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-error+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-networkmap+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-networkmapfilter+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-updatestreamcontrol+json": {
        source: "iana",
        compressible: true
      },
      "application/alto-updatestreamparams+json": {
        source: "iana",
        compressible: true
      },
      "application/aml": {
        source: "iana"
      },
      "application/andrew-inset": {
        source: "iana",
        extensions: ["ez"]
      },
      "application/applefile": {
        source: "iana"
      },
      "application/applixware": {
        source: "apache",
        extensions: ["aw"]
      },
      "application/at+jwt": {
        source: "iana"
      },
      "application/atf": {
        source: "iana"
      },
      "application/atfx": {
        source: "iana"
      },
      "application/atom+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atom"]
      },
      "application/atomcat+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atomcat"]
      },
      "application/atomdeleted+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atomdeleted"]
      },
      "application/atomicmail": {
        source: "iana"
      },
      "application/atomsvc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["atomsvc"]
      },
      "application/atsc-dwd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dwd"]
      },
      "application/atsc-dynamic-event-message": {
        source: "iana"
      },
      "application/atsc-held+xml": {
        source: "iana",
        compressible: true,
        extensions: ["held"]
      },
      "application/atsc-rdt+json": {
        source: "iana",
        compressible: true
      },
      "application/atsc-rsat+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rsat"]
      },
      "application/atxml": {
        source: "iana"
      },
      "application/auth-policy+xml": {
        source: "iana",
        compressible: true
      },
      "application/bacnet-xdd+zip": {
        source: "iana",
        compressible: false
      },
      "application/batch-smtp": {
        source: "iana"
      },
      "application/bdoc": {
        compressible: false,
        extensions: ["bdoc"]
      },
      "application/beep+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/calendar+json": {
        source: "iana",
        compressible: true
      },
      "application/calendar+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xcs"]
      },
      "application/call-completion": {
        source: "iana"
      },
      "application/cals-1840": {
        source: "iana"
      },
      "application/captive+json": {
        source: "iana",
        compressible: true
      },
      "application/cbor": {
        source: "iana"
      },
      "application/cbor-seq": {
        source: "iana"
      },
      "application/cccex": {
        source: "iana"
      },
      "application/ccmp+xml": {
        source: "iana",
        compressible: true
      },
      "application/ccxml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ccxml"]
      },
      "application/cdfx+xml": {
        source: "iana",
        compressible: true,
        extensions: ["cdfx"]
      },
      "application/cdmi-capability": {
        source: "iana",
        extensions: ["cdmia"]
      },
      "application/cdmi-container": {
        source: "iana",
        extensions: ["cdmic"]
      },
      "application/cdmi-domain": {
        source: "iana",
        extensions: ["cdmid"]
      },
      "application/cdmi-object": {
        source: "iana",
        extensions: ["cdmio"]
      },
      "application/cdmi-queue": {
        source: "iana",
        extensions: ["cdmiq"]
      },
      "application/cdni": {
        source: "iana"
      },
      "application/cea": {
        source: "iana"
      },
      "application/cea-2018+xml": {
        source: "iana",
        compressible: true
      },
      "application/cellml+xml": {
        source: "iana",
        compressible: true
      },
      "application/cfw": {
        source: "iana"
      },
      "application/city+json": {
        source: "iana",
        compressible: true
      },
      "application/clr": {
        source: "iana"
      },
      "application/clue+xml": {
        source: "iana",
        compressible: true
      },
      "application/clue_info+xml": {
        source: "iana",
        compressible: true
      },
      "application/cms": {
        source: "iana"
      },
      "application/cnrp+xml": {
        source: "iana",
        compressible: true
      },
      "application/coap-group+json": {
        source: "iana",
        compressible: true
      },
      "application/coap-payload": {
        source: "iana"
      },
      "application/commonground": {
        source: "iana"
      },
      "application/conference-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/cose": {
        source: "iana"
      },
      "application/cose-key": {
        source: "iana"
      },
      "application/cose-key-set": {
        source: "iana"
      },
      "application/cpl+xml": {
        source: "iana",
        compressible: true,
        extensions: ["cpl"]
      },
      "application/csrattrs": {
        source: "iana"
      },
      "application/csta+xml": {
        source: "iana",
        compressible: true
      },
      "application/cstadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/csvm+json": {
        source: "iana",
        compressible: true
      },
      "application/cu-seeme": {
        source: "apache",
        extensions: ["cu"]
      },
      "application/cwt": {
        source: "iana"
      },
      "application/cybercash": {
        source: "iana"
      },
      "application/dart": {
        compressible: true
      },
      "application/dash+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpd"]
      },
      "application/dash-patch+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpp"]
      },
      "application/dashdelta": {
        source: "iana"
      },
      "application/davmount+xml": {
        source: "iana",
        compressible: true,
        extensions: ["davmount"]
      },
      "application/dca-rft": {
        source: "iana"
      },
      "application/dcd": {
        source: "iana"
      },
      "application/dec-dx": {
        source: "iana"
      },
      "application/dialog-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/dicom": {
        source: "iana"
      },
      "application/dicom+json": {
        source: "iana",
        compressible: true
      },
      "application/dicom+xml": {
        source: "iana",
        compressible: true
      },
      "application/dii": {
        source: "iana"
      },
      "application/dit": {
        source: "iana"
      },
      "application/dns": {
        source: "iana"
      },
      "application/dns+json": {
        source: "iana",
        compressible: true
      },
      "application/dns-message": {
        source: "iana"
      },
      "application/docbook+xml": {
        source: "apache",
        compressible: true,
        extensions: ["dbk"]
      },
      "application/dots+cbor": {
        source: "iana"
      },
      "application/dskpp+xml": {
        source: "iana",
        compressible: true
      },
      "application/dssc+der": {
        source: "iana",
        extensions: ["dssc"]
      },
      "application/dssc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdssc"]
      },
      "application/dvcs": {
        source: "iana"
      },
      "application/ecmascript": {
        source: "iana",
        compressible: true,
        extensions: ["es", "ecma"]
      },
      "application/edi-consent": {
        source: "iana"
      },
      "application/edi-x12": {
        source: "iana",
        compressible: false
      },
      "application/edifact": {
        source: "iana",
        compressible: false
      },
      "application/efi": {
        source: "iana"
      },
      "application/elm+json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/elm+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.cap+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/emergencycalldata.comment+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.control+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.deviceinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.ecall.msd": {
        source: "iana"
      },
      "application/emergencycalldata.providerinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.serviceinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.subscriberinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/emergencycalldata.veds+xml": {
        source: "iana",
        compressible: true
      },
      "application/emma+xml": {
        source: "iana",
        compressible: true,
        extensions: ["emma"]
      },
      "application/emotionml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["emotionml"]
      },
      "application/encaprtp": {
        source: "iana"
      },
      "application/epp+xml": {
        source: "iana",
        compressible: true
      },
      "application/epub+zip": {
        source: "iana",
        compressible: false,
        extensions: ["epub"]
      },
      "application/eshop": {
        source: "iana"
      },
      "application/exi": {
        source: "iana",
        extensions: ["exi"]
      },
      "application/expect-ct-report+json": {
        source: "iana",
        compressible: true
      },
      "application/express": {
        source: "iana",
        extensions: ["exp"]
      },
      "application/fastinfoset": {
        source: "iana"
      },
      "application/fastsoap": {
        source: "iana"
      },
      "application/fdt+xml": {
        source: "iana",
        compressible: true,
        extensions: ["fdt"]
      },
      "application/fhir+json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/fhir+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/fido.trusted-apps+json": {
        compressible: true
      },
      "application/fits": {
        source: "iana"
      },
      "application/flexfec": {
        source: "iana"
      },
      "application/font-sfnt": {
        source: "iana"
      },
      "application/font-tdpfr": {
        source: "iana",
        extensions: ["pfr"]
      },
      "application/font-woff": {
        source: "iana",
        compressible: false
      },
      "application/framework-attributes+xml": {
        source: "iana",
        compressible: true
      },
      "application/geo+json": {
        source: "iana",
        compressible: true,
        extensions: ["geojson"]
      },
      "application/geo+json-seq": {
        source: "iana"
      },
      "application/geopackage+sqlite3": {
        source: "iana"
      },
      "application/geoxacml+xml": {
        source: "iana",
        compressible: true
      },
      "application/gltf-buffer": {
        source: "iana"
      },
      "application/gml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["gml"]
      },
      "application/gpx+xml": {
        source: "apache",
        compressible: true,
        extensions: ["gpx"]
      },
      "application/gxf": {
        source: "apache",
        extensions: ["gxf"]
      },
      "application/gzip": {
        source: "iana",
        compressible: false,
        extensions: ["gz"]
      },
      "application/h224": {
        source: "iana"
      },
      "application/held+xml": {
        source: "iana",
        compressible: true
      },
      "application/hjson": {
        extensions: ["hjson"]
      },
      "application/http": {
        source: "iana"
      },
      "application/hyperstudio": {
        source: "iana",
        extensions: ["stk"]
      },
      "application/ibe-key-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/ibe-pkg-reply+xml": {
        source: "iana",
        compressible: true
      },
      "application/ibe-pp-data": {
        source: "iana"
      },
      "application/iges": {
        source: "iana"
      },
      "application/im-iscomposing+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/index": {
        source: "iana"
      },
      "application/index.cmd": {
        source: "iana"
      },
      "application/index.obj": {
        source: "iana"
      },
      "application/index.response": {
        source: "iana"
      },
      "application/index.vnd": {
        source: "iana"
      },
      "application/inkml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ink", "inkml"]
      },
      "application/iotp": {
        source: "iana"
      },
      "application/ipfix": {
        source: "iana",
        extensions: ["ipfix"]
      },
      "application/ipp": {
        source: "iana"
      },
      "application/isup": {
        source: "iana"
      },
      "application/its+xml": {
        source: "iana",
        compressible: true,
        extensions: ["its"]
      },
      "application/java-archive": {
        source: "apache",
        compressible: false,
        extensions: ["jar", "war", "ear"]
      },
      "application/java-serialized-object": {
        source: "apache",
        compressible: false,
        extensions: ["ser"]
      },
      "application/java-vm": {
        source: "apache",
        compressible: false,
        extensions: ["class"]
      },
      "application/javascript": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["js", "mjs"]
      },
      "application/jf2feed+json": {
        source: "iana",
        compressible: true
      },
      "application/jose": {
        source: "iana"
      },
      "application/jose+json": {
        source: "iana",
        compressible: true
      },
      "application/jrd+json": {
        source: "iana",
        compressible: true
      },
      "application/jscalendar+json": {
        source: "iana",
        compressible: true
      },
      "application/json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["json", "map"]
      },
      "application/json-patch+json": {
        source: "iana",
        compressible: true
      },
      "application/json-seq": {
        source: "iana"
      },
      "application/json5": {
        extensions: ["json5"]
      },
      "application/jsonml+json": {
        source: "apache",
        compressible: true,
        extensions: ["jsonml"]
      },
      "application/jwk+json": {
        source: "iana",
        compressible: true
      },
      "application/jwk-set+json": {
        source: "iana",
        compressible: true
      },
      "application/jwt": {
        source: "iana"
      },
      "application/kpml-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/kpml-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/ld+json": {
        source: "iana",
        compressible: true,
        extensions: ["jsonld"]
      },
      "application/lgr+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lgr"]
      },
      "application/link-format": {
        source: "iana"
      },
      "application/load-control+xml": {
        source: "iana",
        compressible: true
      },
      "application/lost+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lostxml"]
      },
      "application/lostsync+xml": {
        source: "iana",
        compressible: true
      },
      "application/lpf+zip": {
        source: "iana",
        compressible: false
      },
      "application/lxf": {
        source: "iana"
      },
      "application/mac-binhex40": {
        source: "iana",
        extensions: ["hqx"]
      },
      "application/mac-compactpro": {
        source: "apache",
        extensions: ["cpt"]
      },
      "application/macwriteii": {
        source: "iana"
      },
      "application/mads+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mads"]
      },
      "application/manifest+json": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["webmanifest"]
      },
      "application/marc": {
        source: "iana",
        extensions: ["mrc"]
      },
      "application/marcxml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mrcx"]
      },
      "application/mathematica": {
        source: "iana",
        extensions: ["ma", "nb", "mb"]
      },
      "application/mathml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mathml"]
      },
      "application/mathml-content+xml": {
        source: "iana",
        compressible: true
      },
      "application/mathml-presentation+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-associated-procedure-description+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-deregister+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-envelope+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-msk+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-msk-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-protection-description+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-reception-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-register+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-register-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-schedule+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbms-user-service-description+xml": {
        source: "iana",
        compressible: true
      },
      "application/mbox": {
        source: "iana",
        extensions: ["mbox"]
      },
      "application/media-policy-dataset+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpf"]
      },
      "application/media_control+xml": {
        source: "iana",
        compressible: true
      },
      "application/mediaservercontrol+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mscml"]
      },
      "application/merge-patch+json": {
        source: "iana",
        compressible: true
      },
      "application/metalink+xml": {
        source: "apache",
        compressible: true,
        extensions: ["metalink"]
      },
      "application/metalink4+xml": {
        source: "iana",
        compressible: true,
        extensions: ["meta4"]
      },
      "application/mets+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mets"]
      },
      "application/mf4": {
        source: "iana"
      },
      "application/mikey": {
        source: "iana"
      },
      "application/mipc": {
        source: "iana"
      },
      "application/missing-blocks+cbor-seq": {
        source: "iana"
      },
      "application/mmt-aei+xml": {
        source: "iana",
        compressible: true,
        extensions: ["maei"]
      },
      "application/mmt-usd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["musd"]
      },
      "application/mods+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mods"]
      },
      "application/moss-keys": {
        source: "iana"
      },
      "application/moss-signature": {
        source: "iana"
      },
      "application/mosskey-data": {
        source: "iana"
      },
      "application/mosskey-request": {
        source: "iana"
      },
      "application/mp21": {
        source: "iana",
        extensions: ["m21", "mp21"]
      },
      "application/mp4": {
        source: "iana",
        extensions: ["mp4s", "m4p"]
      },
      "application/mpeg4-generic": {
        source: "iana"
      },
      "application/mpeg4-iod": {
        source: "iana"
      },
      "application/mpeg4-iod-xmt": {
        source: "iana"
      },
      "application/mrb-consumer+xml": {
        source: "iana",
        compressible: true
      },
      "application/mrb-publish+xml": {
        source: "iana",
        compressible: true
      },
      "application/msc-ivr+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/msc-mixer+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/msword": {
        source: "iana",
        compressible: false,
        extensions: ["doc", "dot"]
      },
      "application/mud+json": {
        source: "iana",
        compressible: true
      },
      "application/multipart-core": {
        source: "iana"
      },
      "application/mxf": {
        source: "iana",
        extensions: ["mxf"]
      },
      "application/n-quads": {
        source: "iana",
        extensions: ["nq"]
      },
      "application/n-triples": {
        source: "iana",
        extensions: ["nt"]
      },
      "application/nasdata": {
        source: "iana"
      },
      "application/news-checkgroups": {
        source: "iana",
        charset: "US-ASCII"
      },
      "application/news-groupinfo": {
        source: "iana",
        charset: "US-ASCII"
      },
      "application/news-transmission": {
        source: "iana"
      },
      "application/nlsml+xml": {
        source: "iana",
        compressible: true
      },
      "application/node": {
        source: "iana",
        extensions: ["cjs"]
      },
      "application/nss": {
        source: "iana"
      },
      "application/oauth-authz-req+jwt": {
        source: "iana"
      },
      "application/oblivious-dns-message": {
        source: "iana"
      },
      "application/ocsp-request": {
        source: "iana"
      },
      "application/ocsp-response": {
        source: "iana"
      },
      "application/octet-stream": {
        source: "iana",
        compressible: false,
        extensions: ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"]
      },
      "application/oda": {
        source: "iana",
        extensions: ["oda"]
      },
      "application/odm+xml": {
        source: "iana",
        compressible: true
      },
      "application/odx": {
        source: "iana"
      },
      "application/oebps-package+xml": {
        source: "iana",
        compressible: true,
        extensions: ["opf"]
      },
      "application/ogg": {
        source: "iana",
        compressible: false,
        extensions: ["ogx"]
      },
      "application/omdoc+xml": {
        source: "apache",
        compressible: true,
        extensions: ["omdoc"]
      },
      "application/onenote": {
        source: "apache",
        extensions: ["onetoc", "onetoc2", "onetmp", "onepkg"]
      },
      "application/opc-nodeset+xml": {
        source: "iana",
        compressible: true
      },
      "application/oscore": {
        source: "iana"
      },
      "application/oxps": {
        source: "iana",
        extensions: ["oxps"]
      },
      "application/p21": {
        source: "iana"
      },
      "application/p21+zip": {
        source: "iana",
        compressible: false
      },
      "application/p2p-overlay+xml": {
        source: "iana",
        compressible: true,
        extensions: ["relo"]
      },
      "application/parityfec": {
        source: "iana"
      },
      "application/passport": {
        source: "iana"
      },
      "application/patch-ops-error+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xer"]
      },
      "application/pdf": {
        source: "iana",
        compressible: false,
        extensions: ["pdf"]
      },
      "application/pdx": {
        source: "iana"
      },
      "application/pem-certificate-chain": {
        source: "iana"
      },
      "application/pgp-encrypted": {
        source: "iana",
        compressible: false,
        extensions: ["pgp"]
      },
      "application/pgp-keys": {
        source: "iana",
        extensions: ["asc"]
      },
      "application/pgp-signature": {
        source: "iana",
        extensions: ["asc", "sig"]
      },
      "application/pics-rules": {
        source: "apache",
        extensions: ["prf"]
      },
      "application/pidf+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/pidf-diff+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/pkcs10": {
        source: "iana",
        extensions: ["p10"]
      },
      "application/pkcs12": {
        source: "iana"
      },
      "application/pkcs7-mime": {
        source: "iana",
        extensions: ["p7m", "p7c"]
      },
      "application/pkcs7-signature": {
        source: "iana",
        extensions: ["p7s"]
      },
      "application/pkcs8": {
        source: "iana",
        extensions: ["p8"]
      },
      "application/pkcs8-encrypted": {
        source: "iana"
      },
      "application/pkix-attr-cert": {
        source: "iana",
        extensions: ["ac"]
      },
      "application/pkix-cert": {
        source: "iana",
        extensions: ["cer"]
      },
      "application/pkix-crl": {
        source: "iana",
        extensions: ["crl"]
      },
      "application/pkix-pkipath": {
        source: "iana",
        extensions: ["pkipath"]
      },
      "application/pkixcmp": {
        source: "iana",
        extensions: ["pki"]
      },
      "application/pls+xml": {
        source: "iana",
        compressible: true,
        extensions: ["pls"]
      },
      "application/poc-settings+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/postscript": {
        source: "iana",
        compressible: true,
        extensions: ["ai", "eps", "ps"]
      },
      "application/ppsp-tracker+json": {
        source: "iana",
        compressible: true
      },
      "application/problem+json": {
        source: "iana",
        compressible: true
      },
      "application/problem+xml": {
        source: "iana",
        compressible: true
      },
      "application/provenance+xml": {
        source: "iana",
        compressible: true,
        extensions: ["provx"]
      },
      "application/prs.alvestrand.titrax-sheet": {
        source: "iana"
      },
      "application/prs.cww": {
        source: "iana",
        extensions: ["cww"]
      },
      "application/prs.cyn": {
        source: "iana",
        charset: "7-BIT"
      },
      "application/prs.hpub+zip": {
        source: "iana",
        compressible: false
      },
      "application/prs.nprend": {
        source: "iana"
      },
      "application/prs.plucker": {
        source: "iana"
      },
      "application/prs.rdf-xml-crypt": {
        source: "iana"
      },
      "application/prs.xsf+xml": {
        source: "iana",
        compressible: true
      },
      "application/pskc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["pskcxml"]
      },
      "application/pvd+json": {
        source: "iana",
        compressible: true
      },
      "application/qsig": {
        source: "iana"
      },
      "application/raml+yaml": {
        compressible: true,
        extensions: ["raml"]
      },
      "application/raptorfec": {
        source: "iana"
      },
      "application/rdap+json": {
        source: "iana",
        compressible: true
      },
      "application/rdf+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rdf", "owl"]
      },
      "application/reginfo+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rif"]
      },
      "application/relax-ng-compact-syntax": {
        source: "iana",
        extensions: ["rnc"]
      },
      "application/remote-printing": {
        source: "iana"
      },
      "application/reputon+json": {
        source: "iana",
        compressible: true
      },
      "application/resource-lists+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rl"]
      },
      "application/resource-lists-diff+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rld"]
      },
      "application/rfc+xml": {
        source: "iana",
        compressible: true
      },
      "application/riscos": {
        source: "iana"
      },
      "application/rlmi+xml": {
        source: "iana",
        compressible: true
      },
      "application/rls-services+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rs"]
      },
      "application/route-apd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rapd"]
      },
      "application/route-s-tsid+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sls"]
      },
      "application/route-usd+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rusd"]
      },
      "application/rpki-ghostbusters": {
        source: "iana",
        extensions: ["gbr"]
      },
      "application/rpki-manifest": {
        source: "iana",
        extensions: ["mft"]
      },
      "application/rpki-publication": {
        source: "iana"
      },
      "application/rpki-roa": {
        source: "iana",
        extensions: ["roa"]
      },
      "application/rpki-updown": {
        source: "iana"
      },
      "application/rsd+xml": {
        source: "apache",
        compressible: true,
        extensions: ["rsd"]
      },
      "application/rss+xml": {
        source: "apache",
        compressible: true,
        extensions: ["rss"]
      },
      "application/rtf": {
        source: "iana",
        compressible: true,
        extensions: ["rtf"]
      },
      "application/rtploopback": {
        source: "iana"
      },
      "application/rtx": {
        source: "iana"
      },
      "application/samlassertion+xml": {
        source: "iana",
        compressible: true
      },
      "application/samlmetadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/sarif+json": {
        source: "iana",
        compressible: true
      },
      "application/sarif-external-properties+json": {
        source: "iana",
        compressible: true
      },
      "application/sbe": {
        source: "iana"
      },
      "application/sbml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sbml"]
      },
      "application/scaip+xml": {
        source: "iana",
        compressible: true
      },
      "application/scim+json": {
        source: "iana",
        compressible: true
      },
      "application/scvp-cv-request": {
        source: "iana",
        extensions: ["scq"]
      },
      "application/scvp-cv-response": {
        source: "iana",
        extensions: ["scs"]
      },
      "application/scvp-vp-request": {
        source: "iana",
        extensions: ["spq"]
      },
      "application/scvp-vp-response": {
        source: "iana",
        extensions: ["spp"]
      },
      "application/sdp": {
        source: "iana",
        extensions: ["sdp"]
      },
      "application/secevent+jwt": {
        source: "iana"
      },
      "application/senml+cbor": {
        source: "iana"
      },
      "application/senml+json": {
        source: "iana",
        compressible: true
      },
      "application/senml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["senmlx"]
      },
      "application/senml-etch+cbor": {
        source: "iana"
      },
      "application/senml-etch+json": {
        source: "iana",
        compressible: true
      },
      "application/senml-exi": {
        source: "iana"
      },
      "application/sensml+cbor": {
        source: "iana"
      },
      "application/sensml+json": {
        source: "iana",
        compressible: true
      },
      "application/sensml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sensmlx"]
      },
      "application/sensml-exi": {
        source: "iana"
      },
      "application/sep+xml": {
        source: "iana",
        compressible: true
      },
      "application/sep-exi": {
        source: "iana"
      },
      "application/session-info": {
        source: "iana"
      },
      "application/set-payment": {
        source: "iana"
      },
      "application/set-payment-initiation": {
        source: "iana",
        extensions: ["setpay"]
      },
      "application/set-registration": {
        source: "iana"
      },
      "application/set-registration-initiation": {
        source: "iana",
        extensions: ["setreg"]
      },
      "application/sgml": {
        source: "iana"
      },
      "application/sgml-open-catalog": {
        source: "iana"
      },
      "application/shf+xml": {
        source: "iana",
        compressible: true,
        extensions: ["shf"]
      },
      "application/sieve": {
        source: "iana",
        extensions: ["siv", "sieve"]
      },
      "application/simple-filter+xml": {
        source: "iana",
        compressible: true
      },
      "application/simple-message-summary": {
        source: "iana"
      },
      "application/simplesymbolcontainer": {
        source: "iana"
      },
      "application/sipc": {
        source: "iana"
      },
      "application/slate": {
        source: "iana"
      },
      "application/smil": {
        source: "iana"
      },
      "application/smil+xml": {
        source: "iana",
        compressible: true,
        extensions: ["smi", "smil"]
      },
      "application/smpte336m": {
        source: "iana"
      },
      "application/soap+fastinfoset": {
        source: "iana"
      },
      "application/soap+xml": {
        source: "iana",
        compressible: true
      },
      "application/sparql-query": {
        source: "iana",
        extensions: ["rq"]
      },
      "application/sparql-results+xml": {
        source: "iana",
        compressible: true,
        extensions: ["srx"]
      },
      "application/spdx+json": {
        source: "iana",
        compressible: true
      },
      "application/spirits-event+xml": {
        source: "iana",
        compressible: true
      },
      "application/sql": {
        source: "iana"
      },
      "application/srgs": {
        source: "iana",
        extensions: ["gram"]
      },
      "application/srgs+xml": {
        source: "iana",
        compressible: true,
        extensions: ["grxml"]
      },
      "application/sru+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sru"]
      },
      "application/ssdl+xml": {
        source: "apache",
        compressible: true,
        extensions: ["ssdl"]
      },
      "application/ssml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ssml"]
      },
      "application/stix+json": {
        source: "iana",
        compressible: true
      },
      "application/swid+xml": {
        source: "iana",
        compressible: true,
        extensions: ["swidtag"]
      },
      "application/tamp-apex-update": {
        source: "iana"
      },
      "application/tamp-apex-update-confirm": {
        source: "iana"
      },
      "application/tamp-community-update": {
        source: "iana"
      },
      "application/tamp-community-update-confirm": {
        source: "iana"
      },
      "application/tamp-error": {
        source: "iana"
      },
      "application/tamp-sequence-adjust": {
        source: "iana"
      },
      "application/tamp-sequence-adjust-confirm": {
        source: "iana"
      },
      "application/tamp-status-query": {
        source: "iana"
      },
      "application/tamp-status-response": {
        source: "iana"
      },
      "application/tamp-update": {
        source: "iana"
      },
      "application/tamp-update-confirm": {
        source: "iana"
      },
      "application/tar": {
        compressible: true
      },
      "application/taxii+json": {
        source: "iana",
        compressible: true
      },
      "application/td+json": {
        source: "iana",
        compressible: true
      },
      "application/tei+xml": {
        source: "iana",
        compressible: true,
        extensions: ["tei", "teicorpus"]
      },
      "application/tetra_isi": {
        source: "iana"
      },
      "application/thraud+xml": {
        source: "iana",
        compressible: true,
        extensions: ["tfi"]
      },
      "application/timestamp-query": {
        source: "iana"
      },
      "application/timestamp-reply": {
        source: "iana"
      },
      "application/timestamped-data": {
        source: "iana",
        extensions: ["tsd"]
      },
      "application/tlsrpt+gzip": {
        source: "iana"
      },
      "application/tlsrpt+json": {
        source: "iana",
        compressible: true
      },
      "application/tnauthlist": {
        source: "iana"
      },
      "application/token-introspection+jwt": {
        source: "iana"
      },
      "application/toml": {
        compressible: true,
        extensions: ["toml"]
      },
      "application/trickle-ice-sdpfrag": {
        source: "iana"
      },
      "application/trig": {
        source: "iana",
        extensions: ["trig"]
      },
      "application/ttml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ttml"]
      },
      "application/tve-trigger": {
        source: "iana"
      },
      "application/tzif": {
        source: "iana"
      },
      "application/tzif-leap": {
        source: "iana"
      },
      "application/ubjson": {
        compressible: false,
        extensions: ["ubj"]
      },
      "application/ulpfec": {
        source: "iana"
      },
      "application/urc-grpsheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/urc-ressheet+xml": {
        source: "iana",
        compressible: true,
        extensions: ["rsheet"]
      },
      "application/urc-targetdesc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["td"]
      },
      "application/urc-uisocketdesc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vcard+json": {
        source: "iana",
        compressible: true
      },
      "application/vcard+xml": {
        source: "iana",
        compressible: true
      },
      "application/vemmi": {
        source: "iana"
      },
      "application/vividence.scriptfile": {
        source: "apache"
      },
      "application/vnd.1000minds.decision-model+xml": {
        source: "iana",
        compressible: true,
        extensions: ["1km"]
      },
      "application/vnd.3gpp-prose+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp-prose-pc3ch+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp-v2x-local-service-information": {
        source: "iana"
      },
      "application/vnd.3gpp.5gnas": {
        source: "iana"
      },
      "application/vnd.3gpp.access-transfer-events+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.bsf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.gmop+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.gtpc": {
        source: "iana"
      },
      "application/vnd.3gpp.interworking-data": {
        source: "iana"
      },
      "application/vnd.3gpp.lpp": {
        source: "iana"
      },
      "application/vnd.3gpp.mc-signalling-ear": {
        source: "iana"
      },
      "application/vnd.3gpp.mcdata-affiliation-command+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-payload": {
        source: "iana"
      },
      "application/vnd.3gpp.mcdata-service-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-signalling": {
        source: "iana"
      },
      "application/vnd.3gpp.mcdata-ue-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcdata-user-profile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-affiliation-command+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-floor-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-location-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-mbms-usage-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-service-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-signed+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-ue-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-ue-init-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcptt-user-profile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-affiliation-command+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-affiliation-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-location-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-service-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-transmission-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-ue-config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mcvideo-user-profile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.mid-call+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.ngap": {
        source: "iana"
      },
      "application/vnd.3gpp.pfcp": {
        source: "iana"
      },
      "application/vnd.3gpp.pic-bw-large": {
        source: "iana",
        extensions: ["plb"]
      },
      "application/vnd.3gpp.pic-bw-small": {
        source: "iana",
        extensions: ["psb"]
      },
      "application/vnd.3gpp.pic-bw-var": {
        source: "iana",
        extensions: ["pvb"]
      },
      "application/vnd.3gpp.s1ap": {
        source: "iana"
      },
      "application/vnd.3gpp.sms": {
        source: "iana"
      },
      "application/vnd.3gpp.sms+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.srvcc-ext+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.srvcc-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.state-and-event-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp.ussd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp2.bcmcsinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.3gpp2.sms": {
        source: "iana"
      },
      "application/vnd.3gpp2.tcap": {
        source: "iana",
        extensions: ["tcap"]
      },
      "application/vnd.3lightssoftware.imagescal": {
        source: "iana"
      },
      "application/vnd.3m.post-it-notes": {
        source: "iana",
        extensions: ["pwn"]
      },
      "application/vnd.accpac.simply.aso": {
        source: "iana",
        extensions: ["aso"]
      },
      "application/vnd.accpac.simply.imp": {
        source: "iana",
        extensions: ["imp"]
      },
      "application/vnd.acucobol": {
        source: "iana",
        extensions: ["acu"]
      },
      "application/vnd.acucorp": {
        source: "iana",
        extensions: ["atc", "acutc"]
      },
      "application/vnd.adobe.air-application-installer-package+zip": {
        source: "apache",
        compressible: false,
        extensions: ["air"]
      },
      "application/vnd.adobe.flash.movie": {
        source: "iana"
      },
      "application/vnd.adobe.formscentral.fcdt": {
        source: "iana",
        extensions: ["fcdt"]
      },
      "application/vnd.adobe.fxp": {
        source: "iana",
        extensions: ["fxp", "fxpl"]
      },
      "application/vnd.adobe.partial-upload": {
        source: "iana"
      },
      "application/vnd.adobe.xdp+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdp"]
      },
      "application/vnd.adobe.xfdf": {
        source: "iana",
        extensions: ["xfdf"]
      },
      "application/vnd.aether.imp": {
        source: "iana"
      },
      "application/vnd.afpc.afplinedata": {
        source: "iana"
      },
      "application/vnd.afpc.afplinedata-pagedef": {
        source: "iana"
      },
      "application/vnd.afpc.cmoca-cmresource": {
        source: "iana"
      },
      "application/vnd.afpc.foca-charset": {
        source: "iana"
      },
      "application/vnd.afpc.foca-codedfont": {
        source: "iana"
      },
      "application/vnd.afpc.foca-codepage": {
        source: "iana"
      },
      "application/vnd.afpc.modca": {
        source: "iana"
      },
      "application/vnd.afpc.modca-cmtable": {
        source: "iana"
      },
      "application/vnd.afpc.modca-formdef": {
        source: "iana"
      },
      "application/vnd.afpc.modca-mediummap": {
        source: "iana"
      },
      "application/vnd.afpc.modca-objectcontainer": {
        source: "iana"
      },
      "application/vnd.afpc.modca-overlay": {
        source: "iana"
      },
      "application/vnd.afpc.modca-pagesegment": {
        source: "iana"
      },
      "application/vnd.age": {
        source: "iana",
        extensions: ["age"]
      },
      "application/vnd.ah-barcode": {
        source: "iana"
      },
      "application/vnd.ahead.space": {
        source: "iana",
        extensions: ["ahead"]
      },
      "application/vnd.airzip.filesecure.azf": {
        source: "iana",
        extensions: ["azf"]
      },
      "application/vnd.airzip.filesecure.azs": {
        source: "iana",
        extensions: ["azs"]
      },
      "application/vnd.amadeus+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.amazon.ebook": {
        source: "apache",
        extensions: ["azw"]
      },
      "application/vnd.amazon.mobi8-ebook": {
        source: "iana"
      },
      "application/vnd.americandynamics.acc": {
        source: "iana",
        extensions: ["acc"]
      },
      "application/vnd.amiga.ami": {
        source: "iana",
        extensions: ["ami"]
      },
      "application/vnd.amundsen.maze+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.android.ota": {
        source: "iana"
      },
      "application/vnd.android.package-archive": {
        source: "apache",
        compressible: false,
        extensions: ["apk"]
      },
      "application/vnd.anki": {
        source: "iana"
      },
      "application/vnd.anser-web-certificate-issue-initiation": {
        source: "iana",
        extensions: ["cii"]
      },
      "application/vnd.anser-web-funds-transfer-initiation": {
        source: "apache",
        extensions: ["fti"]
      },
      "application/vnd.antix.game-component": {
        source: "iana",
        extensions: ["atx"]
      },
      "application/vnd.apache.arrow.file": {
        source: "iana"
      },
      "application/vnd.apache.arrow.stream": {
        source: "iana"
      },
      "application/vnd.apache.thrift.binary": {
        source: "iana"
      },
      "application/vnd.apache.thrift.compact": {
        source: "iana"
      },
      "application/vnd.apache.thrift.json": {
        source: "iana"
      },
      "application/vnd.api+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.aplextor.warrp+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.apothekende.reservation+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.apple.installer+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mpkg"]
      },
      "application/vnd.apple.keynote": {
        source: "iana",
        extensions: ["key"]
      },
      "application/vnd.apple.mpegurl": {
        source: "iana",
        extensions: ["m3u8"]
      },
      "application/vnd.apple.numbers": {
        source: "iana",
        extensions: ["numbers"]
      },
      "application/vnd.apple.pages": {
        source: "iana",
        extensions: ["pages"]
      },
      "application/vnd.apple.pkpass": {
        compressible: false,
        extensions: ["pkpass"]
      },
      "application/vnd.arastra.swi": {
        source: "iana"
      },
      "application/vnd.aristanetworks.swi": {
        source: "iana",
        extensions: ["swi"]
      },
      "application/vnd.artisan+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.artsquare": {
        source: "iana"
      },
      "application/vnd.astraea-software.iota": {
        source: "iana",
        extensions: ["iota"]
      },
      "application/vnd.audiograph": {
        source: "iana",
        extensions: ["aep"]
      },
      "application/vnd.autopackage": {
        source: "iana"
      },
      "application/vnd.avalon+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.avistar+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.balsamiq.bmml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["bmml"]
      },
      "application/vnd.balsamiq.bmpr": {
        source: "iana"
      },
      "application/vnd.banana-accounting": {
        source: "iana"
      },
      "application/vnd.bbf.usp.error": {
        source: "iana"
      },
      "application/vnd.bbf.usp.msg": {
        source: "iana"
      },
      "application/vnd.bbf.usp.msg+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.bekitzur-stech+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.bint.med-content": {
        source: "iana"
      },
      "application/vnd.biopax.rdf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.blink-idb-value-wrapper": {
        source: "iana"
      },
      "application/vnd.blueice.multipass": {
        source: "iana",
        extensions: ["mpm"]
      },
      "application/vnd.bluetooth.ep.oob": {
        source: "iana"
      },
      "application/vnd.bluetooth.le.oob": {
        source: "iana"
      },
      "application/vnd.bmi": {
        source: "iana",
        extensions: ["bmi"]
      },
      "application/vnd.bpf": {
        source: "iana"
      },
      "application/vnd.bpf3": {
        source: "iana"
      },
      "application/vnd.businessobjects": {
        source: "iana",
        extensions: ["rep"]
      },
      "application/vnd.byu.uapi+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cab-jscript": {
        source: "iana"
      },
      "application/vnd.canon-cpdl": {
        source: "iana"
      },
      "application/vnd.canon-lips": {
        source: "iana"
      },
      "application/vnd.capasystems-pg+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cendio.thinlinc.clientconf": {
        source: "iana"
      },
      "application/vnd.century-systems.tcp_stream": {
        source: "iana"
      },
      "application/vnd.chemdraw+xml": {
        source: "iana",
        compressible: true,
        extensions: ["cdxml"]
      },
      "application/vnd.chess-pgn": {
        source: "iana"
      },
      "application/vnd.chipnuts.karaoke-mmd": {
        source: "iana",
        extensions: ["mmd"]
      },
      "application/vnd.ciedi": {
        source: "iana"
      },
      "application/vnd.cinderella": {
        source: "iana",
        extensions: ["cdy"]
      },
      "application/vnd.cirpack.isdn-ext": {
        source: "iana"
      },
      "application/vnd.citationstyles.style+xml": {
        source: "iana",
        compressible: true,
        extensions: ["csl"]
      },
      "application/vnd.claymore": {
        source: "iana",
        extensions: ["cla"]
      },
      "application/vnd.cloanto.rp9": {
        source: "iana",
        extensions: ["rp9"]
      },
      "application/vnd.clonk.c4group": {
        source: "iana",
        extensions: ["c4g", "c4d", "c4f", "c4p", "c4u"]
      },
      "application/vnd.cluetrust.cartomobile-config": {
        source: "iana",
        extensions: ["c11amc"]
      },
      "application/vnd.cluetrust.cartomobile-config-pkg": {
        source: "iana",
        extensions: ["c11amz"]
      },
      "application/vnd.coffeescript": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.document": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.document-template": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.presentation": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.presentation-template": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.spreadsheet": {
        source: "iana"
      },
      "application/vnd.collabio.xodocuments.spreadsheet-template": {
        source: "iana"
      },
      "application/vnd.collection+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.collection.doc+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.collection.next+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.comicbook+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.comicbook-rar": {
        source: "iana"
      },
      "application/vnd.commerce-battelle": {
        source: "iana"
      },
      "application/vnd.commonspace": {
        source: "iana",
        extensions: ["csp"]
      },
      "application/vnd.contact.cmsg": {
        source: "iana",
        extensions: ["cdbcmsg"]
      },
      "application/vnd.coreos.ignition+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cosmocaller": {
        source: "iana",
        extensions: ["cmc"]
      },
      "application/vnd.crick.clicker": {
        source: "iana",
        extensions: ["clkx"]
      },
      "application/vnd.crick.clicker.keyboard": {
        source: "iana",
        extensions: ["clkk"]
      },
      "application/vnd.crick.clicker.palette": {
        source: "iana",
        extensions: ["clkp"]
      },
      "application/vnd.crick.clicker.template": {
        source: "iana",
        extensions: ["clkt"]
      },
      "application/vnd.crick.clicker.wordbank": {
        source: "iana",
        extensions: ["clkw"]
      },
      "application/vnd.criticaltools.wbs+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wbs"]
      },
      "application/vnd.cryptii.pipe+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.crypto-shade-file": {
        source: "iana"
      },
      "application/vnd.cryptomator.encrypted": {
        source: "iana"
      },
      "application/vnd.cryptomator.vault": {
        source: "iana"
      },
      "application/vnd.ctc-posml": {
        source: "iana",
        extensions: ["pml"]
      },
      "application/vnd.ctct.ws+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cups-pdf": {
        source: "iana"
      },
      "application/vnd.cups-postscript": {
        source: "iana"
      },
      "application/vnd.cups-ppd": {
        source: "iana",
        extensions: ["ppd"]
      },
      "application/vnd.cups-raster": {
        source: "iana"
      },
      "application/vnd.cups-raw": {
        source: "iana"
      },
      "application/vnd.curl": {
        source: "iana"
      },
      "application/vnd.curl.car": {
        source: "apache",
        extensions: ["car"]
      },
      "application/vnd.curl.pcurl": {
        source: "apache",
        extensions: ["pcurl"]
      },
      "application/vnd.cyan.dean.root+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cybank": {
        source: "iana"
      },
      "application/vnd.cyclonedx+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.cyclonedx+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.d2l.coursepackage1p0+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.d3m-dataset": {
        source: "iana"
      },
      "application/vnd.d3m-problem": {
        source: "iana"
      },
      "application/vnd.dart": {
        source: "iana",
        compressible: true,
        extensions: ["dart"]
      },
      "application/vnd.data-vision.rdz": {
        source: "iana",
        extensions: ["rdz"]
      },
      "application/vnd.datapackage+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dataresource+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dbf": {
        source: "iana",
        extensions: ["dbf"]
      },
      "application/vnd.debian.binary-package": {
        source: "iana"
      },
      "application/vnd.dece.data": {
        source: "iana",
        extensions: ["uvf", "uvvf", "uvd", "uvvd"]
      },
      "application/vnd.dece.ttml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["uvt", "uvvt"]
      },
      "application/vnd.dece.unspecified": {
        source: "iana",
        extensions: ["uvx", "uvvx"]
      },
      "application/vnd.dece.zip": {
        source: "iana",
        extensions: ["uvz", "uvvz"]
      },
      "application/vnd.denovo.fcselayout-link": {
        source: "iana",
        extensions: ["fe_launch"]
      },
      "application/vnd.desmume.movie": {
        source: "iana"
      },
      "application/vnd.dir-bi.plate-dl-nosuffix": {
        source: "iana"
      },
      "application/vnd.dm.delegation+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dna": {
        source: "iana",
        extensions: ["dna"]
      },
      "application/vnd.document+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dolby.mlp": {
        source: "apache",
        extensions: ["mlp"]
      },
      "application/vnd.dolby.mobile.1": {
        source: "iana"
      },
      "application/vnd.dolby.mobile.2": {
        source: "iana"
      },
      "application/vnd.doremir.scorecloud-binary-document": {
        source: "iana"
      },
      "application/vnd.dpgraph": {
        source: "iana",
        extensions: ["dpg"]
      },
      "application/vnd.dreamfactory": {
        source: "iana",
        extensions: ["dfac"]
      },
      "application/vnd.drive+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ds-keypoint": {
        source: "apache",
        extensions: ["kpxx"]
      },
      "application/vnd.dtg.local": {
        source: "iana"
      },
      "application/vnd.dtg.local.flash": {
        source: "iana"
      },
      "application/vnd.dtg.local.html": {
        source: "iana"
      },
      "application/vnd.dvb.ait": {
        source: "iana",
        extensions: ["ait"]
      },
      "application/vnd.dvb.dvbisl+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.dvbj": {
        source: "iana"
      },
      "application/vnd.dvb.esgcontainer": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcdftnotifaccess": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcesgaccess": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcesgaccess2": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcesgpdd": {
        source: "iana"
      },
      "application/vnd.dvb.ipdcroaming": {
        source: "iana"
      },
      "application/vnd.dvb.iptv.alfec-base": {
        source: "iana"
      },
      "application/vnd.dvb.iptv.alfec-enhancement": {
        source: "iana"
      },
      "application/vnd.dvb.notif-aggregate-root+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-container+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-generic+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-ia-msglist+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-ia-registration-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-ia-registration-response+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.notif-init+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.dvb.pfr": {
        source: "iana"
      },
      "application/vnd.dvb.service": {
        source: "iana",
        extensions: ["svc"]
      },
      "application/vnd.dxr": {
        source: "iana"
      },
      "application/vnd.dynageo": {
        source: "iana",
        extensions: ["geo"]
      },
      "application/vnd.dzr": {
        source: "iana"
      },
      "application/vnd.easykaraoke.cdgdownload": {
        source: "iana"
      },
      "application/vnd.ecdis-update": {
        source: "iana"
      },
      "application/vnd.ecip.rlp": {
        source: "iana"
      },
      "application/vnd.eclipse.ditto+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ecowin.chart": {
        source: "iana",
        extensions: ["mag"]
      },
      "application/vnd.ecowin.filerequest": {
        source: "iana"
      },
      "application/vnd.ecowin.fileupdate": {
        source: "iana"
      },
      "application/vnd.ecowin.series": {
        source: "iana"
      },
      "application/vnd.ecowin.seriesrequest": {
        source: "iana"
      },
      "application/vnd.ecowin.seriesupdate": {
        source: "iana"
      },
      "application/vnd.efi.img": {
        source: "iana"
      },
      "application/vnd.efi.iso": {
        source: "iana"
      },
      "application/vnd.emclient.accessrequest+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.enliven": {
        source: "iana",
        extensions: ["nml"]
      },
      "application/vnd.enphase.envoy": {
        source: "iana"
      },
      "application/vnd.eprints.data+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.epson.esf": {
        source: "iana",
        extensions: ["esf"]
      },
      "application/vnd.epson.msf": {
        source: "iana",
        extensions: ["msf"]
      },
      "application/vnd.epson.quickanime": {
        source: "iana",
        extensions: ["qam"]
      },
      "application/vnd.epson.salt": {
        source: "iana",
        extensions: ["slt"]
      },
      "application/vnd.epson.ssf": {
        source: "iana",
        extensions: ["ssf"]
      },
      "application/vnd.ericsson.quickcall": {
        source: "iana"
      },
      "application/vnd.espass-espass+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.eszigno3+xml": {
        source: "iana",
        compressible: true,
        extensions: ["es3", "et3"]
      },
      "application/vnd.etsi.aoc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.asic-e+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.etsi.asic-s+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.etsi.cug+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvcommand+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvdiscovery+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsad-bc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsad-cod+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsad-npvr+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvservice+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvsync+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.iptvueprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.mcid+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.mheg5": {
        source: "iana"
      },
      "application/vnd.etsi.overload-control-policy-dataset+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.pstn+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.sci+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.simservs+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.timestamp-token": {
        source: "iana"
      },
      "application/vnd.etsi.tsl+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.etsi.tsl.der": {
        source: "iana"
      },
      "application/vnd.eu.kasparian.car+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.eudora.data": {
        source: "iana"
      },
      "application/vnd.evolv.ecig.profile": {
        source: "iana"
      },
      "application/vnd.evolv.ecig.settings": {
        source: "iana"
      },
      "application/vnd.evolv.ecig.theme": {
        source: "iana"
      },
      "application/vnd.exstream-empower+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.exstream-package": {
        source: "iana"
      },
      "application/vnd.ezpix-album": {
        source: "iana",
        extensions: ["ez2"]
      },
      "application/vnd.ezpix-package": {
        source: "iana",
        extensions: ["ez3"]
      },
      "application/vnd.f-secure.mobile": {
        source: "iana"
      },
      "application/vnd.familysearch.gedcom+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.fastcopy-disk-image": {
        source: "iana"
      },
      "application/vnd.fdf": {
        source: "iana",
        extensions: ["fdf"]
      },
      "application/vnd.fdsn.mseed": {
        source: "iana",
        extensions: ["mseed"]
      },
      "application/vnd.fdsn.seed": {
        source: "iana",
        extensions: ["seed", "dataless"]
      },
      "application/vnd.ffsns": {
        source: "iana"
      },
      "application/vnd.ficlab.flb+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.filmit.zfc": {
        source: "iana"
      },
      "application/vnd.fints": {
        source: "iana"
      },
      "application/vnd.firemonkeys.cloudcell": {
        source: "iana"
      },
      "application/vnd.flographit": {
        source: "iana",
        extensions: ["gph"]
      },
      "application/vnd.fluxtime.clip": {
        source: "iana",
        extensions: ["ftc"]
      },
      "application/vnd.font-fontforge-sfd": {
        source: "iana"
      },
      "application/vnd.framemaker": {
        source: "iana",
        extensions: ["fm", "frame", "maker", "book"]
      },
      "application/vnd.frogans.fnc": {
        source: "iana",
        extensions: ["fnc"]
      },
      "application/vnd.frogans.ltf": {
        source: "iana",
        extensions: ["ltf"]
      },
      "application/vnd.fsc.weblaunch": {
        source: "iana",
        extensions: ["fsc"]
      },
      "application/vnd.fujifilm.fb.docuworks": {
        source: "iana"
      },
      "application/vnd.fujifilm.fb.docuworks.binder": {
        source: "iana"
      },
      "application/vnd.fujifilm.fb.docuworks.container": {
        source: "iana"
      },
      "application/vnd.fujifilm.fb.jfi+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.fujitsu.oasys": {
        source: "iana",
        extensions: ["oas"]
      },
      "application/vnd.fujitsu.oasys2": {
        source: "iana",
        extensions: ["oa2"]
      },
      "application/vnd.fujitsu.oasys3": {
        source: "iana",
        extensions: ["oa3"]
      },
      "application/vnd.fujitsu.oasysgp": {
        source: "iana",
        extensions: ["fg5"]
      },
      "application/vnd.fujitsu.oasysprs": {
        source: "iana",
        extensions: ["bh2"]
      },
      "application/vnd.fujixerox.art-ex": {
        source: "iana"
      },
      "application/vnd.fujixerox.art4": {
        source: "iana"
      },
      "application/vnd.fujixerox.ddd": {
        source: "iana",
        extensions: ["ddd"]
      },
      "application/vnd.fujixerox.docuworks": {
        source: "iana",
        extensions: ["xdw"]
      },
      "application/vnd.fujixerox.docuworks.binder": {
        source: "iana",
        extensions: ["xbd"]
      },
      "application/vnd.fujixerox.docuworks.container": {
        source: "iana"
      },
      "application/vnd.fujixerox.hbpl": {
        source: "iana"
      },
      "application/vnd.fut-misnet": {
        source: "iana"
      },
      "application/vnd.futoin+cbor": {
        source: "iana"
      },
      "application/vnd.futoin+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.fuzzysheet": {
        source: "iana",
        extensions: ["fzs"]
      },
      "application/vnd.genomatix.tuxedo": {
        source: "iana",
        extensions: ["txd"]
      },
      "application/vnd.gentics.grd+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.geo+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.geocube+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.geogebra.file": {
        source: "iana",
        extensions: ["ggb"]
      },
      "application/vnd.geogebra.slides": {
        source: "iana"
      },
      "application/vnd.geogebra.tool": {
        source: "iana",
        extensions: ["ggt"]
      },
      "application/vnd.geometry-explorer": {
        source: "iana",
        extensions: ["gex", "gre"]
      },
      "application/vnd.geonext": {
        source: "iana",
        extensions: ["gxt"]
      },
      "application/vnd.geoplan": {
        source: "iana",
        extensions: ["g2w"]
      },
      "application/vnd.geospace": {
        source: "iana",
        extensions: ["g3w"]
      },
      "application/vnd.gerber": {
        source: "iana"
      },
      "application/vnd.globalplatform.card-content-mgt": {
        source: "iana"
      },
      "application/vnd.globalplatform.card-content-mgt-response": {
        source: "iana"
      },
      "application/vnd.gmx": {
        source: "iana",
        extensions: ["gmx"]
      },
      "application/vnd.google-apps.document": {
        compressible: false,
        extensions: ["gdoc"]
      },
      "application/vnd.google-apps.presentation": {
        compressible: false,
        extensions: ["gslides"]
      },
      "application/vnd.google-apps.spreadsheet": {
        compressible: false,
        extensions: ["gsheet"]
      },
      "application/vnd.google-earth.kml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["kml"]
      },
      "application/vnd.google-earth.kmz": {
        source: "iana",
        compressible: false,
        extensions: ["kmz"]
      },
      "application/vnd.gov.sk.e-form+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.gov.sk.e-form+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.gov.sk.xmldatacontainer+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.grafeq": {
        source: "iana",
        extensions: ["gqf", "gqs"]
      },
      "application/vnd.gridmp": {
        source: "iana"
      },
      "application/vnd.groove-account": {
        source: "iana",
        extensions: ["gac"]
      },
      "application/vnd.groove-help": {
        source: "iana",
        extensions: ["ghf"]
      },
      "application/vnd.groove-identity-message": {
        source: "iana",
        extensions: ["gim"]
      },
      "application/vnd.groove-injector": {
        source: "iana",
        extensions: ["grv"]
      },
      "application/vnd.groove-tool-message": {
        source: "iana",
        extensions: ["gtm"]
      },
      "application/vnd.groove-tool-template": {
        source: "iana",
        extensions: ["tpl"]
      },
      "application/vnd.groove-vcard": {
        source: "iana",
        extensions: ["vcg"]
      },
      "application/vnd.hal+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hal+xml": {
        source: "iana",
        compressible: true,
        extensions: ["hal"]
      },
      "application/vnd.handheld-entertainment+xml": {
        source: "iana",
        compressible: true,
        extensions: ["zmm"]
      },
      "application/vnd.hbci": {
        source: "iana",
        extensions: ["hbci"]
      },
      "application/vnd.hc+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hcl-bireports": {
        source: "iana"
      },
      "application/vnd.hdt": {
        source: "iana"
      },
      "application/vnd.heroku+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hhe.lesson-player": {
        source: "iana",
        extensions: ["les"]
      },
      "application/vnd.hl7cda+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.hl7v2+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.hp-hpgl": {
        source: "iana",
        extensions: ["hpgl"]
      },
      "application/vnd.hp-hpid": {
        source: "iana",
        extensions: ["hpid"]
      },
      "application/vnd.hp-hps": {
        source: "iana",
        extensions: ["hps"]
      },
      "application/vnd.hp-jlyt": {
        source: "iana",
        extensions: ["jlt"]
      },
      "application/vnd.hp-pcl": {
        source: "iana",
        extensions: ["pcl"]
      },
      "application/vnd.hp-pclxl": {
        source: "iana",
        extensions: ["pclxl"]
      },
      "application/vnd.httphone": {
        source: "iana"
      },
      "application/vnd.hydrostatix.sof-data": {
        source: "iana",
        extensions: ["sfd-hdstx"]
      },
      "application/vnd.hyper+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hyper-item+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hyperdrive+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.hzn-3d-crossword": {
        source: "iana"
      },
      "application/vnd.ibm.afplinedata": {
        source: "iana"
      },
      "application/vnd.ibm.electronic-media": {
        source: "iana"
      },
      "application/vnd.ibm.minipay": {
        source: "iana",
        extensions: ["mpy"]
      },
      "application/vnd.ibm.modcap": {
        source: "iana",
        extensions: ["afp", "listafp", "list3820"]
      },
      "application/vnd.ibm.rights-management": {
        source: "iana",
        extensions: ["irm"]
      },
      "application/vnd.ibm.secure-container": {
        source: "iana",
        extensions: ["sc"]
      },
      "application/vnd.iccprofile": {
        source: "iana",
        extensions: ["icc", "icm"]
      },
      "application/vnd.ieee.1905": {
        source: "iana"
      },
      "application/vnd.igloader": {
        source: "iana",
        extensions: ["igl"]
      },
      "application/vnd.imagemeter.folder+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.imagemeter.image+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.immervision-ivp": {
        source: "iana",
        extensions: ["ivp"]
      },
      "application/vnd.immervision-ivu": {
        source: "iana",
        extensions: ["ivu"]
      },
      "application/vnd.ims.imsccv1p1": {
        source: "iana"
      },
      "application/vnd.ims.imsccv1p2": {
        source: "iana"
      },
      "application/vnd.ims.imsccv1p3": {
        source: "iana"
      },
      "application/vnd.ims.lis.v2.result+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolconsumerprofile+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolproxy+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolproxy.id+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolsettings+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ims.lti.v2.toolsettings.simple+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.informedcontrol.rms+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.informix-visionary": {
        source: "iana"
      },
      "application/vnd.infotech.project": {
        source: "iana"
      },
      "application/vnd.infotech.project+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.innopath.wamp.notification": {
        source: "iana"
      },
      "application/vnd.insors.igm": {
        source: "iana",
        extensions: ["igm"]
      },
      "application/vnd.intercon.formnet": {
        source: "iana",
        extensions: ["xpw", "xpx"]
      },
      "application/vnd.intergeo": {
        source: "iana",
        extensions: ["i2g"]
      },
      "application/vnd.intertrust.digibox": {
        source: "iana"
      },
      "application/vnd.intertrust.nncp": {
        source: "iana"
      },
      "application/vnd.intu.qbo": {
        source: "iana",
        extensions: ["qbo"]
      },
      "application/vnd.intu.qfx": {
        source: "iana",
        extensions: ["qfx"]
      },
      "application/vnd.iptc.g2.catalogitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.conceptitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.knowledgeitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.newsitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.newsmessage+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.packageitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.iptc.g2.planningitem+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ipunplugged.rcprofile": {
        source: "iana",
        extensions: ["rcprofile"]
      },
      "application/vnd.irepository.package+xml": {
        source: "iana",
        compressible: true,
        extensions: ["irp"]
      },
      "application/vnd.is-xpr": {
        source: "iana",
        extensions: ["xpr"]
      },
      "application/vnd.isac.fcs": {
        source: "iana",
        extensions: ["fcs"]
      },
      "application/vnd.iso11783-10+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.jam": {
        source: "iana",
        extensions: ["jam"]
      },
      "application/vnd.japannet-directory-service": {
        source: "iana"
      },
      "application/vnd.japannet-jpnstore-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-payment-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-registration": {
        source: "iana"
      },
      "application/vnd.japannet-registration-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-setstore-wakeup": {
        source: "iana"
      },
      "application/vnd.japannet-verification": {
        source: "iana"
      },
      "application/vnd.japannet-verification-wakeup": {
        source: "iana"
      },
      "application/vnd.jcp.javame.midlet-rms": {
        source: "iana",
        extensions: ["rms"]
      },
      "application/vnd.jisp": {
        source: "iana",
        extensions: ["jisp"]
      },
      "application/vnd.joost.joda-archive": {
        source: "iana",
        extensions: ["joda"]
      },
      "application/vnd.jsk.isdn-ngn": {
        source: "iana"
      },
      "application/vnd.kahootz": {
        source: "iana",
        extensions: ["ktz", "ktr"]
      },
      "application/vnd.kde.karbon": {
        source: "iana",
        extensions: ["karbon"]
      },
      "application/vnd.kde.kchart": {
        source: "iana",
        extensions: ["chrt"]
      },
      "application/vnd.kde.kformula": {
        source: "iana",
        extensions: ["kfo"]
      },
      "application/vnd.kde.kivio": {
        source: "iana",
        extensions: ["flw"]
      },
      "application/vnd.kde.kontour": {
        source: "iana",
        extensions: ["kon"]
      },
      "application/vnd.kde.kpresenter": {
        source: "iana",
        extensions: ["kpr", "kpt"]
      },
      "application/vnd.kde.kspread": {
        source: "iana",
        extensions: ["ksp"]
      },
      "application/vnd.kde.kword": {
        source: "iana",
        extensions: ["kwd", "kwt"]
      },
      "application/vnd.kenameaapp": {
        source: "iana",
        extensions: ["htke"]
      },
      "application/vnd.kidspiration": {
        source: "iana",
        extensions: ["kia"]
      },
      "application/vnd.kinar": {
        source: "iana",
        extensions: ["kne", "knp"]
      },
      "application/vnd.koan": {
        source: "iana",
        extensions: ["skp", "skd", "skt", "skm"]
      },
      "application/vnd.kodak-descriptor": {
        source: "iana",
        extensions: ["sse"]
      },
      "application/vnd.las": {
        source: "iana"
      },
      "application/vnd.las.las+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.las.las+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lasxml"]
      },
      "application/vnd.laszip": {
        source: "iana"
      },
      "application/vnd.leap+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.liberty-request+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.llamagraphics.life-balance.desktop": {
        source: "iana",
        extensions: ["lbd"]
      },
      "application/vnd.llamagraphics.life-balance.exchange+xml": {
        source: "iana",
        compressible: true,
        extensions: ["lbe"]
      },
      "application/vnd.logipipe.circuit+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.loom": {
        source: "iana"
      },
      "application/vnd.lotus-1-2-3": {
        source: "iana",
        extensions: ["123"]
      },
      "application/vnd.lotus-approach": {
        source: "iana",
        extensions: ["apr"]
      },
      "application/vnd.lotus-freelance": {
        source: "iana",
        extensions: ["pre"]
      },
      "application/vnd.lotus-notes": {
        source: "iana",
        extensions: ["nsf"]
      },
      "application/vnd.lotus-organizer": {
        source: "iana",
        extensions: ["org"]
      },
      "application/vnd.lotus-screencam": {
        source: "iana",
        extensions: ["scm"]
      },
      "application/vnd.lotus-wordpro": {
        source: "iana",
        extensions: ["lwp"]
      },
      "application/vnd.macports.portpkg": {
        source: "iana",
        extensions: ["portpkg"]
      },
      "application/vnd.mapbox-vector-tile": {
        source: "iana",
        extensions: ["mvt"]
      },
      "application/vnd.marlin.drm.actiontoken+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.marlin.drm.conftoken+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.marlin.drm.license+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.marlin.drm.mdcf": {
        source: "iana"
      },
      "application/vnd.mason+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.maxar.archive.3tz+zip": {
        source: "iana",
        compressible: false
      },
      "application/vnd.maxmind.maxmind-db": {
        source: "iana"
      },
      "application/vnd.mcd": {
        source: "iana",
        extensions: ["mcd"]
      },
      "application/vnd.medcalcdata": {
        source: "iana",
        extensions: ["mc1"]
      },
      "application/vnd.mediastation.cdkey": {
        source: "iana",
        extensions: ["cdkey"]
      },
      "application/vnd.meridian-slingshot": {
        source: "iana"
      },
      "application/vnd.mfer": {
        source: "iana",
        extensions: ["mwf"]
      },
      "application/vnd.mfmp": {
        source: "iana",
        extensions: ["mfm"]
      },
      "application/vnd.micro+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.micrografx.flo": {
        source: "iana",
        extensions: ["flo"]
      },
      "application/vnd.micrografx.igx": {
        source: "iana",
        extensions: ["igx"]
      },
      "application/vnd.microsoft.portable-executable": {
        source: "iana"
      },
      "application/vnd.microsoft.windows.thumbnail-cache": {
        source: "iana"
      },
      "application/vnd.miele+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.mif": {
        source: "iana",
        extensions: ["mif"]
      },
      "application/vnd.minisoft-hp3000-save": {
        source: "iana"
      },
      "application/vnd.mitsubishi.misty-guard.trustweb": {
        source: "iana"
      },
      "application/vnd.mobius.daf": {
        source: "iana",
        extensions: ["daf"]
      },
      "application/vnd.mobius.dis": {
        source: "iana",
        extensions: ["dis"]
      },
      "application/vnd.mobius.mbk": {
        source: "iana",
        extensions: ["mbk"]
      },
      "application/vnd.mobius.mqy": {
        source: "iana",
        extensions: ["mqy"]
      },
      "application/vnd.mobius.msl": {
        source: "iana",
        extensions: ["msl"]
      },
      "application/vnd.mobius.plc": {
        source: "iana",
        extensions: ["plc"]
      },
      "application/vnd.mobius.txf": {
        source: "iana",
        extensions: ["txf"]
      },
      "application/vnd.mophun.application": {
        source: "iana",
        extensions: ["mpn"]
      },
      "application/vnd.mophun.certificate": {
        source: "iana",
        extensions: ["mpc"]
      },
      "application/vnd.motorola.flexsuite": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.adsi": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.fis": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.gotap": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.kmr": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.ttc": {
        source: "iana"
      },
      "application/vnd.motorola.flexsuite.wem": {
        source: "iana"
      },
      "application/vnd.motorola.iprm": {
        source: "iana"
      },
      "application/vnd.mozilla.xul+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xul"]
      },
      "application/vnd.ms-3mfdocument": {
        source: "iana"
      },
      "application/vnd.ms-artgalry": {
        source: "iana",
        extensions: ["cil"]
      },
      "application/vnd.ms-asf": {
        source: "iana"
      },
      "application/vnd.ms-cab-compressed": {
        source: "iana",
        extensions: ["cab"]
      },
      "application/vnd.ms-color.iccprofile": {
        source: "apache"
      },
      "application/vnd.ms-excel": {
        source: "iana",
        compressible: false,
        extensions: ["xls", "xlm", "xla", "xlc", "xlt", "xlw"]
      },
      "application/vnd.ms-excel.addin.macroenabled.12": {
        source: "iana",
        extensions: ["xlam"]
      },
      "application/vnd.ms-excel.sheet.binary.macroenabled.12": {
        source: "iana",
        extensions: ["xlsb"]
      },
      "application/vnd.ms-excel.sheet.macroenabled.12": {
        source: "iana",
        extensions: ["xlsm"]
      },
      "application/vnd.ms-excel.template.macroenabled.12": {
        source: "iana",
        extensions: ["xltm"]
      },
      "application/vnd.ms-fontobject": {
        source: "iana",
        compressible: true,
        extensions: ["eot"]
      },
      "application/vnd.ms-htmlhelp": {
        source: "iana",
        extensions: ["chm"]
      },
      "application/vnd.ms-ims": {
        source: "iana",
        extensions: ["ims"]
      },
      "application/vnd.ms-lrm": {
        source: "iana",
        extensions: ["lrm"]
      },
      "application/vnd.ms-office.activex+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-officetheme": {
        source: "iana",
        extensions: ["thmx"]
      },
      "application/vnd.ms-opentype": {
        source: "apache",
        compressible: true
      },
      "application/vnd.ms-outlook": {
        compressible: false,
        extensions: ["msg"]
      },
      "application/vnd.ms-package.obfuscated-opentype": {
        source: "apache"
      },
      "application/vnd.ms-pki.seccat": {
        source: "apache",
        extensions: ["cat"]
      },
      "application/vnd.ms-pki.stl": {
        source: "apache",
        extensions: ["stl"]
      },
      "application/vnd.ms-playready.initiator+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-powerpoint": {
        source: "iana",
        compressible: false,
        extensions: ["ppt", "pps", "pot"]
      },
      "application/vnd.ms-powerpoint.addin.macroenabled.12": {
        source: "iana",
        extensions: ["ppam"]
      },
      "application/vnd.ms-powerpoint.presentation.macroenabled.12": {
        source: "iana",
        extensions: ["pptm"]
      },
      "application/vnd.ms-powerpoint.slide.macroenabled.12": {
        source: "iana",
        extensions: ["sldm"]
      },
      "application/vnd.ms-powerpoint.slideshow.macroenabled.12": {
        source: "iana",
        extensions: ["ppsm"]
      },
      "application/vnd.ms-powerpoint.template.macroenabled.12": {
        source: "iana",
        extensions: ["potm"]
      },
      "application/vnd.ms-printdevicecapabilities+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-printing.printticket+xml": {
        source: "apache",
        compressible: true
      },
      "application/vnd.ms-printschematicket+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ms-project": {
        source: "iana",
        extensions: ["mpp", "mpt"]
      },
      "application/vnd.ms-tnef": {
        source: "iana"
      },
      "application/vnd.ms-windows.devicepairing": {
        source: "iana"
      },
      "application/vnd.ms-windows.nwprinting.oob": {
        source: "iana"
      },
      "application/vnd.ms-windows.printerpairing": {
        source: "iana"
      },
      "application/vnd.ms-windows.wsd.oob": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.lic-chlg-req": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.lic-resp": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.meter-chlg-req": {
        source: "iana"
      },
      "application/vnd.ms-wmdrm.meter-resp": {
        source: "iana"
      },
      "application/vnd.ms-word.document.macroenabled.12": {
        source: "iana",
        extensions: ["docm"]
      },
      "application/vnd.ms-word.template.macroenabled.12": {
        source: "iana",
        extensions: ["dotm"]
      },
      "application/vnd.ms-works": {
        source: "iana",
        extensions: ["wps", "wks", "wcm", "wdb"]
      },
      "application/vnd.ms-wpl": {
        source: "iana",
        extensions: ["wpl"]
      },
      "application/vnd.ms-xpsdocument": {
        source: "iana",
        compressible: false,
        extensions: ["xps"]
      },
      "application/vnd.msa-disk-image": {
        source: "iana"
      },
      "application/vnd.mseq": {
        source: "iana",
        extensions: ["mseq"]
      },
      "application/vnd.msign": {
        source: "iana"
      },
      "application/vnd.multiad.creator": {
        source: "iana"
      },
      "application/vnd.multiad.creator.cif": {
        source: "iana"
      },
      "application/vnd.music-niff": {
        source: "iana"
      },
      "application/vnd.musician": {
        source: "iana",
        extensions: ["mus"]
      },
      "application/vnd.muvee.style": {
        source: "iana",
        extensions: ["msty"]
      },
      "application/vnd.mynfc": {
        source: "iana",
        extensions: ["taglet"]
      },
      "application/vnd.nacamar.ybrid+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.ncd.control": {
        source: "iana"
      },
      "application/vnd.ncd.reference": {
        source: "iana"
      },
      "application/vnd.nearst.inv+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nebumind.line": {
        source: "iana"
      },
      "application/vnd.nervana": {
        source: "iana"
      },
      "application/vnd.netfpx": {
        source: "iana"
      },
      "application/vnd.neurolanguage.nlu": {
        source: "iana",
        extensions: ["nlu"]
      },
      "application/vnd.nimn": {
        source: "iana"
      },
      "application/vnd.nintendo.nitro.rom": {
        source: "iana"
      },
      "application/vnd.nintendo.snes.rom": {
        source: "iana"
      },
      "application/vnd.nitf": {
        source: "iana",
        extensions: ["ntf", "nitf"]
      },
      "application/vnd.noblenet-directory": {
        source: "iana",
        extensions: ["nnd"]
      },
      "application/vnd.noblenet-sealer": {
        source: "iana",
        extensions: ["nns"]
      },
      "application/vnd.noblenet-web": {
        source: "iana",
        extensions: ["nnw"]
      },
      "application/vnd.nokia.catalogs": {
        source: "iana"
      },
      "application/vnd.nokia.conml+wbxml": {
        source: "iana"
      },
      "application/vnd.nokia.conml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.iptv.config+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.isds-radio-presets": {
        source: "iana"
      },
      "application/vnd.nokia.landmark+wbxml": {
        source: "iana"
      },
      "application/vnd.nokia.landmark+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.landmarkcollection+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.n-gage.ac+xml": {
        source: "iana",
        compressible: true,
        extensions: ["ac"]
      },
      "application/vnd.nokia.n-gage.data": {
        source: "iana",
        extensions: ["ngdat"]
      },
      "application/vnd.nokia.n-gage.symbian.install": {
        source: "iana",
        extensions: ["n-gage"]
      },
      "application/vnd.nokia.ncd": {
        source: "iana"
      },
      "application/vnd.nokia.pcd+wbxml": {
        source: "iana"
      },
      "application/vnd.nokia.pcd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.nokia.radio-preset": {
        source: "iana",
        extensions: ["rpst"]
      },
      "application/vnd.nokia.radio-presets": {
        source: "iana",
        extensions: ["rpss"]
      },
      "application/vnd.novadigm.edm": {
        source: "iana",
        extensions: ["edm"]
      },
      "application/vnd.novadigm.edx": {
        source: "iana",
        extensions: ["edx"]
      },
      "application/vnd.novadigm.ext": {
        source: "iana",
        extensions: ["ext"]
      },
      "application/vnd.ntt-local.content-share": {
        source: "iana"
      },
      "application/vnd.ntt-local.file-transfer": {
        source: "iana"
      },
      "application/vnd.ntt-local.ogw_remote-access": {
        source: "iana"
      },
      "application/vnd.ntt-local.sip-ta_remote": {
        source: "iana"
      },
      "application/vnd.ntt-local.sip-ta_tcp_stream": {
        source: "iana"
      },
      "application/vnd.oasis.opendocument.chart": {
        source: "iana",
        extensions: ["odc"]
      },
      "application/vnd.oasis.opendocument.chart-template": {
        source: "iana",
        extensions: ["otc"]
      },
      "application/vnd.oasis.opendocument.database": {
        source: "iana",
        extensions: ["odb"]
      },
      "application/vnd.oasis.opendocument.formula": {
        source: "iana",
        extensions: ["odf"]
      },
      "application/vnd.oasis.opendocument.formula-template": {
        source: "iana",
        extensions: ["odft"]
      },
      "application/vnd.oasis.opendocument.graphics": {
        source: "iana",
        compressible: false,
        extensions: ["odg"]
      },
      "application/vnd.oasis.opendocument.graphics-template": {
        source: "iana",
        extensions: ["otg"]
      },
      "application/vnd.oasis.opendocument.image": {
        source: "iana",
        extensions: ["odi"]
      },
      "application/vnd.oasis.opendocument.image-template": {
        source: "iana",
        extensions: ["oti"]
      },
      "application/vnd.oasis.opendocument.presentation": {
        source: "iana",
        compressible: false,
        extensions: ["odp"]
      },
      "application/vnd.oasis.opendocument.presentation-template": {
        source: "iana",
        extensions: ["otp"]
      },
      "application/vnd.oasis.opendocument.spreadsheet": {
        source: "iana",
        compressible: false,
        extensions: ["ods"]
      },
      "application/vnd.oasis.opendocument.spreadsheet-template": {
        source: "iana",
        extensions: ["ots"]
      },
      "application/vnd.oasis.opendocument.text": {
        source: "iana",
        compressible: false,
        extensions: ["odt"]
      },
      "application/vnd.oasis.opendocument.text-master": {
        source: "iana",
        extensions: ["odm"]
      },
      "application/vnd.oasis.opendocument.text-template": {
        source: "iana",
        extensions: ["ott"]
      },
      "application/vnd.oasis.opendocument.text-web": {
        source: "iana",
        extensions: ["oth"]
      },
      "application/vnd.obn": {
        source: "iana"
      },
      "application/vnd.ocf+cbor": {
        source: "iana"
      },
      "application/vnd.oci.image.manifest.v1+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oftn.l10n+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.contentaccessdownload+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.contentaccessstreaming+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.cspg-hexbinary": {
        source: "iana"
      },
      "application/vnd.oipf.dae.svg+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.dae.xhtml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.mippvcontrolmessage+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.pae.gem": {
        source: "iana"
      },
      "application/vnd.oipf.spdiscovery+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.spdlist+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.ueprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oipf.userprofile+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.olpc-sugar": {
        source: "iana",
        extensions: ["xo"]
      },
      "application/vnd.oma-scws-config": {
        source: "iana"
      },
      "application/vnd.oma-scws-http-request": {
        source: "iana"
      },
      "application/vnd.oma-scws-http-response": {
        source: "iana"
      },
      "application/vnd.oma.bcast.associated-procedure-parameter+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.drm-trigger+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.imd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.ltkm": {
        source: "iana"
      },
      "application/vnd.oma.bcast.notification+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.provisioningtrigger": {
        source: "iana"
      },
      "application/vnd.oma.bcast.sgboot": {
        source: "iana"
      },
      "application/vnd.oma.bcast.sgdd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.sgdu": {
        source: "iana"
      },
      "application/vnd.oma.bcast.simple-symbol-container": {
        source: "iana"
      },
      "application/vnd.oma.bcast.smartcard-trigger+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.sprov+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.bcast.stkm": {
        source: "iana"
      },
      "application/vnd.oma.cab-address-book+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-feature-handler+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-pcc+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-subs-invite+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.cab-user-prefs+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.dcd": {
        source: "iana"
      },
      "application/vnd.oma.dcdc": {
        source: "iana"
      },
      "application/vnd.oma.dd2+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dd2"]
      },
      "application/vnd.oma.drm.risd+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.group-usage-list+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.lwm2m+cbor": {
        source: "iana"
      },
      "application/vnd.oma.lwm2m+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.lwm2m+tlv": {
        source: "iana"
      },
      "application/vnd.oma.pal+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.detailed-progress-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.final-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.groups+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.invocation-descriptor+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.poc.optimized-progress-report+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.push": {
        source: "iana"
      },
      "application/vnd.oma.scidm.messages+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oma.xcap-directory+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.omads-email+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.omads-file+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.omads-folder+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.omaloc-supl-init": {
        source: "iana"
      },
      "application/vnd.onepager": {
        source: "iana"
      },
      "application/vnd.onepagertamp": {
        source: "iana"
      },
      "application/vnd.onepagertamx": {
        source: "iana"
      },
      "application/vnd.onepagertat": {
        source: "iana"
      },
      "application/vnd.onepagertatp": {
        source: "iana"
      },
      "application/vnd.onepagertatx": {
        source: "iana"
      },
      "application/vnd.openblox.game+xml": {
        source: "iana",
        compressible: true,
        extensions: ["obgx"]
      },
      "application/vnd.openblox.game-binary": {
        source: "iana"
      },
      "application/vnd.openeye.oeb": {
        source: "iana"
      },
      "application/vnd.openofficeorg.extension": {
        source: "apache",
        extensions: ["oxt"]
      },
      "application/vnd.openstreetmap.data+xml": {
        source: "iana",
        compressible: true,
        extensions: ["osm"]
      },
      "application/vnd.opentimestamps.ots": {
        source: "iana"
      },
      "application/vnd.openxmlformats-officedocument.custom-properties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawing+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.extended-properties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.presentation": {
        source: "iana",
        compressible: false,
        extensions: ["pptx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slide": {
        source: "iana",
        extensions: ["sldx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slideshow": {
        source: "iana",
        extensions: ["ppsx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.template": {
        source: "iana",
        extensions: ["potx"]
      },
      "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": {
        source: "iana",
        compressible: false,
        extensions: ["xlsx"]
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.template": {
        source: "iana",
        extensions: ["xltx"]
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.theme+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.themeoverride+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.vmldrawing": {
        source: "iana"
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document": {
        source: "iana",
        compressible: false,
        extensions: ["docx"]
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.template": {
        source: "iana",
        extensions: ["dotx"]
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-package.core-properties+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.openxmlformats-package.relationships+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oracle.resource+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.orange.indata": {
        source: "iana"
      },
      "application/vnd.osa.netdeploy": {
        source: "iana"
      },
      "application/vnd.osgeo.mapguide.package": {
        source: "iana",
        extensions: ["mgp"]
      },
      "application/vnd.osgi.bundle": {
        source: "iana"
      },
      "application/vnd.osgi.dp": {
        source: "iana",
        extensions: ["dp"]
      },
      "application/vnd.osgi.subsystem": {
        source: "iana",
        extensions: ["esa"]
      },
      "application/vnd.otps.ct-kip+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.oxli.countgraph": {
        source: "iana"
      },
      "application/vnd.pagerduty+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.palm": {
        source: "iana",
        extensions: ["pdb", "pqa", "oprc"]
      },
      "application/vnd.panoply": {
        source: "iana"
      },
      "application/vnd.paos.xml": {
        source: "iana"
      },
      "application/vnd.patentdive": {
        source: "iana"
      },
      "application/vnd.patientecommsdoc": {
        source: "iana"
      },
      "application/vnd.pawaafile": {
        source: "iana",
        extensions: ["paw"]
      },
      "application/vnd.pcos": {
        source: "iana"
      },
      "application/vnd.pg.format": {
        source: "iana",
        extensions: ["str"]
      },
      "application/vnd.pg.osasli": {
        source: "iana",
        extensions: ["ei6"]
      },
      "application/vnd.piaccess.application-licence": {
        source: "iana"
      },
      "application/vnd.picsel": {
        source: "iana",
        extensions: ["efif"]
      },
      "application/vnd.pmi.widget": {
        source: "iana",
        extensions: ["wg"]
      },
      "application/vnd.poc.group-advertisement+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.pocketlearn": {
        source: "iana",
        extensions: ["plf"]
      },
      "application/vnd.powerbuilder6": {
        source: "iana",
        extensions: ["pbd"]
      },
      "application/vnd.powerbuilder6-s": {
        source: "iana"
      },
      "application/vnd.powerbuilder7": {
        source: "iana"
      },
      "application/vnd.powerbuilder7-s": {
        source: "iana"
      },
      "application/vnd.powerbuilder75": {
        source: "iana"
      },
      "application/vnd.powerbuilder75-s": {
        source: "iana"
      },
      "application/vnd.preminet": {
        source: "iana"
      },
      "application/vnd.previewsystems.box": {
        source: "iana",
        extensions: ["box"]
      },
      "application/vnd.proteus.magazine": {
        source: "iana",
        extensions: ["mgz"]
      },
      "application/vnd.psfs": {
        source: "iana"
      },
      "application/vnd.publishare-delta-tree": {
        source: "iana",
        extensions: ["qps"]
      },
      "application/vnd.pvi.ptid1": {
        source: "iana",
        extensions: ["ptid"]
      },
      "application/vnd.pwg-multiplexed": {
        source: "iana"
      },
      "application/vnd.pwg-xhtml-print+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.qualcomm.brew-app-res": {
        source: "iana"
      },
      "application/vnd.quarantainenet": {
        source: "iana"
      },
      "application/vnd.quark.quarkxpress": {
        source: "iana",
        extensions: ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"]
      },
      "application/vnd.quobject-quoxdocument": {
        source: "iana"
      },
      "application/vnd.radisys.moml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-conf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-conn+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-dialog+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-audit-stream+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-conf+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-base+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-fax-detect+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-group+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-speech+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.radisys.msml-dialog-transform+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.rainstor.data": {
        source: "iana"
      },
      "application/vnd.rapid": {
        source: "iana"
      },
      "application/vnd.rar": {
        source: "iana",
        extensions: ["rar"]
      },
      "application/vnd.realvnc.bed": {
        source: "iana",
        extensions: ["bed"]
      },
      "application/vnd.recordare.musicxml": {
        source: "iana",
        extensions: ["mxl"]
      },
      "application/vnd.recordare.musicxml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["musicxml"]
      },
      "application/vnd.renlearn.rlprint": {
        source: "iana"
      },
      "application/vnd.resilient.logic": {
        source: "iana"
      },
      "application/vnd.restful+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.rig.cryptonote": {
        source: "iana",
        extensions: ["cryptonote"]
      },
      "application/vnd.rim.cod": {
        source: "apache",
        extensions: ["cod"]
      },
      "application/vnd.rn-realmedia": {
        source: "apache",
        extensions: ["rm"]
      },
      "application/vnd.rn-realmedia-vbr": {
        source: "apache",
        extensions: ["rmvb"]
      },
      "application/vnd.route66.link66+xml": {
        source: "iana",
        compressible: true,
        extensions: ["link66"]
      },
      "application/vnd.rs-274x": {
        source: "iana"
      },
      "application/vnd.ruckus.download": {
        source: "iana"
      },
      "application/vnd.s3sms": {
        source: "iana"
      },
      "application/vnd.sailingtracker.track": {
        source: "iana",
        extensions: ["st"]
      },
      "application/vnd.sar": {
        source: "iana"
      },
      "application/vnd.sbm.cid": {
        source: "iana"
      },
      "application/vnd.sbm.mid2": {
        source: "iana"
      },
      "application/vnd.scribus": {
        source: "iana"
      },
      "application/vnd.sealed.3df": {
        source: "iana"
      },
      "application/vnd.sealed.csf": {
        source: "iana"
      },
      "application/vnd.sealed.doc": {
        source: "iana"
      },
      "application/vnd.sealed.eml": {
        source: "iana"
      },
      "application/vnd.sealed.mht": {
        source: "iana"
      },
      "application/vnd.sealed.net": {
        source: "iana"
      },
      "application/vnd.sealed.ppt": {
        source: "iana"
      },
      "application/vnd.sealed.tiff": {
        source: "iana"
      },
      "application/vnd.sealed.xls": {
        source: "iana"
      },
      "application/vnd.sealedmedia.softseal.html": {
        source: "iana"
      },
      "application/vnd.sealedmedia.softseal.pdf": {
        source: "iana"
      },
      "application/vnd.seemail": {
        source: "iana",
        extensions: ["see"]
      },
      "application/vnd.seis+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.sema": {
        source: "iana",
        extensions: ["sema"]
      },
      "application/vnd.semd": {
        source: "iana",
        extensions: ["semd"]
      },
      "application/vnd.semf": {
        source: "iana",
        extensions: ["semf"]
      },
      "application/vnd.shade-save-file": {
        source: "iana"
      },
      "application/vnd.shana.informed.formdata": {
        source: "iana",
        extensions: ["ifm"]
      },
      "application/vnd.shana.informed.formtemplate": {
        source: "iana",
        extensions: ["itp"]
      },
      "application/vnd.shana.informed.interchange": {
        source: "iana",
        extensions: ["iif"]
      },
      "application/vnd.shana.informed.package": {
        source: "iana",
        extensions: ["ipk"]
      },
      "application/vnd.shootproof+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.shopkick+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.shp": {
        source: "iana"
      },
      "application/vnd.shx": {
        source: "iana"
      },
      "application/vnd.sigrok.session": {
        source: "iana"
      },
      "application/vnd.simtech-mindmapper": {
        source: "iana",
        extensions: ["twd", "twds"]
      },
      "application/vnd.siren+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.smaf": {
        source: "iana",
        extensions: ["mmf"]
      },
      "application/vnd.smart.notebook": {
        source: "iana"
      },
      "application/vnd.smart.teacher": {
        source: "iana",
        extensions: ["teacher"]
      },
      "application/vnd.snesdev-page-table": {
        source: "iana"
      },
      "application/vnd.software602.filler.form+xml": {
        source: "iana",
        compressible: true,
        extensions: ["fo"]
      },
      "application/vnd.software602.filler.form-xml-zip": {
        source: "iana"
      },
      "application/vnd.solent.sdkm+xml": {
        source: "iana",
        compressible: true,
        extensions: ["sdkm", "sdkd"]
      },
      "application/vnd.spotfire.dxp": {
        source: "iana",
        extensions: ["dxp"]
      },
      "application/vnd.spotfire.sfs": {
        source: "iana",
        extensions: ["sfs"]
      },
      "application/vnd.sqlite3": {
        source: "iana"
      },
      "application/vnd.sss-cod": {
        source: "iana"
      },
      "application/vnd.sss-dtf": {
        source: "iana"
      },
      "application/vnd.sss-ntf": {
        source: "iana"
      },
      "application/vnd.stardivision.calc": {
        source: "apache",
        extensions: ["sdc"]
      },
      "application/vnd.stardivision.draw": {
        source: "apache",
        extensions: ["sda"]
      },
      "application/vnd.stardivision.impress": {
        source: "apache",
        extensions: ["sdd"]
      },
      "application/vnd.stardivision.math": {
        source: "apache",
        extensions: ["smf"]
      },
      "application/vnd.stardivision.writer": {
        source: "apache",
        extensions: ["sdw", "vor"]
      },
      "application/vnd.stardivision.writer-global": {
        source: "apache",
        extensions: ["sgl"]
      },
      "application/vnd.stepmania.package": {
        source: "iana",
        extensions: ["smzip"]
      },
      "application/vnd.stepmania.stepchart": {
        source: "iana",
        extensions: ["sm"]
      },
      "application/vnd.street-stream": {
        source: "iana"
      },
      "application/vnd.sun.wadl+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wadl"]
      },
      "application/vnd.sun.xml.calc": {
        source: "apache",
        extensions: ["sxc"]
      },
      "application/vnd.sun.xml.calc.template": {
        source: "apache",
        extensions: ["stc"]
      },
      "application/vnd.sun.xml.draw": {
        source: "apache",
        extensions: ["sxd"]
      },
      "application/vnd.sun.xml.draw.template": {
        source: "apache",
        extensions: ["std"]
      },
      "application/vnd.sun.xml.impress": {
        source: "apache",
        extensions: ["sxi"]
      },
      "application/vnd.sun.xml.impress.template": {
        source: "apache",
        extensions: ["sti"]
      },
      "application/vnd.sun.xml.math": {
        source: "apache",
        extensions: ["sxm"]
      },
      "application/vnd.sun.xml.writer": {
        source: "apache",
        extensions: ["sxw"]
      },
      "application/vnd.sun.xml.writer.global": {
        source: "apache",
        extensions: ["sxg"]
      },
      "application/vnd.sun.xml.writer.template": {
        source: "apache",
        extensions: ["stw"]
      },
      "application/vnd.sus-calendar": {
        source: "iana",
        extensions: ["sus", "susp"]
      },
      "application/vnd.svd": {
        source: "iana",
        extensions: ["svd"]
      },
      "application/vnd.swiftview-ics": {
        source: "iana"
      },
      "application/vnd.sycle+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.syft+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.symbian.install": {
        source: "apache",
        extensions: ["sis", "sisx"]
      },
      "application/vnd.syncml+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["xsm"]
      },
      "application/vnd.syncml.dm+wbxml": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["bdm"]
      },
      "application/vnd.syncml.dm+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["xdm"]
      },
      "application/vnd.syncml.dm.notification": {
        source: "iana"
      },
      "application/vnd.syncml.dmddf+wbxml": {
        source: "iana"
      },
      "application/vnd.syncml.dmddf+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["ddf"]
      },
      "application/vnd.syncml.dmtnds+wbxml": {
        source: "iana"
      },
      "application/vnd.syncml.dmtnds+xml": {
        source: "iana",
        charset: "UTF-8",
        compressible: true
      },
      "application/vnd.syncml.ds.notification": {
        source: "iana"
      },
      "application/vnd.tableschema+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.tao.intent-module-archive": {
        source: "iana",
        extensions: ["tao"]
      },
      "application/vnd.tcpdump.pcap": {
        source: "iana",
        extensions: ["pcap", "cap", "dmp"]
      },
      "application/vnd.think-cell.ppttc+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.tmd.mediaflex.api+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.tml": {
        source: "iana"
      },
      "application/vnd.tmobile-livetv": {
        source: "iana",
        extensions: ["tmo"]
      },
      "application/vnd.tri.onesource": {
        source: "iana"
      },
      "application/vnd.trid.tpt": {
        source: "iana",
        extensions: ["tpt"]
      },
      "application/vnd.triscape.mxs": {
        source: "iana",
        extensions: ["mxs"]
      },
      "application/vnd.trueapp": {
        source: "iana",
        extensions: ["tra"]
      },
      "application/vnd.truedoc": {
        source: "iana"
      },
      "application/vnd.ubisoft.webplayer": {
        source: "iana"
      },
      "application/vnd.ufdl": {
        source: "iana",
        extensions: ["ufd", "ufdl"]
      },
      "application/vnd.uiq.theme": {
        source: "iana",
        extensions: ["utz"]
      },
      "application/vnd.umajin": {
        source: "iana",
        extensions: ["umj"]
      },
      "application/vnd.unity": {
        source: "iana",
        extensions: ["unityweb"]
      },
      "application/vnd.uoml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["uoml"]
      },
      "application/vnd.uplanet.alert": {
        source: "iana"
      },
      "application/vnd.uplanet.alert-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.bearer-choice": {
        source: "iana"
      },
      "application/vnd.uplanet.bearer-choice-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.cacheop": {
        source: "iana"
      },
      "application/vnd.uplanet.cacheop-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.channel": {
        source: "iana"
      },
      "application/vnd.uplanet.channel-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.list": {
        source: "iana"
      },
      "application/vnd.uplanet.list-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.listcmd": {
        source: "iana"
      },
      "application/vnd.uplanet.listcmd-wbxml": {
        source: "iana"
      },
      "application/vnd.uplanet.signal": {
        source: "iana"
      },
      "application/vnd.uri-map": {
        source: "iana"
      },
      "application/vnd.valve.source.material": {
        source: "iana"
      },
      "application/vnd.vcx": {
        source: "iana",
        extensions: ["vcx"]
      },
      "application/vnd.vd-study": {
        source: "iana"
      },
      "application/vnd.vectorworks": {
        source: "iana"
      },
      "application/vnd.vel+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.verimatrix.vcas": {
        source: "iana"
      },
      "application/vnd.veritone.aion+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.veryant.thin": {
        source: "iana"
      },
      "application/vnd.ves.encrypted": {
        source: "iana"
      },
      "application/vnd.vidsoft.vidconference": {
        source: "iana"
      },
      "application/vnd.visio": {
        source: "iana",
        extensions: ["vsd", "vst", "vss", "vsw"]
      },
      "application/vnd.visionary": {
        source: "iana",
        extensions: ["vis"]
      },
      "application/vnd.vividence.scriptfile": {
        source: "iana"
      },
      "application/vnd.vsf": {
        source: "iana",
        extensions: ["vsf"]
      },
      "application/vnd.wap.sic": {
        source: "iana"
      },
      "application/vnd.wap.slc": {
        source: "iana"
      },
      "application/vnd.wap.wbxml": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["wbxml"]
      },
      "application/vnd.wap.wmlc": {
        source: "iana",
        extensions: ["wmlc"]
      },
      "application/vnd.wap.wmlscriptc": {
        source: "iana",
        extensions: ["wmlsc"]
      },
      "application/vnd.webturbo": {
        source: "iana",
        extensions: ["wtb"]
      },
      "application/vnd.wfa.dpp": {
        source: "iana"
      },
      "application/vnd.wfa.p2p": {
        source: "iana"
      },
      "application/vnd.wfa.wsc": {
        source: "iana"
      },
      "application/vnd.windows.devicepairing": {
        source: "iana"
      },
      "application/vnd.wmc": {
        source: "iana"
      },
      "application/vnd.wmf.bootstrap": {
        source: "iana"
      },
      "application/vnd.wolfram.mathematica": {
        source: "iana"
      },
      "application/vnd.wolfram.mathematica.package": {
        source: "iana"
      },
      "application/vnd.wolfram.player": {
        source: "iana",
        extensions: ["nbp"]
      },
      "application/vnd.wordperfect": {
        source: "iana",
        extensions: ["wpd"]
      },
      "application/vnd.wqd": {
        source: "iana",
        extensions: ["wqd"]
      },
      "application/vnd.wrq-hp3000-labelled": {
        source: "iana"
      },
      "application/vnd.wt.stf": {
        source: "iana",
        extensions: ["stf"]
      },
      "application/vnd.wv.csp+wbxml": {
        source: "iana"
      },
      "application/vnd.wv.csp+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.wv.ssp+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.xacml+json": {
        source: "iana",
        compressible: true
      },
      "application/vnd.xara": {
        source: "iana",
        extensions: ["xar"]
      },
      "application/vnd.xfdl": {
        source: "iana",
        extensions: ["xfdl"]
      },
      "application/vnd.xfdl.webform": {
        source: "iana"
      },
      "application/vnd.xmi+xml": {
        source: "iana",
        compressible: true
      },
      "application/vnd.xmpie.cpkg": {
        source: "iana"
      },
      "application/vnd.xmpie.dpkg": {
        source: "iana"
      },
      "application/vnd.xmpie.plan": {
        source: "iana"
      },
      "application/vnd.xmpie.ppkg": {
        source: "iana"
      },
      "application/vnd.xmpie.xlim": {
        source: "iana"
      },
      "application/vnd.yamaha.hv-dic": {
        source: "iana",
        extensions: ["hvd"]
      },
      "application/vnd.yamaha.hv-script": {
        source: "iana",
        extensions: ["hvs"]
      },
      "application/vnd.yamaha.hv-voice": {
        source: "iana",
        extensions: ["hvp"]
      },
      "application/vnd.yamaha.openscoreformat": {
        source: "iana",
        extensions: ["osf"]
      },
      "application/vnd.yamaha.openscoreformat.osfpvg+xml": {
        source: "iana",
        compressible: true,
        extensions: ["osfpvg"]
      },
      "application/vnd.yamaha.remote-setup": {
        source: "iana"
      },
      "application/vnd.yamaha.smaf-audio": {
        source: "iana",
        extensions: ["saf"]
      },
      "application/vnd.yamaha.smaf-phrase": {
        source: "iana",
        extensions: ["spf"]
      },
      "application/vnd.yamaha.through-ngn": {
        source: "iana"
      },
      "application/vnd.yamaha.tunnel-udpencap": {
        source: "iana"
      },
      "application/vnd.yaoweme": {
        source: "iana"
      },
      "application/vnd.yellowriver-custom-menu": {
        source: "iana",
        extensions: ["cmp"]
      },
      "application/vnd.youtube.yt": {
        source: "iana"
      },
      "application/vnd.zul": {
        source: "iana",
        extensions: ["zir", "zirz"]
      },
      "application/vnd.zzazz.deck+xml": {
        source: "iana",
        compressible: true,
        extensions: ["zaz"]
      },
      "application/voicexml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["vxml"]
      },
      "application/voucher-cms+json": {
        source: "iana",
        compressible: true
      },
      "application/vq-rtcpxr": {
        source: "iana"
      },
      "application/wasm": {
        source: "iana",
        compressible: true,
        extensions: ["wasm"]
      },
      "application/watcherinfo+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wif"]
      },
      "application/webpush-options+json": {
        source: "iana",
        compressible: true
      },
      "application/whoispp-query": {
        source: "iana"
      },
      "application/whoispp-response": {
        source: "iana"
      },
      "application/widget": {
        source: "iana",
        extensions: ["wgt"]
      },
      "application/winhlp": {
        source: "apache",
        extensions: ["hlp"]
      },
      "application/wita": {
        source: "iana"
      },
      "application/wordperfect5.1": {
        source: "iana"
      },
      "application/wsdl+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wsdl"]
      },
      "application/wspolicy+xml": {
        source: "iana",
        compressible: true,
        extensions: ["wspolicy"]
      },
      "application/x-7z-compressed": {
        source: "apache",
        compressible: false,
        extensions: ["7z"]
      },
      "application/x-abiword": {
        source: "apache",
        extensions: ["abw"]
      },
      "application/x-ace-compressed": {
        source: "apache",
        extensions: ["ace"]
      },
      "application/x-amf": {
        source: "apache"
      },
      "application/x-apple-diskimage": {
        source: "apache",
        extensions: ["dmg"]
      },
      "application/x-arj": {
        compressible: false,
        extensions: ["arj"]
      },
      "application/x-authorware-bin": {
        source: "apache",
        extensions: ["aab", "x32", "u32", "vox"]
      },
      "application/x-authorware-map": {
        source: "apache",
        extensions: ["aam"]
      },
      "application/x-authorware-seg": {
        source: "apache",
        extensions: ["aas"]
      },
      "application/x-bcpio": {
        source: "apache",
        extensions: ["bcpio"]
      },
      "application/x-bdoc": {
        compressible: false,
        extensions: ["bdoc"]
      },
      "application/x-bittorrent": {
        source: "apache",
        extensions: ["torrent"]
      },
      "application/x-blorb": {
        source: "apache",
        extensions: ["blb", "blorb"]
      },
      "application/x-bzip": {
        source: "apache",
        compressible: false,
        extensions: ["bz"]
      },
      "application/x-bzip2": {
        source: "apache",
        compressible: false,
        extensions: ["bz2", "boz"]
      },
      "application/x-cbr": {
        source: "apache",
        extensions: ["cbr", "cba", "cbt", "cbz", "cb7"]
      },
      "application/x-cdlink": {
        source: "apache",
        extensions: ["vcd"]
      },
      "application/x-cfs-compressed": {
        source: "apache",
        extensions: ["cfs"]
      },
      "application/x-chat": {
        source: "apache",
        extensions: ["chat"]
      },
      "application/x-chess-pgn": {
        source: "apache",
        extensions: ["pgn"]
      },
      "application/x-chrome-extension": {
        extensions: ["crx"]
      },
      "application/x-cocoa": {
        source: "nginx",
        extensions: ["cco"]
      },
      "application/x-compress": {
        source: "apache"
      },
      "application/x-conference": {
        source: "apache",
        extensions: ["nsc"]
      },
      "application/x-cpio": {
        source: "apache",
        extensions: ["cpio"]
      },
      "application/x-csh": {
        source: "apache",
        extensions: ["csh"]
      },
      "application/x-deb": {
        compressible: false
      },
      "application/x-debian-package": {
        source: "apache",
        extensions: ["deb", "udeb"]
      },
      "application/x-dgc-compressed": {
        source: "apache",
        extensions: ["dgc"]
      },
      "application/x-director": {
        source: "apache",
        extensions: ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"]
      },
      "application/x-doom": {
        source: "apache",
        extensions: ["wad"]
      },
      "application/x-dtbncx+xml": {
        source: "apache",
        compressible: true,
        extensions: ["ncx"]
      },
      "application/x-dtbook+xml": {
        source: "apache",
        compressible: true,
        extensions: ["dtb"]
      },
      "application/x-dtbresource+xml": {
        source: "apache",
        compressible: true,
        extensions: ["res"]
      },
      "application/x-dvi": {
        source: "apache",
        compressible: false,
        extensions: ["dvi"]
      },
      "application/x-envoy": {
        source: "apache",
        extensions: ["evy"]
      },
      "application/x-eva": {
        source: "apache",
        extensions: ["eva"]
      },
      "application/x-font-bdf": {
        source: "apache",
        extensions: ["bdf"]
      },
      "application/x-font-dos": {
        source: "apache"
      },
      "application/x-font-framemaker": {
        source: "apache"
      },
      "application/x-font-ghostscript": {
        source: "apache",
        extensions: ["gsf"]
      },
      "application/x-font-libgrx": {
        source: "apache"
      },
      "application/x-font-linux-psf": {
        source: "apache",
        extensions: ["psf"]
      },
      "application/x-font-pcf": {
        source: "apache",
        extensions: ["pcf"]
      },
      "application/x-font-snf": {
        source: "apache",
        extensions: ["snf"]
      },
      "application/x-font-speedo": {
        source: "apache"
      },
      "application/x-font-sunos-news": {
        source: "apache"
      },
      "application/x-font-type1": {
        source: "apache",
        extensions: ["pfa", "pfb", "pfm", "afm"]
      },
      "application/x-font-vfont": {
        source: "apache"
      },
      "application/x-freearc": {
        source: "apache",
        extensions: ["arc"]
      },
      "application/x-futuresplash": {
        source: "apache",
        extensions: ["spl"]
      },
      "application/x-gca-compressed": {
        source: "apache",
        extensions: ["gca"]
      },
      "application/x-glulx": {
        source: "apache",
        extensions: ["ulx"]
      },
      "application/x-gnumeric": {
        source: "apache",
        extensions: ["gnumeric"]
      },
      "application/x-gramps-xml": {
        source: "apache",
        extensions: ["gramps"]
      },
      "application/x-gtar": {
        source: "apache",
        extensions: ["gtar"]
      },
      "application/x-gzip": {
        source: "apache"
      },
      "application/x-hdf": {
        source: "apache",
        extensions: ["hdf"]
      },
      "application/x-httpd-php": {
        compressible: true,
        extensions: ["php"]
      },
      "application/x-install-instructions": {
        source: "apache",
        extensions: ["install"]
      },
      "application/x-iso9660-image": {
        source: "apache",
        extensions: ["iso"]
      },
      "application/x-iwork-keynote-sffkey": {
        extensions: ["key"]
      },
      "application/x-iwork-numbers-sffnumbers": {
        extensions: ["numbers"]
      },
      "application/x-iwork-pages-sffpages": {
        extensions: ["pages"]
      },
      "application/x-java-archive-diff": {
        source: "nginx",
        extensions: ["jardiff"]
      },
      "application/x-java-jnlp-file": {
        source: "apache",
        compressible: false,
        extensions: ["jnlp"]
      },
      "application/x-javascript": {
        compressible: true
      },
      "application/x-keepass2": {
        extensions: ["kdbx"]
      },
      "application/x-latex": {
        source: "apache",
        compressible: false,
        extensions: ["latex"]
      },
      "application/x-lua-bytecode": {
        extensions: ["luac"]
      },
      "application/x-lzh-compressed": {
        source: "apache",
        extensions: ["lzh", "lha"]
      },
      "application/x-makeself": {
        source: "nginx",
        extensions: ["run"]
      },
      "application/x-mie": {
        source: "apache",
        extensions: ["mie"]
      },
      "application/x-mobipocket-ebook": {
        source: "apache",
        extensions: ["prc", "mobi"]
      },
      "application/x-mpegurl": {
        compressible: false
      },
      "application/x-ms-application": {
        source: "apache",
        extensions: ["application"]
      },
      "application/x-ms-shortcut": {
        source: "apache",
        extensions: ["lnk"]
      },
      "application/x-ms-wmd": {
        source: "apache",
        extensions: ["wmd"]
      },
      "application/x-ms-wmz": {
        source: "apache",
        extensions: ["wmz"]
      },
      "application/x-ms-xbap": {
        source: "apache",
        extensions: ["xbap"]
      },
      "application/x-msaccess": {
        source: "apache",
        extensions: ["mdb"]
      },
      "application/x-msbinder": {
        source: "apache",
        extensions: ["obd"]
      },
      "application/x-mscardfile": {
        source: "apache",
        extensions: ["crd"]
      },
      "application/x-msclip": {
        source: "apache",
        extensions: ["clp"]
      },
      "application/x-msdos-program": {
        extensions: ["exe"]
      },
      "application/x-msdownload": {
        source: "apache",
        extensions: ["exe", "dll", "com", "bat", "msi"]
      },
      "application/x-msmediaview": {
        source: "apache",
        extensions: ["mvb", "m13", "m14"]
      },
      "application/x-msmetafile": {
        source: "apache",
        extensions: ["wmf", "wmz", "emf", "emz"]
      },
      "application/x-msmoney": {
        source: "apache",
        extensions: ["mny"]
      },
      "application/x-mspublisher": {
        source: "apache",
        extensions: ["pub"]
      },
      "application/x-msschedule": {
        source: "apache",
        extensions: ["scd"]
      },
      "application/x-msterminal": {
        source: "apache",
        extensions: ["trm"]
      },
      "application/x-mswrite": {
        source: "apache",
        extensions: ["wri"]
      },
      "application/x-netcdf": {
        source: "apache",
        extensions: ["nc", "cdf"]
      },
      "application/x-ns-proxy-autoconfig": {
        compressible: true,
        extensions: ["pac"]
      },
      "application/x-nzb": {
        source: "apache",
        extensions: ["nzb"]
      },
      "application/x-perl": {
        source: "nginx",
        extensions: ["pl", "pm"]
      },
      "application/x-pilot": {
        source: "nginx",
        extensions: ["prc", "pdb"]
      },
      "application/x-pkcs12": {
        source: "apache",
        compressible: false,
        extensions: ["p12", "pfx"]
      },
      "application/x-pkcs7-certificates": {
        source: "apache",
        extensions: ["p7b", "spc"]
      },
      "application/x-pkcs7-certreqresp": {
        source: "apache",
        extensions: ["p7r"]
      },
      "application/x-pki-message": {
        source: "iana"
      },
      "application/x-rar-compressed": {
        source: "apache",
        compressible: false,
        extensions: ["rar"]
      },
      "application/x-redhat-package-manager": {
        source: "nginx",
        extensions: ["rpm"]
      },
      "application/x-research-info-systems": {
        source: "apache",
        extensions: ["ris"]
      },
      "application/x-sea": {
        source: "nginx",
        extensions: ["sea"]
      },
      "application/x-sh": {
        source: "apache",
        compressible: true,
        extensions: ["sh"]
      },
      "application/x-shar": {
        source: "apache",
        extensions: ["shar"]
      },
      "application/x-shockwave-flash": {
        source: "apache",
        compressible: false,
        extensions: ["swf"]
      },
      "application/x-silverlight-app": {
        source: "apache",
        extensions: ["xap"]
      },
      "application/x-sql": {
        source: "apache",
        extensions: ["sql"]
      },
      "application/x-stuffit": {
        source: "apache",
        compressible: false,
        extensions: ["sit"]
      },
      "application/x-stuffitx": {
        source: "apache",
        extensions: ["sitx"]
      },
      "application/x-subrip": {
        source: "apache",
        extensions: ["srt"]
      },
      "application/x-sv4cpio": {
        source: "apache",
        extensions: ["sv4cpio"]
      },
      "application/x-sv4crc": {
        source: "apache",
        extensions: ["sv4crc"]
      },
      "application/x-t3vm-image": {
        source: "apache",
        extensions: ["t3"]
      },
      "application/x-tads": {
        source: "apache",
        extensions: ["gam"]
      },
      "application/x-tar": {
        source: "apache",
        compressible: true,
        extensions: ["tar"]
      },
      "application/x-tcl": {
        source: "apache",
        extensions: ["tcl", "tk"]
      },
      "application/x-tex": {
        source: "apache",
        extensions: ["tex"]
      },
      "application/x-tex-tfm": {
        source: "apache",
        extensions: ["tfm"]
      },
      "application/x-texinfo": {
        source: "apache",
        extensions: ["texinfo", "texi"]
      },
      "application/x-tgif": {
        source: "apache",
        extensions: ["obj"]
      },
      "application/x-ustar": {
        source: "apache",
        extensions: ["ustar"]
      },
      "application/x-virtualbox-hdd": {
        compressible: true,
        extensions: ["hdd"]
      },
      "application/x-virtualbox-ova": {
        compressible: true,
        extensions: ["ova"]
      },
      "application/x-virtualbox-ovf": {
        compressible: true,
        extensions: ["ovf"]
      },
      "application/x-virtualbox-vbox": {
        compressible: true,
        extensions: ["vbox"]
      },
      "application/x-virtualbox-vbox-extpack": {
        compressible: false,
        extensions: ["vbox-extpack"]
      },
      "application/x-virtualbox-vdi": {
        compressible: true,
        extensions: ["vdi"]
      },
      "application/x-virtualbox-vhd": {
        compressible: true,
        extensions: ["vhd"]
      },
      "application/x-virtualbox-vmdk": {
        compressible: true,
        extensions: ["vmdk"]
      },
      "application/x-wais-source": {
        source: "apache",
        extensions: ["src"]
      },
      "application/x-web-app-manifest+json": {
        compressible: true,
        extensions: ["webapp"]
      },
      "application/x-www-form-urlencoded": {
        source: "iana",
        compressible: true
      },
      "application/x-x509-ca-cert": {
        source: "iana",
        extensions: ["der", "crt", "pem"]
      },
      "application/x-x509-ca-ra-cert": {
        source: "iana"
      },
      "application/x-x509-next-ca-cert": {
        source: "iana"
      },
      "application/x-xfig": {
        source: "apache",
        extensions: ["fig"]
      },
      "application/x-xliff+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xlf"]
      },
      "application/x-xpinstall": {
        source: "apache",
        compressible: false,
        extensions: ["xpi"]
      },
      "application/x-xz": {
        source: "apache",
        extensions: ["xz"]
      },
      "application/x-zmachine": {
        source: "apache",
        extensions: ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"]
      },
      "application/x400-bp": {
        source: "iana"
      },
      "application/xacml+xml": {
        source: "iana",
        compressible: true
      },
      "application/xaml+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xaml"]
      },
      "application/xcap-att+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xav"]
      },
      "application/xcap-caps+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xca"]
      },
      "application/xcap-diff+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xdf"]
      },
      "application/xcap-el+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xel"]
      },
      "application/xcap-error+xml": {
        source: "iana",
        compressible: true
      },
      "application/xcap-ns+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xns"]
      },
      "application/xcon-conference-info+xml": {
        source: "iana",
        compressible: true
      },
      "application/xcon-conference-info-diff+xml": {
        source: "iana",
        compressible: true
      },
      "application/xenc+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xenc"]
      },
      "application/xhtml+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xhtml", "xht"]
      },
      "application/xhtml-voice+xml": {
        source: "apache",
        compressible: true
      },
      "application/xliff+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xlf"]
      },
      "application/xml": {
        source: "iana",
        compressible: true,
        extensions: ["xml", "xsl", "xsd", "rng"]
      },
      "application/xml-dtd": {
        source: "iana",
        compressible: true,
        extensions: ["dtd"]
      },
      "application/xml-external-parsed-entity": {
        source: "iana"
      },
      "application/xml-patch+xml": {
        source: "iana",
        compressible: true
      },
      "application/xmpp+xml": {
        source: "iana",
        compressible: true
      },
      "application/xop+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xop"]
      },
      "application/xproc+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xpl"]
      },
      "application/xslt+xml": {
        source: "iana",
        compressible: true,
        extensions: ["xsl", "xslt"]
      },
      "application/xspf+xml": {
        source: "apache",
        compressible: true,
        extensions: ["xspf"]
      },
      "application/xv+xml": {
        source: "iana",
        compressible: true,
        extensions: ["mxml", "xhvml", "xvml", "xvm"]
      },
      "application/yang": {
        source: "iana",
        extensions: ["yang"]
      },
      "application/yang-data+json": {
        source: "iana",
        compressible: true
      },
      "application/yang-data+xml": {
        source: "iana",
        compressible: true
      },
      "application/yang-patch+json": {
        source: "iana",
        compressible: true
      },
      "application/yang-patch+xml": {
        source: "iana",
        compressible: true
      },
      "application/yin+xml": {
        source: "iana",
        compressible: true,
        extensions: ["yin"]
      },
      "application/zip": {
        source: "iana",
        compressible: false,
        extensions: ["zip"]
      },
      "application/zlib": {
        source: "iana"
      },
      "application/zstd": {
        source: "iana"
      },
      "audio/1d-interleaved-parityfec": {
        source: "iana"
      },
      "audio/32kadpcm": {
        source: "iana"
      },
      "audio/3gpp": {
        source: "iana",
        compressible: false,
        extensions: ["3gpp"]
      },
      "audio/3gpp2": {
        source: "iana"
      },
      "audio/aac": {
        source: "iana"
      },
      "audio/ac3": {
        source: "iana"
      },
      "audio/adpcm": {
        source: "apache",
        extensions: ["adp"]
      },
      "audio/amr": {
        source: "iana",
        extensions: ["amr"]
      },
      "audio/amr-wb": {
        source: "iana"
      },
      "audio/amr-wb+": {
        source: "iana"
      },
      "audio/aptx": {
        source: "iana"
      },
      "audio/asc": {
        source: "iana"
      },
      "audio/atrac-advanced-lossless": {
        source: "iana"
      },
      "audio/atrac-x": {
        source: "iana"
      },
      "audio/atrac3": {
        source: "iana"
      },
      "audio/basic": {
        source: "iana",
        compressible: false,
        extensions: ["au", "snd"]
      },
      "audio/bv16": {
        source: "iana"
      },
      "audio/bv32": {
        source: "iana"
      },
      "audio/clearmode": {
        source: "iana"
      },
      "audio/cn": {
        source: "iana"
      },
      "audio/dat12": {
        source: "iana"
      },
      "audio/dls": {
        source: "iana"
      },
      "audio/dsr-es201108": {
        source: "iana"
      },
      "audio/dsr-es202050": {
        source: "iana"
      },
      "audio/dsr-es202211": {
        source: "iana"
      },
      "audio/dsr-es202212": {
        source: "iana"
      },
      "audio/dv": {
        source: "iana"
      },
      "audio/dvi4": {
        source: "iana"
      },
      "audio/eac3": {
        source: "iana"
      },
      "audio/encaprtp": {
        source: "iana"
      },
      "audio/evrc": {
        source: "iana"
      },
      "audio/evrc-qcp": {
        source: "iana"
      },
      "audio/evrc0": {
        source: "iana"
      },
      "audio/evrc1": {
        source: "iana"
      },
      "audio/evrcb": {
        source: "iana"
      },
      "audio/evrcb0": {
        source: "iana"
      },
      "audio/evrcb1": {
        source: "iana"
      },
      "audio/evrcnw": {
        source: "iana"
      },
      "audio/evrcnw0": {
        source: "iana"
      },
      "audio/evrcnw1": {
        source: "iana"
      },
      "audio/evrcwb": {
        source: "iana"
      },
      "audio/evrcwb0": {
        source: "iana"
      },
      "audio/evrcwb1": {
        source: "iana"
      },
      "audio/evs": {
        source: "iana"
      },
      "audio/flexfec": {
        source: "iana"
      },
      "audio/fwdred": {
        source: "iana"
      },
      "audio/g711-0": {
        source: "iana"
      },
      "audio/g719": {
        source: "iana"
      },
      "audio/g722": {
        source: "iana"
      },
      "audio/g7221": {
        source: "iana"
      },
      "audio/g723": {
        source: "iana"
      },
      "audio/g726-16": {
        source: "iana"
      },
      "audio/g726-24": {
        source: "iana"
      },
      "audio/g726-32": {
        source: "iana"
      },
      "audio/g726-40": {
        source: "iana"
      },
      "audio/g728": {
        source: "iana"
      },
      "audio/g729": {
        source: "iana"
      },
      "audio/g7291": {
        source: "iana"
      },
      "audio/g729d": {
        source: "iana"
      },
      "audio/g729e": {
        source: "iana"
      },
      "audio/gsm": {
        source: "iana"
      },
      "audio/gsm-efr": {
        source: "iana"
      },
      "audio/gsm-hr-08": {
        source: "iana"
      },
      "audio/ilbc": {
        source: "iana"
      },
      "audio/ip-mr_v2.5": {
        source: "iana"
      },
      "audio/isac": {
        source: "apache"
      },
      "audio/l16": {
        source: "iana"
      },
      "audio/l20": {
        source: "iana"
      },
      "audio/l24": {
        source: "iana",
        compressible: false
      },
      "audio/l8": {
        source: "iana"
      },
      "audio/lpc": {
        source: "iana"
      },
      "audio/melp": {
        source: "iana"
      },
      "audio/melp1200": {
        source: "iana"
      },
      "audio/melp2400": {
        source: "iana"
      },
      "audio/melp600": {
        source: "iana"
      },
      "audio/mhas": {
        source: "iana"
      },
      "audio/midi": {
        source: "apache",
        extensions: ["mid", "midi", "kar", "rmi"]
      },
      "audio/mobile-xmf": {
        source: "iana",
        extensions: ["mxmf"]
      },
      "audio/mp3": {
        compressible: false,
        extensions: ["mp3"]
      },
      "audio/mp4": {
        source: "iana",
        compressible: false,
        extensions: ["m4a", "mp4a"]
      },
      "audio/mp4a-latm": {
        source: "iana"
      },
      "audio/mpa": {
        source: "iana"
      },
      "audio/mpa-robust": {
        source: "iana"
      },
      "audio/mpeg": {
        source: "iana",
        compressible: false,
        extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"]
      },
      "audio/mpeg4-generic": {
        source: "iana"
      },
      "audio/musepack": {
        source: "apache"
      },
      "audio/ogg": {
        source: "iana",
        compressible: false,
        extensions: ["oga", "ogg", "spx", "opus"]
      },
      "audio/opus": {
        source: "iana"
      },
      "audio/parityfec": {
        source: "iana"
      },
      "audio/pcma": {
        source: "iana"
      },
      "audio/pcma-wb": {
        source: "iana"
      },
      "audio/pcmu": {
        source: "iana"
      },
      "audio/pcmu-wb": {
        source: "iana"
      },
      "audio/prs.sid": {
        source: "iana"
      },
      "audio/qcelp": {
        source: "iana"
      },
      "audio/raptorfec": {
        source: "iana"
      },
      "audio/red": {
        source: "iana"
      },
      "audio/rtp-enc-aescm128": {
        source: "iana"
      },
      "audio/rtp-midi": {
        source: "iana"
      },
      "audio/rtploopback": {
        source: "iana"
      },
      "audio/rtx": {
        source: "iana"
      },
      "audio/s3m": {
        source: "apache",
        extensions: ["s3m"]
      },
      "audio/scip": {
        source: "iana"
      },
      "audio/silk": {
        source: "apache",
        extensions: ["sil"]
      },
      "audio/smv": {
        source: "iana"
      },
      "audio/smv-qcp": {
        source: "iana"
      },
      "audio/smv0": {
        source: "iana"
      },
      "audio/sofa": {
        source: "iana"
      },
      "audio/sp-midi": {
        source: "iana"
      },
      "audio/speex": {
        source: "iana"
      },
      "audio/t140c": {
        source: "iana"
      },
      "audio/t38": {
        source: "iana"
      },
      "audio/telephone-event": {
        source: "iana"
      },
      "audio/tetra_acelp": {
        source: "iana"
      },
      "audio/tetra_acelp_bb": {
        source: "iana"
      },
      "audio/tone": {
        source: "iana"
      },
      "audio/tsvcis": {
        source: "iana"
      },
      "audio/uemclip": {
        source: "iana"
      },
      "audio/ulpfec": {
        source: "iana"
      },
      "audio/usac": {
        source: "iana"
      },
      "audio/vdvi": {
        source: "iana"
      },
      "audio/vmr-wb": {
        source: "iana"
      },
      "audio/vnd.3gpp.iufp": {
        source: "iana"
      },
      "audio/vnd.4sb": {
        source: "iana"
      },
      "audio/vnd.audiokoz": {
        source: "iana"
      },
      "audio/vnd.celp": {
        source: "iana"
      },
      "audio/vnd.cisco.nse": {
        source: "iana"
      },
      "audio/vnd.cmles.radio-events": {
        source: "iana"
      },
      "audio/vnd.cns.anp1": {
        source: "iana"
      },
      "audio/vnd.cns.inf1": {
        source: "iana"
      },
      "audio/vnd.dece.audio": {
        source: "iana",
        extensions: ["uva", "uvva"]
      },
      "audio/vnd.digital-winds": {
        source: "iana",
        extensions: ["eol"]
      },
      "audio/vnd.dlna.adts": {
        source: "iana"
      },
      "audio/vnd.dolby.heaac.1": {
        source: "iana"
      },
      "audio/vnd.dolby.heaac.2": {
        source: "iana"
      },
      "audio/vnd.dolby.mlp": {
        source: "iana"
      },
      "audio/vnd.dolby.mps": {
        source: "iana"
      },
      "audio/vnd.dolby.pl2": {
        source: "iana"
      },
      "audio/vnd.dolby.pl2x": {
        source: "iana"
      },
      "audio/vnd.dolby.pl2z": {
        source: "iana"
      },
      "audio/vnd.dolby.pulse.1": {
        source: "iana"
      },
      "audio/vnd.dra": {
        source: "iana",
        extensions: ["dra"]
      },
      "audio/vnd.dts": {
        source: "iana",
        extensions: ["dts"]
      },
      "audio/vnd.dts.hd": {
        source: "iana",
        extensions: ["dtshd"]
      },
      "audio/vnd.dts.uhd": {
        source: "iana"
      },
      "audio/vnd.dvb.file": {
        source: "iana"
      },
      "audio/vnd.everad.plj": {
        source: "iana"
      },
      "audio/vnd.hns.audio": {
        source: "iana"
      },
      "audio/vnd.lucent.voice": {
        source: "iana",
        extensions: ["lvp"]
      },
      "audio/vnd.ms-playready.media.pya": {
        source: "iana",
        extensions: ["pya"]
      },
      "audio/vnd.nokia.mobile-xmf": {
        source: "iana"
      },
      "audio/vnd.nortel.vbk": {
        source: "iana"
      },
      "audio/vnd.nuera.ecelp4800": {
        source: "iana",
        extensions: ["ecelp4800"]
      },
      "audio/vnd.nuera.ecelp7470": {
        source: "iana",
        extensions: ["ecelp7470"]
      },
      "audio/vnd.nuera.ecelp9600": {
        source: "iana",
        extensions: ["ecelp9600"]
      },
      "audio/vnd.octel.sbc": {
        source: "iana"
      },
      "audio/vnd.presonus.multitrack": {
        source: "iana"
      },
      "audio/vnd.qcelp": {
        source: "iana"
      },
      "audio/vnd.rhetorex.32kadpcm": {
        source: "iana"
      },
      "audio/vnd.rip": {
        source: "iana",
        extensions: ["rip"]
      },
      "audio/vnd.rn-realaudio": {
        compressible: false
      },
      "audio/vnd.sealedmedia.softseal.mpeg": {
        source: "iana"
      },
      "audio/vnd.vmx.cvsd": {
        source: "iana"
      },
      "audio/vnd.wave": {
        compressible: false
      },
      "audio/vorbis": {
        source: "iana",
        compressible: false
      },
      "audio/vorbis-config": {
        source: "iana"
      },
      "audio/wav": {
        compressible: false,
        extensions: ["wav"]
      },
      "audio/wave": {
        compressible: false,
        extensions: ["wav"]
      },
      "audio/webm": {
        source: "apache",
        compressible: false,
        extensions: ["weba"]
      },
      "audio/x-aac": {
        source: "apache",
        compressible: false,
        extensions: ["aac"]
      },
      "audio/x-aiff": {
        source: "apache",
        extensions: ["aif", "aiff", "aifc"]
      },
      "audio/x-caf": {
        source: "apache",
        compressible: false,
        extensions: ["caf"]
      },
      "audio/x-flac": {
        source: "apache",
        extensions: ["flac"]
      },
      "audio/x-m4a": {
        source: "nginx",
        extensions: ["m4a"]
      },
      "audio/x-matroska": {
        source: "apache",
        extensions: ["mka"]
      },
      "audio/x-mpegurl": {
        source: "apache",
        extensions: ["m3u"]
      },
      "audio/x-ms-wax": {
        source: "apache",
        extensions: ["wax"]
      },
      "audio/x-ms-wma": {
        source: "apache",
        extensions: ["wma"]
      },
      "audio/x-pn-realaudio": {
        source: "apache",
        extensions: ["ram", "ra"]
      },
      "audio/x-pn-realaudio-plugin": {
        source: "apache",
        extensions: ["rmp"]
      },
      "audio/x-realaudio": {
        source: "nginx",
        extensions: ["ra"]
      },
      "audio/x-tta": {
        source: "apache"
      },
      "audio/x-wav": {
        source: "apache",
        extensions: ["wav"]
      },
      "audio/xm": {
        source: "apache",
        extensions: ["xm"]
      },
      "chemical/x-cdx": {
        source: "apache",
        extensions: ["cdx"]
      },
      "chemical/x-cif": {
        source: "apache",
        extensions: ["cif"]
      },
      "chemical/x-cmdf": {
        source: "apache",
        extensions: ["cmdf"]
      },
      "chemical/x-cml": {
        source: "apache",
        extensions: ["cml"]
      },
      "chemical/x-csml": {
        source: "apache",
        extensions: ["csml"]
      },
      "chemical/x-pdb": {
        source: "apache"
      },
      "chemical/x-xyz": {
        source: "apache",
        extensions: ["xyz"]
      },
      "font/collection": {
        source: "iana",
        extensions: ["ttc"]
      },
      "font/otf": {
        source: "iana",
        compressible: true,
        extensions: ["otf"]
      },
      "font/sfnt": {
        source: "iana"
      },
      "font/ttf": {
        source: "iana",
        compressible: true,
        extensions: ["ttf"]
      },
      "font/woff": {
        source: "iana",
        extensions: ["woff"]
      },
      "font/woff2": {
        source: "iana",
        extensions: ["woff2"]
      },
      "image/aces": {
        source: "iana",
        extensions: ["exr"]
      },
      "image/apng": {
        compressible: false,
        extensions: ["apng"]
      },
      "image/avci": {
        source: "iana",
        extensions: ["avci"]
      },
      "image/avcs": {
        source: "iana",
        extensions: ["avcs"]
      },
      "image/avif": {
        source: "iana",
        compressible: false,
        extensions: ["avif"]
      },
      "image/bmp": {
        source: "iana",
        compressible: true,
        extensions: ["bmp"]
      },
      "image/cgm": {
        source: "iana",
        extensions: ["cgm"]
      },
      "image/dicom-rle": {
        source: "iana",
        extensions: ["drle"]
      },
      "image/emf": {
        source: "iana",
        extensions: ["emf"]
      },
      "image/fits": {
        source: "iana",
        extensions: ["fits"]
      },
      "image/g3fax": {
        source: "iana",
        extensions: ["g3"]
      },
      "image/gif": {
        source: "iana",
        compressible: false,
        extensions: ["gif"]
      },
      "image/heic": {
        source: "iana",
        extensions: ["heic"]
      },
      "image/heic-sequence": {
        source: "iana",
        extensions: ["heics"]
      },
      "image/heif": {
        source: "iana",
        extensions: ["heif"]
      },
      "image/heif-sequence": {
        source: "iana",
        extensions: ["heifs"]
      },
      "image/hej2k": {
        source: "iana",
        extensions: ["hej2"]
      },
      "image/hsj2": {
        source: "iana",
        extensions: ["hsj2"]
      },
      "image/ief": {
        source: "iana",
        extensions: ["ief"]
      },
      "image/jls": {
        source: "iana",
        extensions: ["jls"]
      },
      "image/jp2": {
        source: "iana",
        compressible: false,
        extensions: ["jp2", "jpg2"]
      },
      "image/jpeg": {
        source: "iana",
        compressible: false,
        extensions: ["jpeg", "jpg", "jpe"]
      },
      "image/jph": {
        source: "iana",
        extensions: ["jph"]
      },
      "image/jphc": {
        source: "iana",
        extensions: ["jhc"]
      },
      "image/jpm": {
        source: "iana",
        compressible: false,
        extensions: ["jpm"]
      },
      "image/jpx": {
        source: "iana",
        compressible: false,
        extensions: ["jpx", "jpf"]
      },
      "image/jxr": {
        source: "iana",
        extensions: ["jxr"]
      },
      "image/jxra": {
        source: "iana",
        extensions: ["jxra"]
      },
      "image/jxrs": {
        source: "iana",
        extensions: ["jxrs"]
      },
      "image/jxs": {
        source: "iana",
        extensions: ["jxs"]
      },
      "image/jxsc": {
        source: "iana",
        extensions: ["jxsc"]
      },
      "image/jxsi": {
        source: "iana",
        extensions: ["jxsi"]
      },
      "image/jxss": {
        source: "iana",
        extensions: ["jxss"]
      },
      "image/ktx": {
        source: "iana",
        extensions: ["ktx"]
      },
      "image/ktx2": {
        source: "iana",
        extensions: ["ktx2"]
      },
      "image/naplps": {
        source: "iana"
      },
      "image/pjpeg": {
        compressible: false
      },
      "image/png": {
        source: "iana",
        compressible: false,
        extensions: ["png"]
      },
      "image/prs.btif": {
        source: "iana",
        extensions: ["btif"]
      },
      "image/prs.pti": {
        source: "iana",
        extensions: ["pti"]
      },
      "image/pwg-raster": {
        source: "iana"
      },
      "image/sgi": {
        source: "apache",
        extensions: ["sgi"]
      },
      "image/svg+xml": {
        source: "iana",
        compressible: true,
        extensions: ["svg", "svgz"]
      },
      "image/t38": {
        source: "iana",
        extensions: ["t38"]
      },
      "image/tiff": {
        source: "iana",
        compressible: false,
        extensions: ["tif", "tiff"]
      },
      "image/tiff-fx": {
        source: "iana",
        extensions: ["tfx"]
      },
      "image/vnd.adobe.photoshop": {
        source: "iana",
        compressible: true,
        extensions: ["psd"]
      },
      "image/vnd.airzip.accelerator.azv": {
        source: "iana",
        extensions: ["azv"]
      },
      "image/vnd.cns.inf2": {
        source: "iana"
      },
      "image/vnd.dece.graphic": {
        source: "iana",
        extensions: ["uvi", "uvvi", "uvg", "uvvg"]
      },
      "image/vnd.djvu": {
        source: "iana",
        extensions: ["djvu", "djv"]
      },
      "image/vnd.dvb.subtitle": {
        source: "iana",
        extensions: ["sub"]
      },
      "image/vnd.dwg": {
        source: "iana",
        extensions: ["dwg"]
      },
      "image/vnd.dxf": {
        source: "iana",
        extensions: ["dxf"]
      },
      "image/vnd.fastbidsheet": {
        source: "iana",
        extensions: ["fbs"]
      },
      "image/vnd.fpx": {
        source: "iana",
        extensions: ["fpx"]
      },
      "image/vnd.fst": {
        source: "iana",
        extensions: ["fst"]
      },
      "image/vnd.fujixerox.edmics-mmr": {
        source: "iana",
        extensions: ["mmr"]
      },
      "image/vnd.fujixerox.edmics-rlc": {
        source: "iana",
        extensions: ["rlc"]
      },
      "image/vnd.globalgraphics.pgb": {
        source: "iana"
      },
      "image/vnd.microsoft.icon": {
        source: "iana",
        compressible: true,
        extensions: ["ico"]
      },
      "image/vnd.mix": {
        source: "iana"
      },
      "image/vnd.mozilla.apng": {
        source: "iana"
      },
      "image/vnd.ms-dds": {
        compressible: true,
        extensions: ["dds"]
      },
      "image/vnd.ms-modi": {
        source: "iana",
        extensions: ["mdi"]
      },
      "image/vnd.ms-photo": {
        source: "apache",
        extensions: ["wdp"]
      },
      "image/vnd.net-fpx": {
        source: "iana",
        extensions: ["npx"]
      },
      "image/vnd.pco.b16": {
        source: "iana",
        extensions: ["b16"]
      },
      "image/vnd.radiance": {
        source: "iana"
      },
      "image/vnd.sealed.png": {
        source: "iana"
      },
      "image/vnd.sealedmedia.softseal.gif": {
        source: "iana"
      },
      "image/vnd.sealedmedia.softseal.jpg": {
        source: "iana"
      },
      "image/vnd.svf": {
        source: "iana"
      },
      "image/vnd.tencent.tap": {
        source: "iana",
        extensions: ["tap"]
      },
      "image/vnd.valve.source.texture": {
        source: "iana",
        extensions: ["vtf"]
      },
      "image/vnd.wap.wbmp": {
        source: "iana",
        extensions: ["wbmp"]
      },
      "image/vnd.xiff": {
        source: "iana",
        extensions: ["xif"]
      },
      "image/vnd.zbrush.pcx": {
        source: "iana",
        extensions: ["pcx"]
      },
      "image/webp": {
        source: "apache",
        extensions: ["webp"]
      },
      "image/wmf": {
        source: "iana",
        extensions: ["wmf"]
      },
      "image/x-3ds": {
        source: "apache",
        extensions: ["3ds"]
      },
      "image/x-cmu-raster": {
        source: "apache",
        extensions: ["ras"]
      },
      "image/x-cmx": {
        source: "apache",
        extensions: ["cmx"]
      },
      "image/x-freehand": {
        source: "apache",
        extensions: ["fh", "fhc", "fh4", "fh5", "fh7"]
      },
      "image/x-icon": {
        source: "apache",
        compressible: true,
        extensions: ["ico"]
      },
      "image/x-jng": {
        source: "nginx",
        extensions: ["jng"]
      },
      "image/x-mrsid-image": {
        source: "apache",
        extensions: ["sid"]
      },
      "image/x-ms-bmp": {
        source: "nginx",
        compressible: true,
        extensions: ["bmp"]
      },
      "image/x-pcx": {
        source: "apache",
        extensions: ["pcx"]
      },
      "image/x-pict": {
        source: "apache",
        extensions: ["pic", "pct"]
      },
      "image/x-portable-anymap": {
        source: "apache",
        extensions: ["pnm"]
      },
      "image/x-portable-bitmap": {
        source: "apache",
        extensions: ["pbm"]
      },
      "image/x-portable-graymap": {
        source: "apache",
        extensions: ["pgm"]
      },
      "image/x-portable-pixmap": {
        source: "apache",
        extensions: ["ppm"]
      },
      "image/x-rgb": {
        source: "apache",
        extensions: ["rgb"]
      },
      "image/x-tga": {
        source: "apache",
        extensions: ["tga"]
      },
      "image/x-xbitmap": {
        source: "apache",
        extensions: ["xbm"]
      },
      "image/x-xcf": {
        compressible: false
      },
      "image/x-xpixmap": {
        source: "apache",
        extensions: ["xpm"]
      },
      "image/x-xwindowdump": {
        source: "apache",
        extensions: ["xwd"]
      },
      "message/cpim": {
        source: "iana"
      },
      "message/delivery-status": {
        source: "iana"
      },
      "message/disposition-notification": {
        source: "iana",
        extensions: [
          "disposition-notification"
        ]
      },
      "message/external-body": {
        source: "iana"
      },
      "message/feedback-report": {
        source: "iana"
      },
      "message/global": {
        source: "iana",
        extensions: ["u8msg"]
      },
      "message/global-delivery-status": {
        source: "iana",
        extensions: ["u8dsn"]
      },
      "message/global-disposition-notification": {
        source: "iana",
        extensions: ["u8mdn"]
      },
      "message/global-headers": {
        source: "iana",
        extensions: ["u8hdr"]
      },
      "message/http": {
        source: "iana",
        compressible: false
      },
      "message/imdn+xml": {
        source: "iana",
        compressible: true
      },
      "message/news": {
        source: "iana"
      },
      "message/partial": {
        source: "iana",
        compressible: false
      },
      "message/rfc822": {
        source: "iana",
        compressible: true,
        extensions: ["eml", "mime"]
      },
      "message/s-http": {
        source: "iana"
      },
      "message/sip": {
        source: "iana"
      },
      "message/sipfrag": {
        source: "iana"
      },
      "message/tracking-status": {
        source: "iana"
      },
      "message/vnd.si.simp": {
        source: "iana"
      },
      "message/vnd.wfa.wsc": {
        source: "iana",
        extensions: ["wsc"]
      },
      "model/3mf": {
        source: "iana",
        extensions: ["3mf"]
      },
      "model/e57": {
        source: "iana"
      },
      "model/gltf+json": {
        source: "iana",
        compressible: true,
        extensions: ["gltf"]
      },
      "model/gltf-binary": {
        source: "iana",
        compressible: true,
        extensions: ["glb"]
      },
      "model/iges": {
        source: "iana",
        compressible: false,
        extensions: ["igs", "iges"]
      },
      "model/mesh": {
        source: "iana",
        compressible: false,
        extensions: ["msh", "mesh", "silo"]
      },
      "model/mtl": {
        source: "iana",
        extensions: ["mtl"]
      },
      "model/obj": {
        source: "iana",
        extensions: ["obj"]
      },
      "model/step": {
        source: "iana"
      },
      "model/step+xml": {
        source: "iana",
        compressible: true,
        extensions: ["stpx"]
      },
      "model/step+zip": {
        source: "iana",
        compressible: false,
        extensions: ["stpz"]
      },
      "model/step-xml+zip": {
        source: "iana",
        compressible: false,
        extensions: ["stpxz"]
      },
      "model/stl": {
        source: "iana",
        extensions: ["stl"]
      },
      "model/vnd.collada+xml": {
        source: "iana",
        compressible: true,
        extensions: ["dae"]
      },
      "model/vnd.dwf": {
        source: "iana",
        extensions: ["dwf"]
      },
      "model/vnd.flatland.3dml": {
        source: "iana"
      },
      "model/vnd.gdl": {
        source: "iana",
        extensions: ["gdl"]
      },
      "model/vnd.gs-gdl": {
        source: "apache"
      },
      "model/vnd.gs.gdl": {
        source: "iana"
      },
      "model/vnd.gtw": {
        source: "iana",
        extensions: ["gtw"]
      },
      "model/vnd.moml+xml": {
        source: "iana",
        compressible: true
      },
      "model/vnd.mts": {
        source: "iana",
        extensions: ["mts"]
      },
      "model/vnd.opengex": {
        source: "iana",
        extensions: ["ogex"]
      },
      "model/vnd.parasolid.transmit.binary": {
        source: "iana",
        extensions: ["x_b"]
      },
      "model/vnd.parasolid.transmit.text": {
        source: "iana",
        extensions: ["x_t"]
      },
      "model/vnd.pytha.pyox": {
        source: "iana"
      },
      "model/vnd.rosette.annotated-data-model": {
        source: "iana"
      },
      "model/vnd.sap.vds": {
        source: "iana",
        extensions: ["vds"]
      },
      "model/vnd.usdz+zip": {
        source: "iana",
        compressible: false,
        extensions: ["usdz"]
      },
      "model/vnd.valve.source.compiled-map": {
        source: "iana",
        extensions: ["bsp"]
      },
      "model/vnd.vtu": {
        source: "iana",
        extensions: ["vtu"]
      },
      "model/vrml": {
        source: "iana",
        compressible: false,
        extensions: ["wrl", "vrml"]
      },
      "model/x3d+binary": {
        source: "apache",
        compressible: false,
        extensions: ["x3db", "x3dbz"]
      },
      "model/x3d+fastinfoset": {
        source: "iana",
        extensions: ["x3db"]
      },
      "model/x3d+vrml": {
        source: "apache",
        compressible: false,
        extensions: ["x3dv", "x3dvz"]
      },
      "model/x3d+xml": {
        source: "iana",
        compressible: true,
        extensions: ["x3d", "x3dz"]
      },
      "model/x3d-vrml": {
        source: "iana",
        extensions: ["x3dv"]
      },
      "multipart/alternative": {
        source: "iana",
        compressible: false
      },
      "multipart/appledouble": {
        source: "iana"
      },
      "multipart/byteranges": {
        source: "iana"
      },
      "multipart/digest": {
        source: "iana"
      },
      "multipart/encrypted": {
        source: "iana",
        compressible: false
      },
      "multipart/form-data": {
        source: "iana",
        compressible: false
      },
      "multipart/header-set": {
        source: "iana"
      },
      "multipart/mixed": {
        source: "iana"
      },
      "multipart/multilingual": {
        source: "iana"
      },
      "multipart/parallel": {
        source: "iana"
      },
      "multipart/related": {
        source: "iana",
        compressible: false
      },
      "multipart/report": {
        source: "iana"
      },
      "multipart/signed": {
        source: "iana",
        compressible: false
      },
      "multipart/vnd.bint.med-plus": {
        source: "iana"
      },
      "multipart/voice-message": {
        source: "iana"
      },
      "multipart/x-mixed-replace": {
        source: "iana"
      },
      "text/1d-interleaved-parityfec": {
        source: "iana"
      },
      "text/cache-manifest": {
        source: "iana",
        compressible: true,
        extensions: ["appcache", "manifest"]
      },
      "text/calendar": {
        source: "iana",
        extensions: ["ics", "ifb"]
      },
      "text/calender": {
        compressible: true
      },
      "text/cmd": {
        compressible: true
      },
      "text/coffeescript": {
        extensions: ["coffee", "litcoffee"]
      },
      "text/cql": {
        source: "iana"
      },
      "text/cql-expression": {
        source: "iana"
      },
      "text/cql-identifier": {
        source: "iana"
      },
      "text/css": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["css"]
      },
      "text/csv": {
        source: "iana",
        compressible: true,
        extensions: ["csv"]
      },
      "text/csv-schema": {
        source: "iana"
      },
      "text/directory": {
        source: "iana"
      },
      "text/dns": {
        source: "iana"
      },
      "text/ecmascript": {
        source: "iana"
      },
      "text/encaprtp": {
        source: "iana"
      },
      "text/enriched": {
        source: "iana"
      },
      "text/fhirpath": {
        source: "iana"
      },
      "text/flexfec": {
        source: "iana"
      },
      "text/fwdred": {
        source: "iana"
      },
      "text/gff3": {
        source: "iana"
      },
      "text/grammar-ref-list": {
        source: "iana"
      },
      "text/html": {
        source: "iana",
        compressible: true,
        extensions: ["html", "htm", "shtml"]
      },
      "text/jade": {
        extensions: ["jade"]
      },
      "text/javascript": {
        source: "iana",
        compressible: true
      },
      "text/jcr-cnd": {
        source: "iana"
      },
      "text/jsx": {
        compressible: true,
        extensions: ["jsx"]
      },
      "text/less": {
        compressible: true,
        extensions: ["less"]
      },
      "text/markdown": {
        source: "iana",
        compressible: true,
        extensions: ["markdown", "md"]
      },
      "text/mathml": {
        source: "nginx",
        extensions: ["mml"]
      },
      "text/mdx": {
        compressible: true,
        extensions: ["mdx"]
      },
      "text/mizar": {
        source: "iana"
      },
      "text/n3": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["n3"]
      },
      "text/parameters": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/parityfec": {
        source: "iana"
      },
      "text/plain": {
        source: "iana",
        compressible: true,
        extensions: ["txt", "text", "conf", "def", "list", "log", "in", "ini"]
      },
      "text/provenance-notation": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/prs.fallenstein.rst": {
        source: "iana"
      },
      "text/prs.lines.tag": {
        source: "iana",
        extensions: ["dsc"]
      },
      "text/prs.prop.logic": {
        source: "iana"
      },
      "text/raptorfec": {
        source: "iana"
      },
      "text/red": {
        source: "iana"
      },
      "text/rfc822-headers": {
        source: "iana"
      },
      "text/richtext": {
        source: "iana",
        compressible: true,
        extensions: ["rtx"]
      },
      "text/rtf": {
        source: "iana",
        compressible: true,
        extensions: ["rtf"]
      },
      "text/rtp-enc-aescm128": {
        source: "iana"
      },
      "text/rtploopback": {
        source: "iana"
      },
      "text/rtx": {
        source: "iana"
      },
      "text/sgml": {
        source: "iana",
        extensions: ["sgml", "sgm"]
      },
      "text/shaclc": {
        source: "iana"
      },
      "text/shex": {
        source: "iana",
        extensions: ["shex"]
      },
      "text/slim": {
        extensions: ["slim", "slm"]
      },
      "text/spdx": {
        source: "iana",
        extensions: ["spdx"]
      },
      "text/strings": {
        source: "iana"
      },
      "text/stylus": {
        extensions: ["stylus", "styl"]
      },
      "text/t140": {
        source: "iana"
      },
      "text/tab-separated-values": {
        source: "iana",
        compressible: true,
        extensions: ["tsv"]
      },
      "text/troff": {
        source: "iana",
        extensions: ["t", "tr", "roff", "man", "me", "ms"]
      },
      "text/turtle": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["ttl"]
      },
      "text/ulpfec": {
        source: "iana"
      },
      "text/uri-list": {
        source: "iana",
        compressible: true,
        extensions: ["uri", "uris", "urls"]
      },
      "text/vcard": {
        source: "iana",
        compressible: true,
        extensions: ["vcard"]
      },
      "text/vnd.a": {
        source: "iana"
      },
      "text/vnd.abc": {
        source: "iana"
      },
      "text/vnd.ascii-art": {
        source: "iana"
      },
      "text/vnd.curl": {
        source: "iana",
        extensions: ["curl"]
      },
      "text/vnd.curl.dcurl": {
        source: "apache",
        extensions: ["dcurl"]
      },
      "text/vnd.curl.mcurl": {
        source: "apache",
        extensions: ["mcurl"]
      },
      "text/vnd.curl.scurl": {
        source: "apache",
        extensions: ["scurl"]
      },
      "text/vnd.debian.copyright": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/vnd.dmclientscript": {
        source: "iana"
      },
      "text/vnd.dvb.subtitle": {
        source: "iana",
        extensions: ["sub"]
      },
      "text/vnd.esmertec.theme-descriptor": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/vnd.familysearch.gedcom": {
        source: "iana",
        extensions: ["ged"]
      },
      "text/vnd.ficlab.flt": {
        source: "iana"
      },
      "text/vnd.fly": {
        source: "iana",
        extensions: ["fly"]
      },
      "text/vnd.fmi.flexstor": {
        source: "iana",
        extensions: ["flx"]
      },
      "text/vnd.gml": {
        source: "iana"
      },
      "text/vnd.graphviz": {
        source: "iana",
        extensions: ["gv"]
      },
      "text/vnd.hans": {
        source: "iana"
      },
      "text/vnd.hgl": {
        source: "iana"
      },
      "text/vnd.in3d.3dml": {
        source: "iana",
        extensions: ["3dml"]
      },
      "text/vnd.in3d.spot": {
        source: "iana",
        extensions: ["spot"]
      },
      "text/vnd.iptc.newsml": {
        source: "iana"
      },
      "text/vnd.iptc.nitf": {
        source: "iana"
      },
      "text/vnd.latex-z": {
        source: "iana"
      },
      "text/vnd.motorola.reflex": {
        source: "iana"
      },
      "text/vnd.ms-mediapackage": {
        source: "iana"
      },
      "text/vnd.net2phone.commcenter.command": {
        source: "iana"
      },
      "text/vnd.radisys.msml-basic-layout": {
        source: "iana"
      },
      "text/vnd.senx.warpscript": {
        source: "iana"
      },
      "text/vnd.si.uricatalogue": {
        source: "iana"
      },
      "text/vnd.sosi": {
        source: "iana"
      },
      "text/vnd.sun.j2me.app-descriptor": {
        source: "iana",
        charset: "UTF-8",
        extensions: ["jad"]
      },
      "text/vnd.trolltech.linguist": {
        source: "iana",
        charset: "UTF-8"
      },
      "text/vnd.wap.si": {
        source: "iana"
      },
      "text/vnd.wap.sl": {
        source: "iana"
      },
      "text/vnd.wap.wml": {
        source: "iana",
        extensions: ["wml"]
      },
      "text/vnd.wap.wmlscript": {
        source: "iana",
        extensions: ["wmls"]
      },
      "text/vtt": {
        source: "iana",
        charset: "UTF-8",
        compressible: true,
        extensions: ["vtt"]
      },
      "text/x-asm": {
        source: "apache",
        extensions: ["s", "asm"]
      },
      "text/x-c": {
        source: "apache",
        extensions: ["c", "cc", "cxx", "cpp", "h", "hh", "dic"]
      },
      "text/x-component": {
        source: "nginx",
        extensions: ["htc"]
      },
      "text/x-fortran": {
        source: "apache",
        extensions: ["f", "for", "f77", "f90"]
      },
      "text/x-gwt-rpc": {
        compressible: true
      },
      "text/x-handlebars-template": {
        extensions: ["hbs"]
      },
      "text/x-java-source": {
        source: "apache",
        extensions: ["java"]
      },
      "text/x-jquery-tmpl": {
        compressible: true
      },
      "text/x-lua": {
        extensions: ["lua"]
      },
      "text/x-markdown": {
        compressible: true,
        extensions: ["mkd"]
      },
      "text/x-nfo": {
        source: "apache",
        extensions: ["nfo"]
      },
      "text/x-opml": {
        source: "apache",
        extensions: ["opml"]
      },
      "text/x-org": {
        compressible: true,
        extensions: ["org"]
      },
      "text/x-pascal": {
        source: "apache",
        extensions: ["p", "pas"]
      },
      "text/x-processing": {
        compressible: true,
        extensions: ["pde"]
      },
      "text/x-sass": {
        extensions: ["sass"]
      },
      "text/x-scss": {
        extensions: ["scss"]
      },
      "text/x-setext": {
        source: "apache",
        extensions: ["etx"]
      },
      "text/x-sfv": {
        source: "apache",
        extensions: ["sfv"]
      },
      "text/x-suse-ymp": {
        compressible: true,
        extensions: ["ymp"]
      },
      "text/x-uuencode": {
        source: "apache",
        extensions: ["uu"]
      },
      "text/x-vcalendar": {
        source: "apache",
        extensions: ["vcs"]
      },
      "text/x-vcard": {
        source: "apache",
        extensions: ["vcf"]
      },
      "text/xml": {
        source: "iana",
        compressible: true,
        extensions: ["xml"]
      },
      "text/xml-external-parsed-entity": {
        source: "iana"
      },
      "text/yaml": {
        compressible: true,
        extensions: ["yaml", "yml"]
      },
      "video/1d-interleaved-parityfec": {
        source: "iana"
      },
      "video/3gpp": {
        source: "iana",
        extensions: ["3gp", "3gpp"]
      },
      "video/3gpp-tt": {
        source: "iana"
      },
      "video/3gpp2": {
        source: "iana",
        extensions: ["3g2"]
      },
      "video/av1": {
        source: "iana"
      },
      "video/bmpeg": {
        source: "iana"
      },
      "video/bt656": {
        source: "iana"
      },
      "video/celb": {
        source: "iana"
      },
      "video/dv": {
        source: "iana"
      },
      "video/encaprtp": {
        source: "iana"
      },
      "video/ffv1": {
        source: "iana"
      },
      "video/flexfec": {
        source: "iana"
      },
      "video/h261": {
        source: "iana",
        extensions: ["h261"]
      },
      "video/h263": {
        source: "iana",
        extensions: ["h263"]
      },
      "video/h263-1998": {
        source: "iana"
      },
      "video/h263-2000": {
        source: "iana"
      },
      "video/h264": {
        source: "iana",
        extensions: ["h264"]
      },
      "video/h264-rcdo": {
        source: "iana"
      },
      "video/h264-svc": {
        source: "iana"
      },
      "video/h265": {
        source: "iana"
      },
      "video/iso.segment": {
        source: "iana",
        extensions: ["m4s"]
      },
      "video/jpeg": {
        source: "iana",
        extensions: ["jpgv"]
      },
      "video/jpeg2000": {
        source: "iana"
      },
      "video/jpm": {
        source: "apache",
        extensions: ["jpm", "jpgm"]
      },
      "video/jxsv": {
        source: "iana"
      },
      "video/mj2": {
        source: "iana",
        extensions: ["mj2", "mjp2"]
      },
      "video/mp1s": {
        source: "iana"
      },
      "video/mp2p": {
        source: "iana"
      },
      "video/mp2t": {
        source: "iana",
        extensions: ["ts"]
      },
      "video/mp4": {
        source: "iana",
        compressible: false,
        extensions: ["mp4", "mp4v", "mpg4"]
      },
      "video/mp4v-es": {
        source: "iana"
      },
      "video/mpeg": {
        source: "iana",
        compressible: false,
        extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"]
      },
      "video/mpeg4-generic": {
        source: "iana"
      },
      "video/mpv": {
        source: "iana"
      },
      "video/nv": {
        source: "iana"
      },
      "video/ogg": {
        source: "iana",
        compressible: false,
        extensions: ["ogv"]
      },
      "video/parityfec": {
        source: "iana"
      },
      "video/pointer": {
        source: "iana"
      },
      "video/quicktime": {
        source: "iana",
        compressible: false,
        extensions: ["qt", "mov"]
      },
      "video/raptorfec": {
        source: "iana"
      },
      "video/raw": {
        source: "iana"
      },
      "video/rtp-enc-aescm128": {
        source: "iana"
      },
      "video/rtploopback": {
        source: "iana"
      },
      "video/rtx": {
        source: "iana"
      },
      "video/scip": {
        source: "iana"
      },
      "video/smpte291": {
        source: "iana"
      },
      "video/smpte292m": {
        source: "iana"
      },
      "video/ulpfec": {
        source: "iana"
      },
      "video/vc1": {
        source: "iana"
      },
      "video/vc2": {
        source: "iana"
      },
      "video/vnd.cctv": {
        source: "iana"
      },
      "video/vnd.dece.hd": {
        source: "iana",
        extensions: ["uvh", "uvvh"]
      },
      "video/vnd.dece.mobile": {
        source: "iana",
        extensions: ["uvm", "uvvm"]
      },
      "video/vnd.dece.mp4": {
        source: "iana"
      },
      "video/vnd.dece.pd": {
        source: "iana",
        extensions: ["uvp", "uvvp"]
      },
      "video/vnd.dece.sd": {
        source: "iana",
        extensions: ["uvs", "uvvs"]
      },
      "video/vnd.dece.video": {
        source: "iana",
        extensions: ["uvv", "uvvv"]
      },
      "video/vnd.directv.mpeg": {
        source: "iana"
      },
      "video/vnd.directv.mpeg-tts": {
        source: "iana"
      },
      "video/vnd.dlna.mpeg-tts": {
        source: "iana"
      },
      "video/vnd.dvb.file": {
        source: "iana",
        extensions: ["dvb"]
      },
      "video/vnd.fvt": {
        source: "iana",
        extensions: ["fvt"]
      },
      "video/vnd.hns.video": {
        source: "iana"
      },
      "video/vnd.iptvforum.1dparityfec-1010": {
        source: "iana"
      },
      "video/vnd.iptvforum.1dparityfec-2005": {
        source: "iana"
      },
      "video/vnd.iptvforum.2dparityfec-1010": {
        source: "iana"
      },
      "video/vnd.iptvforum.2dparityfec-2005": {
        source: "iana"
      },
      "video/vnd.iptvforum.ttsavc": {
        source: "iana"
      },
      "video/vnd.iptvforum.ttsmpeg2": {
        source: "iana"
      },
      "video/vnd.motorola.video": {
        source: "iana"
      },
      "video/vnd.motorola.videop": {
        source: "iana"
      },
      "video/vnd.mpegurl": {
        source: "iana",
        extensions: ["mxu", "m4u"]
      },
      "video/vnd.ms-playready.media.pyv": {
        source: "iana",
        extensions: ["pyv"]
      },
      "video/vnd.nokia.interleaved-multimedia": {
        source: "iana"
      },
      "video/vnd.nokia.mp4vr": {
        source: "iana"
      },
      "video/vnd.nokia.videovoip": {
        source: "iana"
      },
      "video/vnd.objectvideo": {
        source: "iana"
      },
      "video/vnd.radgamettools.bink": {
        source: "iana"
      },
      "video/vnd.radgamettools.smacker": {
        source: "iana"
      },
      "video/vnd.sealed.mpeg1": {
        source: "iana"
      },
      "video/vnd.sealed.mpeg4": {
        source: "iana"
      },
      "video/vnd.sealed.swf": {
        source: "iana"
      },
      "video/vnd.sealedmedia.softseal.mov": {
        source: "iana"
      },
      "video/vnd.uvvu.mp4": {
        source: "iana",
        extensions: ["uvu", "uvvu"]
      },
      "video/vnd.vivo": {
        source: "iana",
        extensions: ["viv"]
      },
      "video/vnd.youtube.yt": {
        source: "iana"
      },
      "video/vp8": {
        source: "iana"
      },
      "video/vp9": {
        source: "iana"
      },
      "video/webm": {
        source: "apache",
        compressible: false,
        extensions: ["webm"]
      },
      "video/x-f4v": {
        source: "apache",
        extensions: ["f4v"]
      },
      "video/x-fli": {
        source: "apache",
        extensions: ["fli"]
      },
      "video/x-flv": {
        source: "apache",
        compressible: false,
        extensions: ["flv"]
      },
      "video/x-m4v": {
        source: "apache",
        extensions: ["m4v"]
      },
      "video/x-matroska": {
        source: "apache",
        compressible: false,
        extensions: ["mkv", "mk3d", "mks"]
      },
      "video/x-mng": {
        source: "apache",
        extensions: ["mng"]
      },
      "video/x-ms-asf": {
        source: "apache",
        extensions: ["asf", "asx"]
      },
      "video/x-ms-vob": {
        source: "apache",
        extensions: ["vob"]
      },
      "video/x-ms-wm": {
        source: "apache",
        extensions: ["wm"]
      },
      "video/x-ms-wmv": {
        source: "apache",
        compressible: false,
        extensions: ["wmv"]
      },
      "video/x-ms-wmx": {
        source: "apache",
        extensions: ["wmx"]
      },
      "video/x-ms-wvx": {
        source: "apache",
        extensions: ["wvx"]
      },
      "video/x-msvideo": {
        source: "apache",
        extensions: ["avi"]
      },
      "video/x-sgi-movie": {
        source: "apache",
        extensions: ["movie"]
      },
      "video/x-smv": {
        source: "apache",
        extensions: ["smv"]
      },
      "x-conference/x-cooltalk": {
        source: "apache",
        extensions: ["ice"]
      },
      "x-shader/x-fragment": {
        compressible: true
      },
      "x-shader/x-vertex": {
        compressible: true
      }
    };
  }
});

// node_modules/form-data/node_modules/mime-db/index.js
var require_mime_db3 = __commonJS({
  "node_modules/form-data/node_modules/mime-db/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_db3();
  }
});

// node_modules/form-data/node_modules/mime-types/index.js
var require_mime_types3 = __commonJS({
  "node_modules/form-data/node_modules/mime-types/index.js"(exports2) {
    "use strict";
    var db2 = require_mime_db3();
    var extname = require("path").extname;
    var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
    var TEXT_TYPE_REGEXP = /^text\//i;
    exports2.charset = charset;
    exports2.charsets = { lookup: charset };
    exports2.contentType = contentType;
    exports2.extension = extension;
    exports2.extensions = /* @__PURE__ */ Object.create(null);
    exports2.lookup = lookup;
    exports2.types = /* @__PURE__ */ Object.create(null);
    populateMaps(exports2.extensions, exports2.types);
    function charset(type) {
      if (!type || typeof type !== "string") {
        return false;
      }
      var match = EXTRACT_TYPE_REGEXP.exec(type);
      var mime = match && db2[match[1].toLowerCase()];
      if (mime && mime.charset) {
        return mime.charset;
      }
      if (match && TEXT_TYPE_REGEXP.test(match[1])) {
        return "UTF-8";
      }
      return false;
    }
    function contentType(str) {
      if (!str || typeof str !== "string") {
        return false;
      }
      var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str;
      if (!mime) {
        return false;
      }
      if (mime.indexOf("charset") === -1) {
        var charset2 = exports2.charset(mime);
        if (charset2) mime += "; charset=" + charset2.toLowerCase();
      }
      return mime;
    }
    function extension(type) {
      if (!type || typeof type !== "string") {
        return false;
      }
      var match = EXTRACT_TYPE_REGEXP.exec(type);
      var exts = match && exports2.extensions[match[1].toLowerCase()];
      if (!exts || !exts.length) {
        return false;
      }
      return exts[0];
    }
    function lookup(path33) {
      if (!path33 || typeof path33 !== "string") {
        return false;
      }
      var extension2 = extname("x." + path33).toLowerCase().substr(1);
      if (!extension2) {
        return false;
      }
      return exports2.types[extension2] || false;
    }
    function populateMaps(extensions, types) {
      var preference = ["nginx", "apache", void 0, "iana"];
      Object.keys(db2).forEach(function forEachMimeType(type) {
        var mime = db2[type];
        var exts = mime.extensions;
        if (!exts || !exts.length) {
          return;
        }
        extensions[type] = exts;
        for (var i = 0; i < exts.length; i++) {
          var extension2 = exts[i];
          if (types[extension2]) {
            var from = preference.indexOf(db2[types[extension2]].source);
            var to = preference.indexOf(mime.source);
            if (types[extension2] !== "application/octet-stream" && (from > to || from === to && types[extension2].substr(0, 12) === "application/")) {
              continue;
            }
          }
          types[extension2] = type;
        }
      });
    }
  }
});

// node_modules/asynckit/lib/defer.js
var require_defer2 = __commonJS({
  "node_modules/asynckit/lib/defer.js"(exports2, module2) {
    "use strict";
    module2.exports = defer;
    function defer(fn) {
      var nextTick = typeof setImmediate == "function" ? setImmediate : typeof process == "object" && typeof process.nextTick == "function" ? process.nextTick : null;
      if (nextTick) {
        nextTick(fn);
      } else {
        setTimeout(fn, 0);
      }
    }
  }
});

// node_modules/asynckit/lib/async.js
var require_async8 = __commonJS({
  "node_modules/asynckit/lib/async.js"(exports2, module2) {
    "use strict";
    var defer = require_defer2();
    module2.exports = async;
    function async(callback) {
      var isAsync2 = false;
      defer(function() {
        isAsync2 = true;
      });
      return function async_callback(err, result) {
        if (isAsync2) {
          callback(err, result);
        } else {
          defer(function nextTick_callback() {
            callback(err, result);
          });
        }
      };
    }
  }
});

// node_modules/asynckit/lib/abort.js
var require_abort = __commonJS({
  "node_modules/asynckit/lib/abort.js"(exports2, module2) {
    "use strict";
    module2.exports = abort;
    function abort(state) {
      Object.keys(state.jobs).forEach(clean.bind(state));
      state.jobs = {};
    }
    function clean(key) {
      if (typeof this.jobs[key] == "function") {
        this.jobs[key]();
      }
    }
  }
});

// node_modules/asynckit/lib/iterate.js
var require_iterate = __commonJS({
  "node_modules/asynckit/lib/iterate.js"(exports2, module2) {
    "use strict";
    var async = require_async8();
    var abort = require_abort();
    module2.exports = iterate;
    function iterate(list2, iterator2, state, callback) {
      var key = state["keyedList"] ? state["keyedList"][state.index] : state.index;
      state.jobs[key] = runJob(iterator2, key, list2[key], function(error73, output) {
        if (!(key in state.jobs)) {
          return;
        }
        delete state.jobs[key];
        if (error73) {
          abort(state);
        } else {
          state.results[key] = output;
        }
        callback(error73, state.results);
      });
    }
    function runJob(iterator2, key, item, callback) {
      var aborter;
      if (iterator2.length == 2) {
        aborter = iterator2(item, async(callback));
      } else {
        aborter = iterator2(item, key, async(callback));
      }
      return aborter;
    }
  }
});

// node_modules/asynckit/lib/state.js
var require_state2 = __commonJS({
  "node_modules/asynckit/lib/state.js"(exports2, module2) {
    "use strict";
    module2.exports = state;
    function state(list2, sortMethod) {
      var isNamedList = !Array.isArray(list2), initState = {
        index: 0,
        keyedList: isNamedList || sortMethod ? Object.keys(list2) : null,
        jobs: {},
        results: isNamedList ? {} : [],
        size: isNamedList ? Object.keys(list2).length : list2.length
      };
      if (sortMethod) {
        initState.keyedList.sort(isNamedList ? sortMethod : function(a, b) {
          return sortMethod(list2[a], list2[b]);
        });
      }
      return initState;
    }
  }
});

// node_modules/asynckit/lib/terminator.js
var require_terminator = __commonJS({
  "node_modules/asynckit/lib/terminator.js"(exports2, module2) {
    "use strict";
    var abort = require_abort();
    var async = require_async8();
    module2.exports = terminator;
    function terminator(callback) {
      if (!Object.keys(this.jobs).length) {
        return;
      }
      this.index = this.size;
      abort(this);
      async(callback)(null, this.results);
    }
  }
});

// node_modules/asynckit/parallel.js
var require_parallel = __commonJS({
  "node_modules/asynckit/parallel.js"(exports2, module2) {
    "use strict";
    var iterate = require_iterate();
    var initState = require_state2();
    var terminator = require_terminator();
    module2.exports = parallel;
    function parallel(list2, iterator2, callback) {
      var state = initState(list2);
      while (state.index < (state["keyedList"] || list2).length) {
        iterate(list2, iterator2, state, function(error73, result) {
          if (error73) {
            callback(error73, result);
            return;
          }
          if (Object.keys(state.jobs).length === 0) {
            callback(null, state.results);
            return;
          }
        });
        state.index++;
      }
      return terminator.bind(state, callback);
    }
  }
});

// node_modules/asynckit/serialOrdered.js
var require_serialOrdered = __commonJS({
  "node_modules/asynckit/serialOrdered.js"(exports2, module2) {
    "use strict";
    var iterate = require_iterate();
    var initState = require_state2();
    var terminator = require_terminator();
    module2.exports = serialOrdered;
    module2.exports.ascending = ascending;
    module2.exports.descending = descending;
    function serialOrdered(list2, iterator2, sortMethod, callback) {
      var state = initState(list2, sortMethod);
      iterate(list2, iterator2, state, function iteratorHandler(error73, result) {
        if (error73) {
          callback(error73, result);
          return;
        }
        state.index++;
        if (state.index < (state["keyedList"] || list2).length) {
          iterate(list2, iterator2, state, iteratorHandler);
          return;
        }
        callback(null, state.results);
      });
      return terminator.bind(state, callback);
    }
    function ascending(a, b) {
      return a < b ? -1 : a > b ? 1 : 0;
    }
    function descending(a, b) {
      return -1 * ascending(a, b);
    }
  }
});

// node_modules/asynckit/serial.js
var require_serial = __commonJS({
  "node_modules/asynckit/serial.js"(exports2, module2) {
    "use strict";
    var serialOrdered = require_serialOrdered();
    module2.exports = serial;
    function serial(list2, iterator2, callback) {
      return serialOrdered(list2, iterator2, null, callback);
    }
  }
});

// node_modules/asynckit/index.js
var require_asynckit = __commonJS({
  "node_modules/asynckit/index.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      parallel: require_parallel(),
      serial: require_serial(),
      serialOrdered: require_serialOrdered()
    };
  }
});

// node_modules/has-tostringtag/shams.js
var require_shams2 = __commonJS({
  "node_modules/has-tostringtag/shams.js"(exports2, module2) {
    "use strict";
    var hasSymbols = require_shams();
    module2.exports = function hasToStringTagShams() {
      return hasSymbols() && !!Symbol.toStringTag;
    };
  }
});

// node_modules/es-set-tostringtag/index.js
var require_es_set_tostringtag = __commonJS({
  "node_modules/es-set-tostringtag/index.js"(exports2, module2) {
    "use strict";
    var GetIntrinsic = require_get_intrinsic();
    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
    var hasToStringTag = require_shams2()();
    var hasOwn = require_hasown();
    var $TypeError = require_type();
    var toStringTag2 = hasToStringTag ? Symbol.toStringTag : null;
    module2.exports = function setToStringTag(object4, value) {
      var overrideIfSet = arguments.length > 2 && !!arguments[2] && arguments[2].force;
      var nonConfigurable = arguments.length > 2 && !!arguments[2] && arguments[2].nonConfigurable;
      if (typeof overrideIfSet !== "undefined" && typeof overrideIfSet !== "boolean" || typeof nonConfigurable !== "undefined" && typeof nonConfigurable !== "boolean") {
        throw new $TypeError("if provided, the `overrideIfSet` and `nonConfigurable` options must be booleans");
      }
      if (toStringTag2 && (overrideIfSet || !hasOwn(object4, toStringTag2))) {
        if ($defineProperty) {
          $defineProperty(object4, toStringTag2, {
            configurable: !nonConfigurable,
            enumerable: false,
            value,
            writable: false
          });
        } else {
          object4[toStringTag2] = value;
        }
      }
    };
  }
});

// node_modules/form-data/lib/populate.js
var require_populate = __commonJS({
  "node_modules/form-data/lib/populate.js"(exports2, module2) {
    "use strict";
    module2.exports = function(dst, src) {
      Object.keys(src).forEach(function(prop) {
        dst[prop] = dst[prop] || src[prop];
      });
      return dst;
    };
  }
});

// node_modules/form-data/lib/form_data.js
var require_form_data = __commonJS({
  "node_modules/form-data/lib/form_data.js"(exports2, module2) {
    "use strict";
    var CombinedStream = require_combined_stream();
    var util4 = require("util");
    var path33 = require("path");
    var http4 = require("http");
    var https2 = require("https");
    var parseUrl2 = require("url").parse;
    var fs34 = require("fs");
    var Stream = require("stream").Stream;
    var crypto7 = require("crypto");
    var mime = require_mime_types3();
    var asynckit = require_asynckit();
    var setToStringTag = require_es_set_tostringtag();
    var hasOwn = require_hasown();
    var populate = require_populate();
    function FormData4(options) {
      if (!(this instanceof FormData4)) {
        return new FormData4(options);
      }
      this._overheadLength = 0;
      this._valueLength = 0;
      this._valuesToMeasure = [];
      CombinedStream.call(this);
      options = options || {};
      for (var option in options) {
        this[option] = options[option];
      }
    }
    util4.inherits(FormData4, CombinedStream);
    FormData4.LINE_BREAK = "\r\n";
    FormData4.DEFAULT_CONTENT_TYPE = "application/octet-stream";
    FormData4.prototype.append = function(field, value, options) {
      options = options || {};
      if (typeof options === "string") {
        options = { filename: options };
      }
      var append2 = CombinedStream.prototype.append.bind(this);
      if (typeof value === "number" || value == null) {
        value = String(value);
      }
      if (Array.isArray(value)) {
        this._error(new Error("Arrays are not supported."));
        return;
      }
      var header = this._multiPartHeader(field, value, options);
      var footer = this._multiPartFooter();
      append2(header);
      append2(value);
      append2(footer);
      this._trackLength(header, value, options);
    };
    FormData4.prototype._trackLength = function(header, value, options) {
      var valueLength = 0;
      if (options.knownLength != null) {
        valueLength += Number(options.knownLength);
      } else if (Buffer.isBuffer(value)) {
        valueLength = value.length;
      } else if (typeof value === "string") {
        valueLength = Buffer.byteLength(value);
      }
      this._valueLength += valueLength;
      this._overheadLength += Buffer.byteLength(header) + FormData4.LINE_BREAK.length;
      if (!value || !value.path && !(value.readable && hasOwn(value, "httpVersion")) && !(value instanceof Stream)) {
        return;
      }
      if (!options.knownLength) {
        this._valuesToMeasure.push(value);
      }
    };
    FormData4.prototype._lengthRetriever = function(value, callback) {
      if (hasOwn(value, "fd")) {
        if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
          callback(null, value.end + 1 - (value.start ? value.start : 0));
        } else {
          fs34.stat(value.path, function(err, stat) {
            if (err) {
              callback(err);
              return;
            }
            var fileSize = stat.size - (value.start ? value.start : 0);
            callback(null, fileSize);
          });
        }
      } else if (hasOwn(value, "httpVersion")) {
        callback(null, Number(value.headers["content-length"]));
      } else if (hasOwn(value, "httpModule")) {
        value.on("response", function(response) {
          value.pause();
          callback(null, Number(response.headers["content-length"]));
        });
        value.resume();
      } else {
        callback("Unknown stream");
      }
    };
    FormData4.prototype._multiPartHeader = function(field, value, options) {
      if (typeof options.header === "string") {
        return options.header;
      }
      var contentDisposition = this._getContentDisposition(value, options);
      var contentType = this._getContentType(value, options);
      var contents = "";
      var headers = {
        // add custom disposition as third element or keep it two elements if not
        "Content-Disposition": ["form-data", 'name="' + field + '"'].concat(contentDisposition || []),
        // if no content type. allow it to be empty array
        "Content-Type": [].concat(contentType || [])
      };
      if (typeof options.header === "object") {
        populate(headers, options.header);
      }
      var header;
      for (var prop in headers) {
        if (hasOwn(headers, prop)) {
          header = headers[prop];
          if (header == null) {
            continue;
          }
          if (!Array.isArray(header)) {
            header = [header];
          }
          if (header.length) {
            contents += prop + ": " + header.join("; ") + FormData4.LINE_BREAK;
          }
        }
      }
      return "--" + this.getBoundary() + FormData4.LINE_BREAK + contents + FormData4.LINE_BREAK;
    };
    FormData4.prototype._getContentDisposition = function(value, options) {
      var filename;
      if (typeof options.filepath === "string") {
        filename = path33.normalize(options.filepath).replace(/\\/g, "/");
      } else if (options.filename || value && (value.name || value.path)) {
        filename = path33.basename(options.filename || value && (value.name || value.path));
      } else if (value && value.readable && hasOwn(value, "httpVersion")) {
        filename = path33.basename(value.client._httpMessage.path || "");
      }
      if (filename) {
        return 'filename="' + filename + '"';
      }
    };
    FormData4.prototype._getContentType = function(value, options) {
      var contentType = options.contentType;
      if (!contentType && value && value.name) {
        contentType = mime.lookup(value.name);
      }
      if (!contentType && value && value.path) {
        contentType = mime.lookup(value.path);
      }
      if (!contentType && value && value.readable && hasOwn(value, "httpVersion")) {
        contentType = value.headers["content-type"];
      }
      if (!contentType && (options.filepath || options.filename)) {
        contentType = mime.lookup(options.filepath || options.filename);
      }
      if (!contentType && value && typeof value === "object") {
        contentType = FormData4.DEFAULT_CONTENT_TYPE;
      }
      return contentType;
    };
    FormData4.prototype._multiPartFooter = function() {
      return function(next) {
        var footer = FormData4.LINE_BREAK;
        var lastPart = this._streams.length === 0;
        if (lastPart) {
          footer += this._lastBoundary();
        }
        next(footer);
      }.bind(this);
    };
    FormData4.prototype._lastBoundary = function() {
      return "--" + this.getBoundary() + "--" + FormData4.LINE_BREAK;
    };
    FormData4.prototype.getHeaders = function(userHeaders) {
      var header;
      var formHeaders = {
        "content-type": "multipart/form-data; boundary=" + this.getBoundary()
      };
      for (header in userHeaders) {
        if (hasOwn(userHeaders, header)) {
          formHeaders[header.toLowerCase()] = userHeaders[header];
        }
      }
      return formHeaders;
    };
    FormData4.prototype.setBoundary = function(boundary) {
      if (typeof boundary !== "string") {
        throw new TypeError("FormData boundary must be a string");
      }
      this._boundary = boundary;
    };
    FormData4.prototype.getBoundary = function() {
      if (!this._boundary) {
        this._generateBoundary();
      }
      return this._boundary;
    };
    FormData4.prototype.getBuffer = function() {
      var dataBuffer = new Buffer.alloc(0);
      var boundary = this.getBoundary();
      for (var i = 0, len = this._streams.length; i < len; i++) {
        if (typeof this._streams[i] !== "function") {
          if (Buffer.isBuffer(this._streams[i])) {
            dataBuffer = Buffer.concat([dataBuffer, this._streams[i]]);
          } else {
            dataBuffer = Buffer.concat([dataBuffer, Buffer.from(this._streams[i])]);
          }
          if (typeof this._streams[i] !== "string" || this._streams[i].substring(2, boundary.length + 2) !== boundary) {
            dataBuffer = Buffer.concat([dataBuffer, Buffer.from(FormData4.LINE_BREAK)]);
          }
        }
      }
      return Buffer.concat([dataBuffer, Buffer.from(this._lastBoundary())]);
    };
    FormData4.prototype._generateBoundary = function() {
      this._boundary = "--------------------------" + crypto7.randomBytes(12).toString("hex");
    };
    FormData4.prototype.getLengthSync = function() {
      var knownLength = this._overheadLength + this._valueLength;
      if (this._streams.length) {
        knownLength += this._lastBoundary().length;
      }
      if (!this.hasKnownLength()) {
        this._error(new Error("Cannot calculate proper length in synchronous way."));
      }
      return knownLength;
    };
    FormData4.prototype.hasKnownLength = function() {
      var hasKnownLength = true;
      if (this._valuesToMeasure.length) {
        hasKnownLength = false;
      }
      return hasKnownLength;
    };
    FormData4.prototype.getLength = function(cb) {
      var knownLength = this._overheadLength + this._valueLength;
      if (this._streams.length) {
        knownLength += this._lastBoundary().length;
      }
      if (!this._valuesToMeasure.length) {
        process.nextTick(cb.bind(this, null, knownLength));
        return;
      }
      asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
        if (err) {
          cb(err);
          return;
        }
        values.forEach(function(length) {
          knownLength += length;
        });
        cb(null, knownLength);
      });
    };
    FormData4.prototype.submit = function(params, cb) {
      var request;
      var options;
      var defaults2 = { method: "post" };
      if (typeof params === "string") {
        params = parseUrl2(params);
        options = populate({
          port: params.port,
          path: params.pathname,
          host: params.hostname,
          protocol: params.protocol
        }, defaults2);
      } else {
        options = populate(params, defaults2);
        if (!options.port) {
          options.port = options.protocol === "https:" ? 443 : 80;
        }
      }
      options.headers = this.getHeaders(params.headers);
      if (options.protocol === "https:") {
        request = https2.request(options);
      } else {
        request = http4.request(options);
      }
      this.getLength(function(err, length) {
        if (err && err !== "Unknown stream") {
          this._error(err);
          return;
        }
        if (length) {
          request.setHeader("Content-Length", length);
        }
        this.pipe(request);
        if (cb) {
          var onResponse;
          var callback = function(error73, responce) {
            request.removeListener("error", callback);
            request.removeListener("response", onResponse);
            return cb.call(this, error73, responce);
          };
          onResponse = callback.bind(this, null);
          request.on("error", callback);
          request.on("response", onResponse);
        }
      }.bind(this));
      return request;
    };
    FormData4.prototype._error = function(err) {
      if (!this.error) {
        this.error = err;
        this.pause();
        this.emit("error", err);
      }
    };
    FormData4.prototype.toString = function() {
      return "[object FormData]";
    };
    setToStringTag(FormData4.prototype, "FormData");
    module2.exports = FormData4;
  }
});

// node_modules/axios/lib/platform/node/classes/FormData.js
var import_form_data, FormData_default;
var init_FormData = __esm({
  "node_modules/axios/lib/platform/node/classes/FormData.js"() {
    "use strict";
    import_form_data = __toESM(require_form_data(), 1);
    FormData_default = import_form_data.default;
  }
});

// node_modules/axios/lib/helpers/toFormData.js
function isVisitable(thing) {
  return utils_default2.isPlainObject(thing) || utils_default2.isArray(thing);
}
function removeBrackets(key) {
  return utils_default2.endsWith(key, "[]") ? key.slice(0, -2) : key;
}
function renderKey(path33, key, dots) {
  if (!path33) return key;
  return path33.concat(key).map(function each(token, i) {
    token = removeBrackets(token);
    return !dots && i ? "[" + token + "]" : token;
  }).join(dots ? "." : "");
}
function isFlatArray(arr) {
  return utils_default2.isArray(arr) && !arr.some(isVisitable);
}
function toFormData(obj, formData, options) {
  if (!utils_default2.isObject(obj)) {
    throw new TypeError("target must be an object");
  }
  formData = formData || new (FormData_default || FormData)();
  options = utils_default2.toFlatObject(
    options,
    {
      metaTokens: true,
      dots: false,
      indexes: false
    },
    false,
    function defined(option, source) {
      return !utils_default2.isUndefined(source[option]);
    }
  );
  const metaTokens = options.metaTokens;
  const visitor = options.visitor || defaultVisitor;
  const dots = options.dots;
  const indexes = options.indexes;
  const _Blob = options.Blob || typeof Blob !== "undefined" && Blob;
  const useBlob = _Blob && utils_default2.isSpecCompliantForm(formData);
  if (!utils_default2.isFunction(visitor)) {
    throw new TypeError("visitor must be a function");
  }
  function convertValue(value) {
    if (value === null) return "";
    if (utils_default2.isDate(value)) {
      return value.toISOString();
    }
    if (utils_default2.isBoolean(value)) {
      return value.toString();
    }
    if (!useBlob && utils_default2.isBlob(value)) {
      throw new AxiosError_default("Blob is not supported. Use a Buffer instead.");
    }
    if (utils_default2.isArrayBuffer(value) || utils_default2.isTypedArray(value)) {
      return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
    }
    return value;
  }
  function defaultVisitor(value, key, path33) {
    let arr = value;
    if (utils_default2.isReactNative(formData) && utils_default2.isReactNativeBlob(value)) {
      formData.append(renderKey(path33, key, dots), convertValue(value));
      return false;
    }
    if (value && !path33 && typeof value === "object") {
      if (utils_default2.endsWith(key, "{}")) {
        key = metaTokens ? key : key.slice(0, -2);
        value = JSON.stringify(value);
      } else if (utils_default2.isArray(value) && isFlatArray(value) || (utils_default2.isFileList(value) || utils_default2.endsWith(key, "[]")) && (arr = utils_default2.toArray(value))) {
        key = removeBrackets(key);
        arr.forEach(function each(el, index) {
          !(utils_default2.isUndefined(el) || el === null) && formData.append(
            // eslint-disable-next-line no-nested-ternary
            indexes === true ? renderKey([key], index, dots) : indexes === null ? key : key + "[]",
            convertValue(el)
          );
        });
        return false;
      }
    }
    if (isVisitable(value)) {
      return true;
    }
    formData.append(renderKey(path33, key, dots), convertValue(value));
    return false;
  }
  const stack = [];
  const exposedHelpers = Object.assign(predicates, {
    defaultVisitor,
    convertValue,
    isVisitable
  });
  function build(value, path33) {
    if (utils_default2.isUndefined(value)) return;
    if (stack.indexOf(value) !== -1) {
      throw Error("Circular reference detected in " + path33.join("."));
    }
    stack.push(value);
    utils_default2.forEach(value, function each(el, key) {
      const result = !(utils_default2.isUndefined(el) || el === null) && visitor.call(formData, el, utils_default2.isString(key) ? key.trim() : key, path33, exposedHelpers);
      if (result === true) {
        build(el, path33 ? path33.concat(key) : [key]);
      }
    });
    stack.pop();
  }
  if (!utils_default2.isObject(obj)) {
    throw new TypeError("data must be an object");
  }
  build(obj);
  return formData;
}
var predicates, toFormData_default;
var init_toFormData = __esm({
  "node_modules/axios/lib/helpers/toFormData.js"() {
    "use strict";
    init_utils();
    init_AxiosError();
    init_FormData();
    predicates = utils_default2.toFlatObject(utils_default2, {}, null, function filter(prop) {
      return /^is[A-Z]/.test(prop);
    });
    toFormData_default = toFormData;
  }
});

// node_modules/axios/lib/helpers/AxiosURLSearchParams.js
function encode(str) {
  const charMap = {
    "!": "%21",
    "'": "%27",
    "(": "%28",
    ")": "%29",
    "~": "%7E",
    "%20": "+",
    "%00": "\0"
  };
  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
    return charMap[match];
  });
}
function AxiosURLSearchParams(params, options) {
  this._pairs = [];
  params && toFormData_default(params, this, options);
}
var prototype, AxiosURLSearchParams_default;
var init_AxiosURLSearchParams = __esm({
  "node_modules/axios/lib/helpers/AxiosURLSearchParams.js"() {
    "use strict";
    init_toFormData();
    prototype = AxiosURLSearchParams.prototype;
    prototype.append = function append(name28, value) {
      this._pairs.push([name28, value]);
    };
    prototype.toString = function toString3(encoder) {
      const _encode3 = encoder ? function(value) {
        return encoder.call(this, value, encode);
      } : encode;
      return this._pairs.map(function each(pair) {
        return _encode3(pair[0]) + "=" + _encode3(pair[1]);
      }, "").join("&");
    };
    AxiosURLSearchParams_default = AxiosURLSearchParams;
  }
});

// node_modules/axios/lib/helpers/buildURL.js
function encode2(val) {
  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+");
}
function buildURL(url4, params, options) {
  if (!params) {
    return url4;
  }
  const _encode3 = options && options.encode || encode2;
  const _options = utils_default2.isFunction(options) ? {
    serialize: options
  } : options;
  const serializeFn = _options && _options.serialize;
  let serializedParams;
  if (serializeFn) {
    serializedParams = serializeFn(params, _options);
  } else {
    serializedParams = utils_default2.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams_default(params, _options).toString(_encode3);
  }
  if (serializedParams) {
    const hashmarkIndex = url4.indexOf("#");
    if (hashmarkIndex !== -1) {
      url4 = url4.slice(0, hashmarkIndex);
    }
    url4 += (url4.indexOf("?") === -1 ? "?" : "&") + serializedParams;
  }
  return url4;
}
var init_buildURL = __esm({
  "node_modules/axios/lib/helpers/buildURL.js"() {
    "use strict";
    init_utils();
    init_AxiosURLSearchParams();
  }
});

// node_modules/axios/lib/core/InterceptorManager.js
var InterceptorManager, InterceptorManager_default;
var init_InterceptorManager = __esm({
  "node_modules/axios/lib/core/InterceptorManager.js"() {
    "use strict";
    init_utils();
    InterceptorManager = class {
      constructor() {
        this.handlers = [];
      }
      /**
       * Add a new interceptor to the stack
       *
       * @param {Function} fulfilled The function to handle `then` for a `Promise`
       * @param {Function} rejected The function to handle `reject` for a `Promise`
       * @param {Object} options The options for the interceptor, synchronous and runWhen
       *
       * @return {Number} An ID used to remove interceptor later
       */
      use(fulfilled, rejected, options) {
        this.handlers.push({
          fulfilled,
          rejected,
          synchronous: options ? options.synchronous : false,
          runWhen: options ? options.runWhen : null
        });
        return this.handlers.length - 1;
      }
      /**
       * Remove an interceptor from the stack
       *
       * @param {Number} id The ID that was returned by `use`
       *
       * @returns {void}
       */
      eject(id) {
        if (this.handlers[id]) {
          this.handlers[id] = null;
        }
      }
      /**
       * Clear all interceptors from the stack
       *
       * @returns {void}
       */
      clear() {
        if (this.handlers) {
          this.handlers = [];
        }
      }
      /**
       * Iterate over all the registered interceptors
       *
       * This method is particularly useful for skipping over any
       * interceptors that may have become `null` calling `eject`.
       *
       * @param {Function} fn The function to call for each interceptor
       *
       * @returns {void}
       */
      forEach(fn) {
        utils_default2.forEach(this.handlers, function forEachHandler(h) {
          if (h !== null) {
            fn(h);
          }
        });
      }
    };
    InterceptorManager_default = InterceptorManager;
  }
});

// node_modules/axios/lib/defaults/transitional.js
var transitional_default;
var init_transitional = __esm({
  "node_modules/axios/lib/defaults/transitional.js"() {
    "use strict";
    transitional_default = {
      silentJSONParsing: true,
      forcedJSONParsing: true,
      clarifyTimeoutError: false,
      legacyInterceptorReqResOrdering: true
    };
  }
});

// node_modules/axios/lib/platform/node/classes/URLSearchParams.js
var import_url2, URLSearchParams_default;
var init_URLSearchParams = __esm({
  "node_modules/axios/lib/platform/node/classes/URLSearchParams.js"() {
    "use strict";
    import_url2 = __toESM(require("url"), 1);
    URLSearchParams_default = import_url2.default.URLSearchParams;
  }
});

// node_modules/axios/lib/platform/node/index.js
var import_crypto4, ALPHA, DIGIT, ALPHABET, generateString, node_default;
var init_node = __esm({
  "node_modules/axios/lib/platform/node/index.js"() {
    "use strict";
    import_crypto4 = __toESM(require("crypto"), 1);
    init_URLSearchParams();
    init_FormData();
    ALPHA = "abcdefghijklmnopqrstuvwxyz";
    DIGIT = "0123456789";
    ALPHABET = {
      DIGIT,
      ALPHA,
      ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
    };
    generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
      let str = "";
      const { length } = alphabet;
      const randomValues = new Uint32Array(size);
      import_crypto4.default.randomFillSync(randomValues);
      for (let i = 0; i < size; i++) {
        str += alphabet[randomValues[i] % length];
      }
      return str;
    };
    node_default = {
      isNode: true,
      classes: {
        URLSearchParams: URLSearchParams_default,
        FormData: FormData_default,
        Blob: typeof Blob !== "undefined" && Blob || null
      },
      ALPHABET,
      generateString,
      protocols: ["http", "https", "file", "data"]
    };
  }
});

// node_modules/axios/lib/platform/common/utils.js
var utils_exports = {};
__export(utils_exports, {
  hasBrowserEnv: () => hasBrowserEnv,
  hasStandardBrowserEnv: () => hasStandardBrowserEnv,
  hasStandardBrowserWebWorkerEnv: () => hasStandardBrowserWebWorkerEnv,
  navigator: () => _navigator,
  origin: () => origin
});
var hasBrowserEnv, _navigator, hasStandardBrowserEnv, hasStandardBrowserWebWorkerEnv, origin;
var init_utils2 = __esm({
  "node_modules/axios/lib/platform/common/utils.js"() {
    "use strict";
    hasBrowserEnv = typeof window !== "undefined" && typeof document !== "undefined";
    _navigator = typeof navigator === "object" && navigator || void 0;
    hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || ["ReactNative", "NativeScript", "NS"].indexOf(_navigator.product) < 0);
    hasStandardBrowserWebWorkerEnv = (() => {
      return typeof WorkerGlobalScope !== "undefined" && // eslint-disable-next-line no-undef
      self instanceof WorkerGlobalScope && typeof self.importScripts === "function";
    })();
    origin = hasBrowserEnv && window.location.href || "http://localhost";
  }
});

// node_modules/axios/lib/platform/index.js
var platform_default;
var init_platform = __esm({
  "node_modules/axios/lib/platform/index.js"() {
    "use strict";
    init_node();
    init_utils2();
    platform_default = {
      ...utils_exports,
      ...node_default
    };
  }
});

// node_modules/axios/lib/helpers/toURLEncodedForm.js
function toURLEncodedForm(data, options) {
  return toFormData_default(data, new platform_default.classes.URLSearchParams(), {
    visitor: function(value, key, path33, helpers) {
      if (platform_default.isNode && utils_default2.isBuffer(value)) {
        this.append(key, value.toString("base64"));
        return false;
      }
      return helpers.defaultVisitor.apply(this, arguments);
    },
    ...options
  });
}
var init_toURLEncodedForm = __esm({
  "node_modules/axios/lib/helpers/toURLEncodedForm.js"() {
    "use strict";
    init_utils();
    init_toFormData();
    init_platform();
  }
});

// node_modules/axios/lib/helpers/formDataToJSON.js
function parsePropPath(name28) {
  return utils_default2.matchAll(/\w+|\[(\w*)]/g, name28).map((match) => {
    return match[0] === "[]" ? "" : match[1] || match[0];
  });
}
function arrayToObject(arr) {
  const obj = {};
  const keys2 = Object.keys(arr);
  let i;
  const len = keys2.length;
  let key;
  for (i = 0; i < len; i++) {
    key = keys2[i];
    obj[key] = arr[key];
  }
  return obj;
}
function formDataToJSON(formData) {
  function buildPath(path33, value, target, index) {
    let name28 = path33[index++];
    if (name28 === "__proto__") return true;
    const isNumericKey = Number.isFinite(+name28);
    const isLast = index >= path33.length;
    name28 = !name28 && utils_default2.isArray(target) ? target.length : name28;
    if (isLast) {
      if (utils_default2.hasOwnProp(target, name28)) {
        target[name28] = [target[name28], value];
      } else {
        target[name28] = value;
      }
      return !isNumericKey;
    }
    if (!target[name28] || !utils_default2.isObject(target[name28])) {
      target[name28] = [];
    }
    const result = buildPath(path33, value, target[name28], index);
    if (result && utils_default2.isArray(target[name28])) {
      target[name28] = arrayToObject(target[name28]);
    }
    return !isNumericKey;
  }
  if (utils_default2.isFormData(formData) && utils_default2.isFunction(formData.entries)) {
    const obj = {};
    utils_default2.forEachEntry(formData, (name28, value) => {
      buildPath(parsePropPath(name28), value, obj, 0);
    });
    return obj;
  }
  return null;
}
var formDataToJSON_default;
var init_formDataToJSON = __esm({
  "node_modules/axios/lib/helpers/formDataToJSON.js"() {
    "use strict";
    init_utils();
    formDataToJSON_default = formDataToJSON;
  }
});

// node_modules/axios/lib/defaults/index.js
function stringifySafely(rawValue, parser, encoder) {
  if (utils_default2.isString(rawValue)) {
    try {
      (parser || JSON.parse)(rawValue);
      return utils_default2.trim(rawValue);
    } catch (e) {
      if (e.name !== "SyntaxError") {
        throw e;
      }
    }
  }
  return (encoder || JSON.stringify)(rawValue);
}
var defaults, defaults_default;
var init_defaults = __esm({
  "node_modules/axios/lib/defaults/index.js"() {
    "use strict";
    init_utils();
    init_AxiosError();
    init_transitional();
    init_toFormData();
    init_toURLEncodedForm();
    init_platform();
    init_formDataToJSON();
    defaults = {
      transitional: transitional_default,
      adapter: ["xhr", "http", "fetch"],
      transformRequest: [
        function transformRequest(data, headers) {
          const contentType = headers.getContentType() || "";
          const hasJSONContentType = contentType.indexOf("application/json") > -1;
          const isObjectPayload = utils_default2.isObject(data);
          if (isObjectPayload && utils_default2.isHTMLForm(data)) {
            data = new FormData(data);
          }
          const isFormData2 = utils_default2.isFormData(data);
          if (isFormData2) {
            return hasJSONContentType ? JSON.stringify(formDataToJSON_default(data)) : data;
          }
          if (utils_default2.isArrayBuffer(data) || utils_default2.isBuffer(data) || utils_default2.isStream(data) || utils_default2.isFile(data) || utils_default2.isBlob(data) || utils_default2.isReadableStream(data)) {
            return data;
          }
          if (utils_default2.isArrayBufferView(data)) {
            return data.buffer;
          }
          if (utils_default2.isURLSearchParams(data)) {
            headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false);
            return data.toString();
          }
          let isFileList2;
          if (isObjectPayload) {
            if (contentType.indexOf("application/x-www-form-urlencoded") > -1) {
              return toURLEncodedForm(data, this.formSerializer).toString();
            }
            if ((isFileList2 = utils_default2.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
              const _FormData = this.env && this.env.FormData;
              return toFormData_default(
                isFileList2 ? { "files[]": data } : data,
                _FormData && new _FormData(),
                this.formSerializer
              );
            }
          }
          if (isObjectPayload || hasJSONContentType) {
            headers.setContentType("application/json", false);
            return stringifySafely(data);
          }
          return data;
        }
      ],
      transformResponse: [
        function transformResponse(data) {
          const transitional2 = this.transitional || defaults.transitional;
          const forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing;
          const JSONRequested = this.responseType === "json";
          if (utils_default2.isResponse(data) || utils_default2.isReadableStream(data)) {
            return data;
          }
          if (data && utils_default2.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
            const silentJSONParsing = transitional2 && transitional2.silentJSONParsing;
            const strictJSONParsing = !silentJSONParsing && JSONRequested;
            try {
              return JSON.parse(data, this.parseReviver);
            } catch (e) {
              if (strictJSONParsing) {
                if (e.name === "SyntaxError") {
                  throw AxiosError_default.from(e, AxiosError_default.ERR_BAD_RESPONSE, this, null, this.response);
                }
                throw e;
              }
            }
          }
          return data;
        }
      ],
      /**
       * A timeout in milliseconds to abort a request. If set to 0 (default) a
       * timeout is not created.
       */
      timeout: 0,
      xsrfCookieName: "XSRF-TOKEN",
      xsrfHeaderName: "X-XSRF-TOKEN",
      maxContentLength: -1,
      maxBodyLength: -1,
      env: {
        FormData: platform_default.classes.FormData,
        Blob: platform_default.classes.Blob
      },
      validateStatus: function validateStatus(status) {
        return status >= 200 && status < 300;
      },
      headers: {
        common: {
          Accept: "application/json, text/plain, */*",
          "Content-Type": void 0
        }
      }
    };
    utils_default2.forEach(["delete", "get", "head", "post", "put", "patch"], (method) => {
      defaults.headers[method] = {};
    });
    defaults_default = defaults;
  }
});

// node_modules/axios/lib/helpers/parseHeaders.js
var ignoreDuplicateOf, parseHeaders_default;
var init_parseHeaders = __esm({
  "node_modules/axios/lib/helpers/parseHeaders.js"() {
    "use strict";
    init_utils();
    ignoreDuplicateOf = utils_default2.toObjectSet([
      "age",
      "authorization",
      "content-length",
      "content-type",
      "etag",
      "expires",
      "from",
      "host",
      "if-modified-since",
      "if-unmodified-since",
      "last-modified",
      "location",
      "max-forwards",
      "proxy-authorization",
      "referer",
      "retry-after",
      "user-agent"
    ]);
    parseHeaders_default = (rawHeaders) => {
      const parsed = {};
      let key;
      let val;
      let i;
      rawHeaders && rawHeaders.split("\n").forEach(function parser(line) {
        i = line.indexOf(":");
        key = line.substring(0, i).trim().toLowerCase();
        val = line.substring(i + 1).trim();
        if (!key || parsed[key] && ignoreDuplicateOf[key]) {
          return;
        }
        if (key === "set-cookie") {
          if (parsed[key]) {
            parsed[key].push(val);
          } else {
            parsed[key] = [val];
          }
        } else {
          parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
        }
      });
      return parsed;
    };
  }
});

// node_modules/axios/lib/core/AxiosHeaders.js
function normalizeHeader(header) {
  return header && String(header).trim().toLowerCase();
}
function normalizeValue(value) {
  if (value === false || value == null) {
    return value;
  }
  return utils_default2.isArray(value) ? value.map(normalizeValue) : String(value).replace(/[\r\n]+$/, "");
}
function parseTokens(str) {
  const tokens = /* @__PURE__ */ Object.create(null);
  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
  let match;
  while (match = tokensRE.exec(str)) {
    tokens[match[1]] = match[2];
  }
  return tokens;
}
function matchHeaderValue(context2, value, header, filter6, isHeaderNameFilter) {
  if (utils_default2.isFunction(filter6)) {
    return filter6.call(this, value, header);
  }
  if (isHeaderNameFilter) {
    value = header;
  }
  if (!utils_default2.isString(value)) return;
  if (utils_default2.isString(filter6)) {
    return value.indexOf(filter6) !== -1;
  }
  if (utils_default2.isRegExp(filter6)) {
    return filter6.test(value);
  }
}
function formatHeader(header) {
  return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
    return char.toUpperCase() + str;
  });
}
function buildAccessors(obj, header) {
  const accessorName = utils_default2.toCamelCase(" " + header);
  ["get", "set", "has"].forEach((methodName) => {
    Object.defineProperty(obj, methodName + accessorName, {
      value: function(arg1, arg2, arg3) {
        return this[methodName].call(this, header, arg1, arg2, arg3);
      },
      configurable: true
    });
  });
}
var $internals, isValidHeaderName, AxiosHeaders, AxiosHeaders_default;
var init_AxiosHeaders = __esm({
  "node_modules/axios/lib/core/AxiosHeaders.js"() {
    "use strict";
    init_utils();
    init_parseHeaders();
    $internals = /* @__PURE__ */ Symbol("internals");
    isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
    AxiosHeaders = class {
      constructor(headers) {
        headers && this.set(headers);
      }
      set(header, valueOrRewrite, rewrite) {
        const self2 = this;
        function setHeader(_value, _header, _rewrite) {
          const lHeader = normalizeHeader(_header);
          if (!lHeader) {
            throw new Error("header name must be a non-empty string");
          }
          const key = utils_default2.findKey(self2, lHeader);
          if (!key || self2[key] === void 0 || _rewrite === true || _rewrite === void 0 && self2[key] !== false) {
            self2[key || _header] = normalizeValue(_value);
          }
        }
        const setHeaders = (headers, _rewrite) => utils_default2.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
        if (utils_default2.isPlainObject(header) || header instanceof this.constructor) {
          setHeaders(header, valueOrRewrite);
        } else if (utils_default2.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
          setHeaders(parseHeaders_default(header), valueOrRewrite);
        } else if (utils_default2.isObject(header) && utils_default2.isIterable(header)) {
          let obj = {}, dest, key;
          for (const entry of header) {
            if (!utils_default2.isArray(entry)) {
              throw TypeError("Object iterator must return a key-value pair");
            }
            obj[key = entry[0]] = (dest = obj[key]) ? utils_default2.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
          }
          setHeaders(obj, valueOrRewrite);
        } else {
          header != null && setHeader(valueOrRewrite, header, rewrite);
        }
        return this;
      }
      get(header, parser) {
        header = normalizeHeader(header);
        if (header) {
          const key = utils_default2.findKey(this, header);
          if (key) {
            const value = this[key];
            if (!parser) {
              return value;
            }
            if (parser === true) {
              return parseTokens(value);
            }
            if (utils_default2.isFunction(parser)) {
              return parser.call(this, value, key);
            }
            if (utils_default2.isRegExp(parser)) {
              return parser.exec(value);
            }
            throw new TypeError("parser must be boolean|regexp|function");
          }
        }
      }
      has(header, matcher) {
        header = normalizeHeader(header);
        if (header) {
          const key = utils_default2.findKey(this, header);
          return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
        }
        return false;
      }
      delete(header, matcher) {
        const self2 = this;
        let deleted = false;
        function deleteHeader(_header) {
          _header = normalizeHeader(_header);
          if (_header) {
            const key = utils_default2.findKey(self2, _header);
            if (key && (!matcher || matchHeaderValue(self2, self2[key], key, matcher))) {
              delete self2[key];
              deleted = true;
            }
          }
        }
        if (utils_default2.isArray(header)) {
          header.forEach(deleteHeader);
        } else {
          deleteHeader(header);
        }
        return deleted;
      }
      clear(matcher) {
        const keys2 = Object.keys(this);
        let i = keys2.length;
        let deleted = false;
        while (i--) {
          const key = keys2[i];
          if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
            delete this[key];
            deleted = true;
          }
        }
        return deleted;
      }
      normalize(format) {
        const self2 = this;
        const headers = {};
        utils_default2.forEach(this, (value, header) => {
          const key = utils_default2.findKey(headers, header);
          if (key) {
            self2[key] = normalizeValue(value);
            delete self2[header];
            return;
          }
          const normalized = format ? formatHeader(header) : String(header).trim();
          if (normalized !== header) {
            delete self2[header];
          }
          self2[normalized] = normalizeValue(value);
          headers[normalized] = true;
        });
        return this;
      }
      concat(...targets) {
        return this.constructor.concat(this, ...targets);
      }
      toJSON(asStrings) {
        const obj = /* @__PURE__ */ Object.create(null);
        utils_default2.forEach(this, (value, header) => {
          value != null && value !== false && (obj[header] = asStrings && utils_default2.isArray(value) ? value.join(", ") : value);
        });
        return obj;
      }
      [Symbol.iterator]() {
        return Object.entries(this.toJSON())[Symbol.iterator]();
      }
      toString() {
        return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
      }
      getSetCookie() {
        return this.get("set-cookie") || [];
      }
      get [Symbol.toStringTag]() {
        return "AxiosHeaders";
      }
      static from(thing) {
        return thing instanceof this ? thing : new this(thing);
      }
      static concat(first, ...targets) {
        const computed = new this(first);
        targets.forEach((target) => computed.set(target));
        return computed;
      }
      static accessor(header) {
        const internals = this[$internals] = this[$internals] = {
          accessors: {}
        };
        const accessors = internals.accessors;
        const prototype2 = this.prototype;
        function defineAccessor(_header) {
          const lHeader = normalizeHeader(_header);
          if (!accessors[lHeader]) {
            buildAccessors(prototype2, _header);
            accessors[lHeader] = true;
          }
        }
        utils_default2.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
        return this;
      }
    };
    AxiosHeaders.accessor([
      "Content-Type",
      "Content-Length",
      "Accept",
      "Accept-Encoding",
      "User-Agent",
      "Authorization"
    ]);
    utils_default2.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
      let mapped = key[0].toUpperCase() + key.slice(1);
      return {
        get: () => value,
        set(headerValue) {
          this[mapped] = headerValue;
        }
      };
    });
    utils_default2.freezeMethods(AxiosHeaders);
    AxiosHeaders_default = AxiosHeaders;
  }
});

// node_modules/axios/lib/core/transformData.js
function transformData(fns, response) {
  const config3 = this || defaults_default;
  const context2 = response || config3;
  const headers = AxiosHeaders_default.from(context2.headers);
  let data = context2.data;
  utils_default2.forEach(fns, function transform8(fn) {
    data = fn.call(config3, data, headers.normalize(), response ? response.status : void 0);
  });
  headers.normalize();
  return data;
}
var init_transformData = __esm({
  "node_modules/axios/lib/core/transformData.js"() {
    "use strict";
    init_utils();
    init_defaults();
    init_AxiosHeaders();
  }
});

// node_modules/axios/lib/cancel/isCancel.js
function isCancel(value) {
  return !!(value && value.__CANCEL__);
}
var init_isCancel = __esm({
  "node_modules/axios/lib/cancel/isCancel.js"() {
    "use strict";
  }
});

// node_modules/axios/lib/cancel/CanceledError.js
var CanceledError, CanceledError_default;
var init_CanceledError = __esm({
  "node_modules/axios/lib/cancel/CanceledError.js"() {
    "use strict";
    init_AxiosError();
    CanceledError = class extends AxiosError_default {
      /**
       * A `CanceledError` is an object that is thrown when an operation is canceled.
       *
       * @param {string=} message The message.
       * @param {Object=} config The config.
       * @param {Object=} request The request.
       *
       * @returns {CanceledError} The created error.
       */
      constructor(message, config3, request) {
        super(message == null ? "canceled" : message, AxiosError_default.ERR_CANCELED, config3, request);
        this.name = "CanceledError";
        this.__CANCEL__ = true;
      }
    };
    CanceledError_default = CanceledError;
  }
});

// node_modules/axios/lib/core/settle.js
function settle(resolve3, reject, response) {
  const validateStatus2 = response.config.validateStatus;
  if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
    resolve3(response);
  } else {
    reject(
      new AxiosError_default(
        "Request failed with status code " + response.status,
        [AxiosError_default.ERR_BAD_REQUEST, AxiosError_default.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
        response.config,
        response.request,
        response
      )
    );
  }
}
var init_settle = __esm({
  "node_modules/axios/lib/core/settle.js"() {
    "use strict";
    init_AxiosError();
  }
});

// node_modules/axios/lib/helpers/isAbsoluteURL.js
function isAbsoluteURL(url4) {
  if (typeof url4 !== "string") {
    return false;
  }
  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url4);
}
var init_isAbsoluteURL = __esm({
  "node_modules/axios/lib/helpers/isAbsoluteURL.js"() {
    "use strict";
  }
});

// node_modules/axios/lib/helpers/combineURLs.js
function combineURLs(baseURL, relativeURL) {
  return relativeURL ? baseURL.replace(/\/?\/$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
}
var init_combineURLs = __esm({
  "node_modules/axios/lib/helpers/combineURLs.js"() {
    "use strict";
  }
});

// node_modules/axios/lib/core/buildFullPath.js
function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
  let isRelativeUrl = !isAbsoluteURL(requestedURL);
  if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
    return combineURLs(baseURL, requestedURL);
  }
  return requestedURL;
}
var init_buildFullPath = __esm({
  "node_modules/axios/lib/core/buildFullPath.js"() {
    "use strict";
    init_isAbsoluteURL();
    init_combineURLs();
  }
});

// node_modules/proxy-from-env/index.js
function parseUrl(urlString) {
  try {
    return new URL(urlString);
  } catch {
    return null;
  }
}
function getProxyForUrl(url4) {
  var parsedUrl = (typeof url4 === "string" ? parseUrl(url4) : url4) || {};
  var proto = parsedUrl.protocol;
  var hostname4 = parsedUrl.host;
  var port = parsedUrl.port;
  if (typeof hostname4 !== "string" || !hostname4 || typeof proto !== "string") {
    return "";
  }
  proto = proto.split(":", 1)[0];
  hostname4 = hostname4.replace(/:\d*$/, "");
  port = parseInt(port) || DEFAULT_PORTS[proto] || 0;
  if (!shouldProxy(hostname4, port)) {
    return "";
  }
  var proxy = getEnv(proto + "_proxy") || getEnv("all_proxy");
  if (proxy && proxy.indexOf("://") === -1) {
    proxy = proto + "://" + proxy;
  }
  return proxy;
}
function shouldProxy(hostname4, port) {
  var NO_PROXY = getEnv("no_proxy").toLowerCase();
  if (!NO_PROXY) {
    return true;
  }
  if (NO_PROXY === "*") {
    return false;
  }
  return NO_PROXY.split(/[,\s]/).every(function(proxy) {
    if (!proxy) {
      return true;
    }
    var parsedProxy = proxy.match(/^(.+):(\d+)$/);
    var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
    var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
    if (parsedProxyPort && parsedProxyPort !== port) {
      return true;
    }
    if (!/^[.*]/.test(parsedProxyHostname)) {
      return hostname4 !== parsedProxyHostname;
    }
    if (parsedProxyHostname.charAt(0) === "*") {
      parsedProxyHostname = parsedProxyHostname.slice(1);
    }
    return !hostname4.endsWith(parsedProxyHostname);
  });
}
function getEnv(key) {
  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || "";
}
var DEFAULT_PORTS;
var init_proxy_from_env = __esm({
  "node_modules/proxy-from-env/index.js"() {
    "use strict";
    DEFAULT_PORTS = {
      ftp: 21,
      gopher: 70,
      http: 80,
      https: 443,
      ws: 80,
      wss: 443
    };
  }
});

// node_modules/follow-redirects/debug.js
var require_debug2 = __commonJS({
  "node_modules/follow-redirects/debug.js"(exports2, module2) {
    "use strict";
    var debug;
    module2.exports = function() {
      if (!debug) {
        try {
          debug = require_src()("follow-redirects");
        } catch (error73) {
        }
        if (typeof debug !== "function") {
          debug = function() {
          };
        }
      }
      debug.apply(null, arguments);
    };
  }
});

// node_modules/follow-redirects/index.js
var require_follow_redirects = __commonJS({
  "node_modules/follow-redirects/index.js"(exports2, module2) {
    "use strict";
    var url4 = require("url");
    var URL2 = url4.URL;
    var http4 = require("http");
    var https2 = require("https");
    var Writable = require("stream").Writable;
    var assert3 = require("assert");
    var debug = require_debug2();
    (function detectUnsupportedEnvironment() {
      var looksLikeNode = typeof process !== "undefined";
      var looksLikeBrowser = typeof window !== "undefined" && typeof document !== "undefined";
      var looksLikeV8 = isFunction4(Error.captureStackTrace);
      if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) {
        console.warn("The follow-redirects package should be excluded from browser builds.");
      }
    })();
    var useNativeURL = false;
    try {
      assert3(new URL2(""));
    } catch (error73) {
      useNativeURL = error73.code === "ERR_INVALID_URL";
    }
    var preservedUrlFields = [
      "auth",
      "host",
      "hostname",
      "href",
      "path",
      "pathname",
      "port",
      "protocol",
      "query",
      "search",
      "hash"
    ];
    var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
    var eventHandlers = /* @__PURE__ */ Object.create(null);
    events.forEach(function(event) {
      eventHandlers[event] = function(arg1, arg2, arg3) {
        this._redirectable.emit(event, arg1, arg2, arg3);
      };
    });
    var InvalidUrlError = createErrorType(
      "ERR_INVALID_URL",
      "Invalid URL",
      TypeError
    );
    var RedirectionError = createErrorType(
      "ERR_FR_REDIRECTION_FAILURE",
      "Redirected request failed"
    );
    var TooManyRedirectsError = createErrorType(
      "ERR_FR_TOO_MANY_REDIRECTS",
      "Maximum number of redirects exceeded",
      RedirectionError
    );
    var MaxBodyLengthExceededError = createErrorType(
      "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
      "Request body larger than maxBodyLength limit"
    );
    var WriteAfterEndError = createErrorType(
      "ERR_STREAM_WRITE_AFTER_END",
      "write after end"
    );
    var destroy = Writable.prototype.destroy || noop4;
    function RedirectableRequest(options, responseCallback) {
      Writable.call(this);
      this._sanitizeOptions(options);
      this._options = options;
      this._ended = false;
      this._ending = false;
      this._redirectCount = 0;
      this._redirects = [];
      this._requestBodyLength = 0;
      this._requestBodyBuffers = [];
      if (responseCallback) {
        this.on("response", responseCallback);
      }
      var self2 = this;
      this._onNativeResponse = function(response) {
        try {
          self2._processResponse(response);
        } catch (cause) {
          self2.emit("error", cause instanceof RedirectionError ? cause : new RedirectionError({ cause }));
        }
      };
      this._performRequest();
    }
    RedirectableRequest.prototype = Object.create(Writable.prototype);
    RedirectableRequest.prototype.abort = function() {
      destroyRequest(this._currentRequest);
      this._currentRequest.abort();
      this.emit("abort");
    };
    RedirectableRequest.prototype.destroy = function(error73) {
      destroyRequest(this._currentRequest, error73);
      destroy.call(this, error73);
      return this;
    };
    RedirectableRequest.prototype.write = function(data, encoding, callback) {
      if (this._ending) {
        throw new WriteAfterEndError();
      }
      if (!isString2(data) && !isBuffer3(data)) {
        throw new TypeError("data should be a string, Buffer or Uint8Array");
      }
      if (isFunction4(encoding)) {
        callback = encoding;
        encoding = null;
      }
      if (data.length === 0) {
        if (callback) {
          callback();
        }
        return;
      }
      if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
        this._requestBodyLength += data.length;
        this._requestBodyBuffers.push({ data, encoding });
        this._currentRequest.write(data, encoding, callback);
      } else {
        this.emit("error", new MaxBodyLengthExceededError());
        this.abort();
      }
    };
    RedirectableRequest.prototype.end = function(data, encoding, callback) {
      if (isFunction4(data)) {
        callback = data;
        data = encoding = null;
      } else if (isFunction4(encoding)) {
        callback = encoding;
        encoding = null;
      }
      if (!data) {
        this._ended = this._ending = true;
        this._currentRequest.end(null, null, callback);
      } else {
        var self2 = this;
        var currentRequest = this._currentRequest;
        this.write(data, encoding, function() {
          self2._ended = true;
          currentRequest.end(null, null, callback);
        });
        this._ending = true;
      }
    };
    RedirectableRequest.prototype.setHeader = function(name28, value) {
      this._options.headers[name28] = value;
      this._currentRequest.setHeader(name28, value);
    };
    RedirectableRequest.prototype.removeHeader = function(name28) {
      delete this._options.headers[name28];
      this._currentRequest.removeHeader(name28);
    };
    RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
      var self2 = this;
      function destroyOnTimeout(socket) {
        socket.setTimeout(msecs);
        socket.removeListener("timeout", socket.destroy);
        socket.addListener("timeout", socket.destroy);
      }
      function startTimer(socket) {
        if (self2._timeout) {
          clearTimeout(self2._timeout);
        }
        self2._timeout = setTimeout(function() {
          self2.emit("timeout");
          clearTimer();
        }, msecs);
        destroyOnTimeout(socket);
      }
      function clearTimer() {
        if (self2._timeout) {
          clearTimeout(self2._timeout);
          self2._timeout = null;
        }
        self2.removeListener("abort", clearTimer);
        self2.removeListener("error", clearTimer);
        self2.removeListener("response", clearTimer);
        self2.removeListener("close", clearTimer);
        if (callback) {
          self2.removeListener("timeout", callback);
        }
        if (!self2.socket) {
          self2._currentRequest.removeListener("socket", startTimer);
        }
      }
      if (callback) {
        this.on("timeout", callback);
      }
      if (this.socket) {
        startTimer(this.socket);
      } else {
        this._currentRequest.once("socket", startTimer);
      }
      this.on("socket", destroyOnTimeout);
      this.on("abort", clearTimer);
      this.on("error", clearTimer);
      this.on("response", clearTimer);
      this.on("close", clearTimer);
      return this;
    };
    [
      "flushHeaders",
      "getHeader",
      "setNoDelay",
      "setSocketKeepAlive"
    ].forEach(function(method) {
      RedirectableRequest.prototype[method] = function(a, b) {
        return this._currentRequest[method](a, b);
      };
    });
    ["aborted", "connection", "socket"].forEach(function(property2) {
      Object.defineProperty(RedirectableRequest.prototype, property2, {
        get: function() {
          return this._currentRequest[property2];
        }
      });
    });
    RedirectableRequest.prototype._sanitizeOptions = function(options) {
      if (!options.headers) {
        options.headers = {};
      }
      if (options.host) {
        if (!options.hostname) {
          options.hostname = options.host;
        }
        delete options.host;
      }
      if (!options.pathname && options.path) {
        var searchPos = options.path.indexOf("?");
        if (searchPos < 0) {
          options.pathname = options.path;
        } else {
          options.pathname = options.path.substring(0, searchPos);
          options.search = options.path.substring(searchPos);
        }
      }
    };
    RedirectableRequest.prototype._performRequest = function() {
      var protocol = this._options.protocol;
      var nativeProtocol = this._options.nativeProtocols[protocol];
      if (!nativeProtocol) {
        throw new TypeError("Unsupported protocol " + protocol);
      }
      if (this._options.agents) {
        var scheme = protocol.slice(0, -1);
        this._options.agent = this._options.agents[scheme];
      }
      var request = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
      request._redirectable = this;
      for (var event of events) {
        request.on(event, eventHandlers[event]);
      }
      this._currentUrl = /^\//.test(this._options.path) ? url4.format(this._options) : (
        // When making a request to a proxy, […]
        // a client MUST send the target URI in absolute-form […].
        this._options.path
      );
      if (this._isRedirect) {
        var i = 0;
        var self2 = this;
        var buffers = this._requestBodyBuffers;
        (function writeNext(error73) {
          if (request === self2._currentRequest) {
            if (error73) {
              self2.emit("error", error73);
            } else if (i < buffers.length) {
              var buffer = buffers[i++];
              if (!request.finished) {
                request.write(buffer.data, buffer.encoding, writeNext);
              }
            } else if (self2._ended) {
              request.end();
            }
          }
        })();
      }
    };
    RedirectableRequest.prototype._processResponse = function(response) {
      var statusCode = response.statusCode;
      if (this._options.trackRedirects) {
        this._redirects.push({
          url: this._currentUrl,
          headers: response.headers,
          statusCode
        });
      }
      var location = response.headers.location;
      if (!location || this._options.followRedirects === false || statusCode < 300 || statusCode >= 400) {
        response.responseUrl = this._currentUrl;
        response.redirects = this._redirects;
        this.emit("response", response);
        this._requestBodyBuffers = [];
        return;
      }
      destroyRequest(this._currentRequest);
      response.destroy();
      if (++this._redirectCount > this._options.maxRedirects) {
        throw new TooManyRedirectsError();
      }
      var requestHeaders;
      var beforeRedirect = this._options.beforeRedirect;
      if (beforeRedirect) {
        requestHeaders = Object.assign({
          // The Host header was set by nativeProtocol.request
          Host: response.req.getHeader("host")
        }, this._options.headers);
      }
      var method = this._options.method;
      if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" || // RFC7231§6.4.4: The 303 (See Other) status code indicates that
      // the server is redirecting the user agent to a different resource […]
      // A user agent can perform a retrieval request targeting that URI
      // (a GET or HEAD request if using HTTP) […]
      statusCode === 303 && !/^(?:GET|HEAD)$/.test(this._options.method)) {
        this._options.method = "GET";
        this._requestBodyBuffers = [];
        removeMatchingHeaders(/^content-/i, this._options.headers);
      }
      var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
      var currentUrlParts = parseUrl2(this._currentUrl);
      var currentHost = currentHostHeader || currentUrlParts.host;
      var currentUrl = /^\w+:/.test(location) ? this._currentUrl : url4.format(Object.assign(currentUrlParts, { host: currentHost }));
      var redirectUrl = resolveUrl(location, currentUrl);
      debug("redirecting to", redirectUrl.href);
      this._isRedirect = true;
      spreadUrlObject(redirectUrl, this._options);
      if (redirectUrl.protocol !== currentUrlParts.protocol && redirectUrl.protocol !== "https:" || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) {
        removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
      }
      if (isFunction4(beforeRedirect)) {
        var responseDetails = {
          headers: response.headers,
          statusCode
        };
        var requestDetails = {
          url: currentUrl,
          method,
          headers: requestHeaders
        };
        beforeRedirect(this._options, responseDetails, requestDetails);
        this._sanitizeOptions(this._options);
      }
      this._performRequest();
    };
    function wrap(protocols) {
      var exports3 = {
        maxRedirects: 21,
        maxBodyLength: 10 * 1024 * 1024
      };
      var nativeProtocols = {};
      Object.keys(protocols).forEach(function(scheme) {
        var protocol = scheme + ":";
        var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
        var wrappedProtocol = exports3[scheme] = Object.create(nativeProtocol);
        function request(input, options, callback) {
          if (isURL(input)) {
            input = spreadUrlObject(input);
          } else if (isString2(input)) {
            input = spreadUrlObject(parseUrl2(input));
          } else {
            callback = options;
            options = validateUrl(input);
            input = { protocol };
          }
          if (isFunction4(options)) {
            callback = options;
            options = null;
          }
          options = Object.assign({
            maxRedirects: exports3.maxRedirects,
            maxBodyLength: exports3.maxBodyLength
          }, input, options);
          options.nativeProtocols = nativeProtocols;
          if (!isString2(options.host) && !isString2(options.hostname)) {
            options.hostname = "::1";
          }
          assert3.equal(options.protocol, protocol, "protocol mismatch");
          debug("options", options);
          return new RedirectableRequest(options, callback);
        }
        function get2(input, options, callback) {
          var wrappedRequest = wrappedProtocol.request(input, options, callback);
          wrappedRequest.end();
          return wrappedRequest;
        }
        Object.defineProperties(wrappedProtocol, {
          request: { value: request, configurable: true, enumerable: true, writable: true },
          get: { value: get2, configurable: true, enumerable: true, writable: true }
        });
      });
      return exports3;
    }
    function noop4() {
    }
    function parseUrl2(input) {
      var parsed;
      if (useNativeURL) {
        parsed = new URL2(input);
      } else {
        parsed = validateUrl(url4.parse(input));
        if (!isString2(parsed.protocol)) {
          throw new InvalidUrlError({ input });
        }
      }
      return parsed;
    }
    function resolveUrl(relative, base) {
      return useNativeURL ? new URL2(relative, base) : parseUrl2(url4.resolve(base, relative));
    }
    function validateUrl(input) {
      if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
        throw new InvalidUrlError({ input: input.href || input });
      }
      if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
        throw new InvalidUrlError({ input: input.href || input });
      }
      return input;
    }
    function spreadUrlObject(urlObject, target) {
      var spread3 = target || {};
      for (var key of preservedUrlFields) {
        spread3[key] = urlObject[key];
      }
      if (spread3.hostname.startsWith("[")) {
        spread3.hostname = spread3.hostname.slice(1, -1);
      }
      if (spread3.port !== "") {
        spread3.port = Number(spread3.port);
      }
      spread3.path = spread3.search ? spread3.pathname + spread3.search : spread3.pathname;
      return spread3;
    }
    function removeMatchingHeaders(regex, headers) {
      var lastValue;
      for (var header in headers) {
        if (regex.test(header)) {
          lastValue = headers[header];
          delete headers[header];
        }
      }
      return lastValue === null || typeof lastValue === "undefined" ? void 0 : String(lastValue).trim();
    }
    function createErrorType(code, message, baseClass) {
      function CustomError(properties) {
        if (isFunction4(Error.captureStackTrace)) {
          Error.captureStackTrace(this, this.constructor);
        }
        Object.assign(this, properties || {});
        this.code = code;
        this.message = this.cause ? message + ": " + this.cause.message : message;
      }
      CustomError.prototype = new (baseClass || Error)();
      Object.defineProperties(CustomError.prototype, {
        constructor: {
          value: CustomError,
          enumerable: false
        },
        name: {
          value: "Error [" + code + "]",
          enumerable: false
        }
      });
      return CustomError;
    }
    function destroyRequest(request, error73) {
      for (var event of events) {
        request.removeListener(event, eventHandlers[event]);
      }
      request.on("error", noop4);
      request.destroy(error73);
    }
    function isSubdomain(subdomain, domain3) {
      assert3(isString2(subdomain) && isString2(domain3));
      var dot = subdomain.length - domain3.length - 1;
      return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain3);
    }
    function isString2(value) {
      return typeof value === "string" || value instanceof String;
    }
    function isFunction4(value) {
      return typeof value === "function";
    }
    function isBuffer3(value) {
      return typeof value === "object" && "length" in value;
    }
    function isURL(value) {
      return URL2 && value instanceof URL2;
    }
    module2.exports = wrap({ http: http4, https: https2 });
    module2.exports.wrap = wrap;
  }
});

// node_modules/axios/lib/env/data.js
var VERSION;
var init_data = __esm({
  "node_modules/axios/lib/env/data.js"() {
    "use strict";
    VERSION = "1.14.0";
  }
});

// node_modules/axios/lib/helpers/parseProtocol.js
function parseProtocol(url4) {
  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url4);
  return match && match[1] || "";
}
var init_parseProtocol = __esm({
  "node_modules/axios/lib/helpers/parseProtocol.js"() {
    "use strict";
  }
});

// node_modules/axios/lib/helpers/fromDataURI.js
function fromDataURI(uri, asBlob, options) {
  const _Blob = options && options.Blob || platform_default.classes.Blob;
  const protocol = parseProtocol(uri);
  if (asBlob === void 0 && _Blob) {
    asBlob = true;
  }
  if (protocol === "data") {
    uri = protocol.length ? uri.slice(protocol.length + 1) : uri;
    const match = DATA_URL_PATTERN.exec(uri);
    if (!match) {
      throw new AxiosError_default("Invalid URL", AxiosError_default.ERR_INVALID_URL);
    }
    const mime = match[1];
    const isBase64 = match[2];
    const body = match[3];
    const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? "base64" : "utf8");
    if (asBlob) {
      if (!_Blob) {
        throw new AxiosError_default("Blob is not supported", AxiosError_default.ERR_NOT_SUPPORT);
      }
      return new _Blob([buffer], { type: mime });
    }
    return buffer;
  }
  throw new AxiosError_default("Unsupported protocol " + protocol, AxiosError_default.ERR_NOT_SUPPORT);
}
var DATA_URL_PATTERN;
var init_fromDataURI = __esm({
  "node_modules/axios/lib/helpers/fromDataURI.js"() {
    "use strict";
    init_AxiosError();
    init_parseProtocol();
    init_platform();
    DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
  }
});

// node_modules/axios/lib/helpers/AxiosTransformStream.js
var import_stream, kInternals, AxiosTransformStream, AxiosTransformStream_default;
var init_AxiosTransformStream = __esm({
  "node_modules/axios/lib/helpers/AxiosTransformStream.js"() {
    "use strict";
    import_stream = __toESM(require("stream"), 1);
    init_utils();
    kInternals = /* @__PURE__ */ Symbol("internals");
    AxiosTransformStream = class extends import_stream.default.Transform {
      constructor(options) {
        options = utils_default2.toFlatObject(
          options,
          {
            maxRate: 0,
            chunkSize: 64 * 1024,
            minChunkSize: 100,
            timeWindow: 500,
            ticksRate: 2,
            samplesCount: 15
          },
          null,
          (prop, source) => {
            return !utils_default2.isUndefined(source[prop]);
          }
        );
        super({
          readableHighWaterMark: options.chunkSize
        });
        const internals = this[kInternals] = {
          timeWindow: options.timeWindow,
          chunkSize: options.chunkSize,
          maxRate: options.maxRate,
          minChunkSize: options.minChunkSize,
          bytesSeen: 0,
          isCaptured: false,
          notifiedBytesLoaded: 0,
          ts: Date.now(),
          bytes: 0,
          onReadCallback: null
        };
        this.on("newListener", (event) => {
          if (event === "progress") {
            if (!internals.isCaptured) {
              internals.isCaptured = true;
            }
          }
        });
      }
      _read(size) {
        const internals = this[kInternals];
        if (internals.onReadCallback) {
          internals.onReadCallback();
        }
        return super._read(size);
      }
      _transform(chunk, encoding, callback) {
        const internals = this[kInternals];
        const maxRate = internals.maxRate;
        const readableHighWaterMark = this.readableHighWaterMark;
        const timeWindow = internals.timeWindow;
        const divider = 1e3 / timeWindow;
        const bytesThreshold = maxRate / divider;
        const minChunkSize = internals.minChunkSize !== false ? Math.max(internals.minChunkSize, bytesThreshold * 0.01) : 0;
        const pushChunk = (_chunk, _callback) => {
          const bytes = Buffer.byteLength(_chunk);
          internals.bytesSeen += bytes;
          internals.bytes += bytes;
          internals.isCaptured && this.emit("progress", internals.bytesSeen);
          if (this.push(_chunk)) {
            process.nextTick(_callback);
          } else {
            internals.onReadCallback = () => {
              internals.onReadCallback = null;
              process.nextTick(_callback);
            };
          }
        };
        const transformChunk = (_chunk, _callback) => {
          const chunkSize = Buffer.byteLength(_chunk);
          let chunkRemainder = null;
          let maxChunkSize = readableHighWaterMark;
          let bytesLeft;
          let passed = 0;
          if (maxRate) {
            const now2 = Date.now();
            if (!internals.ts || (passed = now2 - internals.ts) >= timeWindow) {
              internals.ts = now2;
              bytesLeft = bytesThreshold - internals.bytes;
              internals.bytes = bytesLeft < 0 ? -bytesLeft : 0;
              passed = 0;
            }
            bytesLeft = bytesThreshold - internals.bytes;
          }
          if (maxRate) {
            if (bytesLeft <= 0) {
              return setTimeout(() => {
                _callback(null, _chunk);
              }, timeWindow - passed);
            }
            if (bytesLeft < maxChunkSize) {
              maxChunkSize = bytesLeft;
            }
          }
          if (maxChunkSize && chunkSize > maxChunkSize && chunkSize - maxChunkSize > minChunkSize) {
            chunkRemainder = _chunk.subarray(maxChunkSize);
            _chunk = _chunk.subarray(0, maxChunkSize);
          }
          pushChunk(
            _chunk,
            chunkRemainder ? () => {
              process.nextTick(_callback, null, chunkRemainder);
            } : _callback
          );
        };
        transformChunk(chunk, function transformNextChunk(err, _chunk) {
          if (err) {
            return callback(err);
          }
          if (_chunk) {
            transformChunk(_chunk, transformNextChunk);
          } else {
            callback(null);
          }
        });
      }
    };
    AxiosTransformStream_default = AxiosTransformStream;
  }
});

// node_modules/axios/lib/helpers/readBlob.js
var asyncIterator, readBlob, readBlob_default;
var init_readBlob = __esm({
  "node_modules/axios/lib/helpers/readBlob.js"() {
    "use strict";
    ({ asyncIterator } = Symbol);
    readBlob = async function* (blob) {
      if (blob.stream) {
        yield* blob.stream();
      } else if (blob.arrayBuffer) {
        yield await blob.arrayBuffer();
      } else if (blob[asyncIterator]) {
        yield* blob[asyncIterator]();
      } else {
        yield blob;
      }
    };
    readBlob_default = readBlob;
  }
});

// node_modules/axios/lib/helpers/formDataToStream.js
var import_util2, import_stream2, BOUNDARY_ALPHABET, textEncoder, CRLF, CRLF_BYTES, CRLF_BYTES_COUNT, FormDataPart, formDataToStream, formDataToStream_default;
var init_formDataToStream = __esm({
  "node_modules/axios/lib/helpers/formDataToStream.js"() {
    "use strict";
    import_util2 = __toESM(require("util"), 1);
    import_stream2 = require("stream");
    init_utils();
    init_readBlob();
    init_platform();
    BOUNDARY_ALPHABET = platform_default.ALPHABET.ALPHA_DIGIT + "-_";
    textEncoder = typeof TextEncoder === "function" ? new TextEncoder() : new import_util2.default.TextEncoder();
    CRLF = "\r\n";
    CRLF_BYTES = textEncoder.encode(CRLF);
    CRLF_BYTES_COUNT = 2;
    FormDataPart = class {
      constructor(name28, value) {
        const { escapeName } = this.constructor;
        const isStringValue = utils_default2.isString(value);
        let headers = `Content-Disposition: form-data; name="${escapeName(name28)}"${!isStringValue && value.name ? `; filename="${escapeName(value.name)}"` : ""}${CRLF}`;
        if (isStringValue) {
          value = textEncoder.encode(String(value).replace(/\r?\n|\r\n?/g, CRLF));
        } else {
          headers += `Content-Type: ${value.type || "application/octet-stream"}${CRLF}`;
        }
        this.headers = textEncoder.encode(headers + CRLF);
        this.contentLength = isStringValue ? value.byteLength : value.size;
        this.size = this.headers.byteLength + this.contentLength + CRLF_BYTES_COUNT;
        this.name = name28;
        this.value = value;
      }
      async *encode() {
        yield this.headers;
        const { value } = this;
        if (utils_default2.isTypedArray(value)) {
          yield value;
        } else {
          yield* readBlob_default(value);
        }
        yield CRLF_BYTES;
      }
      static escapeName(name28) {
        return String(name28).replace(
          /[\r\n"]/g,
          (match) => ({
            "\r": "%0D",
            "\n": "%0A",
            '"': "%22"
          })[match]
        );
      }
    };
    formDataToStream = (form, headersHandler, options) => {
      const {
        tag = "form-data-boundary",
        size = 25,
        boundary = tag + "-" + platform_default.generateString(size, BOUNDARY_ALPHABET)
      } = options || {};
      if (!utils_default2.isFormData(form)) {
        throw TypeError("FormData instance required");
      }
      if (boundary.length < 1 || boundary.length > 70) {
        throw Error("boundary must be 10-70 characters long");
      }
      const boundaryBytes = textEncoder.encode("--" + boundary + CRLF);
      const footerBytes = textEncoder.encode("--" + boundary + "--" + CRLF);
      let contentLength = footerBytes.byteLength;
      const parts = Array.from(form.entries()).map(([name28, value]) => {
        const part = new FormDataPart(name28, value);
        contentLength += part.size;
        return part;
      });
      contentLength += boundaryBytes.byteLength * parts.length;
      contentLength = utils_default2.toFiniteNumber(contentLength);
      const computedHeaders = {
        "Content-Type": `multipart/form-data; boundary=${boundary}`
      };
      if (Number.isFinite(contentLength)) {
        computedHeaders["Content-Length"] = contentLength;
      }
      headersHandler && headersHandler(computedHeaders);
      return import_stream2.Readable.from(
        (async function* () {
          for (const part of parts) {
            yield boundaryBytes;
            yield* part.encode();
          }
          yield footerBytes;
        })()
      );
    };
    formDataToStream_default = formDataToStream;
  }
});

// node_modules/axios/lib/helpers/ZlibHeaderTransformStream.js
var import_stream3, ZlibHeaderTransformStream, ZlibHeaderTransformStream_default;
var init_ZlibHeaderTransformStream = __esm({
  "node_modules/axios/lib/helpers/ZlibHeaderTransformStream.js"() {
    "use strict";
    import_stream3 = __toESM(require("stream"), 1);
    ZlibHeaderTransformStream = class extends import_stream3.default.Transform {
      __transform(chunk, encoding, callback) {
        this.push(chunk);
        callback();
      }
      _transform(chunk, encoding, callback) {
        if (chunk.length !== 0) {
          this._transform = this.__transform;
          if (chunk[0] !== 120) {
            const header = Buffer.alloc(2);
            header[0] = 120;
            header[1] = 156;
            this.push(header, encoding);
          }
        }
        this.__transform(chunk, encoding, callback);
      }
    };
    ZlibHeaderTransformStream_default = ZlibHeaderTransformStream;
  }
});

// node_modules/axios/lib/helpers/callbackify.js
var callbackify, callbackify_default;
var init_callbackify = __esm({
  "node_modules/axios/lib/helpers/callbackify.js"() {
    "use strict";
    init_utils();
    callbackify = (fn, reducer) => {
      return utils_default2.isAsyncFn(fn) ? function(...args) {
        const cb = args.pop();
        fn.apply(this, args).then((value) => {
          try {
            reducer ? cb(null, ...reducer(value)) : cb(null, value);
          } catch (err) {
            cb(err);
          }
        }, cb);
      } : fn;
    };
    callbackify_default = callbackify;
  }
});

// node_modules/axios/lib/helpers/speedometer.js
function speedometer(samplesCount, min) {
  samplesCount = samplesCount || 10;
  const bytes = new Array(samplesCount);
  const timestamps = new Array(samplesCount);
  let head = 0;
  let tail = 0;
  let firstSampleTS;
  min = min !== void 0 ? min : 1e3;
  return function push(chunkLength) {
    const now2 = Date.now();
    const startedAt = timestamps[tail];
    if (!firstSampleTS) {
      firstSampleTS = now2;
    }
    bytes[head] = chunkLength;
    timestamps[head] = now2;
    let i = tail;
    let bytesCount = 0;
    while (i !== head) {
      bytesCount += bytes[i++];
      i = i % samplesCount;
    }
    head = (head + 1) % samplesCount;
    if (head === tail) {
      tail = (tail + 1) % samplesCount;
    }
    if (now2 - firstSampleTS < min) {
      return;
    }
    const passed = startedAt && now2 - startedAt;
    return passed ? Math.round(bytesCount * 1e3 / passed) : void 0;
  };
}
var speedometer_default;
var init_speedometer = __esm({
  "node_modules/axios/lib/helpers/speedometer.js"() {
    "use strict";
    speedometer_default = speedometer;
  }
});

// node_modules/axios/lib/helpers/throttle.js
function throttle(fn, freq) {
  let timestamp = 0;
  let threshold = 1e3 / freq;
  let lastArgs;
  let timer;
  const invoke = (args, now2 = Date.now()) => {
    timestamp = now2;
    lastArgs = null;
    if (timer) {
      clearTimeout(timer);
      timer = null;
    }
    fn(...args);
  };
  const throttled = (...args) => {
    const now2 = Date.now();
    const passed = now2 - timestamp;
    if (passed >= threshold) {
      invoke(args, now2);
    } else {
      lastArgs = args;
      if (!timer) {
        timer = setTimeout(() => {
          timer = null;
          invoke(lastArgs);
        }, threshold - passed);
      }
    }
  };
  const flush = () => lastArgs && invoke(lastArgs);
  return [throttled, flush];
}
var throttle_default;
var init_throttle = __esm({
  "node_modules/axios/lib/helpers/throttle.js"() {
    "use strict";
    throttle_default = throttle;
  }
});

// node_modules/axios/lib/helpers/progressEventReducer.js
var progressEventReducer, progressEventDecorator, asyncDecorator;
var init_progressEventReducer = __esm({
  "node_modules/axios/lib/helpers/progressEventReducer.js"() {
    "use strict";
    init_speedometer();
    init_throttle();
    init_utils();
    progressEventReducer = (listener, isDownloadStream, freq = 3) => {
      let bytesNotified = 0;
      const _speedometer = speedometer_default(50, 250);
      return throttle_default((e) => {
        const loaded = e.loaded;
        const total = e.lengthComputable ? e.total : void 0;
        const progressBytes = loaded - bytesNotified;
        const rate = _speedometer(progressBytes);
        const inRange = loaded <= total;
        bytesNotified = loaded;
        const data = {
          loaded,
          total,
          progress: total ? loaded / total : void 0,
          bytes: progressBytes,
          rate: rate ? rate : void 0,
          estimated: rate && total && inRange ? (total - loaded) / rate : void 0,
          event: e,
          lengthComputable: total != null,
          [isDownloadStream ? "download" : "upload"]: true
        };
        listener(data);
      }, freq);
    };
    progressEventDecorator = (total, throttled) => {
      const lengthComputable = total != null;
      return [
        (loaded) => throttled[0]({
          lengthComputable,
          total,
          loaded
        }),
        throttled[1]
      ];
    };
    asyncDecorator = (fn) => (...args) => utils_default2.asap(() => fn(...args));
  }
});

// node_modules/axios/lib/helpers/estimateDataURLDecodedBytes.js
function estimateDataURLDecodedBytes(url4) {
  if (!url4 || typeof url4 !== "string") return 0;
  if (!url4.startsWith("data:")) return 0;
  const comma = url4.indexOf(",");
  if (comma < 0) return 0;
  const meta4 = url4.slice(5, comma);
  const body = url4.slice(comma + 1);
  const isBase64 = /;base64/i.test(meta4);
  if (isBase64) {
    let effectiveLen = body.length;
    const len = body.length;
    for (let i = 0; i < len; i++) {
      if (body.charCodeAt(i) === 37 && i + 2 < len) {
        const a = body.charCodeAt(i + 1);
        const b = body.charCodeAt(i + 2);
        const isHex = (a >= 48 && a <= 57 || a >= 65 && a <= 70 || a >= 97 && a <= 102) && (b >= 48 && b <= 57 || b >= 65 && b <= 70 || b >= 97 && b <= 102);
        if (isHex) {
          effectiveLen -= 2;
          i += 2;
        }
      }
    }
    let pad = 0;
    let idx = len - 1;
    const tailIsPct3D = (j) => j >= 2 && body.charCodeAt(j - 2) === 37 && // '%'
    body.charCodeAt(j - 1) === 51 && // '3'
    (body.charCodeAt(j) === 68 || body.charCodeAt(j) === 100);
    if (idx >= 0) {
      if (body.charCodeAt(idx) === 61) {
        pad++;
        idx--;
      } else if (tailIsPct3D(idx)) {
        pad++;
        idx -= 3;
      }
    }
    if (pad === 1 && idx >= 0) {
      if (body.charCodeAt(idx) === 61) {
        pad++;
      } else if (tailIsPct3D(idx)) {
        pad++;
      }
    }
    const groups = Math.floor(effectiveLen / 4);
    const bytes = groups * 3 - (pad || 0);
    return bytes > 0 ? bytes : 0;
  }
  return Buffer.byteLength(body, "utf8");
}
var init_estimateDataURLDecodedBytes = __esm({
  "node_modules/axios/lib/helpers/estimateDataURLDecodedBytes.js"() {
    "use strict";
  }
});

// node_modules/axios/lib/adapters/http.js
function dispatchBeforeRedirect(options, responseDetails) {
  if (options.beforeRedirects.proxy) {
    options.beforeRedirects.proxy(options);
  }
  if (options.beforeRedirects.config) {
    options.beforeRedirects.config(options, responseDetails);
  }
}
function setProxy(options, configProxy, location) {
  let proxy = configProxy;
  if (!proxy && proxy !== false) {
    const proxyUrl = getProxyForUrl(location);
    if (proxyUrl) {
      proxy = new URL(proxyUrl);
    }
  }
  if (proxy) {
    if (proxy.username) {
      proxy.auth = (proxy.username || "") + ":" + (proxy.password || "");
    }
    if (proxy.auth) {
      const validProxyAuth = Boolean(proxy.auth.username || proxy.auth.password);
      if (validProxyAuth) {
        proxy.auth = (proxy.auth.username || "") + ":" + (proxy.auth.password || "");
      } else if (typeof proxy.auth === "object") {
        throw new AxiosError_default("Invalid proxy authorization", AxiosError_default.ERR_BAD_OPTION, { proxy });
      }
      const base644 = Buffer.from(proxy.auth, "utf8").toString("base64");
      options.headers["Proxy-Authorization"] = "Basic " + base644;
    }
    options.headers.host = options.hostname + (options.port ? ":" + options.port : "");
    const proxyHost = proxy.hostname || proxy.host;
    options.hostname = proxyHost;
    options.host = proxyHost;
    options.port = proxy.port;
    options.path = location;
    if (proxy.protocol) {
      options.protocol = proxy.protocol.includes(":") ? proxy.protocol : `${proxy.protocol}:`;
    }
  }
  options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) {
    setProxy(redirectOptions, configProxy, redirectOptions.href);
  };
}
var import_http, import_https, import_http2, import_util3, import_follow_redirects, import_zlib, import_stream4, import_events, zlibOptions, brotliOptions, isBrotliSupported, httpFollow, httpsFollow, isHttps, supportedProtocols, flushOnFinish, Http2Sessions, http2Sessions, isHttpAdapterSupported, wrapAsync, resolveFamily, buildAddressEntry, http2Transport, http_default;
var init_http = __esm({
  "node_modules/axios/lib/adapters/http.js"() {
    "use strict";
    init_utils();
    init_settle();
    init_buildFullPath();
    init_buildURL();
    init_proxy_from_env();
    import_http = __toESM(require("http"), 1);
    import_https = __toESM(require("https"), 1);
    import_http2 = __toESM(require("http2"), 1);
    import_util3 = __toESM(require("util"), 1);
    import_follow_redirects = __toESM(require_follow_redirects(), 1);
    import_zlib = __toESM(require("zlib"), 1);
    init_data();
    init_transitional();
    init_AxiosError();
    init_CanceledError();
    init_platform();
    init_fromDataURI();
    import_stream4 = __toESM(require("stream"), 1);
    init_AxiosHeaders();
    init_AxiosTransformStream();
    import_events = require("events");
    init_formDataToStream();
    init_readBlob();
    init_ZlibHeaderTransformStream();
    init_callbackify();
    init_progressEventReducer();
    init_estimateDataURLDecodedBytes();
    zlibOptions = {
      flush: import_zlib.default.constants.Z_SYNC_FLUSH,
      finishFlush: import_zlib.default.constants.Z_SYNC_FLUSH
    };
    brotliOptions = {
      flush: import_zlib.default.constants.BROTLI_OPERATION_FLUSH,
      finishFlush: import_zlib.default.constants.BROTLI_OPERATION_FLUSH
    };
    isBrotliSupported = utils_default2.isFunction(import_zlib.default.createBrotliDecompress);
    ({ http: httpFollow, https: httpsFollow } = import_follow_redirects.default);
    isHttps = /https:?/;
    supportedProtocols = platform_default.protocols.map((protocol) => {
      return protocol + ":";
    });
    flushOnFinish = (stream4, [throttled, flush]) => {
      stream4.on("end", flush).on("error", flush);
      return throttled;
    };
    Http2Sessions = class {
      constructor() {
        this.sessions = /* @__PURE__ */ Object.create(null);
      }
      getSession(authority, options) {
        options = Object.assign(
          {
            sessionTimeout: 1e3
          },
          options
        );
        let authoritySessions = this.sessions[authority];
        if (authoritySessions) {
          let len = authoritySessions.length;
          for (let i = 0; i < len; i++) {
            const [sessionHandle, sessionOptions] = authoritySessions[i];
            if (!sessionHandle.destroyed && !sessionHandle.closed && import_util3.default.isDeepStrictEqual(sessionOptions, options)) {
              return sessionHandle;
            }
          }
        }
        const session = import_http2.default.connect(authority, options);
        let removed;
        const removeSession = () => {
          if (removed) {
            return;
          }
          removed = true;
          let entries = authoritySessions, len = entries.length, i = len;
          while (i--) {
            if (entries[i][0] === session) {
              if (len === 1) {
                delete this.sessions[authority];
              } else {
                entries.splice(i, 1);
              }
              if (!session.closed) {
                session.close();
              }
              return;
            }
          }
        };
        const originalRequestFn = session.request;
        const { sessionTimeout } = options;
        if (sessionTimeout != null) {
          let timer;
          let streamsCount = 0;
          session.request = function() {
            const stream4 = originalRequestFn.apply(this, arguments);
            streamsCount++;
            if (timer) {
              clearTimeout(timer);
              timer = null;
            }
            stream4.once("close", () => {
              if (!--streamsCount) {
                timer = setTimeout(() => {
                  timer = null;
                  removeSession();
                }, sessionTimeout);
              }
            });
            return stream4;
          };
        }
        session.once("close", removeSession);
        let entry = [session, options];
        authoritySessions ? authoritySessions.push(entry) : authoritySessions = this.sessions[authority] = [entry];
        return session;
      }
    };
    http2Sessions = new Http2Sessions();
    isHttpAdapterSupported = typeof process !== "undefined" && utils_default2.kindOf(process) === "process";
    wrapAsync = (asyncExecutor) => {
      return new Promise((resolve3, reject) => {
        let onDone;
        let isDone;
        const done = (value, isRejected) => {
          if (isDone) return;
          isDone = true;
          onDone && onDone(value, isRejected);
        };
        const _resolve = (value) => {
          done(value);
          resolve3(value);
        };
        const _reject = (reason) => {
          done(reason, true);
          reject(reason);
        };
        asyncExecutor(_resolve, _reject, (onDoneHandler) => onDone = onDoneHandler).catch(_reject);
      });
    };
    resolveFamily = ({ address, family }) => {
      if (!utils_default2.isString(address)) {
        throw TypeError("address must be a string");
      }
      return {
        address,
        family: family || (address.indexOf(".") < 0 ? 6 : 4)
      };
    };
    buildAddressEntry = (address, family) => resolveFamily(utils_default2.isObject(address) ? address : { address, family });
    http2Transport = {
      request(options, cb) {
        const authority = options.protocol + "//" + options.hostname + ":" + (options.port || (options.protocol === "https:" ? 443 : 80));
        const { http2Options, headers } = options;
        const session = http2Sessions.getSession(authority, http2Options);
        const { HTTP2_HEADER_SCHEME, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_STATUS } = import_http2.default.constants;
        const http2Headers = {
          [HTTP2_HEADER_SCHEME]: options.protocol.replace(":", ""),
          [HTTP2_HEADER_METHOD]: options.method,
          [HTTP2_HEADER_PATH]: options.path
        };
        utils_default2.forEach(headers, (header, name28) => {
          name28.charAt(0) !== ":" && (http2Headers[name28] = header);
        });
        const req = session.request(http2Headers);
        req.once("response", (responseHeaders) => {
          const response = req;
          responseHeaders = Object.assign({}, responseHeaders);
          const status = responseHeaders[HTTP2_HEADER_STATUS];
          delete responseHeaders[HTTP2_HEADER_STATUS];
          response.headers = responseHeaders;
          response.statusCode = +status;
          cb(response);
        });
        return req;
      }
    };
    http_default = isHttpAdapterSupported && function httpAdapter(config3) {
      return wrapAsync(async function dispatchHttpRequest(resolve3, reject, onDone) {
        let { data, lookup, family, httpVersion = 1, http2Options } = config3;
        const { responseType, responseEncoding } = config3;
        const method = config3.method.toUpperCase();
        let isDone;
        let rejected = false;
        let req;
        httpVersion = +httpVersion;
        if (Number.isNaN(httpVersion)) {
          throw TypeError(`Invalid protocol version: '${config3.httpVersion}' is not a number`);
        }
        if (httpVersion !== 1 && httpVersion !== 2) {
          throw TypeError(`Unsupported protocol version '${httpVersion}'`);
        }
        const isHttp2 = httpVersion === 2;
        if (lookup) {
          const _lookup = callbackify_default(lookup, (value) => utils_default2.isArray(value) ? value : [value]);
          lookup = (hostname4, opt, cb) => {
            _lookup(hostname4, opt, (err, arg0, arg1) => {
              if (err) {
                return cb(err);
              }
              const addresses = utils_default2.isArray(arg0) ? arg0.map((addr) => buildAddressEntry(addr)) : [buildAddressEntry(arg0, arg1)];
              opt.all ? cb(err, addresses) : cb(err, addresses[0].address, addresses[0].family);
            });
          };
        }
        const abortEmitter = new import_events.EventEmitter();
        function abort(reason) {
          try {
            abortEmitter.emit(
              "abort",
              !reason || reason.type ? new CanceledError_default(null, config3, req) : reason
            );
          } catch (err) {
            console.warn("emit error", err);
          }
        }
        abortEmitter.once("abort", reject);
        const onFinished = () => {
          if (config3.cancelToken) {
            config3.cancelToken.unsubscribe(abort);
          }
          if (config3.signal) {
            config3.signal.removeEventListener("abort", abort);
          }
          abortEmitter.removeAllListeners();
        };
        if (config3.cancelToken || config3.signal) {
          config3.cancelToken && config3.cancelToken.subscribe(abort);
          if (config3.signal) {
            config3.signal.aborted ? abort() : config3.signal.addEventListener("abort", abort);
          }
        }
        onDone((response, isRejected) => {
          isDone = true;
          if (isRejected) {
            rejected = true;
            onFinished();
            return;
          }
          const { data: data2 } = response;
          if (data2 instanceof import_stream4.default.Readable || data2 instanceof import_stream4.default.Duplex) {
            const offListeners = import_stream4.default.finished(data2, () => {
              offListeners();
              onFinished();
            });
          } else {
            onFinished();
          }
        });
        const fullPath = buildFullPath(config3.baseURL, config3.url, config3.allowAbsoluteUrls);
        const parsed = new URL(fullPath, platform_default.hasBrowserEnv ? platform_default.origin : void 0);
        const protocol = parsed.protocol || supportedProtocols[0];
        if (protocol === "data:") {
          if (config3.maxContentLength > -1) {
            const dataUrl = String(config3.url || fullPath || "");
            const estimated = estimateDataURLDecodedBytes(dataUrl);
            if (estimated > config3.maxContentLength) {
              return reject(
                new AxiosError_default(
                  "maxContentLength size of " + config3.maxContentLength + " exceeded",
                  AxiosError_default.ERR_BAD_RESPONSE,
                  config3
                )
              );
            }
          }
          let convertedData;
          if (method !== "GET") {
            return settle(resolve3, reject, {
              status: 405,
              statusText: "method not allowed",
              headers: {},
              config: config3
            });
          }
          try {
            convertedData = fromDataURI(config3.url, responseType === "blob", {
              Blob: config3.env && config3.env.Blob
            });
          } catch (err) {
            throw AxiosError_default.from(err, AxiosError_default.ERR_BAD_REQUEST, config3);
          }
          if (responseType === "text") {
            convertedData = convertedData.toString(responseEncoding);
            if (!responseEncoding || responseEncoding === "utf8") {
              convertedData = utils_default2.stripBOM(convertedData);
            }
          } else if (responseType === "stream") {
            convertedData = import_stream4.default.Readable.from(convertedData);
          }
          return settle(resolve3, reject, {
            data: convertedData,
            status: 200,
            statusText: "OK",
            headers: new AxiosHeaders_default(),
            config: config3
          });
        }
        if (supportedProtocols.indexOf(protocol) === -1) {
          return reject(
            new AxiosError_default("Unsupported protocol " + protocol, AxiosError_default.ERR_BAD_REQUEST, config3)
          );
        }
        const headers = AxiosHeaders_default.from(config3.headers).normalize();
        headers.set("User-Agent", "axios/" + VERSION, false);
        const { onUploadProgress, onDownloadProgress } = config3;
        const maxRate = config3.maxRate;
        let maxUploadRate = void 0;
        let maxDownloadRate = void 0;
        if (utils_default2.isSpecCompliantForm(data)) {
          const userBoundary = headers.getContentType(/boundary=([-_\w\d]{10,70})/i);
          data = formDataToStream_default(
            data,
            (formHeaders) => {
              headers.set(formHeaders);
            },
            {
              tag: `axios-${VERSION}-boundary`,
              boundary: userBoundary && userBoundary[1] || void 0
            }
          );
        } else if (utils_default2.isFormData(data) && utils_default2.isFunction(data.getHeaders)) {
          headers.set(data.getHeaders());
          if (!headers.hasContentLength()) {
            try {
              const knownLength = await import_util3.default.promisify(data.getLength).call(data);
              Number.isFinite(knownLength) && knownLength >= 0 && headers.setContentLength(knownLength);
            } catch (e) {
            }
          }
        } else if (utils_default2.isBlob(data) || utils_default2.isFile(data)) {
          data.size && headers.setContentType(data.type || "application/octet-stream");
          headers.setContentLength(data.size || 0);
          data = import_stream4.default.Readable.from(readBlob_default(data));
        } else if (data && !utils_default2.isStream(data)) {
          if (Buffer.isBuffer(data)) {
          } else if (utils_default2.isArrayBuffer(data)) {
            data = Buffer.from(new Uint8Array(data));
          } else if (utils_default2.isString(data)) {
            data = Buffer.from(data, "utf-8");
          } else {
            return reject(
              new AxiosError_default(
                "Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream",
                AxiosError_default.ERR_BAD_REQUEST,
                config3
              )
            );
          }
          headers.setContentLength(data.length, false);
          if (config3.maxBodyLength > -1 && data.length > config3.maxBodyLength) {
            return reject(
              new AxiosError_default(
                "Request body larger than maxBodyLength limit",
                AxiosError_default.ERR_BAD_REQUEST,
                config3
              )
            );
          }
        }
        const contentLength = utils_default2.toFiniteNumber(headers.getContentLength());
        if (utils_default2.isArray(maxRate)) {
          maxUploadRate = maxRate[0];
          maxDownloadRate = maxRate[1];
        } else {
          maxUploadRate = maxDownloadRate = maxRate;
        }
        if (data && (onUploadProgress || maxUploadRate)) {
          if (!utils_default2.isStream(data)) {
            data = import_stream4.default.Readable.from(data, { objectMode: false });
          }
          data = import_stream4.default.pipeline(
            [
              data,
              new AxiosTransformStream_default({
                maxRate: utils_default2.toFiniteNumber(maxUploadRate)
              })
            ],
            utils_default2.noop
          );
          onUploadProgress && data.on(
            "progress",
            flushOnFinish(
              data,
              progressEventDecorator(
                contentLength,
                progressEventReducer(asyncDecorator(onUploadProgress), false, 3)
              )
            )
          );
        }
        let auth = void 0;
        if (config3.auth) {
          const username = config3.auth.username || "";
          const password = config3.auth.password || "";
          auth = username + ":" + password;
        }
        if (!auth && parsed.username) {
          const urlUsername = parsed.username;
          const urlPassword = parsed.password;
          auth = urlUsername + ":" + urlPassword;
        }
        auth && headers.delete("authorization");
        let path33;
        try {
          path33 = buildURL(
            parsed.pathname + parsed.search,
            config3.params,
            config3.paramsSerializer
          ).replace(/^\?/, "");
        } catch (err) {
          const customErr = new Error(err.message);
          customErr.config = config3;
          customErr.url = config3.url;
          customErr.exists = true;
          return reject(customErr);
        }
        headers.set(
          "Accept-Encoding",
          "gzip, compress, deflate" + (isBrotliSupported ? ", br" : ""),
          false
        );
        const options = {
          path: path33,
          method,
          headers: headers.toJSON(),
          agents: { http: config3.httpAgent, https: config3.httpsAgent },
          auth,
          protocol,
          family,
          beforeRedirect: dispatchBeforeRedirect,
          beforeRedirects: {},
          http2Options
        };
        !utils_default2.isUndefined(lookup) && (options.lookup = lookup);
        if (config3.socketPath) {
          options.socketPath = config3.socketPath;
        } else {
          options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
          options.port = parsed.port;
          setProxy(
            options,
            config3.proxy,
            protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path
          );
        }
        let transport;
        const isHttpsRequest = isHttps.test(options.protocol);
        options.agent = isHttpsRequest ? config3.httpsAgent : config3.httpAgent;
        if (isHttp2) {
          transport = http2Transport;
        } else {
          if (config3.transport) {
            transport = config3.transport;
          } else if (config3.maxRedirects === 0) {
            transport = isHttpsRequest ? import_https.default : import_http.default;
          } else {
            if (config3.maxRedirects) {
              options.maxRedirects = config3.maxRedirects;
            }
            if (config3.beforeRedirect) {
              options.beforeRedirects.config = config3.beforeRedirect;
            }
            transport = isHttpsRequest ? httpsFollow : httpFollow;
          }
        }
        if (config3.maxBodyLength > -1) {
          options.maxBodyLength = config3.maxBodyLength;
        } else {
          options.maxBodyLength = Infinity;
        }
        if (config3.insecureHTTPParser) {
          options.insecureHTTPParser = config3.insecureHTTPParser;
        }
        req = transport.request(options, function handleResponse(res) {
          if (req.destroyed) return;
          const streams = [res];
          const responseLength = utils_default2.toFiniteNumber(res.headers["content-length"]);
          if (onDownloadProgress || maxDownloadRate) {
            const transformStream = new AxiosTransformStream_default({
              maxRate: utils_default2.toFiniteNumber(maxDownloadRate)
            });
            onDownloadProgress && transformStream.on(
              "progress",
              flushOnFinish(
                transformStream,
                progressEventDecorator(
                  responseLength,
                  progressEventReducer(asyncDecorator(onDownloadProgress), true, 3)
                )
              )
            );
            streams.push(transformStream);
          }
          let responseStream = res;
          const lastRequest = res.req || req;
          if (config3.decompress !== false && res.headers["content-encoding"]) {
            if (method === "HEAD" || res.statusCode === 204) {
              delete res.headers["content-encoding"];
            }
            switch ((res.headers["content-encoding"] || "").toLowerCase()) {
              /*eslint default-case:0*/
              case "gzip":
              case "x-gzip":
              case "compress":
              case "x-compress":
                streams.push(import_zlib.default.createUnzip(zlibOptions));
                delete res.headers["content-encoding"];
                break;
              case "deflate":
                streams.push(new ZlibHeaderTransformStream_default());
                streams.push(import_zlib.default.createUnzip(zlibOptions));
                delete res.headers["content-encoding"];
                break;
              case "br":
                if (isBrotliSupported) {
                  streams.push(import_zlib.default.createBrotliDecompress(brotliOptions));
                  delete res.headers["content-encoding"];
                }
            }
          }
          responseStream = streams.length > 1 ? import_stream4.default.pipeline(streams, utils_default2.noop) : streams[0];
          const response = {
            status: res.statusCode,
            statusText: res.statusMessage,
            headers: new AxiosHeaders_default(res.headers),
            config: config3,
            request: lastRequest
          };
          if (responseType === "stream") {
            response.data = responseStream;
            settle(resolve3, reject, response);
          } else {
            const responseBuffer = [];
            let totalResponseBytes = 0;
            responseStream.on("data", function handleStreamData(chunk) {
              responseBuffer.push(chunk);
              totalResponseBytes += chunk.length;
              if (config3.maxContentLength > -1 && totalResponseBytes > config3.maxContentLength) {
                rejected = true;
                responseStream.destroy();
                abort(
                  new AxiosError_default(
                    "maxContentLength size of " + config3.maxContentLength + " exceeded",
                    AxiosError_default.ERR_BAD_RESPONSE,
                    config3,
                    lastRequest
                  )
                );
              }
            });
            responseStream.on("aborted", function handlerStreamAborted() {
              if (rejected) {
                return;
              }
              const err = new AxiosError_default(
                "stream has been aborted",
                AxiosError_default.ERR_BAD_RESPONSE,
                config3,
                lastRequest
              );
              responseStream.destroy(err);
              reject(err);
            });
            responseStream.on("error", function handleStreamError(err) {
              if (req.destroyed) return;
              reject(AxiosError_default.from(err, null, config3, lastRequest));
            });
            responseStream.on("end", function handleStreamEnd() {
              try {
                let responseData = responseBuffer.length === 1 ? responseBuffer[0] : Buffer.concat(responseBuffer);
                if (responseType !== "arraybuffer") {
                  responseData = responseData.toString(responseEncoding);
                  if (!responseEncoding || responseEncoding === "utf8") {
                    responseData = utils_default2.stripBOM(responseData);
                  }
                }
                response.data = responseData;
              } catch (err) {
                return reject(AxiosError_default.from(err, null, config3, response.request, response));
              }
              settle(resolve3, reject, response);
            });
          }
          abortEmitter.once("abort", (err) => {
            if (!responseStream.destroyed) {
              responseStream.emit("error", err);
              responseStream.destroy();
            }
          });
        });
        abortEmitter.once("abort", (err) => {
          if (req.close) {
            req.close();
          } else {
            req.destroy(err);
          }
        });
        req.on("error", function handleRequestError(err) {
          reject(AxiosError_default.from(err, null, config3, req));
        });
        req.on("socket", function handleRequestSocket(socket) {
          socket.setKeepAlive(true, 1e3 * 60);
        });
        if (config3.timeout) {
          const timeout = parseInt(config3.timeout, 10);
          if (Number.isNaN(timeout)) {
            abort(
              new AxiosError_default(
                "error trying to parse `config.timeout` to int",
                AxiosError_default.ERR_BAD_OPTION_VALUE,
                config3,
                req
              )
            );
            return;
          }
          req.setTimeout(timeout, function handleRequestTimeout() {
            if (isDone) return;
            let timeoutErrorMessage = config3.timeout ? "timeout of " + config3.timeout + "ms exceeded" : "timeout exceeded";
            const transitional2 = config3.transitional || transitional_default;
            if (config3.timeoutErrorMessage) {
              timeoutErrorMessage = config3.timeoutErrorMessage;
            }
            abort(
              new AxiosError_default(
                timeoutErrorMessage,
                transitional2.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED,
                config3,
                req
              )
            );
          });
        } else {
          req.setTimeout(0);
        }
        if (utils_default2.isStream(data)) {
          let ended = false;
          let errored = false;
          data.on("end", () => {
            ended = true;
          });
          data.once("error", (err) => {
            errored = true;
            req.destroy(err);
          });
          data.on("close", () => {
            if (!ended && !errored) {
              abort(new CanceledError_default("Request stream has been aborted", config3, req));
            }
          });
          data.pipe(req);
        } else {
          data && req.write(data);
          req.end();
        }
      });
    };
  }
});

// node_modules/axios/lib/helpers/isURLSameOrigin.js
var isURLSameOrigin_default;
var init_isURLSameOrigin = __esm({
  "node_modules/axios/lib/helpers/isURLSameOrigin.js"() {
    "use strict";
    init_platform();
    isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? /* @__PURE__ */ ((origin2, isMSIE) => (url4) => {
      url4 = new URL(url4, platform_default.origin);
      return origin2.protocol === url4.protocol && origin2.host === url4.host && (isMSIE || origin2.port === url4.port);
    })(
      new URL(platform_default.origin),
      platform_default.navigator && /(msie|trident)/i.test(platform_default.navigator.userAgent)
    ) : () => true;
  }
});

// node_modules/axios/lib/helpers/cookies.js
var cookies_default;
var init_cookies = __esm({
  "node_modules/axios/lib/helpers/cookies.js"() {
    "use strict";
    init_utils();
    init_platform();
    cookies_default = platform_default.hasStandardBrowserEnv ? (
      // Standard browser envs support document.cookie
      {
        write(name28, value, expires, path33, domain3, secure, sameSite) {
          if (typeof document === "undefined") return;
          const cookie = [`${name28}=${encodeURIComponent(value)}`];
          if (utils_default2.isNumber(expires)) {
            cookie.push(`expires=${new Date(expires).toUTCString()}`);
          }
          if (utils_default2.isString(path33)) {
            cookie.push(`path=${path33}`);
          }
          if (utils_default2.isString(domain3)) {
            cookie.push(`domain=${domain3}`);
          }
          if (secure === true) {
            cookie.push("secure");
          }
          if (utils_default2.isString(sameSite)) {
            cookie.push(`SameSite=${sameSite}`);
          }
          document.cookie = cookie.join("; ");
        },
        read(name28) {
          if (typeof document === "undefined") return null;
          const match = document.cookie.match(new RegExp("(?:^|; )" + name28 + "=([^;]*)"));
          return match ? decodeURIComponent(match[1]) : null;
        },
        remove(name28) {
          this.write(name28, "", Date.now() - 864e5, "/");
        }
      }
    ) : (
      // Non-standard browser env (web workers, react-native) lack needed support.
      {
        write() {
        },
        read() {
          return null;
        },
        remove() {
        }
      }
    );
  }
});

// node_modules/axios/lib/core/mergeConfig.js
function mergeConfig(config1, config22) {
  config22 = config22 || {};
  const config3 = {};
  function getMergedValue(target, source, prop, caseless) {
    if (utils_default2.isPlainObject(target) && utils_default2.isPlainObject(source)) {
      return utils_default2.merge.call({ caseless }, target, source);
    } else if (utils_default2.isPlainObject(source)) {
      return utils_default2.merge({}, source);
    } else if (utils_default2.isArray(source)) {
      return source.slice();
    }
    return source;
  }
  function mergeDeepProperties(a, b, prop, caseless) {
    if (!utils_default2.isUndefined(b)) {
      return getMergedValue(a, b, prop, caseless);
    } else if (!utils_default2.isUndefined(a)) {
      return getMergedValue(void 0, a, prop, caseless);
    }
  }
  function valueFromConfig2(a, b) {
    if (!utils_default2.isUndefined(b)) {
      return getMergedValue(void 0, b);
    }
  }
  function defaultToConfig2(a, b) {
    if (!utils_default2.isUndefined(b)) {
      return getMergedValue(void 0, b);
    } else if (!utils_default2.isUndefined(a)) {
      return getMergedValue(void 0, a);
    }
  }
  function mergeDirectKeys(a, b, prop) {
    if (prop in config22) {
      return getMergedValue(a, b);
    } else if (prop in config1) {
      return getMergedValue(void 0, a);
    }
  }
  const mergeMap = {
    url: valueFromConfig2,
    method: valueFromConfig2,
    data: valueFromConfig2,
    baseURL: defaultToConfig2,
    transformRequest: defaultToConfig2,
    transformResponse: defaultToConfig2,
    paramsSerializer: defaultToConfig2,
    timeout: defaultToConfig2,
    timeoutMessage: defaultToConfig2,
    withCredentials: defaultToConfig2,
    withXSRFToken: defaultToConfig2,
    adapter: defaultToConfig2,
    responseType: defaultToConfig2,
    xsrfCookieName: defaultToConfig2,
    xsrfHeaderName: defaultToConfig2,
    onUploadProgress: defaultToConfig2,
    onDownloadProgress: defaultToConfig2,
    decompress: defaultToConfig2,
    maxContentLength: defaultToConfig2,
    maxBodyLength: defaultToConfig2,
    beforeRedirect: defaultToConfig2,
    transport: defaultToConfig2,
    httpAgent: defaultToConfig2,
    httpsAgent: defaultToConfig2,
    cancelToken: defaultToConfig2,
    socketPath: defaultToConfig2,
    responseEncoding: defaultToConfig2,
    validateStatus: mergeDirectKeys,
    headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
  };
  utils_default2.forEach(Object.keys({ ...config1, ...config22 }), function computeConfigValue(prop) {
    if (prop === "__proto__" || prop === "constructor" || prop === "prototype") return;
    const merge4 = utils_default2.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
    const configValue = merge4(config1[prop], config22[prop], prop);
    utils_default2.isUndefined(configValue) && merge4 !== mergeDirectKeys || (config3[prop] = configValue);
  });
  return config3;
}
var headersToObject;
var init_mergeConfig = __esm({
  "node_modules/axios/lib/core/mergeConfig.js"() {
    "use strict";
    init_utils();
    init_AxiosHeaders();
    headersToObject = (thing) => thing instanceof AxiosHeaders_default ? { ...thing } : thing;
  }
});

// node_modules/axios/lib/helpers/resolveConfig.js
var resolveConfig_default;
var init_resolveConfig = __esm({
  "node_modules/axios/lib/helpers/resolveConfig.js"() {
    "use strict";
    init_platform();
    init_utils();
    init_isURLSameOrigin();
    init_cookies();
    init_buildFullPath();
    init_mergeConfig();
    init_AxiosHeaders();
    init_buildURL();
    resolveConfig_default = (config3) => {
      const newConfig = mergeConfig({}, config3);
      let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
      newConfig.headers = headers = AxiosHeaders_default.from(headers);
      newConfig.url = buildURL(
        buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls),
        config3.params,
        config3.paramsSerializer
      );
      if (auth) {
        headers.set(
          "Authorization",
          "Basic " + btoa(
            (auth.username || "") + ":" + (auth.password ? unescape(encodeURIComponent(auth.password)) : "")
          )
        );
      }
      if (utils_default2.isFormData(data)) {
        if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv) {
          headers.setContentType(void 0);
        } else if (utils_default2.isFunction(data.getHeaders)) {
          const formHeaders = data.getHeaders();
          const allowedHeaders = ["content-type", "content-length"];
          Object.entries(formHeaders).forEach(([key, val]) => {
            if (allowedHeaders.includes(key.toLowerCase())) {
              headers.set(key, val);
            }
          });
        }
      }
      if (platform_default.hasStandardBrowserEnv) {
        withXSRFToken && utils_default2.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));
        if (withXSRFToken || withXSRFToken !== false && isURLSameOrigin_default(newConfig.url)) {
          const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies_default.read(xsrfCookieName);
          if (xsrfValue) {
            headers.set(xsrfHeaderName, xsrfValue);
          }
        }
      }
      return newConfig;
    };
  }
});

// node_modules/axios/lib/adapters/xhr.js
var isXHRAdapterSupported, xhr_default;
var init_xhr = __esm({
  "node_modules/axios/lib/adapters/xhr.js"() {
    "use strict";
    init_utils();
    init_settle();
    init_transitional();
    init_AxiosError();
    init_CanceledError();
    init_parseProtocol();
    init_platform();
    init_AxiosHeaders();
    init_progressEventReducer();
    init_resolveConfig();
    isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
    xhr_default = isXHRAdapterSupported && function(config3) {
      return new Promise(function dispatchXhrRequest(resolve3, reject) {
        const _config = resolveConfig_default(config3);
        let requestData = _config.data;
        const requestHeaders = AxiosHeaders_default.from(_config.headers).normalize();
        let { responseType, onUploadProgress, onDownloadProgress } = _config;
        let onCanceled;
        let uploadThrottled, downloadThrottled;
        let flushUpload, flushDownload;
        function done() {
          flushUpload && flushUpload();
          flushDownload && flushDownload();
          _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
          _config.signal && _config.signal.removeEventListener("abort", onCanceled);
        }
        let request = new XMLHttpRequest();
        request.open(_config.method.toUpperCase(), _config.url, true);
        request.timeout = _config.timeout;
        function onloadend() {
          if (!request) {
            return;
          }
          const responseHeaders = AxiosHeaders_default.from(
            "getAllResponseHeaders" in request && request.getAllResponseHeaders()
          );
          const responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
          const response = {
            data: responseData,
            status: request.status,
            statusText: request.statusText,
            headers: responseHeaders,
            config: config3,
            request
          };
          settle(
            function _resolve(value) {
              resolve3(value);
              done();
            },
            function _reject(err) {
              reject(err);
              done();
            },
            response
          );
          request = null;
        }
        if ("onloadend" in request) {
          request.onloadend = onloadend;
        } else {
          request.onreadystatechange = function handleLoad() {
            if (!request || request.readyState !== 4) {
              return;
            }
            if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
              return;
            }
            setTimeout(onloadend);
          };
        }
        request.onabort = function handleAbort() {
          if (!request) {
            return;
          }
          reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config3, request));
          request = null;
        };
        request.onerror = function handleError(event) {
          const msg = event && event.message ? event.message : "Network Error";
          const err = new AxiosError_default(msg, AxiosError_default.ERR_NETWORK, config3, request);
          err.event = event || null;
          reject(err);
          request = null;
        };
        request.ontimeout = function handleTimeout() {
          let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
          const transitional2 = _config.transitional || transitional_default;
          if (_config.timeoutErrorMessage) {
            timeoutErrorMessage = _config.timeoutErrorMessage;
          }
          reject(
            new AxiosError_default(
              timeoutErrorMessage,
              transitional2.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED,
              config3,
              request
            )
          );
          request = null;
        };
        requestData === void 0 && requestHeaders.setContentType(null);
        if ("setRequestHeader" in request) {
          utils_default2.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
            request.setRequestHeader(key, val);
          });
        }
        if (!utils_default2.isUndefined(_config.withCredentials)) {
          request.withCredentials = !!_config.withCredentials;
        }
        if (responseType && responseType !== "json") {
          request.responseType = _config.responseType;
        }
        if (onDownloadProgress) {
          [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
          request.addEventListener("progress", downloadThrottled);
        }
        if (onUploadProgress && request.upload) {
          [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);
          request.upload.addEventListener("progress", uploadThrottled);
          request.upload.addEventListener("loadend", flushUpload);
        }
        if (_config.cancelToken || _config.signal) {
          onCanceled = (cancel) => {
            if (!request) {
              return;
            }
            reject(!cancel || cancel.type ? new CanceledError_default(null, config3, request) : cancel);
            request.abort();
            request = null;
          };
          _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
          if (_config.signal) {
            _config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled);
          }
        }
        const protocol = parseProtocol(_config.url);
        if (protocol && platform_default.protocols.indexOf(protocol) === -1) {
          reject(
            new AxiosError_default(
              "Unsupported protocol " + protocol + ":",
              AxiosError_default.ERR_BAD_REQUEST,
              config3
            )
          );
          return;
        }
        request.send(requestData || null);
      });
    };
  }
});

// node_modules/axios/lib/helpers/composeSignals.js
var composeSignals, composeSignals_default;
var init_composeSignals = __esm({
  "node_modules/axios/lib/helpers/composeSignals.js"() {
    "use strict";
    init_CanceledError();
    init_AxiosError();
    init_utils();
    composeSignals = (signals, timeout) => {
      const { length } = signals = signals ? signals.filter(Boolean) : [];
      if (timeout || length) {
        let controller = new AbortController();
        let aborted3;
        const onabort = function(reason) {
          if (!aborted3) {
            aborted3 = true;
            unsubscribe();
            const err = reason instanceof Error ? reason : this.reason;
            controller.abort(
              err instanceof AxiosError_default ? err : new CanceledError_default(err instanceof Error ? err.message : err)
            );
          }
        };
        let timer = timeout && setTimeout(() => {
          timer = null;
          onabort(new AxiosError_default(`timeout of ${timeout}ms exceeded`, AxiosError_default.ETIMEDOUT));
        }, timeout);
        const unsubscribe = () => {
          if (signals) {
            timer && clearTimeout(timer);
            timer = null;
            signals.forEach((signal2) => {
              signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
            });
            signals = null;
          }
        };
        signals.forEach((signal2) => signal2.addEventListener("abort", onabort));
        const { signal } = controller;
        signal.unsubscribe = () => utils_default2.asap(unsubscribe);
        return signal;
      }
    };
    composeSignals_default = composeSignals;
  }
});

// node_modules/axios/lib/helpers/trackStream.js
var streamChunk, readBytes, readStream, trackStream;
var init_trackStream = __esm({
  "node_modules/axios/lib/helpers/trackStream.js"() {
    "use strict";
    streamChunk = function* (chunk, chunkSize) {
      let len = chunk.byteLength;
      if (!chunkSize || len < chunkSize) {
        yield chunk;
        return;
      }
      let pos = 0;
      let end;
      while (pos < len) {
        end = pos + chunkSize;
        yield chunk.slice(pos, end);
        pos = end;
      }
    };
    readBytes = async function* (iterable, chunkSize) {
      for await (const chunk of readStream(iterable)) {
        yield* streamChunk(chunk, chunkSize);
      }
    };
    readStream = async function* (stream4) {
      if (stream4[Symbol.asyncIterator]) {
        yield* stream4;
        return;
      }
      const reader = stream4.getReader();
      try {
        for (; ; ) {
          const { done, value } = await reader.read();
          if (done) {
            break;
          }
          yield value;
        }
      } finally {
        await reader.cancel();
      }
    };
    trackStream = (stream4, chunkSize, onProgress, onFinish) => {
      const iterator2 = readBytes(stream4, chunkSize);
      let bytes = 0;
      let done;
      let _onFinish = (e) => {
        if (!done) {
          done = true;
          onFinish && onFinish(e);
        }
      };
      return new ReadableStream(
        {
          async pull(controller) {
            try {
              const { done: done2, value } = await iterator2.next();
              if (done2) {
                _onFinish();
                controller.close();
                return;
              }
              let len = value.byteLength;
              if (onProgress) {
                let loadedBytes = bytes += len;
                onProgress(loadedBytes);
              }
              controller.enqueue(new Uint8Array(value));
            } catch (err) {
              _onFinish(err);
              throw err;
            }
          },
          cancel(reason) {
            _onFinish(reason);
            return iterator2.return();
          }
        },
        {
          highWaterMark: 2
        }
      );
    };
  }
});

// node_modules/axios/lib/adapters/fetch.js
var DEFAULT_CHUNK_SIZE, isFunction3, globalFetchAPI, ReadableStream2, TextEncoder2, test, factory, seedCache, getFetch, adapter;
var init_fetch = __esm({
  "node_modules/axios/lib/adapters/fetch.js"() {
    "use strict";
    init_platform();
    init_utils();
    init_AxiosError();
    init_composeSignals();
    init_trackStream();
    init_AxiosHeaders();
    init_progressEventReducer();
    init_resolveConfig();
    init_settle();
    DEFAULT_CHUNK_SIZE = 64 * 1024;
    ({ isFunction: isFunction3 } = utils_default2);
    globalFetchAPI = (({ Request: Request2, Response: Response3 }) => ({
      Request: Request2,
      Response: Response3
    }))(utils_default2.global);
    ({ ReadableStream: ReadableStream2, TextEncoder: TextEncoder2 } = utils_default2.global);
    test = (fn, ...args) => {
      try {
        return !!fn(...args);
      } catch (e) {
        return false;
      }
    };
    factory = (env2) => {
      env2 = utils_default2.merge.call(
        {
          skipUndefined: true
        },
        globalFetchAPI,
        env2
      );
      const { fetch: envFetch, Request: Request2, Response: Response3 } = env2;
      const isFetchSupported = envFetch ? isFunction3(envFetch) : typeof fetch === "function";
      const isRequestSupported = isFunction3(Request2);
      const isResponseSupported = isFunction3(Response3);
      if (!isFetchSupported) {
        return false;
      }
      const isReadableStreamSupported = isFetchSupported && isFunction3(ReadableStream2);
      const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? /* @__PURE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder2()) : async (str) => new Uint8Array(await new Request2(str).arrayBuffer()));
      const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
        let duplexAccessed = false;
        const body = new ReadableStream2();
        const hasContentType = new Request2(platform_default.origin, {
          body,
          method: "POST",
          get duplex() {
            duplexAccessed = true;
            return "half";
          }
        }).headers.has("Content-Type");
        body.cancel();
        return duplexAccessed && !hasContentType;
      });
      const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils_default2.isReadableStream(new Response3("").body));
      const resolvers = {
        stream: supportsResponseStream && ((res) => res.body)
      };
      isFetchSupported && (() => {
        ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
          !resolvers[type] && (resolvers[type] = (res, config3) => {
            let method = res && res[type];
            if (method) {
              return method.call(res);
            }
            throw new AxiosError_default(
              `Response type '${type}' is not supported`,
              AxiosError_default.ERR_NOT_SUPPORT,
              config3
            );
          });
        });
      })();
      const getBodyLength = async (body) => {
        if (body == null) {
          return 0;
        }
        if (utils_default2.isBlob(body)) {
          return body.size;
        }
        if (utils_default2.isSpecCompliantForm(body)) {
          const _request = new Request2(platform_default.origin, {
            method: "POST",
            body
          });
          return (await _request.arrayBuffer()).byteLength;
        }
        if (utils_default2.isArrayBufferView(body) || utils_default2.isArrayBuffer(body)) {
          return body.byteLength;
        }
        if (utils_default2.isURLSearchParams(body)) {
          body = body + "";
        }
        if (utils_default2.isString(body)) {
          return (await encodeText(body)).byteLength;
        }
      };
      const resolveBodyLength = async (headers, body) => {
        const length = utils_default2.toFiniteNumber(headers.getContentLength());
        return length == null ? getBodyLength(body) : length;
      };
      return async (config3) => {
        let {
          url: url4,
          method,
          data,
          signal,
          cancelToken,
          timeout,
          onDownloadProgress,
          onUploadProgress,
          responseType,
          headers,
          withCredentials = "same-origin",
          fetchOptions
        } = resolveConfig_default(config3);
        let _fetch = envFetch || fetch;
        responseType = responseType ? (responseType + "").toLowerCase() : "text";
        let composedSignal = composeSignals_default(
          [signal, cancelToken && cancelToken.toAbortSignal()],
          timeout
        );
        let request = null;
        const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
          composedSignal.unsubscribe();
        });
        let requestContentLength;
        try {
          if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
            let _request = new Request2(url4, {
              method: "POST",
              body: data,
              duplex: "half"
            });
            let contentTypeHeader;
            if (utils_default2.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
              headers.setContentType(contentTypeHeader);
            }
            if (_request.body) {
              const [onProgress, flush] = progressEventDecorator(
                requestContentLength,
                progressEventReducer(asyncDecorator(onUploadProgress))
              );
              data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
            }
          }
          if (!utils_default2.isString(withCredentials)) {
            withCredentials = withCredentials ? "include" : "omit";
          }
          const isCredentialsSupported = isRequestSupported && "credentials" in Request2.prototype;
          const resolvedOptions = {
            ...fetchOptions,
            signal: composedSignal,
            method: method.toUpperCase(),
            headers: headers.normalize().toJSON(),
            body: data,
            duplex: "half",
            credentials: isCredentialsSupported ? withCredentials : void 0
          };
          request = isRequestSupported && new Request2(url4, resolvedOptions);
          let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url4, resolvedOptions));
          const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
          if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
            const options = {};
            ["status", "statusText", "headers"].forEach((prop) => {
              options[prop] = response[prop];
            });
            const responseContentLength = utils_default2.toFiniteNumber(response.headers.get("content-length"));
            const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
              responseContentLength,
              progressEventReducer(asyncDecorator(onDownloadProgress), true)
            ) || [];
            response = new Response3(
              trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
                flush && flush();
                unsubscribe && unsubscribe();
              }),
              options
            );
          }
          responseType = responseType || "text";
          let responseData = await resolvers[utils_default2.findKey(resolvers, responseType) || "text"](
            response,
            config3
          );
          !isStreamResponse && unsubscribe && unsubscribe();
          return await new Promise((resolve3, reject) => {
            settle(resolve3, reject, {
              data: responseData,
              headers: AxiosHeaders_default.from(response.headers),
              status: response.status,
              statusText: response.statusText,
              config: config3,
              request
            });
          });
        } catch (err) {
          unsubscribe && unsubscribe();
          if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
            throw Object.assign(
              new AxiosError_default(
                "Network Error",
                AxiosError_default.ERR_NETWORK,
                config3,
                request,
                err && err.response
              ),
              {
                cause: err.cause || err
              }
            );
          }
          throw AxiosError_default.from(err, err && err.code, config3, request, err && err.response);
        }
      };
    };
    seedCache = /* @__PURE__ */ new Map();
    getFetch = (config3) => {
      let env2 = config3 && config3.env || {};
      const { fetch: fetch2, Request: Request2, Response: Response3 } = env2;
      const seeds = [Request2, Response3, fetch2];
      let len = seeds.length, i = len, seed, target, map3 = seedCache;
      while (i--) {
        seed = seeds[i];
        target = map3.get(seed);
        target === void 0 && map3.set(seed, target = i ? /* @__PURE__ */ new Map() : factory(env2));
        map3 = target;
      }
      return target;
    };
    adapter = getFetch();
  }
});

// node_modules/axios/lib/adapters/adapters.js
function getAdapter(adapters2, config3) {
  adapters2 = utils_default2.isArray(adapters2) ? adapters2 : [adapters2];
  const { length } = adapters2;
  let nameOrAdapter;
  let adapter2;
  const rejectedReasons = {};
  for (let i = 0; i < length; i++) {
    nameOrAdapter = adapters2[i];
    let id;
    adapter2 = nameOrAdapter;
    if (!isResolvedHandle(nameOrAdapter)) {
      adapter2 = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
      if (adapter2 === void 0) {
        throw new AxiosError_default(`Unknown adapter '${id}'`);
      }
    }
    if (adapter2 && (utils_default2.isFunction(adapter2) || (adapter2 = adapter2.get(config3)))) {
      break;
    }
    rejectedReasons[id || "#" + i] = adapter2;
  }
  if (!adapter2) {
    const reasons = Object.entries(rejectedReasons).map(
      ([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build")
    );
    let s = length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason).join("\n") : " " + renderReason(reasons[0]) : "as no adapter specified";
    throw new AxiosError_default(
      `There is no suitable adapter to dispatch the request ` + s,
      "ERR_NOT_SUPPORT"
    );
  }
  return adapter2;
}
var knownAdapters, renderReason, isResolvedHandle, adapters_default;
var init_adapters = __esm({
  "node_modules/axios/lib/adapters/adapters.js"() {
    "use strict";
    init_utils();
    init_http();
    init_xhr();
    init_fetch();
    init_AxiosError();
    knownAdapters = {
      http: http_default,
      xhr: xhr_default,
      fetch: {
        get: getFetch
      }
    };
    utils_default2.forEach(knownAdapters, (fn, value) => {
      if (fn) {
        try {
          Object.defineProperty(fn, "name", { value });
        } catch (e) {
        }
        Object.defineProperty(fn, "adapterName", { value });
      }
    });
    renderReason = (reason) => `- ${reason}`;
    isResolvedHandle = (adapter2) => utils_default2.isFunction(adapter2) || adapter2 === null || adapter2 === false;
    adapters_default = {
      /**
       * Resolve an adapter from a list of adapter names or functions.
       * @type {Function}
       */
      getAdapter,
      /**
       * Exposes all known adapters
       * @type {Object<string, Function|Object>}
       */
      adapters: knownAdapters
    };
  }
});

// node_modules/axios/lib/core/dispatchRequest.js
function throwIfCancellationRequested(config3) {
  if (config3.cancelToken) {
    config3.cancelToken.throwIfRequested();
  }
  if (config3.signal && config3.signal.aborted) {
    throw new CanceledError_default(null, config3);
  }
}
function dispatchRequest(config3) {
  throwIfCancellationRequested(config3);
  config3.headers = AxiosHeaders_default.from(config3.headers);
  config3.data = transformData.call(config3, config3.transformRequest);
  if (["post", "put", "patch"].indexOf(config3.method) !== -1) {
    config3.headers.setContentType("application/x-www-form-urlencoded", false);
  }
  const adapter2 = adapters_default.getAdapter(config3.adapter || defaults_default.adapter, config3);
  return adapter2(config3).then(
    function onAdapterResolution(response) {
      throwIfCancellationRequested(config3);
      response.data = transformData.call(config3, config3.transformResponse, response);
      response.headers = AxiosHeaders_default.from(response.headers);
      return response;
    },
    function onAdapterRejection(reason) {
      if (!isCancel(reason)) {
        throwIfCancellationRequested(config3);
        if (reason && reason.response) {
          reason.response.data = transformData.call(
            config3,
            config3.transformResponse,
            reason.response
          );
          reason.response.headers = AxiosHeaders_default.from(reason.response.headers);
        }
      }
      return Promise.reject(reason);
    }
  );
}
var init_dispatchRequest = __esm({
  "node_modules/axios/lib/core/dispatchRequest.js"() {
    "use strict";
    init_transformData();
    init_isCancel();
    init_defaults();
    init_CanceledError();
    init_AxiosHeaders();
    init_adapters();
  }
});

// node_modules/axios/lib/helpers/validator.js
function assertOptions(options, schema, allowUnknown) {
  if (typeof options !== "object") {
    throw new AxiosError_default("options must be an object", AxiosError_default.ERR_BAD_OPTION_VALUE);
  }
  const keys2 = Object.keys(options);
  let i = keys2.length;
  while (i-- > 0) {
    const opt = keys2[i];
    const validator2 = schema[opt];
    if (validator2) {
      const value = options[opt];
      const result = value === void 0 || validator2(value, opt, options);
      if (result !== true) {
        throw new AxiosError_default(
          "option " + opt + " must be " + result,
          AxiosError_default.ERR_BAD_OPTION_VALUE
        );
      }
      continue;
    }
    if (allowUnknown !== true) {
      throw new AxiosError_default("Unknown option " + opt, AxiosError_default.ERR_BAD_OPTION);
    }
  }
}
var validators, deprecatedWarnings, validator_default;
var init_validator = __esm({
  "node_modules/axios/lib/helpers/validator.js"() {
    "use strict";
    init_data();
    init_AxiosError();
    validators = {};
    ["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
      validators[type] = function validator2(thing) {
        return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
      };
    });
    deprecatedWarnings = {};
    validators.transitional = function transitional(validator2, version3, message) {
      function formatMessage(opt, desc) {
        return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
      }
      return (value, opt, opts) => {
        if (validator2 === false) {
          throw new AxiosError_default(
            formatMessage(opt, " has been removed" + (version3 ? " in " + version3 : "")),
            AxiosError_default.ERR_DEPRECATED
          );
        }
        if (version3 && !deprecatedWarnings[opt]) {
          deprecatedWarnings[opt] = true;
          console.warn(
            formatMessage(
              opt,
              " has been deprecated since v" + version3 + " and will be removed in the near future"
            )
          );
        }
        return validator2 ? validator2(value, opt, opts) : true;
      };
    };
    validators.spelling = function spelling(correctSpelling) {
      return (value, opt) => {
        console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
        return true;
      };
    };
    validator_default = {
      assertOptions,
      validators
    };
  }
});

// node_modules/axios/lib/core/Axios.js
var validators2, Axios, Axios_default;
var init_Axios = __esm({
  "node_modules/axios/lib/core/Axios.js"() {
    "use strict";
    init_utils();
    init_buildURL();
    init_InterceptorManager();
    init_dispatchRequest();
    init_mergeConfig();
    init_buildFullPath();
    init_validator();
    init_AxiosHeaders();
    init_transitional();
    validators2 = validator_default.validators;
    Axios = class {
      constructor(instanceConfig) {
        this.defaults = instanceConfig || {};
        this.interceptors = {
          request: new InterceptorManager_default(),
          response: new InterceptorManager_default()
        };
      }
      /**
       * Dispatch a request
       *
       * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
       * @param {?Object} config
       *
       * @returns {Promise} The Promise to be fulfilled
       */
      async request(configOrUrl, config3) {
        try {
          return await this._request(configOrUrl, config3);
        } catch (err) {
          if (err instanceof Error) {
            let dummy = {};
            Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = new Error();
            const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, "") : "";
            try {
              if (!err.stack) {
                err.stack = stack;
              } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ""))) {
                err.stack += "\n" + stack;
              }
            } catch (e) {
            }
          }
          throw err;
        }
      }
      _request(configOrUrl, config3) {
        if (typeof configOrUrl === "string") {
          config3 = config3 || {};
          config3.url = configOrUrl;
        } else {
          config3 = configOrUrl || {};
        }
        config3 = mergeConfig(this.defaults, config3);
        const { transitional: transitional2, paramsSerializer, headers } = config3;
        if (transitional2 !== void 0) {
          validator_default.assertOptions(
            transitional2,
            {
              silentJSONParsing: validators2.transitional(validators2.boolean),
              forcedJSONParsing: validators2.transitional(validators2.boolean),
              clarifyTimeoutError: validators2.transitional(validators2.boolean),
              legacyInterceptorReqResOrdering: validators2.transitional(validators2.boolean)
            },
            false
          );
        }
        if (paramsSerializer != null) {
          if (utils_default2.isFunction(paramsSerializer)) {
            config3.paramsSerializer = {
              serialize: paramsSerializer
            };
          } else {
            validator_default.assertOptions(
              paramsSerializer,
              {
                encode: validators2.function,
                serialize: validators2.function
              },
              true
            );
          }
        }
        if (config3.allowAbsoluteUrls !== void 0) {
        } else if (this.defaults.allowAbsoluteUrls !== void 0) {
          config3.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
        } else {
          config3.allowAbsoluteUrls = true;
        }
        validator_default.assertOptions(
          config3,
          {
            baseUrl: validators2.spelling("baseURL"),
            withXsrfToken: validators2.spelling("withXSRFToken")
          },
          true
        );
        config3.method = (config3.method || this.defaults.method || "get").toLowerCase();
        let contextHeaders = headers && utils_default2.merge(headers.common, headers[config3.method]);
        headers && utils_default2.forEach(["delete", "get", "head", "post", "put", "patch", "common"], (method) => {
          delete headers[method];
        });
        config3.headers = AxiosHeaders_default.concat(contextHeaders, headers);
        const requestInterceptorChain = [];
        let synchronousRequestInterceptors = true;
        this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
          if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config3) === false) {
            return;
          }
          synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
          const transitional3 = config3.transitional || transitional_default;
          const legacyInterceptorReqResOrdering = transitional3 && transitional3.legacyInterceptorReqResOrdering;
          if (legacyInterceptorReqResOrdering) {
            requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
          } else {
            requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
          }
        });
        const responseInterceptorChain = [];
        this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
          responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
        });
        let promise3;
        let i = 0;
        let len;
        if (!synchronousRequestInterceptors) {
          const chain = [dispatchRequest.bind(this), void 0];
          chain.unshift(...requestInterceptorChain);
          chain.push(...responseInterceptorChain);
          len = chain.length;
          promise3 = Promise.resolve(config3);
          while (i < len) {
            promise3 = promise3.then(chain[i++], chain[i++]);
          }
          return promise3;
        }
        len = requestInterceptorChain.length;
        let newConfig = config3;
        while (i < len) {
          const onFulfilled = requestInterceptorChain[i++];
          const onRejected = requestInterceptorChain[i++];
          try {
            newConfig = onFulfilled(newConfig);
          } catch (error73) {
            onRejected.call(this, error73);
            break;
          }
        }
        try {
          promise3 = dispatchRequest.call(this, newConfig);
        } catch (error73) {
          return Promise.reject(error73);
        }
        i = 0;
        len = responseInterceptorChain.length;
        while (i < len) {
          promise3 = promise3.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
        }
        return promise3;
      }
      getUri(config3) {
        config3 = mergeConfig(this.defaults, config3);
        const fullPath = buildFullPath(config3.baseURL, config3.url, config3.allowAbsoluteUrls);
        return buildURL(fullPath, config3.params, config3.paramsSerializer);
      }
    };
    utils_default2.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
      Axios.prototype[method] = function(url4, config3) {
        return this.request(
          mergeConfig(config3 || {}, {
            method,
            url: url4,
            data: (config3 || {}).data
          })
        );
      };
    });
    utils_default2.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
      function generateHTTPMethod(isForm) {
        return function httpMethod(url4, data, config3) {
          return this.request(
            mergeConfig(config3 || {}, {
              method,
              headers: isForm ? {
                "Content-Type": "multipart/form-data"
              } : {},
              url: url4,
              data
            })
          );
        };
      }
      Axios.prototype[method] = generateHTTPMethod();
      Axios.prototype[method + "Form"] = generateHTTPMethod(true);
    });
    Axios_default = Axios;
  }
});

// node_modules/axios/lib/cancel/CancelToken.js
var CancelToken, CancelToken_default;
var init_CancelToken = __esm({
  "node_modules/axios/lib/cancel/CancelToken.js"() {
    "use strict";
    init_CanceledError();
    CancelToken = class _CancelToken {
      constructor(executor) {
        if (typeof executor !== "function") {
          throw new TypeError("executor must be a function.");
        }
        let resolvePromise;
        this.promise = new Promise(function promiseExecutor(resolve3) {
          resolvePromise = resolve3;
        });
        const token = this;
        this.promise.then((cancel) => {
          if (!token._listeners) return;
          let i = token._listeners.length;
          while (i-- > 0) {
            token._listeners[i](cancel);
          }
          token._listeners = null;
        });
        this.promise.then = (onfulfilled) => {
          let _resolve;
          const promise3 = new Promise((resolve3) => {
            token.subscribe(resolve3);
            _resolve = resolve3;
          }).then(onfulfilled);
          promise3.cancel = function reject() {
            token.unsubscribe(_resolve);
          };
          return promise3;
        };
        executor(function cancel(message, config3, request) {
          if (token.reason) {
            return;
          }
          token.reason = new CanceledError_default(message, config3, request);
          resolvePromise(token.reason);
        });
      }
      /**
       * Throws a `CanceledError` if cancellation has been requested.
       */
      throwIfRequested() {
        if (this.reason) {
          throw this.reason;
        }
      }
      /**
       * Subscribe to the cancel signal
       */
      subscribe(listener) {
        if (this.reason) {
          listener(this.reason);
          return;
        }
        if (this._listeners) {
          this._listeners.push(listener);
        } else {
          this._listeners = [listener];
        }
      }
      /**
       * Unsubscribe from the cancel signal
       */
      unsubscribe(listener) {
        if (!this._listeners) {
          return;
        }
        const index = this._listeners.indexOf(listener);
        if (index !== -1) {
          this._listeners.splice(index, 1);
        }
      }
      toAbortSignal() {
        const controller = new AbortController();
        const abort = (err) => {
          controller.abort(err);
        };
        this.subscribe(abort);
        controller.signal.unsubscribe = () => this.unsubscribe(abort);
        return controller.signal;
      }
      /**
       * Returns an object that contains a new `CancelToken` and a function that, when called,
       * cancels the `CancelToken`.
       */
      static source() {
        let cancel;
        const token = new _CancelToken(function executor(c) {
          cancel = c;
        });
        return {
          token,
          cancel
        };
      }
    };
    CancelToken_default = CancelToken;
  }
});

// node_modules/axios/lib/helpers/spread.js
function spread(callback) {
  return function wrap(arr) {
    return callback.apply(null, arr);
  };
}
var init_spread = __esm({
  "node_modules/axios/lib/helpers/spread.js"() {
    "use strict";
  }
});

// node_modules/axios/lib/helpers/isAxiosError.js
function isAxiosError(payload) {
  return utils_default2.isObject(payload) && payload.isAxiosError === true;
}
var init_isAxiosError = __esm({
  "node_modules/axios/lib/helpers/isAxiosError.js"() {
    "use strict";
    init_utils();
  }
});

// node_modules/axios/lib/helpers/HttpStatusCode.js
var HttpStatusCode, HttpStatusCode_default;
var init_HttpStatusCode = __esm({
  "node_modules/axios/lib/helpers/HttpStatusCode.js"() {
    "use strict";
    HttpStatusCode = {
      Continue: 100,
      SwitchingProtocols: 101,
      Processing: 102,
      EarlyHints: 103,
      Ok: 200,
      Created: 201,
      Accepted: 202,
      NonAuthoritativeInformation: 203,
      NoContent: 204,
      ResetContent: 205,
      PartialContent: 206,
      MultiStatus: 207,
      AlreadyReported: 208,
      ImUsed: 226,
      MultipleChoices: 300,
      MovedPermanently: 301,
      Found: 302,
      SeeOther: 303,
      NotModified: 304,
      UseProxy: 305,
      Unused: 306,
      TemporaryRedirect: 307,
      PermanentRedirect: 308,
      BadRequest: 400,
      Unauthorized: 401,
      PaymentRequired: 402,
      Forbidden: 403,
      NotFound: 404,
      MethodNotAllowed: 405,
      NotAcceptable: 406,
      ProxyAuthenticationRequired: 407,
      RequestTimeout: 408,
      Conflict: 409,
      Gone: 410,
      LengthRequired: 411,
      PreconditionFailed: 412,
      PayloadTooLarge: 413,
      UriTooLong: 414,
      UnsupportedMediaType: 415,
      RangeNotSatisfiable: 416,
      ExpectationFailed: 417,
      ImATeapot: 418,
      MisdirectedRequest: 421,
      UnprocessableEntity: 422,
      Locked: 423,
      FailedDependency: 424,
      TooEarly: 425,
      UpgradeRequired: 426,
      PreconditionRequired: 428,
      TooManyRequests: 429,
      RequestHeaderFieldsTooLarge: 431,
      UnavailableForLegalReasons: 451,
      InternalServerError: 500,
      NotImplemented: 501,
      BadGateway: 502,
      ServiceUnavailable: 503,
      GatewayTimeout: 504,
      HttpVersionNotSupported: 505,
      VariantAlsoNegotiates: 506,
      InsufficientStorage: 507,
      LoopDetected: 508,
      NotExtended: 510,
      NetworkAuthenticationRequired: 511,
      WebServerIsDown: 521,
      ConnectionTimedOut: 522,
      OriginIsUnreachable: 523,
      TimeoutOccurred: 524,
      SslHandshakeFailed: 525,
      InvalidSslCertificate: 526
    };
    Object.entries(HttpStatusCode).forEach(([key, value]) => {
      HttpStatusCode[value] = key;
    });
    HttpStatusCode_default = HttpStatusCode;
  }
});

// node_modules/axios/lib/axios.js
function createInstance(defaultConfig) {
  const context2 = new Axios_default(defaultConfig);
  const instance = bind(Axios_default.prototype.request, context2);
  utils_default2.extend(instance, Axios_default.prototype, context2, { allOwnKeys: true });
  utils_default2.extend(instance, context2, null, { allOwnKeys: true });
  instance.create = function create(instanceConfig) {
    return createInstance(mergeConfig(defaultConfig, instanceConfig));
  };
  return instance;
}
var axios, axios_default;
var init_axios = __esm({
  "node_modules/axios/lib/axios.js"() {
    "use strict";
    init_utils();
    init_bind();
    init_Axios();
    init_mergeConfig();
    init_defaults();
    init_formDataToJSON();
    init_CanceledError();
    init_CancelToken();
    init_isCancel();
    init_data();
    init_toFormData();
    init_AxiosError();
    init_spread();
    init_isAxiosError();
    init_AxiosHeaders();
    init_adapters();
    init_HttpStatusCode();
    axios = createInstance(defaults_default);
    axios.Axios = Axios_default;
    axios.CanceledError = CanceledError_default;
    axios.CancelToken = CancelToken_default;
    axios.isCancel = isCancel;
    axios.VERSION = VERSION;
    axios.toFormData = toFormData_default;
    axios.AxiosError = AxiosError_default;
    axios.Cancel = axios.CanceledError;
    axios.all = function all(promises6) {
      return Promise.all(promises6);
    };
    axios.spread = spread;
    axios.isAxiosError = isAxiosError;
    axios.mergeConfig = mergeConfig;
    axios.AxiosHeaders = AxiosHeaders_default;
    axios.formToJSON = (thing) => formDataToJSON_default(utils_default2.isHTMLForm(thing) ? new FormData(thing) : thing);
    axios.getAdapter = adapters_default.getAdapter;
    axios.HttpStatusCode = HttpStatusCode_default;
    axios.default = axios;
    axios_default = axios;
  }
});

// node_modules/axios/index.js
var Axios2, AxiosError2, CanceledError2, isCancel2, CancelToken2, VERSION2, all2, Cancel, isAxiosError2, spread2, toFormData2, AxiosHeaders2, HttpStatusCode2, formToJSON, getAdapter2, mergeConfig2;
var init_axios2 = __esm({
  "node_modules/axios/index.js"() {
    "use strict";
    init_axios();
    ({
      Axios: Axios2,
      AxiosError: AxiosError2,
      CanceledError: CanceledError2,
      isCancel: isCancel2,
      CancelToken: CancelToken2,
      VERSION: VERSION2,
      all: all2,
      Cancel,
      isAxiosError: isAxiosError2,
      spread: spread2,
      toFormData: toFormData2,
      AxiosHeaders: AxiosHeaders2,
      HttpStatusCode: HttpStatusCode2,
      formToJSON,
      getAdapter: getAdapter2,
      mergeConfig: mergeConfig2
    } = axios_default);
  }
});

// src/utils/error.ts
function normalizeError(error73) {
  if (isAxiosError2(error73)) {
    return {
      name: "AxiosError",
      message: error73.response?.data?.error?.message || error73.response?.data?.message || error73.message,
      code: error73.code,
      status: error73.response?.status,
      stack: error73.stack,
      responseData: error73.response?.data,
      meta: {
        url: error73.config?.url,
        method: error73.config?.method
      }
    };
  }
  if (error73 instanceof Error) {
    const serialized = serializeError(error73);
    return {
      name: serialized.name || "Error",
      message: serialized.message || "\u672A\u77E5\u9519\u8BEF",
      code: serialized.code,
      stack: serialized.stack,
      cause: error73.cause ? normalizeError(error73.cause) : void 0,
      meta: extractMeta(serialized)
    };
  }
  return {
    name: "UnknownError",
    message: String(error73),
    meta: { raw: serializeError(error73) }
  };
}
function extractMeta(obj) {
  const standardKeys = ["name", "message", "stack", "cause"];
  const meta4 = {};
  for (const [key, value] of Object.entries(obj)) {
    if (!standardKeys.includes(key) && value !== void 0) {
      meta4[key] = value;
    }
  }
  return Object.keys(meta4).length > 0 ? meta4 : void 0;
}
var error_default;
var init_error = __esm({
  "src/utils/error.ts"() {
    "use strict";
    init_serialize_error();
    init_axios2();
    error_default = normalizeError;
  }
});

// src/utils/stripThink.ts
function stripThink(text2) {
  return text2.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
}
var init_stripThink = __esm({
  "src/utils/stripThink.ts"() {
    "use strict";
  }
});

// src/lib/requestContext.ts
function runWithRequestContext(context2, fn) {
  return requestContext.run(context2, fn);
}
function getContextUserId() {
  const userId = requestContext.getStore()?.userId;
  return Number.isFinite(userId) ? userId : void 0;
}
var import_node_async_hooks, requestContext;
var init_requestContext = __esm({
  "src/lib/requestContext.ts"() {
    "use strict";
    import_node_async_hooks = require("node:async_hooks");
    requestContext = new import_node_async_hooks.AsyncLocalStorage();
  }
});

// src/lib/userConfig.ts
function requireRequestUserId(req) {
  const userId = Number(req.user?.id);
  if (!Number.isFinite(userId)) throw new Error("\u672A\u767B\u5F55");
  return userId;
}
function parseJson(value, fallback) {
  if (!value) return fallback;
  try {
    return JSON.parse(value);
  } catch {
    return fallback;
  }
}
async function upsert(table, where, patch) {
  const existing = await db_default(table).where(where).first();
  if (existing) {
    await db_default(table).where(where).update(patch);
    return;
  }
  await db_default(table).insert({ ...where, ...patch });
}
async function getUserSettingValue(key, userId = getContextUserId()) {
  if (userId) {
    const userSetting = await db_default("o_userSetting").where({ userId, key }).first();
    if (userSetting) return userSetting.value ?? "";
  }
  const setting = await db_default("o_setting").where({ key }).first();
  return setting?.value ?? void 0;
}
async function setUserSettingValue(userId, key, value) {
  await upsert("o_userSetting", { userId, key }, { value });
}
async function getVendorConfigForUser(vendorId, userId = getContextUserId()) {
  const base = await db_default("o_vendorConfig").where("id", vendorId).first();
  if (!base) return null;
  const userConfig = userId ? await db_default("o_userVendorConfig").where({ userId, vendorId }).first() : null;
  return {
    ...base,
    inputValues: userConfig?.inputValues ?? "{}",
    models: userConfig?.models ?? base.models ?? "[]",
    enable: userConfig?.enable ?? base.enable ?? 0
  };
}
async function getEnabledVendorIdsForUser(userId = getContextUserId()) {
  const baseRows = await db_default("o_vendorConfig").select("id", "enable");
  const userRows = userId ? await db_default("o_userVendorConfig").where({ userId }).select("vendorId", "enable") : [];
  const userEnableMap = new Map(userRows.map((row) => [row.vendorId, row.enable]));
  return baseRows.filter((row) => Number(userEnableMap.has(row.id) ? userEnableMap.get(row.id) : row.enable) === 1).map((row) => row.id).filter(Boolean);
}
async function setUserVendorConfig(userId, vendorId, patch) {
  await upsert("o_userVendorConfig", { userId, vendorId }, patch);
}
async function getEditableVendorModels(userId, vendorId) {
  const base = await db_default("o_vendorConfig").where("id", vendorId).first();
  const userConfig = await db_default("o_userVendorConfig").where({ userId, vendorId }).first();
  return parseJson(userConfig?.models ?? base?.models, []);
}
async function getAgentDeployForUser(key, userId = getContextUserId()) {
  const base = await db_default("o_agentDeploy").where({ key }).first();
  if (!base) return null;
  const userDeploy = userId ? await db_default("o_userAgentDeploy").where({ userId, key }).first() : null;
  return {
    ...base,
    model: userDeploy?.model ?? base.model,
    modelName: userDeploy?.modelName ?? base.modelName,
    vendorId: userDeploy?.vendorId ?? base.vendorId,
    temperature: userDeploy?.temperature ?? base.temperature,
    maxOutputTokens: userDeploy?.maxOutputTokens ?? base.maxOutputTokens,
    disabled: userDeploy?.disabled ?? base.disabled
  };
}
async function getAllAgentDeployForUser(userId) {
  const rows = await db_default("o_agentDeploy").select("*");
  const userRows = await db_default("o_userAgentDeploy").where({ userId }).select("*");
  const userMap = new Map(userRows.map((row) => [row.key, row]));
  return rows.map((row) => {
    const userRow = userMap.get(row.key);
    return {
      ...row,
      model: userRow?.model ?? row.model,
      modelName: userRow?.modelName ?? row.modelName,
      vendorId: userRow?.vendorId ?? row.vendorId,
      temperature: userRow?.temperature ?? row.temperature,
      maxOutputTokens: userRow?.maxOutputTokens ?? row.maxOutputTokens,
      disabled: userRow?.disabled ?? row.disabled
    };
  });
}
async function setUserAgentDeploy(userId, key, patch) {
  await upsert("o_userAgentDeploy", { userId, key }, patch);
}
async function getPromptForUser(type, userId = getContextUserId()) {
  const prompt = await db_default("o_prompt").where({ type }).first();
  if (!prompt) return null;
  const userPrompt = userId ? await db_default("o_userPrompt").where({ userId, promptId: prompt.id }).first() : null;
  return {
    ...prompt,
    data: userPrompt?.useData ?? prompt.useData ?? prompt.data,
    useData: userPrompt?.useData ?? null
  };
}
async function setUserPrompt(userId, promptId, useData) {
  await upsert("o_userPrompt", { userId, promptId }, { useData });
}
async function getModelPromptBindingForUser(vendorId, model, userId = getContextUserId()) {
  if (userId) {
    const userBinding = await db_default("o_userModelPrompt").where({ userId, vendorId, model }).first();
    if (userBinding) return { ...userBinding, scope: "user" };
  }
  const globalBinding = await db_default("o_modelPrompt").where({ vendorId, model }).first();
  return globalBinding ? { ...globalBinding, scope: "global" } : null;
}
async function getModelPromptBindingsForUser(vendorId, userId) {
  const globalRows = await db_default("o_modelPrompt").where({ vendorId }).select("*");
  const userRows = await db_default("o_userModelPrompt").where({ userId, vendorId }).select("*");
  const map3 = /* @__PURE__ */ new Map();
  for (const row of globalRows) {
    if (row.model) map3.set(row.model, { ...row, scope: "global" });
  }
  for (const row of userRows) {
    if (row.model) map3.set(row.model, { ...row, scope: "user" });
  }
  return [...map3.values()];
}
async function setUserModelPromptBinding(userId, vendorId, model, patch) {
  await upsert("o_userModelPrompt", { userId, vendorId, model }, patch);
}
var init_userConfig = __esm({
  "src/lib/userConfig.ts"() {
    "use strict";
    init_db();
    init_requestContext();
  }
});

// src/utils/cleanNovel.ts
var import_events2, CleanNovel, cleanNovel_default;
var init_cleanNovel = __esm({
  "src/utils/cleanNovel.ts"() {
    "use strict";
    import_events2 = require("events");
    init_utils3();
    init_stripThink();
    init_userConfig();
    CleanNovel = class {
      emitter;
      /** 最大并发数 */
      concurrency;
      constructor(concurrency = 5) {
        this.emitter = new import_events2.EventEmitter();
        this.concurrency = concurrency;
      }
      async processChapter(novel) {
        try {
          const prompt = await utils_default.getPrompts("event");
          const promptData = await getPromptForUser("eventExtraction");
          const eventExtraction = promptData?.data ?? void 0;
          const resData = await utils_default.Ai.Text("universalAi").invoke({
            system: eventExtraction ? JSON.stringify(eventExtraction) : prompt,
            messages: [
              {
                role: "user",
                content: "\u8BF7\u6839\u636E\u4EE5\u4E0B\u5C0F\u8BF4\u7AE0\u8282\u6570\uFF1A" + novel.chapterIndex + "\u5C0F\u8BF4\u7AE0\u8282\u5238\uFF1A" + novel.reel + "\u5C0F\u8BF4\u7AE0\u8282\u540D\u79F0\uFF1A" + novel.chapter + "\u3001\u5C0F\u8BF4\u7AE0\u8282\u5185\u5BB9\u751F\u6210\u4E8B\u4EF6\u6458\u8981\uFF1A\n" + novel.chapterData
              }
            ]
          });
          const preData = stripThink(resData.text);
          this.emitter.emit("item", { id: novel.id, event: preData });
          return { id: novel.id, event: preData };
        } catch (e) {
          this.emitter.emit("item", { id: novel.id, event: null, errorReason: utils_default.error(e).message });
          return null;
        }
      }
      async start(allChapters, projectId) {
        const totalEvent = [];
        let running = 0;
        let index = 0;
        const results = [];
        const runNext = () => {
          if (index >= allChapters.length) return Promise.resolve();
          const novel = allChapters[index++];
          running++;
          return this.processChapter(novel).then((result) => {
            if (result) totalEvent.push(result);
            running--;
            return runNext();
          });
        };
        const workers = Array.from({ length: Math.min(this.concurrency, allChapters.length) }, () => runNext());
        await Promise.all(workers);
        return totalEvent;
      }
    };
    cleanNovel_default = CleanNovel;
  }
});

// node_modules/@ai-sdk/provider/dist/index.mjs
function getErrorMessage(error73) {
  if (error73 == null) {
    return "unknown error";
  }
  if (typeof error73 === "string") {
    return error73;
  }
  if (error73 instanceof Error) {
    return error73.message;
  }
  return JSON.stringify(error73);
}
var marker, symbol, _a, _b, AISDKError, name, marker2, symbol2, _a2, _b2, APICallError, name2, marker3, symbol3, _a3, _b3, EmptyResponseBodyError, name3, marker4, symbol4, _a4, _b4, InvalidArgumentError, name4, marker5, symbol5, _a5, _b5, InvalidPromptError, name5, marker6, symbol6, _a6, _b6, InvalidResponseDataError, name6, marker7, symbol7, _a7, _b7, JSONParseError, name7, marker8, symbol8, _a8, _b8, LoadAPIKeyError, name8, marker9, symbol9, _a9, _b9, LoadSettingError, name9, marker10, symbol10, _a10, _b10, NoContentGeneratedError, name10, marker11, symbol11, _a11, _b11, NoSuchModelError, name11, marker12, symbol12, _a12, _b12, TooManyEmbeddingValuesForCallError, name12, marker13, symbol13, _a13, _b13, TypeValidationError, name13, marker14, symbol14, _a14, _b14, UnsupportedFunctionalityError;
var init_dist3 = __esm({
  "node_modules/@ai-sdk/provider/dist/index.mjs"() {
    "use strict";
    marker = "vercel.ai.error";
    symbol = Symbol.for(marker);
    AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
      /**
       * Creates an AI SDK Error.
       *
       * @param {Object} params - The parameters for creating the error.
       * @param {string} params.name - The name of the error.
       * @param {string} params.message - The error message.
       * @param {unknown} [params.cause] - The underlying cause of the error.
       */
      constructor({
        name: name143,
        message,
        cause
      }) {
        super(message);
        this[_a] = true;
        this.name = name143;
        this.cause = cause;
      }
      /**
       * Checks if the given error is an AI SDK Error.
       * @param {unknown} error - The error to check.
       * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
       */
      static isInstance(error73) {
        return _AISDKError.hasMarker(error73, marker);
      }
      static hasMarker(error73, marker153) {
        const markerSymbol = Symbol.for(marker153);
        return error73 != null && typeof error73 === "object" && markerSymbol in error73 && typeof error73[markerSymbol] === "boolean" && error73[markerSymbol] === true;
      }
    };
    name = "AI_APICallError";
    marker2 = `vercel.ai.error.${name}`;
    symbol2 = Symbol.for(marker2);
    APICallError = class extends (_b2 = AISDKError, _a2 = symbol2, _b2) {
      constructor({
        message,
        url: url4,
        requestBodyValues,
        statusCode,
        responseHeaders,
        responseBody,
        cause,
        isRetryable = statusCode != null && (statusCode === 408 || // request timeout
        statusCode === 409 || // conflict
        statusCode === 429 || // too many requests
        statusCode >= 500),
        // server error
        data
      }) {
        super({ name, message, cause });
        this[_a2] = true;
        this.url = url4;
        this.requestBodyValues = requestBodyValues;
        this.statusCode = statusCode;
        this.responseHeaders = responseHeaders;
        this.responseBody = responseBody;
        this.isRetryable = isRetryable;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker2);
      }
    };
    name2 = "AI_EmptyResponseBodyError";
    marker3 = `vercel.ai.error.${name2}`;
    symbol3 = Symbol.for(marker3);
    EmptyResponseBodyError = class extends (_b3 = AISDKError, _a3 = symbol3, _b3) {
      // used in isInstance
      constructor({ message = "Empty response body" } = {}) {
        super({ name: name2, message });
        this[_a3] = true;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker3);
      }
    };
    name3 = "AI_InvalidArgumentError";
    marker4 = `vercel.ai.error.${name3}`;
    symbol4 = Symbol.for(marker4);
    InvalidArgumentError = class extends (_b4 = AISDKError, _a4 = symbol4, _b4) {
      constructor({
        message,
        cause,
        argument
      }) {
        super({ name: name3, message, cause });
        this[_a4] = true;
        this.argument = argument;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker4);
      }
    };
    name4 = "AI_InvalidPromptError";
    marker5 = `vercel.ai.error.${name4}`;
    symbol5 = Symbol.for(marker5);
    InvalidPromptError = class extends (_b5 = AISDKError, _a5 = symbol5, _b5) {
      constructor({
        prompt,
        message,
        cause
      }) {
        super({ name: name4, message: `Invalid prompt: ${message}`, cause });
        this[_a5] = true;
        this.prompt = prompt;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker5);
      }
    };
    name5 = "AI_InvalidResponseDataError";
    marker6 = `vercel.ai.error.${name5}`;
    symbol6 = Symbol.for(marker6);
    InvalidResponseDataError = class extends (_b6 = AISDKError, _a6 = symbol6, _b6) {
      constructor({
        data,
        message = `Invalid response data: ${JSON.stringify(data)}.`
      }) {
        super({ name: name5, message });
        this[_a6] = true;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker6);
      }
    };
    name6 = "AI_JSONParseError";
    marker7 = `vercel.ai.error.${name6}`;
    symbol7 = Symbol.for(marker7);
    JSONParseError = class extends (_b7 = AISDKError, _a7 = symbol7, _b7) {
      constructor({ text: text2, cause }) {
        super({
          name: name6,
          message: `JSON parsing failed: Text: ${text2}.
Error message: ${getErrorMessage(cause)}`,
          cause
        });
        this[_a7] = true;
        this.text = text2;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker7);
      }
    };
    name7 = "AI_LoadAPIKeyError";
    marker8 = `vercel.ai.error.${name7}`;
    symbol8 = Symbol.for(marker8);
    LoadAPIKeyError = class extends (_b8 = AISDKError, _a8 = symbol8, _b8) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name7, message });
        this[_a8] = true;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker8);
      }
    };
    name8 = "AI_LoadSettingError";
    marker9 = `vercel.ai.error.${name8}`;
    symbol9 = Symbol.for(marker9);
    LoadSettingError = class extends (_b9 = AISDKError, _a9 = symbol9, _b9) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name8, message });
        this[_a9] = true;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker9);
      }
    };
    name9 = "AI_NoContentGeneratedError";
    marker10 = `vercel.ai.error.${name9}`;
    symbol10 = Symbol.for(marker10);
    NoContentGeneratedError = class extends (_b10 = AISDKError, _a10 = symbol10, _b10) {
      // used in isInstance
      constructor({
        message = "No content generated."
      } = {}) {
        super({ name: name9, message });
        this[_a10] = true;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker10);
      }
    };
    name10 = "AI_NoSuchModelError";
    marker11 = `vercel.ai.error.${name10}`;
    symbol11 = Symbol.for(marker11);
    NoSuchModelError = class extends (_b11 = AISDKError, _a11 = symbol11, _b11) {
      constructor({
        errorName = name10,
        modelId,
        modelType,
        message = `No such ${modelType}: ${modelId}`
      }) {
        super({ name: errorName, message });
        this[_a11] = true;
        this.modelId = modelId;
        this.modelType = modelType;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker11);
      }
    };
    name11 = "AI_TooManyEmbeddingValuesForCallError";
    marker12 = `vercel.ai.error.${name11}`;
    symbol12 = Symbol.for(marker12);
    TooManyEmbeddingValuesForCallError = class extends (_b12 = AISDKError, _a12 = symbol12, _b12) {
      constructor(options) {
        super({
          name: name11,
          message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
        });
        this[_a12] = true;
        this.provider = options.provider;
        this.modelId = options.modelId;
        this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
        this.values = options.values;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker12);
      }
    };
    name12 = "AI_TypeValidationError";
    marker13 = `vercel.ai.error.${name12}`;
    symbol13 = Symbol.for(marker13);
    TypeValidationError = class _TypeValidationError extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
      constructor({
        value,
        cause,
        context: context2
      }) {
        let contextPrefix = "Type validation failed";
        if (context2 == null ? void 0 : context2.field) {
          contextPrefix += ` for ${context2.field}`;
        }
        if ((context2 == null ? void 0 : context2.entityName) || (context2 == null ? void 0 : context2.entityId)) {
          contextPrefix += " (";
          const parts = [];
          if (context2.entityName) {
            parts.push(context2.entityName);
          }
          if (context2.entityId) {
            parts.push(`id: "${context2.entityId}"`);
          }
          contextPrefix += parts.join(", ");
          contextPrefix += ")";
        }
        super({
          name: name12,
          message: `${contextPrefix}: Value: ${JSON.stringify(value)}.
Error message: ${getErrorMessage(cause)}`,
          cause
        });
        this[_a13] = true;
        this.value = value;
        this.context = context2;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker13);
      }
      /**
       * Wraps an error into a TypeValidationError.
       * If the cause is already a TypeValidationError with the same value and context, it returns the cause.
       * Otherwise, it creates a new TypeValidationError.
       *
       * @param {Object} params - The parameters for wrapping the error.
       * @param {unknown} params.value - The value that failed validation.
       * @param {unknown} params.cause - The original error or cause of the validation failure.
       * @param {TypeValidationContext} params.context - Optional context about what is being validated.
       * @returns {TypeValidationError} A TypeValidationError instance.
       */
      static wrap({
        value,
        cause,
        context: context2
      }) {
        var _a153, _b152, _c;
        if (_TypeValidationError.isInstance(cause) && cause.value === value && ((_a153 = cause.context) == null ? void 0 : _a153.field) === (context2 == null ? void 0 : context2.field) && ((_b152 = cause.context) == null ? void 0 : _b152.entityName) === (context2 == null ? void 0 : context2.entityName) && ((_c = cause.context) == null ? void 0 : _c.entityId) === (context2 == null ? void 0 : context2.entityId)) {
          return cause;
        }
        return new _TypeValidationError({ value, cause, context: context2 });
      }
    };
    name13 = "AI_UnsupportedFunctionalityError";
    marker14 = `vercel.ai.error.${name13}`;
    symbol14 = Symbol.for(marker14);
    UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = symbol14, _b14) {
      constructor({
        functionality,
        message = `'${functionality}' functionality not supported.`
      }) {
        super({ name: name13, message });
        this[_a14] = true;
        this.functionality = functionality;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker14);
      }
    };
  }
});

// node_modules/zod/v4/core/core.js
// @__NO_SIDE_EFFECTS__
function $constructor(name28, initializer4, params) {
  function init(inst, def) {
    if (!inst._zod) {
      Object.defineProperty(inst, "_zod", {
        value: {
          def,
          constr: _,
          traits: /* @__PURE__ */ new Set()
        },
        enumerable: false
      });
    }
    if (inst._zod.traits.has(name28)) {
      return;
    }
    inst._zod.traits.add(name28);
    initializer4(inst, def);
    const proto = _.prototype;
    const keys2 = Object.keys(proto);
    for (let i = 0; i < keys2.length; i++) {
      const k = keys2[i];
      if (!(k in inst)) {
        inst[k] = proto[k].bind(inst);
      }
    }
  }
  const Parent = params?.Parent ?? Object;
  class Definition extends Parent {
  }
  Object.defineProperty(Definition, "name", { value: name28 });
  function _(def) {
    var _a31;
    const inst = params?.Parent ? new Definition() : this;
    init(inst, def);
    (_a31 = inst._zod).deferred ?? (_a31.deferred = []);
    for (const fn of inst._zod.deferred) {
      fn();
    }
    return inst;
  }
  Object.defineProperty(_, "init", { value: init });
  Object.defineProperty(_, Symbol.hasInstance, {
    value: (inst) => {
      if (params?.Parent && inst instanceof params.Parent)
        return true;
      return inst?._zod?.traits?.has(name28);
    }
  });
  Object.defineProperty(_, "name", { value: name28 });
  return _;
}
function config(newConfig) {
  if (newConfig)
    Object.assign(globalConfig, newConfig);
  return globalConfig;
}
var NEVER, $brand, $ZodAsyncError, $ZodEncodeError, globalConfig;
var init_core = __esm({
  "node_modules/zod/v4/core/core.js"() {
    "use strict";
    NEVER = Object.freeze({
      status: "aborted"
    });
    $brand = /* @__PURE__ */ Symbol("zod_brand");
    $ZodAsyncError = class extends Error {
      constructor() {
        super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
      }
    };
    $ZodEncodeError = class extends Error {
      constructor(name28) {
        super(`Encountered unidirectional transform during encode: ${name28}`);
        this.name = "ZodEncodeError";
      }
    };
    globalConfig = {};
  }
});

// node_modules/zod/v4/core/util.js
var util_exports = {};
__export(util_exports, {
  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
  Class: () => Class,
  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
  aborted: () => aborted,
  allowsEval: () => allowsEval,
  assert: () => assert,
  assertEqual: () => assertEqual,
  assertIs: () => assertIs,
  assertNever: () => assertNever,
  assertNotEqual: () => assertNotEqual,
  assignProp: () => assignProp,
  base64ToUint8Array: () => base64ToUint8Array,
  base64urlToUint8Array: () => base64urlToUint8Array,
  cached: () => cached,
  captureStackTrace: () => captureStackTrace,
  cleanEnum: () => cleanEnum,
  cleanRegex: () => cleanRegex,
  clone: () => clone,
  cloneDef: () => cloneDef,
  createTransparentProxy: () => createTransparentProxy,
  defineLazy: () => defineLazy,
  esc: () => esc,
  escapeRegex: () => escapeRegex,
  extend: () => extend2,
  finalizeIssue: () => finalizeIssue,
  floatSafeRemainder: () => floatSafeRemainder,
  getElementAtPath: () => getElementAtPath,
  getEnumValues: () => getEnumValues,
  getLengthableOrigin: () => getLengthableOrigin,
  getParsedType: () => getParsedType,
  getSizableOrigin: () => getSizableOrigin,
  hexToUint8Array: () => hexToUint8Array,
  isObject: () => isObject3,
  isPlainObject: () => isPlainObject2,
  issue: () => issue,
  joinValues: () => joinValues,
  jsonStringifyReplacer: () => jsonStringifyReplacer,
  merge: () => merge2,
  mergeDefs: () => mergeDefs,
  normalizeParams: () => normalizeParams,
  nullish: () => nullish,
  numKeys: () => numKeys,
  objectClone: () => objectClone,
  omit: () => omit,
  optionalKeys: () => optionalKeys,
  parsedType: () => parsedType,
  partial: () => partial,
  pick: () => pick,
  prefixIssues: () => prefixIssues,
  primitiveTypes: () => primitiveTypes,
  promiseAllObject: () => promiseAllObject,
  propertyKeyTypes: () => propertyKeyTypes,
  randomString: () => randomString,
  required: () => required,
  safeExtend: () => safeExtend,
  shallowClone: () => shallowClone,
  slugify: () => slugify,
  stringifyPrimitive: () => stringifyPrimitive,
  uint8ArrayToBase64: () => uint8ArrayToBase64,
  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
  uint8ArrayToHex: () => uint8ArrayToHex,
  unwrapMessage: () => unwrapMessage
});
function assertEqual(val) {
  return val;
}
function assertNotEqual(val) {
  return val;
}
function assertIs(_arg) {
}
function assertNever(_x) {
  throw new Error("Unexpected value in exhaustive check");
}
function assert(_) {
}
function getEnumValues(entries) {
  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
  return values;
}
function joinValues(array4, separator = "|") {
  return array4.map((val) => stringifyPrimitive(val)).join(separator);
}
function jsonStringifyReplacer(_, value) {
  if (typeof value === "bigint")
    return value.toString();
  return value;
}
function cached(getter) {
  const set3 = false;
  return {
    get value() {
      if (!set3) {
        const value = getter();
        Object.defineProperty(this, "value", { value });
        return value;
      }
      throw new Error("cached value already set");
    }
  };
}
function nullish(input) {
  return input === null || input === void 0;
}
function cleanRegex(source) {
  const start = source.startsWith("^") ? 1 : 0;
  const end = source.endsWith("$") ? source.length - 1 : source.length;
  return source.slice(start, end);
}
function floatSafeRemainder(val, step) {
  const valDecCount = (val.toString().split(".")[1] || "").length;
  const stepString = step.toString();
  let stepDecCount = (stepString.split(".")[1] || "").length;
  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
    const match = stepString.match(/\d?e-(\d?)/);
    if (match?.[1]) {
      stepDecCount = Number.parseInt(match[1]);
    }
  }
  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
  return valInt % stepInt / 10 ** decCount;
}
function defineLazy(object4, key, getter) {
  let value = void 0;
  Object.defineProperty(object4, key, {
    get() {
      if (value === EVALUATING) {
        return void 0;
      }
      if (value === void 0) {
        value = EVALUATING;
        value = getter();
      }
      return value;
    },
    set(v) {
      Object.defineProperty(object4, key, {
        value: v
        // configurable: true,
      });
    },
    configurable: true
  });
}
function objectClone(obj) {
  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
}
function assignProp(target, prop, value) {
  Object.defineProperty(target, prop, {
    value,
    writable: true,
    enumerable: true,
    configurable: true
  });
}
function mergeDefs(...defs) {
  const mergedDescriptors = {};
  for (const def of defs) {
    const descriptors = Object.getOwnPropertyDescriptors(def);
    Object.assign(mergedDescriptors, descriptors);
  }
  return Object.defineProperties({}, mergedDescriptors);
}
function cloneDef(schema) {
  return mergeDefs(schema._zod.def);
}
function getElementAtPath(obj, path33) {
  if (!path33)
    return obj;
  return path33.reduce((acc, key) => acc?.[key], obj);
}
function promiseAllObject(promisesObj) {
  const keys2 = Object.keys(promisesObj);
  const promises6 = keys2.map((key) => promisesObj[key]);
  return Promise.all(promises6).then((results) => {
    const resolvedObj = {};
    for (let i = 0; i < keys2.length; i++) {
      resolvedObj[keys2[i]] = results[i];
    }
    return resolvedObj;
  });
}
function randomString(length = 10) {
  const chars = "abcdefghijklmnopqrstuvwxyz";
  let str = "";
  for (let i = 0; i < length; i++) {
    str += chars[Math.floor(Math.random() * chars.length)];
  }
  return str;
}
function esc(str) {
  return JSON.stringify(str);
}
function slugify(input) {
  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
}
function isObject3(data) {
  return typeof data === "object" && data !== null && !Array.isArray(data);
}
function isPlainObject2(o) {
  if (isObject3(o) === false)
    return false;
  const ctor = o.constructor;
  if (ctor === void 0)
    return true;
  if (typeof ctor !== "function")
    return true;
  const prot = ctor.prototype;
  if (isObject3(prot) === false)
    return false;
  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
    return false;
  }
  return true;
}
function shallowClone(o) {
  if (isPlainObject2(o))
    return { ...o };
  if (Array.isArray(o))
    return [...o];
  return o;
}
function numKeys(data) {
  let keyCount = 0;
  for (const key in data) {
    if (Object.prototype.hasOwnProperty.call(data, key)) {
      keyCount++;
    }
  }
  return keyCount;
}
function escapeRegex(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone(inst, def, params) {
  const cl = new inst._zod.constr(def ?? inst._zod.def);
  if (!def || params?.parent)
    cl._zod.parent = inst;
  return cl;
}
function normalizeParams(_params) {
  const params = _params;
  if (!params)
    return {};
  if (typeof params === "string")
    return { error: () => params };
  if (params?.message !== void 0) {
    if (params?.error !== void 0)
      throw new Error("Cannot specify both `message` and `error` params");
    params.error = params.message;
  }
  delete params.message;
  if (typeof params.error === "string")
    return { ...params, error: () => params.error };
  return params;
}
function createTransparentProxy(getter) {
  let target;
  return new Proxy({}, {
    get(_, prop, receiver) {
      target ?? (target = getter());
      return Reflect.get(target, prop, receiver);
    },
    set(_, prop, value, receiver) {
      target ?? (target = getter());
      return Reflect.set(target, prop, value, receiver);
    },
    has(_, prop) {
      target ?? (target = getter());
      return Reflect.has(target, prop);
    },
    deleteProperty(_, prop) {
      target ?? (target = getter());
      return Reflect.deleteProperty(target, prop);
    },
    ownKeys(_) {
      target ?? (target = getter());
      return Reflect.ownKeys(target);
    },
    getOwnPropertyDescriptor(_, prop) {
      target ?? (target = getter());
      return Reflect.getOwnPropertyDescriptor(target, prop);
    },
    defineProperty(_, prop, descriptor) {
      target ?? (target = getter());
      return Reflect.defineProperty(target, prop, descriptor);
    }
  });
}
function stringifyPrimitive(value) {
  if (typeof value === "bigint")
    return value.toString() + "n";
  if (typeof value === "string")
    return `"${value}"`;
  return `${value}`;
}
function optionalKeys(shape) {
  return Object.keys(shape).filter((k) => {
    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
  });
}
function pick(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".pick() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const newShape = {};
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        newShape[key] = currDef.shape[key];
      }
      assignProp(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone(schema, def);
}
function omit(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".omit() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const newShape = { ...schema._zod.def.shape };
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        delete newShape[key];
      }
      assignProp(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone(schema, def);
}
function extend2(schema, shape) {
  if (!isPlainObject2(shape)) {
    throw new Error("Invalid input to extend: expected a plain object");
  }
  const checks = schema._zod.def.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    const existingShape = schema._zod.def.shape;
    for (const key in shape) {
      if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
      }
    }
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp(this, "shape", _shape);
      return _shape;
    }
  });
  return clone(schema, def);
}
function safeExtend(schema, shape) {
  if (!isPlainObject2(shape)) {
    throw new Error("Invalid input to safeExtend: expected a plain object");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp(this, "shape", _shape);
      return _shape;
    }
  });
  return clone(schema, def);
}
function merge2(a, b) {
  const def = mergeDefs(a._zod.def, {
    get shape() {
      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
      assignProp(this, "shape", _shape);
      return _shape;
    },
    get catchall() {
      return b._zod.def.catchall;
    },
    checks: []
    // delete existing checks
  });
  return clone(a, def);
}
function partial(Class3, schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".partial() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in oldShape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = Class3 ? new Class3({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      } else {
        for (const key in oldShape) {
          shape[key] = Class3 ? new Class3({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      }
      assignProp(this, "shape", shape);
      return shape;
    },
    checks: []
  });
  return clone(schema, def);
}
function required(Class3, schema, mask) {
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in shape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = new Class3({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      } else {
        for (const key in oldShape) {
          shape[key] = new Class3({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      }
      assignProp(this, "shape", shape);
      return shape;
    }
  });
  return clone(schema, def);
}
function aborted(x, startIndex = 0) {
  if (x.aborted === true)
    return true;
  for (let i = startIndex; i < x.issues.length; i++) {
    if (x.issues[i]?.continue !== true) {
      return true;
    }
  }
  return false;
}
function prefixIssues(path33, issues) {
  return issues.map((iss) => {
    var _a31;
    (_a31 = iss).path ?? (_a31.path = []);
    iss.path.unshift(path33);
    return iss;
  });
}
function unwrapMessage(message) {
  return typeof message === "string" ? message : message?.message;
}
function finalizeIssue(iss, ctx, config3) {
  const full = { ...iss, path: iss.path ?? [] };
  if (!iss.message) {
    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config3.customError?.(iss)) ?? unwrapMessage(config3.localeError?.(iss)) ?? "Invalid input";
    full.message = message;
  }
  delete full.inst;
  delete full.continue;
  if (!ctx?.reportInput) {
    delete full.input;
  }
  return full;
}
function getSizableOrigin(input) {
  if (input instanceof Set)
    return "set";
  if (input instanceof Map)
    return "map";
  if (input instanceof File)
    return "file";
  return "unknown";
}
function getLengthableOrigin(input) {
  if (Array.isArray(input))
    return "array";
  if (typeof input === "string")
    return "string";
  return "unknown";
}
function parsedType(data) {
  const t = typeof data;
  switch (t) {
    case "number": {
      return Number.isNaN(data) ? "nan" : "number";
    }
    case "object": {
      if (data === null) {
        return "null";
      }
      if (Array.isArray(data)) {
        return "array";
      }
      const obj = data;
      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
        return obj.constructor.name;
      }
    }
  }
  return t;
}
function issue(...args) {
  const [iss, input, inst] = args;
  if (typeof iss === "string") {
    return {
      message: iss,
      code: "custom",
      input,
      inst
    };
  }
  return { ...iss };
}
function cleanEnum(obj) {
  return Object.entries(obj).filter(([k, _]) => {
    return Number.isNaN(Number.parseInt(k, 10));
  }).map((el) => el[1]);
}
function base64ToUint8Array(base644) {
  const binaryString = atob(base644);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  return bytes;
}
function uint8ArrayToBase64(bytes) {
  let binaryString = "";
  for (let i = 0; i < bytes.length; i++) {
    binaryString += String.fromCharCode(bytes[i]);
  }
  return btoa(binaryString);
}
function base64urlToUint8Array(base64url4) {
  const base644 = base64url4.replace(/-/g, "+").replace(/_/g, "/");
  const padding = "=".repeat((4 - base644.length % 4) % 4);
  return base64ToUint8Array(base644 + padding);
}
function uint8ArrayToBase64url(bytes) {
  return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
}
function hexToUint8Array(hex4) {
  const cleanHex = hex4.replace(/^0x/, "");
  if (cleanHex.length % 2 !== 0) {
    throw new Error("Invalid hex string length");
  }
  const bytes = new Uint8Array(cleanHex.length / 2);
  for (let i = 0; i < cleanHex.length; i += 2) {
    bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
  }
  return bytes;
}
function uint8ArrayToHex(bytes) {
  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
}
var EVALUATING, captureStackTrace, allowsEval, getParsedType, propertyKeyTypes, primitiveTypes, NUMBER_FORMAT_RANGES, BIGINT_FORMAT_RANGES, Class;
var init_util = __esm({
  "node_modules/zod/v4/core/util.js"() {
    "use strict";
    EVALUATING = /* @__PURE__ */ Symbol("evaluating");
    captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
    };
    allowsEval = cached(() => {
      if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
        return false;
      }
      try {
        const F = Function;
        new F("");
        return true;
      } catch (_) {
        return false;
      }
    });
    getParsedType = (data) => {
      const t = typeof data;
      switch (t) {
        case "undefined":
          return "undefined";
        case "string":
          return "string";
        case "number":
          return Number.isNaN(data) ? "nan" : "number";
        case "boolean":
          return "boolean";
        case "function":
          return "function";
        case "bigint":
          return "bigint";
        case "symbol":
          return "symbol";
        case "object":
          if (Array.isArray(data)) {
            return "array";
          }
          if (data === null) {
            return "null";
          }
          if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
            return "promise";
          }
          if (typeof Map !== "undefined" && data instanceof Map) {
            return "map";
          }
          if (typeof Set !== "undefined" && data instanceof Set) {
            return "set";
          }
          if (typeof Date !== "undefined" && data instanceof Date) {
            return "date";
          }
          if (typeof File !== "undefined" && data instanceof File) {
            return "file";
          }
          return "object";
        default:
          throw new Error(`Unknown data type: ${t}`);
      }
    };
    propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
    primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
    NUMBER_FORMAT_RANGES = {
      safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
      int32: [-2147483648, 2147483647],
      uint32: [0, 4294967295],
      float32: [-34028234663852886e22, 34028234663852886e22],
      float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
    };
    BIGINT_FORMAT_RANGES = {
      int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
      uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
    };
    Class = class {
      constructor(..._args) {
      }
    };
  }
});

// node_modules/zod/v4/core/errors.js
function flattenError(error73, mapper = (issue3) => issue3.message) {
  const fieldErrors = {};
  const formErrors = [];
  for (const sub of error73.issues) {
    if (sub.path.length > 0) {
      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
      fieldErrors[sub.path[0]].push(mapper(sub));
    } else {
      formErrors.push(mapper(sub));
    }
  }
  return { formErrors, fieldErrors };
}
function formatError(error73, mapper = (issue3) => issue3.message) {
  const fieldErrors = { _errors: [] };
  const processError = (error74) => {
    for (const issue3 of error74.issues) {
      if (issue3.code === "invalid_union" && issue3.errors.length) {
        issue3.errors.map((issues) => processError({ issues }));
      } else if (issue3.code === "invalid_key") {
        processError({ issues: issue3.issues });
      } else if (issue3.code === "invalid_element") {
        processError({ issues: issue3.issues });
      } else if (issue3.path.length === 0) {
        fieldErrors._errors.push(mapper(issue3));
      } else {
        let curr = fieldErrors;
        let i = 0;
        while (i < issue3.path.length) {
          const el = issue3.path[i];
          const terminal = i === issue3.path.length - 1;
          if (!terminal) {
            curr[el] = curr[el] || { _errors: [] };
          } else {
            curr[el] = curr[el] || { _errors: [] };
            curr[el]._errors.push(mapper(issue3));
          }
          curr = curr[el];
          i++;
        }
      }
    }
  };
  processError(error73);
  return fieldErrors;
}
function treeifyError(error73, mapper = (issue3) => issue3.message) {
  const result = { errors: [] };
  const processError = (error74, path33 = []) => {
    var _a31, _b27;
    for (const issue3 of error74.issues) {
      if (issue3.code === "invalid_union" && issue3.errors.length) {
        issue3.errors.map((issues) => processError({ issues }, issue3.path));
      } else if (issue3.code === "invalid_key") {
        processError({ issues: issue3.issues }, issue3.path);
      } else if (issue3.code === "invalid_element") {
        processError({ issues: issue3.issues }, issue3.path);
      } else {
        const fullpath = [...path33, ...issue3.path];
        if (fullpath.length === 0) {
          result.errors.push(mapper(issue3));
          continue;
        }
        let curr = result;
        let i = 0;
        while (i < fullpath.length) {
          const el = fullpath[i];
          const terminal = i === fullpath.length - 1;
          if (typeof el === "string") {
            curr.properties ?? (curr.properties = {});
            (_a31 = curr.properties)[el] ?? (_a31[el] = { errors: [] });
            curr = curr.properties[el];
          } else {
            curr.items ?? (curr.items = []);
            (_b27 = curr.items)[el] ?? (_b27[el] = { errors: [] });
            curr = curr.items[el];
          }
          if (terminal) {
            curr.errors.push(mapper(issue3));
          }
          i++;
        }
      }
    }
  };
  processError(error73);
  return result;
}
function toDotPath(_path) {
  const segs = [];
  const path33 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
  for (const seg of path33) {
    if (typeof seg === "number")
      segs.push(`[${seg}]`);
    else if (typeof seg === "symbol")
      segs.push(`[${JSON.stringify(String(seg))}]`);
    else if (/[^\w$]/.test(seg))
      segs.push(`[${JSON.stringify(seg)}]`);
    else {
      if (segs.length)
        segs.push(".");
      segs.push(seg);
    }
  }
  return segs.join("");
}
function prettifyError(error73) {
  const lines = [];
  const issues = [...error73.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
  for (const issue3 of issues) {
    lines.push(`\u2716 ${issue3.message}`);
    if (issue3.path?.length)
      lines.push(`  \u2192 at ${toDotPath(issue3.path)}`);
  }
  return lines.join("\n");
}
var initializer, $ZodError, $ZodRealError;
var init_errors = __esm({
  "node_modules/zod/v4/core/errors.js"() {
    "use strict";
    init_core();
    init_util();
    initializer = (inst, def) => {
      inst.name = "$ZodError";
      Object.defineProperty(inst, "_zod", {
        value: inst._zod,
        enumerable: false
      });
      Object.defineProperty(inst, "issues", {
        value: def,
        enumerable: false
      });
      inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
      Object.defineProperty(inst, "toString", {
        value: () => inst.message,
        enumerable: false
      });
    };
    $ZodError = $constructor("$ZodError", initializer);
    $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
  }
});

// node_modules/zod/v4/core/parse.js
var _parse, parse, _parseAsync, parseAsync, _safeParse, safeParse, _safeParseAsync, safeParseAsync, _encode, encode3, _decode, decode, _encodeAsync, encodeAsync, _decodeAsync, decodeAsync, _safeEncode, safeEncode, _safeDecode, safeDecode, _safeEncodeAsync, safeEncodeAsync, _safeDecodeAsync, safeDecodeAsync;
var init_parse = __esm({
  "node_modules/zod/v4/core/parse.js"() {
    "use strict";
    init_core();
    init_errors();
    init_util();
    _parse = (_Err) => (schema, value, _ctx, _params) => {
      const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
      const result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise) {
        throw new $ZodAsyncError();
      }
      if (result.issues.length) {
        const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
        captureStackTrace(e, _params?.callee);
        throw e;
      }
      return result.value;
    };
    parse = /* @__PURE__ */ _parse($ZodRealError);
    _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
      const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
      let result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise)
        result = await result;
      if (result.issues.length) {
        const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
        captureStackTrace(e, params?.callee);
        throw e;
      }
      return result.value;
    };
    parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
    _safeParse = (_Err) => (schema, value, _ctx) => {
      const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
      const result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise) {
        throw new $ZodAsyncError();
      }
      return result.issues.length ? {
        success: false,
        error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
      } : { success: true, data: result.value };
    };
    safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
    _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
      let result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise)
        result = await result;
      return result.issues.length ? {
        success: false,
        error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
      } : { success: true, data: result.value };
    };
    safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
    _encode = (_Err) => (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return _parse(_Err)(schema, value, ctx);
    };
    encode3 = /* @__PURE__ */ _encode($ZodRealError);
    _decode = (_Err) => (schema, value, _ctx) => {
      return _parse(_Err)(schema, value, _ctx);
    };
    decode = /* @__PURE__ */ _decode($ZodRealError);
    _encodeAsync = (_Err) => async (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return _parseAsync(_Err)(schema, value, ctx);
    };
    encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
    _decodeAsync = (_Err) => async (schema, value, _ctx) => {
      return _parseAsync(_Err)(schema, value, _ctx);
    };
    decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
    _safeEncode = (_Err) => (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return _safeParse(_Err)(schema, value, ctx);
    };
    safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
    _safeDecode = (_Err) => (schema, value, _ctx) => {
      return _safeParse(_Err)(schema, value, _ctx);
    };
    safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
    _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return _safeParseAsync(_Err)(schema, value, ctx);
    };
    safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
    _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
      return _safeParseAsync(_Err)(schema, value, _ctx);
    };
    safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
  }
});

// node_modules/zod/v4/core/regexes.js
var regexes_exports = {};
__export(regexes_exports, {
  base64: () => base64,
  base64url: () => base64url,
  bigint: () => bigint,
  boolean: () => boolean,
  browserEmail: () => browserEmail,
  cidrv4: () => cidrv4,
  cidrv6: () => cidrv6,
  cuid: () => cuid,
  cuid2: () => cuid2,
  date: () => date,
  datetime: () => datetime,
  domain: () => domain,
  duration: () => duration,
  e164: () => e164,
  email: () => email,
  emoji: () => emoji,
  extendedDuration: () => extendedDuration,
  guid: () => guid,
  hex: () => hex,
  hostname: () => hostname,
  html5Email: () => html5Email,
  idnEmail: () => idnEmail,
  integer: () => integer,
  ipv4: () => ipv4,
  ipv6: () => ipv6,
  ksuid: () => ksuid,
  lowercase: () => lowercase,
  mac: () => mac,
  md5_base64: () => md5_base64,
  md5_base64url: () => md5_base64url,
  md5_hex: () => md5_hex,
  nanoid: () => nanoid,
  null: () => _null,
  number: () => number,
  rfc5322Email: () => rfc5322Email,
  sha1_base64: () => sha1_base64,
  sha1_base64url: () => sha1_base64url,
  sha1_hex: () => sha1_hex,
  sha256_base64: () => sha256_base64,
  sha256_base64url: () => sha256_base64url,
  sha256_hex: () => sha256_hex,
  sha384_base64: () => sha384_base64,
  sha384_base64url: () => sha384_base64url,
  sha384_hex: () => sha384_hex,
  sha512_base64: () => sha512_base64,
  sha512_base64url: () => sha512_base64url,
  sha512_hex: () => sha512_hex,
  string: () => string,
  time: () => time,
  ulid: () => ulid,
  undefined: () => _undefined,
  unicodeEmail: () => unicodeEmail,
  uppercase: () => uppercase,
  uuid: () => uuid,
  uuid4: () => uuid4,
  uuid6: () => uuid6,
  uuid7: () => uuid7,
  xid: () => xid
});
function emoji() {
  return new RegExp(_emoji, "u");
}
function timeSource(args) {
  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
  return regex;
}
function time(args) {
  return new RegExp(`^${timeSource(args)}$`);
}
function datetime(args) {
  const time4 = timeSource({ precision: args.precision });
  const opts = ["Z"];
  if (args.local)
    opts.push("");
  if (args.offset)
    opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
  const timeRegex2 = `${time4}(?:${opts.join("|")})`;
  return new RegExp(`^${dateSource}T(?:${timeRegex2})$`);
}
function fixedBase64(bodyLength, padding) {
  return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
}
function fixedBase64url(length) {
  return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
}
var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, extendedDuration, guid, uuid, uuid4, uuid6, uuid7, email, html5Email, rfc5322Email, unicodeEmail, idnEmail, browserEmail, _emoji, ipv4, ipv6, mac, cidrv4, cidrv6, base64, base64url, hostname, domain, e164, dateSource, date, string, bigint, integer, number, boolean, _null, _undefined, lowercase, uppercase, hex, md5_hex, md5_base64, md5_base64url, sha1_hex, sha1_base64, sha1_base64url, sha256_hex, sha256_base64, sha256_base64url, sha384_hex, sha384_base64, sha384_base64url, sha512_hex, sha512_base64, sha512_base64url;
var init_regexes = __esm({
  "node_modules/zod/v4/core/regexes.js"() {
    "use strict";
    init_util();
    cuid = /^[cC][^\s-]{8,}$/;
    cuid2 = /^[0-9a-z]+$/;
    ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
    xid = /^[0-9a-vA-V]{20}$/;
    ksuid = /^[A-Za-z0-9]{27}$/;
    nanoid = /^[a-zA-Z0-9_-]{21}$/;
    duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
    extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
    guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
    uuid = (version3) => {
      if (!version3)
        return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
      return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version3}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
    };
    uuid4 = /* @__PURE__ */ uuid(4);
    uuid6 = /* @__PURE__ */ uuid(6);
    uuid7 = /* @__PURE__ */ uuid(7);
    email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
    html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
    rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
    idnEmail = unicodeEmail;
    browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
    _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
    ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
    ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
    mac = (delimiter) => {
      const escapedDelim = escapeRegex(delimiter ?? ":");
      return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
    };
    cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
    cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
    base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
    base64url = /^[A-Za-z0-9_-]*$/;
    hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
    domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
    e164 = /^\+[1-9]\d{6,14}$/;
    dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
    date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
    string = (params) => {
      const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
      return new RegExp(`^${regex}$`);
    };
    bigint = /^-?\d+n?$/;
    integer = /^-?\d+$/;
    number = /^-?\d+(?:\.\d+)?$/;
    boolean = /^(?:true|false)$/i;
    _null = /^null$/i;
    _undefined = /^undefined$/i;
    lowercase = /^[^A-Z]*$/;
    uppercase = /^[^a-z]*$/;
    hex = /^[0-9a-fA-F]*$/;
    md5_hex = /^[0-9a-fA-F]{32}$/;
    md5_base64 = /* @__PURE__ */ fixedBase64(22, "==");
    md5_base64url = /* @__PURE__ */ fixedBase64url(22);
    sha1_hex = /^[0-9a-fA-F]{40}$/;
    sha1_base64 = /* @__PURE__ */ fixedBase64(27, "=");
    sha1_base64url = /* @__PURE__ */ fixedBase64url(27);
    sha256_hex = /^[0-9a-fA-F]{64}$/;
    sha256_base64 = /* @__PURE__ */ fixedBase64(43, "=");
    sha256_base64url = /* @__PURE__ */ fixedBase64url(43);
    sha384_hex = /^[0-9a-fA-F]{96}$/;
    sha384_base64 = /* @__PURE__ */ fixedBase64(64, "");
    sha384_base64url = /* @__PURE__ */ fixedBase64url(64);
    sha512_hex = /^[0-9a-fA-F]{128}$/;
    sha512_base64 = /* @__PURE__ */ fixedBase64(86, "==");
    sha512_base64url = /* @__PURE__ */ fixedBase64url(86);
  }
});

// node_modules/zod/v4/core/checks.js
function handleCheckPropertyResult(result, payload, property2) {
  if (result.issues.length) {
    payload.issues.push(...prefixIssues(property2, result.issues));
  }
}
var $ZodCheck, numericOriginMap, $ZodCheckLessThan, $ZodCheckGreaterThan, $ZodCheckMultipleOf, $ZodCheckNumberFormat, $ZodCheckBigIntFormat, $ZodCheckMaxSize, $ZodCheckMinSize, $ZodCheckSizeEquals, $ZodCheckMaxLength, $ZodCheckMinLength, $ZodCheckLengthEquals, $ZodCheckStringFormat, $ZodCheckRegex, $ZodCheckLowerCase, $ZodCheckUpperCase, $ZodCheckIncludes, $ZodCheckStartsWith, $ZodCheckEndsWith, $ZodCheckProperty, $ZodCheckMimeType, $ZodCheckOverwrite;
var init_checks = __esm({
  "node_modules/zod/v4/core/checks.js"() {
    "use strict";
    init_core();
    init_regexes();
    init_util();
    $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
      var _a31;
      inst._zod ?? (inst._zod = {});
      inst._zod.def = def;
      (_a31 = inst._zod).onattach ?? (_a31.onattach = []);
    });
    numericOriginMap = {
      number: "number",
      bigint: "bigint",
      object: "date"
    };
    $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
      $ZodCheck.init(inst, def);
      const origin2 = numericOriginMap[typeof def.value];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
        if (def.value < curr) {
          if (def.inclusive)
            bag.maximum = def.value;
          else
            bag.exclusiveMaximum = def.value;
        }
      });
      inst._zod.check = (payload) => {
        if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
          return;
        }
        payload.issues.push({
          origin: origin2,
          code: "too_big",
          maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
          input: payload.value,
          inclusive: def.inclusive,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
      $ZodCheck.init(inst, def);
      const origin2 = numericOriginMap[typeof def.value];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
        if (def.value > curr) {
          if (def.inclusive)
            bag.minimum = def.value;
          else
            bag.exclusiveMinimum = def.value;
        }
      });
      inst._zod.check = (payload) => {
        if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
          return;
        }
        payload.issues.push({
          origin: origin2,
          code: "too_small",
          minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
          input: payload.value,
          inclusive: def.inclusive,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
      $ZodCheck.init(inst, def);
      inst._zod.onattach.push((inst2) => {
        var _a31;
        (_a31 = inst2._zod.bag).multipleOf ?? (_a31.multipleOf = def.value);
      });
      inst._zod.check = (payload) => {
        if (typeof payload.value !== typeof def.value)
          throw new Error("Cannot mix number and bigint in multiple_of check.");
        const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
        if (isMultiple)
          return;
        payload.issues.push({
          origin: typeof payload.value,
          code: "not_multiple_of",
          divisor: def.value,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
      $ZodCheck.init(inst, def);
      def.format = def.format || "float64";
      const isInt = def.format?.includes("int");
      const origin2 = isInt ? "int" : "number";
      const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.format = def.format;
        bag.minimum = minimum;
        bag.maximum = maximum;
        if (isInt)
          bag.pattern = integer;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        if (isInt) {
          if (!Number.isInteger(input)) {
            payload.issues.push({
              expected: origin2,
              format: def.format,
              code: "invalid_type",
              continue: false,
              input,
              inst
            });
            return;
          }
          if (!Number.isSafeInteger(input)) {
            if (input > 0) {
              payload.issues.push({
                input,
                code: "too_big",
                maximum: Number.MAX_SAFE_INTEGER,
                note: "Integers must be within the safe integer range.",
                inst,
                origin: origin2,
                inclusive: true,
                continue: !def.abort
              });
            } else {
              payload.issues.push({
                input,
                code: "too_small",
                minimum: Number.MIN_SAFE_INTEGER,
                note: "Integers must be within the safe integer range.",
                inst,
                origin: origin2,
                inclusive: true,
                continue: !def.abort
              });
            }
            return;
          }
        }
        if (input < minimum) {
          payload.issues.push({
            origin: "number",
            input,
            code: "too_small",
            minimum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
        if (input > maximum) {
          payload.issues.push({
            origin: "number",
            input,
            code: "too_big",
            maximum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat", (inst, def) => {
      $ZodCheck.init(inst, def);
      const [minimum, maximum] = BIGINT_FORMAT_RANGES[def.format];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.format = def.format;
        bag.minimum = minimum;
        bag.maximum = maximum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        if (input < minimum) {
          payload.issues.push({
            origin: "bigint",
            input,
            code: "too_small",
            minimum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
        if (input > maximum) {
          payload.issues.push({
            origin: "bigint",
            input,
            code: "too_big",
            maximum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
      var _a31;
      $ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !nullish(val) && val.size !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
        if (def.maximum < curr)
          inst2._zod.bag.maximum = def.maximum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const size = input.size;
        if (size <= def.maximum)
          return;
        payload.issues.push({
          origin: getSizableOrigin(input),
          code: "too_big",
          maximum: def.maximum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
      var _a31;
      $ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !nullish(val) && val.size !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
        if (def.minimum > curr)
          inst2._zod.bag.minimum = def.minimum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const size = input.size;
        if (size >= def.minimum)
          return;
        payload.issues.push({
          origin: getSizableOrigin(input),
          code: "too_small",
          minimum: def.minimum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
      var _a31;
      $ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !nullish(val) && val.size !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.minimum = def.size;
        bag.maximum = def.size;
        bag.size = def.size;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const size = input.size;
        if (size === def.size)
          return;
        const tooBig = size > def.size;
        payload.issues.push({
          origin: getSizableOrigin(input),
          ...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size },
          inclusive: true,
          exact: true,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
      var _a31;
      $ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !nullish(val) && val.length !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
        if (def.maximum < curr)
          inst2._zod.bag.maximum = def.maximum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const length = input.length;
        if (length <= def.maximum)
          return;
        const origin2 = getLengthableOrigin(input);
        payload.issues.push({
          origin: origin2,
          code: "too_big",
          maximum: def.maximum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
      var _a31;
      $ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !nullish(val) && val.length !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
        if (def.minimum > curr)
          inst2._zod.bag.minimum = def.minimum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const length = input.length;
        if (length >= def.minimum)
          return;
        const origin2 = getLengthableOrigin(input);
        payload.issues.push({
          origin: origin2,
          code: "too_small",
          minimum: def.minimum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
      var _a31;
      $ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !nullish(val) && val.length !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.minimum = def.length;
        bag.maximum = def.length;
        bag.length = def.length;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const length = input.length;
        if (length === def.length)
          return;
        const origin2 = getLengthableOrigin(input);
        const tooBig = length > def.length;
        payload.issues.push({
          origin: origin2,
          ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
          inclusive: true,
          exact: true,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
      var _a31, _b27;
      $ZodCheck.init(inst, def);
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.format = def.format;
        if (def.pattern) {
          bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
          bag.patterns.add(def.pattern);
        }
      });
      if (def.pattern)
        (_a31 = inst._zod).check ?? (_a31.check = (payload) => {
          def.pattern.lastIndex = 0;
          if (def.pattern.test(payload.value))
            return;
          payload.issues.push({
            origin: "string",
            code: "invalid_format",
            format: def.format,
            input: payload.value,
            ...def.pattern ? { pattern: def.pattern.toString() } : {},
            inst,
            continue: !def.abort
          });
        });
      else
        (_b27 = inst._zod).check ?? (_b27.check = () => {
        });
    });
    $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
      $ZodCheckStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        def.pattern.lastIndex = 0;
        if (def.pattern.test(payload.value))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "regex",
          input: payload.value,
          pattern: def.pattern.toString(),
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
      def.pattern ?? (def.pattern = lowercase);
      $ZodCheckStringFormat.init(inst, def);
    });
    $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
      def.pattern ?? (def.pattern = uppercase);
      $ZodCheckStringFormat.init(inst, def);
    });
    $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
      $ZodCheck.init(inst, def);
      const escapedRegex = escapeRegex(def.includes);
      const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
      def.pattern = pattern;
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
        bag.patterns.add(pattern);
      });
      inst._zod.check = (payload) => {
        if (payload.value.includes(def.includes, def.position))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "includes",
          includes: def.includes,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
      $ZodCheck.init(inst, def);
      const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
      def.pattern ?? (def.pattern = pattern);
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
        bag.patterns.add(pattern);
      });
      inst._zod.check = (payload) => {
        if (payload.value.startsWith(def.prefix))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "starts_with",
          prefix: def.prefix,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
      $ZodCheck.init(inst, def);
      const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
      def.pattern ?? (def.pattern = pattern);
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
        bag.patterns.add(pattern);
      });
      inst._zod.check = (payload) => {
        if (payload.value.endsWith(def.suffix))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "ends_with",
          suffix: def.suffix,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckProperty = /* @__PURE__ */ $constructor("$ZodCheckProperty", (inst, def) => {
      $ZodCheck.init(inst, def);
      inst._zod.check = (payload) => {
        const result = def.schema._zod.run({
          value: payload.value[def.property],
          issues: []
        }, {});
        if (result instanceof Promise) {
          return result.then((result2) => handleCheckPropertyResult(result2, payload, def.property));
        }
        handleCheckPropertyResult(result, payload, def.property);
        return;
      };
    });
    $ZodCheckMimeType = /* @__PURE__ */ $constructor("$ZodCheckMimeType", (inst, def) => {
      $ZodCheck.init(inst, def);
      const mimeSet = new Set(def.mime);
      inst._zod.onattach.push((inst2) => {
        inst2._zod.bag.mime = def.mime;
      });
      inst._zod.check = (payload) => {
        if (mimeSet.has(payload.value.type))
          return;
        payload.issues.push({
          code: "invalid_value",
          values: def.mime,
          input: payload.value.type,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
      $ZodCheck.init(inst, def);
      inst._zod.check = (payload) => {
        payload.value = def.tx(payload.value);
      };
    });
  }
});

// node_modules/zod/v4/core/doc.js
var Doc;
var init_doc = __esm({
  "node_modules/zod/v4/core/doc.js"() {
    "use strict";
    Doc = class {
      constructor(args = []) {
        this.content = [];
        this.indent = 0;
        if (this)
          this.args = args;
      }
      indented(fn) {
        this.indent += 1;
        fn(this);
        this.indent -= 1;
      }
      write(arg) {
        if (typeof arg === "function") {
          arg(this, { execution: "sync" });
          arg(this, { execution: "async" });
          return;
        }
        const content = arg;
        const lines = content.split("\n").filter((x) => x);
        const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
        const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
        for (const line of dedented) {
          this.content.push(line);
        }
      }
      compile() {
        const F = Function;
        const args = this?.args;
        const content = this?.content ?? [``];
        const lines = [...content.map((x) => `  ${x}`)];
        return new F(...args, lines.join("\n"));
      }
    };
  }
});

// node_modules/zod/v4/core/versions.js
var version;
var init_versions = __esm({
  "node_modules/zod/v4/core/versions.js"() {
    "use strict";
    version = {
      major: 4,
      minor: 3,
      patch: 6
    };
  }
});

// node_modules/zod/v4/core/schemas.js
function isValidBase64(data) {
  if (data === "")
    return true;
  if (data.length % 4 !== 0)
    return false;
  try {
    atob(data);
    return true;
  } catch {
    return false;
  }
}
function isValidBase64URL(data) {
  if (!base64url.test(data))
    return false;
  const base644 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
  const padded = base644.padEnd(Math.ceil(base644.length / 4) * 4, "=");
  return isValidBase64(padded);
}
function isValidJWT(token, algorithm = null) {
  try {
    const tokensParts = token.split(".");
    if (tokensParts.length !== 3)
      return false;
    const [header] = tokensParts;
    if (!header)
      return false;
    const parsedHeader = JSON.parse(atob(header));
    if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
      return false;
    if (!parsedHeader.alg)
      return false;
    if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
      return false;
    return true;
  } catch {
    return false;
  }
}
function handleArrayResult(result, final, index) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues(index, result.issues));
  }
  final.value[index] = result.value;
}
function handlePropertyResult(result, final, key, input, isOptionalOut) {
  if (result.issues.length) {
    if (isOptionalOut && !(key in input)) {
      return;
    }
    final.issues.push(...prefixIssues(key, result.issues));
  }
  if (result.value === void 0) {
    if (key in input) {
      final.value[key] = void 0;
    }
  } else {
    final.value[key] = result.value;
  }
}
function normalizeDef(def) {
  const keys2 = Object.keys(def.shape);
  for (const k of keys2) {
    if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
    }
  }
  const okeys = optionalKeys(def.shape);
  return {
    ...def,
    keys: keys2,
    keySet: new Set(keys2),
    numKeys: keys2.length,
    optionalKeys: new Set(okeys)
  };
}
function handleCatchall(proms, input, payload, ctx, def, inst) {
  const unrecognized = [];
  const keySet = def.keySet;
  const _catchall = def.catchall._zod;
  const t = _catchall.def.type;
  const isOptionalOut = _catchall.optout === "optional";
  for (const key in input) {
    if (keySet.has(key))
      continue;
    if (t === "never") {
      unrecognized.push(key);
      continue;
    }
    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
    if (r instanceof Promise) {
      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
    } else {
      handlePropertyResult(r, payload, key, input, isOptionalOut);
    }
  }
  if (unrecognized.length) {
    payload.issues.push({
      code: "unrecognized_keys",
      keys: unrecognized,
      input,
      inst
    });
  }
  if (!proms.length)
    return payload;
  return Promise.all(proms).then(() => {
    return payload;
  });
}
function handleUnionResults(results, final, inst, ctx) {
  for (const result of results) {
    if (result.issues.length === 0) {
      final.value = result.value;
      return final;
    }
  }
  const nonaborted = results.filter((r) => !aborted(r));
  if (nonaborted.length === 1) {
    final.value = nonaborted[0].value;
    return nonaborted[0];
  }
  final.issues.push({
    code: "invalid_union",
    input: final.value,
    inst,
    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  });
  return final;
}
function handleExclusiveUnionResults(results, final, inst, ctx) {
  const successes = results.filter((r) => r.issues.length === 0);
  if (successes.length === 1) {
    final.value = successes[0].value;
    return final;
  }
  if (successes.length === 0) {
    final.issues.push({
      code: "invalid_union",
      input: final.value,
      inst,
      errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
    });
  } else {
    final.issues.push({
      code: "invalid_union",
      input: final.value,
      inst,
      errors: [],
      inclusive: false
    });
  }
  return final;
}
function mergeValues(a, b) {
  if (a === b) {
    return { valid: true, data: a };
  }
  if (a instanceof Date && b instanceof Date && +a === +b) {
    return { valid: true, data: a };
  }
  if (isPlainObject2(a) && isPlainObject2(b)) {
    const bKeys = Object.keys(b);
    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues(a[key], b[key]);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
        };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  }
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) {
      return { valid: false, mergeErrorPath: [] };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues(itemA, itemB);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
        };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  }
  return { valid: false, mergeErrorPath: [] };
}
function handleIntersectionResults(result, left, right) {
  const unrecKeys = /* @__PURE__ */ new Map();
  let unrecIssue;
  for (const iss of left.issues) {
    if (iss.code === "unrecognized_keys") {
      unrecIssue ?? (unrecIssue = iss);
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).l = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  for (const iss of right.issues) {
    if (iss.code === "unrecognized_keys") {
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).r = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
  if (bothKeys.length && unrecIssue) {
    result.issues.push({ ...unrecIssue, keys: bothKeys });
  }
  if (aborted(result))
    return result;
  const merged = mergeValues(left.value, right.value);
  if (!merged.valid) {
    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
  }
  result.value = merged.data;
  return result;
}
function handleTupleResult(result, final, index) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues(index, result.issues));
  }
  final.value[index] = result.value;
}
function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
  if (keyResult.issues.length) {
    if (propertyKeyTypes.has(typeof key)) {
      final.issues.push(...prefixIssues(key, keyResult.issues));
    } else {
      final.issues.push({
        code: "invalid_key",
        origin: "map",
        input,
        inst,
        issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
      });
    }
  }
  if (valueResult.issues.length) {
    if (propertyKeyTypes.has(typeof key)) {
      final.issues.push(...prefixIssues(key, valueResult.issues));
    } else {
      final.issues.push({
        origin: "map",
        code: "invalid_element",
        input,
        inst,
        key,
        issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
      });
    }
  }
  final.value.set(keyResult.value, valueResult.value);
}
function handleSetResult(result, final) {
  if (result.issues.length) {
    final.issues.push(...result.issues);
  }
  final.value.add(result.value);
}
function handleOptionalResult(result, input) {
  if (result.issues.length && input === void 0) {
    return { issues: [], value: void 0 };
  }
  return result;
}
function handleDefaultResult(payload, def) {
  if (payload.value === void 0) {
    payload.value = def.defaultValue;
  }
  return payload;
}
function handleNonOptionalResult(payload, inst) {
  if (!payload.issues.length && payload.value === void 0) {
    payload.issues.push({
      code: "invalid_type",
      expected: "nonoptional",
      input: payload.value,
      inst
    });
  }
  return payload;
}
function handlePipeResult(left, next, ctx) {
  if (left.issues.length) {
    left.aborted = true;
    return left;
  }
  return next._zod.run({ value: left.value, issues: left.issues }, ctx);
}
function handleCodecAResult(result, def, ctx) {
  if (result.issues.length) {
    result.aborted = true;
    return result;
  }
  const direction = ctx.direction || "forward";
  if (direction === "forward") {
    const transformed = def.transform(result.value, result);
    if (transformed instanceof Promise) {
      return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));
    }
    return handleCodecTxResult(result, transformed, def.out, ctx);
  } else {
    const transformed = def.reverseTransform(result.value, result);
    if (transformed instanceof Promise) {
      return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));
    }
    return handleCodecTxResult(result, transformed, def.in, ctx);
  }
}
function handleCodecTxResult(left, value, nextSchema, ctx) {
  if (left.issues.length) {
    left.aborted = true;
    return left;
  }
  return nextSchema._zod.run({ value, issues: left.issues }, ctx);
}
function handleReadonlyResult(payload) {
  payload.value = Object.freeze(payload.value);
  return payload;
}
function handleRefineResult(result, payload, input, inst) {
  if (!result) {
    const _iss = {
      code: "custom",
      input,
      inst,
      // incorporates params.error into issue reporting
      path: [...inst._zod.def.path ?? []],
      // incorporates params.error into issue reporting
      continue: !inst._zod.def.abort
      // params: inst._zod.def.params,
    };
    if (inst._zod.def.params)
      _iss.params = inst._zod.def.params;
    payload.issues.push(issue(_iss));
  }
}
var $ZodType, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, $ZodIPv6, $ZodMAC, $ZodCIDRv4, $ZodCIDRv6, $ZodBase64, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodCustomStringFormat, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodBigInt, $ZodBigIntFormat, $ZodSymbol, $ZodUndefined, $ZodNull, $ZodAny, $ZodUnknown, $ZodNever, $ZodVoid, $ZodDate, $ZodArray, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodXor, $ZodDiscriminatedUnion, $ZodIntersection, $ZodTuple, $ZodRecord, $ZodMap, $ZodSet, $ZodEnum, $ZodLiteral, $ZodFile, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodSuccess, $ZodCatch, $ZodNaN, $ZodPipe, $ZodCodec, $ZodReadonly, $ZodTemplateLiteral, $ZodFunction, $ZodPromise, $ZodLazy, $ZodCustom;
var init_schemas = __esm({
  "node_modules/zod/v4/core/schemas.js"() {
    "use strict";
    init_checks();
    init_core();
    init_doc();
    init_parse();
    init_regexes();
    init_util();
    init_versions();
    init_util();
    $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
      var _a31;
      inst ?? (inst = {});
      inst._zod.def = def;
      inst._zod.bag = inst._zod.bag || {};
      inst._zod.version = version;
      const checks = [...inst._zod.def.checks ?? []];
      if (inst._zod.traits.has("$ZodCheck")) {
        checks.unshift(inst);
      }
      for (const ch of checks) {
        for (const fn of ch._zod.onattach) {
          fn(inst);
        }
      }
      if (checks.length === 0) {
        (_a31 = inst._zod).deferred ?? (_a31.deferred = []);
        inst._zod.deferred?.push(() => {
          inst._zod.run = inst._zod.parse;
        });
      } else {
        const runChecks = (payload, checks2, ctx) => {
          let isAborted2 = aborted(payload);
          let asyncResult;
          for (const ch of checks2) {
            if (ch._zod.def.when) {
              const shouldRun = ch._zod.def.when(payload);
              if (!shouldRun)
                continue;
            } else if (isAborted2) {
              continue;
            }
            const currLen = payload.issues.length;
            const _ = ch._zod.check(payload);
            if (_ instanceof Promise && ctx?.async === false) {
              throw new $ZodAsyncError();
            }
            if (asyncResult || _ instanceof Promise) {
              asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
                await _;
                const nextLen = payload.issues.length;
                if (nextLen === currLen)
                  return;
                if (!isAborted2)
                  isAborted2 = aborted(payload, currLen);
              });
            } else {
              const nextLen = payload.issues.length;
              if (nextLen === currLen)
                continue;
              if (!isAborted2)
                isAborted2 = aborted(payload, currLen);
            }
          }
          if (asyncResult) {
            return asyncResult.then(() => {
              return payload;
            });
          }
          return payload;
        };
        const handleCanaryResult = (canary, payload, ctx) => {
          if (aborted(canary)) {
            canary.aborted = true;
            return canary;
          }
          const checkResult = runChecks(payload, checks, ctx);
          if (checkResult instanceof Promise) {
            if (ctx.async === false)
              throw new $ZodAsyncError();
            return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
          }
          return inst._zod.parse(checkResult, ctx);
        };
        inst._zod.run = (payload, ctx) => {
          if (ctx.skipChecks) {
            return inst._zod.parse(payload, ctx);
          }
          if (ctx.direction === "backward") {
            const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
            if (canary instanceof Promise) {
              return canary.then((canary2) => {
                return handleCanaryResult(canary2, payload, ctx);
              });
            }
            return handleCanaryResult(canary, payload, ctx);
          }
          const result = inst._zod.parse(payload, ctx);
          if (result instanceof Promise) {
            if (ctx.async === false)
              throw new $ZodAsyncError();
            return result.then((result2) => runChecks(result2, checks, ctx));
          }
          return runChecks(result, checks, ctx);
        };
      }
      defineLazy(inst, "~standard", () => ({
        validate: (value) => {
          try {
            const r = safeParse(inst, value);
            return r.success ? { value: r.data } : { issues: r.error?.issues };
          } catch (_) {
            return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
          }
        },
        vendor: "zod",
        version: 1
      }));
    });
    $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
      inst._zod.parse = (payload, _) => {
        if (def.coerce)
          try {
            payload.value = String(payload.value);
          } catch (_2) {
          }
        if (typeof payload.value === "string")
          return payload;
        payload.issues.push({
          expected: "string",
          code: "invalid_type",
          input: payload.value,
          inst
        });
        return payload;
      };
    });
    $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
      $ZodCheckStringFormat.init(inst, def);
      $ZodString.init(inst, def);
    });
    $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
      def.pattern ?? (def.pattern = guid);
      $ZodStringFormat.init(inst, def);
    });
    $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
      if (def.version) {
        const versionMap = {
          v1: 1,
          v2: 2,
          v3: 3,
          v4: 4,
          v5: 5,
          v6: 6,
          v7: 7,
          v8: 8
        };
        const v = versionMap[def.version];
        if (v === void 0)
          throw new Error(`Invalid UUID version: "${def.version}"`);
        def.pattern ?? (def.pattern = uuid(v));
      } else
        def.pattern ?? (def.pattern = uuid());
      $ZodStringFormat.init(inst, def);
    });
    $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
      def.pattern ?? (def.pattern = email);
      $ZodStringFormat.init(inst, def);
    });
    $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
      $ZodStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        try {
          const trimmed = payload.value.trim();
          const url4 = new URL(trimmed);
          if (def.hostname) {
            def.hostname.lastIndex = 0;
            if (!def.hostname.test(url4.hostname)) {
              payload.issues.push({
                code: "invalid_format",
                format: "url",
                note: "Invalid hostname",
                pattern: def.hostname.source,
                input: payload.value,
                inst,
                continue: !def.abort
              });
            }
          }
          if (def.protocol) {
            def.protocol.lastIndex = 0;
            if (!def.protocol.test(url4.protocol.endsWith(":") ? url4.protocol.slice(0, -1) : url4.protocol)) {
              payload.issues.push({
                code: "invalid_format",
                format: "url",
                note: "Invalid protocol",
                pattern: def.protocol.source,
                input: payload.value,
                inst,
                continue: !def.abort
              });
            }
          }
          if (def.normalize) {
            payload.value = url4.href;
          } else {
            payload.value = trimmed;
          }
          return;
        } catch (_) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
      def.pattern ?? (def.pattern = emoji());
      $ZodStringFormat.init(inst, def);
    });
    $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
      def.pattern ?? (def.pattern = nanoid);
      $ZodStringFormat.init(inst, def);
    });
    $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
      def.pattern ?? (def.pattern = cuid);
      $ZodStringFormat.init(inst, def);
    });
    $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
      def.pattern ?? (def.pattern = cuid2);
      $ZodStringFormat.init(inst, def);
    });
    $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
      def.pattern ?? (def.pattern = ulid);
      $ZodStringFormat.init(inst, def);
    });
    $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
      def.pattern ?? (def.pattern = xid);
      $ZodStringFormat.init(inst, def);
    });
    $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
      def.pattern ?? (def.pattern = ksuid);
      $ZodStringFormat.init(inst, def);
    });
    $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
      def.pattern ?? (def.pattern = datetime(def));
      $ZodStringFormat.init(inst, def);
    });
    $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
      def.pattern ?? (def.pattern = date);
      $ZodStringFormat.init(inst, def);
    });
    $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
      def.pattern ?? (def.pattern = time(def));
      $ZodStringFormat.init(inst, def);
    });
    $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
      def.pattern ?? (def.pattern = duration);
      $ZodStringFormat.init(inst, def);
    });
    $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
      def.pattern ?? (def.pattern = ipv4);
      $ZodStringFormat.init(inst, def);
      inst._zod.bag.format = `ipv4`;
    });
    $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
      def.pattern ?? (def.pattern = ipv6);
      $ZodStringFormat.init(inst, def);
      inst._zod.bag.format = `ipv6`;
      inst._zod.check = (payload) => {
        try {
          new URL(`http://[${payload.value}]`);
        } catch {
          payload.issues.push({
            code: "invalid_format",
            format: "ipv6",
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodMAC = /* @__PURE__ */ $constructor("$ZodMAC", (inst, def) => {
      def.pattern ?? (def.pattern = mac(def.delimiter));
      $ZodStringFormat.init(inst, def);
      inst._zod.bag.format = `mac`;
    });
    $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
      def.pattern ?? (def.pattern = cidrv4);
      $ZodStringFormat.init(inst, def);
    });
    $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
      def.pattern ?? (def.pattern = cidrv6);
      $ZodStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        const parts = payload.value.split("/");
        try {
          if (parts.length !== 2)
            throw new Error();
          const [address, prefix] = parts;
          if (!prefix)
            throw new Error();
          const prefixNum = Number(prefix);
          if (`${prefixNum}` !== prefix)
            throw new Error();
          if (prefixNum < 0 || prefixNum > 128)
            throw new Error();
          new URL(`http://[${address}]`);
        } catch {
          payload.issues.push({
            code: "invalid_format",
            format: "cidrv6",
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
      def.pattern ?? (def.pattern = base64);
      $ZodStringFormat.init(inst, def);
      inst._zod.bag.contentEncoding = "base64";
      inst._zod.check = (payload) => {
        if (isValidBase64(payload.value))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: "base64",
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
      def.pattern ?? (def.pattern = base64url);
      $ZodStringFormat.init(inst, def);
      inst._zod.bag.contentEncoding = "base64url";
      inst._zod.check = (payload) => {
        if (isValidBase64URL(payload.value))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: "base64url",
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
      def.pattern ?? (def.pattern = e164);
      $ZodStringFormat.init(inst, def);
    });
    $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
      $ZodStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        if (isValidJWT(payload.value, def.alg))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: "jwt",
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCustomStringFormat = /* @__PURE__ */ $constructor("$ZodCustomStringFormat", (inst, def) => {
      $ZodStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        if (def.fn(payload.value))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: def.format,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.pattern = inst._zod.bag.pattern ?? number;
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce)
          try {
            payload.value = Number(payload.value);
          } catch (_) {
          }
        const input = payload.value;
        if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
          return payload;
        }
        const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
        payload.issues.push({
          expected: "number",
          code: "invalid_type",
          input,
          inst,
          ...received ? { received } : {}
        });
        return payload;
      };
    });
    $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => {
      $ZodCheckNumberFormat.init(inst, def);
      $ZodNumber.init(inst, def);
    });
    $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.pattern = boolean;
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce)
          try {
            payload.value = Boolean(payload.value);
          } catch (_) {
          }
        const input = payload.value;
        if (typeof input === "boolean")
          return payload;
        payload.issues.push({
          expected: "boolean",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.pattern = bigint;
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce)
          try {
            payload.value = BigInt(payload.value);
          } catch (_) {
          }
        if (typeof payload.value === "bigint")
          return payload;
        payload.issues.push({
          expected: "bigint",
          code: "invalid_type",
          input: payload.value,
          inst
        });
        return payload;
      };
    });
    $ZodBigIntFormat = /* @__PURE__ */ $constructor("$ZodBigIntFormat", (inst, def) => {
      $ZodCheckBigIntFormat.init(inst, def);
      $ZodBigInt.init(inst, def);
    });
    $ZodSymbol = /* @__PURE__ */ $constructor("$ZodSymbol", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (typeof input === "symbol")
          return payload;
        payload.issues.push({
          expected: "symbol",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.pattern = _undefined;
      inst._zod.values = /* @__PURE__ */ new Set([void 0]);
      inst._zod.optin = "optional";
      inst._zod.optout = "optional";
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (typeof input === "undefined")
          return payload;
        payload.issues.push({
          expected: "undefined",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.pattern = _null;
      inst._zod.values = /* @__PURE__ */ new Set([null]);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (input === null)
          return payload;
        payload.issues.push({
          expected: "null",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload) => payload;
    });
    $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload) => payload;
    });
    $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        payload.issues.push({
          expected: "never",
          code: "invalid_type",
          input: payload.value,
          inst
        });
        return payload;
      };
    });
    $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (typeof input === "undefined")
          return payload;
        payload.issues.push({
          expected: "void",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce) {
          try {
            payload.value = new Date(payload.value);
          } catch (_err) {
          }
        }
        const input = payload.value;
        const isDate2 = input instanceof Date;
        const isValidDate = isDate2 && !Number.isNaN(input.getTime());
        if (isValidDate)
          return payload;
        payload.issues.push({
          expected: "date",
          code: "invalid_type",
          input,
          ...isDate2 ? { received: "Invalid Date" } : {},
          inst
        });
        return payload;
      };
    });
    $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!Array.isArray(input)) {
          payload.issues.push({
            expected: "array",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        payload.value = Array(input.length);
        const proms = [];
        for (let i = 0; i < input.length; i++) {
          const item = input[i];
          const result = def.element._zod.run({
            value: item,
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
          } else {
            handleArrayResult(result, payload, i);
          }
        }
        if (proms.length) {
          return Promise.all(proms).then(() => payload);
        }
        return payload;
      };
    });
    $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
      $ZodType.init(inst, def);
      const desc = Object.getOwnPropertyDescriptor(def, "shape");
      if (!desc?.get) {
        const sh = def.shape;
        Object.defineProperty(def, "shape", {
          get: () => {
            const newSh = { ...sh };
            Object.defineProperty(def, "shape", {
              value: newSh
            });
            return newSh;
          }
        });
      }
      const _normalized = cached(() => normalizeDef(def));
      defineLazy(inst._zod, "propValues", () => {
        const shape = def.shape;
        const propValues = {};
        for (const key in shape) {
          const field = shape[key]._zod;
          if (field.values) {
            propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
            for (const v of field.values)
              propValues[key].add(v);
          }
        }
        return propValues;
      });
      const isObject5 = isObject3;
      const catchall = def.catchall;
      let value;
      inst._zod.parse = (payload, ctx) => {
        value ?? (value = _normalized.value);
        const input = payload.value;
        if (!isObject5(input)) {
          payload.issues.push({
            expected: "object",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        payload.value = {};
        const proms = [];
        const shape = value.shape;
        for (const key of value.keys) {
          const el = shape[key];
          const isOptionalOut = el._zod.optout === "optional";
          const r = el._zod.run({ value: input[key], issues: [] }, ctx);
          if (r instanceof Promise) {
            proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
          } else {
            handlePropertyResult(r, payload, key, input, isOptionalOut);
          }
        }
        if (!catchall) {
          return proms.length ? Promise.all(proms).then(() => payload) : payload;
        }
        return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
      };
    });
    $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
      $ZodObject.init(inst, def);
      const superParse = inst._zod.parse;
      const _normalized = cached(() => normalizeDef(def));
      const generateFastpass = (shape) => {
        const doc = new Doc(["shape", "payload", "ctx"]);
        const normalized = _normalized.value;
        const parseStr = (key) => {
          const k = esc(key);
          return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
        };
        doc.write(`const input = payload.value;`);
        const ids = /* @__PURE__ */ Object.create(null);
        let counter = 0;
        for (const key of normalized.keys) {
          ids[key] = `key_${counter++}`;
        }
        doc.write(`const newResult = {};`);
        for (const key of normalized.keys) {
          const id = ids[key];
          const k = esc(key);
          const schema = shape[key];
          const isOptionalOut = schema?._zod?.optout === "optional";
          doc.write(`const ${id} = ${parseStr(key)};`);
          if (isOptionalOut) {
            doc.write(`
        if (${id}.issues.length) {
          if (${k} in input) {
            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
              ...iss,
              path: iss.path ? [${k}, ...iss.path] : [${k}]
            })));
          }
        }
        
        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }
        
      `);
          } else {
            doc.write(`
        if (${id}.issues.length) {
          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
            ...iss,
            path: iss.path ? [${k}, ...iss.path] : [${k}]
          })));
        }
        
        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }
        
      `);
          }
        }
        doc.write(`payload.value = newResult;`);
        doc.write(`return payload;`);
        const fn = doc.compile();
        return (payload, ctx) => fn(shape, payload, ctx);
      };
      let fastpass;
      const isObject5 = isObject3;
      const jit = !globalConfig.jitless;
      const allowsEval3 = allowsEval;
      const fastEnabled = jit && allowsEval3.value;
      const catchall = def.catchall;
      let value;
      inst._zod.parse = (payload, ctx) => {
        value ?? (value = _normalized.value);
        const input = payload.value;
        if (!isObject5(input)) {
          payload.issues.push({
            expected: "object",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
          if (!fastpass)
            fastpass = generateFastpass(def.shape);
          payload = fastpass(payload, ctx);
          if (!catchall)
            return payload;
          return handleCatchall([], input, payload, ctx, value, inst);
        }
        return superParse(payload, ctx);
      };
    });
    $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
      $ZodType.init(inst, def);
      defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
      defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
      defineLazy(inst._zod, "values", () => {
        if (def.options.every((o) => o._zod.values)) {
          return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
        }
        return void 0;
      });
      defineLazy(inst._zod, "pattern", () => {
        if (def.options.every((o) => o._zod.pattern)) {
          const patterns = def.options.map((o) => o._zod.pattern);
          return new RegExp(`^(${patterns.map((p3) => cleanRegex(p3.source)).join("|")})$`);
        }
        return void 0;
      });
      const single = def.options.length === 1;
      const first = def.options[0]._zod.run;
      inst._zod.parse = (payload, ctx) => {
        if (single) {
          return first(payload, ctx);
        }
        let async = false;
        const results = [];
        for (const option of def.options) {
          const result = option._zod.run({
            value: payload.value,
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            results.push(result);
            async = true;
          } else {
            if (result.issues.length === 0)
              return result;
            results.push(result);
          }
        }
        if (!async)
          return handleUnionResults(results, payload, inst, ctx);
        return Promise.all(results).then((results2) => {
          return handleUnionResults(results2, payload, inst, ctx);
        });
      };
    });
    $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
      $ZodUnion.init(inst, def);
      def.inclusive = false;
      const single = def.options.length === 1;
      const first = def.options[0]._zod.run;
      inst._zod.parse = (payload, ctx) => {
        if (single) {
          return first(payload, ctx);
        }
        let async = false;
        const results = [];
        for (const option of def.options) {
          const result = option._zod.run({
            value: payload.value,
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            results.push(result);
            async = true;
          } else {
            results.push(result);
          }
        }
        if (!async)
          return handleExclusiveUnionResults(results, payload, inst, ctx);
        return Promise.all(results).then((results2) => {
          return handleExclusiveUnionResults(results2, payload, inst, ctx);
        });
      };
    });
    $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
      def.inclusive = false;
      $ZodUnion.init(inst, def);
      const _super = inst._zod.parse;
      defineLazy(inst._zod, "propValues", () => {
        const propValues = {};
        for (const option of def.options) {
          const pv = option._zod.propValues;
          if (!pv || Object.keys(pv).length === 0)
            throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
          for (const [k, v] of Object.entries(pv)) {
            if (!propValues[k])
              propValues[k] = /* @__PURE__ */ new Set();
            for (const val of v) {
              propValues[k].add(val);
            }
          }
        }
        return propValues;
      });
      const disc = cached(() => {
        const opts = def.options;
        const map3 = /* @__PURE__ */ new Map();
        for (const o of opts) {
          const values = o._zod.propValues?.[def.discriminator];
          if (!values || values.size === 0)
            throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
          for (const v of values) {
            if (map3.has(v)) {
              throw new Error(`Duplicate discriminator value "${String(v)}"`);
            }
            map3.set(v, o);
          }
        }
        return map3;
      });
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!isObject3(input)) {
          payload.issues.push({
            code: "invalid_type",
            expected: "object",
            input,
            inst
          });
          return payload;
        }
        const opt = disc.value.get(input?.[def.discriminator]);
        if (opt) {
          return opt._zod.run(payload, ctx);
        }
        if (def.unionFallback) {
          return _super(payload, ctx);
        }
        payload.issues.push({
          code: "invalid_union",
          errors: [],
          note: "No matching discriminator",
          discriminator: def.discriminator,
          input,
          path: [def.discriminator],
          inst
        });
        return payload;
      };
    });
    $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        const left = def.left._zod.run({ value: input, issues: [] }, ctx);
        const right = def.right._zod.run({ value: input, issues: [] }, ctx);
        const async = left instanceof Promise || right instanceof Promise;
        if (async) {
          return Promise.all([left, right]).then(([left2, right2]) => {
            return handleIntersectionResults(payload, left2, right2);
          });
        }
        return handleIntersectionResults(payload, left, right);
      };
    });
    $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
      $ZodType.init(inst, def);
      const items = def.items;
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!Array.isArray(input)) {
          payload.issues.push({
            input,
            inst,
            expected: "tuple",
            code: "invalid_type"
          });
          return payload;
        }
        payload.value = [];
        const proms = [];
        const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
        const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
        if (!def.rest) {
          const tooBig = input.length > items.length;
          const tooSmall = input.length < optStart - 1;
          if (tooBig || tooSmall) {
            payload.issues.push({
              ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
              input,
              inst,
              origin: "array"
            });
            return payload;
          }
        }
        let i = -1;
        for (const item of items) {
          i++;
          if (i >= input.length) {
            if (i >= optStart)
              continue;
          }
          const result = item._zod.run({
            value: input[i],
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
          } else {
            handleTupleResult(result, payload, i);
          }
        }
        if (def.rest) {
          const rest = input.slice(items.length);
          for (const el of rest) {
            i++;
            const result = def.rest._zod.run({
              value: el,
              issues: []
            }, ctx);
            if (result instanceof Promise) {
              proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
            } else {
              handleTupleResult(result, payload, i);
            }
          }
        }
        if (proms.length)
          return Promise.all(proms).then(() => payload);
        return payload;
      };
    });
    $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!isPlainObject2(input)) {
          payload.issues.push({
            expected: "record",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        const proms = [];
        const values = def.keyType._zod.values;
        if (values) {
          payload.value = {};
          const recordKeys = /* @__PURE__ */ new Set();
          for (const key of values) {
            if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
              recordKeys.add(typeof key === "number" ? key.toString() : key);
              const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
              if (result instanceof Promise) {
                proms.push(result.then((result2) => {
                  if (result2.issues.length) {
                    payload.issues.push(...prefixIssues(key, result2.issues));
                  }
                  payload.value[key] = result2.value;
                }));
              } else {
                if (result.issues.length) {
                  payload.issues.push(...prefixIssues(key, result.issues));
                }
                payload.value[key] = result.value;
              }
            }
          }
          let unrecognized;
          for (const key in input) {
            if (!recordKeys.has(key)) {
              unrecognized = unrecognized ?? [];
              unrecognized.push(key);
            }
          }
          if (unrecognized && unrecognized.length > 0) {
            payload.issues.push({
              code: "unrecognized_keys",
              input,
              inst,
              keys: unrecognized
            });
          }
        } else {
          payload.value = {};
          for (const key of Reflect.ownKeys(input)) {
            if (key === "__proto__")
              continue;
            let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
            if (keyResult instanceof Promise) {
              throw new Error("Async schemas not supported in object keys currently");
            }
            const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
            if (checkNumericKey) {
              const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
              if (retryResult instanceof Promise) {
                throw new Error("Async schemas not supported in object keys currently");
              }
              if (retryResult.issues.length === 0) {
                keyResult = retryResult;
              }
            }
            if (keyResult.issues.length) {
              if (def.mode === "loose") {
                payload.value[key] = input[key];
              } else {
                payload.issues.push({
                  code: "invalid_key",
                  origin: "record",
                  issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
                  input: key,
                  path: [key],
                  inst
                });
              }
              continue;
            }
            const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
            if (result instanceof Promise) {
              proms.push(result.then((result2) => {
                if (result2.issues.length) {
                  payload.issues.push(...prefixIssues(key, result2.issues));
                }
                payload.value[keyResult.value] = result2.value;
              }));
            } else {
              if (result.issues.length) {
                payload.issues.push(...prefixIssues(key, result.issues));
              }
              payload.value[keyResult.value] = result.value;
            }
          }
        }
        if (proms.length) {
          return Promise.all(proms).then(() => payload);
        }
        return payload;
      };
    });
    $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!(input instanceof Map)) {
          payload.issues.push({
            expected: "map",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        const proms = [];
        payload.value = /* @__PURE__ */ new Map();
        for (const [key, value] of input) {
          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
          const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
          if (keyResult instanceof Promise || valueResult instanceof Promise) {
            proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
              handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx);
            }));
          } else {
            handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
          }
        }
        if (proms.length)
          return Promise.all(proms).then(() => payload);
        return payload;
      };
    });
    $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!(input instanceof Set)) {
          payload.issues.push({
            input,
            inst,
            expected: "set",
            code: "invalid_type"
          });
          return payload;
        }
        const proms = [];
        payload.value = /* @__PURE__ */ new Set();
        for (const item of input) {
          const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => handleSetResult(result2, payload)));
          } else
            handleSetResult(result, payload);
        }
        if (proms.length)
          return Promise.all(proms).then(() => payload);
        return payload;
      };
    });
    $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
      $ZodType.init(inst, def);
      const values = getEnumValues(def.entries);
      const valuesSet = new Set(values);
      inst._zod.values = valuesSet;
      inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (valuesSet.has(input)) {
          return payload;
        }
        payload.issues.push({
          code: "invalid_value",
          values,
          input,
          inst
        });
        return payload;
      };
    });
    $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
      $ZodType.init(inst, def);
      if (def.values.length === 0) {
        throw new Error("Cannot create literal schema with no valid values");
      }
      const values = new Set(def.values);
      inst._zod.values = values;
      inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (values.has(input)) {
          return payload;
        }
        payload.issues.push({
          code: "invalid_value",
          values: def.values,
          input,
          inst
        });
        return payload;
      };
    });
    $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (input instanceof File)
          return payload;
        payload.issues.push({
          expected: "file",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          throw new $ZodEncodeError(inst.constructor.name);
        }
        const _out = def.transform(payload.value, payload);
        if (ctx.async) {
          const output = _out instanceof Promise ? _out : Promise.resolve(_out);
          return output.then((output2) => {
            payload.value = output2;
            return payload;
          });
        }
        if (_out instanceof Promise) {
          throw new $ZodAsyncError();
        }
        payload.value = _out;
        return payload;
      };
    });
    $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.optin = "optional";
      inst._zod.optout = "optional";
      defineLazy(inst._zod, "values", () => {
        return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
      });
      defineLazy(inst._zod, "pattern", () => {
        const pattern = def.innerType._zod.pattern;
        return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        if (def.innerType._zod.optin === "optional") {
          const result = def.innerType._zod.run(payload, ctx);
          if (result instanceof Promise)
            return result.then((r) => handleOptionalResult(r, payload.value));
          return handleOptionalResult(result, payload.value);
        }
        if (payload.value === void 0) {
          return payload;
        }
        return def.innerType._zod.run(payload, ctx);
      };
    });
    $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
      $ZodOptional.init(inst, def);
      defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
      inst._zod.parse = (payload, ctx) => {
        return def.innerType._zod.run(payload, ctx);
      };
    });
    $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
      $ZodType.init(inst, def);
      defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
      defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
      defineLazy(inst._zod, "pattern", () => {
        const pattern = def.innerType._zod.pattern;
        return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
      });
      defineLazy(inst._zod, "values", () => {
        return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        if (payload.value === null)
          return payload;
        return def.innerType._zod.run(payload, ctx);
      };
    });
    $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.optin = "optional";
      defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        if (payload.value === void 0) {
          payload.value = def.defaultValue;
          return payload;
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => handleDefaultResult(result2, def));
        }
        return handleDefaultResult(result, def);
      };
    });
    $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.optin = "optional";
      defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        if (payload.value === void 0) {
          payload.value = def.defaultValue;
        }
        return def.innerType._zod.run(payload, ctx);
      };
    });
    $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
      $ZodType.init(inst, def);
      defineLazy(inst._zod, "values", () => {
        const v = def.innerType._zod.values;
        return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => handleNonOptionalResult(result2, inst));
        }
        return handleNonOptionalResult(result, inst);
      };
    });
    $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          throw new $ZodEncodeError("ZodSuccess");
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => {
            payload.value = result2.issues.length === 0;
            return payload;
          });
        }
        payload.value = result.issues.length === 0;
        return payload;
      };
    });
    $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
      $ZodType.init(inst, def);
      defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
      defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
      defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => {
            payload.value = result2.value;
            if (result2.issues.length) {
              payload.value = def.catchValue({
                ...payload,
                error: {
                  issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
                },
                input: payload.value
              });
              payload.issues = [];
            }
            return payload;
          });
        }
        payload.value = result.value;
        if (result.issues.length) {
          payload.value = def.catchValue({
            ...payload,
            error: {
              issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
            },
            input: payload.value
          });
          payload.issues = [];
        }
        return payload;
      };
    });
    $ZodNaN = /* @__PURE__ */ $constructor("$ZodNaN", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
          payload.issues.push({
            input: payload.value,
            inst,
            expected: "nan",
            code: "invalid_type"
          });
          return payload;
        }
        return payload;
      };
    });
    $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
      $ZodType.init(inst, def);
      defineLazy(inst._zod, "values", () => def.in._zod.values);
      defineLazy(inst._zod, "optin", () => def.in._zod.optin);
      defineLazy(inst._zod, "optout", () => def.out._zod.optout);
      defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          const right = def.out._zod.run(payload, ctx);
          if (right instanceof Promise) {
            return right.then((right2) => handlePipeResult(right2, def.in, ctx));
          }
          return handlePipeResult(right, def.in, ctx);
        }
        const left = def.in._zod.run(payload, ctx);
        if (left instanceof Promise) {
          return left.then((left2) => handlePipeResult(left2, def.out, ctx));
        }
        return handlePipeResult(left, def.out, ctx);
      };
    });
    $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
      $ZodType.init(inst, def);
      defineLazy(inst._zod, "values", () => def.in._zod.values);
      defineLazy(inst._zod, "optin", () => def.in._zod.optin);
      defineLazy(inst._zod, "optout", () => def.out._zod.optout);
      defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
      inst._zod.parse = (payload, ctx) => {
        const direction = ctx.direction || "forward";
        if (direction === "forward") {
          const left = def.in._zod.run(payload, ctx);
          if (left instanceof Promise) {
            return left.then((left2) => handleCodecAResult(left2, def, ctx));
          }
          return handleCodecAResult(left, def, ctx);
        } else {
          const right = def.out._zod.run(payload, ctx);
          if (right instanceof Promise) {
            return right.then((right2) => handleCodecAResult(right2, def, ctx));
          }
          return handleCodecAResult(right, def, ctx);
        }
      };
    });
    $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
      $ZodType.init(inst, def);
      defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
      defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
      defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then(handleReadonlyResult);
        }
        return handleReadonlyResult(result);
      };
    });
    $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => {
      $ZodType.init(inst, def);
      const regexParts = [];
      for (const part of def.parts) {
        if (typeof part === "object" && part !== null) {
          if (!part._zod.pattern) {
            throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
          }
          const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
          if (!source)
            throw new Error(`Invalid template literal part: ${part._zod.traits}`);
          const start = source.startsWith("^") ? 1 : 0;
          const end = source.endsWith("$") ? source.length - 1 : source.length;
          regexParts.push(source.slice(start, end));
        } else if (part === null || primitiveTypes.has(typeof part)) {
          regexParts.push(escapeRegex(`${part}`));
        } else {
          throw new Error(`Invalid template literal part: ${part}`);
        }
      }
      inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
      inst._zod.parse = (payload, _ctx) => {
        if (typeof payload.value !== "string") {
          payload.issues.push({
            input: payload.value,
            inst,
            expected: "string",
            code: "invalid_type"
          });
          return payload;
        }
        inst._zod.pattern.lastIndex = 0;
        if (!inst._zod.pattern.test(payload.value)) {
          payload.issues.push({
            input: payload.value,
            inst,
            code: "invalid_format",
            format: def.format ?? "template_literal",
            pattern: inst._zod.pattern.source
          });
          return payload;
        }
        return payload;
      };
    });
    $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
      $ZodType.init(inst, def);
      inst._def = def;
      inst._zod.def = def;
      inst.implement = (func) => {
        if (typeof func !== "function") {
          throw new Error("implement() must be called with a function");
        }
        return function(...args) {
          const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
          const result = Reflect.apply(func, this, parsedArgs);
          if (inst._def.output) {
            return parse(inst._def.output, result);
          }
          return result;
        };
      };
      inst.implementAsync = (func) => {
        if (typeof func !== "function") {
          throw new Error("implementAsync() must be called with a function");
        }
        return async function(...args) {
          const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;
          const result = await Reflect.apply(func, this, parsedArgs);
          if (inst._def.output) {
            return await parseAsync(inst._def.output, result);
          }
          return result;
        };
      };
      inst._zod.parse = (payload, _ctx) => {
        if (typeof payload.value !== "function") {
          payload.issues.push({
            code: "invalid_type",
            expected: "function",
            input: payload.value,
            inst
          });
          return payload;
        }
        const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise";
        if (hasPromiseOutput) {
          payload.value = inst.implementAsync(payload.value);
        } else {
          payload.value = inst.implement(payload.value);
        }
        return payload;
      };
      inst.input = (...args) => {
        const F = inst.constructor;
        if (Array.isArray(args[0])) {
          return new F({
            type: "function",
            input: new $ZodTuple({
              type: "tuple",
              items: args[0],
              rest: args[1]
            }),
            output: inst._def.output
          });
        }
        return new F({
          type: "function",
          input: args[0],
          output: inst._def.output
        });
      };
      inst.output = (output) => {
        const F = inst.constructor;
        return new F({
          type: "function",
          input: inst._def.input,
          output
        });
      };
      return inst;
    });
    $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => {
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
      };
    });
    $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
      $ZodType.init(inst, def);
      defineLazy(inst._zod, "innerType", () => def.getter());
      defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
      defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
      defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
      defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? void 0);
      inst._zod.parse = (payload, ctx) => {
        const inner = inst._zod.innerType;
        return inner._zod.run(payload, ctx);
      };
    });
    $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
      $ZodCheck.init(inst, def);
      $ZodType.init(inst, def);
      inst._zod.parse = (payload, _) => {
        return payload;
      };
      inst._zod.check = (payload) => {
        const input = payload.value;
        const r = def.fn(input);
        if (r instanceof Promise) {
          return r.then((r2) => handleRefineResult(r2, payload, input, inst));
        }
        handleRefineResult(r, payload, input, inst);
        return;
      };
    });
  }
});

// node_modules/zod/v4/locales/ar.js
function ar_default() {
  return {
    localeError: error()
  };
}
var error;
var init_ar = __esm({
  "node_modules/zod/v4/locales/ar.js"() {
    "use strict";
    init_util();
    error = () => {
      const Sizable = {
        string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
        file: { unit: "\u0628\u0627\u064A\u062A", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
        array: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
        set: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0645\u062F\u062E\u0644",
        email: "\u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A",
        url: "\u0631\u0627\u0628\u0637",
        emoji: "\u0625\u064A\u0645\u0648\u062C\u064A",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u062A\u0627\u0631\u064A\u062E \u0648\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        date: "\u062A\u0627\u0631\u064A\u062E \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        time: "\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        duration: "\u0645\u062F\u0629 \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        ipv4: "\u0639\u0646\u0648\u0627\u0646 IPv4",
        ipv6: "\u0639\u0646\u0648\u0627\u0646 IPv6",
        cidrv4: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv4",
        cidrv6: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv6",
        base64: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64-encoded",
        base64url: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64url-encoded",
        json_string: "\u0646\u064E\u0635 \u0639\u0644\u0649 \u0647\u064A\u0626\u0629 JSON",
        e164: "\u0631\u0642\u0645 \u0647\u0627\u062A\u0641 \u0628\u0645\u0639\u064A\u0627\u0631 E.164",
        jwt: "JWT",
        template_literal: "\u0645\u062F\u062E\u0644"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 instanceof ${issue3.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
            }
            return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${stringifyPrimitive(issue3.values[0])}`;
            return `\u0627\u062E\u062A\u064A\u0627\u0631 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062A\u0648\u0642\u0639 \u0627\u0646\u062A\u0642\u0627\u0621 \u0623\u062D\u062F \u0647\u0630\u0647 \u0627\u0644\u062E\u064A\u0627\u0631\u0627\u062A: ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return ` \u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue3.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"}`;
            return `\u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue3.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue3.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue3.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0628\u062F\u0623 \u0628\u0640 "${issue3.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0646\u062A\u0647\u064A \u0628\u0640 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u062A\u0636\u0645\u0651\u064E\u0646 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0637\u0627\u0628\u0642 \u0627\u0644\u0646\u0645\u0637 ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`;
          }
          case "not_multiple_of":
            return `\u0631\u0642\u0645 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0645\u0646 \u0645\u0636\u0627\u0639\u0641\u0627\u062A ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u0645\u0639\u0631\u0641${issue3.keys.length > 1 ? "\u0627\u062A" : ""} \u063A\u0631\u064A\u0628${issue3.keys.length > 1 ? "\u0629" : ""}: ${joinValues(issue3.keys, "\u060C ")}`;
          case "invalid_key":
            return `\u0645\u0639\u0631\u0641 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue3.origin}`;
          case "invalid_union":
            return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
          case "invalid_element":
            return `\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue3.origin}`;
          default:
            return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/az.js
function az_default() {
  return {
    localeError: error2()
  };
}
var error2;
var init_az = __esm({
  "node_modules/zod/v4/locales/az.js"() {
    "use strict";
    init_util();
    error2 = () => {
      const Sizable = {
        string: { unit: "simvol", verb: "olmal\u0131d\u0131r" },
        file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
        array: { unit: "element", verb: "olmal\u0131d\u0131r" },
        set: { unit: "element", verb: "olmal\u0131d\u0131r" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "email address",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datetime",
        date: "ISO date",
        time: "ISO time",
        duration: "ISO duration",
        ipv4: "IPv4 address",
        ipv6: "IPv6 address",
        cidrv4: "IPv4 range",
        cidrv6: "IPv6 range",
        base64: "base64-encoded string",
        base64url: "base64url-encoded string",
        json_string: "JSON string",
        e164: "E.164 number",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n instanceof ${issue3.expected}, daxil olan ${received}`;
            }
            return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${expected}, daxil olan ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${stringifyPrimitive(issue3.values[0])}`;
            return `Yanl\u0131\u015F se\xE7im: a\u015Fa\u011F\u0131dak\u0131lardan biri olmal\u0131d\u0131r: ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue3.origin ?? "d\u0259y\u0259r"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "element"}`;
            return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue3.origin ?? "d\u0259y\u0259r"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Yanl\u0131\u015F m\u0259tn: "${_issue.prefix}" il\u0259 ba\u015Flamal\u0131d\u0131r`;
            if (_issue.format === "ends_with")
              return `Yanl\u0131\u015F m\u0259tn: "${_issue.suffix}" il\u0259 bitm\u0259lidir`;
            if (_issue.format === "includes")
              return `Yanl\u0131\u015F m\u0259tn: "${_issue.includes}" daxil olmal\u0131d\u0131r`;
            if (_issue.format === "regex")
              return `Yanl\u0131\u015F m\u0259tn: ${_issue.pattern} \u015Fablonuna uy\u011Fun olmal\u0131d\u0131r`;
            return `Yanl\u0131\u015F ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Yanl\u0131\u015F \u0259d\u0259d: ${issue3.divisor} il\u0259 b\xF6l\xFCn\u0259 bil\u0259n olmal\u0131d\u0131r`;
          case "unrecognized_keys":
            return `Tan\u0131nmayan a\xE7ar${issue3.keys.length > 1 ? "lar" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} daxilind\u0259 yanl\u0131\u015F a\xE7ar`;
          case "invalid_union":
            return "Yanl\u0131\u015F d\u0259y\u0259r";
          case "invalid_element":
            return `${issue3.origin} daxilind\u0259 yanl\u0131\u015F d\u0259y\u0259r`;
          default:
            return `Yanl\u0131\u015F d\u0259y\u0259r`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/be.js
function getBelarusianPlural(count, one, few, many) {
  const absCount = Math.abs(count);
  const lastDigit = absCount % 10;
  const lastTwoDigits = absCount % 100;
  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
    return many;
  }
  if (lastDigit === 1) {
    return one;
  }
  if (lastDigit >= 2 && lastDigit <= 4) {
    return few;
  }
  return many;
}
function be_default() {
  return {
    localeError: error3()
  };
}
var error3;
var init_be = __esm({
  "node_modules/zod/v4/locales/be.js"() {
    "use strict";
    init_util();
    error3 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "\u0441\u0456\u043C\u0432\u0430\u043B",
            few: "\u0441\u0456\u043C\u0432\u0430\u043B\u044B",
            many: "\u0441\u0456\u043C\u0432\u0430\u043B\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        },
        array: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        },
        set: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        },
        file: {
          unit: {
            one: "\u0431\u0430\u0439\u0442",
            few: "\u0431\u0430\u0439\u0442\u044B",
            many: "\u0431\u0430\u0439\u0442\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0443\u0432\u043E\u0434",
        email: "email \u0430\u0434\u0440\u0430\u0441",
        url: "URL",
        emoji: "\u044D\u043C\u043E\u0434\u0437\u0456",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0434\u0430\u0442\u0430 \u0456 \u0447\u0430\u0441",
        date: "ISO \u0434\u0430\u0442\u0430",
        time: "ISO \u0447\u0430\u0441",
        duration: "ISO \u043F\u0440\u0430\u0446\u044F\u0433\u043B\u0430\u0441\u0446\u044C",
        ipv4: "IPv4 \u0430\u0434\u0440\u0430\u0441",
        ipv6: "IPv6 \u0430\u0434\u0440\u0430\u0441",
        cidrv4: "IPv4 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
        cidrv6: "IPv6 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
        base64: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64",
        base64url: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64url",
        json_string: "JSON \u0440\u0430\u0434\u043E\u043A",
        e164: "\u043D\u0443\u043C\u0430\u0440 E.164",
        jwt: "JWT",
        template_literal: "\u0443\u0432\u043E\u0434"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u043B\u0456\u043A",
        array: "\u043C\u0430\u0441\u0456\u045E"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F instanceof ${issue3.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
            }
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F ${stringifyPrimitive(issue3.values[0])}`;
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0432\u0430\u0440\u044B\u044F\u043D\u0442: \u0447\u0430\u043A\u0430\u045E\u0441\u044F \u0430\u0434\u0437\u0456\u043D \u0437 ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const maxValue = Number(issue3.maximum);
              const unit = getBelarusianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue3.maximum.toString()} ${unit}`;
            }
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const minValue = Number(issue3.minimum);
              const unit = getBelarusianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue3.minimum.toString()} ${unit}`;
            }
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u043F\u0430\u0447\u044B\u043D\u0430\u0446\u0446\u0430 \u0437 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u0430\u043A\u0430\u043D\u0447\u0432\u0430\u0446\u0446\u0430 \u043D\u0430 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u043C\u044F\u0448\u0447\u0430\u0446\u044C "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0430\u0434\u043F\u0430\u0432\u044F\u0434\u0430\u0446\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043B\u0456\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0431\u044B\u0446\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u0430\u0441\u043F\u0430\u0437\u043D\u0430\u043D\u044B ${issue3.keys.length > 1 ? "\u043A\u043B\u044E\u0447\u044B" : "\u043A\u043B\u044E\u0447"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043A\u043B\u044E\u0447 \u0443 ${issue3.origin}`;
          case "invalid_union":
            return "\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434";
          case "invalid_element":
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u0430\u0435 \u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435 \u045E ${issue3.origin}`;
          default:
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/bg.js
function bg_default() {
  return {
    localeError: error4()
  };
}
var error4;
var init_bg = __esm({
  "node_modules/zod/v4/locales/bg.js"() {
    "use strict";
    init_util();
    error4 = () => {
      const Sizable = {
        string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
        file: { unit: "\u0431\u0430\u0439\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
        array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
        set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0432\u0445\u043E\u0434",
        email: "\u0438\u043C\u0435\u0439\u043B \u0430\u0434\u0440\u0435\u0441",
        url: "URL",
        emoji: "\u0435\u043C\u043E\u0434\u0436\u0438",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0432\u0440\u0435\u043C\u0435",
        date: "ISO \u0434\u0430\u0442\u0430",
        time: "ISO \u0432\u0440\u0435\u043C\u0435",
        duration: "ISO \u043F\u0440\u043E\u0434\u044A\u043B\u0436\u0438\u0442\u0435\u043B\u043D\u043E\u0441\u0442",
        ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
        ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
        cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        base64: "base64-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
        base64url: "base64url-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
        json_string: "JSON \u043D\u0438\u0437",
        e164: "E.164 \u043D\u043E\u043C\u0435\u0440",
        jwt: "JWT",
        template_literal: "\u0432\u0445\u043E\u0434"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0447\u0438\u0441\u043B\u043E",
        array: "\u043C\u0430\u0441\u0438\u0432"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D instanceof ${issue3.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
            }
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${stringifyPrimitive(issue3.values[0])}`;
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u043E\u043F\u0446\u0438\u044F: \u043E\u0447\u0430\u043A\u0432\u0430\u043D\u043E \u0435\u0434\u043D\u043E \u043E\u0442 ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue3.origin ?? "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430"}`;
            return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue3.origin ?? "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue3.origin} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue3.origin} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u0432\u0430 \u0441 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u0432\u044A\u0440\u0448\u0432\u0430 \u0441 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0432\u043A\u043B\u044E\u0447\u0432\u0430 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0441\u044A\u0432\u043F\u0430\u0434\u0430 \u0441 ${_issue.pattern}`;
            let invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D";
            if (_issue.format === "emoji")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
            if (_issue.format === "datetime")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
            if (_issue.format === "date")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
            if (_issue.format === "time")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
            if (_issue.format === "duration")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
            return `${invalid_adj} ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E \u0447\u0438\u0441\u043B\u043E: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0431\u044A\u0434\u0435 \u043A\u0440\u0430\u0442\u043D\u043E \u043D\u0430 ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u0430\u0437\u043F\u043E\u0437\u043D\u0430\u0442${issue3.keys.length > 1 ? "\u0438" : ""} \u043A\u043B\u044E\u0447${issue3.keys.length > 1 ? "\u043E\u0432\u0435" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043A\u043B\u044E\u0447 \u0432 ${issue3.origin}`;
          case "invalid_union":
            return "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434";
          case "invalid_element":
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442 \u0432 ${issue3.origin}`;
          default:
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/ca.js
function ca_default() {
  return {
    localeError: error5()
  };
}
var error5;
var init_ca = __esm({
  "node_modules/zod/v4/locales/ca.js"() {
    "use strict";
    init_util();
    error5 = () => {
      const Sizable = {
        string: { unit: "car\xE0cters", verb: "contenir" },
        file: { unit: "bytes", verb: "contenir" },
        array: { unit: "elements", verb: "contenir" },
        set: { unit: "elements", verb: "contenir" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "entrada",
        email: "adre\xE7a electr\xF2nica",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data i hora ISO",
        date: "data ISO",
        time: "hora ISO",
        duration: "durada ISO",
        ipv4: "adre\xE7a IPv4",
        ipv6: "adre\xE7a IPv6",
        cidrv4: "rang IPv4",
        cidrv6: "rang IPv6",
        base64: "cadena codificada en base64",
        base64url: "cadena codificada en base64url",
        json_string: "cadena JSON",
        e164: "n\xFAmero E.164",
        jwt: "JWT",
        template_literal: "entrada"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Tipus inv\xE0lid: s'esperava instanceof ${issue3.expected}, s'ha rebut ${received}`;
            }
            return `Tipus inv\xE0lid: s'esperava ${expected}, s'ha rebut ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Valor inv\xE0lid: s'esperava ${stringifyPrimitive(issue3.values[0])}`;
            return `Opci\xF3 inv\xE0lida: s'esperava una de ${joinValues(issue3.values, " o ")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "com a m\xE0xim" : "menys de";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Massa gran: s'esperava que ${issue3.origin ?? "el valor"} contingu\xE9s ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "elements"}`;
            return `Massa gran: s'esperava que ${issue3.origin ?? "el valor"} fos ${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "com a m\xEDnim" : "m\xE9s de";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Massa petit: s'esperava que ${issue3.origin} contingu\xE9s ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Massa petit: s'esperava que ${issue3.origin} fos ${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Format inv\xE0lid: ha de comen\xE7ar amb "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Format inv\xE0lid: ha d'acabar amb "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Format inv\xE0lid: ha d'incloure "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Format inv\xE0lid: ha de coincidir amb el patr\xF3 ${_issue.pattern}`;
            return `Format inv\xE0lid per a ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `N\xFAmero inv\xE0lid: ha de ser m\xFAltiple de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Clau${issue3.keys.length > 1 ? "s" : ""} no reconeguda${issue3.keys.length > 1 ? "s" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Clau inv\xE0lida a ${issue3.origin}`;
          case "invalid_union":
            return "Entrada inv\xE0lida";
          // Could also be "Tipus d'unió invàlid" but "Entrada invàlida" is more general
          case "invalid_element":
            return `Element inv\xE0lid a ${issue3.origin}`;
          default:
            return `Entrada inv\xE0lida`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/cs.js
function cs_default() {
  return {
    localeError: error6()
  };
}
var error6;
var init_cs = __esm({
  "node_modules/zod/v4/locales/cs.js"() {
    "use strict";
    init_util();
    error6 = () => {
      const Sizable = {
        string: { unit: "znak\u016F", verb: "m\xEDt" },
        file: { unit: "bajt\u016F", verb: "m\xEDt" },
        array: { unit: "prvk\u016F", verb: "m\xEDt" },
        set: { unit: "prvk\u016F", verb: "m\xEDt" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "regul\xE1rn\xED v\xFDraz",
        email: "e-mailov\xE1 adresa",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "datum a \u010Das ve form\xE1tu ISO",
        date: "datum ve form\xE1tu ISO",
        time: "\u010Das ve form\xE1tu ISO",
        duration: "doba trv\xE1n\xED ISO",
        ipv4: "IPv4 adresa",
        ipv6: "IPv6 adresa",
        cidrv4: "rozsah IPv4",
        cidrv6: "rozsah IPv6",
        base64: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64",
        base64url: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64url",
        json_string: "\u0159et\u011Bzec ve form\xE1tu JSON",
        e164: "\u010D\xEDslo E.164",
        jwt: "JWT",
        template_literal: "vstup"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u010D\xEDslo",
        string: "\u0159et\u011Bzec",
        function: "funkce",
        array: "pole"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no instanceof ${issue3.expected}, obdr\u017Eeno ${received}`;
            }
            return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${expected}, obdr\u017Eeno ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${stringifyPrimitive(issue3.values[0])}`;
            return `Neplatn\xE1 mo\u017Enost: o\u010Dek\xE1v\xE1na jedna z hodnot ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue3.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
            }
            return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue3.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue3.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue3.minimum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
            }
            return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue3.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED za\u010D\xEDnat na "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED kon\u010Dit na "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED obsahovat "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED odpov\xEDdat vzoru ${_issue.pattern}`;
            return `Neplatn\xFD form\xE1t ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Neplatn\xE9 \u010D\xEDslo: mus\xED b\xFDt n\xE1sobkem ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Nezn\xE1m\xE9 kl\xED\u010De: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Neplatn\xFD kl\xED\u010D v ${issue3.origin}`;
          case "invalid_union":
            return "Neplatn\xFD vstup";
          case "invalid_element":
            return `Neplatn\xE1 hodnota v ${issue3.origin}`;
          default:
            return `Neplatn\xFD vstup`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/da.js
function da_default() {
  return {
    localeError: error7()
  };
}
var error7;
var init_da = __esm({
  "node_modules/zod/v4/locales/da.js"() {
    "use strict";
    init_util();
    error7 = () => {
      const Sizable = {
        string: { unit: "tegn", verb: "havde" },
        file: { unit: "bytes", verb: "havde" },
        array: { unit: "elementer", verb: "indeholdt" },
        set: { unit: "elementer", verb: "indeholdt" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "e-mailadresse",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO dato- og klokkesl\xE6t",
        date: "ISO-dato",
        time: "ISO-klokkesl\xE6t",
        duration: "ISO-varighed",
        ipv4: "IPv4-omr\xE5de",
        ipv6: "IPv6-omr\xE5de",
        cidrv4: "IPv4-spektrum",
        cidrv6: "IPv6-spektrum",
        base64: "base64-kodet streng",
        base64url: "base64url-kodet streng",
        json_string: "JSON-streng",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        string: "streng",
        number: "tal",
        boolean: "boolean",
        array: "liste",
        object: "objekt",
        set: "s\xE6t",
        file: "fil"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ugyldigt input: forventede instanceof ${issue3.expected}, fik ${received}`;
            }
            return `Ugyldigt input: forventede ${expected}, fik ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ugyldig v\xE6rdi: forventede ${stringifyPrimitive(issue3.values[0])}`;
            return `Ugyldigt valg: forventede en af f\xF8lgende ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            if (sizing)
              return `For stor: forventede ${origin2 ?? "value"} ${sizing.verb} ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "elementer"}`;
            return `For stor: forventede ${origin2 ?? "value"} havde ${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            if (sizing) {
              return `For lille: forventede ${origin2} ${sizing.verb} ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `For lille: forventede ${origin2} havde ${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Ugyldig streng: skal starte med "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Ugyldig streng: skal ende med "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Ugyldig streng: skal indeholde "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Ugyldig streng: skal matche m\xF8nsteret ${_issue.pattern}`;
            return `Ugyldig ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ugyldigt tal: skal v\xE6re deleligt med ${issue3.divisor}`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Ukendte n\xF8gler" : "Ukendt n\xF8gle"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ugyldig n\xF8gle i ${issue3.origin}`;
          case "invalid_union":
            return "Ugyldigt input: matcher ingen af de tilladte typer";
          case "invalid_element":
            return `Ugyldig v\xE6rdi i ${issue3.origin}`;
          default:
            return `Ugyldigt input`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/de.js
function de_default() {
  return {
    localeError: error8()
  };
}
var error8;
var init_de = __esm({
  "node_modules/zod/v4/locales/de.js"() {
    "use strict";
    init_util();
    error8 = () => {
      const Sizable = {
        string: { unit: "Zeichen", verb: "zu haben" },
        file: { unit: "Bytes", verb: "zu haben" },
        array: { unit: "Elemente", verb: "zu haben" },
        set: { unit: "Elemente", verb: "zu haben" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "Eingabe",
        email: "E-Mail-Adresse",
        url: "URL",
        emoji: "Emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-Datum und -Uhrzeit",
        date: "ISO-Datum",
        time: "ISO-Uhrzeit",
        duration: "ISO-Dauer",
        ipv4: "IPv4-Adresse",
        ipv6: "IPv6-Adresse",
        cidrv4: "IPv4-Bereich",
        cidrv6: "IPv6-Bereich",
        base64: "Base64-codierter String",
        base64url: "Base64-URL-codierter String",
        json_string: "JSON-String",
        e164: "E.164-Nummer",
        jwt: "JWT",
        template_literal: "Eingabe"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "Zahl",
        array: "Array"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ung\xFCltige Eingabe: erwartet instanceof ${issue3.expected}, erhalten ${received}`;
            }
            return `Ung\xFCltige Eingabe: erwartet ${expected}, erhalten ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ung\xFCltige Eingabe: erwartet ${stringifyPrimitive(issue3.values[0])}`;
            return `Ung\xFCltige Option: erwartet eine von ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Zu gro\xDF: erwartet, dass ${issue3.origin ?? "Wert"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "Elemente"} hat`;
            return `Zu gro\xDF: erwartet, dass ${issue3.origin ?? "Wert"} ${adj}${issue3.maximum.toString()} ist`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Zu klein: erwartet, dass ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} hat`;
            }
            return `Zu klein: erwartet, dass ${issue3.origin} ${adj}${issue3.minimum.toString()} ist`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Ung\xFCltiger String: muss mit "${_issue.prefix}" beginnen`;
            if (_issue.format === "ends_with")
              return `Ung\xFCltiger String: muss mit "${_issue.suffix}" enden`;
            if (_issue.format === "includes")
              return `Ung\xFCltiger String: muss "${_issue.includes}" enthalten`;
            if (_issue.format === "regex")
              return `Ung\xFCltiger String: muss dem Muster ${_issue.pattern} entsprechen`;
            return `Ung\xFCltig: ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ung\xFCltige Zahl: muss ein Vielfaches von ${issue3.divisor} sein`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Unbekannte Schl\xFCssel" : "Unbekannter Schl\xFCssel"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ung\xFCltiger Schl\xFCssel in ${issue3.origin}`;
          case "invalid_union":
            return "Ung\xFCltige Eingabe";
          case "invalid_element":
            return `Ung\xFCltiger Wert in ${issue3.origin}`;
          default:
            return `Ung\xFCltige Eingabe`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/en.js
function en_default() {
  return {
    localeError: error9()
  };
}
var error9;
var init_en = __esm({
  "node_modules/zod/v4/locales/en.js"() {
    "use strict";
    init_util();
    error9 = () => {
      const Sizable = {
        string: { unit: "characters", verb: "to have" },
        file: { unit: "bytes", verb: "to have" },
        array: { unit: "items", verb: "to have" },
        set: { unit: "items", verb: "to have" },
        map: { unit: "entries", verb: "to have" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "email address",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datetime",
        date: "ISO date",
        time: "ISO time",
        duration: "ISO duration",
        ipv4: "IPv4 address",
        ipv6: "IPv6 address",
        mac: "MAC address",
        cidrv4: "IPv4 range",
        cidrv6: "IPv6 range",
        base64: "base64-encoded string",
        base64url: "base64url-encoded string",
        json_string: "JSON string",
        e164: "E.164 number",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        // Compatibility: "nan" -> "NaN" for display
        nan: "NaN"
        // All other type names omitted - they fall back to raw values via ?? operator
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            return `Invalid input: expected ${expected}, received ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Invalid input: expected ${stringifyPrimitive(issue3.values[0])}`;
            return `Invalid option: expected one of ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Too big: expected ${issue3.origin ?? "value"} to have ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elements"}`;
            return `Too big: expected ${issue3.origin ?? "value"} to be ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Too small: expected ${issue3.origin} to have ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Too small: expected ${issue3.origin} to be ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Invalid string: must start with "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Invalid string: must end with "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Invalid string: must include "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Invalid string: must match pattern ${_issue.pattern}`;
            return `Invalid ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Invalid number: must be a multiple of ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Unrecognized key${issue3.keys.length > 1 ? "s" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Invalid key in ${issue3.origin}`;
          case "invalid_union":
            return "Invalid input";
          case "invalid_element":
            return `Invalid value in ${issue3.origin}`;
          default:
            return `Invalid input`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/eo.js
function eo_default() {
  return {
    localeError: error10()
  };
}
var error10;
var init_eo = __esm({
  "node_modules/zod/v4/locales/eo.js"() {
    "use strict";
    init_util();
    error10 = () => {
      const Sizable = {
        string: { unit: "karaktrojn", verb: "havi" },
        file: { unit: "bajtojn", verb: "havi" },
        array: { unit: "elementojn", verb: "havi" },
        set: { unit: "elementojn", verb: "havi" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "enigo",
        email: "retadreso",
        url: "URL",
        emoji: "emo\u011Dio",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-datotempo",
        date: "ISO-dato",
        time: "ISO-tempo",
        duration: "ISO-da\u016Dro",
        ipv4: "IPv4-adreso",
        ipv6: "IPv6-adreso",
        cidrv4: "IPv4-rango",
        cidrv6: "IPv6-rango",
        base64: "64-ume kodita karaktraro",
        base64url: "URL-64-ume kodita karaktraro",
        json_string: "JSON-karaktraro",
        e164: "E.164-nombro",
        jwt: "JWT",
        template_literal: "enigo"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "nombro",
        array: "tabelo",
        null: "senvalora"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Nevalida enigo: atendi\u011Dis instanceof ${issue3.expected}, ricevi\u011Dis ${received}`;
            }
            return `Nevalida enigo: atendi\u011Dis ${expected}, ricevi\u011Dis ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Nevalida enigo: atendi\u011Dis ${stringifyPrimitive(issue3.values[0])}`;
            return `Nevalida opcio: atendi\u011Dis unu el ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Tro granda: atendi\u011Dis ke ${issue3.origin ?? "valoro"} havu ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementojn"}`;
            return `Tro granda: atendi\u011Dis ke ${issue3.origin ?? "valoro"} havu ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Tro malgranda: atendi\u011Dis ke ${issue3.origin} havu ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Tro malgranda: atendi\u011Dis ke ${issue3.origin} estu ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Nevalida karaktraro: devas komenci\u011Di per "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Nevalida karaktraro: devas fini\u011Di per "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Nevalida karaktraro: devas inkluzivi "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Nevalida karaktraro: devas kongrui kun la modelo ${_issue.pattern}`;
            return `Nevalida ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Nevalida nombro: devas esti oblo de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Nekonata${issue3.keys.length > 1 ? "j" : ""} \u015Dlosilo${issue3.keys.length > 1 ? "j" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Nevalida \u015Dlosilo en ${issue3.origin}`;
          case "invalid_union":
            return "Nevalida enigo";
          case "invalid_element":
            return `Nevalida valoro en ${issue3.origin}`;
          default:
            return `Nevalida enigo`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/es.js
function es_default() {
  return {
    localeError: error11()
  };
}
var error11;
var init_es = __esm({
  "node_modules/zod/v4/locales/es.js"() {
    "use strict";
    init_util();
    error11 = () => {
      const Sizable = {
        string: { unit: "caracteres", verb: "tener" },
        file: { unit: "bytes", verb: "tener" },
        array: { unit: "elementos", verb: "tener" },
        set: { unit: "elementos", verb: "tener" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "entrada",
        email: "direcci\xF3n de correo electr\xF3nico",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "fecha y hora ISO",
        date: "fecha ISO",
        time: "hora ISO",
        duration: "duraci\xF3n ISO",
        ipv4: "direcci\xF3n IPv4",
        ipv6: "direcci\xF3n IPv6",
        cidrv4: "rango IPv4",
        cidrv6: "rango IPv6",
        base64: "cadena codificada en base64",
        base64url: "URL codificada en base64",
        json_string: "cadena JSON",
        e164: "n\xFAmero E.164",
        jwt: "JWT",
        template_literal: "entrada"
      };
      const TypeDictionary = {
        nan: "NaN",
        string: "texto",
        number: "n\xFAmero",
        boolean: "booleano",
        array: "arreglo",
        object: "objeto",
        set: "conjunto",
        file: "archivo",
        date: "fecha",
        bigint: "n\xFAmero grande",
        symbol: "s\xEDmbolo",
        undefined: "indefinido",
        null: "nulo",
        function: "funci\xF3n",
        map: "mapa",
        record: "registro",
        tuple: "tupla",
        enum: "enumeraci\xF3n",
        union: "uni\xF3n",
        literal: "literal",
        promise: "promesa",
        void: "vac\xEDo",
        never: "nunca",
        unknown: "desconocido",
        any: "cualquiera"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Entrada inv\xE1lida: se esperaba instanceof ${issue3.expected}, recibido ${received}`;
            }
            return `Entrada inv\xE1lida: se esperaba ${expected}, recibido ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Entrada inv\xE1lida: se esperaba ${stringifyPrimitive(issue3.values[0])}`;
            return `Opci\xF3n inv\xE1lida: se esperaba una de ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            if (sizing)
              return `Demasiado grande: se esperaba que ${origin2 ?? "valor"} tuviera ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementos"}`;
            return `Demasiado grande: se esperaba que ${origin2 ?? "valor"} fuera ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            if (sizing) {
              return `Demasiado peque\xF1o: se esperaba que ${origin2} tuviera ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Demasiado peque\xF1o: se esperaba que ${origin2} fuera ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Cadena inv\xE1lida: debe comenzar con "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Cadena inv\xE1lida: debe terminar en "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Cadena inv\xE1lida: debe incluir "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Cadena inv\xE1lida: debe coincidir con el patr\xF3n ${_issue.pattern}`;
            return `Inv\xE1lido ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `N\xFAmero inv\xE1lido: debe ser m\xFAltiplo de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Llave${issue3.keys.length > 1 ? "s" : ""} desconocida${issue3.keys.length > 1 ? "s" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Llave inv\xE1lida en ${TypeDictionary[issue3.origin] ?? issue3.origin}`;
          case "invalid_union":
            return "Entrada inv\xE1lida";
          case "invalid_element":
            return `Valor inv\xE1lido en ${TypeDictionary[issue3.origin] ?? issue3.origin}`;
          default:
            return `Entrada inv\xE1lida`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/fa.js
function fa_default() {
  return {
    localeError: error12()
  };
}
var error12;
var init_fa = __esm({
  "node_modules/zod/v4/locales/fa.js"() {
    "use strict";
    init_util();
    error12 = () => {
      const Sizable = {
        string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
        file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
        array: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
        set: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0648\u0631\u0648\u062F\u06CC",
        email: "\u0622\u062F\u0631\u0633 \u0627\u06CC\u0645\u06CC\u0644",
        url: "URL",
        emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u062A\u0627\u0631\u06CC\u062E \u0648 \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
        date: "\u062A\u0627\u0631\u06CC\u062E \u0627\u06CC\u0632\u0648",
        time: "\u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
        duration: "\u0645\u062F\u062A \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
        ipv4: "IPv4 \u0622\u062F\u0631\u0633",
        ipv6: "IPv6 \u0622\u062F\u0631\u0633",
        cidrv4: "IPv4 \u062F\u0627\u0645\u0646\u0647",
        cidrv6: "IPv6 \u062F\u0627\u0645\u0646\u0647",
        base64: "base64-encoded \u0631\u0634\u062A\u0647",
        base64url: "base64url-encoded \u0631\u0634\u062A\u0647",
        json_string: "JSON \u0631\u0634\u062A\u0647",
        e164: "E.164 \u0639\u062F\u062F",
        jwt: "JWT",
        template_literal: "\u0648\u0631\u0648\u062F\u06CC"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0639\u062F\u062F",
        array: "\u0622\u0631\u0627\u06CC\u0647"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A instanceof ${issue3.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
            }
            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
          }
          case "invalid_value":
            if (issue3.values.length === 1) {
              return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${stringifyPrimitive(issue3.values[0])} \u0645\u06CC\u200C\u0628\u0648\u062F`;
            }
            return `\u06AF\u0632\u06CC\u0646\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A \u06CC\u06A9\u06CC \u0627\u0632 ${joinValues(issue3.values, "|")} \u0645\u06CC\u200C\u0628\u0648\u062F`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue3.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"} \u0628\u0627\u0634\u062F`;
            }
            return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue3.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} \u0628\u0627\u0634\u062F`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} ${sizing.unit} \u0628\u0627\u0634\u062F`;
            }
            return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} \u0628\u0627\u0634\u062F`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.prefix}" \u0634\u0631\u0648\u0639 \u0634\u0648\u062F`;
            }
            if (_issue.format === "ends_with") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.suffix}" \u062A\u0645\u0627\u0645 \u0634\u0648\u062F`;
            }
            if (_issue.format === "includes") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0634\u0627\u0645\u0644 "${_issue.includes}" \u0628\u0627\u0634\u062F`;
            }
            if (_issue.format === "regex") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 \u0627\u0644\u06AF\u0648\u06CC ${_issue.pattern} \u0645\u0637\u0627\u0628\u0642\u062A \u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F`;
            }
            return `${FormatDictionary[_issue.format] ?? issue3.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
          }
          case "not_multiple_of":
            return `\u0639\u062F\u062F \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0645\u0636\u0631\u0628 ${issue3.divisor} \u0628\u0627\u0634\u062F`;
          case "unrecognized_keys":
            return `\u06A9\u0644\u06CC\u062F${issue3.keys.length > 1 ? "\u0647\u0627\u06CC" : ""} \u0646\u0627\u0634\u0646\u0627\u0633: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u06A9\u0644\u06CC\u062F \u0646\u0627\u0634\u0646\u0627\u0633 \u062F\u0631 ${issue3.origin}`;
          case "invalid_union":
            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
          case "invalid_element":
            return `\u0645\u0642\u062F\u0627\u0631 \u0646\u0627\u0645\u0639\u062A\u0628\u0631 \u062F\u0631 ${issue3.origin}`;
          default:
            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/fi.js
function fi_default() {
  return {
    localeError: error13()
  };
}
var error13;
var init_fi = __esm({
  "node_modules/zod/v4/locales/fi.js"() {
    "use strict";
    init_util();
    error13 = () => {
      const Sizable = {
        string: { unit: "merkki\xE4", subject: "merkkijonon" },
        file: { unit: "tavua", subject: "tiedoston" },
        array: { unit: "alkiota", subject: "listan" },
        set: { unit: "alkiota", subject: "joukon" },
        number: { unit: "", subject: "luvun" },
        bigint: { unit: "", subject: "suuren kokonaisluvun" },
        int: { unit: "", subject: "kokonaisluvun" },
        date: { unit: "", subject: "p\xE4iv\xE4m\xE4\xE4r\xE4n" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "s\xE4\xE4nn\xF6llinen lauseke",
        email: "s\xE4hk\xF6postiosoite",
        url: "URL-osoite",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-aikaleima",
        date: "ISO-p\xE4iv\xE4m\xE4\xE4r\xE4",
        time: "ISO-aika",
        duration: "ISO-kesto",
        ipv4: "IPv4-osoite",
        ipv6: "IPv6-osoite",
        cidrv4: "IPv4-alue",
        cidrv6: "IPv6-alue",
        base64: "base64-koodattu merkkijono",
        base64url: "base64url-koodattu merkkijono",
        json_string: "JSON-merkkijono",
        e164: "E.164-luku",
        jwt: "JWT",
        template_literal: "templaattimerkkijono"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Virheellinen tyyppi: odotettiin instanceof ${issue3.expected}, oli ${received}`;
            }
            return `Virheellinen tyyppi: odotettiin ${expected}, oli ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Virheellinen sy\xF6te: t\xE4ytyy olla ${stringifyPrimitive(issue3.values[0])}`;
            return `Virheellinen valinta: t\xE4ytyy olla yksi seuraavista: ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Liian suuri: ${sizing.subject} t\xE4ytyy olla ${adj}${issue3.maximum.toString()} ${sizing.unit}`.trim();
            }
            return `Liian suuri: arvon t\xE4ytyy olla ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Liian pieni: ${sizing.subject} t\xE4ytyy olla ${adj}${issue3.minimum.toString()} ${sizing.unit}`.trim();
            }
            return `Liian pieni: arvon t\xE4ytyy olla ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Virheellinen sy\xF6te: t\xE4ytyy alkaa "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Virheellinen sy\xF6te: t\xE4ytyy loppua "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Virheellinen sy\xF6te: t\xE4ytyy sis\xE4lt\xE4\xE4 "${_issue.includes}"`;
            if (_issue.format === "regex") {
              return `Virheellinen sy\xF6te: t\xE4ytyy vastata s\xE4\xE4nn\xF6llist\xE4 lauseketta ${_issue.pattern}`;
            }
            return `Virheellinen ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Virheellinen luku: t\xE4ytyy olla luvun ${issue3.divisor} monikerta`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Tuntemattomat avaimet" : "Tuntematon avain"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return "Virheellinen avain tietueessa";
          case "invalid_union":
            return "Virheellinen unioni";
          case "invalid_element":
            return "Virheellinen arvo joukossa";
          default:
            return `Virheellinen sy\xF6te`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/fr.js
function fr_default() {
  return {
    localeError: error14()
  };
}
var error14;
var init_fr = __esm({
  "node_modules/zod/v4/locales/fr.js"() {
    "use strict";
    init_util();
    error14 = () => {
      const Sizable = {
        string: { unit: "caract\xE8res", verb: "avoir" },
        file: { unit: "octets", verb: "avoir" },
        array: { unit: "\xE9l\xE9ments", verb: "avoir" },
        set: { unit: "\xE9l\xE9ments", verb: "avoir" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "entr\xE9e",
        email: "adresse e-mail",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "date et heure ISO",
        date: "date ISO",
        time: "heure ISO",
        duration: "dur\xE9e ISO",
        ipv4: "adresse IPv4",
        ipv6: "adresse IPv6",
        cidrv4: "plage IPv4",
        cidrv6: "plage IPv6",
        base64: "cha\xEEne encod\xE9e en base64",
        base64url: "cha\xEEne encod\xE9e en base64url",
        json_string: "cha\xEEne JSON",
        e164: "num\xE9ro E.164",
        jwt: "JWT",
        template_literal: "entr\xE9e"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "nombre",
        array: "tableau"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Entr\xE9e invalide : instanceof ${issue3.expected} attendu, ${received} re\xE7u`;
            }
            return `Entr\xE9e invalide : ${expected} attendu, ${received} re\xE7u`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Entr\xE9e invalide : ${stringifyPrimitive(issue3.values[0])} attendu`;
            return `Option invalide : une valeur parmi ${joinValues(issue3.values, "|")} attendue`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Trop grand : ${issue3.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
            return `Trop grand : ${issue3.origin ?? "valeur"} doit \xEAtre ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Trop petit : ${issue3.origin} doit ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Trop petit : ${issue3.origin} doit \xEAtre ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Cha\xEEne invalide : doit correspondre au mod\xE8le ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} invalide`;
          }
          case "not_multiple_of":
            return `Nombre invalide : doit \xEAtre un multiple de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Cl\xE9${issue3.keys.length > 1 ? "s" : ""} non reconnue${issue3.keys.length > 1 ? "s" : ""} : ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Cl\xE9 invalide dans ${issue3.origin}`;
          case "invalid_union":
            return "Entr\xE9e invalide";
          case "invalid_element":
            return `Valeur invalide dans ${issue3.origin}`;
          default:
            return `Entr\xE9e invalide`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/fr-CA.js
function fr_CA_default() {
  return {
    localeError: error15()
  };
}
var error15;
var init_fr_CA = __esm({
  "node_modules/zod/v4/locales/fr-CA.js"() {
    "use strict";
    init_util();
    error15 = () => {
      const Sizable = {
        string: { unit: "caract\xE8res", verb: "avoir" },
        file: { unit: "octets", verb: "avoir" },
        array: { unit: "\xE9l\xE9ments", verb: "avoir" },
        set: { unit: "\xE9l\xE9ments", verb: "avoir" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "entr\xE9e",
        email: "adresse courriel",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "date-heure ISO",
        date: "date ISO",
        time: "heure ISO",
        duration: "dur\xE9e ISO",
        ipv4: "adresse IPv4",
        ipv6: "adresse IPv6",
        cidrv4: "plage IPv4",
        cidrv6: "plage IPv6",
        base64: "cha\xEEne encod\xE9e en base64",
        base64url: "cha\xEEne encod\xE9e en base64url",
        json_string: "cha\xEEne JSON",
        e164: "num\xE9ro E.164",
        jwt: "JWT",
        template_literal: "entr\xE9e"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Entr\xE9e invalide : attendu instanceof ${issue3.expected}, re\xE7u ${received}`;
            }
            return `Entr\xE9e invalide : attendu ${expected}, re\xE7u ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Entr\xE9e invalide : attendu ${stringifyPrimitive(issue3.values[0])}`;
            return `Option invalide : attendu l'une des valeurs suivantes ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "\u2264" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Trop grand : attendu que ${issue3.origin ?? "la valeur"} ait ${adj}${issue3.maximum.toString()} ${sizing.unit}`;
            return `Trop grand : attendu que ${issue3.origin ?? "la valeur"} soit ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "\u2265" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Trop petit : attendu que ${issue3.origin} ait ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Trop petit : attendu que ${issue3.origin} soit ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Cha\xEEne invalide : doit correspondre au motif ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} invalide`;
          }
          case "not_multiple_of":
            return `Nombre invalide : doit \xEAtre un multiple de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Cl\xE9${issue3.keys.length > 1 ? "s" : ""} non reconnue${issue3.keys.length > 1 ? "s" : ""} : ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Cl\xE9 invalide dans ${issue3.origin}`;
          case "invalid_union":
            return "Entr\xE9e invalide";
          case "invalid_element":
            return `Valeur invalide dans ${issue3.origin}`;
          default:
            return `Entr\xE9e invalide`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/he.js
function he_default() {
  return {
    localeError: error16()
  };
}
var error16;
var init_he = __esm({
  "node_modules/zod/v4/locales/he.js"() {
    "use strict";
    init_util();
    error16 = () => {
      const TypeNames = {
        string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
        number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
        boolean: { label: "\u05E2\u05E8\u05DA \u05D1\u05D5\u05DC\u05D9\u05D0\u05E0\u05D9", gender: "m" },
        bigint: { label: "BigInt", gender: "m" },
        date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA", gender: "m" },
        array: { label: "\u05DE\u05E2\u05E8\u05DA", gender: "m" },
        object: { label: "\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8", gender: "m" },
        null: { label: "\u05E2\u05E8\u05DA \u05E8\u05D9\u05E7 (null)", gender: "m" },
        undefined: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05DE\u05D5\u05D2\u05D3\u05E8 (undefined)", gender: "m" },
        symbol: { label: "\u05E1\u05D9\u05DE\u05D1\u05D5\u05DC (Symbol)", gender: "m" },
        function: { label: "\u05E4\u05D5\u05E0\u05E7\u05E6\u05D9\u05D4", gender: "f" },
        map: { label: "\u05DE\u05E4\u05D4 (Map)", gender: "f" },
        set: { label: "\u05E7\u05D1\u05D5\u05E6\u05D4 (Set)", gender: "f" },
        file: { label: "\u05E7\u05D5\u05D1\u05E5", gender: "m" },
        promise: { label: "Promise", gender: "m" },
        NaN: { label: "NaN", gender: "m" },
        unknown: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05D9\u05D3\u05D5\u05E2", gender: "m" },
        value: { label: "\u05E2\u05E8\u05DA", gender: "m" }
      };
      const Sizable = {
        string: { unit: "\u05EA\u05D5\u05D5\u05D9\u05DD", shortLabel: "\u05E7\u05E6\u05E8", longLabel: "\u05D0\u05E8\u05D5\u05DA" },
        file: { unit: "\u05D1\u05D9\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
        array: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
        set: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
        number: { unit: "", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }
        // no unit
      };
      const typeEntry = (t) => t ? TypeNames[t] : void 0;
      const typeLabel = (t) => {
        const e = typeEntry(t);
        if (e)
          return e.label;
        return t ?? TypeNames.unknown.label;
      };
      const withDefinite = (t) => `\u05D4${typeLabel(t)}`;
      const verbFor = (t) => {
        const e = typeEntry(t);
        const gender = e?.gender ?? "m";
        return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA";
      };
      const getSizing = (origin2) => {
        if (!origin2)
          return null;
        return Sizable[origin2] ?? null;
      };
      const FormatDictionary = {
        regex: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        email: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05D0\u05D9\u05DE\u05D9\u05D9\u05DC", gender: "f" },
        url: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05E8\u05E9\u05EA", gender: "f" },
        emoji: { label: "\u05D0\u05D9\u05DE\u05D5\u05D2'\u05D9", gender: "m" },
        uuid: { label: "UUID", gender: "m" },
        nanoid: { label: "nanoid", gender: "m" },
        guid: { label: "GUID", gender: "m" },
        cuid: { label: "cuid", gender: "m" },
        cuid2: { label: "cuid2", gender: "m" },
        ulid: { label: "ULID", gender: "m" },
        xid: { label: "XID", gender: "m" },
        ksuid: { label: "KSUID", gender: "m" },
        datetime: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA \u05D5\u05D6\u05DE\u05DF ISO", gender: "m" },
        date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA ISO", gender: "m" },
        time: { label: "\u05D6\u05DE\u05DF ISO", gender: "m" },
        duration: { label: "\u05DE\u05E9\u05DA \u05D6\u05DE\u05DF ISO", gender: "m" },
        ipv4: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv4", gender: "f" },
        ipv6: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv6", gender: "f" },
        cidrv4: { label: "\u05D8\u05D5\u05D5\u05D7 IPv4", gender: "m" },
        cidrv6: { label: "\u05D8\u05D5\u05D5\u05D7 IPv6", gender: "m" },
        base64: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64", gender: "f" },
        base64url: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64 \u05DC\u05DB\u05EA\u05D5\u05D1\u05D5\u05EA \u05E8\u05E9\u05EA", gender: "f" },
        json_string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA JSON", gender: "f" },
        e164: { label: "\u05DE\u05E1\u05E4\u05E8 E.164", gender: "m" },
        jwt: { label: "JWT", gender: "m" },
        ends_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        includes: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        lowercase: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        starts_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        uppercase: { label: "\u05E7\u05DC\u05D8", gender: "m" }
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expectedKey = issue3.expected;
            const expected = TypeDictionary[expectedKey ?? ""] ?? typeLabel(expectedKey);
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? TypeNames[receivedType]?.label ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA instanceof ${issue3.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
            }
            return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
          }
          case "invalid_value": {
            if (issue3.values.length === 1) {
              return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05E2\u05E8\u05DA \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA ${stringifyPrimitive(issue3.values[0])}`;
            }
            const stringified = issue3.values.map((v) => stringifyPrimitive(v));
            if (issue3.values.length === 2) {
              return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${stringified[0]} \u05D0\u05D5 ${stringified[1]}`;
            }
            const lastValue = stringified[stringified.length - 1];
            const restValues = stringified.slice(0, -1).join(", ");
            return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${restValues} \u05D0\u05D5 ${lastValue}`;
          }
          case "too_big": {
            const sizing = getSizing(issue3.origin);
            const subject = withDefinite(issue3.origin ?? "value");
            if (issue3.origin === "string") {
              return `${sizing?.longLabel ?? "\u05D0\u05E8\u05D5\u05DA"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue3.maximum.toString()} ${sizing?.unit ?? ""} ${issue3.inclusive ? "\u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA" : "\u05DC\u05DB\u05DC \u05D4\u05D9\u05D5\u05EA\u05E8"}`.trim();
            }
            if (issue3.origin === "number") {
              const comparison = issue3.inclusive ? `\u05E7\u05D8\u05DF \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue3.maximum}` : `\u05E7\u05D8\u05DF \u05DE-${issue3.maximum}`;
              return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
            }
            if (issue3.origin === "array" || issue3.origin === "set") {
              const verb = issue3.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
              const comparison = issue3.inclusive ? `${issue3.maximum} ${sizing?.unit ?? ""} \u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA` : `\u05E4\u05D7\u05D5\u05EA \u05DE-${issue3.maximum} ${sizing?.unit ?? ""}`;
              return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
            }
            const adj = issue3.inclusive ? "<=" : "<";
            const be = verbFor(issue3.origin ?? "value");
            if (sizing?.unit) {
              return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue3.maximum.toString()} ${sizing.unit}`;
            }
            return `${sizing?.longLabel ?? "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const sizing = getSizing(issue3.origin);
            const subject = withDefinite(issue3.origin ?? "value");
            if (issue3.origin === "string") {
              return `${sizing?.shortLabel ?? "\u05E7\u05E6\u05E8"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue3.minimum.toString()} ${sizing?.unit ?? ""} ${issue3.inclusive ? "\u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8" : "\u05DC\u05E4\u05D7\u05D5\u05EA"}`.trim();
            }
            if (issue3.origin === "number") {
              const comparison = issue3.inclusive ? `\u05D2\u05D3\u05D5\u05DC \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue3.minimum}` : `\u05D2\u05D3\u05D5\u05DC \u05DE-${issue3.minimum}`;
              return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
            }
            if (issue3.origin === "array" || issue3.origin === "set") {
              const verb = issue3.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
              if (issue3.minimum === 1 && issue3.inclusive) {
                const singularPhrase = issue3.origin === "set" ? "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3" : "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3";
                return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${singularPhrase}`;
              }
              const comparison = issue3.inclusive ? `${issue3.minimum} ${sizing?.unit ?? ""} \u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8` : `\u05D9\u05D5\u05EA\u05E8 \u05DE-${issue3.minimum} ${sizing?.unit ?? ""}`;
              return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
            }
            const adj = issue3.inclusive ? ">=" : ">";
            const be = verbFor(issue3.origin ?? "value");
            if (sizing?.unit) {
              return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `${sizing?.shortLabel ?? "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D7\u05D9\u05DC \u05D1 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05E1\u05EA\u05D9\u05D9\u05DD \u05D1 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05DB\u05DC\u05D5\u05DC "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${_issue.pattern}`;
            const nounEntry = FormatDictionary[_issue.format];
            const noun = nounEntry?.label ?? _issue.format;
            const gender = nounEntry?.gender ?? "m";
            const adjective = gender === "f" ? "\u05EA\u05E7\u05D9\u05E0\u05D4" : "\u05EA\u05E7\u05D9\u05DF";
            return `${noun} \u05DC\u05D0 ${adjective}`;
          }
          case "not_multiple_of":
            return `\u05DE\u05E1\u05E4\u05E8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA \u05DE\u05DB\u05E4\u05DC\u05D4 \u05E9\u05DC ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u05DE\u05E4\u05EA\u05D7${issue3.keys.length > 1 ? "\u05D5\u05EA" : ""} \u05DC\u05D0 \u05DE\u05D6\u05D5\u05D4${issue3.keys.length > 1 ? "\u05D9\u05DD" : "\u05D4"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key": {
            return `\u05E9\u05D3\u05D4 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8`;
          }
          case "invalid_union":
            return "\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF";
          case "invalid_element": {
            const place = withDefinite(issue3.origin ?? "array");
            return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${place}`;
          }
          default:
            return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/hu.js
function hu_default() {
  return {
    localeError: error17()
  };
}
var error17;
var init_hu = __esm({
  "node_modules/zod/v4/locales/hu.js"() {
    "use strict";
    init_util();
    error17 = () => {
      const Sizable = {
        string: { unit: "karakter", verb: "legyen" },
        file: { unit: "byte", verb: "legyen" },
        array: { unit: "elem", verb: "legyen" },
        set: { unit: "elem", verb: "legyen" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "bemenet",
        email: "email c\xEDm",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO id\u0151b\xE9lyeg",
        date: "ISO d\xE1tum",
        time: "ISO id\u0151",
        duration: "ISO id\u0151intervallum",
        ipv4: "IPv4 c\xEDm",
        ipv6: "IPv6 c\xEDm",
        cidrv4: "IPv4 tartom\xE1ny",
        cidrv6: "IPv6 tartom\xE1ny",
        base64: "base64-k\xF3dolt string",
        base64url: "base64url-k\xF3dolt string",
        json_string: "JSON string",
        e164: "E.164 sz\xE1m",
        jwt: "JWT",
        template_literal: "bemenet"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "sz\xE1m",
        array: "t\xF6mb"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue3.expected}, a kapott \xE9rt\xE9k ${received}`;
            }
            return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue3.values[0])}`;
            return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `T\xFAl nagy: ${issue3.origin ?? "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elem"}`;
            return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${issue3.origin ?? "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue3.origin} m\xE9rete t\xFAl kicsi ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue3.origin} t\xFAl kicsi ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\xC9rv\xE9nytelen string: "${_issue.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`;
            if (_issue.format === "ends_with")
              return `\xC9rv\xE9nytelen string: "${_issue.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`;
            if (_issue.format === "includes")
              return `\xC9rv\xE9nytelen string: "${_issue.includes}" \xE9rt\xE9ket kell tartalmaznia`;
            if (_issue.format === "regex")
              return `\xC9rv\xE9nytelen string: ${_issue.pattern} mint\xE1nak kell megfelelnie`;
            return `\xC9rv\xE9nytelen ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\xC9rv\xE9nytelen sz\xE1m: ${issue3.divisor} t\xF6bbsz\xF6r\xF6s\xE9nek kell lennie`;
          case "unrecognized_keys":
            return `Ismeretlen kulcs${issue3.keys.length > 1 ? "s" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\xC9rv\xE9nytelen kulcs ${issue3.origin}`;
          case "invalid_union":
            return "\xC9rv\xE9nytelen bemenet";
          case "invalid_element":
            return `\xC9rv\xE9nytelen \xE9rt\xE9k: ${issue3.origin}`;
          default:
            return `\xC9rv\xE9nytelen bemenet`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/hy.js
function getArmenianPlural(count, one, many) {
  return Math.abs(count) === 1 ? one : many;
}
function withDefiniteArticle(word) {
  if (!word)
    return "";
  const vowels = ["\u0561", "\u0565", "\u0568", "\u056B", "\u0578", "\u0578\u0582", "\u0585"];
  const lastChar = word[word.length - 1];
  return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
}
function hy_default() {
  return {
    localeError: error18()
  };
}
var error18;
var init_hy = __esm({
  "node_modules/zod/v4/locales/hy.js"() {
    "use strict";
    init_util();
    error18 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "\u0576\u0577\u0561\u0576",
            many: "\u0576\u0577\u0561\u0576\u0576\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        },
        file: {
          unit: {
            one: "\u0562\u0561\u0575\u0569",
            many: "\u0562\u0561\u0575\u0569\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        },
        array: {
          unit: {
            one: "\u057F\u0561\u0580\u0580",
            many: "\u057F\u0561\u0580\u0580\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        },
        set: {
          unit: {
            one: "\u057F\u0561\u0580\u0580",
            many: "\u057F\u0561\u0580\u0580\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0574\u0578\u0582\u057F\u0584",
        email: "\u0567\u056C. \u0570\u0561\u057D\u0581\u0565",
        url: "URL",
        emoji: "\u0567\u0574\u0578\u057B\u056B",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E \u0587 \u056A\u0561\u0574",
        date: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E",
        time: "ISO \u056A\u0561\u0574",
        duration: "ISO \u057F\u0587\u0578\u0572\u0578\u0582\u0569\u0575\u0578\u0582\u0576",
        ipv4: "IPv4 \u0570\u0561\u057D\u0581\u0565",
        ipv6: "IPv6 \u0570\u0561\u057D\u0581\u0565",
        cidrv4: "IPv4 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
        cidrv6: "IPv6 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
        base64: "base64 \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
        base64url: "base64url \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
        json_string: "JSON \u057F\u0578\u0572",
        e164: "E.164 \u0570\u0561\u0574\u0561\u0580",
        jwt: "JWT",
        template_literal: "\u0574\u0578\u0582\u057F\u0584"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0569\u056B\u057E",
        array: "\u0566\u0561\u0576\u0563\u057E\u0561\u056E"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 instanceof ${issue3.expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
            }
            return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${stringifyPrimitive(issue3.values[1])}`;
            return `\u054D\u056D\u0561\u056C \u057F\u0561\u0580\u0562\u0565\u0580\u0561\u056F\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 \u0570\u0565\u057F\u0587\u0575\u0561\u056C\u0576\u0565\u0580\u056B\u0581 \u0574\u0565\u056F\u0568\u055D ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const maxValue = Number(issue3.maximum);
              const unit = getArmenianPlural(maxValue, sizing.unit.one, sizing.unit.many);
              return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue3.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue3.maximum.toString()} ${unit}`;
            }
            return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue3.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056C\u056B\u0576\u056B ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const minValue = Number(issue3.minimum);
              const unit = getArmenianPlural(minValue, sizing.unit.one, sizing.unit.many);
              return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue3.origin)} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue3.minimum.toString()} ${unit}`;
            }
            return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue3.origin)} \u056C\u056B\u0576\u056B ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057D\u056F\u057D\u057E\u056B "${_issue.prefix}"-\u0578\u057E`;
            if (_issue.format === "ends_with")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0561\u057E\u0561\u0580\u057F\u057E\u056B "${_issue.suffix}"-\u0578\u057E`;
            if (_issue.format === "includes")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057A\u0561\u0580\u0578\u0582\u0576\u0561\u056F\u056B "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0570\u0561\u0574\u0561\u057A\u0561\u057F\u0561\u057D\u056D\u0561\u0576\u056B ${_issue.pattern} \u0571\u0587\u0561\u0579\u0561\u0583\u056B\u0576`;
            return `\u054D\u056D\u0561\u056C ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u054D\u056D\u0561\u056C \u0569\u056B\u057E\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0562\u0561\u0566\u0574\u0561\u057A\u0561\u057F\u056B\u056F \u056C\u056B\u0576\u056B ${issue3.divisor}-\u056B`;
          case "unrecognized_keys":
            return `\u0549\u0573\u0561\u0576\u0561\u0579\u057E\u0561\u056E \u0562\u0561\u0576\u0561\u056C\u056B${issue3.keys.length > 1 ? "\u0576\u0565\u0580" : ""}. ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u054D\u056D\u0561\u056C \u0562\u0561\u0576\u0561\u056C\u056B ${withDefiniteArticle(issue3.origin)}-\u0578\u0582\u0574`;
          case "invalid_union":
            return "\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574";
          case "invalid_element":
            return `\u054D\u056D\u0561\u056C \u0561\u0580\u056A\u0565\u0584 ${withDefiniteArticle(issue3.origin)}-\u0578\u0582\u0574`;
          default:
            return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/id.js
function id_default() {
  return {
    localeError: error19()
  };
}
var error19;
var init_id = __esm({
  "node_modules/zod/v4/locales/id.js"() {
    "use strict";
    init_util();
    error19 = () => {
      const Sizable = {
        string: { unit: "karakter", verb: "memiliki" },
        file: { unit: "byte", verb: "memiliki" },
        array: { unit: "item", verb: "memiliki" },
        set: { unit: "item", verb: "memiliki" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "alamat email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "tanggal dan waktu format ISO",
        date: "tanggal format ISO",
        time: "jam format ISO",
        duration: "durasi format ISO",
        ipv4: "alamat IPv4",
        ipv6: "alamat IPv6",
        cidrv4: "rentang alamat IPv4",
        cidrv6: "rentang alamat IPv6",
        base64: "string dengan enkode base64",
        base64url: "string dengan enkode base64url",
        json_string: "string JSON",
        e164: "angka E.164",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Input tidak valid: diharapkan instanceof ${issue3.expected}, diterima ${received}`;
            }
            return `Input tidak valid: diharapkan ${expected}, diterima ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Input tidak valid: diharapkan ${stringifyPrimitive(issue3.values[0])}`;
            return `Pilihan tidak valid: diharapkan salah satu dari ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Terlalu besar: diharapkan ${issue3.origin ?? "value"} memiliki ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elemen"}`;
            return `Terlalu besar: diharapkan ${issue3.origin ?? "value"} menjadi ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Terlalu kecil: diharapkan ${issue3.origin} memiliki ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Terlalu kecil: diharapkan ${issue3.origin} menjadi ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `String tidak valid: harus dimulai dengan "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `String tidak valid: harus berakhir dengan "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `String tidak valid: harus menyertakan "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `String tidak valid: harus sesuai pola ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} tidak valid`;
          }
          case "not_multiple_of":
            return `Angka tidak valid: harus kelipatan dari ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Kunci tidak dikenali ${issue3.keys.length > 1 ? "s" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Kunci tidak valid di ${issue3.origin}`;
          case "invalid_union":
            return "Input tidak valid";
          case "invalid_element":
            return `Nilai tidak valid di ${issue3.origin}`;
          default:
            return `Input tidak valid`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/is.js
function is_default() {
  return {
    localeError: error20()
  };
}
var error20;
var init_is = __esm({
  "node_modules/zod/v4/locales/is.js"() {
    "use strict";
    init_util();
    error20 = () => {
      const Sizable = {
        string: { unit: "stafi", verb: "a\xF0 hafa" },
        file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
        array: { unit: "hluti", verb: "a\xF0 hafa" },
        set: { unit: "hluti", verb: "a\xF0 hafa" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "gildi",
        email: "netfang",
        url: "vefsl\xF3\xF0",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO dagsetning og t\xEDmi",
        date: "ISO dagsetning",
        time: "ISO t\xEDmi",
        duration: "ISO t\xEDmalengd",
        ipv4: "IPv4 address",
        ipv6: "IPv6 address",
        cidrv4: "IPv4 range",
        cidrv6: "IPv6 range",
        base64: "base64-encoded strengur",
        base64url: "base64url-encoded strengur",
        json_string: "JSON strengur",
        e164: "E.164 t\xF6lugildi",
        jwt: "JWT",
        template_literal: "gildi"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "n\xFAmer",
        array: "fylki"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera instanceof ${issue3.expected}`;
            }
            return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera ${expected}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Rangt gildi: gert r\xE1\xF0 fyrir ${stringifyPrimitive(issue3.values[0])}`;
            return `\xD3gilt val: m\xE1 vera eitt af eftirfarandi ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin ?? "gildi"} hafi ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "hluti"}`;
            return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin ?? "gildi"} s\xE9 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin} hafi ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin} s\xE9 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\xD3gildur strengur: ver\xF0ur a\xF0 byrja \xE1 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\xD3gildur strengur: ver\xF0ur a\xF0 enda \xE1 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\xD3gildur strengur: ver\xF0ur a\xF0 innihalda "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\xD3gildur strengur: ver\xF0ur a\xF0 fylgja mynstri ${_issue.pattern}`;
            return `Rangt ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `R\xF6ng tala: ver\xF0ur a\xF0 vera margfeldi af ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\xD3\xFEekkt ${issue3.keys.length > 1 ? "ir lyklar" : "ur lykill"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Rangur lykill \xED ${issue3.origin}`;
          case "invalid_union":
            return "Rangt gildi";
          case "invalid_element":
            return `Rangt gildi \xED ${issue3.origin}`;
          default:
            return `Rangt gildi`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/it.js
function it_default() {
  return {
    localeError: error21()
  };
}
var error21;
var init_it = __esm({
  "node_modules/zod/v4/locales/it.js"() {
    "use strict";
    init_util();
    error21 = () => {
      const Sizable = {
        string: { unit: "caratteri", verb: "avere" },
        file: { unit: "byte", verb: "avere" },
        array: { unit: "elementi", verb: "avere" },
        set: { unit: "elementi", verb: "avere" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "indirizzo email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data e ora ISO",
        date: "data ISO",
        time: "ora ISO",
        duration: "durata ISO",
        ipv4: "indirizzo IPv4",
        ipv6: "indirizzo IPv6",
        cidrv4: "intervallo IPv4",
        cidrv6: "intervallo IPv6",
        base64: "stringa codificata in base64",
        base64url: "URL codificata in base64",
        json_string: "stringa JSON",
        e164: "numero E.164",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "numero",
        array: "vettore"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Input non valido: atteso instanceof ${issue3.expected}, ricevuto ${received}`;
            }
            return `Input non valido: atteso ${expected}, ricevuto ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Input non valido: atteso ${stringifyPrimitive(issue3.values[0])}`;
            return `Opzione non valida: atteso uno tra ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Troppo grande: ${issue3.origin ?? "valore"} deve avere ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementi"}`;
            return `Troppo grande: ${issue3.origin ?? "valore"} deve essere ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Troppo piccolo: ${issue3.origin} deve avere ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Troppo piccolo: ${issue3.origin} deve essere ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Stringa non valida: deve iniziare con "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Stringa non valida: deve terminare con "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Stringa non valida: deve includere "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
            return `Invalid ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Numero non valido: deve essere un multiplo di ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Chiav${issue3.keys.length > 1 ? "i" : "e"} non riconosciut${issue3.keys.length > 1 ? "e" : "a"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Chiave non valida in ${issue3.origin}`;
          case "invalid_union":
            return "Input non valido";
          case "invalid_element":
            return `Valore non valido in ${issue3.origin}`;
          default:
            return `Input non valido`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/ja.js
function ja_default() {
  return {
    localeError: error22()
  };
}
var error22;
var init_ja = __esm({
  "node_modules/zod/v4/locales/ja.js"() {
    "use strict";
    init_util();
    error22 = () => {
      const Sizable = {
        string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
        file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
        array: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" },
        set: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u5165\u529B\u5024",
        email: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9",
        url: "URL",
        emoji: "\u7D75\u6587\u5B57",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO\u65E5\u6642",
        date: "ISO\u65E5\u4ED8",
        time: "ISO\u6642\u523B",
        duration: "ISO\u671F\u9593",
        ipv4: "IPv4\u30A2\u30C9\u30EC\u30B9",
        ipv6: "IPv6\u30A2\u30C9\u30EC\u30B9",
        cidrv4: "IPv4\u7BC4\u56F2",
        cidrv6: "IPv6\u7BC4\u56F2",
        base64: "base64\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
        base64url: "base64url\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
        json_string: "JSON\u6587\u5B57\u5217",
        e164: "E.164\u756A\u53F7",
        jwt: "JWT",
        template_literal: "\u5165\u529B\u5024"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u6570\u5024",
        array: "\u914D\u5217"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u7121\u52B9\u306A\u5165\u529B: instanceof ${issue3.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
            }
            return `\u7121\u52B9\u306A\u5165\u529B: ${expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u7121\u52B9\u306A\u5165\u529B: ${stringifyPrimitive(issue3.values[0])}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F`;
            return `\u7121\u52B9\u306A\u9078\u629E: ${joinValues(issue3.values, "\u3001")}\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          case "too_big": {
            const adj = issue3.inclusive ? "\u4EE5\u4E0B\u3067\u3042\u308B" : "\u3088\u308A\u5C0F\u3055\u3044";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue3.origin ?? "\u5024"}\u306F${issue3.maximum.toString()}${sizing.unit ?? "\u8981\u7D20"}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue3.origin ?? "\u5024"}\u306F${issue3.maximum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "\u4EE5\u4E0A\u3067\u3042\u308B" : "\u3088\u308A\u5927\u304D\u3044";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue3.origin}\u306F${issue3.minimum.toString()}${sizing.unit}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue3.origin}\u306F${issue3.minimum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.prefix}"\u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            if (_issue.format === "ends_with")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.suffix}"\u3067\u7D42\u308F\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            if (_issue.format === "includes")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.includes}"\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            if (_issue.format === "regex")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: \u30D1\u30BF\u30FC\u30F3${_issue.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            return `\u7121\u52B9\u306A${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u7121\u52B9\u306A\u6570\u5024: ${issue3.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          case "unrecognized_keys":
            return `\u8A8D\u8B58\u3055\u308C\u3066\u3044\u306A\u3044\u30AD\u30FC${issue3.keys.length > 1 ? "\u7FA4" : ""}: ${joinValues(issue3.keys, "\u3001")}`;
          case "invalid_key":
            return `${issue3.origin}\u5185\u306E\u7121\u52B9\u306A\u30AD\u30FC`;
          case "invalid_union":
            return "\u7121\u52B9\u306A\u5165\u529B";
          case "invalid_element":
            return `${issue3.origin}\u5185\u306E\u7121\u52B9\u306A\u5024`;
          default:
            return `\u7121\u52B9\u306A\u5165\u529B`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/ka.js
function ka_default() {
  return {
    localeError: error23()
  };
}
var error23;
var init_ka = __esm({
  "node_modules/zod/v4/locales/ka.js"() {
    "use strict";
    init_util();
    error23 = () => {
      const Sizable = {
        string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
        file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
        array: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
        set: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0",
        email: "\u10D4\u10DA-\u10E4\u10DD\u10E1\u10E2\u10D8\u10E1 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
        url: "URL",
        emoji: "\u10D4\u10DB\u10DD\u10EF\u10D8",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8-\u10D3\u10E0\u10DD",
        date: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8",
        time: "\u10D3\u10E0\u10DD",
        duration: "\u10EE\u10D0\u10DC\u10D2\u10E0\u10EB\u10DA\u10D8\u10D5\u10DD\u10D1\u10D0",
        ipv4: "IPv4 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
        ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
        cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
        cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
        base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
        jwt: "JWT",
        template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
        string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
        function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
        array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 instanceof ${issue3.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
            }
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${stringifyPrimitive(issue3.values[0])}`;
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D0\u10E0\u10D8\u10D0\u10DC\u10E2\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8\u10D0 \u10D4\u10E0\u10D7-\u10D4\u10E0\u10D7\u10D8 ${joinValues(issue3.values, "|")}-\u10D3\u10D0\u10DC`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit}`;
            return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
            }
            if (_issue.format === "ends_with")
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
            if (_issue.format === "includes")
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
            if (_issue.format === "regex")
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E0\u10D8\u10EA\u10EE\u10D5\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10E7\u10DD\u10E1 ${issue3.divisor}-\u10D8\u10E1 \u10EF\u10D4\u10E0\u10D0\u10D3\u10D8`;
          case "unrecognized_keys":
            return `\u10E3\u10EA\u10DC\u10DD\u10D1\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1${issue3.keys.length > 1 ? "\u10D4\u10D1\u10D8" : "\u10D8"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1\u10D8 ${issue3.origin}-\u10E8\u10D8`;
          case "invalid_union":
            return "\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0";
          case "invalid_element":
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0 ${issue3.origin}-\u10E8\u10D8`;
          default:
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/km.js
function km_default() {
  return {
    localeError: error24()
  };
}
var error24;
var init_km = __esm({
  "node_modules/zod/v4/locales/km.js"() {
    "use strict";
    init_util();
    error24 = () => {
      const Sizable = {
        string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
        file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
        array: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
        set: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B",
        email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B",
        url: "URL",
        emoji: "\u179F\u1789\u17D2\u1789\u17B6\u17A2\u17B6\u179A\u1798\u17D2\u1798\u178E\u17CD",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 \u1793\u17B7\u1784\u1798\u17C9\u17C4\u1784 ISO",
        date: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 ISO",
        time: "\u1798\u17C9\u17C4\u1784 ISO",
        duration: "\u179A\u1799\u17C8\u1796\u17C1\u179B ISO",
        ipv4: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
        ipv6: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
        cidrv4: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
        cidrv6: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
        base64: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64",
        base64url: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64url",
        json_string: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A JSON",
        e164: "\u179B\u17C1\u1781 E.164",
        jwt: "JWT",
        template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u179B\u17C1\u1781",
        array: "\u17A2\u17B6\u179A\u17C1 (Array)",
        null: "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A instanceof ${issue3.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
            }
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${stringifyPrimitive(issue3.values[0])}`;
            return `\u1787\u1798\u17D2\u179A\u17BE\u179F\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1787\u17B6\u1798\u17BD\u1799\u1780\u17D2\u1793\u17BB\u1784\u1785\u17C6\u178E\u17C4\u1798 ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "\u1792\u17B6\u178F\u17BB"}`;
            return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin} ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin} ${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1785\u17B6\u1794\u17CB\u1795\u17D2\u178F\u17BE\u1798\u178A\u17C4\u1799 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1794\u1789\u17D2\u1785\u1794\u17CB\u178A\u17C4\u1799 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${_issue.pattern}`;
            return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u179A\u1780\u1783\u17BE\u1789\u179F\u17C4\u1798\u17B7\u1793\u179F\u17D2\u1782\u17B6\u179B\u17CB\u17D6 ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u179F\u17C4\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue3.origin}`;
          case "invalid_union":
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
          case "invalid_element":
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue3.origin}`;
          default:
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/kh.js
function kh_default() {
  return km_default();
}
var init_kh = __esm({
  "node_modules/zod/v4/locales/kh.js"() {
    "use strict";
    init_km();
  }
});

// node_modules/zod/v4/locales/ko.js
function ko_default() {
  return {
    localeError: error25()
  };
}
var error25;
var init_ko = __esm({
  "node_modules/zod/v4/locales/ko.js"() {
    "use strict";
    init_util();
    error25 = () => {
      const Sizable = {
        string: { unit: "\uBB38\uC790", verb: "to have" },
        file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
        array: { unit: "\uAC1C", verb: "to have" },
        set: { unit: "\uAC1C", verb: "to have" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\uC785\uB825",
        email: "\uC774\uBA54\uC77C \uC8FC\uC18C",
        url: "URL",
        emoji: "\uC774\uBAA8\uC9C0",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \uB0A0\uC9DC\uC2DC\uAC04",
        date: "ISO \uB0A0\uC9DC",
        time: "ISO \uC2DC\uAC04",
        duration: "ISO \uAE30\uAC04",
        ipv4: "IPv4 \uC8FC\uC18C",
        ipv6: "IPv6 \uC8FC\uC18C",
        cidrv4: "IPv4 \uBC94\uC704",
        cidrv6: "IPv6 \uBC94\uC704",
        base64: "base64 \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
        base64url: "base64url \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
        json_string: "JSON \uBB38\uC790\uC5F4",
        e164: "E.164 \uBC88\uD638",
        jwt: "JWT",
        template_literal: "\uC785\uB825"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 instanceof ${issue3.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
            }
            return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${stringifyPrimitive(issue3.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`;
            return `\uC798\uBABB\uB41C \uC635\uC158: ${joinValues(issue3.values, "\uB610\uB294 ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
          case "too_big": {
            const adj = issue3.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC";
            const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
            const sizing = getSizing(issue3.origin);
            const unit = sizing?.unit ?? "\uC694\uC18C";
            if (sizing)
              return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue3.maximum.toString()}${unit} ${adj}${suffix}`;
            return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue3.maximum.toString()} ${adj}${suffix}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC";
            const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
            const sizing = getSizing(issue3.origin);
            const unit = sizing?.unit ?? "\uC694\uC18C";
            if (sizing) {
              return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue3.minimum.toString()}${unit} ${adj}${suffix}`;
            }
            return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue3.minimum.toString()} ${adj}${suffix}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.prefix}"(\uC73C)\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4`;
            }
            if (_issue.format === "ends_with")
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.suffix}"(\uC73C)\uB85C \uB05D\uB098\uC57C \uD569\uB2C8\uB2E4`;
            if (_issue.format === "includes")
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`;
            if (_issue.format === "regex")
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${_issue.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`;
            return `\uC798\uBABB\uB41C ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\uC798\uBABB\uB41C \uC22B\uC790: ${issue3.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
          case "unrecognized_keys":
            return `\uC778\uC2DD\uD560 \uC218 \uC5C6\uB294 \uD0A4: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\uC798\uBABB\uB41C \uD0A4: ${issue3.origin}`;
          case "invalid_union":
            return `\uC798\uBABB\uB41C \uC785\uB825`;
          case "invalid_element":
            return `\uC798\uBABB\uB41C \uAC12: ${issue3.origin}`;
          default:
            return `\uC798\uBABB\uB41C \uC785\uB825`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/lt.js
function getUnitTypeFromNumber(number5) {
  const abs = Math.abs(number5);
  const last = abs % 10;
  const last2 = abs % 100;
  if (last2 >= 11 && last2 <= 19 || last === 0)
    return "many";
  if (last === 1)
    return "one";
  return "few";
}
function lt_default() {
  return {
    localeError: error26()
  };
}
var capitalizeFirstCharacter, error26;
var init_lt = __esm({
  "node_modules/zod/v4/locales/lt.js"() {
    "use strict";
    init_util();
    capitalizeFirstCharacter = (text2) => {
      return text2.charAt(0).toUpperCase() + text2.slice(1);
    };
    error26 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "simbolis",
            few: "simboliai",
            many: "simboli\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi b\u016Bti ne ilgesn\u0117 kaip",
              notInclusive: "turi b\u016Bti trumpesn\u0117 kaip"
            },
            bigger: {
              inclusive: "turi b\u016Bti ne trumpesn\u0117 kaip",
              notInclusive: "turi b\u016Bti ilgesn\u0117 kaip"
            }
          }
        },
        file: {
          unit: {
            one: "baitas",
            few: "baitai",
            many: "bait\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi b\u016Bti ne didesnis kaip",
              notInclusive: "turi b\u016Bti ma\u017Eesnis kaip"
            },
            bigger: {
              inclusive: "turi b\u016Bti ne ma\u017Eesnis kaip",
              notInclusive: "turi b\u016Bti didesnis kaip"
            }
          }
        },
        array: {
          unit: {
            one: "element\u0105",
            few: "elementus",
            many: "element\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi tur\u0117ti ne daugiau kaip",
              notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
            },
            bigger: {
              inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
              notInclusive: "turi tur\u0117ti daugiau kaip"
            }
          }
        },
        set: {
          unit: {
            one: "element\u0105",
            few: "elementus",
            many: "element\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi tur\u0117ti ne daugiau kaip",
              notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
            },
            bigger: {
              inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
              notInclusive: "turi tur\u0117ti daugiau kaip"
            }
          }
        }
      };
      function getSizing(origin2, unitType, inclusive, targetShouldBe) {
        const result = Sizable[origin2] ?? null;
        if (result === null)
          return result;
        return {
          unit: result.unit[unitType],
          verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
        };
      }
      const FormatDictionary = {
        regex: "\u012Fvestis",
        email: "el. pa\u0161to adresas",
        url: "URL",
        emoji: "jaustukas",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO data ir laikas",
        date: "ISO data",
        time: "ISO laikas",
        duration: "ISO trukm\u0117",
        ipv4: "IPv4 adresas",
        ipv6: "IPv6 adresas",
        cidrv4: "IPv4 tinklo prefiksas (CIDR)",
        cidrv6: "IPv6 tinklo prefiksas (CIDR)",
        base64: "base64 u\u017Ekoduota eilut\u0117",
        base64url: "base64url u\u017Ekoduota eilut\u0117",
        json_string: "JSON eilut\u0117",
        e164: "E.164 numeris",
        jwt: "JWT",
        template_literal: "\u012Fvestis"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "skai\u010Dius",
        bigint: "sveikasis skai\u010Dius",
        string: "eilut\u0117",
        boolean: "login\u0117 reik\u0161m\u0117",
        undefined: "neapibr\u0117\u017Eta reik\u0161m\u0117",
        function: "funkcija",
        symbol: "simbolis",
        array: "masyvas",
        object: "objektas",
        null: "nulin\u0117 reik\u0161m\u0117"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Gautas tipas ${received}, o tik\u0117tasi - instanceof ${issue3.expected}`;
            }
            return `Gautas tipas ${received}, o tik\u0117tasi - ${expected}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Privalo b\u016Bti ${stringifyPrimitive(issue3.values[0])}`;
            return `Privalo b\u016Bti vienas i\u0161 ${joinValues(issue3.values, "|")} pasirinkim\u0173`;
          case "too_big": {
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            const sizing = getSizing(issue3.origin, getUnitTypeFromNumber(Number(issue3.maximum)), issue3.inclusive ?? false, "smaller");
            if (sizing?.verb)
              return `${capitalizeFirstCharacter(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue3.maximum.toString()} ${sizing.unit ?? "element\u0173"}`;
            const adj = issue3.inclusive ? "ne didesnis kaip" : "ma\u017Eesnis kaip";
            return `${capitalizeFirstCharacter(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue3.maximum.toString()} ${sizing?.unit}`;
          }
          case "too_small": {
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            const sizing = getSizing(issue3.origin, getUnitTypeFromNumber(Number(issue3.minimum)), issue3.inclusive ?? false, "bigger");
            if (sizing?.verb)
              return `${capitalizeFirstCharacter(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue3.minimum.toString()} ${sizing.unit ?? "element\u0173"}`;
            const adj = issue3.inclusive ? "ne ma\u017Eesnis kaip" : "didesnis kaip";
            return `${capitalizeFirstCharacter(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue3.minimum.toString()} ${sizing?.unit}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Eilut\u0117 privalo prasid\u0117ti "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Eilut\u0117 privalo pasibaigti "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Eilut\u0117 privalo \u012Ftraukti "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Eilut\u0117 privalo atitikti ${_issue.pattern}`;
            return `Neteisingas ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Skai\u010Dius privalo b\u016Bti ${issue3.divisor} kartotinis.`;
          case "unrecognized_keys":
            return `Neatpa\u017Eint${issue3.keys.length > 1 ? "i" : "as"} rakt${issue3.keys.length > 1 ? "ai" : "as"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return "Rastas klaidingas raktas";
          case "invalid_union":
            return "Klaidinga \u012Fvestis";
          case "invalid_element": {
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            return `${capitalizeFirstCharacter(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} turi klaiding\u0105 \u012Fvest\u012F`;
          }
          default:
            return "Klaidinga \u012Fvestis";
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/mk.js
function mk_default() {
  return {
    localeError: error27()
  };
}
var error27;
var init_mk = __esm({
  "node_modules/zod/v4/locales/mk.js"() {
    "use strict";
    init_util();
    error27 = () => {
      const Sizable = {
        string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
        file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
        array: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
        set: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0432\u043D\u0435\u0441",
        email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430",
        url: "URL",
        emoji: "\u0435\u043C\u043E\u045F\u0438",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0434\u0430\u0442\u0443\u043C \u0438 \u0432\u0440\u0435\u043C\u0435",
        date: "ISO \u0434\u0430\u0442\u0443\u043C",
        time: "ISO \u0432\u0440\u0435\u043C\u0435",
        duration: "ISO \u0432\u0440\u0435\u043C\u0435\u0442\u0440\u0430\u0435\u045A\u0435",
        ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441\u0430",
        ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441\u0430",
        cidrv4: "IPv4 \u043E\u043F\u0441\u0435\u0433",
        cidrv6: "IPv6 \u043E\u043F\u0441\u0435\u0433",
        base64: "base64-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
        base64url: "base64url-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
        json_string: "JSON \u043D\u0438\u0437\u0430",
        e164: "E.164 \u0431\u0440\u043E\u0458",
        jwt: "JWT",
        template_literal: "\u0432\u043D\u0435\u0441"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0431\u0440\u043E\u0458",
        array: "\u043D\u0438\u0437\u0430"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 instanceof ${issue3.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
            }
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Invalid input: expected ${stringifyPrimitive(issue3.values[0])}`;
            return `\u0413\u0440\u0435\u0448\u0430\u043D\u0430 \u043E\u043F\u0446\u0438\u0458\u0430: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 \u0435\u0434\u043D\u0430 ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0438"}`;
            return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u043D\u0443\u0432\u0430 \u0441\u043E "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u0432\u0440\u0448\u0443\u0432\u0430 \u0441\u043E "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${_issue.pattern}`;
            return `Invalid ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${issue3.divisor}`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D\u0438 \u043A\u043B\u0443\u0447\u0435\u0432\u0438" : "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D \u043A\u043B\u0443\u0447"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u043A\u043B\u0443\u0447 \u0432\u043E ${issue3.origin}`;
          case "invalid_union":
            return "\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441";
          case "invalid_element":
            return `\u0413\u0440\u0435\u0448\u043D\u0430 \u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442 \u0432\u043E ${issue3.origin}`;
          default:
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/ms.js
function ms_default() {
  return {
    localeError: error28()
  };
}
var error28;
var init_ms = __esm({
  "node_modules/zod/v4/locales/ms.js"() {
    "use strict";
    init_util();
    error28 = () => {
      const Sizable = {
        string: { unit: "aksara", verb: "mempunyai" },
        file: { unit: "bait", verb: "mempunyai" },
        array: { unit: "elemen", verb: "mempunyai" },
        set: { unit: "elemen", verb: "mempunyai" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "alamat e-mel",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "tarikh masa ISO",
        date: "tarikh ISO",
        time: "masa ISO",
        duration: "tempoh ISO",
        ipv4: "alamat IPv4",
        ipv6: "alamat IPv6",
        cidrv4: "julat IPv4",
        cidrv6: "julat IPv6",
        base64: "string dikodkan base64",
        base64url: "string dikodkan base64url",
        json_string: "string JSON",
        e164: "nombor E.164",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "nombor"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Input tidak sah: dijangka instanceof ${issue3.expected}, diterima ${received}`;
            }
            return `Input tidak sah: dijangka ${expected}, diterima ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Input tidak sah: dijangka ${stringifyPrimitive(issue3.values[0])}`;
            return `Pilihan tidak sah: dijangka salah satu daripada ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Terlalu besar: dijangka ${issue3.origin ?? "nilai"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elemen"}`;
            return `Terlalu besar: dijangka ${issue3.origin ?? "nilai"} adalah ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Terlalu kecil: dijangka ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Terlalu kecil: dijangka ${issue3.origin} adalah ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `String tidak sah: mesti bermula dengan "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `String tidak sah: mesti berakhir dengan "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `String tidak sah: mesti mengandungi "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} tidak sah`;
          }
          case "not_multiple_of":
            return `Nombor tidak sah: perlu gandaan ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Kunci tidak dikenali: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Kunci tidak sah dalam ${issue3.origin}`;
          case "invalid_union":
            return "Input tidak sah";
          case "invalid_element":
            return `Nilai tidak sah dalam ${issue3.origin}`;
          default:
            return `Input tidak sah`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/nl.js
function nl_default() {
  return {
    localeError: error29()
  };
}
var error29;
var init_nl = __esm({
  "node_modules/zod/v4/locales/nl.js"() {
    "use strict";
    init_util();
    error29 = () => {
      const Sizable = {
        string: { unit: "tekens", verb: "heeft" },
        file: { unit: "bytes", verb: "heeft" },
        array: { unit: "elementen", verb: "heeft" },
        set: { unit: "elementen", verb: "heeft" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "invoer",
        email: "emailadres",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datum en tijd",
        date: "ISO datum",
        time: "ISO tijd",
        duration: "ISO duur",
        ipv4: "IPv4-adres",
        ipv6: "IPv6-adres",
        cidrv4: "IPv4-bereik",
        cidrv6: "IPv6-bereik",
        base64: "base64-gecodeerde tekst",
        base64url: "base64 URL-gecodeerde tekst",
        json_string: "JSON string",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "invoer"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "getal"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ongeldige invoer: verwacht instanceof ${issue3.expected}, ontving ${received}`;
            }
            return `Ongeldige invoer: verwacht ${expected}, ontving ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ongeldige invoer: verwacht ${stringifyPrimitive(issue3.values[0])}`;
            return `Ongeldige optie: verwacht \xE9\xE9n van ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            const longName = issue3.origin === "date" ? "laat" : issue3.origin === "string" ? "lang" : "groot";
            if (sizing)
              return `Te ${longName}: verwacht dat ${issue3.origin ?? "waarde"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementen"} ${sizing.verb}`;
            return `Te ${longName}: verwacht dat ${issue3.origin ?? "waarde"} ${adj}${issue3.maximum.toString()} is`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            const shortName = issue3.origin === "date" ? "vroeg" : issue3.origin === "string" ? "kort" : "klein";
            if (sizing) {
              return `Te ${shortName}: verwacht dat ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
            }
            return `Te ${shortName}: verwacht dat ${issue3.origin} ${adj}${issue3.minimum.toString()} is`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Ongeldige tekst: moet met "${_issue.prefix}" beginnen`;
            }
            if (_issue.format === "ends_with")
              return `Ongeldige tekst: moet op "${_issue.suffix}" eindigen`;
            if (_issue.format === "includes")
              return `Ongeldige tekst: moet "${_issue.includes}" bevatten`;
            if (_issue.format === "regex")
              return `Ongeldige tekst: moet overeenkomen met patroon ${_issue.pattern}`;
            return `Ongeldig: ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ongeldig getal: moet een veelvoud van ${issue3.divisor} zijn`;
          case "unrecognized_keys":
            return `Onbekende key${issue3.keys.length > 1 ? "s" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ongeldige key in ${issue3.origin}`;
          case "invalid_union":
            return "Ongeldige invoer";
          case "invalid_element":
            return `Ongeldige waarde in ${issue3.origin}`;
          default:
            return `Ongeldige invoer`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/no.js
function no_default() {
  return {
    localeError: error30()
  };
}
var error30;
var init_no = __esm({
  "node_modules/zod/v4/locales/no.js"() {
    "use strict";
    init_util();
    error30 = () => {
      const Sizable = {
        string: { unit: "tegn", verb: "\xE5 ha" },
        file: { unit: "bytes", verb: "\xE5 ha" },
        array: { unit: "elementer", verb: "\xE5 inneholde" },
        set: { unit: "elementer", verb: "\xE5 inneholde" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "e-postadresse",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO dato- og klokkeslett",
        date: "ISO-dato",
        time: "ISO-klokkeslett",
        duration: "ISO-varighet",
        ipv4: "IPv4-omr\xE5de",
        ipv6: "IPv6-omr\xE5de",
        cidrv4: "IPv4-spekter",
        cidrv6: "IPv6-spekter",
        base64: "base64-enkodet streng",
        base64url: "base64url-enkodet streng",
        json_string: "JSON-streng",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "tall",
        array: "liste"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ugyldig input: forventet instanceof ${issue3.expected}, fikk ${received}`;
            }
            return `Ugyldig input: forventet ${expected}, fikk ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ugyldig verdi: forventet ${stringifyPrimitive(issue3.values[0])}`;
            return `Ugyldig valg: forventet en av ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `For stor(t): forventet ${issue3.origin ?? "value"} til \xE5 ha ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementer"}`;
            return `For stor(t): forventet ${issue3.origin ?? "value"} til \xE5 ha ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `For lite(n): forventet ${issue3.origin} til \xE5 ha ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `For lite(n): forventet ${issue3.origin} til \xE5 ha ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Ugyldig streng: m\xE5 starte med "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Ugyldig streng: m\xE5 ende med "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Ugyldig streng: m\xE5 inneholde "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${_issue.pattern}`;
            return `Ugyldig ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${issue3.divisor}`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Ukjente n\xF8kler" : "Ukjent n\xF8kkel"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ugyldig n\xF8kkel i ${issue3.origin}`;
          case "invalid_union":
            return "Ugyldig input";
          case "invalid_element":
            return `Ugyldig verdi i ${issue3.origin}`;
          default:
            return `Ugyldig input`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/ota.js
function ota_default() {
  return {
    localeError: error31()
  };
}
var error31;
var init_ota = __esm({
  "node_modules/zod/v4/locales/ota.js"() {
    "use strict";
    init_util();
    error31 = () => {
      const Sizable = {
        string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
        file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
        array: { unit: "unsur", verb: "olmal\u0131d\u0131r" },
        set: { unit: "unsur", verb: "olmal\u0131d\u0131r" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "giren",
        email: "epostag\xE2h",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO heng\xE2m\u0131",
        date: "ISO tarihi",
        time: "ISO zaman\u0131",
        duration: "ISO m\xFCddeti",
        ipv4: "IPv4 ni\u015F\xE2n\u0131",
        ipv6: "IPv6 ni\u015F\xE2n\u0131",
        cidrv4: "IPv4 menzili",
        cidrv6: "IPv6 menzili",
        base64: "base64-\u015Fifreli metin",
        base64url: "base64url-\u015Fifreli metin",
        json_string: "JSON metin",
        e164: "E.164 say\u0131s\u0131",
        jwt: "JWT",
        template_literal: "giren"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "numara",
        array: "saf",
        null: "gayb"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `F\xE2sit giren: umulan instanceof ${issue3.expected}, al\u0131nan ${received}`;
            }
            return `F\xE2sit giren: umulan ${expected}, al\u0131nan ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `F\xE2sit giren: umulan ${stringifyPrimitive(issue3.values[0])}`;
            return `F\xE2sit tercih: m\xFBteberler ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Fazla b\xFCy\xFCk: ${issue3.origin ?? "value"}, ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elements"} sahip olmal\u0131yd\u0131.`;
            return `Fazla b\xFCy\xFCk: ${issue3.origin ?? "value"}, ${adj}${issue3.maximum.toString()} olmal\u0131yd\u0131.`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Fazla k\xFC\xE7\xFCk: ${issue3.origin}, ${adj}${issue3.minimum.toString()} ${sizing.unit} sahip olmal\u0131yd\u0131.`;
            }
            return `Fazla k\xFC\xE7\xFCk: ${issue3.origin}, ${adj}${issue3.minimum.toString()} olmal\u0131yd\u0131.`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `F\xE2sit metin: "${_issue.prefix}" ile ba\u015Flamal\u0131.`;
            if (_issue.format === "ends_with")
              return `F\xE2sit metin: "${_issue.suffix}" ile bitmeli.`;
            if (_issue.format === "includes")
              return `F\xE2sit metin: "${_issue.includes}" ihtiv\xE2 etmeli.`;
            if (_issue.format === "regex")
              return `F\xE2sit metin: ${_issue.pattern} nak\u015F\u0131na uymal\u0131.`;
            return `F\xE2sit ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `F\xE2sit say\u0131: ${issue3.divisor} kat\u0131 olmal\u0131yd\u0131.`;
          case "unrecognized_keys":
            return `Tan\u0131nmayan anahtar ${issue3.keys.length > 1 ? "s" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} i\xE7in tan\u0131nmayan anahtar var.`;
          case "invalid_union":
            return "Giren tan\u0131namad\u0131.";
          case "invalid_element":
            return `${issue3.origin} i\xE7in tan\u0131nmayan k\u0131ymet var.`;
          default:
            return `K\u0131ymet tan\u0131namad\u0131.`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/ps.js
function ps_default() {
  return {
    localeError: error32()
  };
}
var error32;
var init_ps = __esm({
  "node_modules/zod/v4/locales/ps.js"() {
    "use strict";
    init_util();
    error32 = () => {
      const Sizable = {
        string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
        file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
        array: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
        set: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0648\u0631\u0648\u062F\u064A",
        email: "\u0628\u0631\u06CC\u069A\u0646\u0627\u0644\u06CC\u06A9",
        url: "\u06CC\u0648 \u0622\u0631 \u0627\u0644",
        emoji: "\u0627\u06CC\u0645\u0648\u062C\u064A",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u0646\u06CC\u067C\u0647 \u0627\u0648 \u0648\u062E\u062A",
        date: "\u0646\u06D0\u067C\u0647",
        time: "\u0648\u062E\u062A",
        duration: "\u0645\u0648\u062F\u0647",
        ipv4: "\u062F IPv4 \u067E\u062A\u0647",
        ipv6: "\u062F IPv6 \u067E\u062A\u0647",
        cidrv4: "\u062F IPv4 \u0633\u0627\u062D\u0647",
        cidrv6: "\u062F IPv6 \u0633\u0627\u062D\u0647",
        base64: "base64-encoded \u0645\u062A\u0646",
        base64url: "base64url-encoded \u0645\u062A\u0646",
        json_string: "JSON \u0645\u062A\u0646",
        e164: "\u062F E.164 \u0634\u0645\u06D0\u0631\u0647",
        jwt: "JWT",
        template_literal: "\u0648\u0631\u0648\u062F\u064A"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0639\u062F\u062F",
        array: "\u0627\u0631\u06D0"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F instanceof ${issue3.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
            }
            return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
          }
          case "invalid_value":
            if (issue3.values.length === 1) {
              return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${stringifyPrimitive(issue3.values[0])} \u0648\u0627\u06CC`;
            }
            return `\u0646\u0627\u0633\u0645 \u0627\u0646\u062A\u062E\u0627\u0628: \u0628\u0627\u06CC\u062F \u06CC\u0648 \u0644\u0647 ${joinValues(issue3.values, "|")} \u0685\u062E\u0647 \u0648\u0627\u06CC`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue3.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631\u0648\u0646\u0647"} \u0648\u0644\u0631\u064A`;
            }
            return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue3.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} \u0648\u064A`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} ${sizing.unit} \u0648\u0644\u0631\u064A`;
            }
            return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} \u0648\u064A`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.prefix}" \u0633\u0631\u0647 \u067E\u06CC\u0644 \u0634\u064A`;
            }
            if (_issue.format === "ends_with") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.suffix}" \u0633\u0631\u0647 \u067E\u0627\u06CC \u062A\u0647 \u0648\u0631\u0633\u064A\u0696\u064A`;
            }
            if (_issue.format === "includes") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F "${_issue.includes}" \u0648\u0644\u0631\u064A`;
            }
            if (_issue.format === "regex") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F ${_issue.pattern} \u0633\u0631\u0647 \u0645\u0637\u0627\u0628\u0642\u062A \u0648\u0644\u0631\u064A`;
            }
            return `${FormatDictionary[_issue.format] ?? issue3.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`;
          }
          case "not_multiple_of":
            return `\u0646\u0627\u0633\u0645 \u0639\u062F\u062F: \u0628\u0627\u06CC\u062F \u062F ${issue3.divisor} \u0645\u0636\u0631\u0628 \u0648\u064A`;
          case "unrecognized_keys":
            return `\u0646\u0627\u0633\u0645 ${issue3.keys.length > 1 ? "\u06A9\u0644\u06CC\u0689\u0648\u0646\u0647" : "\u06A9\u0644\u06CC\u0689"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u0646\u0627\u0633\u0645 \u06A9\u0644\u06CC\u0689 \u067E\u0647 ${issue3.origin} \u06A9\u06D0`;
          case "invalid_union":
            return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
          case "invalid_element":
            return `\u0646\u0627\u0633\u0645 \u0639\u0646\u0635\u0631 \u067E\u0647 ${issue3.origin} \u06A9\u06D0`;
          default:
            return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/pl.js
function pl_default() {
  return {
    localeError: error33()
  };
}
var error33;
var init_pl = __esm({
  "node_modules/zod/v4/locales/pl.js"() {
    "use strict";
    init_util();
    error33 = () => {
      const Sizable = {
        string: { unit: "znak\xF3w", verb: "mie\u0107" },
        file: { unit: "bajt\xF3w", verb: "mie\u0107" },
        array: { unit: "element\xF3w", verb: "mie\u0107" },
        set: { unit: "element\xF3w", verb: "mie\u0107" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "wyra\u017Cenie",
        email: "adres email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data i godzina w formacie ISO",
        date: "data w formacie ISO",
        time: "godzina w formacie ISO",
        duration: "czas trwania ISO",
        ipv4: "adres IPv4",
        ipv6: "adres IPv6",
        cidrv4: "zakres IPv4",
        cidrv6: "zakres IPv6",
        base64: "ci\u0105g znak\xF3w zakodowany w formacie base64",
        base64url: "ci\u0105g znak\xF3w zakodowany w formacie base64url",
        json_string: "ci\u0105g znak\xF3w w formacie JSON",
        e164: "liczba E.164",
        jwt: "JWT",
        template_literal: "wej\u015Bcie"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "liczba",
        array: "tablica"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano instanceof ${issue3.expected}, otrzymano ${received}`;
            }
            return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${expected}, otrzymano ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${stringifyPrimitive(issue3.values[0])}`;
            return `Nieprawid\u0142owa opcja: oczekiwano jednej z warto\u015Bci ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Za du\u017Ca warto\u015B\u0107: oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "element\xF3w"}`;
            }
            return `Zbyt du\u017C(y/a/e): oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Za ma\u0142a warto\u015B\u0107: oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue3.minimum.toString()} ${sizing.unit ?? "element\xF3w"}`;
            }
            return `Zbyt ma\u0142(y/a/e): oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zaczyna\u0107 si\u0119 od "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi ko\u0144czy\u0107 si\u0119 na "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${_issue.pattern}`;
            return `Nieprawid\u0142ow(y/a/e) ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Nierozpoznane klucze${issue3.keys.length > 1 ? "s" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Nieprawid\u0142owy klucz w ${issue3.origin}`;
          case "invalid_union":
            return "Nieprawid\u0142owe dane wej\u015Bciowe";
          case "invalid_element":
            return `Nieprawid\u0142owa warto\u015B\u0107 w ${issue3.origin}`;
          default:
            return `Nieprawid\u0142owe dane wej\u015Bciowe`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/pt.js
function pt_default() {
  return {
    localeError: error34()
  };
}
var error34;
var init_pt = __esm({
  "node_modules/zod/v4/locales/pt.js"() {
    "use strict";
    init_util();
    error34 = () => {
      const Sizable = {
        string: { unit: "caracteres", verb: "ter" },
        file: { unit: "bytes", verb: "ter" },
        array: { unit: "itens", verb: "ter" },
        set: { unit: "itens", verb: "ter" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "padr\xE3o",
        email: "endere\xE7o de e-mail",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data e hora ISO",
        date: "data ISO",
        time: "hora ISO",
        duration: "dura\xE7\xE3o ISO",
        ipv4: "endere\xE7o IPv4",
        ipv6: "endere\xE7o IPv6",
        cidrv4: "faixa de IPv4",
        cidrv6: "faixa de IPv6",
        base64: "texto codificado em base64",
        base64url: "URL codificada em base64",
        json_string: "texto JSON",
        e164: "n\xFAmero E.164",
        jwt: "JWT",
        template_literal: "entrada"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "n\xFAmero",
        null: "nulo"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Tipo inv\xE1lido: esperado instanceof ${issue3.expected}, recebido ${received}`;
            }
            return `Tipo inv\xE1lido: esperado ${expected}, recebido ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Entrada inv\xE1lida: esperado ${stringifyPrimitive(issue3.values[0])}`;
            return `Op\xE7\xE3o inv\xE1lida: esperada uma das ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Muito grande: esperado que ${issue3.origin ?? "valor"} tivesse ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementos"}`;
            return `Muito grande: esperado que ${issue3.origin ?? "valor"} fosse ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Muito pequeno: esperado que ${issue3.origin} tivesse ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Muito pequeno: esperado que ${issue3.origin} fosse ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Texto inv\xE1lido: deve come\xE7ar com "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Texto inv\xE1lido: deve terminar com "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Texto inv\xE1lido: deve incluir "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} inv\xE1lido`;
          }
          case "not_multiple_of":
            return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Chave${issue3.keys.length > 1 ? "s" : ""} desconhecida${issue3.keys.length > 1 ? "s" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Chave inv\xE1lida em ${issue3.origin}`;
          case "invalid_union":
            return "Entrada inv\xE1lida";
          case "invalid_element":
            return `Valor inv\xE1lido em ${issue3.origin}`;
          default:
            return `Campo inv\xE1lido`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/ru.js
function getRussianPlural(count, one, few, many) {
  const absCount = Math.abs(count);
  const lastDigit = absCount % 10;
  const lastTwoDigits = absCount % 100;
  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
    return many;
  }
  if (lastDigit === 1) {
    return one;
  }
  if (lastDigit >= 2 && lastDigit <= 4) {
    return few;
  }
  return many;
}
function ru_default() {
  return {
    localeError: error35()
  };
}
var error35;
var init_ru = __esm({
  "node_modules/zod/v4/locales/ru.js"() {
    "use strict";
    init_util();
    error35 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "\u0441\u0438\u043C\u0432\u043E\u043B",
            few: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430",
            many: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        },
        file: {
          unit: {
            one: "\u0431\u0430\u0439\u0442",
            few: "\u0431\u0430\u0439\u0442\u0430",
            many: "\u0431\u0430\u0439\u0442"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        },
        array: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        },
        set: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0432\u0432\u043E\u0434",
        email: "email \u0430\u0434\u0440\u0435\u0441",
        url: "URL",
        emoji: "\u044D\u043C\u043E\u0434\u0437\u0438",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F",
        date: "ISO \u0434\u0430\u0442\u0430",
        time: "ISO \u0432\u0440\u0435\u043C\u044F",
        duration: "ISO \u0434\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C",
        ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
        ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
        cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        base64: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64",
        base64url: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64url",
        json_string: "JSON \u0441\u0442\u0440\u043E\u043A\u0430",
        e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
        jwt: "JWT",
        template_literal: "\u0432\u0432\u043E\u0434"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0447\u0438\u0441\u043B\u043E",
        array: "\u043C\u0430\u0441\u0441\u0438\u0432"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C instanceof ${issue3.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
            }
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${stringifyPrimitive(issue3.values[0])}`;
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0434\u043D\u043E \u0438\u0437 ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const maxValue = Number(issue3.maximum);
              const unit = getRussianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue3.maximum.toString()} ${unit}`;
            }
            return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const minValue = Number(issue3.minimum);
              const unit = getRussianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue3.minimum.toString()} ${unit}`;
            }
            return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0437\u0430\u043A\u0430\u043D\u0447\u0438\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D\u043D${issue3.keys.length > 1 ? "\u044B\u0435" : "\u044B\u0439"} \u043A\u043B\u044E\u0447${issue3.keys.length > 1 ? "\u0438" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u043A\u043B\u044E\u0447 \u0432 ${issue3.origin}`;
          case "invalid_union":
            return "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435";
          case "invalid_element":
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0432 ${issue3.origin}`;
          default:
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/sl.js
function sl_default() {
  return {
    localeError: error36()
  };
}
var error36;
var init_sl = __esm({
  "node_modules/zod/v4/locales/sl.js"() {
    "use strict";
    init_util();
    error36 = () => {
      const Sizable = {
        string: { unit: "znakov", verb: "imeti" },
        file: { unit: "bajtov", verb: "imeti" },
        array: { unit: "elementov", verb: "imeti" },
        set: { unit: "elementov", verb: "imeti" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "vnos",
        email: "e-po\u0161tni naslov",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datum in \u010Das",
        date: "ISO datum",
        time: "ISO \u010Das",
        duration: "ISO trajanje",
        ipv4: "IPv4 naslov",
        ipv6: "IPv6 naslov",
        cidrv4: "obseg IPv4",
        cidrv6: "obseg IPv6",
        base64: "base64 kodiran niz",
        base64url: "base64url kodiran niz",
        json_string: "JSON niz",
        e164: "E.164 \u0161tevilka",
        jwt: "JWT",
        template_literal: "vnos"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0161tevilo",
        array: "tabela"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Neveljaven vnos: pri\u010Dakovano instanceof ${issue3.expected}, prejeto ${received}`;
            }
            return `Neveljaven vnos: pri\u010Dakovano ${expected}, prejeto ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Neveljaven vnos: pri\u010Dakovano ${stringifyPrimitive(issue3.values[0])}`;
            return `Neveljavna mo\u017Enost: pri\u010Dakovano eno izmed ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Preveliko: pri\u010Dakovano, da bo ${issue3.origin ?? "vrednost"} imelo ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementov"}`;
            return `Preveliko: pri\u010Dakovano, da bo ${issue3.origin ?? "vrednost"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Premajhno: pri\u010Dakovano, da bo ${issue3.origin} imelo ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Premajhno: pri\u010Dakovano, da bo ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Neveljaven niz: mora se za\u010Deti z "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Neveljaven niz: mora se kon\u010Dati z "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Neveljaven niz: mora vsebovati "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`;
            return `Neveljaven ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Neprepoznan${issue3.keys.length > 1 ? "i klju\u010Di" : " klju\u010D"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Neveljaven klju\u010D v ${issue3.origin}`;
          case "invalid_union":
            return "Neveljaven vnos";
          case "invalid_element":
            return `Neveljavna vrednost v ${issue3.origin}`;
          default:
            return "Neveljaven vnos";
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/sv.js
function sv_default() {
  return {
    localeError: error37()
  };
}
var error37;
var init_sv = __esm({
  "node_modules/zod/v4/locales/sv.js"() {
    "use strict";
    init_util();
    error37 = () => {
      const Sizable = {
        string: { unit: "tecken", verb: "att ha" },
        file: { unit: "bytes", verb: "att ha" },
        array: { unit: "objekt", verb: "att inneh\xE5lla" },
        set: { unit: "objekt", verb: "att inneh\xE5lla" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "regulj\xE4rt uttryck",
        email: "e-postadress",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-datum och tid",
        date: "ISO-datum",
        time: "ISO-tid",
        duration: "ISO-varaktighet",
        ipv4: "IPv4-intervall",
        ipv6: "IPv6-intervall",
        cidrv4: "IPv4-spektrum",
        cidrv6: "IPv6-spektrum",
        base64: "base64-kodad str\xE4ng",
        base64url: "base64url-kodad str\xE4ng",
        json_string: "JSON-str\xE4ng",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "mall-literal"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "antal",
        array: "lista"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ogiltig inmatning: f\xF6rv\xE4ntat instanceof ${issue3.expected}, fick ${received}`;
            }
            return `Ogiltig inmatning: f\xF6rv\xE4ntat ${expected}, fick ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ogiltig inmatning: f\xF6rv\xE4ntat ${stringifyPrimitive(issue3.values[0])}`;
            return `Ogiltigt val: f\xF6rv\xE4ntade en av ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `F\xF6r stor(t): f\xF6rv\xE4ntade ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "element"}`;
            }
            return `F\xF6r stor(t): f\xF6rv\xE4ntat ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Ogiltig str\xE4ng: m\xE5ste b\xF6rja med "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Ogiltig str\xE4ng: m\xE5ste sluta med "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${_issue.pattern}"`;
            return `Ogiltig(t) ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ogiltigt tal: m\xE5ste vara en multipel av ${issue3.divisor}`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Ok\xE4nda nycklar" : "Ok\xE4nd nyckel"}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ogiltig nyckel i ${issue3.origin ?? "v\xE4rdet"}`;
          case "invalid_union":
            return "Ogiltig input";
          case "invalid_element":
            return `Ogiltigt v\xE4rde i ${issue3.origin ?? "v\xE4rdet"}`;
          default:
            return `Ogiltig input`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/ta.js
function ta_default() {
  return {
    localeError: error38()
  };
}
var error38;
var init_ta = __esm({
  "node_modules/zod/v4/locales/ta.js"() {
    "use strict";
    init_util();
    error38 = () => {
      const Sizable = {
        string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
        file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
        array: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
        set: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1",
        email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0BA4\u0BC7\u0BA4\u0BBF \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
        date: "ISO \u0BA4\u0BC7\u0BA4\u0BBF",
        time: "ISO \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
        duration: "ISO \u0B95\u0BBE\u0BB2 \u0B85\u0BB3\u0BB5\u0BC1",
        ipv4: "IPv4 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
        ipv6: "IPv6 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
        cidrv4: "IPv4 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
        cidrv6: "IPv6 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
        base64: "base64-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
        base64url: "base64url-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
        json_string: "JSON \u0B9A\u0BB0\u0BAE\u0BCD",
        e164: "E.164 \u0B8E\u0BA3\u0BCD",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0B8E\u0BA3\u0BCD",
        array: "\u0B85\u0BA3\u0BBF",
        null: "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 instanceof ${issue3.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
            }
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${stringifyPrimitive(issue3.values[0])}`;
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0BB0\u0BC1\u0BAA\u0BCD\u0BAA\u0BAE\u0BCD: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${joinValues(issue3.values, "|")} \u0B87\u0BB2\u0BCD \u0B92\u0BA9\u0BCD\u0BB1\u0BC1`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD"} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            }
            return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue3.maximum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            }
            return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin} ${adj}${issue3.minimum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.prefix}" \u0B87\u0BB2\u0BCD \u0BA4\u0BCA\u0B9F\u0B99\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            if (_issue.format === "ends_with")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.suffix}" \u0B87\u0BB2\u0BCD \u0BAE\u0BC1\u0B9F\u0BBF\u0BB5\u0B9F\u0BC8\u0BAF \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            if (_issue.format === "includes")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            if (_issue.format === "regex")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${_issue.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${issue3.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
          case "unrecognized_keys":
            return `\u0B85\u0B9F\u0BC8\u0BAF\u0BBE\u0BB3\u0BAE\u0BCD \u0BA4\u0BC6\u0BB0\u0BBF\u0BAF\u0BBE\u0BA4 \u0BB5\u0BBF\u0B9A\u0BC8${issue3.keys.length > 1 ? "\u0B95\u0BB3\u0BCD" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0B9A\u0BC8`;
          case "invalid_union":
            return "\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1";
          case "invalid_element":
            return `${issue3.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1`;
          default:
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/th.js
function th_default() {
  return {
    localeError: error39()
  };
}
var error39;
var init_th = __esm({
  "node_modules/zod/v4/locales/th.js"() {
    "use strict";
    init_util();
    error39 = () => {
      const Sizable = {
        string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
        file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
        array: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
        set: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19",
        email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25",
        url: "URL",
        emoji: "\u0E2D\u0E34\u0E42\u0E21\u0E08\u0E34",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
        date: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E41\u0E1A\u0E1A ISO",
        time: "\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
        duration: "\u0E0A\u0E48\u0E27\u0E07\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
        ipv4: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv4",
        ipv6: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv6",
        cidrv4: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv4",
        cidrv6: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv6",
        base64: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64",
        base64url: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64 \u0E2A\u0E33\u0E2B\u0E23\u0E31\u0E1A URL",
        json_string: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A JSON",
        e164: "\u0E40\u0E1A\u0E2D\u0E23\u0E4C\u0E42\u0E17\u0E23\u0E28\u0E31\u0E1E\u0E17\u0E4C\u0E23\u0E30\u0E2B\u0E27\u0E48\u0E32\u0E07\u0E1B\u0E23\u0E30\u0E40\u0E17\u0E28 (E.164)",
        jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT",
        template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02",
        array: "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)",
        null: "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 instanceof ${issue3.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
            }
            return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${stringifyPrimitive(issue3.values[0])}`;
            return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19\u0E2B\u0E19\u0E36\u0E48\u0E07\u0E43\u0E19 ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19" : "\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23"}`;
            return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22" : "\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E02\u0E36\u0E49\u0E19\u0E15\u0E49\u0E19\u0E14\u0E49\u0E27\u0E22 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E25\u0E07\u0E17\u0E49\u0E32\u0E22\u0E14\u0E49\u0E27\u0E22 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${_issue.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`;
            if (_issue.format === "regex")
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${_issue.pattern}`;
            return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${issue3.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`;
          case "unrecognized_keys":
            return `\u0E1E\u0E1A\u0E04\u0E35\u0E22\u0E4C\u0E17\u0E35\u0E48\u0E44\u0E21\u0E48\u0E23\u0E39\u0E49\u0E08\u0E31\u0E01: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u0E04\u0E35\u0E22\u0E4C\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue3.origin}`;
          case "invalid_union":
            return "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E44\u0E21\u0E48\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E22\u0E39\u0E40\u0E19\u0E35\u0E22\u0E19\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14\u0E44\u0E27\u0E49";
          case "invalid_element":
            return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue3.origin}`;
          default:
            return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/tr.js
function tr_default() {
  return {
    localeError: error40()
  };
}
var error40;
var init_tr = __esm({
  "node_modules/zod/v4/locales/tr.js"() {
    "use strict";
    init_util();
    error40 = () => {
      const Sizable = {
        string: { unit: "karakter", verb: "olmal\u0131" },
        file: { unit: "bayt", verb: "olmal\u0131" },
        array: { unit: "\xF6\u011Fe", verb: "olmal\u0131" },
        set: { unit: "\xF6\u011Fe", verb: "olmal\u0131" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "girdi",
        email: "e-posta adresi",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO tarih ve saat",
        date: "ISO tarih",
        time: "ISO saat",
        duration: "ISO s\xFCre",
        ipv4: "IPv4 adresi",
        ipv6: "IPv6 adresi",
        cidrv4: "IPv4 aral\u0131\u011F\u0131",
        cidrv6: "IPv6 aral\u0131\u011F\u0131",
        base64: "base64 ile \u015Fifrelenmi\u015F metin",
        base64url: "base64url ile \u015Fifrelenmi\u015F metin",
        json_string: "JSON dizesi",
        e164: "E.164 say\u0131s\u0131",
        jwt: "JWT",
        template_literal: "\u015Eablon dizesi"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ge\xE7ersiz de\u011Fer: beklenen instanceof ${issue3.expected}, al\u0131nan ${received}`;
            }
            return `Ge\xE7ersiz de\u011Fer: beklenen ${expected}, al\u0131nan ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ge\xE7ersiz de\u011Fer: beklenen ${stringifyPrimitive(issue3.values[0])}`;
            return `Ge\xE7ersiz se\xE7enek: a\u015Fa\u011F\u0131dakilerden biri olmal\u0131: ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\xC7ok b\xFCy\xFCk: beklenen ${issue3.origin ?? "de\u011Fer"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\xF6\u011Fe"}`;
            return `\xC7ok b\xFCy\xFCk: beklenen ${issue3.origin ?? "de\u011Fer"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Ge\xE7ersiz metin: "${_issue.prefix}" ile ba\u015Flamal\u0131`;
            if (_issue.format === "ends_with")
              return `Ge\xE7ersiz metin: "${_issue.suffix}" ile bitmeli`;
            if (_issue.format === "includes")
              return `Ge\xE7ersiz metin: "${_issue.includes}" i\xE7ermeli`;
            if (_issue.format === "regex")
              return `Ge\xE7ersiz metin: ${_issue.pattern} desenine uymal\u0131`;
            return `Ge\xE7ersiz ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ge\xE7ersiz say\u0131: ${issue3.divisor} ile tam b\xF6l\xFCnebilmeli`;
          case "unrecognized_keys":
            return `Tan\u0131nmayan anahtar${issue3.keys.length > 1 ? "lar" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} i\xE7inde ge\xE7ersiz anahtar`;
          case "invalid_union":
            return "Ge\xE7ersiz de\u011Fer";
          case "invalid_element":
            return `${issue3.origin} i\xE7inde ge\xE7ersiz de\u011Fer`;
          default:
            return `Ge\xE7ersiz de\u011Fer`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/uk.js
function uk_default() {
  return {
    localeError: error41()
  };
}
var error41;
var init_uk = __esm({
  "node_modules/zod/v4/locales/uk.js"() {
    "use strict";
    init_util();
    error41 = () => {
      const Sizable = {
        string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
        file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
        array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
        set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456",
        email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438",
        url: "URL",
        emoji: "\u0435\u043C\u043E\u0434\u0437\u0456",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u0434\u0430\u0442\u0430 \u0442\u0430 \u0447\u0430\u0441 ISO",
        date: "\u0434\u0430\u0442\u0430 ISO",
        time: "\u0447\u0430\u0441 ISO",
        duration: "\u0442\u0440\u0438\u0432\u0430\u043B\u0456\u0441\u0442\u044C ISO",
        ipv4: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv4",
        ipv6: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv6",
        cidrv4: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv4",
        cidrv6: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv6",
        base64: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64",
        base64url: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64url",
        json_string: "\u0440\u044F\u0434\u043E\u043A JSON",
        e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
        jwt: "JWT",
        template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0447\u0438\u0441\u043B\u043E",
        array: "\u043C\u0430\u0441\u0438\u0432"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F instanceof ${issue3.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
            }
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${stringifyPrimitive(issue3.values[0])}`;
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0430 \u043E\u043F\u0446\u0456\u044F: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F \u043E\u0434\u043D\u0435 \u0437 ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432"}`;
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} \u0431\u0443\u0434\u0435 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin} \u0431\u0443\u0434\u0435 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043F\u043E\u0447\u0438\u043D\u0430\u0442\u0438\u0441\u044F \u0437 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0437\u0430\u043A\u0456\u043D\u0447\u0443\u0432\u0430\u0442\u0438\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u043E\u0437\u043F\u0456\u0437\u043D\u0430\u043D\u0438\u0439 \u043A\u043B\u044E\u0447${issue3.keys.length > 1 ? "\u0456" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u043A\u043B\u044E\u0447 \u0443 ${issue3.origin}`;
          case "invalid_union":
            return "\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456";
          case "invalid_element":
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F \u0443 ${issue3.origin}`;
          default:
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/ua.js
function ua_default() {
  return uk_default();
}
var init_ua = __esm({
  "node_modules/zod/v4/locales/ua.js"() {
    "use strict";
    init_uk();
  }
});

// node_modules/zod/v4/locales/ur.js
function ur_default() {
  return {
    localeError: error42()
  };
}
var error42;
var init_ur = __esm({
  "node_modules/zod/v4/locales/ur.js"() {
    "use strict";
    init_util();
    error42 = () => {
      const Sizable = {
        string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
        file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
        array: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" },
        set: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0627\u0646 \u067E\u0679",
        email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633",
        url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644",
        emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
        uuid: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        uuidv4: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 4",
        uuidv6: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 6",
        nanoid: "\u0646\u06CC\u0646\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        guid: "\u062C\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        cuid: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        cuid2: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC 2",
        ulid: "\u06CC\u0648 \u0627\u06CC\u0644 \u0622\u0626\u06CC \u0688\u06CC",
        xid: "\u0627\u06CC\u06A9\u0633 \u0622\u0626\u06CC \u0688\u06CC",
        ksuid: "\u06A9\u06D2 \u0627\u06CC\u0633 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        datetime: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0688\u06CC\u0679 \u0679\u0627\u0626\u0645",
        date: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u062A\u0627\u0631\u06CC\u062E",
        time: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0648\u0642\u062A",
        duration: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0645\u062F\u062A",
        ipv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0627\u06CC\u0688\u0631\u06CC\u0633",
        ipv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0627\u06CC\u0688\u0631\u06CC\u0633",
        cidrv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0631\u06CC\u0646\u062C",
        cidrv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0631\u06CC\u0646\u062C",
        base64: "\u0628\u06CC\u0633 64 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
        base64url: "\u0628\u06CC\u0633 64 \u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
        json_string: "\u062C\u06D2 \u0627\u06CC\u0633 \u0627\u0648 \u0627\u06CC\u0646 \u0633\u0679\u0631\u0646\u06AF",
        e164: "\u0627\u06CC 164 \u0646\u0645\u0628\u0631",
        jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC",
        template_literal: "\u0627\u0646 \u067E\u0679"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0646\u0645\u0628\u0631",
        array: "\u0622\u0631\u06D2",
        null: "\u0646\u0644"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: instanceof ${issue3.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
            }
            return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${stringifyPrimitive(issue3.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
            return `\u063A\u0644\u0637 \u0622\u067E\u0634\u0646: ${joinValues(issue3.values, "|")} \u0645\u06CC\u06BA \u0633\u06D2 \u0627\u06CC\u06A9 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue3.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u06D2 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0627\u0635\u0631"} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
            return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue3.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u0627 ${adj}${issue3.maximum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue3.origin} \u06A9\u06D2 ${adj}${issue3.minimum.toString()} ${sizing.unit} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
            }
            return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue3.origin} \u06A9\u0627 ${adj}${issue3.minimum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.prefix}" \u0633\u06D2 \u0634\u0631\u0648\u0639 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            }
            if (_issue.format === "ends_with")
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.suffix}" \u067E\u0631 \u062E\u062A\u0645 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            if (_issue.format === "includes")
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            if (_issue.format === "regex")
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${_issue.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            return `\u063A\u0644\u0637 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${issue3.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
          case "unrecognized_keys":
            return `\u063A\u06CC\u0631 \u062A\u0633\u0644\u06CC\u0645 \u0634\u062F\u06C1 \u06A9\u06CC${issue3.keys.length > 1 ? "\u0632" : ""}: ${joinValues(issue3.keys, "\u060C ")}`;
          case "invalid_key":
            return `${issue3.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u06A9\u06CC`;
          case "invalid_union":
            return "\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679";
          case "invalid_element":
            return `${issue3.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u0648\u06CC\u0644\u06CC\u0648`;
          default:
            return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/uz.js
function uz_default() {
  return {
    localeError: error43()
  };
}
var error43;
var init_uz = __esm({
  "node_modules/zod/v4/locales/uz.js"() {
    "use strict";
    init_util();
    error43 = () => {
      const Sizable = {
        string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
        file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
        array: { unit: "element", verb: "bo\u2018lishi kerak" },
        set: { unit: "element", verb: "bo\u2018lishi kerak" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "kirish",
        email: "elektron pochta manzili",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO sana va vaqti",
        date: "ISO sana",
        time: "ISO vaqt",
        duration: "ISO davomiylik",
        ipv4: "IPv4 manzil",
        ipv6: "IPv6 manzil",
        mac: "MAC manzil",
        cidrv4: "IPv4 diapazon",
        cidrv6: "IPv6 diapazon",
        base64: "base64 kodlangan satr",
        base64url: "base64url kodlangan satr",
        json_string: "JSON satr",
        e164: "E.164 raqam",
        jwt: "JWT",
        template_literal: "kirish"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "raqam",
        array: "massiv"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Noto\u2018g\u2018ri kirish: kutilgan instanceof ${issue3.expected}, qabul qilingan ${received}`;
            }
            return `Noto\u2018g\u2018ri kirish: kutilgan ${expected}, qabul qilingan ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Noto\u2018g\u2018ri kirish: kutilgan ${stringifyPrimitive(issue3.values[0])}`;
            return `Noto\u2018g\u2018ri variant: quyidagilardan biri kutilgan ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Juda katta: kutilgan ${issue3.origin ?? "qiymat"} ${adj}${issue3.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
            return `Juda katta: kutilgan ${issue3.origin ?? "qiymat"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Juda kichik: kutilgan ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
            }
            return `Juda kichik: kutilgan ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Noto\u2018g\u2018ri satr: "${_issue.prefix}" bilan boshlanishi kerak`;
            if (_issue.format === "ends_with")
              return `Noto\u2018g\u2018ri satr: "${_issue.suffix}" bilan tugashi kerak`;
            if (_issue.format === "includes")
              return `Noto\u2018g\u2018ri satr: "${_issue.includes}" ni o\u2018z ichiga olishi kerak`;
            if (_issue.format === "regex")
              return `Noto\u2018g\u2018ri satr: ${_issue.pattern} shabloniga mos kelishi kerak`;
            return `Noto\u2018g\u2018ri ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Noto\u2018g\u2018ri raqam: ${issue3.divisor} ning karralisi bo\u2018lishi kerak`;
          case "unrecognized_keys":
            return `Noma\u2019lum kalit${issue3.keys.length > 1 ? "lar" : ""}: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} dagi kalit noto\u2018g\u2018ri`;
          case "invalid_union":
            return "Noto\u2018g\u2018ri kirish";
          case "invalid_element":
            return `${issue3.origin} da noto\u2018g\u2018ri qiymat`;
          default:
            return `Noto\u2018g\u2018ri kirish`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/vi.js
function vi_default() {
  return {
    localeError: error44()
  };
}
var error44;
var init_vi = __esm({
  "node_modules/zod/v4/locales/vi.js"() {
    "use strict";
    init_util();
    error44 = () => {
      const Sizable = {
        string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
        file: { unit: "byte", verb: "c\xF3" },
        array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" },
        set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0111\u1EA7u v\xE0o",
        email: "\u0111\u1ECBa ch\u1EC9 email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ng\xE0y gi\u1EDD ISO",
        date: "ng\xE0y ISO",
        time: "gi\u1EDD ISO",
        duration: "kho\u1EA3ng th\u1EDDi gian ISO",
        ipv4: "\u0111\u1ECBa ch\u1EC9 IPv4",
        ipv6: "\u0111\u1ECBa ch\u1EC9 IPv6",
        cidrv4: "d\u1EA3i IPv4",
        cidrv6: "d\u1EA3i IPv6",
        base64: "chu\u1ED7i m\xE3 h\xF3a base64",
        base64url: "chu\u1ED7i m\xE3 h\xF3a base64url",
        json_string: "chu\u1ED7i JSON",
        e164: "s\u1ED1 E.164",
        jwt: "JWT",
        template_literal: "\u0111\u1EA7u v\xE0o"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "s\u1ED1",
        array: "m\u1EA3ng"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i instanceof ${issue3.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
            }
            return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${stringifyPrimitive(issue3.values[0])}`;
            return `T\xF9y ch\u1ECDn kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i m\u1ED9t trong c\xE1c gi\xE1 tr\u1ECB ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue3.origin ?? "gi\xE1 tr\u1ECB"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "ph\u1EA7n t\u1EED"}`;
            return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue3.origin ?? "gi\xE1 tr\u1ECB"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i k\u1EBFt th\xFAc b\u1EB1ng "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} kh\xF4ng h\u1EE3p l\u1EC7`;
          }
          case "not_multiple_of":
            return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Kh\xF3a kh\xF4ng \u0111\u01B0\u1EE3c nh\u1EADn d\u1EA1ng: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Kh\xF3a kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue3.origin}`;
          case "invalid_union":
            return "\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7";
          case "invalid_element":
            return `Gi\xE1 tr\u1ECB kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue3.origin}`;
          default:
            return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/zh-CN.js
function zh_CN_default() {
  return {
    localeError: error45()
  };
}
var error45;
var init_zh_CN = __esm({
  "node_modules/zod/v4/locales/zh-CN.js"() {
    "use strict";
    init_util();
    error45 = () => {
      const Sizable = {
        string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
        file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
        array: { unit: "\u9879", verb: "\u5305\u542B" },
        set: { unit: "\u9879", verb: "\u5305\u542B" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u8F93\u5165",
        email: "\u7535\u5B50\u90AE\u4EF6",
        url: "URL",
        emoji: "\u8868\u60C5\u7B26\u53F7",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO\u65E5\u671F\u65F6\u95F4",
        date: "ISO\u65E5\u671F",
        time: "ISO\u65F6\u95F4",
        duration: "ISO\u65F6\u957F",
        ipv4: "IPv4\u5730\u5740",
        ipv6: "IPv6\u5730\u5740",
        cidrv4: "IPv4\u7F51\u6BB5",
        cidrv6: "IPv6\u7F51\u6BB5",
        base64: "base64\u7F16\u7801\u5B57\u7B26\u4E32",
        base64url: "base64url\u7F16\u7801\u5B57\u7B26\u4E32",
        json_string: "JSON\u5B57\u7B26\u4E32",
        e164: "E.164\u53F7\u7801",
        jwt: "JWT",
        template_literal: "\u8F93\u5165"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u6570\u5B57",
        array: "\u6570\u7EC4",
        null: "\u7A7A\u503C(null)"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B instanceof ${issue3.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
            }
            return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${stringifyPrimitive(issue3.values[0])}`;
            return `\u65E0\u6548\u9009\u9879\uFF1A\u671F\u671B\u4EE5\u4E0B\u4E4B\u4E00 ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue3.origin ?? "\u503C"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u4E2A\u5143\u7D20"}`;
            return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue3.origin ?? "\u503C"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.prefix}" \u5F00\u5934`;
            if (_issue.format === "ends_with")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.suffix}" \u7ED3\u5C3E`;
            if (_issue.format === "includes")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${_issue.pattern}`;
            return `\u65E0\u6548${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${issue3.divisor} \u7684\u500D\u6570`;
          case "unrecognized_keys":
            return `\u51FA\u73B0\u672A\u77E5\u7684\u952E(key): ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} \u4E2D\u7684\u952E(key)\u65E0\u6548`;
          case "invalid_union":
            return "\u65E0\u6548\u8F93\u5165";
          case "invalid_element":
            return `${issue3.origin} \u4E2D\u5305\u542B\u65E0\u6548\u503C(value)`;
          default:
            return `\u65E0\u6548\u8F93\u5165`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/zh-TW.js
function zh_TW_default() {
  return {
    localeError: error46()
  };
}
var error46;
var init_zh_TW = __esm({
  "node_modules/zod/v4/locales/zh-TW.js"() {
    "use strict";
    init_util();
    error46 = () => {
      const Sizable = {
        string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
        file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
        array: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" },
        set: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u8F38\u5165",
        email: "\u90F5\u4EF6\u5730\u5740",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u65E5\u671F\u6642\u9593",
        date: "ISO \u65E5\u671F",
        time: "ISO \u6642\u9593",
        duration: "ISO \u671F\u9593",
        ipv4: "IPv4 \u4F4D\u5740",
        ipv6: "IPv6 \u4F4D\u5740",
        cidrv4: "IPv4 \u7BC4\u570D",
        cidrv6: "IPv6 \u7BC4\u570D",
        base64: "base64 \u7DE8\u78BC\u5B57\u4E32",
        base64url: "base64url \u7DE8\u78BC\u5B57\u4E32",
        json_string: "JSON \u5B57\u4E32",
        e164: "E.164 \u6578\u503C",
        jwt: "JWT",
        template_literal: "\u8F38\u5165"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA instanceof ${issue3.expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
            }
            return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${stringifyPrimitive(issue3.values[0])}`;
            return `\u7121\u6548\u7684\u9078\u9805\uFF1A\u9810\u671F\u70BA\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00 ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue3.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u500B\u5143\u7D20"}`;
            return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue3.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue3.origin} \u61C9\u70BA ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue3.origin} \u61C9\u70BA ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.prefix}" \u958B\u982D`;
            }
            if (_issue.format === "ends_with")
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.suffix}" \u7D50\u5C3E`;
            if (_issue.format === "includes")
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${_issue.pattern}`;
            return `\u7121\u6548\u7684 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${issue3.divisor} \u7684\u500D\u6578`;
          case "unrecognized_keys":
            return `\u7121\u6CD5\u8B58\u5225\u7684\u9375\u503C${issue3.keys.length > 1 ? "\u5011" : ""}\uFF1A${joinValues(issue3.keys, "\u3001")}`;
          case "invalid_key":
            return `${issue3.origin} \u4E2D\u6709\u7121\u6548\u7684\u9375\u503C`;
          case "invalid_union":
            return "\u7121\u6548\u7684\u8F38\u5165\u503C";
          case "invalid_element":
            return `${issue3.origin} \u4E2D\u6709\u7121\u6548\u7684\u503C`;
          default:
            return `\u7121\u6548\u7684\u8F38\u5165\u503C`;
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/yo.js
function yo_default() {
  return {
    localeError: error47()
  };
}
var error47;
var init_yo = __esm({
  "node_modules/zod/v4/locales/yo.js"() {
    "use strict";
    init_util();
    error47 = () => {
      const Sizable = {
        string: { unit: "\xE0mi", verb: "n\xED" },
        file: { unit: "bytes", verb: "n\xED" },
        array: { unit: "nkan", verb: "n\xED" },
        set: { unit: "nkan", verb: "n\xED" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9",
        email: "\xE0d\xEDr\u1EB9\u0301s\xEC \xECm\u1EB9\u0301l\xEC",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\xE0k\xF3k\xF2 ISO",
        date: "\u1ECDj\u1ECD\u0301 ISO",
        time: "\xE0k\xF3k\xF2 ISO",
        duration: "\xE0k\xF3k\xF2 t\xF3 p\xE9 ISO",
        ipv4: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv4",
        ipv6: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv6",
        cidrv4: "\xE0gb\xE8gb\xE8 IPv4",
        cidrv6: "\xE0gb\xE8gb\xE8 IPv6",
        base64: "\u1ECD\u0300r\u1ECD\u0300 t\xED a k\u1ECD\u0301 n\xED base64",
        base64url: "\u1ECD\u0300r\u1ECD\u0300 base64url",
        json_string: "\u1ECD\u0300r\u1ECD\u0300 JSON",
        e164: "n\u1ECD\u0301mb\xE0 E.164",
        jwt: "JWT",
        template_literal: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "n\u1ECD\u0301mb\xE0",
        array: "akop\u1ECD"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi instanceof ${issue3.expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
            }
            return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${stringifyPrimitive(issue3.values[0])}`;
            return `\xC0\u1E63\xE0y\xE0n a\u1E63\xEC\u1E63e: yan \u1ECD\u0300kan l\xE1ra ${joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue3.origin ?? "iye"} ${sizing.verb} ${adj}${issue3.maximum} ${sizing.unit}`;
            return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue3.maximum}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum} ${sizing.unit}`;
            return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue3.minimum}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\u1EB9\u0300r\u1EB9\u0300 p\u1EB9\u0300l\xFA "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 par\xED p\u1EB9\u0300l\xFA "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 n\xED "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\xE1 \xE0p\u1EB9\u1EB9r\u1EB9 mu ${_issue.pattern}`;
            return `A\u1E63\xEC\u1E63e: ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `N\u1ECD\u0301mb\xE0 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 j\u1EB9\u0301 \xE8y\xE0 p\xEDp\xEDn ti ${issue3.divisor}`;
          case "unrecognized_keys":
            return `B\u1ECDt\xECn\xEC \xE0\xECm\u1ECD\u0300: ${joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `B\u1ECDt\xECn\xEC a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue3.origin}`;
          case "invalid_union":
            return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
          case "invalid_element":
            return `Iye a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue3.origin}`;
          default:
            return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
        }
      };
    };
  }
});

// node_modules/zod/v4/locales/index.js
var locales_exports = {};
__export(locales_exports, {
  ar: () => ar_default,
  az: () => az_default,
  be: () => be_default,
  bg: () => bg_default,
  ca: () => ca_default,
  cs: () => cs_default,
  da: () => da_default,
  de: () => de_default,
  en: () => en_default,
  eo: () => eo_default,
  es: () => es_default,
  fa: () => fa_default,
  fi: () => fi_default,
  fr: () => fr_default,
  frCA: () => fr_CA_default,
  he: () => he_default,
  hu: () => hu_default,
  hy: () => hy_default,
  id: () => id_default,
  is: () => is_default,
  it: () => it_default,
  ja: () => ja_default,
  ka: () => ka_default,
  kh: () => kh_default,
  km: () => km_default,
  ko: () => ko_default,
  lt: () => lt_default,
  mk: () => mk_default,
  ms: () => ms_default,
  nl: () => nl_default,
  no: () => no_default,
  ota: () => ota_default,
  pl: () => pl_default,
  ps: () => ps_default,
  pt: () => pt_default,
  ru: () => ru_default,
  sl: () => sl_default,
  sv: () => sv_default,
  ta: () => ta_default,
  th: () => th_default,
  tr: () => tr_default,
  ua: () => ua_default,
  uk: () => uk_default,
  ur: () => ur_default,
  uz: () => uz_default,
  vi: () => vi_default,
  yo: () => yo_default,
  zhCN: () => zh_CN_default,
  zhTW: () => zh_TW_default
});
var init_locales = __esm({
  "node_modules/zod/v4/locales/index.js"() {
    "use strict";
    init_ar();
    init_az();
    init_be();
    init_bg();
    init_ca();
    init_cs();
    init_da();
    init_de();
    init_en();
    init_eo();
    init_es();
    init_fa();
    init_fi();
    init_fr();
    init_fr_CA();
    init_he();
    init_hu();
    init_hy();
    init_id();
    init_is();
    init_it();
    init_ja();
    init_ka();
    init_kh();
    init_km();
    init_ko();
    init_lt();
    init_mk();
    init_ms();
    init_nl();
    init_no();
    init_ota();
    init_ps();
    init_pl();
    init_pt();
    init_ru();
    init_sl();
    init_sv();
    init_ta();
    init_th();
    init_tr();
    init_ua();
    init_uk();
    init_ur();
    init_uz();
    init_vi();
    init_zh_CN();
    init_zh_TW();
    init_yo();
  }
});

// node_modules/zod/v4/core/registries.js
function registry() {
  return new $ZodRegistry();
}
var _a15, $output, $input, $ZodRegistry, globalRegistry;
var init_registries = __esm({
  "node_modules/zod/v4/core/registries.js"() {
    "use strict";
    $output = /* @__PURE__ */ Symbol("ZodOutput");
    $input = /* @__PURE__ */ Symbol("ZodInput");
    $ZodRegistry = class {
      constructor() {
        this._map = /* @__PURE__ */ new WeakMap();
        this._idmap = /* @__PURE__ */ new Map();
      }
      add(schema, ..._meta) {
        const meta4 = _meta[0];
        this._map.set(schema, meta4);
        if (meta4 && typeof meta4 === "object" && "id" in meta4) {
          this._idmap.set(meta4.id, schema);
        }
        return this;
      }
      clear() {
        this._map = /* @__PURE__ */ new WeakMap();
        this._idmap = /* @__PURE__ */ new Map();
        return this;
      }
      remove(schema) {
        const meta4 = this._map.get(schema);
        if (meta4 && typeof meta4 === "object" && "id" in meta4) {
          this._idmap.delete(meta4.id);
        }
        this._map.delete(schema);
        return this;
      }
      get(schema) {
        const p3 = schema._zod.parent;
        if (p3) {
          const pm = { ...this.get(p3) ?? {} };
          delete pm.id;
          const f = { ...pm, ...this._map.get(schema) };
          return Object.keys(f).length ? f : void 0;
        }
        return this._map.get(schema);
      }
      has(schema) {
        return this._map.has(schema);
      }
    };
    (_a15 = globalThis).__zod_globalRegistry ?? (_a15.__zod_globalRegistry = registry());
    globalRegistry = globalThis.__zod_globalRegistry;
  }
});

// node_modules/zod/v4/core/api.js
// @__NO_SIDE_EFFECTS__
function _string(Class3, params) {
  return new Class3({
    type: "string",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedString(Class3, params) {
  return new Class3({
    type: "string",
    coerce: true,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _email(Class3, params) {
  return new Class3({
    type: "string",
    format: "email",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _guid(Class3, params) {
  return new Class3({
    type: "string",
    format: "guid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuid(Class3, params) {
  return new Class3({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv4(Class3, params) {
  return new Class3({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v4",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv6(Class3, params) {
  return new Class3({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v6",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv7(Class3, params) {
  return new Class3({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v7",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _url(Class3, params) {
  return new Class3({
    type: "string",
    format: "url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _emoji2(Class3, params) {
  return new Class3({
    type: "string",
    format: "emoji",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nanoid(Class3, params) {
  return new Class3({
    type: "string",
    format: "nanoid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid(Class3, params) {
  return new Class3({
    type: "string",
    format: "cuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid2(Class3, params) {
  return new Class3({
    type: "string",
    format: "cuid2",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ulid(Class3, params) {
  return new Class3({
    type: "string",
    format: "ulid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _xid(Class3, params) {
  return new Class3({
    type: "string",
    format: "xid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ksuid(Class3, params) {
  return new Class3({
    type: "string",
    format: "ksuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv4(Class3, params) {
  return new Class3({
    type: "string",
    format: "ipv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv6(Class3, params) {
  return new Class3({
    type: "string",
    format: "ipv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _mac(Class3, params) {
  return new Class3({
    type: "string",
    format: "mac",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv4(Class3, params) {
  return new Class3({
    type: "string",
    format: "cidrv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv6(Class3, params) {
  return new Class3({
    type: "string",
    format: "cidrv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base64(Class3, params) {
  return new Class3({
    type: "string",
    format: "base64",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base64url(Class3, params) {
  return new Class3({
    type: "string",
    format: "base64url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _e164(Class3, params) {
  return new Class3({
    type: "string",
    format: "e164",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _jwt(Class3, params) {
  return new Class3({
    type: "string",
    format: "jwt",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDateTime(Class3, params) {
  return new Class3({
    type: "string",
    format: "datetime",
    check: "string_format",
    offset: false,
    local: false,
    precision: null,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDate(Class3, params) {
  return new Class3({
    type: "string",
    format: "date",
    check: "string_format",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoTime(Class3, params) {
  return new Class3({
    type: "string",
    format: "time",
    check: "string_format",
    precision: null,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDuration(Class3, params) {
  return new Class3({
    type: "string",
    format: "duration",
    check: "string_format",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _number(Class3, params) {
  return new Class3({
    type: "number",
    checks: [],
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedNumber(Class3, params) {
  return new Class3({
    type: "number",
    coerce: true,
    checks: [],
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int(Class3, params) {
  return new Class3({
    type: "number",
    check: "number_format",
    abort: false,
    format: "safeint",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _float32(Class3, params) {
  return new Class3({
    type: "number",
    check: "number_format",
    abort: false,
    format: "float32",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _float64(Class3, params) {
  return new Class3({
    type: "number",
    check: "number_format",
    abort: false,
    format: "float64",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int32(Class3, params) {
  return new Class3({
    type: "number",
    check: "number_format",
    abort: false,
    format: "int32",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uint32(Class3, params) {
  return new Class3({
    type: "number",
    check: "number_format",
    abort: false,
    format: "uint32",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _boolean(Class3, params) {
  return new Class3({
    type: "boolean",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedBoolean(Class3, params) {
  return new Class3({
    type: "boolean",
    coerce: true,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _bigint(Class3, params) {
  return new Class3({
    type: "bigint",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedBigint(Class3, params) {
  return new Class3({
    type: "bigint",
    coerce: true,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int64(Class3, params) {
  return new Class3({
    type: "bigint",
    check: "bigint_format",
    abort: false,
    format: "int64",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uint64(Class3, params) {
  return new Class3({
    type: "bigint",
    check: "bigint_format",
    abort: false,
    format: "uint64",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _symbol(Class3, params) {
  return new Class3({
    type: "symbol",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _undefined2(Class3, params) {
  return new Class3({
    type: "undefined",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _null2(Class3, params) {
  return new Class3({
    type: "null",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _any(Class3) {
  return new Class3({
    type: "any"
  });
}
// @__NO_SIDE_EFFECTS__
function _unknown(Class3) {
  return new Class3({
    type: "unknown"
  });
}
// @__NO_SIDE_EFFECTS__
function _never(Class3, params) {
  return new Class3({
    type: "never",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _void(Class3, params) {
  return new Class3({
    type: "void",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _date(Class3, params) {
  return new Class3({
    type: "date",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedDate(Class3, params) {
  return new Class3({
    type: "date",
    coerce: true,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nan(Class3, params) {
  return new Class3({
    type: "nan",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _lt(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _lte(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _gt(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _gte(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _positive(params) {
  return /* @__PURE__ */ _gt(0, params);
}
// @__NO_SIDE_EFFECTS__
function _negative(params) {
  return /* @__PURE__ */ _lt(0, params);
}
// @__NO_SIDE_EFFECTS__
function _nonpositive(params) {
  return /* @__PURE__ */ _lte(0, params);
}
// @__NO_SIDE_EFFECTS__
function _nonnegative(params) {
  return /* @__PURE__ */ _gte(0, params);
}
// @__NO_SIDE_EFFECTS__
function _multipleOf(value, params) {
  return new $ZodCheckMultipleOf({
    check: "multiple_of",
    ...normalizeParams(params),
    value
  });
}
// @__NO_SIDE_EFFECTS__
function _maxSize(maximum, params) {
  return new $ZodCheckMaxSize({
    check: "max_size",
    ...normalizeParams(params),
    maximum
  });
}
// @__NO_SIDE_EFFECTS__
function _minSize(minimum, params) {
  return new $ZodCheckMinSize({
    check: "min_size",
    ...normalizeParams(params),
    minimum
  });
}
// @__NO_SIDE_EFFECTS__
function _size(size, params) {
  return new $ZodCheckSizeEquals({
    check: "size_equals",
    ...normalizeParams(params),
    size
  });
}
// @__NO_SIDE_EFFECTS__
function _maxLength(maximum, params) {
  const ch = new $ZodCheckMaxLength({
    check: "max_length",
    ...normalizeParams(params),
    maximum
  });
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _minLength(minimum, params) {
  return new $ZodCheckMinLength({
    check: "min_length",
    ...normalizeParams(params),
    minimum
  });
}
// @__NO_SIDE_EFFECTS__
function _length(length, params) {
  return new $ZodCheckLengthEquals({
    check: "length_equals",
    ...normalizeParams(params),
    length
  });
}
// @__NO_SIDE_EFFECTS__
function _regex(pattern, params) {
  return new $ZodCheckRegex({
    check: "string_format",
    format: "regex",
    ...normalizeParams(params),
    pattern
  });
}
// @__NO_SIDE_EFFECTS__
function _lowercase(params) {
  return new $ZodCheckLowerCase({
    check: "string_format",
    format: "lowercase",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uppercase(params) {
  return new $ZodCheckUpperCase({
    check: "string_format",
    format: "uppercase",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _includes(includes, params) {
  return new $ZodCheckIncludes({
    check: "string_format",
    format: "includes",
    ...normalizeParams(params),
    includes
  });
}
// @__NO_SIDE_EFFECTS__
function _startsWith(prefix, params) {
  return new $ZodCheckStartsWith({
    check: "string_format",
    format: "starts_with",
    ...normalizeParams(params),
    prefix
  });
}
// @__NO_SIDE_EFFECTS__
function _endsWith(suffix, params) {
  return new $ZodCheckEndsWith({
    check: "string_format",
    format: "ends_with",
    ...normalizeParams(params),
    suffix
  });
}
// @__NO_SIDE_EFFECTS__
function _property(property2, schema, params) {
  return new $ZodCheckProperty({
    check: "property",
    property: property2,
    schema,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _mime(types, params) {
  return new $ZodCheckMimeType({
    check: "mime_type",
    mime: types,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _overwrite(tx) {
  return new $ZodCheckOverwrite({
    check: "overwrite",
    tx
  });
}
// @__NO_SIDE_EFFECTS__
function _normalize(form) {
  return /* @__PURE__ */ _overwrite((input) => input.normalize(form));
}
// @__NO_SIDE_EFFECTS__
function _trim() {
  return /* @__PURE__ */ _overwrite((input) => input.trim());
}
// @__NO_SIDE_EFFECTS__
function _toLowerCase() {
  return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());
}
// @__NO_SIDE_EFFECTS__
function _toUpperCase() {
  return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());
}
// @__NO_SIDE_EFFECTS__
function _slugify() {
  return /* @__PURE__ */ _overwrite((input) => slugify(input));
}
// @__NO_SIDE_EFFECTS__
function _array(Class3, element, params) {
  return new Class3({
    type: "array",
    element,
    // get element() {
    //   return element;
    // },
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _union(Class3, options, params) {
  return new Class3({
    type: "union",
    options,
    ...normalizeParams(params)
  });
}
function _xor(Class3, options, params) {
  return new Class3({
    type: "union",
    options,
    inclusive: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _discriminatedUnion(Class3, discriminator, options, params) {
  return new Class3({
    type: "union",
    options,
    discriminator,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _intersection(Class3, left, right) {
  return new Class3({
    type: "intersection",
    left,
    right
  });
}
// @__NO_SIDE_EFFECTS__
function _tuple(Class3, items, _paramsOrRest, _params) {
  const hasRest = _paramsOrRest instanceof $ZodType;
  const params = hasRest ? _params : _paramsOrRest;
  const rest = hasRest ? _paramsOrRest : null;
  return new Class3({
    type: "tuple",
    items,
    rest,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _record(Class3, keyType, valueType, params) {
  return new Class3({
    type: "record",
    keyType,
    valueType,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _map(Class3, keyType, valueType, params) {
  return new Class3({
    type: "map",
    keyType,
    valueType,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _set(Class3, valueType, params) {
  return new Class3({
    type: "set",
    valueType,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _enum(Class3, values, params) {
  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
  return new Class3({
    type: "enum",
    entries,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nativeEnum(Class3, entries, params) {
  return new Class3({
    type: "enum",
    entries,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _literal(Class3, value, params) {
  return new Class3({
    type: "literal",
    values: Array.isArray(value) ? value : [value],
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _file(Class3, params) {
  return new Class3({
    type: "file",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _transform(Class3, fn) {
  return new Class3({
    type: "transform",
    transform: fn
  });
}
// @__NO_SIDE_EFFECTS__
function _optional(Class3, innerType) {
  return new Class3({
    type: "optional",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _nullable(Class3, innerType) {
  return new Class3({
    type: "nullable",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _default(Class3, innerType, defaultValue) {
  return new Class3({
    type: "default",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
    }
  });
}
// @__NO_SIDE_EFFECTS__
function _nonoptional(Class3, innerType, params) {
  return new Class3({
    type: "nonoptional",
    innerType,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _success(Class3, innerType) {
  return new Class3({
    type: "success",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _catch(Class3, innerType, catchValue) {
  return new Class3({
    type: "catch",
    innerType,
    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
  });
}
// @__NO_SIDE_EFFECTS__
function _pipe(Class3, in_, out) {
  return new Class3({
    type: "pipe",
    in: in_,
    out
  });
}
// @__NO_SIDE_EFFECTS__
function _readonly(Class3, innerType) {
  return new Class3({
    type: "readonly",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _templateLiteral(Class3, parts, params) {
  return new Class3({
    type: "template_literal",
    parts,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _lazy(Class3, getter) {
  return new Class3({
    type: "lazy",
    getter
  });
}
// @__NO_SIDE_EFFECTS__
function _promise(Class3, innerType) {
  return new Class3({
    type: "promise",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _custom(Class3, fn, _params) {
  const norm = normalizeParams(_params);
  norm.abort ?? (norm.abort = true);
  const schema = new Class3({
    type: "custom",
    check: "custom",
    fn,
    ...norm
  });
  return schema;
}
// @__NO_SIDE_EFFECTS__
function _refine(Class3, fn, _params) {
  const schema = new Class3({
    type: "custom",
    check: "custom",
    fn,
    ...normalizeParams(_params)
  });
  return schema;
}
// @__NO_SIDE_EFFECTS__
function _superRefine(fn) {
  const ch = /* @__PURE__ */ _check((payload) => {
    payload.addIssue = (issue3) => {
      if (typeof issue3 === "string") {
        payload.issues.push(issue(issue3, payload.value, ch._zod.def));
      } else {
        const _issue = issue3;
        if (_issue.fatal)
          _issue.continue = false;
        _issue.code ?? (_issue.code = "custom");
        _issue.input ?? (_issue.input = payload.value);
        _issue.inst ?? (_issue.inst = ch);
        _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
        payload.issues.push(issue(_issue));
      }
    };
    return fn(payload.value, payload);
  });
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _check(fn, params) {
  const ch = new $ZodCheck({
    check: "custom",
    ...normalizeParams(params)
  });
  ch._zod.check = fn;
  return ch;
}
// @__NO_SIDE_EFFECTS__
function describe(description) {
  const ch = new $ZodCheck({ check: "describe" });
  ch._zod.onattach = [
    (inst) => {
      const existing = globalRegistry.get(inst) ?? {};
      globalRegistry.add(inst, { ...existing, description });
    }
  ];
  ch._zod.check = () => {
  };
  return ch;
}
// @__NO_SIDE_EFFECTS__
function meta(metadata) {
  const ch = new $ZodCheck({ check: "meta" });
  ch._zod.onattach = [
    (inst) => {
      const existing = globalRegistry.get(inst) ?? {};
      globalRegistry.add(inst, { ...existing, ...metadata });
    }
  ];
  ch._zod.check = () => {
  };
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _stringbool(Classes, _params) {
  const params = normalizeParams(_params);
  let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
  let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
  if (params.case !== "sensitive") {
    truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
    falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
  }
  const truthySet = new Set(truthyArray);
  const falsySet = new Set(falsyArray);
  const _Codec = Classes.Codec ?? $ZodCodec;
  const _Boolean = Classes.Boolean ?? $ZodBoolean;
  const _String = Classes.String ?? $ZodString;
  const stringSchema = new _String({ type: "string", error: params.error });
  const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
  const codec3 = new _Codec({
    type: "pipe",
    in: stringSchema,
    out: booleanSchema,
    transform: ((input, payload) => {
      let data = input;
      if (params.case !== "sensitive")
        data = data.toLowerCase();
      if (truthySet.has(data)) {
        return true;
      } else if (falsySet.has(data)) {
        return false;
      } else {
        payload.issues.push({
          code: "invalid_value",
          expected: "stringbool",
          values: [...truthySet, ...falsySet],
          input: payload.value,
          inst: codec3,
          continue: false
        });
        return {};
      }
    }),
    reverseTransform: ((input, _payload) => {
      if (input === true) {
        return truthyArray[0] || "true";
      } else {
        return falsyArray[0] || "false";
      }
    }),
    error: params.error
  });
  return codec3;
}
// @__NO_SIDE_EFFECTS__
function _stringFormat(Class3, format, fnOrRegex, _params = {}) {
  const params = normalizeParams(_params);
  const def = {
    ...normalizeParams(_params),
    check: "string_format",
    type: "string",
    format,
    fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
    ...params
  };
  if (fnOrRegex instanceof RegExp) {
    def.pattern = fnOrRegex;
  }
  const inst = new Class3(def);
  return inst;
}
var TimePrecision;
var init_api = __esm({
  "node_modules/zod/v4/core/api.js"() {
    "use strict";
    init_checks();
    init_registries();
    init_schemas();
    init_util();
    TimePrecision = {
      Any: null,
      Minute: -1,
      Second: 0,
      Millisecond: 3,
      Microsecond: 6
    };
  }
});

// node_modules/zod/v4/core/to-json-schema.js
function initializeContext(params) {
  let target = params?.target ?? "draft-2020-12";
  if (target === "draft-4")
    target = "draft-04";
  if (target === "draft-7")
    target = "draft-07";
  return {
    processors: params.processors ?? {},
    metadataRegistry: params?.metadata ?? globalRegistry,
    target,
    unrepresentable: params?.unrepresentable ?? "throw",
    override: params?.override ?? (() => {
    }),
    io: params?.io ?? "output",
    counter: 0,
    seen: /* @__PURE__ */ new Map(),
    cycles: params?.cycles ?? "ref",
    reused: params?.reused ?? "inline",
    external: params?.external ?? void 0
  };
}
function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
  var _a31;
  const def = schema._zod.def;
  const seen = ctx.seen.get(schema);
  if (seen) {
    seen.count++;
    const isCycle = _params.schemaPath.includes(schema);
    if (isCycle) {
      seen.cycle = _params.path;
    }
    return seen.schema;
  }
  const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
  ctx.seen.set(schema, result);
  const overrideSchema = schema._zod.toJSONSchema?.();
  if (overrideSchema) {
    result.schema = overrideSchema;
  } else {
    const params = {
      ..._params,
      schemaPath: [..._params.schemaPath, schema],
      path: _params.path
    };
    if (schema._zod.processJSONSchema) {
      schema._zod.processJSONSchema(ctx, result.schema, params);
    } else {
      const _json = result.schema;
      const processor = ctx.processors[def.type];
      if (!processor) {
        throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
      }
      processor(schema, ctx, _json, params);
    }
    const parent = schema._zod.parent;
    if (parent) {
      if (!result.ref)
        result.ref = parent;
      process2(parent, ctx, params);
      ctx.seen.get(parent).isParent = true;
    }
  }
  const meta4 = ctx.metadataRegistry.get(schema);
  if (meta4)
    Object.assign(result.schema, meta4);
  if (ctx.io === "input" && isTransforming(schema)) {
    delete result.schema.examples;
    delete result.schema.default;
  }
  if (ctx.io === "input" && result.schema._prefault)
    (_a31 = result.schema).default ?? (_a31.default = result.schema._prefault);
  delete result.schema._prefault;
  const _result = ctx.seen.get(schema);
  return _result.schema;
}
function extractDefs(ctx, schema) {
  const root2 = ctx.seen.get(schema);
  if (!root2)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const idToSchema = /* @__PURE__ */ new Map();
  for (const entry of ctx.seen.entries()) {
    const id = ctx.metadataRegistry.get(entry[0])?.id;
    if (id) {
      const existing = idToSchema.get(id);
      if (existing && existing !== entry[0]) {
        throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
      }
      idToSchema.set(id, entry[0]);
    }
  }
  const makeURI = (entry) => {
    const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
    if (ctx.external) {
      const externalId = ctx.external.registry.get(entry[0])?.id;
      const uriGenerator = ctx.external.uri ?? ((id2) => id2);
      if (externalId) {
        return { ref: uriGenerator(externalId) };
      }
      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
      entry[1].defId = id;
      return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
    }
    if (entry[1] === root2) {
      return { ref: "#" };
    }
    const uriPrefix = `#`;
    const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
    return { defId, ref: defUriPrefix + defId };
  };
  const extractToDef = (entry) => {
    if (entry[1].schema.$ref) {
      return;
    }
    const seen = entry[1];
    const { ref, defId } = makeURI(entry);
    seen.def = { ...seen.schema };
    if (defId)
      seen.defId = defId;
    const schema2 = seen.schema;
    for (const key in schema2) {
      delete schema2[key];
    }
    schema2.$ref = ref;
  };
  if (ctx.cycles === "throw") {
    for (const entry of ctx.seen.entries()) {
      const seen = entry[1];
      if (seen.cycle) {
        throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>

Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
      }
    }
  }
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (schema === entry[0]) {
      extractToDef(entry);
      continue;
    }
    if (ctx.external) {
      const ext = ctx.external.registry.get(entry[0])?.id;
      if (schema !== entry[0] && ext) {
        extractToDef(entry);
        continue;
      }
    }
    const id = ctx.metadataRegistry.get(entry[0])?.id;
    if (id) {
      extractToDef(entry);
      continue;
    }
    if (seen.cycle) {
      extractToDef(entry);
      continue;
    }
    if (seen.count > 1) {
      if (ctx.reused === "ref") {
        extractToDef(entry);
        continue;
      }
    }
  }
}
function finalize(ctx, schema) {
  const root2 = ctx.seen.get(schema);
  if (!root2)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const flattenRef = (zodSchema4) => {
    const seen = ctx.seen.get(zodSchema4);
    if (seen.ref === null)
      return;
    const schema2 = seen.def ?? seen.schema;
    const _cached = { ...schema2 };
    const ref = seen.ref;
    seen.ref = null;
    if (ref) {
      flattenRef(ref);
      const refSeen = ctx.seen.get(ref);
      const refSchema = refSeen.schema;
      if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
        schema2.allOf = schema2.allOf ?? [];
        schema2.allOf.push(refSchema);
      } else {
        Object.assign(schema2, refSchema);
      }
      Object.assign(schema2, _cached);
      const isParentRef = zodSchema4._zod.parent === ref;
      if (isParentRef) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (!(key in _cached)) {
            delete schema2[key];
          }
        }
      }
      if (refSchema.$ref && refSeen.def) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
            delete schema2[key];
          }
        }
      }
    }
    const parent = zodSchema4._zod.parent;
    if (parent && parent !== ref) {
      flattenRef(parent);
      const parentSeen = ctx.seen.get(parent);
      if (parentSeen?.schema.$ref) {
        schema2.$ref = parentSeen.schema.$ref;
        if (parentSeen.def) {
          for (const key in schema2) {
            if (key === "$ref" || key === "allOf")
              continue;
            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
              delete schema2[key];
            }
          }
        }
      }
    }
    ctx.override({
      zodSchema: zodSchema4,
      jsonSchema: schema2,
      path: seen.path ?? []
    });
  };
  for (const entry of [...ctx.seen.entries()].reverse()) {
    flattenRef(entry[0]);
  }
  const result = {};
  if (ctx.target === "draft-2020-12") {
    result.$schema = "https://json-schema.org/draft/2020-12/schema";
  } else if (ctx.target === "draft-07") {
    result.$schema = "http://json-schema.org/draft-07/schema#";
  } else if (ctx.target === "draft-04") {
    result.$schema = "http://json-schema.org/draft-04/schema#";
  } else if (ctx.target === "openapi-3.0") {
  } else {
  }
  if (ctx.external?.uri) {
    const id = ctx.external.registry.get(schema)?.id;
    if (!id)
      throw new Error("Schema is missing an `id` property");
    result.$id = ctx.external.uri(id);
  }
  Object.assign(result, root2.def ?? root2.schema);
  const defs = ctx.external?.defs ?? {};
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (seen.def && seen.defId) {
      defs[seen.defId] = seen.def;
    }
  }
  if (ctx.external) {
  } else {
    if (Object.keys(defs).length > 0) {
      if (ctx.target === "draft-2020-12") {
        result.$defs = defs;
      } else {
        result.definitions = defs;
      }
    }
  }
  try {
    const finalized = JSON.parse(JSON.stringify(result));
    Object.defineProperty(finalized, "~standard", {
      value: {
        ...schema["~standard"],
        jsonSchema: {
          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
        }
      },
      enumerable: false,
      writable: false
    });
    return finalized;
  } catch (_err) {
    throw new Error("Error converting schema to JSON.");
  }
}
function isTransforming(_schema, _ctx) {
  const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
  if (ctx.seen.has(_schema))
    return false;
  ctx.seen.add(_schema);
  const def = _schema._zod.def;
  if (def.type === "transform")
    return true;
  if (def.type === "array")
    return isTransforming(def.element, ctx);
  if (def.type === "set")
    return isTransforming(def.valueType, ctx);
  if (def.type === "lazy")
    return isTransforming(def.getter(), ctx);
  if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
    return isTransforming(def.innerType, ctx);
  }
  if (def.type === "intersection") {
    return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
  }
  if (def.type === "record" || def.type === "map") {
    return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
  }
  if (def.type === "pipe") {
    return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
  }
  if (def.type === "object") {
    for (const key in def.shape) {
      if (isTransforming(def.shape[key], ctx))
        return true;
    }
    return false;
  }
  if (def.type === "union") {
    for (const option of def.options) {
      if (isTransforming(option, ctx))
        return true;
    }
    return false;
  }
  if (def.type === "tuple") {
    for (const item of def.items) {
      if (isTransforming(item, ctx))
        return true;
    }
    if (def.rest && isTransforming(def.rest, ctx))
      return true;
    return false;
  }
  return false;
}
var createToJSONSchemaMethod, createStandardJSONSchemaMethod;
var init_to_json_schema = __esm({
  "node_modules/zod/v4/core/to-json-schema.js"() {
    "use strict";
    init_registries();
    createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
      const ctx = initializeContext({ ...params, processors });
      process2(schema, ctx);
      extractDefs(ctx, schema);
      return finalize(ctx, schema);
    };
    createStandardJSONSchemaMethod = (schema, io2, processors = {}) => (params) => {
      const { libraryOptions, target } = params ?? {};
      const ctx = initializeContext({ ...libraryOptions ?? {}, target, io: io2, processors });
      process2(schema, ctx);
      extractDefs(ctx, schema);
      return finalize(ctx, schema);
    };
  }
});

// node_modules/zod/v4/core/json-schema-processors.js
function toJSONSchema(input, params) {
  if ("_idmap" in input) {
    const registry3 = input;
    const ctx2 = initializeContext({ ...params, processors: allProcessors });
    const defs = {};
    for (const entry of registry3._idmap.entries()) {
      const [_, schema] = entry;
      process2(schema, ctx2);
    }
    const schemas = {};
    const external = {
      registry: registry3,
      uri: params?.uri,
      defs
    };
    ctx2.external = external;
    for (const entry of registry3._idmap.entries()) {
      const [key, schema] = entry;
      extractDefs(ctx2, schema);
      schemas[key] = finalize(ctx2, schema);
    }
    if (Object.keys(defs).length > 0) {
      const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
      schemas.__shared = {
        [defsSegment]: defs
      };
    }
    return { schemas };
  }
  const ctx = initializeContext({ ...params, processors: allProcessors });
  process2(input, ctx);
  extractDefs(ctx, input);
  return finalize(ctx, input);
}
var formatMap, stringProcessor, numberProcessor, booleanProcessor, bigintProcessor, symbolProcessor, nullProcessor, undefinedProcessor, voidProcessor, neverProcessor, anyProcessor, unknownProcessor, dateProcessor, enumProcessor, literalProcessor, nanProcessor, templateLiteralProcessor, fileProcessor, successProcessor, customProcessor, functionProcessor, transformProcessor, mapProcessor, setProcessor, arrayProcessor, objectProcessor, unionProcessor, intersectionProcessor, tupleProcessor, recordProcessor, nullableProcessor, nonoptionalProcessor, defaultProcessor, prefaultProcessor, catchProcessor, pipeProcessor, readonlyProcessor, promiseProcessor, optionalProcessor, lazyProcessor, allProcessors;
var init_json_schema_processors = __esm({
  "node_modules/zod/v4/core/json-schema-processors.js"() {
    "use strict";
    init_to_json_schema();
    init_util();
    formatMap = {
      guid: "uuid",
      url: "uri",
      datetime: "date-time",
      json_string: "json-string",
      regex: ""
      // do not set
    };
    stringProcessor = (schema, ctx, _json, _params) => {
      const json4 = _json;
      json4.type = "string";
      const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
      if (typeof minimum === "number")
        json4.minLength = minimum;
      if (typeof maximum === "number")
        json4.maxLength = maximum;
      if (format) {
        json4.format = formatMap[format] ?? format;
        if (json4.format === "")
          delete json4.format;
        if (format === "time") {
          delete json4.format;
        }
      }
      if (contentEncoding)
        json4.contentEncoding = contentEncoding;
      if (patterns && patterns.size > 0) {
        const regexes = [...patterns];
        if (regexes.length === 1)
          json4.pattern = regexes[0].source;
        else if (regexes.length > 1) {
          json4.allOf = [
            ...regexes.map((regex) => ({
              ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
              pattern: regex.source
            }))
          ];
        }
      }
    };
    numberProcessor = (schema, ctx, _json, _params) => {
      const json4 = _json;
      const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
      if (typeof format === "string" && format.includes("int"))
        json4.type = "integer";
      else
        json4.type = "number";
      if (typeof exclusiveMinimum === "number") {
        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
          json4.minimum = exclusiveMinimum;
          json4.exclusiveMinimum = true;
        } else {
          json4.exclusiveMinimum = exclusiveMinimum;
        }
      }
      if (typeof minimum === "number") {
        json4.minimum = minimum;
        if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
          if (exclusiveMinimum >= minimum)
            delete json4.minimum;
          else
            delete json4.exclusiveMinimum;
        }
      }
      if (typeof exclusiveMaximum === "number") {
        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
          json4.maximum = exclusiveMaximum;
          json4.exclusiveMaximum = true;
        } else {
          json4.exclusiveMaximum = exclusiveMaximum;
        }
      }
      if (typeof maximum === "number") {
        json4.maximum = maximum;
        if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
          if (exclusiveMaximum <= maximum)
            delete json4.maximum;
          else
            delete json4.exclusiveMaximum;
        }
      }
      if (typeof multipleOf === "number")
        json4.multipleOf = multipleOf;
    };
    booleanProcessor = (_schema, _ctx, json4, _params) => {
      json4.type = "boolean";
    };
    bigintProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("BigInt cannot be represented in JSON Schema");
      }
    };
    symbolProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Symbols cannot be represented in JSON Schema");
      }
    };
    nullProcessor = (_schema, ctx, json4, _params) => {
      if (ctx.target === "openapi-3.0") {
        json4.type = "string";
        json4.nullable = true;
        json4.enum = [null];
      } else {
        json4.type = "null";
      }
    };
    undefinedProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Undefined cannot be represented in JSON Schema");
      }
    };
    voidProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Void cannot be represented in JSON Schema");
      }
    };
    neverProcessor = (_schema, _ctx, json4, _params) => {
      json4.not = {};
    };
    anyProcessor = (_schema, _ctx, _json, _params) => {
    };
    unknownProcessor = (_schema, _ctx, _json, _params) => {
    };
    dateProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Date cannot be represented in JSON Schema");
      }
    };
    enumProcessor = (schema, _ctx, json4, _params) => {
      const def = schema._zod.def;
      const values = getEnumValues(def.entries);
      if (values.every((v) => typeof v === "number"))
        json4.type = "number";
      if (values.every((v) => typeof v === "string"))
        json4.type = "string";
      json4.enum = values;
    };
    literalProcessor = (schema, ctx, json4, _params) => {
      const def = schema._zod.def;
      const vals = [];
      for (const val of def.values) {
        if (val === void 0) {
          if (ctx.unrepresentable === "throw") {
            throw new Error("Literal `undefined` cannot be represented in JSON Schema");
          } else {
          }
        } else if (typeof val === "bigint") {
          if (ctx.unrepresentable === "throw") {
            throw new Error("BigInt literals cannot be represented in JSON Schema");
          } else {
            vals.push(Number(val));
          }
        } else {
          vals.push(val);
        }
      }
      if (vals.length === 0) {
      } else if (vals.length === 1) {
        const val = vals[0];
        json4.type = val === null ? "null" : typeof val;
        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
          json4.enum = [val];
        } else {
          json4.const = val;
        }
      } else {
        if (vals.every((v) => typeof v === "number"))
          json4.type = "number";
        if (vals.every((v) => typeof v === "string"))
          json4.type = "string";
        if (vals.every((v) => typeof v === "boolean"))
          json4.type = "boolean";
        if (vals.every((v) => v === null))
          json4.type = "null";
        json4.enum = vals;
      }
    };
    nanProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("NaN cannot be represented in JSON Schema");
      }
    };
    templateLiteralProcessor = (schema, _ctx, json4, _params) => {
      const _json = json4;
      const pattern = schema._zod.pattern;
      if (!pattern)
        throw new Error("Pattern not found in template literal");
      _json.type = "string";
      _json.pattern = pattern.source;
    };
    fileProcessor = (schema, _ctx, json4, _params) => {
      const _json = json4;
      const file3 = {
        type: "string",
        format: "binary",
        contentEncoding: "binary"
      };
      const { minimum, maximum, mime } = schema._zod.bag;
      if (minimum !== void 0)
        file3.minLength = minimum;
      if (maximum !== void 0)
        file3.maxLength = maximum;
      if (mime) {
        if (mime.length === 1) {
          file3.contentMediaType = mime[0];
          Object.assign(_json, file3);
        } else {
          Object.assign(_json, file3);
          _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
        }
      } else {
        Object.assign(_json, file3);
      }
    };
    successProcessor = (_schema, _ctx, json4, _params) => {
      json4.type = "boolean";
    };
    customProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Custom types cannot be represented in JSON Schema");
      }
    };
    functionProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Function types cannot be represented in JSON Schema");
      }
    };
    transformProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Transforms cannot be represented in JSON Schema");
      }
    };
    mapProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Map cannot be represented in JSON Schema");
      }
    };
    setProcessor = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Set cannot be represented in JSON Schema");
      }
    };
    arrayProcessor = (schema, ctx, _json, params) => {
      const json4 = _json;
      const def = schema._zod.def;
      const { minimum, maximum } = schema._zod.bag;
      if (typeof minimum === "number")
        json4.minItems = minimum;
      if (typeof maximum === "number")
        json4.maxItems = maximum;
      json4.type = "array";
      json4.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
    };
    objectProcessor = (schema, ctx, _json, params) => {
      const json4 = _json;
      const def = schema._zod.def;
      json4.type = "object";
      json4.properties = {};
      const shape = def.shape;
      for (const key in shape) {
        json4.properties[key] = process2(shape[key], ctx, {
          ...params,
          path: [...params.path, "properties", key]
        });
      }
      const allKeys = new Set(Object.keys(shape));
      const requiredKeys = new Set([...allKeys].filter((key) => {
        const v = def.shape[key]._zod;
        if (ctx.io === "input") {
          return v.optin === void 0;
        } else {
          return v.optout === void 0;
        }
      }));
      if (requiredKeys.size > 0) {
        json4.required = Array.from(requiredKeys);
      }
      if (def.catchall?._zod.def.type === "never") {
        json4.additionalProperties = false;
      } else if (!def.catchall) {
        if (ctx.io === "output")
          json4.additionalProperties = false;
      } else if (def.catchall) {
        json4.additionalProperties = process2(def.catchall, ctx, {
          ...params,
          path: [...params.path, "additionalProperties"]
        });
      }
    };
    unionProcessor = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      const isExclusive = def.inclusive === false;
      const options = def.options.map((x, i) => process2(x, ctx, {
        ...params,
        path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
      }));
      if (isExclusive) {
        json4.oneOf = options;
      } else {
        json4.anyOf = options;
      }
    };
    intersectionProcessor = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      const a = process2(def.left, ctx, {
        ...params,
        path: [...params.path, "allOf", 0]
      });
      const b = process2(def.right, ctx, {
        ...params,
        path: [...params.path, "allOf", 1]
      });
      const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
      const allOf = [
        ...isSimpleIntersection(a) ? a.allOf : [a],
        ...isSimpleIntersection(b) ? b.allOf : [b]
      ];
      json4.allOf = allOf;
    };
    tupleProcessor = (schema, ctx, _json, params) => {
      const json4 = _json;
      const def = schema._zod.def;
      json4.type = "array";
      const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
      const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
      const prefixItems = def.items.map((x, i) => process2(x, ctx, {
        ...params,
        path: [...params.path, prefixPath, i]
      }));
      const rest = def.rest ? process2(def.rest, ctx, {
        ...params,
        path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
      }) : null;
      if (ctx.target === "draft-2020-12") {
        json4.prefixItems = prefixItems;
        if (rest) {
          json4.items = rest;
        }
      } else if (ctx.target === "openapi-3.0") {
        json4.items = {
          anyOf: prefixItems
        };
        if (rest) {
          json4.items.anyOf.push(rest);
        }
        json4.minItems = prefixItems.length;
        if (!rest) {
          json4.maxItems = prefixItems.length;
        }
      } else {
        json4.items = prefixItems;
        if (rest) {
          json4.additionalItems = rest;
        }
      }
      const { minimum, maximum } = schema._zod.bag;
      if (typeof minimum === "number")
        json4.minItems = minimum;
      if (typeof maximum === "number")
        json4.maxItems = maximum;
    };
    recordProcessor = (schema, ctx, _json, params) => {
      const json4 = _json;
      const def = schema._zod.def;
      json4.type = "object";
      const keyType = def.keyType;
      const keyBag = keyType._zod.bag;
      const patterns = keyBag?.patterns;
      if (def.mode === "loose" && patterns && patterns.size > 0) {
        const valueSchema = process2(def.valueType, ctx, {
          ...params,
          path: [...params.path, "patternProperties", "*"]
        });
        json4.patternProperties = {};
        for (const pattern of patterns) {
          json4.patternProperties[pattern.source] = valueSchema;
        }
      } else {
        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
          json4.propertyNames = process2(def.keyType, ctx, {
            ...params,
            path: [...params.path, "propertyNames"]
          });
        }
        json4.additionalProperties = process2(def.valueType, ctx, {
          ...params,
          path: [...params.path, "additionalProperties"]
        });
      }
      const keyValues = keyType._zod.values;
      if (keyValues) {
        const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
        if (validKeyValues.length > 0) {
          json4.required = validKeyValues;
        }
      }
    };
    nullableProcessor = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      const inner = process2(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      if (ctx.target === "openapi-3.0") {
        seen.ref = def.innerType;
        json4.nullable = true;
      } else {
        json4.anyOf = [inner, { type: "null" }];
      }
    };
    nonoptionalProcessor = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      process2(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
    };
    defaultProcessor = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      process2(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      json4.default = JSON.parse(JSON.stringify(def.defaultValue));
    };
    prefaultProcessor = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      process2(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      if (ctx.io === "input")
        json4._prefault = JSON.parse(JSON.stringify(def.defaultValue));
    };
    catchProcessor = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      process2(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      let catchValue;
      try {
        catchValue = def.catchValue(void 0);
      } catch {
        throw new Error("Dynamic catch values are not supported in JSON Schema");
      }
      json4.default = catchValue;
    };
    pipeProcessor = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
      process2(innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = innerType;
    };
    readonlyProcessor = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      process2(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      json4.readOnly = true;
    };
    promiseProcessor = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      process2(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
    };
    optionalProcessor = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      process2(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
    };
    lazyProcessor = (schema, ctx, _json, params) => {
      const innerType = schema._zod.innerType;
      process2(innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = innerType;
    };
    allProcessors = {
      string: stringProcessor,
      number: numberProcessor,
      boolean: booleanProcessor,
      bigint: bigintProcessor,
      symbol: symbolProcessor,
      null: nullProcessor,
      undefined: undefinedProcessor,
      void: voidProcessor,
      never: neverProcessor,
      any: anyProcessor,
      unknown: unknownProcessor,
      date: dateProcessor,
      enum: enumProcessor,
      literal: literalProcessor,
      nan: nanProcessor,
      template_literal: templateLiteralProcessor,
      file: fileProcessor,
      success: successProcessor,
      custom: customProcessor,
      function: functionProcessor,
      transform: transformProcessor,
      map: mapProcessor,
      set: setProcessor,
      array: arrayProcessor,
      object: objectProcessor,
      union: unionProcessor,
      intersection: intersectionProcessor,
      tuple: tupleProcessor,
      record: recordProcessor,
      nullable: nullableProcessor,
      nonoptional: nonoptionalProcessor,
      default: defaultProcessor,
      prefault: prefaultProcessor,
      catch: catchProcessor,
      pipe: pipeProcessor,
      readonly: readonlyProcessor,
      promise: promiseProcessor,
      optional: optionalProcessor,
      lazy: lazyProcessor
    };
  }
});

// node_modules/zod/v4/core/json-schema-generator.js
var JSONSchemaGenerator;
var init_json_schema_generator = __esm({
  "node_modules/zod/v4/core/json-schema-generator.js"() {
    "use strict";
    init_json_schema_processors();
    init_to_json_schema();
    JSONSchemaGenerator = class {
      /** @deprecated Access via ctx instead */
      get metadataRegistry() {
        return this.ctx.metadataRegistry;
      }
      /** @deprecated Access via ctx instead */
      get target() {
        return this.ctx.target;
      }
      /** @deprecated Access via ctx instead */
      get unrepresentable() {
        return this.ctx.unrepresentable;
      }
      /** @deprecated Access via ctx instead */
      get override() {
        return this.ctx.override;
      }
      /** @deprecated Access via ctx instead */
      get io() {
        return this.ctx.io;
      }
      /** @deprecated Access via ctx instead */
      get counter() {
        return this.ctx.counter;
      }
      set counter(value) {
        this.ctx.counter = value;
      }
      /** @deprecated Access via ctx instead */
      get seen() {
        return this.ctx.seen;
      }
      constructor(params) {
        let normalizedTarget = params?.target ?? "draft-2020-12";
        if (normalizedTarget === "draft-4")
          normalizedTarget = "draft-04";
        if (normalizedTarget === "draft-7")
          normalizedTarget = "draft-07";
        this.ctx = initializeContext({
          processors: allProcessors,
          target: normalizedTarget,
          ...params?.metadata && { metadata: params.metadata },
          ...params?.unrepresentable && { unrepresentable: params.unrepresentable },
          ...params?.override && { override: params.override },
          ...params?.io && { io: params.io }
        });
      }
      /**
       * Process a schema to prepare it for JSON Schema generation.
       * This must be called before emit().
       */
      process(schema, _params = { path: [], schemaPath: [] }) {
        return process2(schema, this.ctx, _params);
      }
      /**
       * Emit the final JSON Schema after processing.
       * Must call process() first.
       */
      emit(schema, _params) {
        if (_params) {
          if (_params.cycles)
            this.ctx.cycles = _params.cycles;
          if (_params.reused)
            this.ctx.reused = _params.reused;
          if (_params.external)
            this.ctx.external = _params.external;
        }
        extractDefs(this.ctx, schema);
        const result = finalize(this.ctx, schema);
        const { "~standard": _, ...plainResult } = result;
        return plainResult;
      }
    };
  }
});

// node_modules/zod/v4/core/json-schema.js
var json_schema_exports = {};
var init_json_schema = __esm({
  "node_modules/zod/v4/core/json-schema.js"() {
    "use strict";
  }
});

// node_modules/zod/v4/core/index.js
var core_exports2 = {};
__export(core_exports2, {
  $ZodAny: () => $ZodAny,
  $ZodArray: () => $ZodArray,
  $ZodAsyncError: () => $ZodAsyncError,
  $ZodBase64: () => $ZodBase64,
  $ZodBase64URL: () => $ZodBase64URL,
  $ZodBigInt: () => $ZodBigInt,
  $ZodBigIntFormat: () => $ZodBigIntFormat,
  $ZodBoolean: () => $ZodBoolean,
  $ZodCIDRv4: () => $ZodCIDRv4,
  $ZodCIDRv6: () => $ZodCIDRv6,
  $ZodCUID: () => $ZodCUID,
  $ZodCUID2: () => $ZodCUID2,
  $ZodCatch: () => $ZodCatch,
  $ZodCheck: () => $ZodCheck,
  $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
  $ZodCheckEndsWith: () => $ZodCheckEndsWith,
  $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
  $ZodCheckIncludes: () => $ZodCheckIncludes,
  $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
  $ZodCheckLessThan: () => $ZodCheckLessThan,
  $ZodCheckLowerCase: () => $ZodCheckLowerCase,
  $ZodCheckMaxLength: () => $ZodCheckMaxLength,
  $ZodCheckMaxSize: () => $ZodCheckMaxSize,
  $ZodCheckMimeType: () => $ZodCheckMimeType,
  $ZodCheckMinLength: () => $ZodCheckMinLength,
  $ZodCheckMinSize: () => $ZodCheckMinSize,
  $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
  $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
  $ZodCheckOverwrite: () => $ZodCheckOverwrite,
  $ZodCheckProperty: () => $ZodCheckProperty,
  $ZodCheckRegex: () => $ZodCheckRegex,
  $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
  $ZodCheckStartsWith: () => $ZodCheckStartsWith,
  $ZodCheckStringFormat: () => $ZodCheckStringFormat,
  $ZodCheckUpperCase: () => $ZodCheckUpperCase,
  $ZodCodec: () => $ZodCodec,
  $ZodCustom: () => $ZodCustom,
  $ZodCustomStringFormat: () => $ZodCustomStringFormat,
  $ZodDate: () => $ZodDate,
  $ZodDefault: () => $ZodDefault,
  $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
  $ZodE164: () => $ZodE164,
  $ZodEmail: () => $ZodEmail,
  $ZodEmoji: () => $ZodEmoji,
  $ZodEncodeError: () => $ZodEncodeError,
  $ZodEnum: () => $ZodEnum,
  $ZodError: () => $ZodError,
  $ZodExactOptional: () => $ZodExactOptional,
  $ZodFile: () => $ZodFile,
  $ZodFunction: () => $ZodFunction,
  $ZodGUID: () => $ZodGUID,
  $ZodIPv4: () => $ZodIPv4,
  $ZodIPv6: () => $ZodIPv6,
  $ZodISODate: () => $ZodISODate,
  $ZodISODateTime: () => $ZodISODateTime,
  $ZodISODuration: () => $ZodISODuration,
  $ZodISOTime: () => $ZodISOTime,
  $ZodIntersection: () => $ZodIntersection,
  $ZodJWT: () => $ZodJWT,
  $ZodKSUID: () => $ZodKSUID,
  $ZodLazy: () => $ZodLazy,
  $ZodLiteral: () => $ZodLiteral,
  $ZodMAC: () => $ZodMAC,
  $ZodMap: () => $ZodMap,
  $ZodNaN: () => $ZodNaN,
  $ZodNanoID: () => $ZodNanoID,
  $ZodNever: () => $ZodNever,
  $ZodNonOptional: () => $ZodNonOptional,
  $ZodNull: () => $ZodNull,
  $ZodNullable: () => $ZodNullable,
  $ZodNumber: () => $ZodNumber,
  $ZodNumberFormat: () => $ZodNumberFormat,
  $ZodObject: () => $ZodObject,
  $ZodObjectJIT: () => $ZodObjectJIT,
  $ZodOptional: () => $ZodOptional,
  $ZodPipe: () => $ZodPipe,
  $ZodPrefault: () => $ZodPrefault,
  $ZodPromise: () => $ZodPromise,
  $ZodReadonly: () => $ZodReadonly,
  $ZodRealError: () => $ZodRealError,
  $ZodRecord: () => $ZodRecord,
  $ZodRegistry: () => $ZodRegistry,
  $ZodSet: () => $ZodSet,
  $ZodString: () => $ZodString,
  $ZodStringFormat: () => $ZodStringFormat,
  $ZodSuccess: () => $ZodSuccess,
  $ZodSymbol: () => $ZodSymbol,
  $ZodTemplateLiteral: () => $ZodTemplateLiteral,
  $ZodTransform: () => $ZodTransform,
  $ZodTuple: () => $ZodTuple,
  $ZodType: () => $ZodType,
  $ZodULID: () => $ZodULID,
  $ZodURL: () => $ZodURL,
  $ZodUUID: () => $ZodUUID,
  $ZodUndefined: () => $ZodUndefined,
  $ZodUnion: () => $ZodUnion,
  $ZodUnknown: () => $ZodUnknown,
  $ZodVoid: () => $ZodVoid,
  $ZodXID: () => $ZodXID,
  $ZodXor: () => $ZodXor,
  $brand: () => $brand,
  $constructor: () => $constructor,
  $input: () => $input,
  $output: () => $output,
  Doc: () => Doc,
  JSONSchema: () => json_schema_exports,
  JSONSchemaGenerator: () => JSONSchemaGenerator,
  NEVER: () => NEVER,
  TimePrecision: () => TimePrecision,
  _any: () => _any,
  _array: () => _array,
  _base64: () => _base64,
  _base64url: () => _base64url,
  _bigint: () => _bigint,
  _boolean: () => _boolean,
  _catch: () => _catch,
  _check: () => _check,
  _cidrv4: () => _cidrv4,
  _cidrv6: () => _cidrv6,
  _coercedBigint: () => _coercedBigint,
  _coercedBoolean: () => _coercedBoolean,
  _coercedDate: () => _coercedDate,
  _coercedNumber: () => _coercedNumber,
  _coercedString: () => _coercedString,
  _cuid: () => _cuid,
  _cuid2: () => _cuid2,
  _custom: () => _custom,
  _date: () => _date,
  _decode: () => _decode,
  _decodeAsync: () => _decodeAsync,
  _default: () => _default,
  _discriminatedUnion: () => _discriminatedUnion,
  _e164: () => _e164,
  _email: () => _email,
  _emoji: () => _emoji2,
  _encode: () => _encode,
  _encodeAsync: () => _encodeAsync,
  _endsWith: () => _endsWith,
  _enum: () => _enum,
  _file: () => _file,
  _float32: () => _float32,
  _float64: () => _float64,
  _gt: () => _gt,
  _gte: () => _gte,
  _guid: () => _guid,
  _includes: () => _includes,
  _int: () => _int,
  _int32: () => _int32,
  _int64: () => _int64,
  _intersection: () => _intersection,
  _ipv4: () => _ipv4,
  _ipv6: () => _ipv6,
  _isoDate: () => _isoDate,
  _isoDateTime: () => _isoDateTime,
  _isoDuration: () => _isoDuration,
  _isoTime: () => _isoTime,
  _jwt: () => _jwt,
  _ksuid: () => _ksuid,
  _lazy: () => _lazy,
  _length: () => _length,
  _literal: () => _literal,
  _lowercase: () => _lowercase,
  _lt: () => _lt,
  _lte: () => _lte,
  _mac: () => _mac,
  _map: () => _map,
  _max: () => _lte,
  _maxLength: () => _maxLength,
  _maxSize: () => _maxSize,
  _mime: () => _mime,
  _min: () => _gte,
  _minLength: () => _minLength,
  _minSize: () => _minSize,
  _multipleOf: () => _multipleOf,
  _nan: () => _nan,
  _nanoid: () => _nanoid,
  _nativeEnum: () => _nativeEnum,
  _negative: () => _negative,
  _never: () => _never,
  _nonnegative: () => _nonnegative,
  _nonoptional: () => _nonoptional,
  _nonpositive: () => _nonpositive,
  _normalize: () => _normalize,
  _null: () => _null2,
  _nullable: () => _nullable,
  _number: () => _number,
  _optional: () => _optional,
  _overwrite: () => _overwrite,
  _parse: () => _parse,
  _parseAsync: () => _parseAsync,
  _pipe: () => _pipe,
  _positive: () => _positive,
  _promise: () => _promise,
  _property: () => _property,
  _readonly: () => _readonly,
  _record: () => _record,
  _refine: () => _refine,
  _regex: () => _regex,
  _safeDecode: () => _safeDecode,
  _safeDecodeAsync: () => _safeDecodeAsync,
  _safeEncode: () => _safeEncode,
  _safeEncodeAsync: () => _safeEncodeAsync,
  _safeParse: () => _safeParse,
  _safeParseAsync: () => _safeParseAsync,
  _set: () => _set,
  _size: () => _size,
  _slugify: () => _slugify,
  _startsWith: () => _startsWith,
  _string: () => _string,
  _stringFormat: () => _stringFormat,
  _stringbool: () => _stringbool,
  _success: () => _success,
  _superRefine: () => _superRefine,
  _symbol: () => _symbol,
  _templateLiteral: () => _templateLiteral,
  _toLowerCase: () => _toLowerCase,
  _toUpperCase: () => _toUpperCase,
  _transform: () => _transform,
  _trim: () => _trim,
  _tuple: () => _tuple,
  _uint32: () => _uint32,
  _uint64: () => _uint64,
  _ulid: () => _ulid,
  _undefined: () => _undefined2,
  _union: () => _union,
  _unknown: () => _unknown,
  _uppercase: () => _uppercase,
  _url: () => _url,
  _uuid: () => _uuid,
  _uuidv4: () => _uuidv4,
  _uuidv6: () => _uuidv6,
  _uuidv7: () => _uuidv7,
  _void: () => _void,
  _xid: () => _xid,
  _xor: () => _xor,
  clone: () => clone,
  config: () => config,
  createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,
  createToJSONSchemaMethod: () => createToJSONSchemaMethod,
  decode: () => decode,
  decodeAsync: () => decodeAsync,
  describe: () => describe,
  encode: () => encode3,
  encodeAsync: () => encodeAsync,
  extractDefs: () => extractDefs,
  finalize: () => finalize,
  flattenError: () => flattenError,
  formatError: () => formatError,
  globalConfig: () => globalConfig,
  globalRegistry: () => globalRegistry,
  initializeContext: () => initializeContext,
  isValidBase64: () => isValidBase64,
  isValidBase64URL: () => isValidBase64URL,
  isValidJWT: () => isValidJWT,
  locales: () => locales_exports,
  meta: () => meta,
  parse: () => parse,
  parseAsync: () => parseAsync,
  prettifyError: () => prettifyError,
  process: () => process2,
  regexes: () => regexes_exports,
  registry: () => registry,
  safeDecode: () => safeDecode,
  safeDecodeAsync: () => safeDecodeAsync,
  safeEncode: () => safeEncode,
  safeEncodeAsync: () => safeEncodeAsync,
  safeParse: () => safeParse,
  safeParseAsync: () => safeParseAsync,
  toDotPath: () => toDotPath,
  toJSONSchema: () => toJSONSchema,
  treeifyError: () => treeifyError,
  util: () => util_exports,
  version: () => version
});
var init_core2 = __esm({
  "node_modules/zod/v4/core/index.js"() {
    "use strict";
    init_core();
    init_parse();
    init_errors();
    init_schemas();
    init_checks();
    init_versions();
    init_util();
    init_regexes();
    init_locales();
    init_registries();
    init_doc();
    init_api();
    init_to_json_schema();
    init_json_schema_processors();
    init_json_schema_generator();
    init_json_schema();
  }
});

// node_modules/zod/v4/classic/checks.js
var checks_exports2 = {};
__export(checks_exports2, {
  endsWith: () => _endsWith,
  gt: () => _gt,
  gte: () => _gte,
  includes: () => _includes,
  length: () => _length,
  lowercase: () => _lowercase,
  lt: () => _lt,
  lte: () => _lte,
  maxLength: () => _maxLength,
  maxSize: () => _maxSize,
  mime: () => _mime,
  minLength: () => _minLength,
  minSize: () => _minSize,
  multipleOf: () => _multipleOf,
  negative: () => _negative,
  nonnegative: () => _nonnegative,
  nonpositive: () => _nonpositive,
  normalize: () => _normalize,
  overwrite: () => _overwrite,
  positive: () => _positive,
  property: () => _property,
  regex: () => _regex,
  size: () => _size,
  slugify: () => _slugify,
  startsWith: () => _startsWith,
  toLowerCase: () => _toLowerCase,
  toUpperCase: () => _toUpperCase,
  trim: () => _trim,
  uppercase: () => _uppercase
});
var init_checks2 = __esm({
  "node_modules/zod/v4/classic/checks.js"() {
    "use strict";
    init_core2();
  }
});

// node_modules/zod/v4/classic/iso.js
var iso_exports = {};
__export(iso_exports, {
  ZodISODate: () => ZodISODate,
  ZodISODateTime: () => ZodISODateTime,
  ZodISODuration: () => ZodISODuration,
  ZodISOTime: () => ZodISOTime,
  date: () => date2,
  datetime: () => datetime2,
  duration: () => duration2,
  time: () => time2
});
function datetime2(params) {
  return _isoDateTime(ZodISODateTime, params);
}
function date2(params) {
  return _isoDate(ZodISODate, params);
}
function time2(params) {
  return _isoTime(ZodISOTime, params);
}
function duration2(params) {
  return _isoDuration(ZodISODuration, params);
}
var ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration;
var init_iso = __esm({
  "node_modules/zod/v4/classic/iso.js"() {
    "use strict";
    init_core2();
    init_schemas2();
    ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
      $ZodISODateTime.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
      $ZodISODate.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
      $ZodISOTime.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
      $ZodISODuration.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
  }
});

// node_modules/zod/v4/classic/errors.js
var initializer2, ZodError, ZodRealError;
var init_errors2 = __esm({
  "node_modules/zod/v4/classic/errors.js"() {
    "use strict";
    init_core2();
    init_core2();
    init_util();
    initializer2 = (inst, issues) => {
      $ZodError.init(inst, issues);
      inst.name = "ZodError";
      Object.defineProperties(inst, {
        format: {
          value: (mapper) => formatError(inst, mapper)
          // enumerable: false,
        },
        flatten: {
          value: (mapper) => flattenError(inst, mapper)
          // enumerable: false,
        },
        addIssue: {
          value: (issue3) => {
            inst.issues.push(issue3);
            inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
          }
          // enumerable: false,
        },
        addIssues: {
          value: (issues2) => {
            inst.issues.push(...issues2);
            inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
          }
          // enumerable: false,
        },
        isEmpty: {
          get() {
            return inst.issues.length === 0;
          }
          // enumerable: false,
        }
      });
    };
    ZodError = $constructor("ZodError", initializer2);
    ZodRealError = $constructor("ZodError", initializer2, {
      Parent: Error
    });
  }
});

// node_modules/zod/v4/classic/parse.js
var parse2, parseAsync2, safeParse2, safeParseAsync2, encode4, decode2, encodeAsync2, decodeAsync2, safeEncode2, safeDecode2, safeEncodeAsync2, safeDecodeAsync2;
var init_parse2 = __esm({
  "node_modules/zod/v4/classic/parse.js"() {
    "use strict";
    init_core2();
    init_errors2();
    parse2 = /* @__PURE__ */ _parse(ZodRealError);
    parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
    safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
    safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
    encode4 = /* @__PURE__ */ _encode(ZodRealError);
    decode2 = /* @__PURE__ */ _decode(ZodRealError);
    encodeAsync2 = /* @__PURE__ */ _encodeAsync(ZodRealError);
    decodeAsync2 = /* @__PURE__ */ _decodeAsync(ZodRealError);
    safeEncode2 = /* @__PURE__ */ _safeEncode(ZodRealError);
    safeDecode2 = /* @__PURE__ */ _safeDecode(ZodRealError);
    safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
    safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
  }
});

// node_modules/zod/v4/classic/schemas.js
var schemas_exports2 = {};
__export(schemas_exports2, {
  ZodAny: () => ZodAny,
  ZodArray: () => ZodArray,
  ZodBase64: () => ZodBase64,
  ZodBase64URL: () => ZodBase64URL,
  ZodBigInt: () => ZodBigInt,
  ZodBigIntFormat: () => ZodBigIntFormat,
  ZodBoolean: () => ZodBoolean,
  ZodCIDRv4: () => ZodCIDRv4,
  ZodCIDRv6: () => ZodCIDRv6,
  ZodCUID: () => ZodCUID,
  ZodCUID2: () => ZodCUID2,
  ZodCatch: () => ZodCatch,
  ZodCodec: () => ZodCodec,
  ZodCustom: () => ZodCustom,
  ZodCustomStringFormat: () => ZodCustomStringFormat,
  ZodDate: () => ZodDate,
  ZodDefault: () => ZodDefault,
  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
  ZodE164: () => ZodE164,
  ZodEmail: () => ZodEmail,
  ZodEmoji: () => ZodEmoji,
  ZodEnum: () => ZodEnum,
  ZodExactOptional: () => ZodExactOptional,
  ZodFile: () => ZodFile,
  ZodFunction: () => ZodFunction,
  ZodGUID: () => ZodGUID,
  ZodIPv4: () => ZodIPv4,
  ZodIPv6: () => ZodIPv6,
  ZodIntersection: () => ZodIntersection,
  ZodJWT: () => ZodJWT,
  ZodKSUID: () => ZodKSUID,
  ZodLazy: () => ZodLazy,
  ZodLiteral: () => ZodLiteral,
  ZodMAC: () => ZodMAC,
  ZodMap: () => ZodMap,
  ZodNaN: () => ZodNaN,
  ZodNanoID: () => ZodNanoID,
  ZodNever: () => ZodNever,
  ZodNonOptional: () => ZodNonOptional,
  ZodNull: () => ZodNull,
  ZodNullable: () => ZodNullable,
  ZodNumber: () => ZodNumber,
  ZodNumberFormat: () => ZodNumberFormat,
  ZodObject: () => ZodObject,
  ZodOptional: () => ZodOptional,
  ZodPipe: () => ZodPipe,
  ZodPrefault: () => ZodPrefault,
  ZodPromise: () => ZodPromise,
  ZodReadonly: () => ZodReadonly,
  ZodRecord: () => ZodRecord,
  ZodSet: () => ZodSet,
  ZodString: () => ZodString,
  ZodStringFormat: () => ZodStringFormat,
  ZodSuccess: () => ZodSuccess,
  ZodSymbol: () => ZodSymbol,
  ZodTemplateLiteral: () => ZodTemplateLiteral,
  ZodTransform: () => ZodTransform,
  ZodTuple: () => ZodTuple,
  ZodType: () => ZodType,
  ZodULID: () => ZodULID,
  ZodURL: () => ZodURL,
  ZodUUID: () => ZodUUID,
  ZodUndefined: () => ZodUndefined,
  ZodUnion: () => ZodUnion,
  ZodUnknown: () => ZodUnknown,
  ZodVoid: () => ZodVoid,
  ZodXID: () => ZodXID,
  ZodXor: () => ZodXor,
  _ZodString: () => _ZodString,
  _default: () => _default2,
  _function: () => _function,
  any: () => any,
  array: () => array,
  base64: () => base642,
  base64url: () => base64url2,
  bigint: () => bigint2,
  boolean: () => boolean2,
  catch: () => _catch2,
  check: () => check,
  cidrv4: () => cidrv42,
  cidrv6: () => cidrv62,
  codec: () => codec,
  cuid: () => cuid3,
  cuid2: () => cuid22,
  custom: () => custom,
  date: () => date3,
  describe: () => describe2,
  discriminatedUnion: () => discriminatedUnion,
  e164: () => e1642,
  email: () => email2,
  emoji: () => emoji2,
  enum: () => _enum2,
  exactOptional: () => exactOptional,
  file: () => file,
  float32: () => float32,
  float64: () => float64,
  function: () => _function,
  guid: () => guid2,
  hash: () => hash,
  hex: () => hex2,
  hostname: () => hostname2,
  httpUrl: () => httpUrl,
  instanceof: () => _instanceof,
  int: () => int,
  int32: () => int32,
  int64: () => int64,
  intersection: () => intersection,
  ipv4: () => ipv42,
  ipv6: () => ipv62,
  json: () => json,
  jwt: () => jwt,
  keyof: () => keyof,
  ksuid: () => ksuid2,
  lazy: () => lazy,
  literal: () => literal,
  looseObject: () => looseObject,
  looseRecord: () => looseRecord,
  mac: () => mac2,
  map: () => map,
  meta: () => meta2,
  nan: () => nan,
  nanoid: () => nanoid2,
  nativeEnum: () => nativeEnum,
  never: () => never,
  nonoptional: () => nonoptional,
  null: () => _null3,
  nullable: () => nullable,
  nullish: () => nullish2,
  number: () => number2,
  object: () => object,
  optional: () => optional,
  partialRecord: () => partialRecord,
  pipe: () => pipe,
  prefault: () => prefault,
  preprocess: () => preprocess,
  promise: () => promise,
  readonly: () => readonly,
  record: () => record,
  refine: () => refine,
  set: () => set,
  strictObject: () => strictObject,
  string: () => string2,
  stringFormat: () => stringFormat,
  stringbool: () => stringbool,
  success: () => success,
  superRefine: () => superRefine,
  symbol: () => symbol15,
  templateLiteral: () => templateLiteral,
  transform: () => transform2,
  tuple: () => tuple,
  uint32: () => uint32,
  uint64: () => uint64,
  ulid: () => ulid2,
  undefined: () => _undefined3,
  union: () => union,
  unknown: () => unknown,
  url: () => url2,
  uuid: () => uuid2,
  uuidv4: () => uuidv4,
  uuidv6: () => uuidv6,
  uuidv7: () => uuidv7,
  void: () => _void2,
  xid: () => xid2,
  xor: () => xor
});
function string2(params) {
  return _string(ZodString, params);
}
function email2(params) {
  return _email(ZodEmail, params);
}
function guid2(params) {
  return _guid(ZodGUID, params);
}
function uuid2(params) {
  return _uuid(ZodUUID, params);
}
function uuidv4(params) {
  return _uuidv4(ZodUUID, params);
}
function uuidv6(params) {
  return _uuidv6(ZodUUID, params);
}
function uuidv7(params) {
  return _uuidv7(ZodUUID, params);
}
function url2(params) {
  return _url(ZodURL, params);
}
function httpUrl(params) {
  return _url(ZodURL, {
    protocol: /^https?$/,
    hostname: regexes_exports.domain,
    ...util_exports.normalizeParams(params)
  });
}
function emoji2(params) {
  return _emoji2(ZodEmoji, params);
}
function nanoid2(params) {
  return _nanoid(ZodNanoID, params);
}
function cuid3(params) {
  return _cuid(ZodCUID, params);
}
function cuid22(params) {
  return _cuid2(ZodCUID2, params);
}
function ulid2(params) {
  return _ulid(ZodULID, params);
}
function xid2(params) {
  return _xid(ZodXID, params);
}
function ksuid2(params) {
  return _ksuid(ZodKSUID, params);
}
function ipv42(params) {
  return _ipv4(ZodIPv4, params);
}
function mac2(params) {
  return _mac(ZodMAC, params);
}
function ipv62(params) {
  return _ipv6(ZodIPv6, params);
}
function cidrv42(params) {
  return _cidrv4(ZodCIDRv4, params);
}
function cidrv62(params) {
  return _cidrv6(ZodCIDRv6, params);
}
function base642(params) {
  return _base64(ZodBase64, params);
}
function base64url2(params) {
  return _base64url(ZodBase64URL, params);
}
function e1642(params) {
  return _e164(ZodE164, params);
}
function jwt(params) {
  return _jwt(ZodJWT, params);
}
function stringFormat(format, fnOrRegex, _params = {}) {
  return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
}
function hostname2(_params) {
  return _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params);
}
function hex2(_params) {
  return _stringFormat(ZodCustomStringFormat, "hex", regexes_exports.hex, _params);
}
function hash(alg, params) {
  const enc = params?.enc ?? "hex";
  const format = `${alg}_${enc}`;
  const regex = regexes_exports[format];
  if (!regex)
    throw new Error(`Unrecognized hash format: ${format}`);
  return _stringFormat(ZodCustomStringFormat, format, regex, params);
}
function number2(params) {
  return _number(ZodNumber, params);
}
function int(params) {
  return _int(ZodNumberFormat, params);
}
function float32(params) {
  return _float32(ZodNumberFormat, params);
}
function float64(params) {
  return _float64(ZodNumberFormat, params);
}
function int32(params) {
  return _int32(ZodNumberFormat, params);
}
function uint32(params) {
  return _uint32(ZodNumberFormat, params);
}
function boolean2(params) {
  return _boolean(ZodBoolean, params);
}
function bigint2(params) {
  return _bigint(ZodBigInt, params);
}
function int64(params) {
  return _int64(ZodBigIntFormat, params);
}
function uint64(params) {
  return _uint64(ZodBigIntFormat, params);
}
function symbol15(params) {
  return _symbol(ZodSymbol, params);
}
function _undefined3(params) {
  return _undefined2(ZodUndefined, params);
}
function _null3(params) {
  return _null2(ZodNull, params);
}
function any() {
  return _any(ZodAny);
}
function unknown() {
  return _unknown(ZodUnknown);
}
function never(params) {
  return _never(ZodNever, params);
}
function _void2(params) {
  return _void(ZodVoid, params);
}
function date3(params) {
  return _date(ZodDate, params);
}
function array(element, params) {
  return _array(ZodArray, element, params);
}
function keyof(schema) {
  const shape = schema._zod.def.shape;
  return _enum2(Object.keys(shape));
}
function object(shape, params) {
  const def = {
    type: "object",
    shape: shape ?? {},
    ...util_exports.normalizeParams(params)
  };
  return new ZodObject(def);
}
function strictObject(shape, params) {
  return new ZodObject({
    type: "object",
    shape,
    catchall: never(),
    ...util_exports.normalizeParams(params)
  });
}
function looseObject(shape, params) {
  return new ZodObject({
    type: "object",
    shape,
    catchall: unknown(),
    ...util_exports.normalizeParams(params)
  });
}
function union(options, params) {
  return new ZodUnion({
    type: "union",
    options,
    ...util_exports.normalizeParams(params)
  });
}
function xor(options, params) {
  return new ZodXor({
    type: "union",
    options,
    inclusive: false,
    ...util_exports.normalizeParams(params)
  });
}
function discriminatedUnion(discriminator, options, params) {
  return new ZodDiscriminatedUnion({
    type: "union",
    options,
    discriminator,
    ...util_exports.normalizeParams(params)
  });
}
function intersection(left, right) {
  return new ZodIntersection({
    type: "intersection",
    left,
    right
  });
}
function tuple(items, _paramsOrRest, _params) {
  const hasRest = _paramsOrRest instanceof $ZodType;
  const params = hasRest ? _params : _paramsOrRest;
  const rest = hasRest ? _paramsOrRest : null;
  return new ZodTuple({
    type: "tuple",
    items,
    rest,
    ...util_exports.normalizeParams(params)
  });
}
function record(keyType, valueType, params) {
  return new ZodRecord({
    type: "record",
    keyType,
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
function partialRecord(keyType, valueType, params) {
  const k = clone(keyType);
  k._zod.values = void 0;
  return new ZodRecord({
    type: "record",
    keyType: k,
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
function looseRecord(keyType, valueType, params) {
  return new ZodRecord({
    type: "record",
    keyType,
    valueType,
    mode: "loose",
    ...util_exports.normalizeParams(params)
  });
}
function map(keyType, valueType, params) {
  return new ZodMap({
    type: "map",
    keyType,
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
function set(valueType, params) {
  return new ZodSet({
    type: "set",
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
function _enum2(values, params) {
  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
  return new ZodEnum({
    type: "enum",
    entries,
    ...util_exports.normalizeParams(params)
  });
}
function nativeEnum(entries, params) {
  return new ZodEnum({
    type: "enum",
    entries,
    ...util_exports.normalizeParams(params)
  });
}
function literal(value, params) {
  return new ZodLiteral({
    type: "literal",
    values: Array.isArray(value) ? value : [value],
    ...util_exports.normalizeParams(params)
  });
}
function file(params) {
  return _file(ZodFile, params);
}
function transform2(fn) {
  return new ZodTransform({
    type: "transform",
    transform: fn
  });
}
function optional(innerType) {
  return new ZodOptional({
    type: "optional",
    innerType
  });
}
function exactOptional(innerType) {
  return new ZodExactOptional({
    type: "optional",
    innerType
  });
}
function nullable(innerType) {
  return new ZodNullable({
    type: "nullable",
    innerType
  });
}
function nullish2(innerType) {
  return optional(nullable(innerType));
}
function _default2(innerType, defaultValue) {
  return new ZodDefault({
    type: "default",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
    }
  });
}
function prefault(innerType, defaultValue) {
  return new ZodPrefault({
    type: "prefault",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
    }
  });
}
function nonoptional(innerType, params) {
  return new ZodNonOptional({
    type: "nonoptional",
    innerType,
    ...util_exports.normalizeParams(params)
  });
}
function success(innerType) {
  return new ZodSuccess({
    type: "success",
    innerType
  });
}
function _catch2(innerType, catchValue) {
  return new ZodCatch({
    type: "catch",
    innerType,
    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
  });
}
function nan(params) {
  return _nan(ZodNaN, params);
}
function pipe(in_, out) {
  return new ZodPipe({
    type: "pipe",
    in: in_,
    out
    // ...util.normalizeParams(params),
  });
}
function codec(in_, out, params) {
  return new ZodCodec({
    type: "pipe",
    in: in_,
    out,
    transform: params.decode,
    reverseTransform: params.encode
  });
}
function readonly(innerType) {
  return new ZodReadonly({
    type: "readonly",
    innerType
  });
}
function templateLiteral(parts, params) {
  return new ZodTemplateLiteral({
    type: "template_literal",
    parts,
    ...util_exports.normalizeParams(params)
  });
}
function lazy(getter) {
  return new ZodLazy({
    type: "lazy",
    getter
  });
}
function promise(innerType) {
  return new ZodPromise({
    type: "promise",
    innerType
  });
}
function _function(params) {
  return new ZodFunction({
    type: "function",
    input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
    output: params?.output ?? unknown()
  });
}
function check(fn) {
  const ch = new $ZodCheck({
    check: "custom"
    // ...util.normalizeParams(params),
  });
  ch._zod.check = fn;
  return ch;
}
function custom(fn, _params) {
  return _custom(ZodCustom, fn ?? (() => true), _params);
}
function refine(fn, _params = {}) {
  return _refine(ZodCustom, fn, _params);
}
function superRefine(fn) {
  return _superRefine(fn);
}
function _instanceof(cls, params = {}) {
  const inst = new ZodCustom({
    type: "custom",
    check: "custom",
    fn: (data) => data instanceof cls,
    abort: true,
    ...util_exports.normalizeParams(params)
  });
  inst._zod.bag.Class = cls;
  inst._zod.check = (payload) => {
    if (!(payload.value instanceof cls)) {
      payload.issues.push({
        code: "invalid_type",
        expected: cls.name,
        input: payload.value,
        inst,
        path: [...inst._zod.def.path ?? []]
      });
    }
  };
  return inst;
}
function json(params) {
  const jsonSchema4 = lazy(() => {
    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema4), record(string2(), jsonSchema4)]);
  });
  return jsonSchema4;
}
function preprocess(fn, schema) {
  return pipe(transform2(fn), schema);
}
var ZodType, _ZodString, ZodString, ZodStringFormat, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodMAC, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodCustomStringFormat, ZodNumber, ZodNumberFormat, ZodBoolean, ZodBigInt, ZodBigIntFormat, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodDate, ZodArray, ZodObject, ZodUnion, ZodXor, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodEnum, ZodLiteral, ZodFile, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodSuccess, ZodCatch, ZodNaN, ZodPipe, ZodCodec, ZodReadonly, ZodTemplateLiteral, ZodLazy, ZodPromise, ZodFunction, ZodCustom, describe2, meta2, stringbool;
var init_schemas2 = __esm({
  "node_modules/zod/v4/classic/schemas.js"() {
    "use strict";
    init_core2();
    init_core2();
    init_json_schema_processors();
    init_to_json_schema();
    init_checks2();
    init_iso();
    init_parse2();
    ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
      $ZodType.init(inst, def);
      Object.assign(inst["~standard"], {
        jsonSchema: {
          input: createStandardJSONSchemaMethod(inst, "input"),
          output: createStandardJSONSchemaMethod(inst, "output")
        }
      });
      inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
      inst.def = def;
      inst.type = def.type;
      Object.defineProperty(inst, "_def", { value: def });
      inst.check = (...checks) => {
        return inst.clone(util_exports.mergeDefs(def, {
          checks: [
            ...def.checks ?? [],
            ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
          ]
        }), {
          parent: true
        });
      };
      inst.with = inst.check;
      inst.clone = (def2, params) => clone(inst, def2, params);
      inst.brand = () => inst;
      inst.register = ((reg, meta4) => {
        reg.add(inst, meta4);
        return inst;
      });
      inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
      inst.safeParse = (data, params) => safeParse2(inst, data, params);
      inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
      inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
      inst.spa = inst.safeParseAsync;
      inst.encode = (data, params) => encode4(inst, data, params);
      inst.decode = (data, params) => decode2(inst, data, params);
      inst.encodeAsync = async (data, params) => encodeAsync2(inst, data, params);
      inst.decodeAsync = async (data, params) => decodeAsync2(inst, data, params);
      inst.safeEncode = (data, params) => safeEncode2(inst, data, params);
      inst.safeDecode = (data, params) => safeDecode2(inst, data, params);
      inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params);
      inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params);
      inst.refine = (check3, params) => inst.check(refine(check3, params));
      inst.superRefine = (refinement) => inst.check(superRefine(refinement));
      inst.overwrite = (fn) => inst.check(_overwrite(fn));
      inst.optional = () => optional(inst);
      inst.exactOptional = () => exactOptional(inst);
      inst.nullable = () => nullable(inst);
      inst.nullish = () => optional(nullable(inst));
      inst.nonoptional = (params) => nonoptional(inst, params);
      inst.array = () => array(inst);
      inst.or = (arg) => union([inst, arg]);
      inst.and = (arg) => intersection(inst, arg);
      inst.transform = (tx) => pipe(inst, transform2(tx));
      inst.default = (def2) => _default2(inst, def2);
      inst.prefault = (def2) => prefault(inst, def2);
      inst.catch = (params) => _catch2(inst, params);
      inst.pipe = (target) => pipe(inst, target);
      inst.readonly = () => readonly(inst);
      inst.describe = (description) => {
        const cl = inst.clone();
        globalRegistry.add(cl, { description });
        return cl;
      };
      Object.defineProperty(inst, "description", {
        get() {
          return globalRegistry.get(inst)?.description;
        },
        configurable: true
      });
      inst.meta = (...args) => {
        if (args.length === 0) {
          return globalRegistry.get(inst);
        }
        const cl = inst.clone();
        globalRegistry.add(cl, args[0]);
        return cl;
      };
      inst.isOptional = () => inst.safeParse(void 0).success;
      inst.isNullable = () => inst.safeParse(null).success;
      inst.apply = (fn) => fn(inst);
      return inst;
    });
    _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
      $ZodString.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => stringProcessor(inst, ctx, json4, params);
      const bag = inst._zod.bag;
      inst.format = bag.format ?? null;
      inst.minLength = bag.minimum ?? null;
      inst.maxLength = bag.maximum ?? null;
      inst.regex = (...args) => inst.check(_regex(...args));
      inst.includes = (...args) => inst.check(_includes(...args));
      inst.startsWith = (...args) => inst.check(_startsWith(...args));
      inst.endsWith = (...args) => inst.check(_endsWith(...args));
      inst.min = (...args) => inst.check(_minLength(...args));
      inst.max = (...args) => inst.check(_maxLength(...args));
      inst.length = (...args) => inst.check(_length(...args));
      inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
      inst.lowercase = (params) => inst.check(_lowercase(params));
      inst.uppercase = (params) => inst.check(_uppercase(params));
      inst.trim = () => inst.check(_trim());
      inst.normalize = (...args) => inst.check(_normalize(...args));
      inst.toLowerCase = () => inst.check(_toLowerCase());
      inst.toUpperCase = () => inst.check(_toUpperCase());
      inst.slugify = () => inst.check(_slugify());
    });
    ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
      $ZodString.init(inst, def);
      _ZodString.init(inst, def);
      inst.email = (params) => inst.check(_email(ZodEmail, params));
      inst.url = (params) => inst.check(_url(ZodURL, params));
      inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
      inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));
      inst.guid = (params) => inst.check(_guid(ZodGUID, params));
      inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
      inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
      inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
      inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
      inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
      inst.guid = (params) => inst.check(_guid(ZodGUID, params));
      inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
      inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
      inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
      inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
      inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
      inst.xid = (params) => inst.check(_xid(ZodXID, params));
      inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
      inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
      inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
      inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
      inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
      inst.e164 = (params) => inst.check(_e164(ZodE164, params));
      inst.datetime = (params) => inst.check(datetime2(params));
      inst.date = (params) => inst.check(date2(params));
      inst.time = (params) => inst.check(time2(params));
      inst.duration = (params) => inst.check(duration2(params));
    });
    ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
      $ZodStringFormat.init(inst, def);
      _ZodString.init(inst, def);
    });
    ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
      $ZodEmail.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
      $ZodGUID.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
      $ZodUUID.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
      $ZodURL.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
      $ZodEmoji.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
      $ZodNanoID.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
      $ZodCUID.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
      $ZodCUID2.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
      $ZodULID.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
      $ZodXID.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
      $ZodKSUID.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
      $ZodIPv4.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodMAC = /* @__PURE__ */ $constructor("ZodMAC", (inst, def) => {
      $ZodMAC.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
      $ZodIPv6.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
      $ZodCIDRv4.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
      $ZodCIDRv6.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
      $ZodBase64.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
      $ZodBase64URL.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
      $ZodE164.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
      $ZodJWT.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat", (inst, def) => {
      $ZodCustomStringFormat.init(inst, def);
      ZodStringFormat.init(inst, def);
    });
    ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
      $ZodNumber.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => numberProcessor(inst, ctx, json4, params);
      inst.gt = (value, params) => inst.check(_gt(value, params));
      inst.gte = (value, params) => inst.check(_gte(value, params));
      inst.min = (value, params) => inst.check(_gte(value, params));
      inst.lt = (value, params) => inst.check(_lt(value, params));
      inst.lte = (value, params) => inst.check(_lte(value, params));
      inst.max = (value, params) => inst.check(_lte(value, params));
      inst.int = (params) => inst.check(int(params));
      inst.safe = (params) => inst.check(int(params));
      inst.positive = (params) => inst.check(_gt(0, params));
      inst.nonnegative = (params) => inst.check(_gte(0, params));
      inst.negative = (params) => inst.check(_lt(0, params));
      inst.nonpositive = (params) => inst.check(_lte(0, params));
      inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
      inst.step = (value, params) => inst.check(_multipleOf(value, params));
      inst.finite = () => inst;
      const bag = inst._zod.bag;
      inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
      inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
      inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
      inst.isFinite = true;
      inst.format = bag.format ?? null;
    });
    ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
      $ZodNumberFormat.init(inst, def);
      ZodNumber.init(inst, def);
    });
    ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
      $ZodBoolean.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => booleanProcessor(inst, ctx, json4, params);
    });
    ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
      $ZodBigInt.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => bigintProcessor(inst, ctx, json4, params);
      inst.gte = (value, params) => inst.check(_gte(value, params));
      inst.min = (value, params) => inst.check(_gte(value, params));
      inst.gt = (value, params) => inst.check(_gt(value, params));
      inst.gte = (value, params) => inst.check(_gte(value, params));
      inst.min = (value, params) => inst.check(_gte(value, params));
      inst.lt = (value, params) => inst.check(_lt(value, params));
      inst.lte = (value, params) => inst.check(_lte(value, params));
      inst.max = (value, params) => inst.check(_lte(value, params));
      inst.positive = (params) => inst.check(_gt(BigInt(0), params));
      inst.negative = (params) => inst.check(_lt(BigInt(0), params));
      inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));
      inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));
      inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
      const bag = inst._zod.bag;
      inst.minValue = bag.minimum ?? null;
      inst.maxValue = bag.maximum ?? null;
      inst.format = bag.format ?? null;
    });
    ZodBigIntFormat = /* @__PURE__ */ $constructor("ZodBigIntFormat", (inst, def) => {
      $ZodBigIntFormat.init(inst, def);
      ZodBigInt.init(inst, def);
    });
    ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
      $ZodSymbol.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => symbolProcessor(inst, ctx, json4, params);
    });
    ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
      $ZodUndefined.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => undefinedProcessor(inst, ctx, json4, params);
    });
    ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
      $ZodNull.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => nullProcessor(inst, ctx, json4, params);
    });
    ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
      $ZodAny.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => anyProcessor(inst, ctx, json4, params);
    });
    ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
      $ZodUnknown.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => unknownProcessor(inst, ctx, json4, params);
    });
    ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
      $ZodNever.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => neverProcessor(inst, ctx, json4, params);
    });
    ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
      $ZodVoid.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => voidProcessor(inst, ctx, json4, params);
    });
    ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
      $ZodDate.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => dateProcessor(inst, ctx, json4, params);
      inst.min = (value, params) => inst.check(_gte(value, params));
      inst.max = (value, params) => inst.check(_lte(value, params));
      const c = inst._zod.bag;
      inst.minDate = c.minimum ? new Date(c.minimum) : null;
      inst.maxDate = c.maximum ? new Date(c.maximum) : null;
    });
    ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
      $ZodArray.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => arrayProcessor(inst, ctx, json4, params);
      inst.element = def.element;
      inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
      inst.nonempty = (params) => inst.check(_minLength(1, params));
      inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
      inst.length = (len, params) => inst.check(_length(len, params));
      inst.unwrap = () => inst.element;
    });
    ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
      $ZodObjectJIT.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => objectProcessor(inst, ctx, json4, params);
      util_exports.defineLazy(inst, "shape", () => {
        return def.shape;
      });
      inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));
      inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
      inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
      inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
      inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
      inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
      inst.extend = (incoming) => {
        return util_exports.extend(inst, incoming);
      };
      inst.safeExtend = (incoming) => {
        return util_exports.safeExtend(inst, incoming);
      };
      inst.merge = (other) => util_exports.merge(inst, other);
      inst.pick = (mask) => util_exports.pick(inst, mask);
      inst.omit = (mask) => util_exports.omit(inst, mask);
      inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);
      inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);
    });
    ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
      $ZodUnion.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => unionProcessor(inst, ctx, json4, params);
      inst.options = def.options;
    });
    ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
      ZodUnion.init(inst, def);
      $ZodXor.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => unionProcessor(inst, ctx, json4, params);
      inst.options = def.options;
    });
    ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
      ZodUnion.init(inst, def);
      $ZodDiscriminatedUnion.init(inst, def);
    });
    ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
      $ZodIntersection.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => intersectionProcessor(inst, ctx, json4, params);
    });
    ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
      $ZodTuple.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => tupleProcessor(inst, ctx, json4, params);
      inst.rest = (rest) => inst.clone({
        ...inst._zod.def,
        rest
      });
    });
    ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
      $ZodRecord.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => recordProcessor(inst, ctx, json4, params);
      inst.keyType = def.keyType;
      inst.valueType = def.valueType;
    });
    ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
      $ZodMap.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => mapProcessor(inst, ctx, json4, params);
      inst.keyType = def.keyType;
      inst.valueType = def.valueType;
      inst.min = (...args) => inst.check(_minSize(...args));
      inst.nonempty = (params) => inst.check(_minSize(1, params));
      inst.max = (...args) => inst.check(_maxSize(...args));
      inst.size = (...args) => inst.check(_size(...args));
    });
    ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
      $ZodSet.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => setProcessor(inst, ctx, json4, params);
      inst.min = (...args) => inst.check(_minSize(...args));
      inst.nonempty = (params) => inst.check(_minSize(1, params));
      inst.max = (...args) => inst.check(_maxSize(...args));
      inst.size = (...args) => inst.check(_size(...args));
    });
    ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
      $ZodEnum.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => enumProcessor(inst, ctx, json4, params);
      inst.enum = def.entries;
      inst.options = Object.values(def.entries);
      const keys2 = new Set(Object.keys(def.entries));
      inst.extract = (values, params) => {
        const newEntries = {};
        for (const value of values) {
          if (keys2.has(value)) {
            newEntries[value] = def.entries[value];
          } else
            throw new Error(`Key ${value} not found in enum`);
        }
        return new ZodEnum({
          ...def,
          checks: [],
          ...util_exports.normalizeParams(params),
          entries: newEntries
        });
      };
      inst.exclude = (values, params) => {
        const newEntries = { ...def.entries };
        for (const value of values) {
          if (keys2.has(value)) {
            delete newEntries[value];
          } else
            throw new Error(`Key ${value} not found in enum`);
        }
        return new ZodEnum({
          ...def,
          checks: [],
          ...util_exports.normalizeParams(params),
          entries: newEntries
        });
      };
    });
    ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
      $ZodLiteral.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => literalProcessor(inst, ctx, json4, params);
      inst.values = new Set(def.values);
      Object.defineProperty(inst, "value", {
        get() {
          if (def.values.length > 1) {
            throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
          }
          return def.values[0];
        }
      });
    });
    ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
      $ZodFile.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => fileProcessor(inst, ctx, json4, params);
      inst.min = (size, params) => inst.check(_minSize(size, params));
      inst.max = (size, params) => inst.check(_maxSize(size, params));
      inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
    });
    ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
      $ZodTransform.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => transformProcessor(inst, ctx, json4, params);
      inst._zod.parse = (payload, _ctx) => {
        if (_ctx.direction === "backward") {
          throw new $ZodEncodeError(inst.constructor.name);
        }
        payload.addIssue = (issue3) => {
          if (typeof issue3 === "string") {
            payload.issues.push(util_exports.issue(issue3, payload.value, def));
          } else {
            const _issue = issue3;
            if (_issue.fatal)
              _issue.continue = false;
            _issue.code ?? (_issue.code = "custom");
            _issue.input ?? (_issue.input = payload.value);
            _issue.inst ?? (_issue.inst = inst);
            payload.issues.push(util_exports.issue(_issue));
          }
        };
        const output = def.transform(payload.value, payload);
        if (output instanceof Promise) {
          return output.then((output2) => {
            payload.value = output2;
            return payload;
          });
        }
        payload.value = output;
        return payload;
      };
    });
    ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
      $ZodOptional.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => optionalProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
      $ZodExactOptional.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => optionalProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
      $ZodNullable.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => nullableProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
      $ZodDefault.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => defaultProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
      inst.removeDefault = inst.unwrap;
    });
    ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
      $ZodPrefault.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => prefaultProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
      $ZodNonOptional.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => nonoptionalProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
      $ZodSuccess.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => successProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
      $ZodCatch.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => catchProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
      inst.removeCatch = inst.unwrap;
    });
    ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
      $ZodNaN.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => nanProcessor(inst, ctx, json4, params);
    });
    ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
      $ZodPipe.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => pipeProcessor(inst, ctx, json4, params);
      inst.in = def.in;
      inst.out = def.out;
    });
    ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => {
      ZodPipe.init(inst, def);
      $ZodCodec.init(inst, def);
    });
    ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
      $ZodReadonly.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => readonlyProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
      $ZodTemplateLiteral.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => templateLiteralProcessor(inst, ctx, json4, params);
    });
    ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
      $ZodLazy.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => lazyProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.getter();
    });
    ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
      $ZodPromise.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => promiseProcessor(inst, ctx, json4, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
      $ZodFunction.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => functionProcessor(inst, ctx, json4, params);
    });
    ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
      $ZodCustom.init(inst, def);
      ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json4, params) => customProcessor(inst, ctx, json4, params);
    });
    describe2 = describe;
    meta2 = meta;
    stringbool = (...args) => _stringbool({
      Codec: ZodCodec,
      Boolean: ZodBoolean,
      String: ZodString
    }, ...args);
  }
});

// node_modules/zod/v4/classic/compat.js
function setErrorMap(map3) {
  config({
    customError: map3
  });
}
function getErrorMap() {
  return config().customError;
}
var ZodIssueCode, ZodFirstPartyTypeKind;
var init_compat = __esm({
  "node_modules/zod/v4/classic/compat.js"() {
    "use strict";
    init_core2();
    init_core2();
    ZodIssueCode = {
      invalid_type: "invalid_type",
      too_big: "too_big",
      too_small: "too_small",
      invalid_format: "invalid_format",
      not_multiple_of: "not_multiple_of",
      unrecognized_keys: "unrecognized_keys",
      invalid_union: "invalid_union",
      invalid_key: "invalid_key",
      invalid_element: "invalid_element",
      invalid_value: "invalid_value",
      custom: "custom"
    };
    /* @__PURE__ */ (function(ZodFirstPartyTypeKind4) {
    })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
  }
});

// node_modules/zod/v4/classic/from-json-schema.js
function detectVersion(schema, defaultTarget) {
  const $schema = schema.$schema;
  if ($schema === "https://json-schema.org/draft/2020-12/schema") {
    return "draft-2020-12";
  }
  if ($schema === "http://json-schema.org/draft-07/schema#") {
    return "draft-7";
  }
  if ($schema === "http://json-schema.org/draft-04/schema#") {
    return "draft-4";
  }
  return defaultTarget ?? "draft-2020-12";
}
function resolveRef(ref, ctx) {
  if (!ref.startsWith("#")) {
    throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
  }
  const path33 = ref.slice(1).split("/").filter(Boolean);
  if (path33.length === 0) {
    return ctx.rootSchema;
  }
  const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
  if (path33[0] === defsKey) {
    const key = path33[1];
    if (!key || !ctx.defs[key]) {
      throw new Error(`Reference not found: ${ref}`);
    }
    return ctx.defs[key];
  }
  throw new Error(`Reference not found: ${ref}`);
}
function convertBaseSchema(schema, ctx) {
  if (schema.not !== void 0) {
    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
      return z.never();
    }
    throw new Error("not is not supported in Zod (except { not: {} } for never)");
  }
  if (schema.unevaluatedItems !== void 0) {
    throw new Error("unevaluatedItems is not supported");
  }
  if (schema.unevaluatedProperties !== void 0) {
    throw new Error("unevaluatedProperties is not supported");
  }
  if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
    throw new Error("Conditional schemas (if/then/else) are not supported");
  }
  if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
    throw new Error("dependentSchemas and dependentRequired are not supported");
  }
  if (schema.$ref) {
    const refPath = schema.$ref;
    if (ctx.refs.has(refPath)) {
      return ctx.refs.get(refPath);
    }
    if (ctx.processing.has(refPath)) {
      return z.lazy(() => {
        if (!ctx.refs.has(refPath)) {
          throw new Error(`Circular reference not resolved: ${refPath}`);
        }
        return ctx.refs.get(refPath);
      });
    }
    ctx.processing.add(refPath);
    const resolved = resolveRef(refPath, ctx);
    const zodSchema5 = convertSchema(resolved, ctx);
    ctx.refs.set(refPath, zodSchema5);
    ctx.processing.delete(refPath);
    return zodSchema5;
  }
  if (schema.enum !== void 0) {
    const enumValues = schema.enum;
    if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
      return z.null();
    }
    if (enumValues.length === 0) {
      return z.never();
    }
    if (enumValues.length === 1) {
      return z.literal(enumValues[0]);
    }
    if (enumValues.every((v) => typeof v === "string")) {
      return z.enum(enumValues);
    }
    const literalSchemas = enumValues.map((v) => z.literal(v));
    if (literalSchemas.length < 2) {
      return literalSchemas[0];
    }
    return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
  }
  if (schema.const !== void 0) {
    return z.literal(schema.const);
  }
  const type = schema.type;
  if (Array.isArray(type)) {
    const typeSchemas = type.map((t) => {
      const typeSchema = { ...schema, type: t };
      return convertBaseSchema(typeSchema, ctx);
    });
    if (typeSchemas.length === 0) {
      return z.never();
    }
    if (typeSchemas.length === 1) {
      return typeSchemas[0];
    }
    return z.union(typeSchemas);
  }
  if (!type) {
    return z.any();
  }
  let zodSchema4;
  switch (type) {
    case "string": {
      let stringSchema = z.string();
      if (schema.format) {
        const format = schema.format;
        if (format === "email") {
          stringSchema = stringSchema.check(z.email());
        } else if (format === "uri" || format === "uri-reference") {
          stringSchema = stringSchema.check(z.url());
        } else if (format === "uuid" || format === "guid") {
          stringSchema = stringSchema.check(z.uuid());
        } else if (format === "date-time") {
          stringSchema = stringSchema.check(z.iso.datetime());
        } else if (format === "date") {
          stringSchema = stringSchema.check(z.iso.date());
        } else if (format === "time") {
          stringSchema = stringSchema.check(z.iso.time());
        } else if (format === "duration") {
          stringSchema = stringSchema.check(z.iso.duration());
        } else if (format === "ipv4") {
          stringSchema = stringSchema.check(z.ipv4());
        } else if (format === "ipv6") {
          stringSchema = stringSchema.check(z.ipv6());
        } else if (format === "mac") {
          stringSchema = stringSchema.check(z.mac());
        } else if (format === "cidr") {
          stringSchema = stringSchema.check(z.cidrv4());
        } else if (format === "cidr-v6") {
          stringSchema = stringSchema.check(z.cidrv6());
        } else if (format === "base64") {
          stringSchema = stringSchema.check(z.base64());
        } else if (format === "base64url") {
          stringSchema = stringSchema.check(z.base64url());
        } else if (format === "e164") {
          stringSchema = stringSchema.check(z.e164());
        } else if (format === "jwt") {
          stringSchema = stringSchema.check(z.jwt());
        } else if (format === "emoji") {
          stringSchema = stringSchema.check(z.emoji());
        } else if (format === "nanoid") {
          stringSchema = stringSchema.check(z.nanoid());
        } else if (format === "cuid") {
          stringSchema = stringSchema.check(z.cuid());
        } else if (format === "cuid2") {
          stringSchema = stringSchema.check(z.cuid2());
        } else if (format === "ulid") {
          stringSchema = stringSchema.check(z.ulid());
        } else if (format === "xid") {
          stringSchema = stringSchema.check(z.xid());
        } else if (format === "ksuid") {
          stringSchema = stringSchema.check(z.ksuid());
        }
      }
      if (typeof schema.minLength === "number") {
        stringSchema = stringSchema.min(schema.minLength);
      }
      if (typeof schema.maxLength === "number") {
        stringSchema = stringSchema.max(schema.maxLength);
      }
      if (schema.pattern) {
        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
      }
      zodSchema4 = stringSchema;
      break;
    }
    case "number":
    case "integer": {
      let numberSchema = type === "integer" ? z.number().int() : z.number();
      if (typeof schema.minimum === "number") {
        numberSchema = numberSchema.min(schema.minimum);
      }
      if (typeof schema.maximum === "number") {
        numberSchema = numberSchema.max(schema.maximum);
      }
      if (typeof schema.exclusiveMinimum === "number") {
        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
        numberSchema = numberSchema.gt(schema.minimum);
      }
      if (typeof schema.exclusiveMaximum === "number") {
        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
        numberSchema = numberSchema.lt(schema.maximum);
      }
      if (typeof schema.multipleOf === "number") {
        numberSchema = numberSchema.multipleOf(schema.multipleOf);
      }
      zodSchema4 = numberSchema;
      break;
    }
    case "boolean": {
      zodSchema4 = z.boolean();
      break;
    }
    case "null": {
      zodSchema4 = z.null();
      break;
    }
    case "object": {
      const shape = {};
      const properties = schema.properties || {};
      const requiredSet = new Set(schema.required || []);
      for (const [key, propSchema] of Object.entries(properties)) {
        const propZodSchema = convertSchema(propSchema, ctx);
        shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
      }
      if (schema.propertyNames) {
        const keySchema3 = convertSchema(schema.propertyNames, ctx);
        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
        if (Object.keys(shape).length === 0) {
          zodSchema4 = z.record(keySchema3, valueSchema);
          break;
        }
        const objectSchema2 = z.object(shape).passthrough();
        const recordSchema = z.looseRecord(keySchema3, valueSchema);
        zodSchema4 = z.intersection(objectSchema2, recordSchema);
        break;
      }
      if (schema.patternProperties) {
        const patternProps = schema.patternProperties;
        const patternKeys = Object.keys(patternProps);
        const looseRecords = [];
        for (const pattern of patternKeys) {
          const patternValue = convertSchema(patternProps[pattern], ctx);
          const keySchema3 = z.string().regex(new RegExp(pattern));
          looseRecords.push(z.looseRecord(keySchema3, patternValue));
        }
        const schemasToIntersect = [];
        if (Object.keys(shape).length > 0) {
          schemasToIntersect.push(z.object(shape).passthrough());
        }
        schemasToIntersect.push(...looseRecords);
        if (schemasToIntersect.length === 0) {
          zodSchema4 = z.object({}).passthrough();
        } else if (schemasToIntersect.length === 1) {
          zodSchema4 = schemasToIntersect[0];
        } else {
          let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
          for (let i = 2; i < schemasToIntersect.length; i++) {
            result = z.intersection(result, schemasToIntersect[i]);
          }
          zodSchema4 = result;
        }
        break;
      }
      const objectSchema = z.object(shape);
      if (schema.additionalProperties === false) {
        zodSchema4 = objectSchema.strict();
      } else if (typeof schema.additionalProperties === "object") {
        zodSchema4 = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
      } else {
        zodSchema4 = objectSchema.passthrough();
      }
      break;
    }
    case "array": {
      const prefixItems = schema.prefixItems;
      const items = schema.items;
      if (prefixItems && Array.isArray(prefixItems)) {
        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
        if (rest) {
          zodSchema4 = z.tuple(tupleItems).rest(rest);
        } else {
          zodSchema4 = z.tuple(tupleItems);
        }
        if (typeof schema.minItems === "number") {
          zodSchema4 = zodSchema4.check(z.minLength(schema.minItems));
        }
        if (typeof schema.maxItems === "number") {
          zodSchema4 = zodSchema4.check(z.maxLength(schema.maxItems));
        }
      } else if (Array.isArray(items)) {
        const tupleItems = items.map((item) => convertSchema(item, ctx));
        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
        if (rest) {
          zodSchema4 = z.tuple(tupleItems).rest(rest);
        } else {
          zodSchema4 = z.tuple(tupleItems);
        }
        if (typeof schema.minItems === "number") {
          zodSchema4 = zodSchema4.check(z.minLength(schema.minItems));
        }
        if (typeof schema.maxItems === "number") {
          zodSchema4 = zodSchema4.check(z.maxLength(schema.maxItems));
        }
      } else if (items !== void 0) {
        const element = convertSchema(items, ctx);
        let arraySchema = z.array(element);
        if (typeof schema.minItems === "number") {
          arraySchema = arraySchema.min(schema.minItems);
        }
        if (typeof schema.maxItems === "number") {
          arraySchema = arraySchema.max(schema.maxItems);
        }
        zodSchema4 = arraySchema;
      } else {
        zodSchema4 = z.array(z.any());
      }
      break;
    }
    default:
      throw new Error(`Unsupported type: ${type}`);
  }
  if (schema.description) {
    zodSchema4 = zodSchema4.describe(schema.description);
  }
  if (schema.default !== void 0) {
    zodSchema4 = zodSchema4.default(schema.default);
  }
  return zodSchema4;
}
function convertSchema(schema, ctx) {
  if (typeof schema === "boolean") {
    return schema ? z.any() : z.never();
  }
  let baseSchema = convertBaseSchema(schema, ctx);
  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
  if (schema.anyOf && Array.isArray(schema.anyOf)) {
    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
    const anyOfUnion = z.union(options);
    baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
  }
  if (schema.oneOf && Array.isArray(schema.oneOf)) {
    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
    const oneOfUnion = z.xor(options);
    baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
  }
  if (schema.allOf && Array.isArray(schema.allOf)) {
    if (schema.allOf.length === 0) {
      baseSchema = hasExplicitType ? baseSchema : z.any();
    } else {
      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
      const startIdx = hasExplicitType ? 0 : 1;
      for (let i = startIdx; i < schema.allOf.length; i++) {
        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
      }
      baseSchema = result;
    }
  }
  if (schema.nullable === true && ctx.version === "openapi-3.0") {
    baseSchema = z.nullable(baseSchema);
  }
  if (schema.readOnly === true) {
    baseSchema = z.readonly(baseSchema);
  }
  const extraMeta = {};
  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
  for (const key of coreMetadataKeys) {
    if (key in schema) {
      extraMeta[key] = schema[key];
    }
  }
  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
  for (const key of contentMetadataKeys) {
    if (key in schema) {
      extraMeta[key] = schema[key];
    }
  }
  for (const key of Object.keys(schema)) {
    if (!RECOGNIZED_KEYS.has(key)) {
      extraMeta[key] = schema[key];
    }
  }
  if (Object.keys(extraMeta).length > 0) {
    ctx.registry.add(baseSchema, extraMeta);
  }
  return baseSchema;
}
function fromJSONSchema(schema, params) {
  if (typeof schema === "boolean") {
    return schema ? z.any() : z.never();
  }
  const version3 = detectVersion(schema, params?.defaultTarget);
  const defs = schema.$defs || schema.definitions || {};
  const ctx = {
    version: version3,
    defs,
    refs: /* @__PURE__ */ new Map(),
    processing: /* @__PURE__ */ new Set(),
    rootSchema: schema,
    registry: params?.registry ?? globalRegistry
  };
  return convertSchema(schema, ctx);
}
var z, RECOGNIZED_KEYS;
var init_from_json_schema = __esm({
  "node_modules/zod/v4/classic/from-json-schema.js"() {
    "use strict";
    init_registries();
    init_checks2();
    init_iso();
    init_schemas2();
    z = {
      ...schemas_exports2,
      ...checks_exports2,
      iso: iso_exports
    };
    RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
      // Schema identification
      "$schema",
      "$ref",
      "$defs",
      "definitions",
      // Core schema keywords
      "$id",
      "id",
      "$comment",
      "$anchor",
      "$vocabulary",
      "$dynamicRef",
      "$dynamicAnchor",
      // Type
      "type",
      "enum",
      "const",
      // Composition
      "anyOf",
      "oneOf",
      "allOf",
      "not",
      // Object
      "properties",
      "required",
      "additionalProperties",
      "patternProperties",
      "propertyNames",
      "minProperties",
      "maxProperties",
      // Array
      "items",
      "prefixItems",
      "additionalItems",
      "minItems",
      "maxItems",
      "uniqueItems",
      "contains",
      "minContains",
      "maxContains",
      // String
      "minLength",
      "maxLength",
      "pattern",
      "format",
      // Number
      "minimum",
      "maximum",
      "exclusiveMinimum",
      "exclusiveMaximum",
      "multipleOf",
      // Already handled metadata
      "description",
      "default",
      // Content
      "contentEncoding",
      "contentMediaType",
      "contentSchema",
      // Unsupported (error-throwing)
      "unevaluatedItems",
      "unevaluatedProperties",
      "if",
      "then",
      "else",
      "dependentSchemas",
      "dependentRequired",
      // OpenAPI
      "nullable",
      "readOnly"
    ]);
  }
});

// node_modules/zod/v4/classic/coerce.js
var coerce_exports = {};
__export(coerce_exports, {
  bigint: () => bigint3,
  boolean: () => boolean3,
  date: () => date4,
  number: () => number3,
  string: () => string3
});
function string3(params) {
  return _coercedString(ZodString, params);
}
function number3(params) {
  return _coercedNumber(ZodNumber, params);
}
function boolean3(params) {
  return _coercedBoolean(ZodBoolean, params);
}
function bigint3(params) {
  return _coercedBigint(ZodBigInt, params);
}
function date4(params) {
  return _coercedDate(ZodDate, params);
}
var init_coerce = __esm({
  "node_modules/zod/v4/classic/coerce.js"() {
    "use strict";
    init_core2();
    init_schemas2();
  }
});

// node_modules/zod/v4/classic/external.js
var external_exports = {};
__export(external_exports, {
  $brand: () => $brand,
  $input: () => $input,
  $output: () => $output,
  NEVER: () => NEVER,
  TimePrecision: () => TimePrecision,
  ZodAny: () => ZodAny,
  ZodArray: () => ZodArray,
  ZodBase64: () => ZodBase64,
  ZodBase64URL: () => ZodBase64URL,
  ZodBigInt: () => ZodBigInt,
  ZodBigIntFormat: () => ZodBigIntFormat,
  ZodBoolean: () => ZodBoolean,
  ZodCIDRv4: () => ZodCIDRv4,
  ZodCIDRv6: () => ZodCIDRv6,
  ZodCUID: () => ZodCUID,
  ZodCUID2: () => ZodCUID2,
  ZodCatch: () => ZodCatch,
  ZodCodec: () => ZodCodec,
  ZodCustom: () => ZodCustom,
  ZodCustomStringFormat: () => ZodCustomStringFormat,
  ZodDate: () => ZodDate,
  ZodDefault: () => ZodDefault,
  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
  ZodE164: () => ZodE164,
  ZodEmail: () => ZodEmail,
  ZodEmoji: () => ZodEmoji,
  ZodEnum: () => ZodEnum,
  ZodError: () => ZodError,
  ZodExactOptional: () => ZodExactOptional,
  ZodFile: () => ZodFile,
  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
  ZodFunction: () => ZodFunction,
  ZodGUID: () => ZodGUID,
  ZodIPv4: () => ZodIPv4,
  ZodIPv6: () => ZodIPv6,
  ZodISODate: () => ZodISODate,
  ZodISODateTime: () => ZodISODateTime,
  ZodISODuration: () => ZodISODuration,
  ZodISOTime: () => ZodISOTime,
  ZodIntersection: () => ZodIntersection,
  ZodIssueCode: () => ZodIssueCode,
  ZodJWT: () => ZodJWT,
  ZodKSUID: () => ZodKSUID,
  ZodLazy: () => ZodLazy,
  ZodLiteral: () => ZodLiteral,
  ZodMAC: () => ZodMAC,
  ZodMap: () => ZodMap,
  ZodNaN: () => ZodNaN,
  ZodNanoID: () => ZodNanoID,
  ZodNever: () => ZodNever,
  ZodNonOptional: () => ZodNonOptional,
  ZodNull: () => ZodNull,
  ZodNullable: () => ZodNullable,
  ZodNumber: () => ZodNumber,
  ZodNumberFormat: () => ZodNumberFormat,
  ZodObject: () => ZodObject,
  ZodOptional: () => ZodOptional,
  ZodPipe: () => ZodPipe,
  ZodPrefault: () => ZodPrefault,
  ZodPromise: () => ZodPromise,
  ZodReadonly: () => ZodReadonly,
  ZodRealError: () => ZodRealError,
  ZodRecord: () => ZodRecord,
  ZodSet: () => ZodSet,
  ZodString: () => ZodString,
  ZodStringFormat: () => ZodStringFormat,
  ZodSuccess: () => ZodSuccess,
  ZodSymbol: () => ZodSymbol,
  ZodTemplateLiteral: () => ZodTemplateLiteral,
  ZodTransform: () => ZodTransform,
  ZodTuple: () => ZodTuple,
  ZodType: () => ZodType,
  ZodULID: () => ZodULID,
  ZodURL: () => ZodURL,
  ZodUUID: () => ZodUUID,
  ZodUndefined: () => ZodUndefined,
  ZodUnion: () => ZodUnion,
  ZodUnknown: () => ZodUnknown,
  ZodVoid: () => ZodVoid,
  ZodXID: () => ZodXID,
  ZodXor: () => ZodXor,
  _ZodString: () => _ZodString,
  _default: () => _default2,
  _function: () => _function,
  any: () => any,
  array: () => array,
  base64: () => base642,
  base64url: () => base64url2,
  bigint: () => bigint2,
  boolean: () => boolean2,
  catch: () => _catch2,
  check: () => check,
  cidrv4: () => cidrv42,
  cidrv6: () => cidrv62,
  clone: () => clone,
  codec: () => codec,
  coerce: () => coerce_exports,
  config: () => config,
  core: () => core_exports2,
  cuid: () => cuid3,
  cuid2: () => cuid22,
  custom: () => custom,
  date: () => date3,
  decode: () => decode2,
  decodeAsync: () => decodeAsync2,
  describe: () => describe2,
  discriminatedUnion: () => discriminatedUnion,
  e164: () => e1642,
  email: () => email2,
  emoji: () => emoji2,
  encode: () => encode4,
  encodeAsync: () => encodeAsync2,
  endsWith: () => _endsWith,
  enum: () => _enum2,
  exactOptional: () => exactOptional,
  file: () => file,
  flattenError: () => flattenError,
  float32: () => float32,
  float64: () => float64,
  formatError: () => formatError,
  fromJSONSchema: () => fromJSONSchema,
  function: () => _function,
  getErrorMap: () => getErrorMap,
  globalRegistry: () => globalRegistry,
  gt: () => _gt,
  gte: () => _gte,
  guid: () => guid2,
  hash: () => hash,
  hex: () => hex2,
  hostname: () => hostname2,
  httpUrl: () => httpUrl,
  includes: () => _includes,
  instanceof: () => _instanceof,
  int: () => int,
  int32: () => int32,
  int64: () => int64,
  intersection: () => intersection,
  ipv4: () => ipv42,
  ipv6: () => ipv62,
  iso: () => iso_exports,
  json: () => json,
  jwt: () => jwt,
  keyof: () => keyof,
  ksuid: () => ksuid2,
  lazy: () => lazy,
  length: () => _length,
  literal: () => literal,
  locales: () => locales_exports,
  looseObject: () => looseObject,
  looseRecord: () => looseRecord,
  lowercase: () => _lowercase,
  lt: () => _lt,
  lte: () => _lte,
  mac: () => mac2,
  map: () => map,
  maxLength: () => _maxLength,
  maxSize: () => _maxSize,
  meta: () => meta2,
  mime: () => _mime,
  minLength: () => _minLength,
  minSize: () => _minSize,
  multipleOf: () => _multipleOf,
  nan: () => nan,
  nanoid: () => nanoid2,
  nativeEnum: () => nativeEnum,
  negative: () => _negative,
  never: () => never,
  nonnegative: () => _nonnegative,
  nonoptional: () => nonoptional,
  nonpositive: () => _nonpositive,
  normalize: () => _normalize,
  null: () => _null3,
  nullable: () => nullable,
  nullish: () => nullish2,
  number: () => number2,
  object: () => object,
  optional: () => optional,
  overwrite: () => _overwrite,
  parse: () => parse2,
  parseAsync: () => parseAsync2,
  partialRecord: () => partialRecord,
  pipe: () => pipe,
  positive: () => _positive,
  prefault: () => prefault,
  preprocess: () => preprocess,
  prettifyError: () => prettifyError,
  promise: () => promise,
  property: () => _property,
  readonly: () => readonly,
  record: () => record,
  refine: () => refine,
  regex: () => _regex,
  regexes: () => regexes_exports,
  registry: () => registry,
  safeDecode: () => safeDecode2,
  safeDecodeAsync: () => safeDecodeAsync2,
  safeEncode: () => safeEncode2,
  safeEncodeAsync: () => safeEncodeAsync2,
  safeParse: () => safeParse2,
  safeParseAsync: () => safeParseAsync2,
  set: () => set,
  setErrorMap: () => setErrorMap,
  size: () => _size,
  slugify: () => _slugify,
  startsWith: () => _startsWith,
  strictObject: () => strictObject,
  string: () => string2,
  stringFormat: () => stringFormat,
  stringbool: () => stringbool,
  success: () => success,
  superRefine: () => superRefine,
  symbol: () => symbol15,
  templateLiteral: () => templateLiteral,
  toJSONSchema: () => toJSONSchema,
  toLowerCase: () => _toLowerCase,
  toUpperCase: () => _toUpperCase,
  transform: () => transform2,
  treeifyError: () => treeifyError,
  trim: () => _trim,
  tuple: () => tuple,
  uint32: () => uint32,
  uint64: () => uint64,
  ulid: () => ulid2,
  undefined: () => _undefined3,
  union: () => union,
  unknown: () => unknown,
  uppercase: () => _uppercase,
  url: () => url2,
  util: () => util_exports,
  uuid: () => uuid2,
  uuidv4: () => uuidv4,
  uuidv6: () => uuidv6,
  uuidv7: () => uuidv7,
  void: () => _void2,
  xid: () => xid2,
  xor: () => xor
});
var init_external = __esm({
  "node_modules/zod/v4/classic/external.js"() {
    "use strict";
    init_core2();
    init_schemas2();
    init_checks2();
    init_errors2();
    init_parse2();
    init_compat();
    init_core2();
    init_en();
    init_core2();
    init_json_schema_processors();
    init_from_json_schema();
    init_locales();
    init_iso();
    init_iso();
    init_coerce();
    config(en_default());
  }
});

// node_modules/zod/v4/classic/index.js
var init_classic = __esm({
  "node_modules/zod/v4/classic/index.js"() {
    "use strict";
    init_external();
    init_external();
  }
});

// node_modules/zod/v4/index.js
var init_v42 = __esm({
  "node_modules/zod/v4/index.js"() {
    "use strict";
    init_classic();
    init_classic();
  }
});

// node_modules/zod/v3/helpers/util.js
var util3, objectUtil, ZodParsedType, getParsedType2;
var init_util2 = __esm({
  "node_modules/zod/v3/helpers/util.js"() {
    "use strict";
    (function(util4) {
      util4.assertEqual = (_) => {
      };
      function assertIs3(_arg) {
      }
      util4.assertIs = assertIs3;
      function assertNever3(_x) {
        throw new Error();
      }
      util4.assertNever = assertNever3;
      util4.arrayToEnum = (items) => {
        const obj = {};
        for (const item of items) {
          obj[item] = item;
        }
        return obj;
      };
      util4.getValidEnumValues = (obj) => {
        const validKeys = util4.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
        const filtered = {};
        for (const k of validKeys) {
          filtered[k] = obj[k];
        }
        return util4.objectValues(filtered);
      };
      util4.objectValues = (obj) => {
        return util4.objectKeys(obj).map(function(e) {
          return obj[e];
        });
      };
      util4.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object4) => {
        const keys2 = [];
        for (const key in object4) {
          if (Object.prototype.hasOwnProperty.call(object4, key)) {
            keys2.push(key);
          }
        }
        return keys2;
      };
      util4.find = (arr, checker) => {
        for (const item of arr) {
          if (checker(item))
            return item;
        }
        return void 0;
      };
      util4.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
      function joinValues3(array4, separator = " | ") {
        return array4.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
      }
      util4.joinValues = joinValues3;
      util4.jsonStringifyReplacer = (_, value) => {
        if (typeof value === "bigint") {
          return value.toString();
        }
        return value;
      };
    })(util3 || (util3 = {}));
    (function(objectUtil2) {
      objectUtil2.mergeShapes = (first, second) => {
        return {
          ...first,
          ...second
          // second overwrites first
        };
      };
    })(objectUtil || (objectUtil = {}));
    ZodParsedType = util3.arrayToEnum([
      "string",
      "nan",
      "number",
      "integer",
      "float",
      "boolean",
      "date",
      "bigint",
      "symbol",
      "function",
      "undefined",
      "null",
      "array",
      "object",
      "unknown",
      "promise",
      "void",
      "never",
      "map",
      "set"
    ]);
    getParsedType2 = (data) => {
      const t = typeof data;
      switch (t) {
        case "undefined":
          return ZodParsedType.undefined;
        case "string":
          return ZodParsedType.string;
        case "number":
          return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
        case "boolean":
          return ZodParsedType.boolean;
        case "function":
          return ZodParsedType.function;
        case "bigint":
          return ZodParsedType.bigint;
        case "symbol":
          return ZodParsedType.symbol;
        case "object":
          if (Array.isArray(data)) {
            return ZodParsedType.array;
          }
          if (data === null) {
            return ZodParsedType.null;
          }
          if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
            return ZodParsedType.promise;
          }
          if (typeof Map !== "undefined" && data instanceof Map) {
            return ZodParsedType.map;
          }
          if (typeof Set !== "undefined" && data instanceof Set) {
            return ZodParsedType.set;
          }
          if (typeof Date !== "undefined" && data instanceof Date) {
            return ZodParsedType.date;
          }
          return ZodParsedType.object;
        default:
          return ZodParsedType.unknown;
      }
    };
  }
});

// node_modules/zod/v3/ZodError.js
var ZodIssueCode2, ZodError2;
var init_ZodError = __esm({
  "node_modules/zod/v3/ZodError.js"() {
    "use strict";
    init_util2();
    ZodIssueCode2 = util3.arrayToEnum([
      "invalid_type",
      "invalid_literal",
      "custom",
      "invalid_union",
      "invalid_union_discriminator",
      "invalid_enum_value",
      "unrecognized_keys",
      "invalid_arguments",
      "invalid_return_type",
      "invalid_date",
      "invalid_string",
      "too_small",
      "too_big",
      "invalid_intersection_types",
      "not_multiple_of",
      "not_finite"
    ]);
    ZodError2 = class _ZodError extends Error {
      get errors() {
        return this.issues;
      }
      constructor(issues) {
        super();
        this.issues = [];
        this.addIssue = (sub) => {
          this.issues = [...this.issues, sub];
        };
        this.addIssues = (subs = []) => {
          this.issues = [...this.issues, ...subs];
        };
        const actualProto = new.target.prototype;
        if (Object.setPrototypeOf) {
          Object.setPrototypeOf(this, actualProto);
        } else {
          this.__proto__ = actualProto;
        }
        this.name = "ZodError";
        this.issues = issues;
      }
      format(_mapper) {
        const mapper = _mapper || function(issue3) {
          return issue3.message;
        };
        const fieldErrors = { _errors: [] };
        const processError = (error73) => {
          for (const issue3 of error73.issues) {
            if (issue3.code === "invalid_union") {
              issue3.unionErrors.map(processError);
            } else if (issue3.code === "invalid_return_type") {
              processError(issue3.returnTypeError);
            } else if (issue3.code === "invalid_arguments") {
              processError(issue3.argumentsError);
            } else if (issue3.path.length === 0) {
              fieldErrors._errors.push(mapper(issue3));
            } else {
              let curr = fieldErrors;
              let i = 0;
              while (i < issue3.path.length) {
                const el = issue3.path[i];
                const terminal = i === issue3.path.length - 1;
                if (!terminal) {
                  curr[el] = curr[el] || { _errors: [] };
                } else {
                  curr[el] = curr[el] || { _errors: [] };
                  curr[el]._errors.push(mapper(issue3));
                }
                curr = curr[el];
                i++;
              }
            }
          }
        };
        processError(this);
        return fieldErrors;
      }
      static assert(value) {
        if (!(value instanceof _ZodError)) {
          throw new Error(`Not a ZodError: ${value}`);
        }
      }
      toString() {
        return this.message;
      }
      get message() {
        return JSON.stringify(this.issues, util3.jsonStringifyReplacer, 2);
      }
      get isEmpty() {
        return this.issues.length === 0;
      }
      flatten(mapper = (issue3) => issue3.message) {
        const fieldErrors = /* @__PURE__ */ Object.create(null);
        const formErrors = [];
        for (const sub of this.issues) {
          if (sub.path.length > 0) {
            const firstEl = sub.path[0];
            fieldErrors[firstEl] = fieldErrors[firstEl] || [];
            fieldErrors[firstEl].push(mapper(sub));
          } else {
            formErrors.push(mapper(sub));
          }
        }
        return { formErrors, fieldErrors };
      }
      get formErrors() {
        return this.flatten();
      }
    };
    ZodError2.create = (issues) => {
      const error73 = new ZodError2(issues);
      return error73;
    };
  }
});

// node_modules/zod/v3/locales/en.js
var errorMap, en_default2;
var init_en2 = __esm({
  "node_modules/zod/v3/locales/en.js"() {
    "use strict";
    init_ZodError();
    init_util2();
    errorMap = (issue3, _ctx) => {
      let message;
      switch (issue3.code) {
        case ZodIssueCode2.invalid_type:
          if (issue3.received === ZodParsedType.undefined) {
            message = "Required";
          } else {
            message = `Expected ${issue3.expected}, received ${issue3.received}`;
          }
          break;
        case ZodIssueCode2.invalid_literal:
          message = `Invalid literal value, expected ${JSON.stringify(issue3.expected, util3.jsonStringifyReplacer)}`;
          break;
        case ZodIssueCode2.unrecognized_keys:
          message = `Unrecognized key(s) in object: ${util3.joinValues(issue3.keys, ", ")}`;
          break;
        case ZodIssueCode2.invalid_union:
          message = `Invalid input`;
          break;
        case ZodIssueCode2.invalid_union_discriminator:
          message = `Invalid discriminator value. Expected ${util3.joinValues(issue3.options)}`;
          break;
        case ZodIssueCode2.invalid_enum_value:
          message = `Invalid enum value. Expected ${util3.joinValues(issue3.options)}, received '${issue3.received}'`;
          break;
        case ZodIssueCode2.invalid_arguments:
          message = `Invalid function arguments`;
          break;
        case ZodIssueCode2.invalid_return_type:
          message = `Invalid function return type`;
          break;
        case ZodIssueCode2.invalid_date:
          message = `Invalid date`;
          break;
        case ZodIssueCode2.invalid_string:
          if (typeof issue3.validation === "object") {
            if ("includes" in issue3.validation) {
              message = `Invalid input: must include "${issue3.validation.includes}"`;
              if (typeof issue3.validation.position === "number") {
                message = `${message} at one or more positions greater than or equal to ${issue3.validation.position}`;
              }
            } else if ("startsWith" in issue3.validation) {
              message = `Invalid input: must start with "${issue3.validation.startsWith}"`;
            } else if ("endsWith" in issue3.validation) {
              message = `Invalid input: must end with "${issue3.validation.endsWith}"`;
            } else {
              util3.assertNever(issue3.validation);
            }
          } else if (issue3.validation !== "regex") {
            message = `Invalid ${issue3.validation}`;
          } else {
            message = "Invalid";
          }
          break;
        case ZodIssueCode2.too_small:
          if (issue3.type === "array")
            message = `Array must contain ${issue3.exact ? "exactly" : issue3.inclusive ? `at least` : `more than`} ${issue3.minimum} element(s)`;
          else if (issue3.type === "string")
            message = `String must contain ${issue3.exact ? "exactly" : issue3.inclusive ? `at least` : `over`} ${issue3.minimum} character(s)`;
          else if (issue3.type === "number")
            message = `Number must be ${issue3.exact ? `exactly equal to ` : issue3.inclusive ? `greater than or equal to ` : `greater than `}${issue3.minimum}`;
          else if (issue3.type === "bigint")
            message = `Number must be ${issue3.exact ? `exactly equal to ` : issue3.inclusive ? `greater than or equal to ` : `greater than `}${issue3.minimum}`;
          else if (issue3.type === "date")
            message = `Date must be ${issue3.exact ? `exactly equal to ` : issue3.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue3.minimum))}`;
          else
            message = "Invalid input";
          break;
        case ZodIssueCode2.too_big:
          if (issue3.type === "array")
            message = `Array must contain ${issue3.exact ? `exactly` : issue3.inclusive ? `at most` : `less than`} ${issue3.maximum} element(s)`;
          else if (issue3.type === "string")
            message = `String must contain ${issue3.exact ? `exactly` : issue3.inclusive ? `at most` : `under`} ${issue3.maximum} character(s)`;
          else if (issue3.type === "number")
            message = `Number must be ${issue3.exact ? `exactly` : issue3.inclusive ? `less than or equal to` : `less than`} ${issue3.maximum}`;
          else if (issue3.type === "bigint")
            message = `BigInt must be ${issue3.exact ? `exactly` : issue3.inclusive ? `less than or equal to` : `less than`} ${issue3.maximum}`;
          else if (issue3.type === "date")
            message = `Date must be ${issue3.exact ? `exactly` : issue3.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue3.maximum))}`;
          else
            message = "Invalid input";
          break;
        case ZodIssueCode2.custom:
          message = `Invalid input`;
          break;
        case ZodIssueCode2.invalid_intersection_types:
          message = `Intersection results could not be merged`;
          break;
        case ZodIssueCode2.not_multiple_of:
          message = `Number must be a multiple of ${issue3.multipleOf}`;
          break;
        case ZodIssueCode2.not_finite:
          message = "Number must be finite";
          break;
        default:
          message = _ctx.defaultError;
          util3.assertNever(issue3);
      }
      return { message };
    };
    en_default2 = errorMap;
  }
});

// node_modules/zod/v3/errors.js
function getErrorMap2() {
  return overrideErrorMap;
}
var overrideErrorMap;
var init_errors3 = __esm({
  "node_modules/zod/v3/errors.js"() {
    "use strict";
    init_en2();
    overrideErrorMap = en_default2;
  }
});

// node_modules/zod/v3/helpers/parseUtil.js
function addIssueToContext(ctx, issueData) {
  const overrideMap = getErrorMap2();
  const issue3 = makeIssue({
    issueData,
    data: ctx.data,
    path: ctx.path,
    errorMaps: [
      ctx.common.contextualErrorMap,
      // contextual error map is first priority
      ctx.schemaErrorMap,
      // then schema-bound map if available
      overrideMap,
      // then global override map
      overrideMap === en_default2 ? void 0 : en_default2
      // then global default map
    ].filter((x) => !!x)
  });
  ctx.common.issues.push(issue3);
}
var makeIssue, ParseStatus, INVALID, DIRTY, OK, isAborted, isDirty, isValid, isAsync;
var init_parseUtil = __esm({
  "node_modules/zod/v3/helpers/parseUtil.js"() {
    "use strict";
    init_errors3();
    init_en2();
    makeIssue = (params) => {
      const { data, path: path33, errorMaps, issueData } = params;
      const fullPath = [...path33, ...issueData.path || []];
      const fullIssue = {
        ...issueData,
        path: fullPath
      };
      if (issueData.message !== void 0) {
        return {
          ...issueData,
          path: fullPath,
          message: issueData.message
        };
      }
      let errorMessage = "";
      const maps = errorMaps.filter((m) => !!m).slice().reverse();
      for (const map3 of maps) {
        errorMessage = map3(fullIssue, { data, defaultError: errorMessage }).message;
      }
      return {
        ...issueData,
        path: fullPath,
        message: errorMessage
      };
    };
    ParseStatus = class _ParseStatus {
      constructor() {
        this.value = "valid";
      }
      dirty() {
        if (this.value === "valid")
          this.value = "dirty";
      }
      abort() {
        if (this.value !== "aborted")
          this.value = "aborted";
      }
      static mergeArray(status, results) {
        const arrayValue = [];
        for (const s of results) {
          if (s.status === "aborted")
            return INVALID;
          if (s.status === "dirty")
            status.dirty();
          arrayValue.push(s.value);
        }
        return { status: status.value, value: arrayValue };
      }
      static async mergeObjectAsync(status, pairs) {
        const syncPairs = [];
        for (const pair of pairs) {
          const key = await pair.key;
          const value = await pair.value;
          syncPairs.push({
            key,
            value
          });
        }
        return _ParseStatus.mergeObjectSync(status, syncPairs);
      }
      static mergeObjectSync(status, pairs) {
        const finalObject = {};
        for (const pair of pairs) {
          const { key, value } = pair;
          if (key.status === "aborted")
            return INVALID;
          if (value.status === "aborted")
            return INVALID;
          if (key.status === "dirty")
            status.dirty();
          if (value.status === "dirty")
            status.dirty();
          if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
            finalObject[key.value] = value.value;
          }
        }
        return { status: status.value, value: finalObject };
      }
    };
    INVALID = Object.freeze({
      status: "aborted"
    });
    DIRTY = (value) => ({ status: "dirty", value });
    OK = (value) => ({ status: "valid", value });
    isAborted = (x) => x.status === "aborted";
    isDirty = (x) => x.status === "dirty";
    isValid = (x) => x.status === "valid";
    isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
  }
});

// node_modules/zod/v3/helpers/typeAliases.js
var init_typeAliases = __esm({
  "node_modules/zod/v3/helpers/typeAliases.js"() {
    "use strict";
  }
});

// node_modules/zod/v3/helpers/errorUtil.js
var errorUtil;
var init_errorUtil = __esm({
  "node_modules/zod/v3/helpers/errorUtil.js"() {
    "use strict";
    (function(errorUtil2) {
      errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
      errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
    })(errorUtil || (errorUtil = {}));
  }
});

// node_modules/zod/v3/types.js
function processCreateParams(params) {
  if (!params)
    return {};
  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
  if (errorMap2 && (invalid_type_error || required_error)) {
    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
  }
  if (errorMap2)
    return { errorMap: errorMap2, description };
  const customMap = (iss, ctx) => {
    const { message } = params;
    if (iss.code === "invalid_enum_value") {
      return { message: message ?? ctx.defaultError };
    }
    if (typeof ctx.data === "undefined") {
      return { message: message ?? required_error ?? ctx.defaultError };
    }
    if (iss.code !== "invalid_type")
      return { message: ctx.defaultError };
    return { message: message ?? invalid_type_error ?? ctx.defaultError };
  };
  return { errorMap: customMap, description };
}
function timeRegexSource(args) {
  let secondsRegexSource = `[0-5]\\d`;
  if (args.precision) {
    secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
  } else if (args.precision == null) {
    secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
  }
  const secondsQuantifier = args.precision ? "+" : "?";
  return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
}
function timeRegex(args) {
  return new RegExp(`^${timeRegexSource(args)}$`);
}
function datetimeRegex(args) {
  let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
  const opts = [];
  opts.push(args.local ? `Z?` : `Z`);
  if (args.offset)
    opts.push(`([+-]\\d{2}:?\\d{2})`);
  regex = `${regex}(${opts.join("|")})`;
  return new RegExp(`^${regex}$`);
}
function isValidIP(ip, version3) {
  if ((version3 === "v4" || !version3) && ipv4Regex.test(ip)) {
    return true;
  }
  if ((version3 === "v6" || !version3) && ipv6Regex.test(ip)) {
    return true;
  }
  return false;
}
function isValidJWT2(jwt4, alg) {
  if (!jwtRegex.test(jwt4))
    return false;
  try {
    const [header] = jwt4.split(".");
    if (!header)
      return false;
    const base644 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
    const decoded = JSON.parse(atob(base644));
    if (typeof decoded !== "object" || decoded === null)
      return false;
    if ("typ" in decoded && decoded?.typ !== "JWT")
      return false;
    if (!decoded.alg)
      return false;
    if (alg && decoded.alg !== alg)
      return false;
    return true;
  } catch {
    return false;
  }
}
function isValidCidr(ip, version3) {
  if ((version3 === "v4" || !version3) && ipv4CidrRegex.test(ip)) {
    return true;
  }
  if ((version3 === "v6" || !version3) && ipv6CidrRegex.test(ip)) {
    return true;
  }
  return false;
}
function floatSafeRemainder2(val, step) {
  const valDecCount = (val.toString().split(".")[1] || "").length;
  const stepDecCount = (step.toString().split(".")[1] || "").length;
  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
  return valInt % stepInt / 10 ** decCount;
}
function deepPartialify(schema) {
  if (schema instanceof ZodObject2) {
    const newShape = {};
    for (const key in schema.shape) {
      const fieldSchema = schema.shape[key];
      newShape[key] = ZodOptional2.create(deepPartialify(fieldSchema));
    }
    return new ZodObject2({
      ...schema._def,
      shape: () => newShape
    });
  } else if (schema instanceof ZodArray2) {
    return new ZodArray2({
      ...schema._def,
      type: deepPartialify(schema.element)
    });
  } else if (schema instanceof ZodOptional2) {
    return ZodOptional2.create(deepPartialify(schema.unwrap()));
  } else if (schema instanceof ZodNullable2) {
    return ZodNullable2.create(deepPartialify(schema.unwrap()));
  } else if (schema instanceof ZodTuple2) {
    return ZodTuple2.create(schema.items.map((item) => deepPartialify(item)));
  } else {
    return schema;
  }
}
function mergeValues2(a, b) {
  const aType = getParsedType2(a);
  const bType = getParsedType2(b);
  if (a === b) {
    return { valid: true, data: a };
  } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
    const bKeys = util3.objectKeys(b);
    const sharedKeys = util3.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues2(a[key], b[key]);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
    if (a.length !== b.length) {
      return { valid: false };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues2(itemA, itemB);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
    return { valid: true, data: a };
  } else {
    return { valid: false };
  }
}
function createZodEnum(values, params) {
  return new ZodEnum2({
    values,
    typeName: ZodFirstPartyTypeKind2.ZodEnum,
    ...processCreateParams(params)
  });
}
var ParseInputLazyPath, handleResult, ZodType2, cuidRegex, cuid2Regex, ulidRegex, uuidRegex, nanoidRegex, jwtRegex, durationRegex, emailRegex, _emojiRegex, emojiRegex, ipv4Regex, ipv4CidrRegex, ipv6Regex, ipv6CidrRegex, base64Regex, base64urlRegex, dateRegexSource, dateRegex, ZodString2, ZodNumber2, ZodBigInt2, ZodBoolean2, ZodDate2, ZodSymbol2, ZodUndefined2, ZodNull2, ZodAny2, ZodUnknown2, ZodNever2, ZodVoid2, ZodArray2, ZodObject2, ZodUnion2, getDiscriminator, ZodDiscriminatedUnion2, ZodIntersection2, ZodTuple2, ZodRecord2, ZodMap2, ZodSet2, ZodFunction2, ZodLazy2, ZodLiteral2, ZodEnum2, ZodNativeEnum, ZodPromise2, ZodEffects, ZodOptional2, ZodNullable2, ZodDefault2, ZodCatch2, ZodNaN2, ZodBranded, ZodPipeline, ZodReadonly2, late, ZodFirstPartyTypeKind2, stringType, numberType, nanType, bigIntType, booleanType, dateType, symbolType, undefinedType, nullType, anyType, unknownType, neverType, voidType, arrayType, objectType, strictObjectType, unionType, discriminatedUnionType, intersectionType, tupleType, recordType, mapType, setType, functionType, lazyType, literalType, enumType, nativeEnumType, promiseType, effectsType, optionalType, nullableType, preprocessType, pipelineType;
var init_types = __esm({
  "node_modules/zod/v3/types.js"() {
    "use strict";
    init_ZodError();
    init_errors3();
    init_errorUtil();
    init_parseUtil();
    init_util2();
    ParseInputLazyPath = class {
      constructor(parent, value, path33, key) {
        this._cachedPath = [];
        this.parent = parent;
        this.data = value;
        this._path = path33;
        this._key = key;
      }
      get path() {
        if (!this._cachedPath.length) {
          if (Array.isArray(this._key)) {
            this._cachedPath.push(...this._path, ...this._key);
          } else {
            this._cachedPath.push(...this._path, this._key);
          }
        }
        return this._cachedPath;
      }
    };
    handleResult = (ctx, result) => {
      if (isValid(result)) {
        return { success: true, data: result.value };
      } else {
        if (!ctx.common.issues.length) {
          throw new Error("Validation failed but no issues detected.");
        }
        return {
          success: false,
          get error() {
            if (this._error)
              return this._error;
            const error73 = new ZodError2(ctx.common.issues);
            this._error = error73;
            return this._error;
          }
        };
      }
    };
    ZodType2 = class {
      get description() {
        return this._def.description;
      }
      _getType(input) {
        return getParsedType2(input.data);
      }
      _getOrReturnCtx(input, ctx) {
        return ctx || {
          common: input.parent.common,
          data: input.data,
          parsedType: getParsedType2(input.data),
          schemaErrorMap: this._def.errorMap,
          path: input.path,
          parent: input.parent
        };
      }
      _processInputParams(input) {
        return {
          status: new ParseStatus(),
          ctx: {
            common: input.parent.common,
            data: input.data,
            parsedType: getParsedType2(input.data),
            schemaErrorMap: this._def.errorMap,
            path: input.path,
            parent: input.parent
          }
        };
      }
      _parseSync(input) {
        const result = this._parse(input);
        if (isAsync(result)) {
          throw new Error("Synchronous parse encountered promise.");
        }
        return result;
      }
      _parseAsync(input) {
        const result = this._parse(input);
        return Promise.resolve(result);
      }
      parse(data, params) {
        const result = this.safeParse(data, params);
        if (result.success)
          return result.data;
        throw result.error;
      }
      safeParse(data, params) {
        const ctx = {
          common: {
            issues: [],
            async: params?.async ?? false,
            contextualErrorMap: params?.errorMap
          },
          path: params?.path || [],
          schemaErrorMap: this._def.errorMap,
          parent: null,
          data,
          parsedType: getParsedType2(data)
        };
        const result = this._parseSync({ data, path: ctx.path, parent: ctx });
        return handleResult(ctx, result);
      }
      "~validate"(data) {
        const ctx = {
          common: {
            issues: [],
            async: !!this["~standard"].async
          },
          path: [],
          schemaErrorMap: this._def.errorMap,
          parent: null,
          data,
          parsedType: getParsedType2(data)
        };
        if (!this["~standard"].async) {
          try {
            const result = this._parseSync({ data, path: [], parent: ctx });
            return isValid(result) ? {
              value: result.value
            } : {
              issues: ctx.common.issues
            };
          } catch (err) {
            if (err?.message?.toLowerCase()?.includes("encountered")) {
              this["~standard"].async = true;
            }
            ctx.common = {
              issues: [],
              async: true
            };
          }
        }
        return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
          value: result.value
        } : {
          issues: ctx.common.issues
        });
      }
      async parseAsync(data, params) {
        const result = await this.safeParseAsync(data, params);
        if (result.success)
          return result.data;
        throw result.error;
      }
      async safeParseAsync(data, params) {
        const ctx = {
          common: {
            issues: [],
            contextualErrorMap: params?.errorMap,
            async: true
          },
          path: params?.path || [],
          schemaErrorMap: this._def.errorMap,
          parent: null,
          data,
          parsedType: getParsedType2(data)
        };
        const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
        const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
        return handleResult(ctx, result);
      }
      refine(check3, message) {
        const getIssueProperties = (val) => {
          if (typeof message === "string" || typeof message === "undefined") {
            return { message };
          } else if (typeof message === "function") {
            return message(val);
          } else {
            return message;
          }
        };
        return this._refinement((val, ctx) => {
          const result = check3(val);
          const setError = () => ctx.addIssue({
            code: ZodIssueCode2.custom,
            ...getIssueProperties(val)
          });
          if (typeof Promise !== "undefined" && result instanceof Promise) {
            return result.then((data) => {
              if (!data) {
                setError();
                return false;
              } else {
                return true;
              }
            });
          }
          if (!result) {
            setError();
            return false;
          } else {
            return true;
          }
        });
      }
      refinement(check3, refinementData) {
        return this._refinement((val, ctx) => {
          if (!check3(val)) {
            ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
            return false;
          } else {
            return true;
          }
        });
      }
      _refinement(refinement) {
        return new ZodEffects({
          schema: this,
          typeName: ZodFirstPartyTypeKind2.ZodEffects,
          effect: { type: "refinement", refinement }
        });
      }
      superRefine(refinement) {
        return this._refinement(refinement);
      }
      constructor(def) {
        this.spa = this.safeParseAsync;
        this._def = def;
        this.parse = this.parse.bind(this);
        this.safeParse = this.safeParse.bind(this);
        this.parseAsync = this.parseAsync.bind(this);
        this.safeParseAsync = this.safeParseAsync.bind(this);
        this.spa = this.spa.bind(this);
        this.refine = this.refine.bind(this);
        this.refinement = this.refinement.bind(this);
        this.superRefine = this.superRefine.bind(this);
        this.optional = this.optional.bind(this);
        this.nullable = this.nullable.bind(this);
        this.nullish = this.nullish.bind(this);
        this.array = this.array.bind(this);
        this.promise = this.promise.bind(this);
        this.or = this.or.bind(this);
        this.and = this.and.bind(this);
        this.transform = this.transform.bind(this);
        this.brand = this.brand.bind(this);
        this.default = this.default.bind(this);
        this.catch = this.catch.bind(this);
        this.describe = this.describe.bind(this);
        this.pipe = this.pipe.bind(this);
        this.readonly = this.readonly.bind(this);
        this.isNullable = this.isNullable.bind(this);
        this.isOptional = this.isOptional.bind(this);
        this["~standard"] = {
          version: 1,
          vendor: "zod",
          validate: (data) => this["~validate"](data)
        };
      }
      optional() {
        return ZodOptional2.create(this, this._def);
      }
      nullable() {
        return ZodNullable2.create(this, this._def);
      }
      nullish() {
        return this.nullable().optional();
      }
      array() {
        return ZodArray2.create(this);
      }
      promise() {
        return ZodPromise2.create(this, this._def);
      }
      or(option) {
        return ZodUnion2.create([this, option], this._def);
      }
      and(incoming) {
        return ZodIntersection2.create(this, incoming, this._def);
      }
      transform(transform8) {
        return new ZodEffects({
          ...processCreateParams(this._def),
          schema: this,
          typeName: ZodFirstPartyTypeKind2.ZodEffects,
          effect: { type: "transform", transform: transform8 }
        });
      }
      default(def) {
        const defaultValueFunc = typeof def === "function" ? def : () => def;
        return new ZodDefault2({
          ...processCreateParams(this._def),
          innerType: this,
          defaultValue: defaultValueFunc,
          typeName: ZodFirstPartyTypeKind2.ZodDefault
        });
      }
      brand() {
        return new ZodBranded({
          typeName: ZodFirstPartyTypeKind2.ZodBranded,
          type: this,
          ...processCreateParams(this._def)
        });
      }
      catch(def) {
        const catchValueFunc = typeof def === "function" ? def : () => def;
        return new ZodCatch2({
          ...processCreateParams(this._def),
          innerType: this,
          catchValue: catchValueFunc,
          typeName: ZodFirstPartyTypeKind2.ZodCatch
        });
      }
      describe(description) {
        const This = this.constructor;
        return new This({
          ...this._def,
          description
        });
      }
      pipe(target) {
        return ZodPipeline.create(this, target);
      }
      readonly() {
        return ZodReadonly2.create(this);
      }
      isOptional() {
        return this.safeParse(void 0).success;
      }
      isNullable() {
        return this.safeParse(null).success;
      }
    };
    cuidRegex = /^c[^\s-]{8,}$/i;
    cuid2Regex = /^[0-9a-z]+$/;
    ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
    uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
    nanoidRegex = /^[a-z0-9_-]{21}$/i;
    jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
    durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
    emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
    _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
    ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
    ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/;
    ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
    ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
    base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
    base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
    dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
    dateRegex = new RegExp(`^${dateRegexSource}$`);
    ZodString2 = class _ZodString3 extends ZodType2 {
      _parse(input) {
        if (this._def.coerce) {
          input.data = String(input.data);
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.string) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.string,
            received: ctx2.parsedType
          });
          return INVALID;
        }
        const status = new ParseStatus();
        let ctx = void 0;
        for (const check3 of this._def.checks) {
          if (check3.kind === "min") {
            if (input.data.length < check3.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.too_small,
                minimum: check3.value,
                type: "string",
                inclusive: true,
                exact: false,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "max") {
            if (input.data.length > check3.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.too_big,
                maximum: check3.value,
                type: "string",
                inclusive: true,
                exact: false,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "length") {
            const tooBig = input.data.length > check3.value;
            const tooSmall = input.data.length < check3.value;
            if (tooBig || tooSmall) {
              ctx = this._getOrReturnCtx(input, ctx);
              if (tooBig) {
                addIssueToContext(ctx, {
                  code: ZodIssueCode2.too_big,
                  maximum: check3.value,
                  type: "string",
                  inclusive: true,
                  exact: true,
                  message: check3.message
                });
              } else if (tooSmall) {
                addIssueToContext(ctx, {
                  code: ZodIssueCode2.too_small,
                  minimum: check3.value,
                  type: "string",
                  inclusive: true,
                  exact: true,
                  message: check3.message
                });
              }
              status.dirty();
            }
          } else if (check3.kind === "email") {
            if (!emailRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "email",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "emoji") {
            if (!emojiRegex) {
              emojiRegex = new RegExp(_emojiRegex, "u");
            }
            if (!emojiRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "emoji",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "uuid") {
            if (!uuidRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "uuid",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "nanoid") {
            if (!nanoidRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "nanoid",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "cuid") {
            if (!cuidRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "cuid",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "cuid2") {
            if (!cuid2Regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "cuid2",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "ulid") {
            if (!ulidRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "ulid",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "url") {
            try {
              new URL(input.data);
            } catch {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "url",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "regex") {
            check3.regex.lastIndex = 0;
            const testResult = check3.regex.test(input.data);
            if (!testResult) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "regex",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "trim") {
            input.data = input.data.trim();
          } else if (check3.kind === "includes") {
            if (!input.data.includes(check3.value, check3.position)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.invalid_string,
                validation: { includes: check3.value, position: check3.position },
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "toLowerCase") {
            input.data = input.data.toLowerCase();
          } else if (check3.kind === "toUpperCase") {
            input.data = input.data.toUpperCase();
          } else if (check3.kind === "startsWith") {
            if (!input.data.startsWith(check3.value)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.invalid_string,
                validation: { startsWith: check3.value },
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "endsWith") {
            if (!input.data.endsWith(check3.value)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.invalid_string,
                validation: { endsWith: check3.value },
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "datetime") {
            const regex = datetimeRegex(check3);
            if (!regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.invalid_string,
                validation: "datetime",
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "date") {
            const regex = dateRegex;
            if (!regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.invalid_string,
                validation: "date",
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "time") {
            const regex = timeRegex(check3);
            if (!regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.invalid_string,
                validation: "time",
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "duration") {
            if (!durationRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "duration",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "ip") {
            if (!isValidIP(input.data, check3.version)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "ip",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "jwt") {
            if (!isValidJWT2(input.data, check3.alg)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "jwt",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "cidr") {
            if (!isValidCidr(input.data, check3.version)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "cidr",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "base64") {
            if (!base64Regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "base64",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "base64url") {
            if (!base64urlRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "base64url",
                code: ZodIssueCode2.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else {
            util3.assertNever(check3);
          }
        }
        return { status: status.value, value: input.data };
      }
      _regex(regex, validation, message) {
        return this.refinement((data) => regex.test(data), {
          validation,
          code: ZodIssueCode2.invalid_string,
          ...errorUtil.errToObj(message)
        });
      }
      _addCheck(check3) {
        return new _ZodString3({
          ...this._def,
          checks: [...this._def.checks, check3]
        });
      }
      email(message) {
        return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
      }
      url(message) {
        return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
      }
      emoji(message) {
        return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
      }
      uuid(message) {
        return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
      }
      nanoid(message) {
        return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
      }
      cuid(message) {
        return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
      }
      cuid2(message) {
        return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
      }
      ulid(message) {
        return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
      }
      base64(message) {
        return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
      }
      base64url(message) {
        return this._addCheck({
          kind: "base64url",
          ...errorUtil.errToObj(message)
        });
      }
      jwt(options) {
        return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) });
      }
      ip(options) {
        return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
      }
      cidr(options) {
        return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
      }
      datetime(options) {
        if (typeof options === "string") {
          return this._addCheck({
            kind: "datetime",
            precision: null,
            offset: false,
            local: false,
            message: options
          });
        }
        return this._addCheck({
          kind: "datetime",
          precision: typeof options?.precision === "undefined" ? null : options?.precision,
          offset: options?.offset ?? false,
          local: options?.local ?? false,
          ...errorUtil.errToObj(options?.message)
        });
      }
      date(message) {
        return this._addCheck({ kind: "date", message });
      }
      time(options) {
        if (typeof options === "string") {
          return this._addCheck({
            kind: "time",
            precision: null,
            message: options
          });
        }
        return this._addCheck({
          kind: "time",
          precision: typeof options?.precision === "undefined" ? null : options?.precision,
          ...errorUtil.errToObj(options?.message)
        });
      }
      duration(message) {
        return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
      }
      regex(regex, message) {
        return this._addCheck({
          kind: "regex",
          regex,
          ...errorUtil.errToObj(message)
        });
      }
      includes(value, options) {
        return this._addCheck({
          kind: "includes",
          value,
          position: options?.position,
          ...errorUtil.errToObj(options?.message)
        });
      }
      startsWith(value, message) {
        return this._addCheck({
          kind: "startsWith",
          value,
          ...errorUtil.errToObj(message)
        });
      }
      endsWith(value, message) {
        return this._addCheck({
          kind: "endsWith",
          value,
          ...errorUtil.errToObj(message)
        });
      }
      min(minLength, message) {
        return this._addCheck({
          kind: "min",
          value: minLength,
          ...errorUtil.errToObj(message)
        });
      }
      max(maxLength, message) {
        return this._addCheck({
          kind: "max",
          value: maxLength,
          ...errorUtil.errToObj(message)
        });
      }
      length(len, message) {
        return this._addCheck({
          kind: "length",
          value: len,
          ...errorUtil.errToObj(message)
        });
      }
      /**
       * Equivalent to `.min(1)`
       */
      nonempty(message) {
        return this.min(1, errorUtil.errToObj(message));
      }
      trim() {
        return new _ZodString3({
          ...this._def,
          checks: [...this._def.checks, { kind: "trim" }]
        });
      }
      toLowerCase() {
        return new _ZodString3({
          ...this._def,
          checks: [...this._def.checks, { kind: "toLowerCase" }]
        });
      }
      toUpperCase() {
        return new _ZodString3({
          ...this._def,
          checks: [...this._def.checks, { kind: "toUpperCase" }]
        });
      }
      get isDatetime() {
        return !!this._def.checks.find((ch) => ch.kind === "datetime");
      }
      get isDate() {
        return !!this._def.checks.find((ch) => ch.kind === "date");
      }
      get isTime() {
        return !!this._def.checks.find((ch) => ch.kind === "time");
      }
      get isDuration() {
        return !!this._def.checks.find((ch) => ch.kind === "duration");
      }
      get isEmail() {
        return !!this._def.checks.find((ch) => ch.kind === "email");
      }
      get isURL() {
        return !!this._def.checks.find((ch) => ch.kind === "url");
      }
      get isEmoji() {
        return !!this._def.checks.find((ch) => ch.kind === "emoji");
      }
      get isUUID() {
        return !!this._def.checks.find((ch) => ch.kind === "uuid");
      }
      get isNANOID() {
        return !!this._def.checks.find((ch) => ch.kind === "nanoid");
      }
      get isCUID() {
        return !!this._def.checks.find((ch) => ch.kind === "cuid");
      }
      get isCUID2() {
        return !!this._def.checks.find((ch) => ch.kind === "cuid2");
      }
      get isULID() {
        return !!this._def.checks.find((ch) => ch.kind === "ulid");
      }
      get isIP() {
        return !!this._def.checks.find((ch) => ch.kind === "ip");
      }
      get isCIDR() {
        return !!this._def.checks.find((ch) => ch.kind === "cidr");
      }
      get isBase64() {
        return !!this._def.checks.find((ch) => ch.kind === "base64");
      }
      get isBase64url() {
        return !!this._def.checks.find((ch) => ch.kind === "base64url");
      }
      get minLength() {
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          }
        }
        return min;
      }
      get maxLength() {
        let max = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return max;
      }
    };
    ZodString2.create = (params) => {
      return new ZodString2({
        checks: [],
        typeName: ZodFirstPartyTypeKind2.ZodString,
        coerce: params?.coerce ?? false,
        ...processCreateParams(params)
      });
    };
    ZodNumber2 = class _ZodNumber extends ZodType2 {
      constructor() {
        super(...arguments);
        this.min = this.gte;
        this.max = this.lte;
        this.step = this.multipleOf;
      }
      _parse(input) {
        if (this._def.coerce) {
          input.data = Number(input.data);
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.number) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.number,
            received: ctx2.parsedType
          });
          return INVALID;
        }
        let ctx = void 0;
        const status = new ParseStatus();
        for (const check3 of this._def.checks) {
          if (check3.kind === "int") {
            if (!util3.isInteger(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.invalid_type,
                expected: "integer",
                received: "float",
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "min") {
            const tooSmall = check3.inclusive ? input.data < check3.value : input.data <= check3.value;
            if (tooSmall) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.too_small,
                minimum: check3.value,
                type: "number",
                inclusive: check3.inclusive,
                exact: false,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "max") {
            const tooBig = check3.inclusive ? input.data > check3.value : input.data >= check3.value;
            if (tooBig) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.too_big,
                maximum: check3.value,
                type: "number",
                inclusive: check3.inclusive,
                exact: false,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "multipleOf") {
            if (floatSafeRemainder2(input.data, check3.value) !== 0) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.not_multiple_of,
                multipleOf: check3.value,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "finite") {
            if (!Number.isFinite(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.not_finite,
                message: check3.message
              });
              status.dirty();
            }
          } else {
            util3.assertNever(check3);
          }
        }
        return { status: status.value, value: input.data };
      }
      gte(value, message) {
        return this.setLimit("min", value, true, errorUtil.toString(message));
      }
      gt(value, message) {
        return this.setLimit("min", value, false, errorUtil.toString(message));
      }
      lte(value, message) {
        return this.setLimit("max", value, true, errorUtil.toString(message));
      }
      lt(value, message) {
        return this.setLimit("max", value, false, errorUtil.toString(message));
      }
      setLimit(kind, value, inclusive, message) {
        return new _ZodNumber({
          ...this._def,
          checks: [
            ...this._def.checks,
            {
              kind,
              value,
              inclusive,
              message: errorUtil.toString(message)
            }
          ]
        });
      }
      _addCheck(check3) {
        return new _ZodNumber({
          ...this._def,
          checks: [...this._def.checks, check3]
        });
      }
      int(message) {
        return this._addCheck({
          kind: "int",
          message: errorUtil.toString(message)
        });
      }
      positive(message) {
        return this._addCheck({
          kind: "min",
          value: 0,
          inclusive: false,
          message: errorUtil.toString(message)
        });
      }
      negative(message) {
        return this._addCheck({
          kind: "max",
          value: 0,
          inclusive: false,
          message: errorUtil.toString(message)
        });
      }
      nonpositive(message) {
        return this._addCheck({
          kind: "max",
          value: 0,
          inclusive: true,
          message: errorUtil.toString(message)
        });
      }
      nonnegative(message) {
        return this._addCheck({
          kind: "min",
          value: 0,
          inclusive: true,
          message: errorUtil.toString(message)
        });
      }
      multipleOf(value, message) {
        return this._addCheck({
          kind: "multipleOf",
          value,
          message: errorUtil.toString(message)
        });
      }
      finite(message) {
        return this._addCheck({
          kind: "finite",
          message: errorUtil.toString(message)
        });
      }
      safe(message) {
        return this._addCheck({
          kind: "min",
          inclusive: true,
          value: Number.MIN_SAFE_INTEGER,
          message: errorUtil.toString(message)
        })._addCheck({
          kind: "max",
          inclusive: true,
          value: Number.MAX_SAFE_INTEGER,
          message: errorUtil.toString(message)
        });
      }
      get minValue() {
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          }
        }
        return min;
      }
      get maxValue() {
        let max = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return max;
      }
      get isInt() {
        return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util3.isInteger(ch.value));
      }
      get isFinite() {
        let max = null;
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
            return true;
          } else if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          } else if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return Number.isFinite(min) && Number.isFinite(max);
      }
    };
    ZodNumber2.create = (params) => {
      return new ZodNumber2({
        checks: [],
        typeName: ZodFirstPartyTypeKind2.ZodNumber,
        coerce: params?.coerce || false,
        ...processCreateParams(params)
      });
    };
    ZodBigInt2 = class _ZodBigInt extends ZodType2 {
      constructor() {
        super(...arguments);
        this.min = this.gte;
        this.max = this.lte;
      }
      _parse(input) {
        if (this._def.coerce) {
          try {
            input.data = BigInt(input.data);
          } catch {
            return this._getInvalidInput(input);
          }
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.bigint) {
          return this._getInvalidInput(input);
        }
        let ctx = void 0;
        const status = new ParseStatus();
        for (const check3 of this._def.checks) {
          if (check3.kind === "min") {
            const tooSmall = check3.inclusive ? input.data < check3.value : input.data <= check3.value;
            if (tooSmall) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.too_small,
                type: "bigint",
                minimum: check3.value,
                inclusive: check3.inclusive,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "max") {
            const tooBig = check3.inclusive ? input.data > check3.value : input.data >= check3.value;
            if (tooBig) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.too_big,
                type: "bigint",
                maximum: check3.value,
                inclusive: check3.inclusive,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "multipleOf") {
            if (input.data % check3.value !== BigInt(0)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.not_multiple_of,
                multipleOf: check3.value,
                message: check3.message
              });
              status.dirty();
            }
          } else {
            util3.assertNever(check3);
          }
        }
        return { status: status.value, value: input.data };
      }
      _getInvalidInput(input) {
        const ctx = this._getOrReturnCtx(input);
        addIssueToContext(ctx, {
          code: ZodIssueCode2.invalid_type,
          expected: ZodParsedType.bigint,
          received: ctx.parsedType
        });
        return INVALID;
      }
      gte(value, message) {
        return this.setLimit("min", value, true, errorUtil.toString(message));
      }
      gt(value, message) {
        return this.setLimit("min", value, false, errorUtil.toString(message));
      }
      lte(value, message) {
        return this.setLimit("max", value, true, errorUtil.toString(message));
      }
      lt(value, message) {
        return this.setLimit("max", value, false, errorUtil.toString(message));
      }
      setLimit(kind, value, inclusive, message) {
        return new _ZodBigInt({
          ...this._def,
          checks: [
            ...this._def.checks,
            {
              kind,
              value,
              inclusive,
              message: errorUtil.toString(message)
            }
          ]
        });
      }
      _addCheck(check3) {
        return new _ZodBigInt({
          ...this._def,
          checks: [...this._def.checks, check3]
        });
      }
      positive(message) {
        return this._addCheck({
          kind: "min",
          value: BigInt(0),
          inclusive: false,
          message: errorUtil.toString(message)
        });
      }
      negative(message) {
        return this._addCheck({
          kind: "max",
          value: BigInt(0),
          inclusive: false,
          message: errorUtil.toString(message)
        });
      }
      nonpositive(message) {
        return this._addCheck({
          kind: "max",
          value: BigInt(0),
          inclusive: true,
          message: errorUtil.toString(message)
        });
      }
      nonnegative(message) {
        return this._addCheck({
          kind: "min",
          value: BigInt(0),
          inclusive: true,
          message: errorUtil.toString(message)
        });
      }
      multipleOf(value, message) {
        return this._addCheck({
          kind: "multipleOf",
          value,
          message: errorUtil.toString(message)
        });
      }
      get minValue() {
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          }
        }
        return min;
      }
      get maxValue() {
        let max = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return max;
      }
    };
    ZodBigInt2.create = (params) => {
      return new ZodBigInt2({
        checks: [],
        typeName: ZodFirstPartyTypeKind2.ZodBigInt,
        coerce: params?.coerce ?? false,
        ...processCreateParams(params)
      });
    };
    ZodBoolean2 = class extends ZodType2 {
      _parse(input) {
        if (this._def.coerce) {
          input.data = Boolean(input.data);
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.boolean) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.boolean,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodBoolean2.create = (params) => {
      return new ZodBoolean2({
        typeName: ZodFirstPartyTypeKind2.ZodBoolean,
        coerce: params?.coerce || false,
        ...processCreateParams(params)
      });
    };
    ZodDate2 = class _ZodDate extends ZodType2 {
      _parse(input) {
        if (this._def.coerce) {
          input.data = new Date(input.data);
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.date) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.date,
            received: ctx2.parsedType
          });
          return INVALID;
        }
        if (Number.isNaN(input.data.getTime())) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode2.invalid_date
          });
          return INVALID;
        }
        const status = new ParseStatus();
        let ctx = void 0;
        for (const check3 of this._def.checks) {
          if (check3.kind === "min") {
            if (input.data.getTime() < check3.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.too_small,
                message: check3.message,
                inclusive: true,
                exact: false,
                minimum: check3.value,
                type: "date"
              });
              status.dirty();
            }
          } else if (check3.kind === "max") {
            if (input.data.getTime() > check3.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode2.too_big,
                message: check3.message,
                inclusive: true,
                exact: false,
                maximum: check3.value,
                type: "date"
              });
              status.dirty();
            }
          } else {
            util3.assertNever(check3);
          }
        }
        return {
          status: status.value,
          value: new Date(input.data.getTime())
        };
      }
      _addCheck(check3) {
        return new _ZodDate({
          ...this._def,
          checks: [...this._def.checks, check3]
        });
      }
      min(minDate, message) {
        return this._addCheck({
          kind: "min",
          value: minDate.getTime(),
          message: errorUtil.toString(message)
        });
      }
      max(maxDate, message) {
        return this._addCheck({
          kind: "max",
          value: maxDate.getTime(),
          message: errorUtil.toString(message)
        });
      }
      get minDate() {
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          }
        }
        return min != null ? new Date(min) : null;
      }
      get maxDate() {
        let max = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return max != null ? new Date(max) : null;
      }
    };
    ZodDate2.create = (params) => {
      return new ZodDate2({
        checks: [],
        coerce: params?.coerce || false,
        typeName: ZodFirstPartyTypeKind2.ZodDate,
        ...processCreateParams(params)
      });
    };
    ZodSymbol2 = class extends ZodType2 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.symbol) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.symbol,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodSymbol2.create = (params) => {
      return new ZodSymbol2({
        typeName: ZodFirstPartyTypeKind2.ZodSymbol,
        ...processCreateParams(params)
      });
    };
    ZodUndefined2 = class extends ZodType2 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.undefined) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.undefined,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodUndefined2.create = (params) => {
      return new ZodUndefined2({
        typeName: ZodFirstPartyTypeKind2.ZodUndefined,
        ...processCreateParams(params)
      });
    };
    ZodNull2 = class extends ZodType2 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.null) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.null,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodNull2.create = (params) => {
      return new ZodNull2({
        typeName: ZodFirstPartyTypeKind2.ZodNull,
        ...processCreateParams(params)
      });
    };
    ZodAny2 = class extends ZodType2 {
      constructor() {
        super(...arguments);
        this._any = true;
      }
      _parse(input) {
        return OK(input.data);
      }
    };
    ZodAny2.create = (params) => {
      return new ZodAny2({
        typeName: ZodFirstPartyTypeKind2.ZodAny,
        ...processCreateParams(params)
      });
    };
    ZodUnknown2 = class extends ZodType2 {
      constructor() {
        super(...arguments);
        this._unknown = true;
      }
      _parse(input) {
        return OK(input.data);
      }
    };
    ZodUnknown2.create = (params) => {
      return new ZodUnknown2({
        typeName: ZodFirstPartyTypeKind2.ZodUnknown,
        ...processCreateParams(params)
      });
    };
    ZodNever2 = class extends ZodType2 {
      _parse(input) {
        const ctx = this._getOrReturnCtx(input);
        addIssueToContext(ctx, {
          code: ZodIssueCode2.invalid_type,
          expected: ZodParsedType.never,
          received: ctx.parsedType
        });
        return INVALID;
      }
    };
    ZodNever2.create = (params) => {
      return new ZodNever2({
        typeName: ZodFirstPartyTypeKind2.ZodNever,
        ...processCreateParams(params)
      });
    };
    ZodVoid2 = class extends ZodType2 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.undefined) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.void,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodVoid2.create = (params) => {
      return new ZodVoid2({
        typeName: ZodFirstPartyTypeKind2.ZodVoid,
        ...processCreateParams(params)
      });
    };
    ZodArray2 = class _ZodArray extends ZodType2 {
      _parse(input) {
        const { ctx, status } = this._processInputParams(input);
        const def = this._def;
        if (ctx.parsedType !== ZodParsedType.array) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.array,
            received: ctx.parsedType
          });
          return INVALID;
        }
        if (def.exactLength !== null) {
          const tooBig = ctx.data.length > def.exactLength.value;
          const tooSmall = ctx.data.length < def.exactLength.value;
          if (tooBig || tooSmall) {
            addIssueToContext(ctx, {
              code: tooBig ? ZodIssueCode2.too_big : ZodIssueCode2.too_small,
              minimum: tooSmall ? def.exactLength.value : void 0,
              maximum: tooBig ? def.exactLength.value : void 0,
              type: "array",
              inclusive: true,
              exact: true,
              message: def.exactLength.message
            });
            status.dirty();
          }
        }
        if (def.minLength !== null) {
          if (ctx.data.length < def.minLength.value) {
            addIssueToContext(ctx, {
              code: ZodIssueCode2.too_small,
              minimum: def.minLength.value,
              type: "array",
              inclusive: true,
              exact: false,
              message: def.minLength.message
            });
            status.dirty();
          }
        }
        if (def.maxLength !== null) {
          if (ctx.data.length > def.maxLength.value) {
            addIssueToContext(ctx, {
              code: ZodIssueCode2.too_big,
              maximum: def.maxLength.value,
              type: "array",
              inclusive: true,
              exact: false,
              message: def.maxLength.message
            });
            status.dirty();
          }
        }
        if (ctx.common.async) {
          return Promise.all([...ctx.data].map((item, i) => {
            return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
          })).then((result2) => {
            return ParseStatus.mergeArray(status, result2);
          });
        }
        const result = [...ctx.data].map((item, i) => {
          return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
        });
        return ParseStatus.mergeArray(status, result);
      }
      get element() {
        return this._def.type;
      }
      min(minLength, message) {
        return new _ZodArray({
          ...this._def,
          minLength: { value: minLength, message: errorUtil.toString(message) }
        });
      }
      max(maxLength, message) {
        return new _ZodArray({
          ...this._def,
          maxLength: { value: maxLength, message: errorUtil.toString(message) }
        });
      }
      length(len, message) {
        return new _ZodArray({
          ...this._def,
          exactLength: { value: len, message: errorUtil.toString(message) }
        });
      }
      nonempty(message) {
        return this.min(1, message);
      }
    };
    ZodArray2.create = (schema, params) => {
      return new ZodArray2({
        type: schema,
        minLength: null,
        maxLength: null,
        exactLength: null,
        typeName: ZodFirstPartyTypeKind2.ZodArray,
        ...processCreateParams(params)
      });
    };
    ZodObject2 = class _ZodObject extends ZodType2 {
      constructor() {
        super(...arguments);
        this._cached = null;
        this.nonstrict = this.passthrough;
        this.augment = this.extend;
      }
      _getCached() {
        if (this._cached !== null)
          return this._cached;
        const shape = this._def.shape();
        const keys2 = util3.objectKeys(shape);
        this._cached = { shape, keys: keys2 };
        return this._cached;
      }
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.object) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.object,
            received: ctx2.parsedType
          });
          return INVALID;
        }
        const { status, ctx } = this._processInputParams(input);
        const { shape, keys: shapeKeys } = this._getCached();
        const extraKeys = [];
        if (!(this._def.catchall instanceof ZodNever2 && this._def.unknownKeys === "strip")) {
          for (const key in ctx.data) {
            if (!shapeKeys.includes(key)) {
              extraKeys.push(key);
            }
          }
        }
        const pairs = [];
        for (const key of shapeKeys) {
          const keyValidator = shape[key];
          const value = ctx.data[key];
          pairs.push({
            key: { status: "valid", value: key },
            value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
            alwaysSet: key in ctx.data
          });
        }
        if (this._def.catchall instanceof ZodNever2) {
          const unknownKeys = this._def.unknownKeys;
          if (unknownKeys === "passthrough") {
            for (const key of extraKeys) {
              pairs.push({
                key: { status: "valid", value: key },
                value: { status: "valid", value: ctx.data[key] }
              });
            }
          } else if (unknownKeys === "strict") {
            if (extraKeys.length > 0) {
              addIssueToContext(ctx, {
                code: ZodIssueCode2.unrecognized_keys,
                keys: extraKeys
              });
              status.dirty();
            }
          } else if (unknownKeys === "strip") {
          } else {
            throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
          }
        } else {
          const catchall = this._def.catchall;
          for (const key of extraKeys) {
            const value = ctx.data[key];
            pairs.push({
              key: { status: "valid", value: key },
              value: catchall._parse(
                new ParseInputLazyPath(ctx, value, ctx.path, key)
                //, ctx.child(key), value, getParsedType(value)
              ),
              alwaysSet: key in ctx.data
            });
          }
        }
        if (ctx.common.async) {
          return Promise.resolve().then(async () => {
            const syncPairs = [];
            for (const pair of pairs) {
              const key = await pair.key;
              const value = await pair.value;
              syncPairs.push({
                key,
                value,
                alwaysSet: pair.alwaysSet
              });
            }
            return syncPairs;
          }).then((syncPairs) => {
            return ParseStatus.mergeObjectSync(status, syncPairs);
          });
        } else {
          return ParseStatus.mergeObjectSync(status, pairs);
        }
      }
      get shape() {
        return this._def.shape();
      }
      strict(message) {
        errorUtil.errToObj;
        return new _ZodObject({
          ...this._def,
          unknownKeys: "strict",
          ...message !== void 0 ? {
            errorMap: (issue3, ctx) => {
              const defaultError = this._def.errorMap?.(issue3, ctx).message ?? ctx.defaultError;
              if (issue3.code === "unrecognized_keys")
                return {
                  message: errorUtil.errToObj(message).message ?? defaultError
                };
              return {
                message: defaultError
              };
            }
          } : {}
        });
      }
      strip() {
        return new _ZodObject({
          ...this._def,
          unknownKeys: "strip"
        });
      }
      passthrough() {
        return new _ZodObject({
          ...this._def,
          unknownKeys: "passthrough"
        });
      }
      // const AugmentFactory =
      //   <Def extends ZodObjectDef>(def: Def) =>
      //   <Augmentation extends ZodRawShape>(
      //     augmentation: Augmentation
      //   ): ZodObject<
      //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
      //     Def["unknownKeys"],
      //     Def["catchall"]
      //   > => {
      //     return new ZodObject({
      //       ...def,
      //       shape: () => ({
      //         ...def.shape(),
      //         ...augmentation,
      //       }),
      //     }) as any;
      //   };
      extend(augmentation) {
        return new _ZodObject({
          ...this._def,
          shape: () => ({
            ...this._def.shape(),
            ...augmentation
          })
        });
      }
      /**
       * Prior to zod@1.0.12 there was a bug in the
       * inferred type of merged objects. Please
       * upgrade if you are experiencing issues.
       */
      merge(merging) {
        const merged = new _ZodObject({
          unknownKeys: merging._def.unknownKeys,
          catchall: merging._def.catchall,
          shape: () => ({
            ...this._def.shape(),
            ...merging._def.shape()
          }),
          typeName: ZodFirstPartyTypeKind2.ZodObject
        });
        return merged;
      }
      // merge<
      //   Incoming extends AnyZodObject,
      //   Augmentation extends Incoming["shape"],
      //   NewOutput extends {
      //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
      //       ? Augmentation[k]["_output"]
      //       : k extends keyof Output
      //       ? Output[k]
      //       : never;
      //   },
      //   NewInput extends {
      //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
      //       ? Augmentation[k]["_input"]
      //       : k extends keyof Input
      //       ? Input[k]
      //       : never;
      //   }
      // >(
      //   merging: Incoming
      // ): ZodObject<
      //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
      //   Incoming["_def"]["unknownKeys"],
      //   Incoming["_def"]["catchall"],
      //   NewOutput,
      //   NewInput
      // > {
      //   const merged: any = new ZodObject({
      //     unknownKeys: merging._def.unknownKeys,
      //     catchall: merging._def.catchall,
      //     shape: () =>
      //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
      //     typeName: ZodFirstPartyTypeKind.ZodObject,
      //   }) as any;
      //   return merged;
      // }
      setKey(key, schema) {
        return this.augment({ [key]: schema });
      }
      // merge<Incoming extends AnyZodObject>(
      //   merging: Incoming
      // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
      // ZodObject<
      //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
      //   Incoming["_def"]["unknownKeys"],
      //   Incoming["_def"]["catchall"]
      // > {
      //   // const mergedShape = objectUtil.mergeShapes(
      //   //   this._def.shape(),
      //   //   merging._def.shape()
      //   // );
      //   const merged: any = new ZodObject({
      //     unknownKeys: merging._def.unknownKeys,
      //     catchall: merging._def.catchall,
      //     shape: () =>
      //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
      //     typeName: ZodFirstPartyTypeKind.ZodObject,
      //   }) as any;
      //   return merged;
      // }
      catchall(index) {
        return new _ZodObject({
          ...this._def,
          catchall: index
        });
      }
      pick(mask) {
        const shape = {};
        for (const key of util3.objectKeys(mask)) {
          if (mask[key] && this.shape[key]) {
            shape[key] = this.shape[key];
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => shape
        });
      }
      omit(mask) {
        const shape = {};
        for (const key of util3.objectKeys(this.shape)) {
          if (!mask[key]) {
            shape[key] = this.shape[key];
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => shape
        });
      }
      /**
       * @deprecated
       */
      deepPartial() {
        return deepPartialify(this);
      }
      partial(mask) {
        const newShape = {};
        for (const key of util3.objectKeys(this.shape)) {
          const fieldSchema = this.shape[key];
          if (mask && !mask[key]) {
            newShape[key] = fieldSchema;
          } else {
            newShape[key] = fieldSchema.optional();
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => newShape
        });
      }
      required(mask) {
        const newShape = {};
        for (const key of util3.objectKeys(this.shape)) {
          if (mask && !mask[key]) {
            newShape[key] = this.shape[key];
          } else {
            const fieldSchema = this.shape[key];
            let newField = fieldSchema;
            while (newField instanceof ZodOptional2) {
              newField = newField._def.innerType;
            }
            newShape[key] = newField;
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => newShape
        });
      }
      keyof() {
        return createZodEnum(util3.objectKeys(this.shape));
      }
    };
    ZodObject2.create = (shape, params) => {
      return new ZodObject2({
        shape: () => shape,
        unknownKeys: "strip",
        catchall: ZodNever2.create(),
        typeName: ZodFirstPartyTypeKind2.ZodObject,
        ...processCreateParams(params)
      });
    };
    ZodObject2.strictCreate = (shape, params) => {
      return new ZodObject2({
        shape: () => shape,
        unknownKeys: "strict",
        catchall: ZodNever2.create(),
        typeName: ZodFirstPartyTypeKind2.ZodObject,
        ...processCreateParams(params)
      });
    };
    ZodObject2.lazycreate = (shape, params) => {
      return new ZodObject2({
        shape,
        unknownKeys: "strip",
        catchall: ZodNever2.create(),
        typeName: ZodFirstPartyTypeKind2.ZodObject,
        ...processCreateParams(params)
      });
    };
    ZodUnion2 = class extends ZodType2 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const options = this._def.options;
        function handleResults(results) {
          for (const result of results) {
            if (result.result.status === "valid") {
              return result.result;
            }
          }
          for (const result of results) {
            if (result.result.status === "dirty") {
              ctx.common.issues.push(...result.ctx.common.issues);
              return result.result;
            }
          }
          const unionErrors = results.map((result) => new ZodError2(result.ctx.common.issues));
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_union,
            unionErrors
          });
          return INVALID;
        }
        if (ctx.common.async) {
          return Promise.all(options.map(async (option) => {
            const childCtx = {
              ...ctx,
              common: {
                ...ctx.common,
                issues: []
              },
              parent: null
            };
            return {
              result: await option._parseAsync({
                data: ctx.data,
                path: ctx.path,
                parent: childCtx
              }),
              ctx: childCtx
            };
          })).then(handleResults);
        } else {
          let dirty = void 0;
          const issues = [];
          for (const option of options) {
            const childCtx = {
              ...ctx,
              common: {
                ...ctx.common,
                issues: []
              },
              parent: null
            };
            const result = option._parseSync({
              data: ctx.data,
              path: ctx.path,
              parent: childCtx
            });
            if (result.status === "valid") {
              return result;
            } else if (result.status === "dirty" && !dirty) {
              dirty = { result, ctx: childCtx };
            }
            if (childCtx.common.issues.length) {
              issues.push(childCtx.common.issues);
            }
          }
          if (dirty) {
            ctx.common.issues.push(...dirty.ctx.common.issues);
            return dirty.result;
          }
          const unionErrors = issues.map((issues2) => new ZodError2(issues2));
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_union,
            unionErrors
          });
          return INVALID;
        }
      }
      get options() {
        return this._def.options;
      }
    };
    ZodUnion2.create = (types, params) => {
      return new ZodUnion2({
        options: types,
        typeName: ZodFirstPartyTypeKind2.ZodUnion,
        ...processCreateParams(params)
      });
    };
    getDiscriminator = (type) => {
      if (type instanceof ZodLazy2) {
        return getDiscriminator(type.schema);
      } else if (type instanceof ZodEffects) {
        return getDiscriminator(type.innerType());
      } else if (type instanceof ZodLiteral2) {
        return [type.value];
      } else if (type instanceof ZodEnum2) {
        return type.options;
      } else if (type instanceof ZodNativeEnum) {
        return util3.objectValues(type.enum);
      } else if (type instanceof ZodDefault2) {
        return getDiscriminator(type._def.innerType);
      } else if (type instanceof ZodUndefined2) {
        return [void 0];
      } else if (type instanceof ZodNull2) {
        return [null];
      } else if (type instanceof ZodOptional2) {
        return [void 0, ...getDiscriminator(type.unwrap())];
      } else if (type instanceof ZodNullable2) {
        return [null, ...getDiscriminator(type.unwrap())];
      } else if (type instanceof ZodBranded) {
        return getDiscriminator(type.unwrap());
      } else if (type instanceof ZodReadonly2) {
        return getDiscriminator(type.unwrap());
      } else if (type instanceof ZodCatch2) {
        return getDiscriminator(type._def.innerType);
      } else {
        return [];
      }
    };
    ZodDiscriminatedUnion2 = class _ZodDiscriminatedUnion extends ZodType2 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.object) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.object,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const discriminator = this.discriminator;
        const discriminatorValue = ctx.data[discriminator];
        const option = this.optionsMap.get(discriminatorValue);
        if (!option) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_union_discriminator,
            options: Array.from(this.optionsMap.keys()),
            path: [discriminator]
          });
          return INVALID;
        }
        if (ctx.common.async) {
          return option._parseAsync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          });
        } else {
          return option._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          });
        }
      }
      get discriminator() {
        return this._def.discriminator;
      }
      get options() {
        return this._def.options;
      }
      get optionsMap() {
        return this._def.optionsMap;
      }
      /**
       * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
       * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
       * have a different value for each object in the union.
       * @param discriminator the name of the discriminator property
       * @param types an array of object schemas
       * @param params
       */
      static create(discriminator, options, params) {
        const optionsMap = /* @__PURE__ */ new Map();
        for (const type of options) {
          const discriminatorValues = getDiscriminator(type.shape[discriminator]);
          if (!discriminatorValues.length) {
            throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
          }
          for (const value of discriminatorValues) {
            if (optionsMap.has(value)) {
              throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
            }
            optionsMap.set(value, type);
          }
        }
        return new _ZodDiscriminatedUnion({
          typeName: ZodFirstPartyTypeKind2.ZodDiscriminatedUnion,
          discriminator,
          options,
          optionsMap,
          ...processCreateParams(params)
        });
      }
    };
    ZodIntersection2 = class extends ZodType2 {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        const handleParsed = (parsedLeft, parsedRight) => {
          if (isAborted(parsedLeft) || isAborted(parsedRight)) {
            return INVALID;
          }
          const merged = mergeValues2(parsedLeft.value, parsedRight.value);
          if (!merged.valid) {
            addIssueToContext(ctx, {
              code: ZodIssueCode2.invalid_intersection_types
            });
            return INVALID;
          }
          if (isDirty(parsedLeft) || isDirty(parsedRight)) {
            status.dirty();
          }
          return { status: status.value, value: merged.data };
        };
        if (ctx.common.async) {
          return Promise.all([
            this._def.left._parseAsync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            }),
            this._def.right._parseAsync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            })
          ]).then(([left, right]) => handleParsed(left, right));
        } else {
          return handleParsed(this._def.left._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          }), this._def.right._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          }));
        }
      }
    };
    ZodIntersection2.create = (left, right, params) => {
      return new ZodIntersection2({
        left,
        right,
        typeName: ZodFirstPartyTypeKind2.ZodIntersection,
        ...processCreateParams(params)
      });
    };
    ZodTuple2 = class _ZodTuple extends ZodType2 {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.array) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.array,
            received: ctx.parsedType
          });
          return INVALID;
        }
        if (ctx.data.length < this._def.items.length) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.too_small,
            minimum: this._def.items.length,
            inclusive: true,
            exact: false,
            type: "array"
          });
          return INVALID;
        }
        const rest = this._def.rest;
        if (!rest && ctx.data.length > this._def.items.length) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.too_big,
            maximum: this._def.items.length,
            inclusive: true,
            exact: false,
            type: "array"
          });
          status.dirty();
        }
        const items = [...ctx.data].map((item, itemIndex) => {
          const schema = this._def.items[itemIndex] || this._def.rest;
          if (!schema)
            return null;
          return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
        }).filter((x) => !!x);
        if (ctx.common.async) {
          return Promise.all(items).then((results) => {
            return ParseStatus.mergeArray(status, results);
          });
        } else {
          return ParseStatus.mergeArray(status, items);
        }
      }
      get items() {
        return this._def.items;
      }
      rest(rest) {
        return new _ZodTuple({
          ...this._def,
          rest
        });
      }
    };
    ZodTuple2.create = (schemas, params) => {
      if (!Array.isArray(schemas)) {
        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
      }
      return new ZodTuple2({
        items: schemas,
        typeName: ZodFirstPartyTypeKind2.ZodTuple,
        rest: null,
        ...processCreateParams(params)
      });
    };
    ZodRecord2 = class _ZodRecord extends ZodType2 {
      get keySchema() {
        return this._def.keyType;
      }
      get valueSchema() {
        return this._def.valueType;
      }
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.object) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.object,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const pairs = [];
        const keyType = this._def.keyType;
        const valueType = this._def.valueType;
        for (const key in ctx.data) {
          pairs.push({
            key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
            value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
            alwaysSet: key in ctx.data
          });
        }
        if (ctx.common.async) {
          return ParseStatus.mergeObjectAsync(status, pairs);
        } else {
          return ParseStatus.mergeObjectSync(status, pairs);
        }
      }
      get element() {
        return this._def.valueType;
      }
      static create(first, second, third) {
        if (second instanceof ZodType2) {
          return new _ZodRecord({
            keyType: first,
            valueType: second,
            typeName: ZodFirstPartyTypeKind2.ZodRecord,
            ...processCreateParams(third)
          });
        }
        return new _ZodRecord({
          keyType: ZodString2.create(),
          valueType: first,
          typeName: ZodFirstPartyTypeKind2.ZodRecord,
          ...processCreateParams(second)
        });
      }
    };
    ZodMap2 = class extends ZodType2 {
      get keySchema() {
        return this._def.keyType;
      }
      get valueSchema() {
        return this._def.valueType;
      }
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.map) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.map,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const keyType = this._def.keyType;
        const valueType = this._def.valueType;
        const pairs = [...ctx.data.entries()].map(([key, value], index) => {
          return {
            key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
            value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
          };
        });
        if (ctx.common.async) {
          const finalMap = /* @__PURE__ */ new Map();
          return Promise.resolve().then(async () => {
            for (const pair of pairs) {
              const key = await pair.key;
              const value = await pair.value;
              if (key.status === "aborted" || value.status === "aborted") {
                return INVALID;
              }
              if (key.status === "dirty" || value.status === "dirty") {
                status.dirty();
              }
              finalMap.set(key.value, value.value);
            }
            return { status: status.value, value: finalMap };
          });
        } else {
          const finalMap = /* @__PURE__ */ new Map();
          for (const pair of pairs) {
            const key = pair.key;
            const value = pair.value;
            if (key.status === "aborted" || value.status === "aborted") {
              return INVALID;
            }
            if (key.status === "dirty" || value.status === "dirty") {
              status.dirty();
            }
            finalMap.set(key.value, value.value);
          }
          return { status: status.value, value: finalMap };
        }
      }
    };
    ZodMap2.create = (keyType, valueType, params) => {
      return new ZodMap2({
        valueType,
        keyType,
        typeName: ZodFirstPartyTypeKind2.ZodMap,
        ...processCreateParams(params)
      });
    };
    ZodSet2 = class _ZodSet extends ZodType2 {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.set) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.set,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const def = this._def;
        if (def.minSize !== null) {
          if (ctx.data.size < def.minSize.value) {
            addIssueToContext(ctx, {
              code: ZodIssueCode2.too_small,
              minimum: def.minSize.value,
              type: "set",
              inclusive: true,
              exact: false,
              message: def.minSize.message
            });
            status.dirty();
          }
        }
        if (def.maxSize !== null) {
          if (ctx.data.size > def.maxSize.value) {
            addIssueToContext(ctx, {
              code: ZodIssueCode2.too_big,
              maximum: def.maxSize.value,
              type: "set",
              inclusive: true,
              exact: false,
              message: def.maxSize.message
            });
            status.dirty();
          }
        }
        const valueType = this._def.valueType;
        function finalizeSet(elements2) {
          const parsedSet = /* @__PURE__ */ new Set();
          for (const element of elements2) {
            if (element.status === "aborted")
              return INVALID;
            if (element.status === "dirty")
              status.dirty();
            parsedSet.add(element.value);
          }
          return { status: status.value, value: parsedSet };
        }
        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
        if (ctx.common.async) {
          return Promise.all(elements).then((elements2) => finalizeSet(elements2));
        } else {
          return finalizeSet(elements);
        }
      }
      min(minSize, message) {
        return new _ZodSet({
          ...this._def,
          minSize: { value: minSize, message: errorUtil.toString(message) }
        });
      }
      max(maxSize, message) {
        return new _ZodSet({
          ...this._def,
          maxSize: { value: maxSize, message: errorUtil.toString(message) }
        });
      }
      size(size, message) {
        return this.min(size, message).max(size, message);
      }
      nonempty(message) {
        return this.min(1, message);
      }
    };
    ZodSet2.create = (valueType, params) => {
      return new ZodSet2({
        valueType,
        minSize: null,
        maxSize: null,
        typeName: ZodFirstPartyTypeKind2.ZodSet,
        ...processCreateParams(params)
      });
    };
    ZodFunction2 = class _ZodFunction extends ZodType2 {
      constructor() {
        super(...arguments);
        this.validate = this.implement;
      }
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.function) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.function,
            received: ctx.parsedType
          });
          return INVALID;
        }
        function makeArgsIssue(args, error73) {
          return makeIssue({
            data: args,
            path: ctx.path,
            errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap2(), en_default2].filter((x) => !!x),
            issueData: {
              code: ZodIssueCode2.invalid_arguments,
              argumentsError: error73
            }
          });
        }
        function makeReturnsIssue(returns, error73) {
          return makeIssue({
            data: returns,
            path: ctx.path,
            errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap2(), en_default2].filter((x) => !!x),
            issueData: {
              code: ZodIssueCode2.invalid_return_type,
              returnTypeError: error73
            }
          });
        }
        const params = { errorMap: ctx.common.contextualErrorMap };
        const fn = ctx.data;
        if (this._def.returns instanceof ZodPromise2) {
          const me = this;
          return OK(async function(...args) {
            const error73 = new ZodError2([]);
            const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
              error73.addIssue(makeArgsIssue(args, e));
              throw error73;
            });
            const result = await Reflect.apply(fn, this, parsedArgs);
            const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
              error73.addIssue(makeReturnsIssue(result, e));
              throw error73;
            });
            return parsedReturns;
          });
        } else {
          const me = this;
          return OK(function(...args) {
            const parsedArgs = me._def.args.safeParse(args, params);
            if (!parsedArgs.success) {
              throw new ZodError2([makeArgsIssue(args, parsedArgs.error)]);
            }
            const result = Reflect.apply(fn, this, parsedArgs.data);
            const parsedReturns = me._def.returns.safeParse(result, params);
            if (!parsedReturns.success) {
              throw new ZodError2([makeReturnsIssue(result, parsedReturns.error)]);
            }
            return parsedReturns.data;
          });
        }
      }
      parameters() {
        return this._def.args;
      }
      returnType() {
        return this._def.returns;
      }
      args(...items) {
        return new _ZodFunction({
          ...this._def,
          args: ZodTuple2.create(items).rest(ZodUnknown2.create())
        });
      }
      returns(returnType) {
        return new _ZodFunction({
          ...this._def,
          returns: returnType
        });
      }
      implement(func) {
        const validatedFunc = this.parse(func);
        return validatedFunc;
      }
      strictImplement(func) {
        const validatedFunc = this.parse(func);
        return validatedFunc;
      }
      static create(args, returns, params) {
        return new _ZodFunction({
          args: args ? args : ZodTuple2.create([]).rest(ZodUnknown2.create()),
          returns: returns || ZodUnknown2.create(),
          typeName: ZodFirstPartyTypeKind2.ZodFunction,
          ...processCreateParams(params)
        });
      }
    };
    ZodLazy2 = class extends ZodType2 {
      get schema() {
        return this._def.getter();
      }
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const lazySchema3 = this._def.getter();
        return lazySchema3._parse({ data: ctx.data, path: ctx.path, parent: ctx });
      }
    };
    ZodLazy2.create = (getter, params) => {
      return new ZodLazy2({
        getter,
        typeName: ZodFirstPartyTypeKind2.ZodLazy,
        ...processCreateParams(params)
      });
    };
    ZodLiteral2 = class extends ZodType2 {
      _parse(input) {
        if (input.data !== this._def.value) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            received: ctx.data,
            code: ZodIssueCode2.invalid_literal,
            expected: this._def.value
          });
          return INVALID;
        }
        return { status: "valid", value: input.data };
      }
      get value() {
        return this._def.value;
      }
    };
    ZodLiteral2.create = (value, params) => {
      return new ZodLiteral2({
        value,
        typeName: ZodFirstPartyTypeKind2.ZodLiteral,
        ...processCreateParams(params)
      });
    };
    ZodEnum2 = class _ZodEnum extends ZodType2 {
      _parse(input) {
        if (typeof input.data !== "string") {
          const ctx = this._getOrReturnCtx(input);
          const expectedValues = this._def.values;
          addIssueToContext(ctx, {
            expected: util3.joinValues(expectedValues),
            received: ctx.parsedType,
            code: ZodIssueCode2.invalid_type
          });
          return INVALID;
        }
        if (!this._cache) {
          this._cache = new Set(this._def.values);
        }
        if (!this._cache.has(input.data)) {
          const ctx = this._getOrReturnCtx(input);
          const expectedValues = this._def.values;
          addIssueToContext(ctx, {
            received: ctx.data,
            code: ZodIssueCode2.invalid_enum_value,
            options: expectedValues
          });
          return INVALID;
        }
        return OK(input.data);
      }
      get options() {
        return this._def.values;
      }
      get enum() {
        const enumValues = {};
        for (const val of this._def.values) {
          enumValues[val] = val;
        }
        return enumValues;
      }
      get Values() {
        const enumValues = {};
        for (const val of this._def.values) {
          enumValues[val] = val;
        }
        return enumValues;
      }
      get Enum() {
        const enumValues = {};
        for (const val of this._def.values) {
          enumValues[val] = val;
        }
        return enumValues;
      }
      extract(values, newDef = this._def) {
        return _ZodEnum.create(values, {
          ...this._def,
          ...newDef
        });
      }
      exclude(values, newDef = this._def) {
        return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
          ...this._def,
          ...newDef
        });
      }
    };
    ZodEnum2.create = createZodEnum;
    ZodNativeEnum = class extends ZodType2 {
      _parse(input) {
        const nativeEnumValues = util3.getValidEnumValues(this._def.values);
        const ctx = this._getOrReturnCtx(input);
        if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
          const expectedValues = util3.objectValues(nativeEnumValues);
          addIssueToContext(ctx, {
            expected: util3.joinValues(expectedValues),
            received: ctx.parsedType,
            code: ZodIssueCode2.invalid_type
          });
          return INVALID;
        }
        if (!this._cache) {
          this._cache = new Set(util3.getValidEnumValues(this._def.values));
        }
        if (!this._cache.has(input.data)) {
          const expectedValues = util3.objectValues(nativeEnumValues);
          addIssueToContext(ctx, {
            received: ctx.data,
            code: ZodIssueCode2.invalid_enum_value,
            options: expectedValues
          });
          return INVALID;
        }
        return OK(input.data);
      }
      get enum() {
        return this._def.values;
      }
    };
    ZodNativeEnum.create = (values, params) => {
      return new ZodNativeEnum({
        values,
        typeName: ZodFirstPartyTypeKind2.ZodNativeEnum,
        ...processCreateParams(params)
      });
    };
    ZodPromise2 = class extends ZodType2 {
      unwrap() {
        return this._def.type;
      }
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.promise,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
        return OK(promisified.then((data) => {
          return this._def.type.parseAsync(data, {
            path: ctx.path,
            errorMap: ctx.common.contextualErrorMap
          });
        }));
      }
    };
    ZodPromise2.create = (schema, params) => {
      return new ZodPromise2({
        type: schema,
        typeName: ZodFirstPartyTypeKind2.ZodPromise,
        ...processCreateParams(params)
      });
    };
    ZodEffects = class extends ZodType2 {
      innerType() {
        return this._def.schema;
      }
      sourceType() {
        return this._def.schema._def.typeName === ZodFirstPartyTypeKind2.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
      }
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        const effect = this._def.effect || null;
        const checkCtx = {
          addIssue: (arg) => {
            addIssueToContext(ctx, arg);
            if (arg.fatal) {
              status.abort();
            } else {
              status.dirty();
            }
          },
          get path() {
            return ctx.path;
          }
        };
        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
        if (effect.type === "preprocess") {
          const processed = effect.transform(ctx.data, checkCtx);
          if (ctx.common.async) {
            return Promise.resolve(processed).then(async (processed2) => {
              if (status.value === "aborted")
                return INVALID;
              const result = await this._def.schema._parseAsync({
                data: processed2,
                path: ctx.path,
                parent: ctx
              });
              if (result.status === "aborted")
                return INVALID;
              if (result.status === "dirty")
                return DIRTY(result.value);
              if (status.value === "dirty")
                return DIRTY(result.value);
              return result;
            });
          } else {
            if (status.value === "aborted")
              return INVALID;
            const result = this._def.schema._parseSync({
              data: processed,
              path: ctx.path,
              parent: ctx
            });
            if (result.status === "aborted")
              return INVALID;
            if (result.status === "dirty")
              return DIRTY(result.value);
            if (status.value === "dirty")
              return DIRTY(result.value);
            return result;
          }
        }
        if (effect.type === "refinement") {
          const executeRefinement = (acc) => {
            const result = effect.refinement(acc, checkCtx);
            if (ctx.common.async) {
              return Promise.resolve(result);
            }
            if (result instanceof Promise) {
              throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
            }
            return acc;
          };
          if (ctx.common.async === false) {
            const inner = this._def.schema._parseSync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            });
            if (inner.status === "aborted")
              return INVALID;
            if (inner.status === "dirty")
              status.dirty();
            executeRefinement(inner.value);
            return { status: status.value, value: inner.value };
          } else {
            return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
              if (inner.status === "aborted")
                return INVALID;
              if (inner.status === "dirty")
                status.dirty();
              return executeRefinement(inner.value).then(() => {
                return { status: status.value, value: inner.value };
              });
            });
          }
        }
        if (effect.type === "transform") {
          if (ctx.common.async === false) {
            const base = this._def.schema._parseSync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            });
            if (!isValid(base))
              return INVALID;
            const result = effect.transform(base.value, checkCtx);
            if (result instanceof Promise) {
              throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
            }
            return { status: status.value, value: result };
          } else {
            return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
              if (!isValid(base))
                return INVALID;
              return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
                status: status.value,
                value: result
              }));
            });
          }
        }
        util3.assertNever(effect);
      }
    };
    ZodEffects.create = (schema, effect, params) => {
      return new ZodEffects({
        schema,
        typeName: ZodFirstPartyTypeKind2.ZodEffects,
        effect,
        ...processCreateParams(params)
      });
    };
    ZodEffects.createWithPreprocess = (preprocess3, schema, params) => {
      return new ZodEffects({
        schema,
        effect: { type: "preprocess", transform: preprocess3 },
        typeName: ZodFirstPartyTypeKind2.ZodEffects,
        ...processCreateParams(params)
      });
    };
    ZodOptional2 = class extends ZodType2 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 === ZodParsedType.undefined) {
          return OK(void 0);
        }
        return this._def.innerType._parse(input);
      }
      unwrap() {
        return this._def.innerType;
      }
    };
    ZodOptional2.create = (type, params) => {
      return new ZodOptional2({
        innerType: type,
        typeName: ZodFirstPartyTypeKind2.ZodOptional,
        ...processCreateParams(params)
      });
    };
    ZodNullable2 = class extends ZodType2 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 === ZodParsedType.null) {
          return OK(null);
        }
        return this._def.innerType._parse(input);
      }
      unwrap() {
        return this._def.innerType;
      }
    };
    ZodNullable2.create = (type, params) => {
      return new ZodNullable2({
        innerType: type,
        typeName: ZodFirstPartyTypeKind2.ZodNullable,
        ...processCreateParams(params)
      });
    };
    ZodDefault2 = class extends ZodType2 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        let data = ctx.data;
        if (ctx.parsedType === ZodParsedType.undefined) {
          data = this._def.defaultValue();
        }
        return this._def.innerType._parse({
          data,
          path: ctx.path,
          parent: ctx
        });
      }
      removeDefault() {
        return this._def.innerType;
      }
    };
    ZodDefault2.create = (type, params) => {
      return new ZodDefault2({
        innerType: type,
        typeName: ZodFirstPartyTypeKind2.ZodDefault,
        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
        ...processCreateParams(params)
      });
    };
    ZodCatch2 = class extends ZodType2 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const newCtx = {
          ...ctx,
          common: {
            ...ctx.common,
            issues: []
          }
        };
        const result = this._def.innerType._parse({
          data: newCtx.data,
          path: newCtx.path,
          parent: {
            ...newCtx
          }
        });
        if (isAsync(result)) {
          return result.then((result2) => {
            return {
              status: "valid",
              value: result2.status === "valid" ? result2.value : this._def.catchValue({
                get error() {
                  return new ZodError2(newCtx.common.issues);
                },
                input: newCtx.data
              })
            };
          });
        } else {
          return {
            status: "valid",
            value: result.status === "valid" ? result.value : this._def.catchValue({
              get error() {
                return new ZodError2(newCtx.common.issues);
              },
              input: newCtx.data
            })
          };
        }
      }
      removeCatch() {
        return this._def.innerType;
      }
    };
    ZodCatch2.create = (type, params) => {
      return new ZodCatch2({
        innerType: type,
        typeName: ZodFirstPartyTypeKind2.ZodCatch,
        catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
        ...processCreateParams(params)
      });
    };
    ZodNaN2 = class extends ZodType2 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== ZodParsedType.nan) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode2.invalid_type,
            expected: ZodParsedType.nan,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return { status: "valid", value: input.data };
      }
    };
    ZodNaN2.create = (params) => {
      return new ZodNaN2({
        typeName: ZodFirstPartyTypeKind2.ZodNaN,
        ...processCreateParams(params)
      });
    };
    ZodBranded = class extends ZodType2 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const data = ctx.data;
        return this._def.type._parse({
          data,
          path: ctx.path,
          parent: ctx
        });
      }
      unwrap() {
        return this._def.type;
      }
    };
    ZodPipeline = class _ZodPipeline extends ZodType2 {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.common.async) {
          const handleAsync = async () => {
            const inResult = await this._def.in._parseAsync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            });
            if (inResult.status === "aborted")
              return INVALID;
            if (inResult.status === "dirty") {
              status.dirty();
              return DIRTY(inResult.value);
            } else {
              return this._def.out._parseAsync({
                data: inResult.value,
                path: ctx.path,
                parent: ctx
              });
            }
          };
          return handleAsync();
        } else {
          const inResult = this._def.in._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          });
          if (inResult.status === "aborted")
            return INVALID;
          if (inResult.status === "dirty") {
            status.dirty();
            return {
              status: "dirty",
              value: inResult.value
            };
          } else {
            return this._def.out._parseSync({
              data: inResult.value,
              path: ctx.path,
              parent: ctx
            });
          }
        }
      }
      static create(a, b) {
        return new _ZodPipeline({
          in: a,
          out: b,
          typeName: ZodFirstPartyTypeKind2.ZodPipeline
        });
      }
    };
    ZodReadonly2 = class extends ZodType2 {
      _parse(input) {
        const result = this._def.innerType._parse(input);
        const freeze = (data) => {
          if (isValid(data)) {
            data.value = Object.freeze(data.value);
          }
          return data;
        };
        return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
      }
      unwrap() {
        return this._def.innerType;
      }
    };
    ZodReadonly2.create = (type, params) => {
      return new ZodReadonly2({
        innerType: type,
        typeName: ZodFirstPartyTypeKind2.ZodReadonly,
        ...processCreateParams(params)
      });
    };
    late = {
      object: ZodObject2.lazycreate
    };
    (function(ZodFirstPartyTypeKind4) {
      ZodFirstPartyTypeKind4["ZodString"] = "ZodString";
      ZodFirstPartyTypeKind4["ZodNumber"] = "ZodNumber";
      ZodFirstPartyTypeKind4["ZodNaN"] = "ZodNaN";
      ZodFirstPartyTypeKind4["ZodBigInt"] = "ZodBigInt";
      ZodFirstPartyTypeKind4["ZodBoolean"] = "ZodBoolean";
      ZodFirstPartyTypeKind4["ZodDate"] = "ZodDate";
      ZodFirstPartyTypeKind4["ZodSymbol"] = "ZodSymbol";
      ZodFirstPartyTypeKind4["ZodUndefined"] = "ZodUndefined";
      ZodFirstPartyTypeKind4["ZodNull"] = "ZodNull";
      ZodFirstPartyTypeKind4["ZodAny"] = "ZodAny";
      ZodFirstPartyTypeKind4["ZodUnknown"] = "ZodUnknown";
      ZodFirstPartyTypeKind4["ZodNever"] = "ZodNever";
      ZodFirstPartyTypeKind4["ZodVoid"] = "ZodVoid";
      ZodFirstPartyTypeKind4["ZodArray"] = "ZodArray";
      ZodFirstPartyTypeKind4["ZodObject"] = "ZodObject";
      ZodFirstPartyTypeKind4["ZodUnion"] = "ZodUnion";
      ZodFirstPartyTypeKind4["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
      ZodFirstPartyTypeKind4["ZodIntersection"] = "ZodIntersection";
      ZodFirstPartyTypeKind4["ZodTuple"] = "ZodTuple";
      ZodFirstPartyTypeKind4["ZodRecord"] = "ZodRecord";
      ZodFirstPartyTypeKind4["ZodMap"] = "ZodMap";
      ZodFirstPartyTypeKind4["ZodSet"] = "ZodSet";
      ZodFirstPartyTypeKind4["ZodFunction"] = "ZodFunction";
      ZodFirstPartyTypeKind4["ZodLazy"] = "ZodLazy";
      ZodFirstPartyTypeKind4["ZodLiteral"] = "ZodLiteral";
      ZodFirstPartyTypeKind4["ZodEnum"] = "ZodEnum";
      ZodFirstPartyTypeKind4["ZodEffects"] = "ZodEffects";
      ZodFirstPartyTypeKind4["ZodNativeEnum"] = "ZodNativeEnum";
      ZodFirstPartyTypeKind4["ZodOptional"] = "ZodOptional";
      ZodFirstPartyTypeKind4["ZodNullable"] = "ZodNullable";
      ZodFirstPartyTypeKind4["ZodDefault"] = "ZodDefault";
      ZodFirstPartyTypeKind4["ZodCatch"] = "ZodCatch";
      ZodFirstPartyTypeKind4["ZodPromise"] = "ZodPromise";
      ZodFirstPartyTypeKind4["ZodBranded"] = "ZodBranded";
      ZodFirstPartyTypeKind4["ZodPipeline"] = "ZodPipeline";
      ZodFirstPartyTypeKind4["ZodReadonly"] = "ZodReadonly";
    })(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {}));
    stringType = ZodString2.create;
    numberType = ZodNumber2.create;
    nanType = ZodNaN2.create;
    bigIntType = ZodBigInt2.create;
    booleanType = ZodBoolean2.create;
    dateType = ZodDate2.create;
    symbolType = ZodSymbol2.create;
    undefinedType = ZodUndefined2.create;
    nullType = ZodNull2.create;
    anyType = ZodAny2.create;
    unknownType = ZodUnknown2.create;
    neverType = ZodNever2.create;
    voidType = ZodVoid2.create;
    arrayType = ZodArray2.create;
    objectType = ZodObject2.create;
    strictObjectType = ZodObject2.strictCreate;
    unionType = ZodUnion2.create;
    discriminatedUnionType = ZodDiscriminatedUnion2.create;
    intersectionType = ZodIntersection2.create;
    tupleType = ZodTuple2.create;
    recordType = ZodRecord2.create;
    mapType = ZodMap2.create;
    setType = ZodSet2.create;
    functionType = ZodFunction2.create;
    lazyType = ZodLazy2.create;
    literalType = ZodLiteral2.create;
    enumType = ZodEnum2.create;
    nativeEnumType = ZodNativeEnum.create;
    promiseType = ZodPromise2.create;
    effectsType = ZodEffects.create;
    optionalType = ZodOptional2.create;
    nullableType = ZodNullable2.create;
    preprocessType = ZodEffects.createWithPreprocess;
    pipelineType = ZodPipeline.create;
  }
});

// node_modules/zod/v3/external.js
var init_external2 = __esm({
  "node_modules/zod/v3/external.js"() {
    "use strict";
    init_errors3();
    init_parseUtil();
    init_typeAliases();
    init_util2();
    init_types();
    init_ZodError();
  }
});

// node_modules/zod/v3/index.js
var init_v3 = __esm({
  "node_modules/zod/v3/index.js"() {
    "use strict";
    init_external2();
    init_external2();
  }
});

// node_modules/eventsource-parser/dist/index.js
function noop3(_arg) {
}
function createParser(callbacks) {
  if (typeof callbacks == "function")
    throw new TypeError(
      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
    );
  const { onEvent = noop3, onError = noop3, onRetry = noop3, onComment } = callbacks;
  let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
  function feed(newChunk) {
    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
    for (const line of complete)
      parseLine(line);
    incompleteLine = incomplete, isFirstChunk = false;
  }
  function parseLine(line) {
    if (line === "") {
      dispatchEvent();
      return;
    }
    if (line.startsWith(":")) {
      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
      return;
    }
    const fieldSeparatorIndex = line.indexOf(":");
    if (fieldSeparatorIndex !== -1) {
      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
      processField(field, value, line);
      return;
    }
    processField(line, "", line);
  }
  function processField(field, value, line) {
    switch (field) {
      case "event":
        eventType = value;
        break;
      case "data":
        data = `${data}${value}
`;
        break;
      case "id":
        id = value.includes("\0") ? void 0 : value;
        break;
      case "retry":
        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
          new ParseError(`Invalid \`retry\` value: "${value}"`, {
            type: "invalid-retry",
            value,
            line
          })
        );
        break;
      default:
        onError(
          new ParseError(
            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
            { type: "unknown-field", field, value, line }
          )
        );
        break;
    }
  }
  function dispatchEvent() {
    data.length > 0 && onEvent({
      id,
      event: eventType || void 0,
      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
      // then remove the last character from the data buffer.
      data: data.endsWith(`
`) ? data.slice(0, -1) : data
    }), id = void 0, data = "", eventType = "";
  }
  function reset(options = {}) {
    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
  }
  return { feed, reset };
}
function splitLines(chunk) {
  const lines = [];
  let incompleteLine = "", searchIndex = 0;
  for (; searchIndex < chunk.length; ) {
    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
`, searchIndex);
    let lineEnd = -1;
    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
      incompleteLine = chunk.slice(searchIndex);
      break;
    } else {
      const line = chunk.slice(searchIndex, lineEnd);
      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
` && searchIndex++;
    }
  }
  return [lines, incompleteLine];
}
var ParseError;
var init_dist4 = __esm({
  "node_modules/eventsource-parser/dist/index.js"() {
    "use strict";
    ParseError = class extends Error {
      constructor(message, options) {
        super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
      }
    };
  }
});

// node_modules/eventsource-parser/dist/stream.js
var EventSourceParserStream2;
var init_stream = __esm({
  "node_modules/eventsource-parser/dist/stream.js"() {
    "use strict";
    init_dist4();
    EventSourceParserStream2 = class extends TransformStream {
      constructor({ onError, onRetry, onComment } = {}) {
        let parser;
        super({
          start(controller) {
            parser = createParser({
              onEvent: (event) => {
                controller.enqueue(event);
              },
              onError(error73) {
                onError === "terminate" ? controller.error(error73) : typeof onError == "function" && onError(error73);
              },
              onRetry,
              onComment
            });
          },
          transform(chunk) {
            parser.feed(chunk);
          }
        });
      }
    };
  }
});

// node_modules/@ai-sdk/provider-utils/dist/index.mjs
function combineHeaders(...headers) {
  return headers.reduce(
    (combinedHeaders, currentHeaders) => ({
      ...combinedHeaders,
      ...currentHeaders != null ? currentHeaders : {}
    }),
    {}
  );
}
function createToolNameMapping({
  tools = [],
  providerToolNames,
  resolveProviderToolName
}) {
  var _a211;
  const customToolNameToProviderToolName = {};
  const providerToolNameToCustomToolName = {};
  for (const tool22 of tools) {
    if (tool22.type === "provider") {
      const providerToolName = (_a211 = resolveProviderToolName == null ? void 0 : resolveProviderToolName(tool22)) != null ? _a211 : tool22.id in providerToolNames ? providerToolNames[tool22.id] : void 0;
      if (providerToolName == null) {
        continue;
      }
      customToolNameToProviderToolName[tool22.name] = providerToolName;
      providerToolNameToCustomToolName[providerToolName] = tool22.name;
    }
  }
  return {
    toProviderToolName: (customToolName) => {
      var _a37;
      return (_a37 = customToolNameToProviderToolName[customToolName]) != null ? _a37 : customToolName;
    },
    toCustomToolName: (providerToolName) => {
      var _a37;
      return (_a37 = providerToolNameToCustomToolName[providerToolName]) != null ? _a37 : providerToolName;
    }
  };
}
async function delay(delayInMs, options) {
  if (delayInMs == null) {
    return Promise.resolve();
  }
  const signal = options == null ? void 0 : options.abortSignal;
  return new Promise((resolve22, reject) => {
    if (signal == null ? void 0 : signal.aborted) {
      reject(createAbortError());
      return;
    }
    const timeoutId = setTimeout(() => {
      cleanup();
      resolve22();
    }, delayInMs);
    const cleanup = () => {
      clearTimeout(timeoutId);
      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
    };
    const onAbort = () => {
      cleanup();
      reject(createAbortError());
    };
    signal == null ? void 0 : signal.addEventListener("abort", onAbort);
  });
}
function createAbortError() {
  return new DOMException("Delay was aborted", "AbortError");
}
function extractResponseHeaders(response) {
  return Object.fromEntries([...response.headers]);
}
function convertBase64ToUint8Array(base64String) {
  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
  const latin1string = atob2(base64Url);
  return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
}
function convertUint8ArrayToBase64(array4) {
  let latin1string = "";
  for (let i = 0; i < array4.length; i++) {
    latin1string += String.fromCodePoint(array4[i]);
  }
  return btoa2(latin1string);
}
function convertToBase64(value) {
  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
}
function convertImageModelFileToDataUri(file3) {
  if (file3.type === "url") return file3.url;
  return `data:${file3.mediaType};base64,${typeof file3.data === "string" ? file3.data : convertUint8ArrayToBase64(file3.data)}`;
}
function convertToFormData(input, options = {}) {
  const { useArrayBrackets = true } = options;
  const formData = new FormData();
  for (const [key, value] of Object.entries(input)) {
    if (value == null) {
      continue;
    }
    if (Array.isArray(value)) {
      if (value.length === 1) {
        formData.append(key, value[0]);
        continue;
      }
      const arrayKey = useArrayBrackets ? `${key}[]` : key;
      for (const item of value) {
        formData.append(arrayKey, item);
      }
      continue;
    }
    formData.append(key, value);
  }
  return formData;
}
async function readResponseWithSizeLimit({
  response,
  url: url4,
  maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE
}) {
  const contentLength = response.headers.get("content-length");
  if (contentLength != null) {
    const length = parseInt(contentLength, 10);
    if (!isNaN(length) && length > maxBytes) {
      throw new DownloadError({
        url: url4,
        message: `Download of ${url4} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
      });
    }
  }
  const body = response.body;
  if (body == null) {
    return new Uint8Array(0);
  }
  const reader = body.getReader();
  const chunks = [];
  let totalBytes = 0;
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      totalBytes += value.length;
      if (totalBytes > maxBytes) {
        throw new DownloadError({
          url: url4,
          message: `Download of ${url4} exceeded maximum size of ${maxBytes} bytes.`
        });
      }
      chunks.push(value);
    }
  } finally {
    try {
      await reader.cancel();
    } finally {
      reader.releaseLock();
    }
  }
  const result = new Uint8Array(totalBytes);
  let offset = 0;
  for (const chunk of chunks) {
    result.set(chunk, offset);
    offset += chunk.length;
  }
  return result;
}
function validateDownloadUrl(url4) {
  let parsed;
  try {
    parsed = new URL(url4);
  } catch (e) {
    throw new DownloadError({
      url: url4,
      message: `Invalid URL: ${url4}`
    });
  }
  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
    throw new DownloadError({
      url: url4,
      message: `URL scheme must be http or https, got ${parsed.protocol}`
    });
  }
  const hostname4 = parsed.hostname;
  if (!hostname4) {
    throw new DownloadError({
      url: url4,
      message: `URL must have a hostname`
    });
  }
  if (hostname4 === "localhost" || hostname4.endsWith(".local") || hostname4.endsWith(".localhost")) {
    throw new DownloadError({
      url: url4,
      message: `URL with hostname ${hostname4} is not allowed`
    });
  }
  if (hostname4.startsWith("[") && hostname4.endsWith("]")) {
    const ipv64 = hostname4.slice(1, -1);
    if (isPrivateIPv6(ipv64)) {
      throw new DownloadError({
        url: url4,
        message: `URL with IPv6 address ${hostname4} is not allowed`
      });
    }
    return;
  }
  if (isIPv4(hostname4)) {
    if (isPrivateIPv4(hostname4)) {
      throw new DownloadError({
        url: url4,
        message: `URL with IP address ${hostname4} is not allowed`
      });
    }
    return;
  }
}
function isIPv4(hostname4) {
  const parts = hostname4.split(".");
  if (parts.length !== 4) return false;
  return parts.every((part) => {
    const num = Number(part);
    return Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part;
  });
}
function isPrivateIPv4(ip) {
  const parts = ip.split(".").map(Number);
  const [a, b] = parts;
  if (a === 0) return true;
  if (a === 10) return true;
  if (a === 127) return true;
  if (a === 169 && b === 254) return true;
  if (a === 172 && b >= 16 && b <= 31) return true;
  if (a === 192 && b === 168) return true;
  return false;
}
function isPrivateIPv6(ip) {
  const normalized = ip.toLowerCase();
  if (normalized === "::1") return true;
  if (normalized === "::") return true;
  if (normalized.startsWith("::ffff:")) {
    const mappedPart = normalized.slice(7);
    if (isIPv4(mappedPart)) {
      return isPrivateIPv4(mappedPart);
    }
    const hexParts = mappedPart.split(":");
    if (hexParts.length === 2) {
      const high = parseInt(hexParts[0], 16);
      const low = parseInt(hexParts[1], 16);
      if (!isNaN(high) && !isNaN(low)) {
        const a = high >> 8 & 255;
        const b = high & 255;
        const c = low >> 8 & 255;
        const d = low & 255;
        return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
      }
    }
  }
  if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
  if (normalized.startsWith("fe80")) return true;
  return false;
}
async function downloadBlob(url4, options) {
  var _a211, _b27;
  validateDownloadUrl(url4);
  try {
    const response = await fetch(url4, {
      signal: options == null ? void 0 : options.abortSignal
    });
    if (response.redirected) {
      validateDownloadUrl(response.url);
    }
    if (!response.ok) {
      throw new DownloadError({
        url: url4,
        statusCode: response.status,
        statusText: response.statusText
      });
    }
    const data = await readResponseWithSizeLimit({
      response,
      url: url4,
      maxBytes: (_a211 = options == null ? void 0 : options.maxBytes) != null ? _a211 : DEFAULT_MAX_DOWNLOAD_SIZE
    });
    const contentType = (_b27 = response.headers.get("content-type")) != null ? _b27 : void 0;
    return new Blob([data], contentType ? { type: contentType } : void 0);
  } catch (error73) {
    if (DownloadError.isInstance(error73)) {
      throw error73;
    }
    throw new DownloadError({ url: url4, cause: error73 });
  }
}
function getErrorMessage2(error73) {
  if (error73 == null) {
    return "unknown error";
  }
  if (typeof error73 === "string") {
    return error73;
  }
  if (error73 instanceof Error) {
    return error73.message;
  }
  return JSON.stringify(error73);
}
function isAbortError(error73) {
  return (error73 instanceof Error || error73 instanceof DOMException) && (error73.name === "AbortError" || error73.name === "ResponseAborted" || // Next.js
  error73.name === "TimeoutError");
}
function isBunNetworkError(error73) {
  if (!(error73 instanceof Error)) {
    return false;
  }
  const code = error73.code;
  if (typeof code === "string" && BUN_ERROR_CODES.includes(code)) {
    return true;
  }
  return false;
}
function handleFetchError({
  error: error73,
  url: url4,
  requestBodyValues
}) {
  if (isAbortError(error73)) {
    return error73;
  }
  if (error73 instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error73.message.toLowerCase())) {
    const cause = error73.cause;
    if (cause != null) {
      return new APICallError({
        message: `Cannot connect to API: ${cause.message}`,
        cause,
        url: url4,
        requestBodyValues,
        isRetryable: true
        // retry when network error
      });
    }
  }
  if (isBunNetworkError(error73)) {
    return new APICallError({
      message: `Cannot connect to API: ${error73.message}`,
      cause: error73,
      url: url4,
      requestBodyValues,
      isRetryable: true
    });
  }
  return error73;
}
function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
  var _a211, _b27, _c;
  if (globalThisAny.window) {
    return `runtime/browser`;
  }
  if ((_a211 = globalThisAny.navigator) == null ? void 0 : _a211.userAgent) {
    return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
  }
  if ((_c = (_b27 = globalThisAny.process) == null ? void 0 : _b27.versions) == null ? void 0 : _c.node) {
    return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
  }
  if (globalThisAny.EdgeRuntime) {
    return `runtime/vercel-edge`;
  }
  return "runtime/unknown";
}
function normalizeHeaders(headers) {
  if (headers == null) {
    return {};
  }
  const normalized = {};
  if (headers instanceof Headers) {
    headers.forEach((value, key) => {
      normalized[key.toLowerCase()] = value;
    });
  } else {
    if (!Array.isArray(headers)) {
      headers = Object.entries(headers);
    }
    for (const [key, value] of headers) {
      if (value != null) {
        normalized[key.toLowerCase()] = value;
      }
    }
  }
  return normalized;
}
function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
  const normalizedHeaders = new Headers(normalizeHeaders(headers));
  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
  normalizedHeaders.set(
    "user-agent",
    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
  );
  return Object.fromEntries(normalizedHeaders.entries());
}
function isNonNullable(value) {
  return value != null;
}
function isUrlSupported({
  mediaType,
  url: url4,
  supportedUrls
}) {
  url4 = url4.toLowerCase();
  mediaType = mediaType.toLowerCase();
  return Object.entries(supportedUrls).map(([key, value]) => {
    const mediaType2 = key.toLowerCase();
    return mediaType2 === "*" || mediaType2 === "*/*" ? { mediaTypePrefix: "", regexes: value } : { mediaTypePrefix: mediaType2.replace(/\*/, ""), regexes: value };
  }).filter(({ mediaTypePrefix }) => mediaType.startsWith(mediaTypePrefix)).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url4));
}
function loadApiKey({
  apiKey,
  environmentVariableName,
  apiKeyParameterName = "apiKey",
  description
}) {
  if (typeof apiKey === "string") {
    return apiKey;
  }
  if (apiKey != null) {
    throw new LoadAPIKeyError({
      message: `${description} API key must be a string.`
    });
  }
  if (typeof process === "undefined") {
    throw new LoadAPIKeyError({
      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
    });
  }
  apiKey = process.env[environmentVariableName];
  if (apiKey == null) {
    throw new LoadAPIKeyError({
      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
    });
  }
  if (typeof apiKey !== "string") {
    throw new LoadAPIKeyError({
      message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
    });
  }
  return apiKey;
}
function loadOptionalSetting({
  settingValue,
  environmentVariableName
}) {
  if (typeof settingValue === "string") {
    return settingValue;
  }
  if (settingValue != null || typeof process === "undefined") {
    return void 0;
  }
  settingValue = process.env[environmentVariableName];
  if (settingValue == null || typeof settingValue !== "string") {
    return void 0;
  }
  return settingValue;
}
function mediaTypeToExtension(mediaType) {
  var _a211;
  const [_type, subtype = ""] = mediaType.toLowerCase().split("/");
  return (_a211 = {
    mpeg: "mp3",
    "x-wav": "wav",
    opus: "ogg",
    mp4: "m4a",
    "x-m4a": "m4a"
  }[subtype]) != null ? _a211 : subtype;
}
function _parse2(text2) {
  const obj = JSON.parse(text2);
  if (obj === null || typeof obj !== "object") {
    return obj;
  }
  if (suspectProtoRx.test(text2) === false && suspectConstructorRx.test(text2) === false) {
    return obj;
  }
  return filter2(obj);
}
function filter2(obj) {
  let next = [obj];
  while (next.length) {
    const nodes = next;
    next = [];
    for (const node of nodes) {
      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      for (const key in node) {
        const value = node[key];
        if (value && typeof value === "object") {
          next.push(value);
        }
      }
    }
  }
  return obj;
}
function secureJsonParse(text2) {
  const { stackTraceLimit } = Error;
  try {
    Error.stackTraceLimit = 0;
  } catch (e) {
    return _parse2(text2);
  }
  try {
    return _parse2(text2);
  } finally {
    Error.stackTraceLimit = stackTraceLimit;
  }
}
function addAdditionalPropertiesToJsonSchema(jsonSchema22) {
  if (jsonSchema22.type === "object" || Array.isArray(jsonSchema22.type) && jsonSchema22.type.includes("object")) {
    jsonSchema22.additionalProperties = false;
    const { properties } = jsonSchema22;
    if (properties != null) {
      for (const key of Object.keys(properties)) {
        properties[key] = visit(properties[key]);
      }
    }
  }
  if (jsonSchema22.items != null) {
    jsonSchema22.items = Array.isArray(jsonSchema22.items) ? jsonSchema22.items.map(visit) : visit(jsonSchema22.items);
  }
  if (jsonSchema22.anyOf != null) {
    jsonSchema22.anyOf = jsonSchema22.anyOf.map(visit);
  }
  if (jsonSchema22.allOf != null) {
    jsonSchema22.allOf = jsonSchema22.allOf.map(visit);
  }
  if (jsonSchema22.oneOf != null) {
    jsonSchema22.oneOf = jsonSchema22.oneOf.map(visit);
  }
  const { definitions } = jsonSchema22;
  if (definitions != null) {
    for (const key of Object.keys(definitions)) {
      definitions[key] = visit(definitions[key]);
    }
  }
  return jsonSchema22;
}
function visit(def) {
  if (typeof def === "boolean") return def;
  return addAdditionalPropertiesToJsonSchema(def);
}
function parseAnyDef() {
  return {};
}
function parseArrayDef(def, refs) {
  var _a211, _b27, _c;
  const res = {
    type: "array"
  };
  if (((_a211 = def.type) == null ? void 0 : _a211._def) && ((_c = (_b27 = def.type) == null ? void 0 : _b27._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind2.ZodAny) {
    res.items = parseDef(def.type._def, {
      ...refs,
      currentPath: [...refs.currentPath, "items"]
    });
  }
  if (def.minLength) {
    res.minItems = def.minLength.value;
  }
  if (def.maxLength) {
    res.maxItems = def.maxLength.value;
  }
  if (def.exactLength) {
    res.minItems = def.exactLength.value;
    res.maxItems = def.exactLength.value;
  }
  return res;
}
function parseBigintDef(def) {
  const res = {
    type: "integer",
    format: "int64"
  };
  if (!def.checks) return res;
  for (const check3 of def.checks) {
    switch (check3.kind) {
      case "min":
        if (check3.inclusive) {
          res.minimum = check3.value;
        } else {
          res.exclusiveMinimum = check3.value;
        }
        break;
      case "max":
        if (check3.inclusive) {
          res.maximum = check3.value;
        } else {
          res.exclusiveMaximum = check3.value;
        }
        break;
      case "multipleOf":
        res.multipleOf = check3.value;
        break;
    }
  }
  return res;
}
function parseBooleanDef() {
  return { type: "boolean" };
}
function parseBrandedDef(_def, refs) {
  return parseDef(_def.type._def, refs);
}
function parseDateDef(def, refs, overrideDateStrategy) {
  const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
  if (Array.isArray(strategy)) {
    return {
      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
    };
  }
  switch (strategy) {
    case "string":
    case "format:date-time":
      return {
        type: "string",
        format: "date-time"
      };
    case "format:date":
      return {
        type: "string",
        format: "date"
      };
    case "integer":
      return integerDateParser(def);
  }
}
function parseDefaultDef(_def, refs) {
  return {
    ...parseDef(_def.innerType._def, refs),
    default: _def.defaultValue()
  };
}
function parseEffectsDef(_def, refs) {
  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
}
function parseEnumDef(def) {
  return {
    type: "string",
    enum: Array.from(def.values)
  };
}
function parseIntersectionDef(def, refs) {
  const allOf = [
    parseDef(def.left._def, {
      ...refs,
      currentPath: [...refs.currentPath, "allOf", "0"]
    }),
    parseDef(def.right._def, {
      ...refs,
      currentPath: [...refs.currentPath, "allOf", "1"]
    })
  ].filter((x) => !!x);
  const mergedAllOf = [];
  allOf.forEach((schema) => {
    if (isJsonSchema7AllOfType(schema)) {
      mergedAllOf.push(...schema.allOf);
    } else {
      let nestedSchema = schema;
      if ("additionalProperties" in schema && schema.additionalProperties === false) {
        const { additionalProperties, ...rest } = schema;
        nestedSchema = rest;
      }
      mergedAllOf.push(nestedSchema);
    }
  });
  return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
}
function parseLiteralDef(def) {
  const parsedType3 = typeof def.value;
  if (parsedType3 !== "bigint" && parsedType3 !== "number" && parsedType3 !== "boolean" && parsedType3 !== "string") {
    return {
      type: Array.isArray(def.value) ? "array" : "object"
    };
  }
  return {
    type: parsedType3 === "bigint" ? "integer" : parsedType3,
    const: def.value
  };
}
function parseStringDef(def, refs) {
  const res = {
    type: "string"
  };
  if (def.checks) {
    for (const check3 of def.checks) {
      switch (check3.kind) {
        case "min":
          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value;
          break;
        case "max":
          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value;
          break;
        case "email":
          switch (refs.emailStrategy) {
            case "format:email":
              addFormat(res, "email", check3.message, refs);
              break;
            case "format:idn-email":
              addFormat(res, "idn-email", check3.message, refs);
              break;
            case "pattern:zod":
              addPattern(res, zodPatterns.email, check3.message, refs);
              break;
          }
          break;
        case "url":
          addFormat(res, "uri", check3.message, refs);
          break;
        case "uuid":
          addFormat(res, "uuid", check3.message, refs);
          break;
        case "regex":
          addPattern(res, check3.regex, check3.message, refs);
          break;
        case "cuid":
          addPattern(res, zodPatterns.cuid, check3.message, refs);
          break;
        case "cuid2":
          addPattern(res, zodPatterns.cuid2, check3.message, refs);
          break;
        case "startsWith":
          addPattern(
            res,
            RegExp(`^${escapeLiteralCheckValue(check3.value, refs)}`),
            check3.message,
            refs
          );
          break;
        case "endsWith":
          addPattern(
            res,
            RegExp(`${escapeLiteralCheckValue(check3.value, refs)}$`),
            check3.message,
            refs
          );
          break;
        case "datetime":
          addFormat(res, "date-time", check3.message, refs);
          break;
        case "date":
          addFormat(res, "date", check3.message, refs);
          break;
        case "time":
          addFormat(res, "time", check3.message, refs);
          break;
        case "duration":
          addFormat(res, "duration", check3.message, refs);
          break;
        case "length":
          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value;
          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value;
          break;
        case "includes": {
          addPattern(
            res,
            RegExp(escapeLiteralCheckValue(check3.value, refs)),
            check3.message,
            refs
          );
          break;
        }
        case "ip": {
          if (check3.version !== "v6") {
            addFormat(res, "ipv4", check3.message, refs);
          }
          if (check3.version !== "v4") {
            addFormat(res, "ipv6", check3.message, refs);
          }
          break;
        }
        case "base64url":
          addPattern(res, zodPatterns.base64url, check3.message, refs);
          break;
        case "jwt":
          addPattern(res, zodPatterns.jwt, check3.message, refs);
          break;
        case "cidr": {
          if (check3.version !== "v6") {
            addPattern(res, zodPatterns.ipv4Cidr, check3.message, refs);
          }
          if (check3.version !== "v4") {
            addPattern(res, zodPatterns.ipv6Cidr, check3.message, refs);
          }
          break;
        }
        case "emoji":
          addPattern(res, zodPatterns.emoji(), check3.message, refs);
          break;
        case "ulid": {
          addPattern(res, zodPatterns.ulid, check3.message, refs);
          break;
        }
        case "base64": {
          switch (refs.base64Strategy) {
            case "format:binary": {
              addFormat(res, "binary", check3.message, refs);
              break;
            }
            case "contentEncoding:base64": {
              res.contentEncoding = "base64";
              break;
            }
            case "pattern:zod": {
              addPattern(res, zodPatterns.base64, check3.message, refs);
              break;
            }
          }
          break;
        }
        case "nanoid": {
          addPattern(res, zodPatterns.nanoid, check3.message, refs);
        }
        case "toLowerCase":
        case "toUpperCase":
        case "trim":
          break;
        default:
          /* @__PURE__ */ ((_) => {
          })(check3);
      }
    }
  }
  return res;
}
function escapeLiteralCheckValue(literal3, refs) {
  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal3) : literal3;
}
function escapeNonAlphaNumeric(source) {
  let result = "";
  for (let i = 0; i < source.length; i++) {
    if (!ALPHA_NUMERIC.has(source[i])) {
      result += "\\";
    }
    result += source[i];
  }
  return result;
}
function addFormat(schema, value, message, refs) {
  var _a211;
  if (schema.format || ((_a211 = schema.anyOf) == null ? void 0 : _a211.some((x) => x.format))) {
    if (!schema.anyOf) {
      schema.anyOf = [];
    }
    if (schema.format) {
      schema.anyOf.push({
        format: schema.format
      });
      delete schema.format;
    }
    schema.anyOf.push({
      format: value,
      ...message && refs.errorMessages && { errorMessage: { format: message } }
    });
  } else {
    schema.format = value;
  }
}
function addPattern(schema, regex, message, refs) {
  var _a211;
  if (schema.pattern || ((_a211 = schema.allOf) == null ? void 0 : _a211.some((x) => x.pattern))) {
    if (!schema.allOf) {
      schema.allOf = [];
    }
    if (schema.pattern) {
      schema.allOf.push({
        pattern: schema.pattern
      });
      delete schema.pattern;
    }
    schema.allOf.push({
      pattern: stringifyRegExpWithFlags(regex, refs),
      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
    });
  } else {
    schema.pattern = stringifyRegExpWithFlags(regex, refs);
  }
}
function stringifyRegExpWithFlags(regex, refs) {
  var _a211;
  if (!refs.applyRegexFlags || !regex.flags) {
    return regex.source;
  }
  const flags = {
    i: regex.flags.includes("i"),
    // Case-insensitive
    m: regex.flags.includes("m"),
    // `^` and `$` matches adjacent to newline characters
    s: regex.flags.includes("s")
    // `.` matches newlines
  };
  const source = flags.i ? regex.source.toLowerCase() : regex.source;
  let pattern = "";
  let isEscaped = false;
  let inCharGroup = false;
  let inCharRange = false;
  for (let i = 0; i < source.length; i++) {
    if (isEscaped) {
      pattern += source[i];
      isEscaped = false;
      continue;
    }
    if (flags.i) {
      if (inCharGroup) {
        if (source[i].match(/[a-z]/)) {
          if (inCharRange) {
            pattern += source[i];
            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
            inCharRange = false;
          } else if (source[i + 1] === "-" && ((_a211 = source[i + 2]) == null ? void 0 : _a211.match(/[a-z]/))) {
            pattern += source[i];
            inCharRange = true;
          } else {
            pattern += `${source[i]}${source[i].toUpperCase()}`;
          }
          continue;
        }
      } else if (source[i].match(/[a-z]/)) {
        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
        continue;
      }
    }
    if (flags.m) {
      if (source[i] === "^") {
        pattern += `(^|(?<=[\r
]))`;
        continue;
      } else if (source[i] === "$") {
        pattern += `($|(?=[\r
]))`;
        continue;
      }
    }
    if (flags.s && source[i] === ".") {
      pattern += inCharGroup ? `${source[i]}\r
` : `[${source[i]}\r
]`;
      continue;
    }
    pattern += source[i];
    if (source[i] === "\\") {
      isEscaped = true;
    } else if (inCharGroup && source[i] === "]") {
      inCharGroup = false;
    } else if (!inCharGroup && source[i] === "[") {
      inCharGroup = true;
    }
  }
  try {
    new RegExp(pattern);
  } catch (e) {
    console.warn(
      `Could not convert regex pattern at ${refs.currentPath.join(
        "/"
      )} to a flag-independent form! Falling back to the flag-ignorant source`
    );
    return regex.source;
  }
  return pattern;
}
function parseRecordDef(def, refs) {
  var _a211, _b27, _c, _d, _e, _f;
  const schema = {
    type: "object",
    additionalProperties: (_a211 = parseDef(def.valueType._def, {
      ...refs,
      currentPath: [...refs.currentPath, "additionalProperties"]
    })) != null ? _a211 : refs.allowedAdditionalProperties
  };
  if (((_b27 = def.keyType) == null ? void 0 : _b27._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
    return {
      ...schema,
      propertyNames: keyType
    };
  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind2.ZodEnum) {
    return {
      ...schema,
      propertyNames: {
        enum: def.keyType._def.values
      }
    };
  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
    const { type, ...keyType } = parseBrandedDef(
      def.keyType._def,
      refs
    );
    return {
      ...schema,
      propertyNames: keyType
    };
  }
  return schema;
}
function parseMapDef(def, refs) {
  if (refs.mapStrategy === "record") {
    return parseRecordDef(def, refs);
  }
  const keys2 = parseDef(def.keyType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items", "items", "0"]
  }) || parseAnyDef();
  const values = parseDef(def.valueType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items", "items", "1"]
  }) || parseAnyDef();
  return {
    type: "array",
    maxItems: 125,
    items: {
      type: "array",
      items: [keys2, values],
      minItems: 2,
      maxItems: 2
    }
  };
}
function parseNativeEnumDef(def) {
  const object4 = def.values;
  const actualKeys = Object.keys(def.values).filter((key) => {
    return typeof object4[object4[key]] !== "number";
  });
  const actualValues = actualKeys.map((key) => object4[key]);
  const parsedTypes = Array.from(
    new Set(actualValues.map((values) => typeof values))
  );
  return {
    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
    enum: actualValues
  };
}
function parseNeverDef() {
  return { not: parseAnyDef() };
}
function parseNullDef() {
  return {
    type: "null"
  };
}
function parseUnionDef(def, refs) {
  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
  if (options.every(
    (x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length)
  )) {
    const types = options.reduce((types2, x) => {
      const type = primitiveMappings[x._def.typeName];
      return type && !types2.includes(type) ? [...types2, type] : types2;
    }, []);
    return {
      type: types.length > 1 ? types : types[0]
    };
  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
    const types = options.reduce(
      (acc, x) => {
        const type = typeof x._def.value;
        switch (type) {
          case "string":
          case "number":
          case "boolean":
            return [...acc, type];
          case "bigint":
            return [...acc, "integer"];
          case "object":
            if (x._def.value === null) return [...acc, "null"];
          case "symbol":
          case "undefined":
          case "function":
          default:
            return acc;
        }
      },
      []
    );
    if (types.length === options.length) {
      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
      return {
        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
        enum: options.reduce(
          (acc, x) => {
            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
          },
          []
        )
      };
    }
  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
    return {
      type: "string",
      enum: options.reduce(
        (acc, x) => [
          ...acc,
          ...x._def.values.filter((x2) => !acc.includes(x2))
        ],
        []
      )
    };
  }
  return asAnyOf(def, refs);
}
function parseNullableDef(def, refs) {
  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
    def.innerType._def.typeName
  ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
    return {
      type: [
        primitiveMappings[def.innerType._def.typeName],
        "null"
      ]
    };
  }
  const base = parseDef(def.innerType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "anyOf", "0"]
  });
  return base && { anyOf: [base, { type: "null" }] };
}
function parseNumberDef(def) {
  const res = {
    type: "number"
  };
  if (!def.checks) return res;
  for (const check3 of def.checks) {
    switch (check3.kind) {
      case "int":
        res.type = "integer";
        break;
      case "min":
        if (check3.inclusive) {
          res.minimum = check3.value;
        } else {
          res.exclusiveMinimum = check3.value;
        }
        break;
      case "max":
        if (check3.inclusive) {
          res.maximum = check3.value;
        } else {
          res.exclusiveMaximum = check3.value;
        }
        break;
      case "multipleOf":
        res.multipleOf = check3.value;
        break;
    }
  }
  return res;
}
function parseObjectDef(def, refs) {
  const result = {
    type: "object",
    properties: {}
  };
  const required3 = [];
  const shape = def.shape();
  for (const propName in shape) {
    let propDef = shape[propName];
    if (propDef === void 0 || propDef._def === void 0) {
      continue;
    }
    const propOptional = safeIsOptional(propDef);
    const parsedDef = parseDef(propDef._def, {
      ...refs,
      currentPath: [...refs.currentPath, "properties", propName],
      propertyPath: [...refs.currentPath, "properties", propName]
    });
    if (parsedDef === void 0) {
      continue;
    }
    result.properties[propName] = parsedDef;
    if (!propOptional) {
      required3.push(propName);
    }
  }
  if (required3.length) {
    result.required = required3;
  }
  const additionalProperties = decideAdditionalProperties(def, refs);
  if (additionalProperties !== void 0) {
    result.additionalProperties = additionalProperties;
  }
  return result;
}
function decideAdditionalProperties(def, refs) {
  if (def.catchall._def.typeName !== "ZodNever") {
    return parseDef(def.catchall._def, {
      ...refs,
      currentPath: [...refs.currentPath, "additionalProperties"]
    });
  }
  switch (def.unknownKeys) {
    case "passthrough":
      return refs.allowedAdditionalProperties;
    case "strict":
      return refs.rejectedAdditionalProperties;
    case "strip":
      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
  }
}
function safeIsOptional(schema) {
  try {
    return schema.isOptional();
  } catch (e) {
    return true;
  }
}
function parsePromiseDef(def, refs) {
  return parseDef(def.type._def, refs);
}
function parseSetDef(def, refs) {
  const items = parseDef(def.valueType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items"]
  });
  const schema = {
    type: "array",
    uniqueItems: true,
    items
  };
  if (def.minSize) {
    schema.minItems = def.minSize.value;
  }
  if (def.maxSize) {
    schema.maxItems = def.maxSize.value;
  }
  return schema;
}
function parseTupleDef(def, refs) {
  if (def.rest) {
    return {
      type: "array",
      minItems: def.items.length,
      items: def.items.map(
        (x, i) => parseDef(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "items", `${i}`]
        })
      ).reduce(
        (acc, x) => x === void 0 ? acc : [...acc, x],
        []
      ),
      additionalItems: parseDef(def.rest._def, {
        ...refs,
        currentPath: [...refs.currentPath, "additionalItems"]
      })
    };
  } else {
    return {
      type: "array",
      minItems: def.items.length,
      maxItems: def.items.length,
      items: def.items.map(
        (x, i) => parseDef(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "items", `${i}`]
        })
      ).reduce(
        (acc, x) => x === void 0 ? acc : [...acc, x],
        []
      )
    };
  }
}
function parseUndefinedDef() {
  return {
    not: parseAnyDef()
  };
}
function parseUnknownDef() {
  return parseAnyDef();
}
function parseDef(def, refs, forceResolution = false) {
  var _a211;
  const seenItem = refs.seen.get(def);
  if (refs.override) {
    const overrideResult = (_a211 = refs.override) == null ? void 0 : _a211.call(
      refs,
      def,
      refs,
      seenItem,
      forceResolution
    );
    if (overrideResult !== ignoreOverride) {
      return overrideResult;
    }
  }
  if (seenItem && !forceResolution) {
    const seenSchema = get$ref(seenItem, refs);
    if (seenSchema !== void 0) {
      return seenSchema;
    }
  }
  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
  refs.seen.set(def, newItem);
  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
  if (jsonSchema22) {
    addMeta(def, refs, jsonSchema22);
  }
  if (refs.postProcess) {
    const postProcessResult = refs.postProcess(jsonSchema22, def, refs);
    newItem.jsonSchema = jsonSchema22;
    return postProcessResult;
  }
  newItem.jsonSchema = jsonSchema22;
  return jsonSchema22;
}
function lazySchema(createSchema) {
  let schema;
  return () => {
    if (schema == null) {
      schema = createSchema();
    }
    return schema;
  };
}
function jsonSchema(jsonSchema22, {
  validate
} = {}) {
  return {
    [schemaSymbol]: true,
    _type: void 0,
    // should never be used directly
    get jsonSchema() {
      if (typeof jsonSchema22 === "function") {
        jsonSchema22 = jsonSchema22();
      }
      return jsonSchema22;
    },
    validate
  };
}
function isSchema(value) {
  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
}
function asSchema(schema) {
  return schema == null ? jsonSchema({ properties: {}, additionalProperties: false }) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
}
function standardSchema(standardSchema22) {
  return jsonSchema(
    () => addAdditionalPropertiesToJsonSchema(
      standardSchema22["~standard"].jsonSchema.input({
        target: "draft-07"
      })
    ),
    {
      validate: async (value) => {
        const result = await standardSchema22["~standard"].validate(value);
        return "value" in result ? { success: true, value: result.value } : {
          success: false,
          error: new TypeValidationError({
            value,
            cause: result.issues
          })
        };
      }
    }
  );
}
function zod3Schema(zodSchema22, options) {
  var _a211;
  const useReferences = (_a211 = options == null ? void 0 : options.useReferences) != null ? _a211 : false;
  return jsonSchema(
    // defer json schema creation to avoid unnecessary computation when only validation is needed
    () => zod3ToJsonSchema(zodSchema22, {
      $refStrategy: useReferences ? "root" : "none"
    }),
    {
      validate: async (value) => {
        const result = await zodSchema22.safeParseAsync(value);
        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
      }
    }
  );
}
function zod4Schema(zodSchema22, options) {
  var _a211;
  const useReferences = (_a211 = options == null ? void 0 : options.useReferences) != null ? _a211 : false;
  return jsonSchema(
    // defer json schema creation to avoid unnecessary computation when only validation is needed
    () => addAdditionalPropertiesToJsonSchema(
      toJSONSchema(zodSchema22, {
        target: "draft-7",
        io: "input",
        reused: useReferences ? "ref" : "inline"
      })
    ),
    {
      validate: async (value) => {
        const result = await safeParseAsync2(zodSchema22, value);
        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
      }
    }
  );
}
function isZod4Schema(zodSchema22) {
  return "_zod" in zodSchema22;
}
function zodSchema(zodSchema22, options) {
  if (isZod4Schema(zodSchema22)) {
    return zod4Schema(zodSchema22, options);
  } else {
    return zod3Schema(zodSchema22, options);
  }
}
async function validateTypes({
  value,
  schema,
  context: context2
}) {
  const result = await safeValidateTypes({ value, schema, context: context2 });
  if (!result.success) {
    throw TypeValidationError.wrap({ value, cause: result.error, context: context2 });
  }
  return result.value;
}
async function safeValidateTypes({
  value,
  schema,
  context: context2
}) {
  const actualSchema = asSchema(schema);
  try {
    if (actualSchema.validate == null) {
      return { success: true, value, rawValue: value };
    }
    const result = await actualSchema.validate(value);
    if (result.success) {
      return { success: true, value: result.value, rawValue: value };
    }
    return {
      success: false,
      error: TypeValidationError.wrap({ value, cause: result.error, context: context2 }),
      rawValue: value
    };
  } catch (error73) {
    return {
      success: false,
      error: TypeValidationError.wrap({ value, cause: error73, context: context2 }),
      rawValue: value
    };
  }
}
async function parseJSON({
  text: text2,
  schema
}) {
  try {
    const value = secureJsonParse(text2);
    if (schema == null) {
      return value;
    }
    return validateTypes({ value, schema });
  } catch (error73) {
    if (JSONParseError.isInstance(error73) || TypeValidationError.isInstance(error73)) {
      throw error73;
    }
    throw new JSONParseError({ text: text2, cause: error73 });
  }
}
async function safeParseJSON({
  text: text2,
  schema
}) {
  try {
    const value = secureJsonParse(text2);
    if (schema == null) {
      return { success: true, value, rawValue: value };
    }
    return await safeValidateTypes({ value, schema });
  } catch (error73) {
    return {
      success: false,
      error: JSONParseError.isInstance(error73) ? error73 : new JSONParseError({ text: text2, cause: error73 }),
      rawValue: void 0
    };
  }
}
function isParsableJson(input) {
  try {
    secureJsonParse(input);
    return true;
  } catch (e) {
    return false;
  }
}
function parseJsonEventStream({
  stream: stream4,
  schema
}) {
  return stream4.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream2()).pipeThrough(
    new TransformStream({
      async transform({ data }, controller) {
        if (data === "[DONE]") {
          return;
        }
        controller.enqueue(await safeParseJSON({ text: data, schema }));
      }
    })
  );
}
async function parseProviderOptions({
  provider,
  providerOptions,
  schema
}) {
  if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
    return void 0;
  }
  const parsedProviderOptions = await safeValidateTypes({
    value: providerOptions[provider],
    schema
  });
  if (!parsedProviderOptions.success) {
    throw new InvalidArgumentError({
      argument: "providerOptions",
      message: `invalid ${provider} provider options`,
      cause: parsedProviderOptions.error
    });
  }
  return parsedProviderOptions.value;
}
function tool(tool22) {
  return tool22;
}
function createProviderToolFactory({
  id,
  inputSchema
}) {
  return ({
    execute,
    outputSchema: outputSchema2,
    needsApproval,
    toModelOutput,
    onInputStart,
    onInputDelta,
    onInputAvailable,
    ...args
  }) => tool({
    type: "provider",
    id,
    args,
    inputSchema,
    outputSchema: outputSchema2,
    execute,
    needsApproval,
    toModelOutput,
    onInputStart,
    onInputDelta,
    onInputAvailable
  });
}
function createProviderToolFactoryWithOutputSchema({
  id,
  inputSchema,
  outputSchema: outputSchema2,
  supportsDeferredResults
}) {
  return ({
    execute,
    needsApproval,
    toModelOutput,
    onInputStart,
    onInputDelta,
    onInputAvailable,
    ...args
  }) => tool({
    type: "provider",
    id,
    args,
    inputSchema,
    outputSchema: outputSchema2,
    execute,
    needsApproval,
    toModelOutput,
    onInputStart,
    onInputDelta,
    onInputAvailable,
    supportsDeferredResults
  });
}
async function resolve(value) {
  if (typeof value === "function") {
    value = value();
  }
  return Promise.resolve(value);
}
function withoutTrailingSlash(url4) {
  return url4 == null ? void 0 : url4.replace(/\/$/, "");
}
function isAsyncIterable(obj) {
  return obj != null && typeof obj[Symbol.asyncIterator] === "function";
}
async function* executeTool({
  execute,
  input,
  options
}) {
  const result = execute(input, options);
  if (isAsyncIterable(result)) {
    let lastOutput;
    for await (const output of result) {
      lastOutput = output;
      yield { type: "preliminary", output };
    }
    yield { type: "final", output: lastOutput };
  } else {
    yield { type: "final", output: await result };
  }
}
var DelayedPromise, btoa2, atob2, name14, marker15, symbol16, _a16, _b15, DownloadError, DEFAULT_MAX_DOWNLOAD_SIZE, createIdGenerator, generateId, FETCH_FAILED_ERROR_MESSAGES, BUN_ERROR_CODES, VERSION3, getOriginalFetch, getFromApi, suspectProtoRx, suspectConstructorRx, ignoreOverride, defaultOptions, getDefaultOptions, parseCatchDef, integerDateParser, isJsonSchema7AllOfType, emojiRegex2, zodPatterns, ALPHA_NUMERIC, primitiveMappings, asAnyOf, parseOptionalDef, parsePipelineDef, parseReadonlyDef, selectParser, getRelativePath, get$ref, addMeta, getRefs, zod3ToJsonSchema, schemaSymbol, getOriginalFetch2, postJsonToApi, postFormDataToApi, postToApi, createJsonErrorResponseHandler, createEventSourceResponseHandler, createJsonResponseHandler, createBinaryResponseHandler, createStatusCodeErrorResponseHandler;
var init_dist5 = __esm({
  "node_modules/@ai-sdk/provider-utils/dist/index.mjs"() {
    "use strict";
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_v42();
    init_v3();
    init_v3();
    init_v3();
    init_stream();
    init_dist3();
    init_dist3();
    init_dist3();
    DelayedPromise = class {
      constructor() {
        this.status = { type: "pending" };
        this._resolve = void 0;
        this._reject = void 0;
      }
      get promise() {
        if (this._promise) {
          return this._promise;
        }
        this._promise = new Promise((resolve22, reject) => {
          if (this.status.type === "resolved") {
            resolve22(this.status.value);
          } else if (this.status.type === "rejected") {
            reject(this.status.error);
          }
          this._resolve = resolve22;
          this._reject = reject;
        });
        return this._promise;
      }
      resolve(value) {
        var _a211;
        this.status = { type: "resolved", value };
        if (this._promise) {
          (_a211 = this._resolve) == null ? void 0 : _a211.call(this, value);
        }
      }
      reject(error73) {
        var _a211;
        this.status = { type: "rejected", error: error73 };
        if (this._promise) {
          (_a211 = this._reject) == null ? void 0 : _a211.call(this, error73);
        }
      }
      isResolved() {
        return this.status.type === "resolved";
      }
      isRejected() {
        return this.status.type === "rejected";
      }
      isPending() {
        return this.status.type === "pending";
      }
    };
    ({ btoa: btoa2, atob: atob2 } = globalThis);
    name14 = "AI_DownloadError";
    marker15 = `vercel.ai.error.${name14}`;
    symbol16 = Symbol.for(marker15);
    DownloadError = class extends (_b15 = AISDKError, _a16 = symbol16, _b15) {
      constructor({
        url: url4,
        statusCode,
        statusText,
        cause,
        message = cause == null ? `Failed to download ${url4}: ${statusCode} ${statusText}` : `Failed to download ${url4}: ${cause}`
      }) {
        super({ name: name14, message, cause });
        this[_a16] = true;
        this.url = url4;
        this.statusCode = statusCode;
        this.statusText = statusText;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker15);
      }
    };
    DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
    createIdGenerator = ({
      prefix,
      size = 16,
      alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
      separator = "-"
    } = {}) => {
      const generator = () => {
        const alphabetLength = alphabet.length;
        const chars = new Array(size);
        for (let i = 0; i < size; i++) {
          chars[i] = alphabet[Math.random() * alphabetLength | 0];
        }
        return chars.join("");
      };
      if (prefix == null) {
        return generator;
      }
      if (alphabet.includes(separator)) {
        throw new InvalidArgumentError({
          argument: "separator",
          message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
        });
      }
      return () => `${prefix}${separator}${generator()}`;
    };
    generateId = createIdGenerator();
    FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
    BUN_ERROR_CODES = [
      "ConnectionRefused",
      "ConnectionClosed",
      "FailedToOpenSocket",
      "ECONNRESET",
      "ECONNREFUSED",
      "ETIMEDOUT",
      "EPIPE"
    ];
    VERSION3 = true ? "4.0.21" : "0.0.0-test";
    getOriginalFetch = () => globalThis.fetch;
    getFromApi = async ({
      url: url4,
      headers = {},
      successfulResponseHandler,
      failedResponseHandler,
      abortSignal,
      fetch: fetch2 = getOriginalFetch()
    }) => {
      try {
        const response = await fetch2(url4, {
          method: "GET",
          headers: withUserAgentSuffix(
            headers,
            `ai-sdk/provider-utils/${VERSION3}`,
            getRuntimeEnvironmentUserAgent()
          ),
          signal: abortSignal
        });
        const responseHeaders = extractResponseHeaders(response);
        if (!response.ok) {
          let errorInformation;
          try {
            errorInformation = await failedResponseHandler({
              response,
              url: url4,
              requestBodyValues: {}
            });
          } catch (error73) {
            if (isAbortError(error73) || APICallError.isInstance(error73)) {
              throw error73;
            }
            throw new APICallError({
              message: "Failed to process error response",
              cause: error73,
              statusCode: response.status,
              url: url4,
              responseHeaders,
              requestBodyValues: {}
            });
          }
          throw errorInformation.value;
        }
        try {
          return await successfulResponseHandler({
            response,
            url: url4,
            requestBodyValues: {}
          });
        } catch (error73) {
          if (error73 instanceof Error) {
            if (isAbortError(error73) || APICallError.isInstance(error73)) {
              throw error73;
            }
          }
          throw new APICallError({
            message: "Failed to process successful response",
            cause: error73,
            statusCode: response.status,
            url: url4,
            responseHeaders,
            requestBodyValues: {}
          });
        }
      } catch (error73) {
        throw handleFetchError({ error: error73, url: url4, requestBodyValues: {} });
      }
    };
    suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
    suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
    ignoreOverride = /* @__PURE__ */ Symbol(
      "Let zodToJsonSchema decide on which parser to use"
    );
    defaultOptions = {
      name: void 0,
      $refStrategy: "root",
      basePath: ["#"],
      effectStrategy: "input",
      pipeStrategy: "all",
      dateStrategy: "format:date-time",
      mapStrategy: "entries",
      removeAdditionalStrategy: "passthrough",
      allowedAdditionalProperties: true,
      rejectedAdditionalProperties: false,
      definitionPath: "definitions",
      strictUnions: false,
      definitions: {},
      errorMessages: false,
      patternStrategy: "escape",
      applyRegexFlags: false,
      emailStrategy: "format:email",
      base64Strategy: "contentEncoding:base64",
      nameStrategy: "ref"
    };
    getDefaultOptions = (options) => typeof options === "string" ? {
      ...defaultOptions,
      name: options
    } : {
      ...defaultOptions,
      ...options
    };
    parseCatchDef = (def, refs) => {
      return parseDef(def.innerType._def, refs);
    };
    integerDateParser = (def) => {
      const res = {
        type: "integer",
        format: "unix-time"
      };
      for (const check3 of def.checks) {
        switch (check3.kind) {
          case "min":
            res.minimum = check3.value;
            break;
          case "max":
            res.maximum = check3.value;
            break;
        }
      }
      return res;
    };
    isJsonSchema7AllOfType = (type) => {
      if ("type" in type && type.type === "string") return false;
      return "allOf" in type;
    };
    emojiRegex2 = void 0;
    zodPatterns = {
      /**
       * `c` was changed to `[cC]` to replicate /i flag
       */
      cuid: /^[cC][^\s-]{8,}$/,
      cuid2: /^[0-9a-z]+$/,
      ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
      /**
       * `a-z` was added to replicate /i flag
       */
      email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
      /**
       * Constructed a valid Unicode RegExp
       *
       * Lazily instantiate since this type of regex isn't supported
       * in all envs (e.g. React Native).
       *
       * See:
       * https://github.com/colinhacks/zod/issues/2433
       * Fix in Zod:
       * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
       */
      emoji: () => {
        if (emojiRegex2 === void 0) {
          emojiRegex2 = RegExp(
            "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
            "u"
          );
        }
        return emojiRegex2;
      },
      /**
       * Unused
       */
      uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
      /**
       * Unused
       */
      ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
      ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
      /**
       * Unused
       */
      ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
      ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
      base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
      base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
      nanoid: /^[a-zA-Z0-9_-]{21}$/,
      jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
    };
    ALPHA_NUMERIC = new Set(
      "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
    );
    primitiveMappings = {
      ZodString: "string",
      ZodNumber: "number",
      ZodBigInt: "integer",
      ZodBoolean: "boolean",
      ZodNull: "null"
    };
    asAnyOf = (def, refs) => {
      const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
        (x, i) => parseDef(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "anyOf", `${i}`]
        })
      ).filter(
        (x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
      );
      return anyOf.length ? { anyOf } : void 0;
    };
    parseOptionalDef = (def, refs) => {
      var _a211;
      if (refs.currentPath.toString() === ((_a211 = refs.propertyPath) == null ? void 0 : _a211.toString())) {
        return parseDef(def.innerType._def, refs);
      }
      const innerSchema = parseDef(def.innerType._def, {
        ...refs,
        currentPath: [...refs.currentPath, "anyOf", "1"]
      });
      return innerSchema ? { anyOf: [{ not: parseAnyDef() }, innerSchema] } : parseAnyDef();
    };
    parsePipelineDef = (def, refs) => {
      if (refs.pipeStrategy === "input") {
        return parseDef(def.in._def, refs);
      } else if (refs.pipeStrategy === "output") {
        return parseDef(def.out._def, refs);
      }
      const a = parseDef(def.in._def, {
        ...refs,
        currentPath: [...refs.currentPath, "allOf", "0"]
      });
      const b = parseDef(def.out._def, {
        ...refs,
        currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
      });
      return {
        allOf: [a, b].filter((x) => x !== void 0)
      };
    };
    parseReadonlyDef = (def, refs) => {
      return parseDef(def.innerType._def, refs);
    };
    selectParser = (def, typeName, refs) => {
      switch (typeName) {
        case ZodFirstPartyTypeKind2.ZodString:
          return parseStringDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodNumber:
          return parseNumberDef(def);
        case ZodFirstPartyTypeKind2.ZodObject:
          return parseObjectDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodBigInt:
          return parseBigintDef(def);
        case ZodFirstPartyTypeKind2.ZodBoolean:
          return parseBooleanDef();
        case ZodFirstPartyTypeKind2.ZodDate:
          return parseDateDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodUndefined:
          return parseUndefinedDef();
        case ZodFirstPartyTypeKind2.ZodNull:
          return parseNullDef();
        case ZodFirstPartyTypeKind2.ZodArray:
          return parseArrayDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodUnion:
        case ZodFirstPartyTypeKind2.ZodDiscriminatedUnion:
          return parseUnionDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodIntersection:
          return parseIntersectionDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodTuple:
          return parseTupleDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodRecord:
          return parseRecordDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodLiteral:
          return parseLiteralDef(def);
        case ZodFirstPartyTypeKind2.ZodEnum:
          return parseEnumDef(def);
        case ZodFirstPartyTypeKind2.ZodNativeEnum:
          return parseNativeEnumDef(def);
        case ZodFirstPartyTypeKind2.ZodNullable:
          return parseNullableDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodOptional:
          return parseOptionalDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodMap:
          return parseMapDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodSet:
          return parseSetDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodLazy:
          return () => def.getter()._def;
        case ZodFirstPartyTypeKind2.ZodPromise:
          return parsePromiseDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodNaN:
        case ZodFirstPartyTypeKind2.ZodNever:
          return parseNeverDef();
        case ZodFirstPartyTypeKind2.ZodEffects:
          return parseEffectsDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodAny:
          return parseAnyDef();
        case ZodFirstPartyTypeKind2.ZodUnknown:
          return parseUnknownDef();
        case ZodFirstPartyTypeKind2.ZodDefault:
          return parseDefaultDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodBranded:
          return parseBrandedDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodReadonly:
          return parseReadonlyDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodCatch:
          return parseCatchDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodPipeline:
          return parsePipelineDef(def, refs);
        case ZodFirstPartyTypeKind2.ZodFunction:
        case ZodFirstPartyTypeKind2.ZodVoid:
        case ZodFirstPartyTypeKind2.ZodSymbol:
          return void 0;
        default:
          return /* @__PURE__ */ ((_) => void 0)(typeName);
      }
    };
    getRelativePath = (pathA, pathB) => {
      let i = 0;
      for (; i < pathA.length && i < pathB.length; i++) {
        if (pathA[i] !== pathB[i]) break;
      }
      return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
    };
    get$ref = (item, refs) => {
      switch (refs.$refStrategy) {
        case "root":
          return { $ref: item.path.join("/") };
        case "relative":
          return { $ref: getRelativePath(refs.currentPath, item.path) };
        case "none":
        case "seen": {
          if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
            console.warn(
              `Recursive reference detected at ${refs.currentPath.join(
                "/"
              )}! Defaulting to any`
            );
            return parseAnyDef();
          }
          return refs.$refStrategy === "seen" ? parseAnyDef() : void 0;
        }
      }
    };
    addMeta = (def, refs, jsonSchema22) => {
      if (def.description) {
        jsonSchema22.description = def.description;
      }
      return jsonSchema22;
    };
    getRefs = (options) => {
      const _options = getDefaultOptions(options);
      const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
      return {
        ..._options,
        currentPath,
        propertyPath: void 0,
        seen: new Map(
          Object.entries(_options.definitions).map(([name28, def]) => [
            def._def,
            {
              def: def._def,
              path: [..._options.basePath, _options.definitionPath, name28],
              // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
              jsonSchema: void 0
            }
          ])
        )
      };
    };
    zod3ToJsonSchema = (schema, options) => {
      var _a211;
      const refs = getRefs(options);
      let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
        (acc, [name37, schema2]) => {
          var _a37;
          return {
            ...acc,
            [name37]: (_a37 = parseDef(
              schema2._def,
              {
                ...refs,
                currentPath: [...refs.basePath, refs.definitionPath, name37]
              },
              true
            )) != null ? _a37 : parseAnyDef()
          };
        },
        {}
      ) : void 0;
      const name28 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
      const main = (_a211 = parseDef(
        schema._def,
        name28 === void 0 ? refs : {
          ...refs,
          currentPath: [...refs.basePath, refs.definitionPath, name28]
        },
        false
      )) != null ? _a211 : parseAnyDef();
      const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
      if (title !== void 0) {
        main.title = title;
      }
      const combined = name28 === void 0 ? definitions ? {
        ...main,
        [refs.definitionPath]: definitions
      } : main : {
        $ref: [
          ...refs.$refStrategy === "relative" ? [] : refs.basePath,
          refs.definitionPath,
          name28
        ].join("/"),
        [refs.definitionPath]: {
          ...definitions,
          [name28]: main
        }
      };
      combined.$schema = "http://json-schema.org/draft-07/schema#";
      return combined;
    };
    schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
    getOriginalFetch2 = () => globalThis.fetch;
    postJsonToApi = async ({
      url: url4,
      headers,
      body,
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    }) => postToApi({
      url: url4,
      headers: {
        "Content-Type": "application/json",
        ...headers
      },
      body: {
        content: JSON.stringify(body),
        values: body
      },
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    });
    postFormDataToApi = async ({
      url: url4,
      headers,
      formData,
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    }) => postToApi({
      url: url4,
      headers,
      body: {
        content: formData,
        values: Object.fromEntries(formData.entries())
      },
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    });
    postToApi = async ({
      url: url4,
      headers = {},
      body,
      successfulResponseHandler,
      failedResponseHandler,
      abortSignal,
      fetch: fetch2 = getOriginalFetch2()
    }) => {
      try {
        const response = await fetch2(url4, {
          method: "POST",
          headers: withUserAgentSuffix(
            headers,
            `ai-sdk/provider-utils/${VERSION3}`,
            getRuntimeEnvironmentUserAgent()
          ),
          body: body.content,
          signal: abortSignal
        });
        const responseHeaders = extractResponseHeaders(response);
        if (!response.ok) {
          let errorInformation;
          try {
            errorInformation = await failedResponseHandler({
              response,
              url: url4,
              requestBodyValues: body.values
            });
          } catch (error73) {
            if (isAbortError(error73) || APICallError.isInstance(error73)) {
              throw error73;
            }
            throw new APICallError({
              message: "Failed to process error response",
              cause: error73,
              statusCode: response.status,
              url: url4,
              responseHeaders,
              requestBodyValues: body.values
            });
          }
          throw errorInformation.value;
        }
        try {
          return await successfulResponseHandler({
            response,
            url: url4,
            requestBodyValues: body.values
          });
        } catch (error73) {
          if (error73 instanceof Error) {
            if (isAbortError(error73) || APICallError.isInstance(error73)) {
              throw error73;
            }
          }
          throw new APICallError({
            message: "Failed to process successful response",
            cause: error73,
            statusCode: response.status,
            url: url4,
            responseHeaders,
            requestBodyValues: body.values
          });
        }
      } catch (error73) {
        throw handleFetchError({ error: error73, url: url4, requestBodyValues: body.values });
      }
    };
    createJsonErrorResponseHandler = ({
      errorSchema,
      errorToMessage,
      isRetryable
    }) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const responseHeaders = extractResponseHeaders(response);
      if (responseBody.trim() === "") {
        return {
          responseHeaders,
          value: new APICallError({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
      try {
        const parsedError = await parseJSON({
          text: responseBody,
          schema: errorSchema
        });
        return {
          responseHeaders,
          value: new APICallError({
            message: errorToMessage(parsedError),
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            data: parsedError,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
          })
        };
      } catch (parseError) {
        return {
          responseHeaders,
          value: new APICallError({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
    };
    createEventSourceResponseHandler = (chunkSchema2) => async ({ response }) => {
      const responseHeaders = extractResponseHeaders(response);
      if (response.body == null) {
        throw new EmptyResponseBodyError({});
      }
      return {
        responseHeaders,
        value: parseJsonEventStream({
          stream: response.body,
          schema: chunkSchema2
        })
      };
    };
    createJsonResponseHandler = (responseSchema2) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const parsedResult = await safeParseJSON({
        text: responseBody,
        schema: responseSchema2
      });
      const responseHeaders = extractResponseHeaders(response);
      if (!parsedResult.success) {
        throw new APICallError({
          message: "Invalid JSON response",
          cause: parsedResult.error,
          statusCode: response.status,
          responseHeaders,
          responseBody,
          url: url4,
          requestBodyValues
        });
      }
      return {
        responseHeaders,
        value: parsedResult.value,
        rawValue: parsedResult.rawValue
      };
    };
    createBinaryResponseHandler = () => async ({ response, url: url4, requestBodyValues }) => {
      const responseHeaders = extractResponseHeaders(response);
      if (!response.body) {
        throw new APICallError({
          message: "Response body is empty",
          url: url4,
          requestBodyValues,
          statusCode: response.status,
          responseHeaders,
          responseBody: void 0
        });
      }
      try {
        const buffer = await response.arrayBuffer();
        return {
          responseHeaders,
          value: new Uint8Array(buffer)
        };
      } catch (error73) {
        throw new APICallError({
          message: "Failed to read response as array buffer",
          url: url4,
          requestBodyValues,
          statusCode: response.status,
          responseHeaders,
          responseBody: void 0,
          cause: error73
        });
      }
    };
    createStatusCodeErrorResponseHandler = () => async ({ response, url: url4, requestBodyValues }) => {
      const responseHeaders = extractResponseHeaders(response);
      const responseBody = await response.text();
      return {
        responseHeaders,
        value: new APICallError({
          message: response.statusText,
          url: url4,
          requestBodyValues,
          statusCode: response.status,
          responseHeaders,
          responseBody
        })
      };
    };
  }
});

// node_modules/@ai-sdk/openai/dist/index.mjs
function getOpenAILanguageModelCapabilities(modelId) {
  const supportsFlexProcessing = modelId.startsWith("o3") || modelId.startsWith("o4-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat");
  const supportsPriorityProcessing = modelId.startsWith("gpt-4") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-nano") && !modelId.startsWith("gpt-5-chat") && !modelId.startsWith("gpt-5.4-nano") || modelId.startsWith("o3") || modelId.startsWith("o4-mini");
  const isReasoningModel = modelId.startsWith("o1") || modelId.startsWith("o3") || modelId.startsWith("o4-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat");
  const supportsNonReasoningParameters = modelId.startsWith("gpt-5.1") || modelId.startsWith("gpt-5.2") || modelId.startsWith("gpt-5.3") || modelId.startsWith("gpt-5.4");
  const systemMessageMode = isReasoningModel ? "developer" : "system";
  return {
    supportsFlexProcessing,
    supportsPriorityProcessing,
    isReasoningModel,
    systemMessageMode,
    supportsNonReasoningParameters
  };
}
function convertOpenAIChatUsage(usage) {
  var _a31, _b27, _c, _d, _e, _f;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = (_a31 = usage.prompt_tokens) != null ? _a31 : 0;
  const completionTokens = (_b27 = usage.completion_tokens) != null ? _b27 : 0;
  const cachedTokens = (_d = (_c = usage.prompt_tokens_details) == null ? void 0 : _c.cached_tokens) != null ? _d : 0;
  const reasoningTokens = (_f = (_e = usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens - cachedTokens,
      cacheRead: cachedTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: completionTokens,
      text: completionTokens - reasoningTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function convertToOpenAIChatMessages({
  prompt,
  systemMessageMode = "system"
}) {
  var _a31;
  const messages = [];
  const warnings = [];
  for (const { role, content } of prompt) {
    switch (role) {
      case "system": {
        switch (systemMessageMode) {
          case "system": {
            messages.push({ role: "system", content });
            break;
          }
          case "developer": {
            messages.push({ role: "developer", content });
            break;
          }
          case "remove": {
            warnings.push({
              type: "other",
              message: "system messages are removed for this model"
            });
            break;
          }
          default: {
            const _exhaustiveCheck = systemMessageMode;
            throw new Error(
              `Unsupported system message mode: ${_exhaustiveCheck}`
            );
          }
        }
        break;
      }
      case "user": {
        if (content.length === 1 && content[0].type === "text") {
          messages.push({ role: "user", content: content[0].text });
          break;
        }
        messages.push({
          role: "user",
          content: content.map((part, index) => {
            var _a211, _b27, _c;
            switch (part.type) {
              case "text": {
                return { type: "text", text: part.text };
              }
              case "file": {
                if (part.mediaType.startsWith("image/")) {
                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
                  return {
                    type: "image_url",
                    image_url: {
                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`,
                      // OpenAI specific extension: image detail
                      detail: (_b27 = (_a211 = part.providerOptions) == null ? void 0 : _a211.openai) == null ? void 0 : _b27.imageDetail
                    }
                  };
                } else if (part.mediaType.startsWith("audio/")) {
                  if (part.data instanceof URL) {
                    throw new UnsupportedFunctionalityError({
                      functionality: "audio file parts with URLs"
                    });
                  }
                  switch (part.mediaType) {
                    case "audio/wav": {
                      return {
                        type: "input_audio",
                        input_audio: {
                          data: convertToBase64(part.data),
                          format: "wav"
                        }
                      };
                    }
                    case "audio/mp3":
                    case "audio/mpeg": {
                      return {
                        type: "input_audio",
                        input_audio: {
                          data: convertToBase64(part.data),
                          format: "mp3"
                        }
                      };
                    }
                    default: {
                      throw new UnsupportedFunctionalityError({
                        functionality: `audio content parts with media type ${part.mediaType}`
                      });
                    }
                  }
                } else if (part.mediaType === "application/pdf") {
                  if (part.data instanceof URL) {
                    throw new UnsupportedFunctionalityError({
                      functionality: "PDF file parts with URLs"
                    });
                  }
                  return {
                    type: "file",
                    file: typeof part.data === "string" && part.data.startsWith("file-") ? { file_id: part.data } : {
                      filename: (_c = part.filename) != null ? _c : `part-${index}.pdf`,
                      file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
                    }
                  };
                } else {
                  throw new UnsupportedFunctionalityError({
                    functionality: `file part media type ${part.mediaType}`
                  });
                }
              }
            }
          })
        });
        break;
      }
      case "assistant": {
        let text2 = "";
        const toolCalls = [];
        for (const part of content) {
          switch (part.type) {
            case "text": {
              text2 += part.text;
              break;
            }
            case "tool-call": {
              toolCalls.push({
                id: part.toolCallId,
                type: "function",
                function: {
                  name: part.toolName,
                  arguments: JSON.stringify(part.input)
                }
              });
              break;
            }
          }
        }
        messages.push({
          role: "assistant",
          content: text2,
          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
        });
        break;
      }
      case "tool": {
        for (const toolResponse of content) {
          if (toolResponse.type === "tool-approval-response") {
            continue;
          }
          const output = toolResponse.output;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = (_a31 = output.reason) != null ? _a31 : "Tool execution denied.";
              break;
            case "content":
            case "json":
            case "error-json":
              contentValue = JSON.stringify(output.value);
              break;
          }
          messages.push({
            role: "tool",
            tool_call_id: toolResponse.toolCallId,
            content: contentValue
          });
        }
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return { messages, warnings };
}
function getResponseMetadata({
  id,
  model,
  created
}) {
  return {
    id: id != null ? id : void 0,
    modelId: model != null ? model : void 0,
    timestamp: created ? new Date(created * 1e3) : void 0
  };
}
function mapOpenAIFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "content_filter":
      return "content-filter";
    case "function_call":
    case "tool_calls":
      return "tool-calls";
    default:
      return "other";
  }
}
function prepareChatTools({
  tools,
  toolChoice
}) {
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const openaiTools2 = [];
  for (const tool3 of tools) {
    switch (tool3.type) {
      case "function":
        openaiTools2.push({
          type: "function",
          function: {
            name: tool3.name,
            description: tool3.description,
            parameters: tool3.inputSchema,
            ...tool3.strict != null ? { strict: tool3.strict } : {}
          }
        });
        break;
      default:
        toolWarnings.push({
          type: "unsupported",
          feature: `tool type: ${tool3.type}`
        });
        break;
    }
  }
  if (toolChoice == null) {
    return { tools: openaiTools2, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
    case "required":
      return { tools: openaiTools2, toolChoice: type, toolWarnings };
    case "tool":
      return {
        tools: openaiTools2,
        toolChoice: {
          type: "function",
          function: {
            name: toolChoice.toolName
          }
        },
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new UnsupportedFunctionalityError({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
function convertOpenAICompletionUsage(usage) {
  var _a31, _b27, _c, _d;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = (_a31 = usage.prompt_tokens) != null ? _a31 : 0;
  const completionTokens = (_b27 = usage.completion_tokens) != null ? _b27 : 0;
  return {
    inputTokens: {
      total: (_c = usage.prompt_tokens) != null ? _c : void 0,
      noCache: promptTokens,
      cacheRead: void 0,
      cacheWrite: void 0
    },
    outputTokens: {
      total: (_d = usage.completion_tokens) != null ? _d : void 0,
      text: completionTokens,
      reasoning: void 0
    },
    raw: usage
  };
}
function convertToOpenAICompletionPrompt({
  prompt,
  user = "user",
  assistant = "assistant"
}) {
  let text2 = "";
  if (prompt[0].role === "system") {
    text2 += `${prompt[0].content}

`;
    prompt = prompt.slice(1);
  }
  for (const { role, content } of prompt) {
    switch (role) {
      case "system": {
        throw new InvalidPromptError({
          message: "Unexpected system message in prompt: ${content}",
          prompt
        });
      }
      case "user": {
        const userMessage = content.map((part) => {
          switch (part.type) {
            case "text": {
              return part.text;
            }
          }
        }).filter(Boolean).join("");
        text2 += `${user}:
${userMessage}

`;
        break;
      }
      case "assistant": {
        const assistantMessage = content.map((part) => {
          switch (part.type) {
            case "text": {
              return part.text;
            }
            case "tool-call": {
              throw new UnsupportedFunctionalityError({
                functionality: "tool-call messages"
              });
            }
          }
        }).join("");
        text2 += `${assistant}:
${assistantMessage}

`;
        break;
      }
      case "tool": {
        throw new UnsupportedFunctionalityError({
          functionality: "tool messages"
        });
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  text2 += `${assistant}:
`;
  return {
    prompt: text2,
    stopSequences: [`
${user}:`]
  };
}
function getResponseMetadata2({
  id,
  model,
  created
}) {
  return {
    id: id != null ? id : void 0,
    modelId: model != null ? model : void 0,
    timestamp: created != null ? new Date(created * 1e3) : void 0
  };
}
function mapOpenAIFinishReason2(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "content_filter":
      return "content-filter";
    case "function_call":
    case "tool_calls":
      return "tool-calls";
    default:
      return "other";
  }
}
function hasDefaultResponseFormat(modelId) {
  return defaultResponseFormatPrefixes.some(
    (prefix) => modelId.startsWith(prefix)
  );
}
function distributeTokenDetails(details, index, total) {
  if (details == null) {
    return {};
  }
  const result = {};
  if (details.image_tokens != null) {
    const base = Math.floor(details.image_tokens / total);
    const remainder = details.image_tokens - base * (total - 1);
    result.imageTokens = index === total - 1 ? remainder : base;
  }
  if (details.text_tokens != null) {
    const base = Math.floor(details.text_tokens / total);
    const remainder = details.text_tokens - base * (total - 1);
    result.textTokens = index === total - 1 ? remainder : base;
  }
  return result;
}
async function fileToBlob(file3) {
  if (!file3) return void 0;
  if (file3.type === "url") {
    return downloadBlob(file3.url);
  }
  const data = file3.data instanceof Uint8Array ? file3.data : convertBase64ToUint8Array(file3.data);
  return new Blob([data], { type: file3.mediaType });
}
function convertOpenAIResponsesUsage(usage) {
  var _a31, _b27, _c, _d;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const inputTokens = usage.input_tokens;
  const outputTokens = usage.output_tokens;
  const cachedTokens = (_b27 = (_a31 = usage.input_tokens_details) == null ? void 0 : _a31.cached_tokens) != null ? _b27 : 0;
  const reasoningTokens = (_d = (_c = usage.output_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0;
  return {
    inputTokens: {
      total: inputTokens,
      noCache: inputTokens - cachedTokens,
      cacheRead: cachedTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: outputTokens,
      text: outputTokens - reasoningTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function isFileId(data, prefixes) {
  if (!prefixes) return false;
  return prefixes.some((prefix) => data.startsWith(prefix));
}
async function convertToOpenAIResponsesInput({
  prompt,
  toolNameMapping,
  systemMessageMode,
  providerOptionsName,
  fileIdPrefixes,
  store,
  hasConversation = false,
  hasLocalShellTool = false,
  hasShellTool = false,
  hasApplyPatchTool = false,
  customProviderToolNames
}) {
  var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
  let input = [];
  const warnings = [];
  const processedApprovalIds = /* @__PURE__ */ new Set();
  for (const { role, content } of prompt) {
    switch (role) {
      case "system": {
        switch (systemMessageMode) {
          case "system": {
            input.push({ role: "system", content });
            break;
          }
          case "developer": {
            input.push({ role: "developer", content });
            break;
          }
          case "remove": {
            warnings.push({
              type: "other",
              message: "system messages are removed for this model"
            });
            break;
          }
          default: {
            const _exhaustiveCheck = systemMessageMode;
            throw new Error(
              `Unsupported system message mode: ${_exhaustiveCheck}`
            );
          }
        }
        break;
      }
      case "user": {
        input.push({
          role: "user",
          content: content.map((part, index) => {
            var _a211, _b28, _c2;
            switch (part.type) {
              case "text": {
                return { type: "input_text", text: part.text };
              }
              case "file": {
                if (part.mediaType.startsWith("image/")) {
                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
                  return {
                    type: "input_image",
                    ...part.data instanceof URL ? { image_url: part.data.toString() } : typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
                      image_url: `data:${mediaType};base64,${convertToBase64(part.data)}`
                    },
                    detail: (_b28 = (_a211 = part.providerOptions) == null ? void 0 : _a211[providerOptionsName]) == null ? void 0 : _b28.imageDetail
                  };
                } else if (part.mediaType === "application/pdf") {
                  if (part.data instanceof URL) {
                    return {
                      type: "input_file",
                      file_url: part.data.toString()
                    };
                  }
                  return {
                    type: "input_file",
                    ...typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
                      filename: (_c2 = part.filename) != null ? _c2 : `part-${index}.pdf`,
                      file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
                    }
                  };
                } else {
                  throw new UnsupportedFunctionalityError({
                    functionality: `file part media type ${part.mediaType}`
                  });
                }
              }
            }
          })
        });
        break;
      }
      case "assistant": {
        const reasoningMessages = {};
        for (const part of content) {
          switch (part.type) {
            case "text": {
              const providerOpts = (_a31 = part.providerOptions) == null ? void 0 : _a31[providerOptionsName];
              const id = providerOpts == null ? void 0 : providerOpts.itemId;
              const phase = providerOpts == null ? void 0 : providerOpts.phase;
              if (hasConversation && id != null) {
                break;
              }
              if (store && id != null) {
                input.push({ type: "item_reference", id });
                break;
              }
              input.push({
                role: "assistant",
                content: [{ type: "output_text", text: part.text }],
                id,
                ...phase != null && { phase }
              });
              break;
            }
            case "tool-call": {
              const id = (_f = (_c = (_b27 = part.providerOptions) == null ? void 0 : _b27[providerOptionsName]) == null ? void 0 : _c.itemId) != null ? _f : (_e = (_d = part.providerMetadata) == null ? void 0 : _d[providerOptionsName]) == null ? void 0 : _e.itemId;
              if (hasConversation && id != null) {
                break;
              }
              const resolvedToolName = toolNameMapping.toProviderToolName(
                part.toolName
              );
              if (resolvedToolName === "tool_search") {
                if (store && id != null) {
                  input.push({ type: "item_reference", id });
                  break;
                }
                const parsedInput = typeof part.input === "string" ? await parseJSON({
                  text: part.input,
                  schema: toolSearchInputSchema
                }) : await validateTypes({
                  value: part.input,
                  schema: toolSearchInputSchema
                });
                const execution = parsedInput.call_id != null ? "client" : "server";
                input.push({
                  type: "tool_search_call",
                  id: id != null ? id : part.toolCallId,
                  execution,
                  call_id: (_g = parsedInput.call_id) != null ? _g : null,
                  status: "completed",
                  arguments: parsedInput.arguments
                });
                break;
              }
              if (part.providerExecuted) {
                if (store && id != null) {
                  input.push({ type: "item_reference", id });
                }
                break;
              }
              if (store && id != null) {
                input.push({ type: "item_reference", id });
                break;
              }
              if (hasLocalShellTool && resolvedToolName === "local_shell") {
                const parsedInput = await validateTypes({
                  value: part.input,
                  schema: localShellInputSchema
                });
                input.push({
                  type: "local_shell_call",
                  call_id: part.toolCallId,
                  id,
                  action: {
                    type: "exec",
                    command: parsedInput.action.command,
                    timeout_ms: parsedInput.action.timeoutMs,
                    user: parsedInput.action.user,
                    working_directory: parsedInput.action.workingDirectory,
                    env: parsedInput.action.env
                  }
                });
                break;
              }
              if (hasShellTool && resolvedToolName === "shell") {
                const parsedInput = await validateTypes({
                  value: part.input,
                  schema: shellInputSchema
                });
                input.push({
                  type: "shell_call",
                  call_id: part.toolCallId,
                  id,
                  status: "completed",
                  action: {
                    commands: parsedInput.action.commands,
                    timeout_ms: parsedInput.action.timeoutMs,
                    max_output_length: parsedInput.action.maxOutputLength
                  }
                });
                break;
              }
              if (hasApplyPatchTool && resolvedToolName === "apply_patch") {
                const parsedInput = await validateTypes({
                  value: part.input,
                  schema: applyPatchInputSchema
                });
                input.push({
                  type: "apply_patch_call",
                  call_id: parsedInput.callId,
                  id,
                  status: "completed",
                  operation: parsedInput.operation
                });
                break;
              }
              if (customProviderToolNames == null ? void 0 : customProviderToolNames.has(resolvedToolName)) {
                input.push({
                  type: "custom_tool_call",
                  call_id: part.toolCallId,
                  name: resolvedToolName,
                  input: typeof part.input === "string" ? part.input : JSON.stringify(part.input),
                  id
                });
                break;
              }
              input.push({
                type: "function_call",
                call_id: part.toolCallId,
                name: resolvedToolName,
                arguments: JSON.stringify(part.input),
                id
              });
              break;
            }
            // assistant tool result parts are from provider-executed tools:
            case "tool-result": {
              if (part.output.type === "execution-denied" || part.output.type === "json" && typeof part.output.value === "object" && part.output.value != null && "type" in part.output.value && part.output.value.type === "execution-denied") {
                break;
              }
              if (hasConversation) {
                break;
              }
              const resolvedResultToolName = toolNameMapping.toProviderToolName(
                part.toolName
              );
              if (resolvedResultToolName === "tool_search") {
                const itemId = (_j = (_i = (_h = part.providerOptions) == null ? void 0 : _h[providerOptionsName]) == null ? void 0 : _i.itemId) != null ? _j : part.toolCallId;
                if (store) {
                  input.push({ type: "item_reference", id: itemId });
                } else if (part.output.type === "json") {
                  const parsedOutput = await validateTypes({
                    value: part.output.value,
                    schema: toolSearchOutputSchema
                  });
                  input.push({
                    type: "tool_search_output",
                    id: itemId,
                    execution: "server",
                    call_id: null,
                    status: "completed",
                    tools: parsedOutput.tools
                  });
                }
                break;
              }
              if (hasShellTool && resolvedResultToolName === "shell") {
                if (part.output.type === "json") {
                  const parsedOutput = await validateTypes({
                    value: part.output.value,
                    schema: shellOutputSchema
                  });
                  input.push({
                    type: "shell_call_output",
                    call_id: part.toolCallId,
                    output: parsedOutput.output.map((item) => ({
                      stdout: item.stdout,
                      stderr: item.stderr,
                      outcome: item.outcome.type === "timeout" ? { type: "timeout" } : {
                        type: "exit",
                        exit_code: item.outcome.exitCode
                      }
                    }))
                  });
                }
                break;
              }
              if (store) {
                const itemId = (_m = (_l = (_k = part.providerOptions) == null ? void 0 : _k[providerOptionsName]) == null ? void 0 : _l.itemId) != null ? _m : part.toolCallId;
                input.push({ type: "item_reference", id: itemId });
              } else {
                warnings.push({
                  type: "other",
                  message: `Results for OpenAI tool ${part.toolName} are not sent to the API when store is false`
                });
              }
              break;
            }
            case "reasoning": {
              const providerOptions = await parseProviderOptions({
                provider: providerOptionsName,
                providerOptions: part.providerOptions,
                schema: openaiResponsesReasoningProviderOptionsSchema
              });
              const reasoningId = providerOptions == null ? void 0 : providerOptions.itemId;
              if (hasConversation && reasoningId != null) {
                break;
              }
              if (reasoningId != null) {
                const reasoningMessage = reasoningMessages[reasoningId];
                if (store) {
                  if (reasoningMessage === void 0) {
                    input.push({ type: "item_reference", id: reasoningId });
                    reasoningMessages[reasoningId] = {
                      type: "reasoning",
                      id: reasoningId,
                      summary: []
                    };
                  }
                } else {
                  const summaryParts = [];
                  if (part.text.length > 0) {
                    summaryParts.push({
                      type: "summary_text",
                      text: part.text
                    });
                  } else if (reasoningMessage !== void 0) {
                    warnings.push({
                      type: "other",
                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${JSON.stringify(part)}.`
                    });
                  }
                  if (reasoningMessage === void 0) {
                    reasoningMessages[reasoningId] = {
                      type: "reasoning",
                      id: reasoningId,
                      encrypted_content: providerOptions == null ? void 0 : providerOptions.reasoningEncryptedContent,
                      summary: summaryParts
                    };
                    input.push(reasoningMessages[reasoningId]);
                  } else {
                    reasoningMessage.summary.push(...summaryParts);
                    if ((providerOptions == null ? void 0 : providerOptions.reasoningEncryptedContent) != null) {
                      reasoningMessage.encrypted_content = providerOptions.reasoningEncryptedContent;
                    }
                  }
                }
              } else {
                const encryptedContent = providerOptions == null ? void 0 : providerOptions.reasoningEncryptedContent;
                if (encryptedContent != null) {
                  const summaryParts = [];
                  if (part.text.length > 0) {
                    summaryParts.push({
                      type: "summary_text",
                      text: part.text
                    });
                  }
                  input.push({
                    type: "reasoning",
                    encrypted_content: encryptedContent,
                    summary: summaryParts
                  });
                } else {
                  warnings.push({
                    type: "other",
                    message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${JSON.stringify(part)}.`
                  });
                }
              }
              break;
            }
          }
        }
        break;
      }
      case "tool": {
        for (const part of content) {
          if (part.type === "tool-approval-response") {
            const approvalResponse = part;
            if (processedApprovalIds.has(approvalResponse.approvalId)) {
              continue;
            }
            processedApprovalIds.add(approvalResponse.approvalId);
            if (store) {
              input.push({
                type: "item_reference",
                id: approvalResponse.approvalId
              });
            }
            input.push({
              type: "mcp_approval_response",
              approval_request_id: approvalResponse.approvalId,
              approve: approvalResponse.approved
            });
            continue;
          }
          const output = part.output;
          if (output.type === "execution-denied") {
            const approvalId = (_o = (_n = output.providerOptions) == null ? void 0 : _n.openai) == null ? void 0 : _o.approvalId;
            if (approvalId) {
              continue;
            }
          }
          const resolvedToolName = toolNameMapping.toProviderToolName(
            part.toolName
          );
          if (resolvedToolName === "tool_search" && output.type === "json") {
            const parsedOutput = await validateTypes({
              value: output.value,
              schema: toolSearchOutputSchema
            });
            input.push({
              type: "tool_search_output",
              execution: "client",
              call_id: part.toolCallId,
              status: "completed",
              tools: parsedOutput.tools
            });
            continue;
          }
          if (hasLocalShellTool && resolvedToolName === "local_shell" && output.type === "json") {
            const parsedOutput = await validateTypes({
              value: output.value,
              schema: localShellOutputSchema
            });
            input.push({
              type: "local_shell_call_output",
              call_id: part.toolCallId,
              output: parsedOutput.output
            });
            continue;
          }
          if (hasShellTool && resolvedToolName === "shell" && output.type === "json") {
            const parsedOutput = await validateTypes({
              value: output.value,
              schema: shellOutputSchema
            });
            input.push({
              type: "shell_call_output",
              call_id: part.toolCallId,
              output: parsedOutput.output.map((item) => ({
                stdout: item.stdout,
                stderr: item.stderr,
                outcome: item.outcome.type === "timeout" ? { type: "timeout" } : {
                  type: "exit",
                  exit_code: item.outcome.exitCode
                }
              }))
            });
            continue;
          }
          if (hasApplyPatchTool && part.toolName === "apply_patch" && output.type === "json") {
            const parsedOutput = await validateTypes({
              value: output.value,
              schema: applyPatchOutputSchema
            });
            input.push({
              type: "apply_patch_call_output",
              call_id: part.toolCallId,
              status: parsedOutput.status,
              output: parsedOutput.output
            });
            continue;
          }
          if (customProviderToolNames == null ? void 0 : customProviderToolNames.has(resolvedToolName)) {
            let outputValue;
            switch (output.type) {
              case "text":
              case "error-text":
                outputValue = output.value;
                break;
              case "execution-denied":
                outputValue = (_p = output.reason) != null ? _p : "Tool execution denied.";
                break;
              case "json":
              case "error-json":
                outputValue = JSON.stringify(output.value);
                break;
              case "content":
                outputValue = output.value.map((item) => {
                  var _a211;
                  switch (item.type) {
                    case "text":
                      return { type: "input_text", text: item.text };
                    case "image-data":
                      return {
                        type: "input_image",
                        image_url: `data:${item.mediaType};base64,${item.data}`
                      };
                    case "image-url":
                      return {
                        type: "input_image",
                        image_url: item.url
                      };
                    case "file-data":
                      return {
                        type: "input_file",
                        filename: (_a211 = item.filename) != null ? _a211 : "data",
                        file_data: `data:${item.mediaType};base64,${item.data}`
                      };
                    case "file-url":
                      return {
                        type: "input_file",
                        file_url: item.url
                      };
                    default:
                      warnings.push({
                        type: "other",
                        message: `unsupported custom tool content part type: ${item.type}`
                      });
                      return void 0;
                  }
                }).filter(isNonNullable);
                break;
              default:
                outputValue = "";
            }
            input.push({
              type: "custom_tool_call_output",
              call_id: part.toolCallId,
              output: outputValue
            });
            continue;
          }
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = (_q = output.reason) != null ? _q : "Tool execution denied.";
              break;
            case "json":
            case "error-json":
              contentValue = JSON.stringify(output.value);
              break;
            case "content":
              contentValue = output.value.map((item) => {
                var _a211;
                switch (item.type) {
                  case "text": {
                    return { type: "input_text", text: item.text };
                  }
                  case "image-data": {
                    return {
                      type: "input_image",
                      image_url: `data:${item.mediaType};base64,${item.data}`
                    };
                  }
                  case "image-url": {
                    return {
                      type: "input_image",
                      image_url: item.url
                    };
                  }
                  case "file-data": {
                    return {
                      type: "input_file",
                      filename: (_a211 = item.filename) != null ? _a211 : "data",
                      file_data: `data:${item.mediaType};base64,${item.data}`
                    };
                  }
                  case "file-url": {
                    return {
                      type: "input_file",
                      file_url: item.url
                    };
                  }
                  default: {
                    warnings.push({
                      type: "other",
                      message: `unsupported tool content part type: ${item.type}`
                    });
                    return void 0;
                  }
                }
              }).filter(isNonNullable);
              break;
          }
          input.push({
            type: "function_call_output",
            call_id: part.toolCallId,
            output: contentValue
          });
        }
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  if (!store && input.some(
    (item) => "type" in item && item.type === "reasoning" && item.encrypted_content == null
  )) {
    warnings.push({
      type: "other",
      message: "Reasoning parts without encrypted content are not supported when store is false. Skipping reasoning parts."
    });
    input = input.filter(
      (item) => !("type" in item) || item.type !== "reasoning" || item.encrypted_content != null
    );
  }
  return { input, warnings };
}
function mapOpenAIResponseFinishReason({
  finishReason,
  hasFunctionCall
}) {
  switch (finishReason) {
    case void 0:
    case null:
      return hasFunctionCall ? "tool-calls" : "stop";
    case "max_output_tokens":
      return "length";
    case "content_filter":
      return "content-filter";
    default:
      return hasFunctionCall ? "tool-calls" : "other";
  }
}
async function prepareResponsesTools({
  tools,
  toolChoice,
  toolNameMapping,
  customProviderToolNames
}) {
  var _a31, _b27;
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const openaiTools2 = [];
  const resolvedCustomProviderToolNames = customProviderToolNames != null ? customProviderToolNames : /* @__PURE__ */ new Set();
  for (const tool3 of tools) {
    switch (tool3.type) {
      case "function": {
        const openaiOptions = (_a31 = tool3.providerOptions) == null ? void 0 : _a31.openai;
        const deferLoading = openaiOptions == null ? void 0 : openaiOptions.deferLoading;
        openaiTools2.push({
          type: "function",
          name: tool3.name,
          description: tool3.description,
          parameters: tool3.inputSchema,
          ...tool3.strict != null ? { strict: tool3.strict } : {},
          ...deferLoading != null ? { defer_loading: deferLoading } : {}
        });
        break;
      }
      case "provider": {
        switch (tool3.id) {
          case "openai.file_search": {
            const args = await validateTypes({
              value: tool3.args,
              schema: fileSearchArgsSchema
            });
            openaiTools2.push({
              type: "file_search",
              vector_store_ids: args.vectorStoreIds,
              max_num_results: args.maxNumResults,
              ranking_options: args.ranking ? {
                ranker: args.ranking.ranker,
                score_threshold: args.ranking.scoreThreshold
              } : void 0,
              filters: args.filters
            });
            break;
          }
          case "openai.local_shell": {
            openaiTools2.push({
              type: "local_shell"
            });
            break;
          }
          case "openai.shell": {
            const args = await validateTypes({
              value: tool3.args,
              schema: shellArgsSchema
            });
            openaiTools2.push({
              type: "shell",
              ...args.environment && {
                environment: mapShellEnvironment(args.environment)
              }
            });
            break;
          }
          case "openai.apply_patch": {
            openaiTools2.push({
              type: "apply_patch"
            });
            break;
          }
          case "openai.web_search_preview": {
            const args = await validateTypes({
              value: tool3.args,
              schema: webSearchPreviewArgsSchema
            });
            openaiTools2.push({
              type: "web_search_preview",
              search_context_size: args.searchContextSize,
              user_location: args.userLocation
            });
            break;
          }
          case "openai.web_search": {
            const args = await validateTypes({
              value: tool3.args,
              schema: webSearchArgsSchema
            });
            openaiTools2.push({
              type: "web_search",
              filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : void 0,
              external_web_access: args.externalWebAccess,
              search_context_size: args.searchContextSize,
              user_location: args.userLocation
            });
            break;
          }
          case "openai.code_interpreter": {
            const args = await validateTypes({
              value: tool3.args,
              schema: codeInterpreterArgsSchema
            });
            openaiTools2.push({
              type: "code_interpreter",
              container: args.container == null ? { type: "auto", file_ids: void 0 } : typeof args.container === "string" ? args.container : { type: "auto", file_ids: args.container.fileIds }
            });
            break;
          }
          case "openai.image_generation": {
            const args = await validateTypes({
              value: tool3.args,
              schema: imageGenerationArgsSchema
            });
            openaiTools2.push({
              type: "image_generation",
              background: args.background,
              input_fidelity: args.inputFidelity,
              input_image_mask: args.inputImageMask ? {
                file_id: args.inputImageMask.fileId,
                image_url: args.inputImageMask.imageUrl
              } : void 0,
              model: args.model,
              moderation: args.moderation,
              partial_images: args.partialImages,
              quality: args.quality,
              output_compression: args.outputCompression,
              output_format: args.outputFormat,
              size: args.size
            });
            break;
          }
          case "openai.mcp": {
            const args = await validateTypes({
              value: tool3.args,
              schema: mcpArgsSchema
            });
            const mapApprovalFilter = (filter6) => ({
              tool_names: filter6.toolNames
            });
            const requireApproval = args.requireApproval;
            const requireApprovalParam = requireApproval == null ? void 0 : typeof requireApproval === "string" ? requireApproval : requireApproval.never != null ? { never: mapApprovalFilter(requireApproval.never) } : void 0;
            openaiTools2.push({
              type: "mcp",
              server_label: args.serverLabel,
              allowed_tools: Array.isArray(args.allowedTools) ? args.allowedTools : args.allowedTools ? {
                read_only: args.allowedTools.readOnly,
                tool_names: args.allowedTools.toolNames
              } : void 0,
              authorization: args.authorization,
              connector_id: args.connectorId,
              headers: args.headers,
              require_approval: requireApprovalParam != null ? requireApprovalParam : "never",
              server_description: args.serverDescription,
              server_url: args.serverUrl
            });
            break;
          }
          case "openai.custom": {
            const args = await validateTypes({
              value: tool3.args,
              schema: customArgsSchema
            });
            openaiTools2.push({
              type: "custom",
              name: args.name,
              description: args.description,
              format: args.format
            });
            resolvedCustomProviderToolNames.add(args.name);
            break;
          }
          case "openai.tool_search": {
            const args = await validateTypes({
              value: tool3.args,
              schema: toolSearchArgsSchema
            });
            openaiTools2.push({
              type: "tool_search",
              ...args.execution != null ? { execution: args.execution } : {},
              ...args.description != null ? { description: args.description } : {},
              ...args.parameters != null ? { parameters: args.parameters } : {}
            });
            break;
          }
        }
        break;
      }
      default:
        toolWarnings.push({
          type: "unsupported",
          feature: `function tool ${tool3}`
        });
        break;
    }
  }
  if (toolChoice == null) {
    return { tools: openaiTools2, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
    case "required":
      return { tools: openaiTools2, toolChoice: type, toolWarnings };
    case "tool": {
      const resolvedToolName = (_b27 = toolNameMapping == null ? void 0 : toolNameMapping.toProviderToolName(toolChoice.toolName)) != null ? _b27 : toolChoice.toolName;
      return {
        tools: openaiTools2,
        toolChoice: resolvedToolName === "code_interpreter" || resolvedToolName === "file_search" || resolvedToolName === "image_generation" || resolvedToolName === "web_search_preview" || resolvedToolName === "web_search" || resolvedToolName === "mcp" || resolvedToolName === "apply_patch" ? { type: resolvedToolName } : resolvedCustomProviderToolNames.has(resolvedToolName) ? { type: "custom", name: resolvedToolName } : { type: "function", name: resolvedToolName },
        toolWarnings
      };
    }
    default: {
      const _exhaustiveCheck = type;
      throw new UnsupportedFunctionalityError({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
function mapShellEnvironment(environment) {
  if (environment.type === "containerReference") {
    const env22 = environment;
    return {
      type: "container_reference",
      container_id: env22.containerId
    };
  }
  if (environment.type === "containerAuto") {
    const env22 = environment;
    return {
      type: "container_auto",
      file_ids: env22.fileIds,
      memory_limit: env22.memoryLimit,
      network_policy: env22.networkPolicy == null ? void 0 : env22.networkPolicy.type === "disabled" ? { type: "disabled" } : {
        type: "allowlist",
        allowed_domains: env22.networkPolicy.allowedDomains,
        domain_secrets: env22.networkPolicy.domainSecrets
      },
      skills: mapShellSkills(env22.skills)
    };
  }
  const env2 = environment;
  return {
    type: "local",
    skills: env2.skills
  };
}
function mapShellSkills(skills) {
  return skills == null ? void 0 : skills.map(
    (skill) => skill.type === "skillReference" ? {
      type: "skill_reference",
      skill_id: skill.skillId,
      version: skill.version
    } : {
      type: "inline",
      name: skill.name,
      description: skill.description,
      source: {
        type: "base64",
        media_type: skill.source.mediaType,
        data: skill.source.data
      }
    }
  );
}
function extractApprovalRequestIdToToolCallIdMapping(prompt) {
  var _a31, _b27;
  const mapping = {};
  for (const message of prompt) {
    if (message.role !== "assistant") continue;
    for (const part of message.content) {
      if (part.type !== "tool-call") continue;
      const approvalRequestId = (_b27 = (_a31 = part.providerOptions) == null ? void 0 : _a31.openai) == null ? void 0 : _b27.approvalRequestId;
      if (approvalRequestId != null) {
        mapping[approvalRequestId] = part.toolCallId;
      }
    }
  }
  return mapping;
}
function isTextDeltaChunk(chunk) {
  return chunk.type === "response.output_text.delta";
}
function isResponseOutputItemDoneChunk(chunk) {
  return chunk.type === "response.output_item.done";
}
function isResponseFinishedChunk(chunk) {
  return chunk.type === "response.completed" || chunk.type === "response.incomplete";
}
function isResponseFailedChunk(chunk) {
  return chunk.type === "response.failed";
}
function isResponseCreatedChunk(chunk) {
  return chunk.type === "response.created";
}
function isResponseFunctionCallArgumentsDeltaChunk(chunk) {
  return chunk.type === "response.function_call_arguments.delta";
}
function isResponseCustomToolCallInputDeltaChunk(chunk) {
  return chunk.type === "response.custom_tool_call_input.delta";
}
function isResponseImageGenerationCallPartialImageChunk(chunk) {
  return chunk.type === "response.image_generation_call.partial_image";
}
function isResponseCodeInterpreterCallCodeDeltaChunk(chunk) {
  return chunk.type === "response.code_interpreter_call_code.delta";
}
function isResponseCodeInterpreterCallCodeDoneChunk(chunk) {
  return chunk.type === "response.code_interpreter_call_code.done";
}
function isResponseApplyPatchCallOperationDiffDeltaChunk(chunk) {
  return chunk.type === "response.apply_patch_call_operation_diff.delta";
}
function isResponseApplyPatchCallOperationDiffDoneChunk(chunk) {
  return chunk.type === "response.apply_patch_call_operation_diff.done";
}
function isResponseOutputItemAddedChunk(chunk) {
  return chunk.type === "response.output_item.added";
}
function isResponseAnnotationAddedChunk(chunk) {
  return chunk.type === "response.output_text.annotation.added";
}
function isErrorChunk(chunk) {
  return chunk.type === "error";
}
function mapWebSearchOutput(action) {
  var _a31;
  if (action == null) {
    return {};
  }
  switch (action.type) {
    case "search":
      return {
        action: { type: "search", query: (_a31 = action.query) != null ? _a31 : void 0 },
        // include sources when provided by the Responses API (behind include flag)
        ...action.sources != null && { sources: action.sources }
      };
    case "open_page":
      return { action: { type: "openPage", url: action.url } };
    case "find_in_page":
      return {
        action: {
          type: "findInPage",
          url: action.url,
          pattern: action.pattern
        }
      };
  }
}
function escapeJSONDelta(delta) {
  return JSON.stringify(delta).slice(1, -1);
}
function createOpenAI(options = {}) {
  var _a31, _b27;
  const baseURL = (_a31 = withoutTrailingSlash(
    loadOptionalSetting({
      settingValue: options.baseURL,
      environmentVariableName: "OPENAI_BASE_URL"
    })
  )) != null ? _a31 : "https://api.openai.com/v1";
  const providerName = (_b27 = options.name) != null ? _b27 : "openai";
  const getHeaders = () => withUserAgentSuffix(
    {
      Authorization: `Bearer ${loadApiKey({
        apiKey: options.apiKey,
        environmentVariableName: "OPENAI_API_KEY",
        description: "OpenAI"
      })}`,
      "OpenAI-Organization": options.organization,
      "OpenAI-Project": options.project,
      ...options.headers
    },
    `ai-sdk/openai/${VERSION4}`
  );
  const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
    provider: `${providerName}.chat`,
    url: ({ path: path33 }) => `${baseURL}${path33}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
    provider: `${providerName}.completion`,
    url: ({ path: path33 }) => `${baseURL}${path33}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
    provider: `${providerName}.embedding`,
    url: ({ path: path33 }) => `${baseURL}${path33}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
    provider: `${providerName}.image`,
    url: ({ path: path33 }) => `${baseURL}${path33}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
    provider: `${providerName}.transcription`,
    url: ({ path: path33 }) => `${baseURL}${path33}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
    provider: `${providerName}.speech`,
    url: ({ path: path33 }) => `${baseURL}${path33}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createLanguageModel = (modelId) => {
    if (new.target) {
      throw new Error(
        "The OpenAI model function cannot be called with the new keyword."
      );
    }
    return createResponsesModel(modelId);
  };
  const createResponsesModel = (modelId) => {
    return new OpenAIResponsesLanguageModel(modelId, {
      provider: `${providerName}.responses`,
      url: ({ path: path33 }) => `${baseURL}${path33}`,
      headers: getHeaders,
      fetch: options.fetch,
      fileIdPrefixes: ["file-"]
    });
  };
  const provider = function(modelId) {
    return createLanguageModel(modelId);
  };
  provider.specificationVersion = "v3";
  provider.languageModel = createLanguageModel;
  provider.chat = createChatModel;
  provider.completion = createCompletionModel;
  provider.responses = createResponsesModel;
  provider.embedding = createEmbeddingModel;
  provider.embeddingModel = createEmbeddingModel;
  provider.textEmbedding = createEmbeddingModel;
  provider.textEmbeddingModel = createEmbeddingModel;
  provider.image = createImageModel;
  provider.imageModel = createImageModel;
  provider.transcription = createTranscriptionModel;
  provider.transcriptionModel = createTranscriptionModel;
  provider.speech = createSpeechModel;
  provider.speechModel = createSpeechModel;
  provider.tools = openaiTools;
  return provider;
}
var openaiErrorDataSchema, openaiFailedResponseHandler, openaiChatResponseSchema, openaiChatChunkSchema, openaiLanguageModelChatOptions, OpenAIChatLanguageModel, openaiCompletionResponseSchema, openaiCompletionChunkSchema, openaiLanguageModelCompletionOptions, OpenAICompletionLanguageModel, openaiEmbeddingModelOptions, openaiTextEmbeddingResponseSchema, OpenAIEmbeddingModel, openaiImageResponseSchema, modelMaxImagesPerCall, defaultResponseFormatPrefixes, OpenAIImageModel, applyPatchInputSchema, applyPatchOutputSchema, applyPatchArgsSchema, applyPatchToolFactory, applyPatch, codeInterpreterInputSchema, codeInterpreterOutputSchema, codeInterpreterArgsSchema, codeInterpreterToolFactory, codeInterpreter, customArgsSchema, customInputSchema, customToolFactory, customTool, comparisonFilterSchema, compoundFilterSchema, fileSearchArgsSchema, fileSearchOutputSchema, fileSearch, imageGenerationArgsSchema, imageGenerationInputSchema, imageGenerationOutputSchema, imageGenerationToolFactory, imageGeneration, localShellInputSchema, localShellOutputSchema, localShell, shellInputSchema, shellOutputSchema, shellSkillsSchema, shellArgsSchema, shell, toolSearchArgsSchema, toolSearchInputSchema, toolSearchOutputSchema, toolSearchToolFactory, toolSearch, webSearchArgsSchema, webSearchInputSchema, webSearchOutputSchema, webSearchToolFactory, webSearch, webSearchPreviewArgsSchema, webSearchPreviewInputSchema, webSearchPreviewOutputSchema, webSearchPreview, jsonValueSchema, mcpArgsSchema, mcpInputSchema, mcpOutputSchema, mcpToolFactory, mcp, openaiTools, openaiResponsesReasoningProviderOptionsSchema, jsonValueSchema2, openaiResponsesChunkSchema, openaiResponsesResponseSchema, TOP_LOGPROBS_MAX, openaiResponsesReasoningModelIds, openaiResponsesModelIds, openaiLanguageModelResponsesOptionsSchema, OpenAIResponsesLanguageModel, openaiSpeechModelOptionsSchema, OpenAISpeechModel, openaiTranscriptionResponseSchema, openAITranscriptionModelOptions, languageMap, OpenAITranscriptionModel, VERSION4, openai;
var init_dist6 = __esm({
  "node_modules/@ai-sdk/openai/dist/index.mjs"() {
    "use strict";
    init_dist5();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist5();
    init_dist3();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_dist3();
    init_v42();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    openaiErrorDataSchema = external_exports.object({
      error: external_exports.object({
        message: external_exports.string(),
        // The additional information below is handled loosely to support
        // OpenAI-compatible providers that have slightly different error
        // responses:
        type: external_exports.string().nullish(),
        param: external_exports.any().nullish(),
        code: external_exports.union([external_exports.string(), external_exports.number()]).nullish()
      })
    });
    openaiFailedResponseHandler = createJsonErrorResponseHandler({
      errorSchema: openaiErrorDataSchema,
      errorToMessage: (data) => data.error.message
    });
    openaiChatResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          id: external_exports.string().nullish(),
          created: external_exports.number().nullish(),
          model: external_exports.string().nullish(),
          choices: external_exports.array(
            external_exports.object({
              message: external_exports.object({
                role: external_exports.literal("assistant").nullish(),
                content: external_exports.string().nullish(),
                tool_calls: external_exports.array(
                  external_exports.object({
                    id: external_exports.string().nullish(),
                    type: external_exports.literal("function"),
                    function: external_exports.object({
                      name: external_exports.string(),
                      arguments: external_exports.string()
                    })
                  })
                ).nullish(),
                annotations: external_exports.array(
                  external_exports.object({
                    type: external_exports.literal("url_citation"),
                    url_citation: external_exports.object({
                      start_index: external_exports.number(),
                      end_index: external_exports.number(),
                      url: external_exports.string(),
                      title: external_exports.string()
                    })
                  })
                ).nullish()
              }),
              index: external_exports.number(),
              logprobs: external_exports.object({
                content: external_exports.array(
                  external_exports.object({
                    token: external_exports.string(),
                    logprob: external_exports.number(),
                    top_logprobs: external_exports.array(
                      external_exports.object({
                        token: external_exports.string(),
                        logprob: external_exports.number()
                      })
                    )
                  })
                ).nullish()
              }).nullish(),
              finish_reason: external_exports.string().nullish()
            })
          ),
          usage: external_exports.object({
            prompt_tokens: external_exports.number().nullish(),
            completion_tokens: external_exports.number().nullish(),
            total_tokens: external_exports.number().nullish(),
            prompt_tokens_details: external_exports.object({
              cached_tokens: external_exports.number().nullish()
            }).nullish(),
            completion_tokens_details: external_exports.object({
              reasoning_tokens: external_exports.number().nullish(),
              accepted_prediction_tokens: external_exports.number().nullish(),
              rejected_prediction_tokens: external_exports.number().nullish()
            }).nullish()
          }).nullish()
        })
      )
    );
    openaiChatChunkSchema = lazySchema(
      () => zodSchema(
        external_exports.union([
          external_exports.object({
            id: external_exports.string().nullish(),
            created: external_exports.number().nullish(),
            model: external_exports.string().nullish(),
            choices: external_exports.array(
              external_exports.object({
                delta: external_exports.object({
                  role: external_exports.enum(["assistant"]).nullish(),
                  content: external_exports.string().nullish(),
                  tool_calls: external_exports.array(
                    external_exports.object({
                      index: external_exports.number(),
                      id: external_exports.string().nullish(),
                      type: external_exports.literal("function").nullish(),
                      function: external_exports.object({
                        name: external_exports.string().nullish(),
                        arguments: external_exports.string().nullish()
                      })
                    })
                  ).nullish(),
                  annotations: external_exports.array(
                    external_exports.object({
                      type: external_exports.literal("url_citation"),
                      url_citation: external_exports.object({
                        start_index: external_exports.number(),
                        end_index: external_exports.number(),
                        url: external_exports.string(),
                        title: external_exports.string()
                      })
                    })
                  ).nullish()
                }).nullish(),
                logprobs: external_exports.object({
                  content: external_exports.array(
                    external_exports.object({
                      token: external_exports.string(),
                      logprob: external_exports.number(),
                      top_logprobs: external_exports.array(
                        external_exports.object({
                          token: external_exports.string(),
                          logprob: external_exports.number()
                        })
                      )
                    })
                  ).nullish()
                }).nullish(),
                finish_reason: external_exports.string().nullish(),
                index: external_exports.number()
              })
            ),
            usage: external_exports.object({
              prompt_tokens: external_exports.number().nullish(),
              completion_tokens: external_exports.number().nullish(),
              total_tokens: external_exports.number().nullish(),
              prompt_tokens_details: external_exports.object({
                cached_tokens: external_exports.number().nullish()
              }).nullish(),
              completion_tokens_details: external_exports.object({
                reasoning_tokens: external_exports.number().nullish(),
                accepted_prediction_tokens: external_exports.number().nullish(),
                rejected_prediction_tokens: external_exports.number().nullish()
              }).nullish()
            }).nullish()
          }),
          openaiErrorDataSchema
        ])
      )
    );
    openaiLanguageModelChatOptions = lazySchema(
      () => zodSchema(
        external_exports.object({
          /**
           * Modify the likelihood of specified tokens appearing in the completion.
           *
           * Accepts a JSON object that maps tokens (specified by their token ID in
           * the GPT tokenizer) to an associated bias value from -100 to 100.
           */
          logitBias: external_exports.record(external_exports.coerce.number(), external_exports.number()).optional(),
          /**
           * Return the log probabilities of the tokens.
           *
           * Setting to true will return the log probabilities of the tokens that
           * were generated.
           *
           * Setting to a number will return the log probabilities of the top n
           * tokens that were generated.
           */
          logprobs: external_exports.union([external_exports.boolean(), external_exports.number()]).optional(),
          /**
           * Whether to enable parallel function calling during tool use. Default to true.
           */
          parallelToolCalls: external_exports.boolean().optional(),
          /**
           * A unique identifier representing your end-user, which can help OpenAI to
           * monitor and detect abuse.
           */
          user: external_exports.string().optional(),
          /**
           * Reasoning effort for reasoning models. Defaults to `medium`.
           */
          reasoningEffort: external_exports.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
          /**
           * Maximum number of completion tokens to generate. Useful for reasoning models.
           */
          maxCompletionTokens: external_exports.number().optional(),
          /**
           * Whether to enable persistence in responses API.
           */
          store: external_exports.boolean().optional(),
          /**
           * Metadata to associate with the request.
           */
          metadata: external_exports.record(external_exports.string().max(64), external_exports.string().max(512)).optional(),
          /**
           * Parameters for prediction mode.
           */
          prediction: external_exports.record(external_exports.string(), external_exports.any()).optional(),
          /**
           * Service tier for the request.
           * - 'auto': Default service tier. The request will be processed with the service tier configured in the
           *           Project settings. Unless otherwise configured, the Project will use 'default'.
           * - 'flex': 50% cheaper processing at the cost of increased latency. Only available for o3 and o4-mini models.
           * - 'priority': Higher-speed processing with predictably low latency at premium cost. Available for Enterprise customers.
           * - 'default': The request will be processed with the standard pricing and performance for the selected model.
           *
           * @default 'auto'
           */
          serviceTier: external_exports.enum(["auto", "flex", "priority", "default"]).optional(),
          /**
           * Whether to use strict JSON schema validation.
           *
           * @default true
           */
          strictJsonSchema: external_exports.boolean().optional(),
          /**
           * Controls the verbosity of the model's responses.
           * Lower values will result in more concise responses, while higher values will result in more verbose responses.
           */
          textVerbosity: external_exports.enum(["low", "medium", "high"]).optional(),
          /**
           * A cache key for prompt caching. Allows manual control over prompt caching behavior.
           * Useful for improving cache hit rates and working around automatic caching issues.
           */
          promptCacheKey: external_exports.string().optional(),
          /**
           * The retention policy for the prompt cache.
           * - 'in_memory': Default. Standard prompt caching behavior.
           * - '24h': Extended prompt caching that keeps cached prefixes active for up to 24 hours.
           *          Currently only available for 5.1 series models.
           *
           * @default 'in_memory'
           */
          promptCacheRetention: external_exports.enum(["in_memory", "24h"]).optional(),
          /**
           * A stable identifier used to help detect users of your application
           * that may be violating OpenAI's usage policies. The IDs should be a
           * string that uniquely identifies each user. We recommend hashing their
           * username or email address, in order to avoid sending us any identifying
           * information.
           */
          safetyIdentifier: external_exports.string().optional(),
          /**
           * Override the system message mode for this model.
           * - 'system': Use the 'system' role for system messages (default for most models)
           * - 'developer': Use the 'developer' role for system messages (used by reasoning models)
           * - 'remove': Remove system messages entirely
           *
           * If not specified, the mode is automatically determined based on the model.
           */
          systemMessageMode: external_exports.enum(["system", "developer", "remove"]).optional(),
          /**
           * Force treating this model as a reasoning model.
           *
           * This is useful for "stealth" reasoning models (e.g. via a custom baseURL)
           * where the model ID is not recognized by the SDK's allowlist.
           *
           * When enabled, the SDK applies reasoning-model parameter compatibility rules
           * and defaults `systemMessageMode` to `developer` unless overridden.
           */
          forceReasoning: external_exports.boolean().optional()
        })
      )
    );
    OpenAIChatLanguageModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.supportedUrls = {
          "image/*": [/^https?:\/\/.*$/]
        };
        this.modelId = modelId;
        this.config = config3;
      }
      get provider() {
        return this.config.provider;
      }
      async getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        stopSequences,
        responseFormat,
        seed,
        tools,
        toolChoice,
        providerOptions
      }) {
        var _a31, _b27, _c, _d, _e;
        const warnings = [];
        const openaiOptions = (_a31 = await parseProviderOptions({
          provider: "openai",
          providerOptions,
          schema: openaiLanguageModelChatOptions
        })) != null ? _a31 : {};
        const modelCapabilities = getOpenAILanguageModelCapabilities(this.modelId);
        const isReasoningModel = (_b27 = openaiOptions.forceReasoning) != null ? _b27 : modelCapabilities.isReasoningModel;
        if (topK != null) {
          warnings.push({ type: "unsupported", feature: "topK" });
        }
        const { messages, warnings: messageWarnings } = convertToOpenAIChatMessages(
          {
            prompt,
            systemMessageMode: (_c = openaiOptions.systemMessageMode) != null ? _c : isReasoningModel ? "developer" : modelCapabilities.systemMessageMode
          }
        );
        warnings.push(...messageWarnings);
        const strictJsonSchema = (_d = openaiOptions.strictJsonSchema) != null ? _d : true;
        const baseArgs = {
          // model id:
          model: this.modelId,
          // model specific settings:
          logit_bias: openaiOptions.logitBias,
          logprobs: openaiOptions.logprobs === true || typeof openaiOptions.logprobs === "number" ? true : void 0,
          top_logprobs: typeof openaiOptions.logprobs === "number" ? openaiOptions.logprobs : typeof openaiOptions.logprobs === "boolean" ? openaiOptions.logprobs ? 0 : void 0 : void 0,
          user: openaiOptions.user,
          parallel_tool_calls: openaiOptions.parallelToolCalls,
          // standardized settings:
          max_tokens: maxOutputTokens,
          temperature,
          top_p: topP,
          frequency_penalty: frequencyPenalty,
          presence_penalty: presencePenalty,
          response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
            type: "json_schema",
            json_schema: {
              schema: responseFormat.schema,
              strict: strictJsonSchema,
              name: (_e = responseFormat.name) != null ? _e : "response",
              description: responseFormat.description
            }
          } : { type: "json_object" } : void 0,
          stop: stopSequences,
          seed,
          verbosity: openaiOptions.textVerbosity,
          // openai specific settings:
          // TODO AI SDK 6: remove, we auto-map maxOutputTokens now
          max_completion_tokens: openaiOptions.maxCompletionTokens,
          store: openaiOptions.store,
          metadata: openaiOptions.metadata,
          prediction: openaiOptions.prediction,
          reasoning_effort: openaiOptions.reasoningEffort,
          service_tier: openaiOptions.serviceTier,
          prompt_cache_key: openaiOptions.promptCacheKey,
          prompt_cache_retention: openaiOptions.promptCacheRetention,
          safety_identifier: openaiOptions.safetyIdentifier,
          // messages:
          messages
        };
        if (isReasoningModel) {
          if (openaiOptions.reasoningEffort !== "none" || !modelCapabilities.supportsNonReasoningParameters) {
            if (baseArgs.temperature != null) {
              baseArgs.temperature = void 0;
              warnings.push({
                type: "unsupported",
                feature: "temperature",
                details: "temperature is not supported for reasoning models"
              });
            }
            if (baseArgs.top_p != null) {
              baseArgs.top_p = void 0;
              warnings.push({
                type: "unsupported",
                feature: "topP",
                details: "topP is not supported for reasoning models"
              });
            }
            if (baseArgs.logprobs != null) {
              baseArgs.logprobs = void 0;
              warnings.push({
                type: "other",
                message: "logprobs is not supported for reasoning models"
              });
            }
          }
          if (baseArgs.frequency_penalty != null) {
            baseArgs.frequency_penalty = void 0;
            warnings.push({
              type: "unsupported",
              feature: "frequencyPenalty",
              details: "frequencyPenalty is not supported for reasoning models"
            });
          }
          if (baseArgs.presence_penalty != null) {
            baseArgs.presence_penalty = void 0;
            warnings.push({
              type: "unsupported",
              feature: "presencePenalty",
              details: "presencePenalty is not supported for reasoning models"
            });
          }
          if (baseArgs.logit_bias != null) {
            baseArgs.logit_bias = void 0;
            warnings.push({
              type: "other",
              message: "logitBias is not supported for reasoning models"
            });
          }
          if (baseArgs.top_logprobs != null) {
            baseArgs.top_logprobs = void 0;
            warnings.push({
              type: "other",
              message: "topLogprobs is not supported for reasoning models"
            });
          }
          if (baseArgs.max_tokens != null) {
            if (baseArgs.max_completion_tokens == null) {
              baseArgs.max_completion_tokens = baseArgs.max_tokens;
            }
            baseArgs.max_tokens = void 0;
          }
        } else if (this.modelId.startsWith("gpt-4o-search-preview") || this.modelId.startsWith("gpt-4o-mini-search-preview")) {
          if (baseArgs.temperature != null) {
            baseArgs.temperature = void 0;
            warnings.push({
              type: "unsupported",
              feature: "temperature",
              details: "temperature is not supported for the search preview models and has been removed."
            });
          }
        }
        if (openaiOptions.serviceTier === "flex" && !modelCapabilities.supportsFlexProcessing) {
          warnings.push({
            type: "unsupported",
            feature: "serviceTier",
            details: "flex processing is only available for o3, o4-mini, and gpt-5 models"
          });
          baseArgs.service_tier = void 0;
        }
        if (openaiOptions.serviceTier === "priority" && !modelCapabilities.supportsPriorityProcessing) {
          warnings.push({
            type: "unsupported",
            feature: "serviceTier",
            details: "priority processing is only available for supported models (gpt-4, gpt-5, gpt-5-mini, o3, o4-mini) and requires Enterprise access. gpt-5-nano is not supported"
          });
          baseArgs.service_tier = void 0;
        }
        const {
          tools: openaiTools2,
          toolChoice: openaiToolChoice,
          toolWarnings
        } = prepareChatTools({
          tools,
          toolChoice
        });
        return {
          args: {
            ...baseArgs,
            tools: openaiTools2,
            tool_choice: openaiToolChoice
          },
          warnings: [...warnings, ...toolWarnings]
        };
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g;
        const { args: body, warnings } = await this.getArgs(options);
        const {
          responseHeaders,
          value: response,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            openaiChatResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const choice2 = response.choices[0];
        const content = [];
        const text2 = choice2.message.content;
        if (text2 != null && text2.length > 0) {
          content.push({ type: "text", text: text2 });
        }
        for (const toolCall of (_a31 = choice2.message.tool_calls) != null ? _a31 : []) {
          content.push({
            type: "tool-call",
            toolCallId: (_b27 = toolCall.id) != null ? _b27 : generateId(),
            toolName: toolCall.function.name,
            input: toolCall.function.arguments
          });
        }
        for (const annotation of (_c = choice2.message.annotations) != null ? _c : []) {
          content.push({
            type: "source",
            sourceType: "url",
            id: generateId(),
            url: annotation.url_citation.url,
            title: annotation.url_citation.title
          });
        }
        const completionTokenDetails = (_d = response.usage) == null ? void 0 : _d.completion_tokens_details;
        const promptTokenDetails = (_e = response.usage) == null ? void 0 : _e.prompt_tokens_details;
        const providerMetadata = { openai: {} };
        if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
          providerMetadata.openai.acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
        }
        if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
          providerMetadata.openai.rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
        }
        if (((_f = choice2.logprobs) == null ? void 0 : _f.content) != null) {
          providerMetadata.openai.logprobs = choice2.logprobs.content;
        }
        return {
          content,
          finishReason: {
            unified: mapOpenAIFinishReason(choice2.finish_reason),
            raw: (_g = choice2.finish_reason) != null ? _g : void 0
          },
          usage: convertOpenAIChatUsage(response.usage),
          request: { body },
          response: {
            ...getResponseMetadata(response),
            headers: responseHeaders,
            body: rawResponse
          },
          warnings,
          providerMetadata
        };
      }
      async doStream(options) {
        const { args, warnings } = await this.getArgs(options);
        const body = {
          ...args,
          stream: true,
          stream_options: {
            include_usage: true
          }
        };
        const { responseHeaders, value: response } = await postJsonToApi({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler(
            openaiChatChunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const toolCalls = [];
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        let usage = void 0;
        let metadataExtracted = false;
        let isActiveText = false;
        const providerMetadata = { openai: {} };
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                if ("error" in value) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: value.error });
                  return;
                }
                if (!metadataExtracted) {
                  const metadata = getResponseMetadata(value);
                  if (Object.values(metadata).some(Boolean)) {
                    metadataExtracted = true;
                    controller.enqueue({
                      type: "response-metadata",
                      ...getResponseMetadata(value)
                    });
                  }
                }
                if (value.usage != null) {
                  usage = value.usage;
                  if (((_a31 = value.usage.completion_tokens_details) == null ? void 0 : _a31.accepted_prediction_tokens) != null) {
                    providerMetadata.openai.acceptedPredictionTokens = (_b27 = value.usage.completion_tokens_details) == null ? void 0 : _b27.accepted_prediction_tokens;
                  }
                  if (((_c = value.usage.completion_tokens_details) == null ? void 0 : _c.rejected_prediction_tokens) != null) {
                    providerMetadata.openai.rejectedPredictionTokens = (_d = value.usage.completion_tokens_details) == null ? void 0 : _d.rejected_prediction_tokens;
                  }
                }
                const choice2 = value.choices[0];
                if ((choice2 == null ? void 0 : choice2.finish_reason) != null) {
                  finishReason = {
                    unified: mapOpenAIFinishReason(choice2.finish_reason),
                    raw: choice2.finish_reason
                  };
                }
                if (((_e = choice2 == null ? void 0 : choice2.logprobs) == null ? void 0 : _e.content) != null) {
                  providerMetadata.openai.logprobs = choice2.logprobs.content;
                }
                if ((choice2 == null ? void 0 : choice2.delta) == null) {
                  return;
                }
                const delta = choice2.delta;
                if (delta.content != null) {
                  if (!isActiveText) {
                    controller.enqueue({ type: "text-start", id: "0" });
                    isActiveText = true;
                  }
                  controller.enqueue({
                    type: "text-delta",
                    id: "0",
                    delta: delta.content
                  });
                }
                if (delta.tool_calls != null) {
                  for (const toolCallDelta of delta.tool_calls) {
                    const index = toolCallDelta.index;
                    if (toolCalls[index] == null) {
                      if (toolCallDelta.type != null && toolCallDelta.type !== "function") {
                        throw new InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'function' type.`
                        });
                      }
                      if (toolCallDelta.id == null) {
                        throw new InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'id' to be a string.`
                        });
                      }
                      if (((_f = toolCallDelta.function) == null ? void 0 : _f.name) == null) {
                        throw new InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'function.name' to be a string.`
                        });
                      }
                      controller.enqueue({
                        type: "tool-input-start",
                        id: toolCallDelta.id,
                        toolName: toolCallDelta.function.name
                      });
                      toolCalls[index] = {
                        id: toolCallDelta.id,
                        type: "function",
                        function: {
                          name: toolCallDelta.function.name,
                          arguments: (_g = toolCallDelta.function.arguments) != null ? _g : ""
                        },
                        hasFinished: false
                      };
                      const toolCall2 = toolCalls[index];
                      if (((_h = toolCall2.function) == null ? void 0 : _h.name) != null && ((_i = toolCall2.function) == null ? void 0 : _i.arguments) != null) {
                        if (toolCall2.function.arguments.length > 0) {
                          controller.enqueue({
                            type: "tool-input-delta",
                            id: toolCall2.id,
                            delta: toolCall2.function.arguments
                          });
                        }
                        if (isParsableJson(toolCall2.function.arguments)) {
                          controller.enqueue({
                            type: "tool-input-end",
                            id: toolCall2.id
                          });
                          controller.enqueue({
                            type: "tool-call",
                            toolCallId: (_j = toolCall2.id) != null ? _j : generateId(),
                            toolName: toolCall2.function.name,
                            input: toolCall2.function.arguments
                          });
                          toolCall2.hasFinished = true;
                        }
                      }
                      continue;
                    }
                    const toolCall = toolCalls[index];
                    if (toolCall.hasFinished) {
                      continue;
                    }
                    if (((_k = toolCallDelta.function) == null ? void 0 : _k.arguments) != null) {
                      toolCall.function.arguments += (_m = (_l = toolCallDelta.function) == null ? void 0 : _l.arguments) != null ? _m : "";
                    }
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.id,
                      delta: (_n = toolCallDelta.function.arguments) != null ? _n : ""
                    });
                    if (((_o = toolCall.function) == null ? void 0 : _o.name) != null && ((_p = toolCall.function) == null ? void 0 : _p.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: (_q = toolCall.id) != null ? _q : generateId(),
                        toolName: toolCall.function.name,
                        input: toolCall.function.arguments
                      });
                      toolCall.hasFinished = true;
                    }
                  }
                }
                if (delta.annotations != null) {
                  for (const annotation of delta.annotations) {
                    controller.enqueue({
                      type: "source",
                      sourceType: "url",
                      id: generateId(),
                      url: annotation.url_citation.url,
                      title: annotation.url_citation.title
                    });
                  }
                }
              },
              flush(controller) {
                if (isActiveText) {
                  controller.enqueue({ type: "text-end", id: "0" });
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage: convertOpenAIChatUsage(usage),
                  ...providerMetadata != null ? { providerMetadata } : {}
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    openaiCompletionResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          id: external_exports.string().nullish(),
          created: external_exports.number().nullish(),
          model: external_exports.string().nullish(),
          choices: external_exports.array(
            external_exports.object({
              text: external_exports.string(),
              finish_reason: external_exports.string(),
              logprobs: external_exports.object({
                tokens: external_exports.array(external_exports.string()),
                token_logprobs: external_exports.array(external_exports.number()),
                top_logprobs: external_exports.array(external_exports.record(external_exports.string(), external_exports.number())).nullish()
              }).nullish()
            })
          ),
          usage: external_exports.object({
            prompt_tokens: external_exports.number(),
            completion_tokens: external_exports.number(),
            total_tokens: external_exports.number()
          }).nullish()
        })
      )
    );
    openaiCompletionChunkSchema = lazySchema(
      () => zodSchema(
        external_exports.union([
          external_exports.object({
            id: external_exports.string().nullish(),
            created: external_exports.number().nullish(),
            model: external_exports.string().nullish(),
            choices: external_exports.array(
              external_exports.object({
                text: external_exports.string(),
                finish_reason: external_exports.string().nullish(),
                index: external_exports.number(),
                logprobs: external_exports.object({
                  tokens: external_exports.array(external_exports.string()),
                  token_logprobs: external_exports.array(external_exports.number()),
                  top_logprobs: external_exports.array(external_exports.record(external_exports.string(), external_exports.number())).nullish()
                }).nullish()
              })
            ),
            usage: external_exports.object({
              prompt_tokens: external_exports.number(),
              completion_tokens: external_exports.number(),
              total_tokens: external_exports.number()
            }).nullish()
          }),
          openaiErrorDataSchema
        ])
      )
    );
    openaiLanguageModelCompletionOptions = lazySchema(
      () => zodSchema(
        external_exports.object({
          /**
           * Echo back the prompt in addition to the completion.
           */
          echo: external_exports.boolean().optional(),
          /**
           * Modify the likelihood of specified tokens appearing in the completion.
           *
           * Accepts a JSON object that maps tokens (specified by their token ID in
           * the GPT tokenizer) to an associated bias value from -100 to 100. You
           * can use this tokenizer tool to convert text to token IDs. Mathematically,
           * the bias is added to the logits generated by the model prior to sampling.
           * The exact effect will vary per model, but values between -1 and 1 should
           * decrease or increase likelihood of selection; values like -100 or 100
           * should result in a ban or exclusive selection of the relevant token.
           *
           * As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
           * token from being generated.
           */
          logitBias: external_exports.record(external_exports.string(), external_exports.number()).optional(),
          /**
           * The suffix that comes after a completion of inserted text.
           */
          suffix: external_exports.string().optional(),
          /**
           * A unique identifier representing your end-user, which can help OpenAI to
           * monitor and detect abuse. Learn more.
           */
          user: external_exports.string().optional(),
          /**
           * Return the log probabilities of the tokens. Including logprobs will increase
           * the response size and can slow down response times. However, it can
           * be useful to better understand how the model is behaving.
           * Setting to true will return the log probabilities of the tokens that
           * were generated.
           * Setting to a number will return the log probabilities of the top n
           * tokens that were generated.
           */
          logprobs: external_exports.union([external_exports.boolean(), external_exports.number()]).optional()
        })
      )
    );
    OpenAICompletionLanguageModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.supportedUrls = {
          // No URLs are supported for completion models.
        };
        this.modelId = modelId;
        this.config = config3;
      }
      get providerOptionsName() {
        return this.config.provider.split(".")[0].trim();
      }
      get provider() {
        return this.config.provider;
      }
      async getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        stopSequences: userStopSequences,
        responseFormat,
        tools,
        toolChoice,
        seed,
        providerOptions
      }) {
        const warnings = [];
        const openaiOptions = {
          ...await parseProviderOptions({
            provider: "openai",
            providerOptions,
            schema: openaiLanguageModelCompletionOptions
          }),
          ...await parseProviderOptions({
            provider: this.providerOptionsName,
            providerOptions,
            schema: openaiLanguageModelCompletionOptions
          })
        };
        if (topK != null) {
          warnings.push({ type: "unsupported", feature: "topK" });
        }
        if (tools == null ? void 0 : tools.length) {
          warnings.push({ type: "unsupported", feature: "tools" });
        }
        if (toolChoice != null) {
          warnings.push({ type: "unsupported", feature: "toolChoice" });
        }
        if (responseFormat != null && responseFormat.type !== "text") {
          warnings.push({
            type: "unsupported",
            feature: "responseFormat",
            details: "JSON response format is not supported."
          });
        }
        const { prompt: completionPrompt, stopSequences } = convertToOpenAICompletionPrompt({ prompt });
        const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
        return {
          args: {
            // model id:
            model: this.modelId,
            // model specific settings:
            echo: openaiOptions.echo,
            logit_bias: openaiOptions.logitBias,
            logprobs: (openaiOptions == null ? void 0 : openaiOptions.logprobs) === true ? 0 : (openaiOptions == null ? void 0 : openaiOptions.logprobs) === false ? void 0 : openaiOptions == null ? void 0 : openaiOptions.logprobs,
            suffix: openaiOptions.suffix,
            user: openaiOptions.user,
            // standardized settings:
            max_tokens: maxOutputTokens,
            temperature,
            top_p: topP,
            frequency_penalty: frequencyPenalty,
            presence_penalty: presencePenalty,
            seed,
            // prompt:
            prompt: completionPrompt,
            // stop sequences:
            stop: stop.length > 0 ? stop : void 0
          },
          warnings
        };
      }
      async doGenerate(options) {
        var _a31;
        const { args, warnings } = await this.getArgs(options);
        const {
          responseHeaders,
          value: response,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: this.config.url({
            path: "/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body: args,
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            openaiCompletionResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const choice2 = response.choices[0];
        const providerMetadata = { openai: {} };
        if (choice2.logprobs != null) {
          providerMetadata.openai.logprobs = choice2.logprobs;
        }
        return {
          content: [{ type: "text", text: choice2.text }],
          usage: convertOpenAICompletionUsage(response.usage),
          finishReason: {
            unified: mapOpenAIFinishReason2(choice2.finish_reason),
            raw: (_a31 = choice2.finish_reason) != null ? _a31 : void 0
          },
          request: { body: args },
          response: {
            ...getResponseMetadata2(response),
            headers: responseHeaders,
            body: rawResponse
          },
          providerMetadata,
          warnings
        };
      }
      async doStream(options) {
        const { args, warnings } = await this.getArgs(options);
        const body = {
          ...args,
          stream: true,
          stream_options: {
            include_usage: true
          }
        };
        const { responseHeaders, value: response } = await postJsonToApi({
          url: this.config.url({
            path: "/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler(
            openaiCompletionChunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        const providerMetadata = { openai: {} };
        let usage = void 0;
        let isFirstChunk = true;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                if ("error" in value) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: value.error });
                  return;
                }
                if (isFirstChunk) {
                  isFirstChunk = false;
                  controller.enqueue({
                    type: "response-metadata",
                    ...getResponseMetadata2(value)
                  });
                  controller.enqueue({ type: "text-start", id: "0" });
                }
                if (value.usage != null) {
                  usage = value.usage;
                }
                const choice2 = value.choices[0];
                if ((choice2 == null ? void 0 : choice2.finish_reason) != null) {
                  finishReason = {
                    unified: mapOpenAIFinishReason2(choice2.finish_reason),
                    raw: choice2.finish_reason
                  };
                }
                if ((choice2 == null ? void 0 : choice2.logprobs) != null) {
                  providerMetadata.openai.logprobs = choice2.logprobs;
                }
                if ((choice2 == null ? void 0 : choice2.text) != null && choice2.text.length > 0) {
                  controller.enqueue({
                    type: "text-delta",
                    id: "0",
                    delta: choice2.text
                  });
                }
              },
              flush(controller) {
                if (!isFirstChunk) {
                  controller.enqueue({ type: "text-end", id: "0" });
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  providerMetadata,
                  usage: convertOpenAICompletionUsage(usage)
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    openaiEmbeddingModelOptions = lazySchema(
      () => zodSchema(
        external_exports.object({
          /**
           * The number of dimensions the resulting output embeddings should have.
           * Only supported in text-embedding-3 and later models.
           */
          dimensions: external_exports.number().optional(),
          /**
           * A unique identifier representing your end-user, which can help OpenAI to
           * monitor and detect abuse. Learn more.
           */
          user: external_exports.string().optional()
        })
      )
    );
    openaiTextEmbeddingResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          data: external_exports.array(external_exports.object({ embedding: external_exports.array(external_exports.number()) })),
          usage: external_exports.object({ prompt_tokens: external_exports.number() }).nullish()
        })
      )
    );
    OpenAIEmbeddingModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.maxEmbeddingsPerCall = 2048;
        this.supportsParallelCalls = true;
        this.modelId = modelId;
        this.config = config3;
      }
      get provider() {
        return this.config.provider;
      }
      async doEmbed({
        values,
        headers,
        abortSignal,
        providerOptions
      }) {
        var _a31;
        if (values.length > this.maxEmbeddingsPerCall) {
          throw new TooManyEmbeddingValuesForCallError({
            provider: this.provider,
            modelId: this.modelId,
            maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
            values
          });
        }
        const openaiOptions = (_a31 = await parseProviderOptions({
          provider: "openai",
          providerOptions,
          schema: openaiEmbeddingModelOptions
        })) != null ? _a31 : {};
        const {
          responseHeaders,
          value: response,
          rawValue
        } = await postJsonToApi({
          url: this.config.url({
            path: "/embeddings",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), headers),
          body: {
            model: this.modelId,
            input: values,
            encoding_format: "float",
            dimensions: openaiOptions.dimensions,
            user: openaiOptions.user
          },
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            openaiTextEmbeddingResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        return {
          warnings: [],
          embeddings: response.data.map((item) => item.embedding),
          usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
          response: { headers: responseHeaders, body: rawValue }
        };
      }
    };
    openaiImageResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          created: external_exports.number().nullish(),
          data: external_exports.array(
            external_exports.object({
              b64_json: external_exports.string(),
              revised_prompt: external_exports.string().nullish()
            })
          ),
          background: external_exports.string().nullish(),
          output_format: external_exports.string().nullish(),
          size: external_exports.string().nullish(),
          quality: external_exports.string().nullish(),
          usage: external_exports.object({
            input_tokens: external_exports.number().nullish(),
            output_tokens: external_exports.number().nullish(),
            total_tokens: external_exports.number().nullish(),
            input_tokens_details: external_exports.object({
              image_tokens: external_exports.number().nullish(),
              text_tokens: external_exports.number().nullish()
            }).nullish()
          }).nullish()
        })
      )
    );
    modelMaxImagesPerCall = {
      "dall-e-3": 1,
      "dall-e-2": 10,
      "gpt-image-1": 10,
      "gpt-image-1-mini": 10,
      "gpt-image-1.5": 10,
      "chatgpt-image-latest": 10
    };
    defaultResponseFormatPrefixes = [
      "chatgpt-image-",
      "gpt-image-1-mini",
      "gpt-image-1.5",
      "gpt-image-1"
    ];
    OpenAIImageModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
      }
      get maxImagesPerCall() {
        var _a31;
        return (_a31 = modelMaxImagesPerCall[this.modelId]) != null ? _a31 : 1;
      }
      get provider() {
        return this.config.provider;
      }
      async doGenerate({
        prompt,
        files,
        mask,
        n,
        size,
        aspectRatio,
        seed,
        providerOptions,
        headers,
        abortSignal
      }) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k;
        const warnings = [];
        if (aspectRatio != null) {
          warnings.push({
            type: "unsupported",
            feature: "aspectRatio",
            details: "This model does not support aspect ratio. Use `size` instead."
          });
        }
        if (seed != null) {
          warnings.push({ type: "unsupported", feature: "seed" });
        }
        const currentDate = (_c = (_b27 = (_a31 = this.config._internal) == null ? void 0 : _a31.currentDate) == null ? void 0 : _b27.call(_a31)) != null ? _c : /* @__PURE__ */ new Date();
        if (files != null) {
          const { value: response2, responseHeaders: responseHeaders2 } = await postFormDataToApi({
            url: this.config.url({
              path: "/images/edits",
              modelId: this.modelId
            }),
            headers: combineHeaders(this.config.headers(), headers),
            formData: convertToFormData({
              model: this.modelId,
              prompt,
              image: await Promise.all(
                files.map(
                  (file3) => file3.type === "file" ? new Blob(
                    [
                      file3.data instanceof Uint8Array ? new Blob([file3.data], {
                        type: file3.mediaType
                      }) : new Blob([convertBase64ToUint8Array(file3.data)], {
                        type: file3.mediaType
                      })
                    ],
                    { type: file3.mediaType }
                  ) : downloadBlob(file3.url)
                )
              ),
              mask: mask != null ? await fileToBlob(mask) : void 0,
              n,
              size,
              ...(_d = providerOptions.openai) != null ? _d : {}
            }),
            failedResponseHandler: openaiFailedResponseHandler,
            successfulResponseHandler: createJsonResponseHandler(
              openaiImageResponseSchema
            ),
            abortSignal,
            fetch: this.config.fetch
          });
          return {
            images: response2.data.map((item) => item.b64_json),
            warnings,
            usage: response2.usage != null ? {
              inputTokens: (_e = response2.usage.input_tokens) != null ? _e : void 0,
              outputTokens: (_f = response2.usage.output_tokens) != null ? _f : void 0,
              totalTokens: (_g = response2.usage.total_tokens) != null ? _g : void 0
            } : void 0,
            response: {
              timestamp: currentDate,
              modelId: this.modelId,
              headers: responseHeaders2
            },
            providerMetadata: {
              openai: {
                images: response2.data.map((item, index) => {
                  var _a211, _b28, _c2, _d2, _e2, _f2;
                  return {
                    ...item.revised_prompt ? { revisedPrompt: item.revised_prompt } : {},
                    created: (_a211 = response2.created) != null ? _a211 : void 0,
                    size: (_b28 = response2.size) != null ? _b28 : void 0,
                    quality: (_c2 = response2.quality) != null ? _c2 : void 0,
                    background: (_d2 = response2.background) != null ? _d2 : void 0,
                    outputFormat: (_e2 = response2.output_format) != null ? _e2 : void 0,
                    ...distributeTokenDetails(
                      (_f2 = response2.usage) == null ? void 0 : _f2.input_tokens_details,
                      index,
                      response2.data.length
                    )
                  };
                })
              }
            }
          };
        }
        const { value: response, responseHeaders } = await postJsonToApi({
          url: this.config.url({
            path: "/images/generations",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), headers),
          body: {
            model: this.modelId,
            prompt,
            n,
            size,
            ...(_h = providerOptions.openai) != null ? _h : {},
            ...!hasDefaultResponseFormat(this.modelId) ? { response_format: "b64_json" } : {}
          },
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            openaiImageResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        return {
          images: response.data.map((item) => item.b64_json),
          warnings,
          usage: response.usage != null ? {
            inputTokens: (_i = response.usage.input_tokens) != null ? _i : void 0,
            outputTokens: (_j = response.usage.output_tokens) != null ? _j : void 0,
            totalTokens: (_k = response.usage.total_tokens) != null ? _k : void 0
          } : void 0,
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: responseHeaders
          },
          providerMetadata: {
            openai: {
              images: response.data.map((item, index) => {
                var _a211, _b28, _c2, _d2, _e2, _f2;
                return {
                  ...item.revised_prompt ? { revisedPrompt: item.revised_prompt } : {},
                  created: (_a211 = response.created) != null ? _a211 : void 0,
                  size: (_b28 = response.size) != null ? _b28 : void 0,
                  quality: (_c2 = response.quality) != null ? _c2 : void 0,
                  background: (_d2 = response.background) != null ? _d2 : void 0,
                  outputFormat: (_e2 = response.output_format) != null ? _e2 : void 0,
                  ...distributeTokenDetails(
                    (_f2 = response.usage) == null ? void 0 : _f2.input_tokens_details,
                    index,
                    response.data.length
                  )
                };
              })
            }
          }
        };
      }
    };
    applyPatchInputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          callId: external_exports.string(),
          operation: external_exports.discriminatedUnion("type", [
            external_exports.object({
              type: external_exports.literal("create_file"),
              path: external_exports.string(),
              diff: external_exports.string()
            }),
            external_exports.object({
              type: external_exports.literal("delete_file"),
              path: external_exports.string()
            }),
            external_exports.object({
              type: external_exports.literal("update_file"),
              path: external_exports.string(),
              diff: external_exports.string()
            })
          ])
        })
      )
    );
    applyPatchOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          status: external_exports.enum(["completed", "failed"]),
          output: external_exports.string().optional()
        })
      )
    );
    applyPatchArgsSchema = lazySchema(() => zodSchema(external_exports.object({})));
    applyPatchToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "openai.apply_patch",
      inputSchema: applyPatchInputSchema,
      outputSchema: applyPatchOutputSchema
    });
    applyPatch = applyPatchToolFactory;
    codeInterpreterInputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          code: external_exports.string().nullish(),
          containerId: external_exports.string()
        })
      )
    );
    codeInterpreterOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          outputs: external_exports.array(
            external_exports.discriminatedUnion("type", [
              external_exports.object({ type: external_exports.literal("logs"), logs: external_exports.string() }),
              external_exports.object({ type: external_exports.literal("image"), url: external_exports.string() })
            ])
          ).nullish()
        })
      )
    );
    codeInterpreterArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          container: external_exports.union([
            external_exports.string(),
            external_exports.object({
              fileIds: external_exports.array(external_exports.string()).optional()
            })
          ]).optional()
        })
      )
    );
    codeInterpreterToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "openai.code_interpreter",
      inputSchema: codeInterpreterInputSchema,
      outputSchema: codeInterpreterOutputSchema
    });
    codeInterpreter = (args = {}) => {
      return codeInterpreterToolFactory(args);
    };
    customArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          name: external_exports.string(),
          description: external_exports.string().optional(),
          format: external_exports.union([
            external_exports.object({
              type: external_exports.literal("grammar"),
              syntax: external_exports.enum(["regex", "lark"]),
              definition: external_exports.string()
            }),
            external_exports.object({
              type: external_exports.literal("text")
            })
          ]).optional()
        })
      )
    );
    customInputSchema = lazySchema(() => zodSchema(external_exports.string()));
    customToolFactory = createProviderToolFactory({
      id: "openai.custom",
      inputSchema: customInputSchema
    });
    customTool = (args) => customToolFactory(args);
    comparisonFilterSchema = external_exports.object({
      key: external_exports.string(),
      type: external_exports.enum(["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin"]),
      value: external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean(), external_exports.array(external_exports.string())])
    });
    compoundFilterSchema = external_exports.object({
      type: external_exports.enum(["and", "or"]),
      filters: external_exports.array(
        external_exports.union([comparisonFilterSchema, external_exports.lazy(() => compoundFilterSchema)])
      )
    });
    fileSearchArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          vectorStoreIds: external_exports.array(external_exports.string()),
          maxNumResults: external_exports.number().optional(),
          ranking: external_exports.object({
            ranker: external_exports.string().optional(),
            scoreThreshold: external_exports.number().optional()
          }).optional(),
          filters: external_exports.union([comparisonFilterSchema, compoundFilterSchema]).optional()
        })
      )
    );
    fileSearchOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          queries: external_exports.array(external_exports.string()),
          results: external_exports.array(
            external_exports.object({
              attributes: external_exports.record(external_exports.string(), external_exports.unknown()),
              fileId: external_exports.string(),
              filename: external_exports.string(),
              score: external_exports.number(),
              text: external_exports.string()
            })
          ).nullable()
        })
      )
    );
    fileSearch = createProviderToolFactoryWithOutputSchema({
      id: "openai.file_search",
      inputSchema: external_exports.object({}),
      outputSchema: fileSearchOutputSchema
    });
    imageGenerationArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          background: external_exports.enum(["auto", "opaque", "transparent"]).optional(),
          inputFidelity: external_exports.enum(["low", "high"]).optional(),
          inputImageMask: external_exports.object({
            fileId: external_exports.string().optional(),
            imageUrl: external_exports.string().optional()
          }).optional(),
          model: external_exports.string().optional(),
          moderation: external_exports.enum(["auto"]).optional(),
          outputCompression: external_exports.number().int().min(0).max(100).optional(),
          outputFormat: external_exports.enum(["png", "jpeg", "webp"]).optional(),
          partialImages: external_exports.number().int().min(0).max(3).optional(),
          quality: external_exports.enum(["auto", "low", "medium", "high"]).optional(),
          size: external_exports.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
        }).strict()
      )
    );
    imageGenerationInputSchema = lazySchema(() => zodSchema(external_exports.object({})));
    imageGenerationOutputSchema = lazySchema(
      () => zodSchema(external_exports.object({ result: external_exports.string() }))
    );
    imageGenerationToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "openai.image_generation",
      inputSchema: imageGenerationInputSchema,
      outputSchema: imageGenerationOutputSchema
    });
    imageGeneration = (args = {}) => {
      return imageGenerationToolFactory(args);
    };
    localShellInputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          action: external_exports.object({
            type: external_exports.literal("exec"),
            command: external_exports.array(external_exports.string()),
            timeoutMs: external_exports.number().optional(),
            user: external_exports.string().optional(),
            workingDirectory: external_exports.string().optional(),
            env: external_exports.record(external_exports.string(), external_exports.string()).optional()
          })
        })
      )
    );
    localShellOutputSchema = lazySchema(
      () => zodSchema(external_exports.object({ output: external_exports.string() }))
    );
    localShell = createProviderToolFactoryWithOutputSchema({
      id: "openai.local_shell",
      inputSchema: localShellInputSchema,
      outputSchema: localShellOutputSchema
    });
    shellInputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          action: external_exports.object({
            commands: external_exports.array(external_exports.string()),
            timeoutMs: external_exports.number().optional(),
            maxOutputLength: external_exports.number().optional()
          })
        })
      )
    );
    shellOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          output: external_exports.array(
            external_exports.object({
              stdout: external_exports.string(),
              stderr: external_exports.string(),
              outcome: external_exports.discriminatedUnion("type", [
                external_exports.object({ type: external_exports.literal("timeout") }),
                external_exports.object({ type: external_exports.literal("exit"), exitCode: external_exports.number() })
              ])
            })
          )
        })
      )
    );
    shellSkillsSchema = external_exports.array(
      external_exports.discriminatedUnion("type", [
        external_exports.object({
          type: external_exports.literal("skillReference"),
          skillId: external_exports.string(),
          version: external_exports.string().optional()
        }),
        external_exports.object({
          type: external_exports.literal("inline"),
          name: external_exports.string(),
          description: external_exports.string(),
          source: external_exports.object({
            type: external_exports.literal("base64"),
            mediaType: external_exports.literal("application/zip"),
            data: external_exports.string()
          })
        })
      ])
    ).optional();
    shellArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          environment: external_exports.union([
            external_exports.object({
              type: external_exports.literal("containerAuto"),
              fileIds: external_exports.array(external_exports.string()).optional(),
              memoryLimit: external_exports.enum(["1g", "4g", "16g", "64g"]).optional(),
              networkPolicy: external_exports.discriminatedUnion("type", [
                external_exports.object({ type: external_exports.literal("disabled") }),
                external_exports.object({
                  type: external_exports.literal("allowlist"),
                  allowedDomains: external_exports.array(external_exports.string()),
                  domainSecrets: external_exports.array(
                    external_exports.object({
                      domain: external_exports.string(),
                      name: external_exports.string(),
                      value: external_exports.string()
                    })
                  ).optional()
                })
              ]).optional(),
              skills: shellSkillsSchema
            }),
            external_exports.object({
              type: external_exports.literal("containerReference"),
              containerId: external_exports.string()
            }),
            external_exports.object({
              type: external_exports.literal("local").optional(),
              skills: external_exports.array(
                external_exports.object({
                  name: external_exports.string(),
                  description: external_exports.string(),
                  path: external_exports.string()
                })
              ).optional()
            })
          ]).optional()
        })
      )
    );
    shell = createProviderToolFactoryWithOutputSchema({
      id: "openai.shell",
      inputSchema: shellInputSchema,
      outputSchema: shellOutputSchema
    });
    toolSearchArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          execution: external_exports.enum(["server", "client"]).optional(),
          description: external_exports.string().optional(),
          parameters: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
        })
      )
    );
    toolSearchInputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          arguments: external_exports.unknown().optional(),
          call_id: external_exports.string().nullish()
        })
      )
    );
    toolSearchOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          tools: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown()))
        })
      )
    );
    toolSearchToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "openai.tool_search",
      inputSchema: toolSearchInputSchema,
      outputSchema: toolSearchOutputSchema
    });
    toolSearch = (args = {}) => toolSearchToolFactory(args);
    webSearchArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          externalWebAccess: external_exports.boolean().optional(),
          filters: external_exports.object({ allowedDomains: external_exports.array(external_exports.string()).optional() }).optional(),
          searchContextSize: external_exports.enum(["low", "medium", "high"]).optional(),
          userLocation: external_exports.object({
            type: external_exports.literal("approximate"),
            country: external_exports.string().optional(),
            city: external_exports.string().optional(),
            region: external_exports.string().optional(),
            timezone: external_exports.string().optional()
          }).optional()
        })
      )
    );
    webSearchInputSchema = lazySchema(() => zodSchema(external_exports.object({})));
    webSearchOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          action: external_exports.discriminatedUnion("type", [
            external_exports.object({
              type: external_exports.literal("search"),
              query: external_exports.string().optional()
            }),
            external_exports.object({
              type: external_exports.literal("openPage"),
              url: external_exports.string().nullish()
            }),
            external_exports.object({
              type: external_exports.literal("findInPage"),
              url: external_exports.string().nullish(),
              pattern: external_exports.string().nullish()
            })
          ]).optional(),
          sources: external_exports.array(
            external_exports.discriminatedUnion("type", [
              external_exports.object({ type: external_exports.literal("url"), url: external_exports.string() }),
              external_exports.object({ type: external_exports.literal("api"), name: external_exports.string() })
            ])
          ).optional()
        })
      )
    );
    webSearchToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "openai.web_search",
      inputSchema: webSearchInputSchema,
      outputSchema: webSearchOutputSchema
    });
    webSearch = (args = {}) => webSearchToolFactory(args);
    webSearchPreviewArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          searchContextSize: external_exports.enum(["low", "medium", "high"]).optional(),
          userLocation: external_exports.object({
            type: external_exports.literal("approximate"),
            country: external_exports.string().optional(),
            city: external_exports.string().optional(),
            region: external_exports.string().optional(),
            timezone: external_exports.string().optional()
          }).optional()
        })
      )
    );
    webSearchPreviewInputSchema = lazySchema(
      () => zodSchema(external_exports.object({}))
    );
    webSearchPreviewOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          action: external_exports.discriminatedUnion("type", [
            external_exports.object({
              type: external_exports.literal("search"),
              query: external_exports.string().optional()
            }),
            external_exports.object({
              type: external_exports.literal("openPage"),
              url: external_exports.string().nullish()
            }),
            external_exports.object({
              type: external_exports.literal("findInPage"),
              url: external_exports.string().nullish(),
              pattern: external_exports.string().nullish()
            })
          ]).optional()
        })
      )
    );
    webSearchPreview = createProviderToolFactoryWithOutputSchema({
      id: "openai.web_search_preview",
      inputSchema: webSearchPreviewInputSchema,
      outputSchema: webSearchPreviewOutputSchema
    });
    jsonValueSchema = external_exports.lazy(
      () => external_exports.union([
        external_exports.string(),
        external_exports.number(),
        external_exports.boolean(),
        external_exports.null(),
        external_exports.array(jsonValueSchema),
        external_exports.record(external_exports.string(), jsonValueSchema)
      ])
    );
    mcpArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          serverLabel: external_exports.string(),
          allowedTools: external_exports.union([
            external_exports.array(external_exports.string()),
            external_exports.object({
              readOnly: external_exports.boolean().optional(),
              toolNames: external_exports.array(external_exports.string()).optional()
            })
          ]).optional(),
          authorization: external_exports.string().optional(),
          connectorId: external_exports.string().optional(),
          headers: external_exports.record(external_exports.string(), external_exports.string()).optional(),
          requireApproval: external_exports.union([
            external_exports.enum(["always", "never"]),
            external_exports.object({
              never: external_exports.object({
                toolNames: external_exports.array(external_exports.string()).optional()
              }).optional()
            })
          ]).optional(),
          serverDescription: external_exports.string().optional(),
          serverUrl: external_exports.string().optional()
        }).refine(
          (v) => v.serverUrl != null || v.connectorId != null,
          "One of serverUrl or connectorId must be provided."
        )
      )
    );
    mcpInputSchema = lazySchema(() => zodSchema(external_exports.object({})));
    mcpOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          type: external_exports.literal("call"),
          serverLabel: external_exports.string(),
          name: external_exports.string(),
          arguments: external_exports.string(),
          output: external_exports.string().nullish(),
          error: external_exports.union([external_exports.string(), jsonValueSchema]).optional()
        })
      )
    );
    mcpToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "openai.mcp",
      inputSchema: mcpInputSchema,
      outputSchema: mcpOutputSchema
    });
    mcp = (args) => mcpToolFactory(args);
    openaiTools = {
      /**
       * The apply_patch tool lets GPT-5.1 create, update, and delete files in your
       * codebase using structured diffs. Instead of just suggesting edits, the model
       * emits patch operations that your application applies and then reports back on,
       * enabling iterative, multi-step code editing workflows.
       *
       */
      applyPatch,
      /**
       * Custom tools let callers constrain model output to a grammar (regex or
       * Lark syntax). The model returns a `custom_tool_call` output item whose
       * `input` field is a string matching the specified grammar.
       *
       * @param name - The name of the custom tool.
       * @param description - An optional description of the tool.
       * @param format - The output format constraint (grammar type, syntax, and definition).
       */
      customTool,
      /**
       * The Code Interpreter tool allows models to write and run Python code in a
       * sandboxed environment to solve complex problems in domains like data analysis,
       * coding, and math.
       *
       * @param container - The container to use for the code interpreter.
       */
      codeInterpreter,
      /**
       * File search is a tool available in the Responses API. It enables models to
       * retrieve information in a knowledge base of previously uploaded files through
       * semantic and keyword search.
       *
       * @param vectorStoreIds - The vector store IDs to use for the file search.
       * @param maxNumResults - The maximum number of results to return.
       * @param ranking - The ranking options to use for the file search.
       * @param filters - The filters to use for the file search.
       */
      fileSearch,
      /**
       * The image generation tool allows you to generate images using a text prompt,
       * and optionally image inputs. It leverages the GPT Image model,
       * and automatically optimizes text inputs for improved performance.
       *
       * @param background - Background type for the generated image. One of 'auto', 'opaque', or 'transparent'.
       * @param inputFidelity - Input fidelity for the generated image. One of 'low' or 'high'.
       * @param inputImageMask - Optional mask for inpainting. Contains fileId and/or imageUrl.
       * @param model - The image generation model to use. Default: gpt-image-1.
       * @param moderation - Moderation level for the generated image. Default: 'auto'.
       * @param outputCompression - Compression level for the output image (0-100).
       * @param outputFormat - The output format of the generated image. One of 'png', 'jpeg', or 'webp'.
       * @param partialImages - Number of partial images to generate in streaming mode (0-3).
       * @param quality - The quality of the generated image. One of 'auto', 'low', 'medium', or 'high'.
       * @param size - The size of the generated image. One of 'auto', '1024x1024', '1024x1536', or '1536x1024'.
       */
      imageGeneration,
      /**
       * Local shell is a tool that allows agents to run shell commands locally
       * on a machine you or the user provides.
       *
       * Supported models: `gpt-5-codex`
       */
      localShell,
      /**
       * The shell tool allows the model to interact with your local computer through
       * a controlled command-line interface. The model proposes shell commands; your
       * integration executes them and returns the outputs.
       *
       * Available through the Responses API for use with GPT-5.1.
       *
       * WARNING: Running arbitrary shell commands can be dangerous. Always sandbox
       * execution or add strict allow-/deny-lists before forwarding a command to
       * the system shell.
       */
      shell,
      /**
       * Web search allows models to access up-to-date information from the internet
       * and provide answers with sourced citations.
       *
       * @param searchContextSize - The search context size to use for the web search.
       * @param userLocation - The user location to use for the web search.
       */
      webSearchPreview,
      /**
       * Web search allows models to access up-to-date information from the internet
       * and provide answers with sourced citations.
       *
       * @param filters - The filters to use for the web search.
       * @param searchContextSize - The search context size to use for the web search.
       * @param userLocation - The user location to use for the web search.
       */
      webSearch,
      /**
       * MCP (Model Context Protocol) allows models to call tools exposed by
       * remote MCP servers or service connectors.
       *
       * @param serverLabel - Label to identify the MCP server.
       * @param allowedTools - Allowed tool names or filter object.
       * @param authorization - OAuth access token for the MCP server/connector.
       * @param connectorId - Identifier for a service connector.
       * @param headers - Optional headers to include in MCP requests.
       * // param requireApproval - Approval policy ('always'|'never'|filter object). (Removed - always 'never')
       * @param serverDescription - Optional description of the server.
       * @param serverUrl - URL for the MCP server.
       */
      mcp,
      /**
       * Tool search allows the model to dynamically search for and load deferred
       * tools into the model's context as needed. This helps reduce overall token
       * usage, cost, and latency by only loading tools when the model needs them.
       *
       * To use tool search, mark functions or namespaces with `defer_loading: true`
       * in the tools array. The model will use tool search to load these tools
       * when it determines they are needed.
       */
      toolSearch
    };
    openaiResponsesReasoningProviderOptionsSchema = external_exports.object({
      itemId: external_exports.string().nullish(),
      reasoningEncryptedContent: external_exports.string().nullish()
    });
    jsonValueSchema2 = external_exports.lazy(
      () => external_exports.union([
        external_exports.string(),
        external_exports.number(),
        external_exports.boolean(),
        external_exports.null(),
        external_exports.array(jsonValueSchema2),
        external_exports.record(external_exports.string(), jsonValueSchema2.optional())
      ])
    );
    openaiResponsesChunkSchema = lazySchema(
      () => zodSchema(
        external_exports.union([
          external_exports.object({
            type: external_exports.literal("response.output_text.delta"),
            item_id: external_exports.string(),
            delta: external_exports.string(),
            logprobs: external_exports.array(
              external_exports.object({
                token: external_exports.string(),
                logprob: external_exports.number(),
                top_logprobs: external_exports.array(
                  external_exports.object({
                    token: external_exports.string(),
                    logprob: external_exports.number()
                  })
                )
              })
            ).nullish()
          }),
          external_exports.object({
            type: external_exports.enum(["response.completed", "response.incomplete"]),
            response: external_exports.object({
              incomplete_details: external_exports.object({ reason: external_exports.string() }).nullish(),
              usage: external_exports.object({
                input_tokens: external_exports.number(),
                input_tokens_details: external_exports.object({ cached_tokens: external_exports.number().nullish() }).nullish(),
                output_tokens: external_exports.number(),
                output_tokens_details: external_exports.object({ reasoning_tokens: external_exports.number().nullish() }).nullish()
              }),
              service_tier: external_exports.string().nullish()
            })
          }),
          external_exports.object({
            type: external_exports.literal("response.failed"),
            response: external_exports.object({
              error: external_exports.object({
                code: external_exports.string().nullish(),
                message: external_exports.string()
              }).nullish(),
              incomplete_details: external_exports.object({ reason: external_exports.string() }).nullish(),
              usage: external_exports.object({
                input_tokens: external_exports.number(),
                input_tokens_details: external_exports.object({ cached_tokens: external_exports.number().nullish() }).nullish(),
                output_tokens: external_exports.number(),
                output_tokens_details: external_exports.object({ reasoning_tokens: external_exports.number().nullish() }).nullish()
              }).nullish(),
              service_tier: external_exports.string().nullish()
            })
          }),
          external_exports.object({
            type: external_exports.literal("response.created"),
            response: external_exports.object({
              id: external_exports.string(),
              created_at: external_exports.number(),
              model: external_exports.string(),
              service_tier: external_exports.string().nullish()
            })
          }),
          external_exports.object({
            type: external_exports.literal("response.output_item.added"),
            output_index: external_exports.number(),
            item: external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("message"),
                id: external_exports.string(),
                phase: external_exports.enum(["commentary", "final_answer"]).nullish()
              }),
              external_exports.object({
                type: external_exports.literal("reasoning"),
                id: external_exports.string(),
                encrypted_content: external_exports.string().nullish()
              }),
              external_exports.object({
                type: external_exports.literal("function_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                name: external_exports.string(),
                arguments: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("web_search_call"),
                id: external_exports.string(),
                status: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("computer_call"),
                id: external_exports.string(),
                status: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("file_search_call"),
                id: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("image_generation_call"),
                id: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("code_interpreter_call"),
                id: external_exports.string(),
                container_id: external_exports.string(),
                code: external_exports.string().nullable(),
                outputs: external_exports.array(
                  external_exports.discriminatedUnion("type", [
                    external_exports.object({ type: external_exports.literal("logs"), logs: external_exports.string() }),
                    external_exports.object({ type: external_exports.literal("image"), url: external_exports.string() })
                  ])
                ).nullable(),
                status: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_call"),
                id: external_exports.string(),
                status: external_exports.string(),
                approval_request_id: external_exports.string().nullish()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_list_tools"),
                id: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_approval_request"),
                id: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("apply_patch_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                status: external_exports.enum(["in_progress", "completed"]),
                operation: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("create_file"),
                    path: external_exports.string(),
                    diff: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("delete_file"),
                    path: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("update_file"),
                    path: external_exports.string(),
                    diff: external_exports.string()
                  })
                ])
              }),
              external_exports.object({
                type: external_exports.literal("custom_tool_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("shell_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                action: external_exports.object({
                  commands: external_exports.array(external_exports.string())
                })
              }),
              external_exports.object({
                type: external_exports.literal("shell_call_output"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                output: external_exports.array(
                  external_exports.object({
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    outcome: external_exports.discriminatedUnion("type", [
                      external_exports.object({ type: external_exports.literal("timeout") }),
                      external_exports.object({
                        type: external_exports.literal("exit"),
                        exit_code: external_exports.number()
                      })
                    ])
                  })
                )
              }),
              external_exports.object({
                type: external_exports.literal("tool_search_call"),
                id: external_exports.string(),
                execution: external_exports.enum(["server", "client"]),
                call_id: external_exports.string().nullable(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                arguments: external_exports.unknown()
              }),
              external_exports.object({
                type: external_exports.literal("tool_search_output"),
                id: external_exports.string(),
                execution: external_exports.enum(["server", "client"]),
                call_id: external_exports.string().nullable(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                tools: external_exports.array(external_exports.record(external_exports.string(), jsonValueSchema2.optional()))
              })
            ])
          }),
          external_exports.object({
            type: external_exports.literal("response.output_item.done"),
            output_index: external_exports.number(),
            item: external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("message"),
                id: external_exports.string(),
                phase: external_exports.enum(["commentary", "final_answer"]).nullish()
              }),
              external_exports.object({
                type: external_exports.literal("reasoning"),
                id: external_exports.string(),
                encrypted_content: external_exports.string().nullish()
              }),
              external_exports.object({
                type: external_exports.literal("function_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                name: external_exports.string(),
                arguments: external_exports.string(),
                status: external_exports.literal("completed")
              }),
              external_exports.object({
                type: external_exports.literal("custom_tool_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.string(),
                status: external_exports.literal("completed")
              }),
              external_exports.object({
                type: external_exports.literal("code_interpreter_call"),
                id: external_exports.string(),
                code: external_exports.string().nullable(),
                container_id: external_exports.string(),
                outputs: external_exports.array(
                  external_exports.discriminatedUnion("type", [
                    external_exports.object({ type: external_exports.literal("logs"), logs: external_exports.string() }),
                    external_exports.object({ type: external_exports.literal("image"), url: external_exports.string() })
                  ])
                ).nullable()
              }),
              external_exports.object({
                type: external_exports.literal("image_generation_call"),
                id: external_exports.string(),
                result: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("web_search_call"),
                id: external_exports.string(),
                status: external_exports.string(),
                action: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("search"),
                    query: external_exports.string().nullish(),
                    sources: external_exports.array(
                      external_exports.discriminatedUnion("type", [
                        external_exports.object({ type: external_exports.literal("url"), url: external_exports.string() }),
                        external_exports.object({ type: external_exports.literal("api"), name: external_exports.string() })
                      ])
                    ).nullish()
                  }),
                  external_exports.object({
                    type: external_exports.literal("open_page"),
                    url: external_exports.string().nullish()
                  }),
                  external_exports.object({
                    type: external_exports.literal("find_in_page"),
                    url: external_exports.string().nullish(),
                    pattern: external_exports.string().nullish()
                  })
                ]).nullish()
              }),
              external_exports.object({
                type: external_exports.literal("file_search_call"),
                id: external_exports.string(),
                queries: external_exports.array(external_exports.string()),
                results: external_exports.array(
                  external_exports.object({
                    attributes: external_exports.record(
                      external_exports.string(),
                      external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()])
                    ),
                    file_id: external_exports.string(),
                    filename: external_exports.string(),
                    score: external_exports.number(),
                    text: external_exports.string()
                  })
                ).nullish()
              }),
              external_exports.object({
                type: external_exports.literal("local_shell_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                action: external_exports.object({
                  type: external_exports.literal("exec"),
                  command: external_exports.array(external_exports.string()),
                  timeout_ms: external_exports.number().optional(),
                  user: external_exports.string().optional(),
                  working_directory: external_exports.string().optional(),
                  env: external_exports.record(external_exports.string(), external_exports.string()).optional()
                })
              }),
              external_exports.object({
                type: external_exports.literal("computer_call"),
                id: external_exports.string(),
                status: external_exports.literal("completed")
              }),
              external_exports.object({
                type: external_exports.literal("mcp_call"),
                id: external_exports.string(),
                status: external_exports.string(),
                arguments: external_exports.string(),
                name: external_exports.string(),
                server_label: external_exports.string(),
                output: external_exports.string().nullish(),
                error: external_exports.union([
                  external_exports.string(),
                  external_exports.object({
                    type: external_exports.string().optional(),
                    code: external_exports.union([external_exports.number(), external_exports.string()]).optional(),
                    message: external_exports.string().optional()
                  }).loose()
                ]).nullish(),
                approval_request_id: external_exports.string().nullish()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_list_tools"),
                id: external_exports.string(),
                server_label: external_exports.string(),
                tools: external_exports.array(
                  external_exports.object({
                    name: external_exports.string(),
                    description: external_exports.string().optional(),
                    input_schema: external_exports.any(),
                    annotations: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
                  })
                ),
                error: external_exports.union([
                  external_exports.string(),
                  external_exports.object({
                    type: external_exports.string().optional(),
                    code: external_exports.union([external_exports.number(), external_exports.string()]).optional(),
                    message: external_exports.string().optional()
                  }).loose()
                ]).optional()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_approval_request"),
                id: external_exports.string(),
                server_label: external_exports.string(),
                name: external_exports.string(),
                arguments: external_exports.string(),
                approval_request_id: external_exports.string().optional()
              }),
              external_exports.object({
                type: external_exports.literal("apply_patch_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                status: external_exports.enum(["in_progress", "completed"]),
                operation: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("create_file"),
                    path: external_exports.string(),
                    diff: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("delete_file"),
                    path: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("update_file"),
                    path: external_exports.string(),
                    diff: external_exports.string()
                  })
                ])
              }),
              external_exports.object({
                type: external_exports.literal("shell_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                action: external_exports.object({
                  commands: external_exports.array(external_exports.string())
                })
              }),
              external_exports.object({
                type: external_exports.literal("shell_call_output"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                output: external_exports.array(
                  external_exports.object({
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    outcome: external_exports.discriminatedUnion("type", [
                      external_exports.object({ type: external_exports.literal("timeout") }),
                      external_exports.object({
                        type: external_exports.literal("exit"),
                        exit_code: external_exports.number()
                      })
                    ])
                  })
                )
              }),
              external_exports.object({
                type: external_exports.literal("tool_search_call"),
                id: external_exports.string(),
                execution: external_exports.enum(["server", "client"]),
                call_id: external_exports.string().nullable(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                arguments: external_exports.unknown()
              }),
              external_exports.object({
                type: external_exports.literal("tool_search_output"),
                id: external_exports.string(),
                execution: external_exports.enum(["server", "client"]),
                call_id: external_exports.string().nullable(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                tools: external_exports.array(external_exports.record(external_exports.string(), jsonValueSchema2.optional()))
              })
            ])
          }),
          external_exports.object({
            type: external_exports.literal("response.function_call_arguments.delta"),
            item_id: external_exports.string(),
            output_index: external_exports.number(),
            delta: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("response.custom_tool_call_input.delta"),
            item_id: external_exports.string(),
            output_index: external_exports.number(),
            delta: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("response.image_generation_call.partial_image"),
            item_id: external_exports.string(),
            output_index: external_exports.number(),
            partial_image_b64: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("response.code_interpreter_call_code.delta"),
            item_id: external_exports.string(),
            output_index: external_exports.number(),
            delta: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("response.code_interpreter_call_code.done"),
            item_id: external_exports.string(),
            output_index: external_exports.number(),
            code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("response.output_text.annotation.added"),
            annotation: external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("url_citation"),
                start_index: external_exports.number(),
                end_index: external_exports.number(),
                url: external_exports.string(),
                title: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("file_citation"),
                file_id: external_exports.string(),
                filename: external_exports.string(),
                index: external_exports.number()
              }),
              external_exports.object({
                type: external_exports.literal("container_file_citation"),
                container_id: external_exports.string(),
                file_id: external_exports.string(),
                filename: external_exports.string(),
                start_index: external_exports.number(),
                end_index: external_exports.number()
              }),
              external_exports.object({
                type: external_exports.literal("file_path"),
                file_id: external_exports.string(),
                index: external_exports.number()
              })
            ])
          }),
          external_exports.object({
            type: external_exports.literal("response.reasoning_summary_part.added"),
            item_id: external_exports.string(),
            summary_index: external_exports.number()
          }),
          external_exports.object({
            type: external_exports.literal("response.reasoning_summary_text.delta"),
            item_id: external_exports.string(),
            summary_index: external_exports.number(),
            delta: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("response.reasoning_summary_part.done"),
            item_id: external_exports.string(),
            summary_index: external_exports.number()
          }),
          external_exports.object({
            type: external_exports.literal("response.apply_patch_call_operation_diff.delta"),
            item_id: external_exports.string(),
            output_index: external_exports.number(),
            delta: external_exports.string(),
            obfuscation: external_exports.string().nullish()
          }),
          external_exports.object({
            type: external_exports.literal("response.apply_patch_call_operation_diff.done"),
            item_id: external_exports.string(),
            output_index: external_exports.number(),
            diff: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("error"),
            sequence_number: external_exports.number(),
            error: external_exports.object({
              type: external_exports.string(),
              code: external_exports.string(),
              message: external_exports.string(),
              param: external_exports.string().nullish()
            })
          }),
          external_exports.object({ type: external_exports.string() }).loose().transform((value) => ({
            type: "unknown_chunk",
            message: value.type
          }))
          // fallback for unknown chunks
        ])
      )
    );
    openaiResponsesResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          id: external_exports.string().optional(),
          created_at: external_exports.number().optional(),
          error: external_exports.object({
            message: external_exports.string(),
            type: external_exports.string(),
            param: external_exports.string().nullish(),
            code: external_exports.string()
          }).nullish(),
          model: external_exports.string().optional(),
          output: external_exports.array(
            external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("message"),
                role: external_exports.literal("assistant"),
                id: external_exports.string(),
                phase: external_exports.enum(["commentary", "final_answer"]).nullish(),
                content: external_exports.array(
                  external_exports.object({
                    type: external_exports.literal("output_text"),
                    text: external_exports.string(),
                    logprobs: external_exports.array(
                      external_exports.object({
                        token: external_exports.string(),
                        logprob: external_exports.number(),
                        top_logprobs: external_exports.array(
                          external_exports.object({
                            token: external_exports.string(),
                            logprob: external_exports.number()
                          })
                        )
                      })
                    ).nullish(),
                    annotations: external_exports.array(
                      external_exports.discriminatedUnion("type", [
                        external_exports.object({
                          type: external_exports.literal("url_citation"),
                          start_index: external_exports.number(),
                          end_index: external_exports.number(),
                          url: external_exports.string(),
                          title: external_exports.string()
                        }),
                        external_exports.object({
                          type: external_exports.literal("file_citation"),
                          file_id: external_exports.string(),
                          filename: external_exports.string(),
                          index: external_exports.number()
                        }),
                        external_exports.object({
                          type: external_exports.literal("container_file_citation"),
                          container_id: external_exports.string(),
                          file_id: external_exports.string(),
                          filename: external_exports.string(),
                          start_index: external_exports.number(),
                          end_index: external_exports.number()
                        }),
                        external_exports.object({
                          type: external_exports.literal("file_path"),
                          file_id: external_exports.string(),
                          index: external_exports.number()
                        })
                      ])
                    )
                  })
                )
              }),
              external_exports.object({
                type: external_exports.literal("web_search_call"),
                id: external_exports.string(),
                status: external_exports.string(),
                action: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("search"),
                    query: external_exports.string().nullish(),
                    sources: external_exports.array(
                      external_exports.discriminatedUnion("type", [
                        external_exports.object({ type: external_exports.literal("url"), url: external_exports.string() }),
                        external_exports.object({
                          type: external_exports.literal("api"),
                          name: external_exports.string()
                        })
                      ])
                    ).nullish()
                  }),
                  external_exports.object({
                    type: external_exports.literal("open_page"),
                    url: external_exports.string().nullish()
                  }),
                  external_exports.object({
                    type: external_exports.literal("find_in_page"),
                    url: external_exports.string().nullish(),
                    pattern: external_exports.string().nullish()
                  })
                ]).nullish()
              }),
              external_exports.object({
                type: external_exports.literal("file_search_call"),
                id: external_exports.string(),
                queries: external_exports.array(external_exports.string()),
                results: external_exports.array(
                  external_exports.object({
                    attributes: external_exports.record(
                      external_exports.string(),
                      external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()])
                    ),
                    file_id: external_exports.string(),
                    filename: external_exports.string(),
                    score: external_exports.number(),
                    text: external_exports.string()
                  })
                ).nullish()
              }),
              external_exports.object({
                type: external_exports.literal("code_interpreter_call"),
                id: external_exports.string(),
                code: external_exports.string().nullable(),
                container_id: external_exports.string(),
                outputs: external_exports.array(
                  external_exports.discriminatedUnion("type", [
                    external_exports.object({ type: external_exports.literal("logs"), logs: external_exports.string() }),
                    external_exports.object({ type: external_exports.literal("image"), url: external_exports.string() })
                  ])
                ).nullable()
              }),
              external_exports.object({
                type: external_exports.literal("image_generation_call"),
                id: external_exports.string(),
                result: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("local_shell_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                action: external_exports.object({
                  type: external_exports.literal("exec"),
                  command: external_exports.array(external_exports.string()),
                  timeout_ms: external_exports.number().optional(),
                  user: external_exports.string().optional(),
                  working_directory: external_exports.string().optional(),
                  env: external_exports.record(external_exports.string(), external_exports.string()).optional()
                })
              }),
              external_exports.object({
                type: external_exports.literal("function_call"),
                call_id: external_exports.string(),
                name: external_exports.string(),
                arguments: external_exports.string(),
                id: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("custom_tool_call"),
                call_id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.string(),
                id: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("computer_call"),
                id: external_exports.string(),
                status: external_exports.string().optional()
              }),
              external_exports.object({
                type: external_exports.literal("reasoning"),
                id: external_exports.string(),
                encrypted_content: external_exports.string().nullish(),
                summary: external_exports.array(
                  external_exports.object({
                    type: external_exports.literal("summary_text"),
                    text: external_exports.string()
                  })
                )
              }),
              external_exports.object({
                type: external_exports.literal("mcp_call"),
                id: external_exports.string(),
                status: external_exports.string(),
                arguments: external_exports.string(),
                name: external_exports.string(),
                server_label: external_exports.string(),
                output: external_exports.string().nullish(),
                error: external_exports.union([
                  external_exports.string(),
                  external_exports.object({
                    type: external_exports.string().optional(),
                    code: external_exports.union([external_exports.number(), external_exports.string()]).optional(),
                    message: external_exports.string().optional()
                  }).loose()
                ]).nullish(),
                approval_request_id: external_exports.string().nullish()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_list_tools"),
                id: external_exports.string(),
                server_label: external_exports.string(),
                tools: external_exports.array(
                  external_exports.object({
                    name: external_exports.string(),
                    description: external_exports.string().optional(),
                    input_schema: external_exports.any(),
                    annotations: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
                  })
                ),
                error: external_exports.union([
                  external_exports.string(),
                  external_exports.object({
                    type: external_exports.string().optional(),
                    code: external_exports.union([external_exports.number(), external_exports.string()]).optional(),
                    message: external_exports.string().optional()
                  }).loose()
                ]).optional()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_approval_request"),
                id: external_exports.string(),
                server_label: external_exports.string(),
                name: external_exports.string(),
                arguments: external_exports.string(),
                approval_request_id: external_exports.string().optional()
              }),
              external_exports.object({
                type: external_exports.literal("apply_patch_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                status: external_exports.enum(["in_progress", "completed"]),
                operation: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("create_file"),
                    path: external_exports.string(),
                    diff: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("delete_file"),
                    path: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("update_file"),
                    path: external_exports.string(),
                    diff: external_exports.string()
                  })
                ])
              }),
              external_exports.object({
                type: external_exports.literal("shell_call"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                action: external_exports.object({
                  commands: external_exports.array(external_exports.string())
                })
              }),
              external_exports.object({
                type: external_exports.literal("shell_call_output"),
                id: external_exports.string(),
                call_id: external_exports.string(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                output: external_exports.array(
                  external_exports.object({
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    outcome: external_exports.discriminatedUnion("type", [
                      external_exports.object({ type: external_exports.literal("timeout") }),
                      external_exports.object({
                        type: external_exports.literal("exit"),
                        exit_code: external_exports.number()
                      })
                    ])
                  })
                )
              }),
              external_exports.object({
                type: external_exports.literal("tool_search_call"),
                id: external_exports.string(),
                execution: external_exports.enum(["server", "client"]),
                call_id: external_exports.string().nullable(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                arguments: external_exports.unknown()
              }),
              external_exports.object({
                type: external_exports.literal("tool_search_output"),
                id: external_exports.string(),
                execution: external_exports.enum(["server", "client"]),
                call_id: external_exports.string().nullable(),
                status: external_exports.enum(["in_progress", "completed", "incomplete"]),
                tools: external_exports.array(external_exports.record(external_exports.string(), jsonValueSchema2.optional()))
              })
            ])
          ).optional(),
          service_tier: external_exports.string().nullish(),
          incomplete_details: external_exports.object({ reason: external_exports.string() }).nullish(),
          usage: external_exports.object({
            input_tokens: external_exports.number(),
            input_tokens_details: external_exports.object({ cached_tokens: external_exports.number().nullish() }).nullish(),
            output_tokens: external_exports.number(),
            output_tokens_details: external_exports.object({ reasoning_tokens: external_exports.number().nullish() }).nullish()
          }).optional()
        })
      )
    );
    TOP_LOGPROBS_MAX = 20;
    openaiResponsesReasoningModelIds = [
      "o1",
      "o1-2024-12-17",
      "o3",
      "o3-2025-04-16",
      "o3-mini",
      "o3-mini-2025-01-31",
      "o4-mini",
      "o4-mini-2025-04-16",
      "gpt-5",
      "gpt-5-2025-08-07",
      "gpt-5-codex",
      "gpt-5-mini",
      "gpt-5-mini-2025-08-07",
      "gpt-5-nano",
      "gpt-5-nano-2025-08-07",
      "gpt-5-pro",
      "gpt-5-pro-2025-10-06",
      "gpt-5.1",
      "gpt-5.1-chat-latest",
      "gpt-5.1-codex-mini",
      "gpt-5.1-codex",
      "gpt-5.1-codex-max",
      "gpt-5.2",
      "gpt-5.2-chat-latest",
      "gpt-5.2-pro",
      "gpt-5.2-codex",
      "gpt-5.3-chat-latest",
      "gpt-5.3-codex",
      "gpt-5.4",
      "gpt-5.4-2026-03-05",
      "gpt-5.4-mini",
      "gpt-5.4-mini-2026-03-17",
      "gpt-5.4-nano",
      "gpt-5.4-nano-2026-03-17",
      "gpt-5.4-pro",
      "gpt-5.4-pro-2026-03-05"
    ];
    openaiResponsesModelIds = [
      "gpt-4.1",
      "gpt-4.1-2025-04-14",
      "gpt-4.1-mini",
      "gpt-4.1-mini-2025-04-14",
      "gpt-4.1-nano",
      "gpt-4.1-nano-2025-04-14",
      "gpt-4o",
      "gpt-4o-2024-05-13",
      "gpt-4o-2024-08-06",
      "gpt-4o-2024-11-20",
      "gpt-4o-audio-preview",
      "gpt-4o-audio-preview-2024-12-17",
      "gpt-4o-search-preview",
      "gpt-4o-search-preview-2025-03-11",
      "gpt-4o-mini-search-preview",
      "gpt-4o-mini-search-preview-2025-03-11",
      "gpt-4o-mini",
      "gpt-4o-mini-2024-07-18",
      "gpt-3.5-turbo-0125",
      "gpt-3.5-turbo",
      "gpt-3.5-turbo-1106",
      "gpt-5-chat-latest",
      ...openaiResponsesReasoningModelIds
    ];
    openaiLanguageModelResponsesOptionsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          /**
           * The ID of the OpenAI Conversation to continue.
           * You must create a conversation first via the OpenAI API.
           * Cannot be used in conjunction with `previousResponseId`.
           * Defaults to `undefined`.
           * @see https://platform.openai.com/docs/api-reference/conversations/create
           */
          conversation: external_exports.string().nullish(),
          /**
           * The set of extra fields to include in the response (advanced, usually not needed).
           * Example values: 'reasoning.encrypted_content', 'file_search_call.results', 'message.output_text.logprobs'.
           */
          include: external_exports.array(
            external_exports.enum([
              "reasoning.encrypted_content",
              // handled internally by default, only needed for unknown reasoning models
              "file_search_call.results",
              "message.output_text.logprobs"
            ])
          ).nullish(),
          /**
           * Instructions for the model.
           * They can be used to change the system or developer message when continuing a conversation using the `previousResponseId` option.
           * Defaults to `undefined`.
           */
          instructions: external_exports.string().nullish(),
          /**
           * Return the log probabilities of the tokens. Including logprobs will increase
           * the response size and can slow down response times. However, it can
           * be useful to better understand how the model is behaving.
           *
           * Setting to true will return the log probabilities of the tokens that
           * were generated.
           *
           * Setting to a number will return the log probabilities of the top n
           * tokens that were generated.
           *
           * @see https://platform.openai.com/docs/api-reference/responses/create
           * @see https://cookbook.openai.com/examples/using_logprobs
           */
          logprobs: external_exports.union([external_exports.boolean(), external_exports.number().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
          /**
           * The maximum number of total calls to built-in tools that can be processed in a response.
           * This maximum number applies across all built-in tool calls, not per individual tool.
           * Any further attempts to call a tool by the model will be ignored.
           */
          maxToolCalls: external_exports.number().nullish(),
          /**
           * Additional metadata to store with the generation.
           */
          metadata: external_exports.any().nullish(),
          /**
           * Whether to use parallel tool calls. Defaults to `true`.
           */
          parallelToolCalls: external_exports.boolean().nullish(),
          /**
           * The ID of the previous response. You can use it to continue a conversation.
           * Defaults to `undefined`.
           */
          previousResponseId: external_exports.string().nullish(),
          /**
           * Sets a cache key to tie this prompt to cached prefixes for better caching performance.
           */
          promptCacheKey: external_exports.string().nullish(),
          /**
           * The retention policy for the prompt cache.
           * - 'in_memory': Default. Standard prompt caching behavior.
           * - '24h': Extended prompt caching that keeps cached prefixes active for up to 24 hours.
           *          Currently only available for 5.1 series models.
           *
           * @default 'in_memory'
           */
          promptCacheRetention: external_exports.enum(["in_memory", "24h"]).nullish(),
          /**
           * Reasoning effort for reasoning models. Defaults to `medium`. If you use
           * `providerOptions` to set the `reasoningEffort` option, this model setting will be ignored.
           * Valid values: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh'
           *
           * The 'none' type for `reasoningEffort` is only available for OpenAI's GPT-5.1
           * models. Also, the 'xhigh' type for `reasoningEffort` is only available for
           * OpenAI's GPT-5.1-Codex-Max model. Setting `reasoningEffort` to 'none' or 'xhigh' with unsupported models will result in
           * an error.
           */
          reasoningEffort: external_exports.string().nullish(),
          /**
           * Controls reasoning summary output from the model.
           * Set to "auto" to automatically receive the richest level available,
           * or "detailed" for comprehensive summaries.
           */
          reasoningSummary: external_exports.string().nullish(),
          /**
           * The identifier for safety monitoring and tracking.
           */
          safetyIdentifier: external_exports.string().nullish(),
          /**
           * Service tier for the request.
           * Set to 'flex' for 50% cheaper processing at the cost of increased latency (available for o3, o4-mini, and gpt-5 models).
           * Set to 'priority' for faster processing with Enterprise access (available for gpt-4, gpt-5, gpt-5-mini, o3, o4-mini; gpt-5-nano is not supported).
           *
           * Defaults to 'auto'.
           */
          serviceTier: external_exports.enum(["auto", "flex", "priority", "default"]).nullish(),
          /**
           * Whether to store the generation. Defaults to `true`.
           */
          store: external_exports.boolean().nullish(),
          /**
           * Whether to use strict JSON schema validation.
           * Defaults to `true`.
           */
          strictJsonSchema: external_exports.boolean().nullish(),
          /**
           * Controls the verbosity of the model's responses. Lower values ('low') will result
           * in more concise responses, while higher values ('high') will result in more verbose responses.
           * Valid values: 'low', 'medium', 'high'.
           */
          textVerbosity: external_exports.enum(["low", "medium", "high"]).nullish(),
          /**
           * Controls output truncation. 'auto' (default) performs truncation automatically;
           * 'disabled' turns truncation off.
           */
          truncation: external_exports.enum(["auto", "disabled"]).nullish(),
          /**
           * A unique identifier representing your end-user, which can help OpenAI to
           * monitor and detect abuse.
           * Defaults to `undefined`.
           * @see https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids
           */
          user: external_exports.string().nullish(),
          /**
           * Override the system message mode for this model.
           * - 'system': Use the 'system' role for system messages (default for most models)
           * - 'developer': Use the 'developer' role for system messages (used by reasoning models)
           * - 'remove': Remove system messages entirely
           *
           * If not specified, the mode is automatically determined based on the model.
           */
          systemMessageMode: external_exports.enum(["system", "developer", "remove"]).optional(),
          /**
           * Force treating this model as a reasoning model.
           *
           * This is useful for "stealth" reasoning models (e.g. via a custom baseURL)
           * where the model ID is not recognized by the SDK's allowlist.
           *
           * When enabled, the SDK applies reasoning-model parameter compatibility rules
           * and defaults `systemMessageMode` to `developer` unless overridden.
           */
          forceReasoning: external_exports.boolean().optional()
        })
      )
    );
    OpenAIResponsesLanguageModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.supportedUrls = {
          "image/*": [/^https?:\/\/.*$/],
          "application/pdf": [/^https?:\/\/.*$/]
        };
        this.modelId = modelId;
        this.config = config3;
      }
      get provider() {
        return this.config.provider;
      }
      async getArgs({
        maxOutputTokens,
        temperature,
        stopSequences,
        topP,
        topK,
        presencePenalty,
        frequencyPenalty,
        seed,
        prompt,
        providerOptions,
        tools,
        toolChoice,
        responseFormat
      }) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h, _i;
        const warnings = [];
        const modelCapabilities = getOpenAILanguageModelCapabilities(this.modelId);
        if (topK != null) {
          warnings.push({ type: "unsupported", feature: "topK" });
        }
        if (seed != null) {
          warnings.push({ type: "unsupported", feature: "seed" });
        }
        if (presencePenalty != null) {
          warnings.push({ type: "unsupported", feature: "presencePenalty" });
        }
        if (frequencyPenalty != null) {
          warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
        }
        if (stopSequences != null) {
          warnings.push({ type: "unsupported", feature: "stopSequences" });
        }
        const providerOptionsName = this.config.provider.includes("azure") ? "azure" : "openai";
        let openaiOptions = await parseProviderOptions({
          provider: providerOptionsName,
          providerOptions,
          schema: openaiLanguageModelResponsesOptionsSchema
        });
        if (openaiOptions == null && providerOptionsName !== "openai") {
          openaiOptions = await parseProviderOptions({
            provider: "openai",
            providerOptions,
            schema: openaiLanguageModelResponsesOptionsSchema
          });
        }
        const isReasoningModel = (_a31 = openaiOptions == null ? void 0 : openaiOptions.forceReasoning) != null ? _a31 : modelCapabilities.isReasoningModel;
        if ((openaiOptions == null ? void 0 : openaiOptions.conversation) && (openaiOptions == null ? void 0 : openaiOptions.previousResponseId)) {
          warnings.push({
            type: "unsupported",
            feature: "conversation",
            details: "conversation and previousResponseId cannot be used together"
          });
        }
        const toolNameMapping = createToolNameMapping({
          tools,
          providerToolNames: {
            "openai.code_interpreter": "code_interpreter",
            "openai.file_search": "file_search",
            "openai.image_generation": "image_generation",
            "openai.local_shell": "local_shell",
            "openai.shell": "shell",
            "openai.web_search": "web_search",
            "openai.web_search_preview": "web_search_preview",
            "openai.mcp": "mcp",
            "openai.apply_patch": "apply_patch",
            "openai.tool_search": "tool_search"
          },
          resolveProviderToolName: (tool3) => tool3.id === "openai.custom" ? tool3.args.name : void 0
        });
        const customProviderToolNames = /* @__PURE__ */ new Set();
        const {
          tools: openaiTools2,
          toolChoice: openaiToolChoice,
          toolWarnings
        } = await prepareResponsesTools({
          tools,
          toolChoice,
          toolNameMapping,
          customProviderToolNames
        });
        const { input, warnings: inputWarnings } = await convertToOpenAIResponsesInput({
          prompt,
          toolNameMapping,
          systemMessageMode: (_b27 = openaiOptions == null ? void 0 : openaiOptions.systemMessageMode) != null ? _b27 : isReasoningModel ? "developer" : modelCapabilities.systemMessageMode,
          providerOptionsName,
          fileIdPrefixes: this.config.fileIdPrefixes,
          store: (_c = openaiOptions == null ? void 0 : openaiOptions.store) != null ? _c : true,
          hasConversation: (openaiOptions == null ? void 0 : openaiOptions.conversation) != null,
          hasLocalShellTool: hasOpenAITool("openai.local_shell"),
          hasShellTool: hasOpenAITool("openai.shell"),
          hasApplyPatchTool: hasOpenAITool("openai.apply_patch"),
          customProviderToolNames: customProviderToolNames.size > 0 ? customProviderToolNames : void 0
        });
        warnings.push(...inputWarnings);
        const strictJsonSchema = (_d = openaiOptions == null ? void 0 : openaiOptions.strictJsonSchema) != null ? _d : true;
        let include = openaiOptions == null ? void 0 : openaiOptions.include;
        function addInclude(key) {
          if (include == null) {
            include = [key];
          } else if (!include.includes(key)) {
            include = [...include, key];
          }
        }
        function hasOpenAITool(id) {
          return (tools == null ? void 0 : tools.find((tool3) => tool3.type === "provider" && tool3.id === id)) != null;
        }
        const topLogprobs = typeof (openaiOptions == null ? void 0 : openaiOptions.logprobs) === "number" ? openaiOptions == null ? void 0 : openaiOptions.logprobs : (openaiOptions == null ? void 0 : openaiOptions.logprobs) === true ? TOP_LOGPROBS_MAX : void 0;
        if (topLogprobs) {
          addInclude("message.output_text.logprobs");
        }
        const webSearchToolName = (_e = tools == null ? void 0 : tools.find(
          (tool3) => tool3.type === "provider" && (tool3.id === "openai.web_search" || tool3.id === "openai.web_search_preview")
        )) == null ? void 0 : _e.name;
        if (webSearchToolName) {
          addInclude("web_search_call.action.sources");
        }
        if (hasOpenAITool("openai.code_interpreter")) {
          addInclude("code_interpreter_call.outputs");
        }
        const store = openaiOptions == null ? void 0 : openaiOptions.store;
        if (store === false && isReasoningModel) {
          addInclude("reasoning.encrypted_content");
        }
        const baseArgs = {
          model: this.modelId,
          input,
          temperature,
          top_p: topP,
          max_output_tokens: maxOutputTokens,
          ...((responseFormat == null ? void 0 : responseFormat.type) === "json" || (openaiOptions == null ? void 0 : openaiOptions.textVerbosity)) && {
            text: {
              ...(responseFormat == null ? void 0 : responseFormat.type) === "json" && {
                format: responseFormat.schema != null ? {
                  type: "json_schema",
                  strict: strictJsonSchema,
                  name: (_f = responseFormat.name) != null ? _f : "response",
                  description: responseFormat.description,
                  schema: responseFormat.schema
                } : { type: "json_object" }
              },
              ...(openaiOptions == null ? void 0 : openaiOptions.textVerbosity) && {
                verbosity: openaiOptions.textVerbosity
              }
            }
          },
          // provider options:
          conversation: openaiOptions == null ? void 0 : openaiOptions.conversation,
          max_tool_calls: openaiOptions == null ? void 0 : openaiOptions.maxToolCalls,
          metadata: openaiOptions == null ? void 0 : openaiOptions.metadata,
          parallel_tool_calls: openaiOptions == null ? void 0 : openaiOptions.parallelToolCalls,
          previous_response_id: openaiOptions == null ? void 0 : openaiOptions.previousResponseId,
          store,
          user: openaiOptions == null ? void 0 : openaiOptions.user,
          instructions: openaiOptions == null ? void 0 : openaiOptions.instructions,
          service_tier: openaiOptions == null ? void 0 : openaiOptions.serviceTier,
          include,
          prompt_cache_key: openaiOptions == null ? void 0 : openaiOptions.promptCacheKey,
          prompt_cache_retention: openaiOptions == null ? void 0 : openaiOptions.promptCacheRetention,
          safety_identifier: openaiOptions == null ? void 0 : openaiOptions.safetyIdentifier,
          top_logprobs: topLogprobs,
          truncation: openaiOptions == null ? void 0 : openaiOptions.truncation,
          // model-specific settings:
          ...isReasoningModel && ((openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null || (openaiOptions == null ? void 0 : openaiOptions.reasoningSummary) != null) && {
            reasoning: {
              ...(openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null && {
                effort: openaiOptions.reasoningEffort
              },
              ...(openaiOptions == null ? void 0 : openaiOptions.reasoningSummary) != null && {
                summary: openaiOptions.reasoningSummary
              }
            }
          }
        };
        if (isReasoningModel) {
          if (!((openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) === "none" && modelCapabilities.supportsNonReasoningParameters)) {
            if (baseArgs.temperature != null) {
              baseArgs.temperature = void 0;
              warnings.push({
                type: "unsupported",
                feature: "temperature",
                details: "temperature is not supported for reasoning models"
              });
            }
            if (baseArgs.top_p != null) {
              baseArgs.top_p = void 0;
              warnings.push({
                type: "unsupported",
                feature: "topP",
                details: "topP is not supported for reasoning models"
              });
            }
          }
        } else {
          if ((openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null) {
            warnings.push({
              type: "unsupported",
              feature: "reasoningEffort",
              details: "reasoningEffort is not supported for non-reasoning models"
            });
          }
          if ((openaiOptions == null ? void 0 : openaiOptions.reasoningSummary) != null) {
            warnings.push({
              type: "unsupported",
              feature: "reasoningSummary",
              details: "reasoningSummary is not supported for non-reasoning models"
            });
          }
        }
        if ((openaiOptions == null ? void 0 : openaiOptions.serviceTier) === "flex" && !modelCapabilities.supportsFlexProcessing) {
          warnings.push({
            type: "unsupported",
            feature: "serviceTier",
            details: "flex processing is only available for o3, o4-mini, and gpt-5 models"
          });
          delete baseArgs.service_tier;
        }
        if ((openaiOptions == null ? void 0 : openaiOptions.serviceTier) === "priority" && !modelCapabilities.supportsPriorityProcessing) {
          warnings.push({
            type: "unsupported",
            feature: "serviceTier",
            details: "priority processing is only available for supported models (gpt-4, gpt-5, gpt-5-mini, o3, o4-mini) and requires Enterprise access. gpt-5-nano is not supported"
          });
          delete baseArgs.service_tier;
        }
        const shellToolEnvType = (_i = (_h = (_g = tools == null ? void 0 : tools.find(
          (tool3) => tool3.type === "provider" && tool3.id === "openai.shell"
        )) == null ? void 0 : _g.args) == null ? void 0 : _h.environment) == null ? void 0 : _i.type;
        const isShellProviderExecuted = shellToolEnvType === "containerAuto" || shellToolEnvType === "containerReference";
        return {
          webSearchToolName,
          args: {
            ...baseArgs,
            tools: openaiTools2,
            tool_choice: openaiToolChoice
          },
          warnings: [...warnings, ...toolWarnings],
          store,
          toolNameMapping,
          providerOptionsName,
          isShellProviderExecuted
        };
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B;
        const {
          args: body,
          warnings,
          webSearchToolName,
          toolNameMapping,
          providerOptionsName,
          isShellProviderExecuted
        } = await this.getArgs(options);
        const url4 = this.config.url({
          path: "/responses",
          modelId: this.modelId
        });
        const approvalRequestIdToDummyToolCallIdFromPrompt = extractApprovalRequestIdToToolCallIdMapping(options.prompt);
        const {
          responseHeaders,
          value: response,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: url4,
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            openaiResponsesResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        if (response.error) {
          throw new APICallError({
            message: response.error.message,
            url: url4,
            requestBodyValues: body,
            statusCode: 400,
            responseHeaders,
            responseBody: rawResponse,
            isRetryable: false
          });
        }
        const content = [];
        const logprobs = [];
        let hasFunctionCall = false;
        const hostedToolSearchCallIds = [];
        for (const part of response.output) {
          switch (part.type) {
            case "reasoning": {
              if (part.summary.length === 0) {
                part.summary.push({ type: "summary_text", text: "" });
              }
              for (const summary of part.summary) {
                content.push({
                  type: "reasoning",
                  text: summary.text,
                  providerMetadata: {
                    [providerOptionsName]: {
                      itemId: part.id,
                      reasoningEncryptedContent: (_a31 = part.encrypted_content) != null ? _a31 : null
                    }
                  }
                });
              }
              break;
            }
            case "image_generation_call": {
              content.push({
                type: "tool-call",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName("image_generation"),
                input: "{}",
                providerExecuted: true
              });
              content.push({
                type: "tool-result",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName("image_generation"),
                result: {
                  result: part.result
                }
              });
              break;
            }
            case "tool_search_call": {
              const toolCallId = (_b27 = part.call_id) != null ? _b27 : part.id;
              const isHosted = part.execution === "server";
              if (isHosted) {
                hostedToolSearchCallIds.push(toolCallId);
              }
              content.push({
                type: "tool-call",
                toolCallId,
                toolName: toolNameMapping.toCustomToolName("tool_search"),
                input: JSON.stringify({
                  arguments: part.arguments,
                  call_id: part.call_id
                }),
                ...isHosted ? { providerExecuted: true } : {},
                providerMetadata: {
                  [providerOptionsName]: {
                    itemId: part.id
                  }
                }
              });
              break;
            }
            case "tool_search_output": {
              const toolCallId = (_d = (_c = part.call_id) != null ? _c : hostedToolSearchCallIds.shift()) != null ? _d : part.id;
              content.push({
                type: "tool-result",
                toolCallId,
                toolName: toolNameMapping.toCustomToolName("tool_search"),
                result: {
                  tools: part.tools
                },
                providerMetadata: {
                  [providerOptionsName]: {
                    itemId: part.id
                  }
                }
              });
              break;
            }
            case "local_shell_call": {
              content.push({
                type: "tool-call",
                toolCallId: part.call_id,
                toolName: toolNameMapping.toCustomToolName("local_shell"),
                input: JSON.stringify({
                  action: part.action
                }),
                providerMetadata: {
                  [providerOptionsName]: {
                    itemId: part.id
                  }
                }
              });
              break;
            }
            case "shell_call": {
              content.push({
                type: "tool-call",
                toolCallId: part.call_id,
                toolName: toolNameMapping.toCustomToolName("shell"),
                input: JSON.stringify({
                  action: {
                    commands: part.action.commands
                  }
                }),
                ...isShellProviderExecuted && { providerExecuted: true },
                providerMetadata: {
                  [providerOptionsName]: {
                    itemId: part.id
                  }
                }
              });
              break;
            }
            case "shell_call_output": {
              content.push({
                type: "tool-result",
                toolCallId: part.call_id,
                toolName: toolNameMapping.toCustomToolName("shell"),
                result: {
                  output: part.output.map((item) => ({
                    stdout: item.stdout,
                    stderr: item.stderr,
                    outcome: item.outcome.type === "exit" ? {
                      type: "exit",
                      exitCode: item.outcome.exit_code
                    } : { type: "timeout" }
                  }))
                }
              });
              break;
            }
            case "message": {
              for (const contentPart of part.content) {
                if (((_f = (_e = options.providerOptions) == null ? void 0 : _e[providerOptionsName]) == null ? void 0 : _f.logprobs) && contentPart.logprobs) {
                  logprobs.push(contentPart.logprobs);
                }
                const providerMetadata2 = {
                  itemId: part.id,
                  ...part.phase != null && { phase: part.phase },
                  ...contentPart.annotations.length > 0 && {
                    annotations: contentPart.annotations
                  }
                };
                content.push({
                  type: "text",
                  text: contentPart.text,
                  providerMetadata: {
                    [providerOptionsName]: providerMetadata2
                  }
                });
                for (const annotation of contentPart.annotations) {
                  if (annotation.type === "url_citation") {
                    content.push({
                      type: "source",
                      sourceType: "url",
                      id: (_i = (_h = (_g = this.config).generateId) == null ? void 0 : _h.call(_g)) != null ? _i : generateId(),
                      url: annotation.url,
                      title: annotation.title
                    });
                  } else if (annotation.type === "file_citation") {
                    content.push({
                      type: "source",
                      sourceType: "document",
                      id: (_l = (_k = (_j = this.config).generateId) == null ? void 0 : _k.call(_j)) != null ? _l : generateId(),
                      mediaType: "text/plain",
                      title: annotation.filename,
                      filename: annotation.filename,
                      providerMetadata: {
                        [providerOptionsName]: {
                          type: annotation.type,
                          fileId: annotation.file_id,
                          index: annotation.index
                        }
                      }
                    });
                  } else if (annotation.type === "container_file_citation") {
                    content.push({
                      type: "source",
                      sourceType: "document",
                      id: (_o = (_n = (_m = this.config).generateId) == null ? void 0 : _n.call(_m)) != null ? _o : generateId(),
                      mediaType: "text/plain",
                      title: annotation.filename,
                      filename: annotation.filename,
                      providerMetadata: {
                        [providerOptionsName]: {
                          type: annotation.type,
                          fileId: annotation.file_id,
                          containerId: annotation.container_id
                        }
                      }
                    });
                  } else if (annotation.type === "file_path") {
                    content.push({
                      type: "source",
                      sourceType: "document",
                      id: (_r = (_q = (_p = this.config).generateId) == null ? void 0 : _q.call(_p)) != null ? _r : generateId(),
                      mediaType: "application/octet-stream",
                      title: annotation.file_id,
                      filename: annotation.file_id,
                      providerMetadata: {
                        [providerOptionsName]: {
                          type: annotation.type,
                          fileId: annotation.file_id,
                          index: annotation.index
                        }
                      }
                    });
                  }
                }
              }
              break;
            }
            case "function_call": {
              hasFunctionCall = true;
              content.push({
                type: "tool-call",
                toolCallId: part.call_id,
                toolName: part.name,
                input: part.arguments,
                providerMetadata: {
                  [providerOptionsName]: {
                    itemId: part.id
                  }
                }
              });
              break;
            }
            case "custom_tool_call": {
              hasFunctionCall = true;
              const toolName = toolNameMapping.toCustomToolName(part.name);
              content.push({
                type: "tool-call",
                toolCallId: part.call_id,
                toolName,
                input: JSON.stringify(part.input),
                providerMetadata: {
                  [providerOptionsName]: {
                    itemId: part.id
                  }
                }
              });
              break;
            }
            case "web_search_call": {
              content.push({
                type: "tool-call",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName(
                  webSearchToolName != null ? webSearchToolName : "web_search"
                ),
                input: JSON.stringify({}),
                providerExecuted: true
              });
              content.push({
                type: "tool-result",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName(
                  webSearchToolName != null ? webSearchToolName : "web_search"
                ),
                result: mapWebSearchOutput(part.action)
              });
              break;
            }
            case "mcp_call": {
              const toolCallId = part.approval_request_id != null ? (_s = approvalRequestIdToDummyToolCallIdFromPrompt[part.approval_request_id]) != null ? _s : part.id : part.id;
              const toolName = `mcp.${part.name}`;
              content.push({
                type: "tool-call",
                toolCallId,
                toolName,
                input: part.arguments,
                providerExecuted: true,
                dynamic: true
              });
              content.push({
                type: "tool-result",
                toolCallId,
                toolName,
                result: {
                  type: "call",
                  serverLabel: part.server_label,
                  name: part.name,
                  arguments: part.arguments,
                  ...part.output != null ? { output: part.output } : {},
                  ...part.error != null ? { error: part.error } : {}
                },
                providerMetadata: {
                  [providerOptionsName]: {
                    itemId: part.id
                  }
                }
              });
              break;
            }
            case "mcp_list_tools": {
              break;
            }
            case "mcp_approval_request": {
              const approvalRequestId = (_t = part.approval_request_id) != null ? _t : part.id;
              const dummyToolCallId = (_w = (_v = (_u = this.config).generateId) == null ? void 0 : _v.call(_u)) != null ? _w : generateId();
              const toolName = `mcp.${part.name}`;
              content.push({
                type: "tool-call",
                toolCallId: dummyToolCallId,
                toolName,
                input: part.arguments,
                providerExecuted: true,
                dynamic: true
              });
              content.push({
                type: "tool-approval-request",
                approvalId: approvalRequestId,
                toolCallId: dummyToolCallId
              });
              break;
            }
            case "computer_call": {
              content.push({
                type: "tool-call",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName("computer_use"),
                input: "",
                providerExecuted: true
              });
              content.push({
                type: "tool-result",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName("computer_use"),
                result: {
                  type: "computer_use_tool_result",
                  status: part.status || "completed"
                }
              });
              break;
            }
            case "file_search_call": {
              content.push({
                type: "tool-call",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName("file_search"),
                input: "{}",
                providerExecuted: true
              });
              content.push({
                type: "tool-result",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName("file_search"),
                result: {
                  queries: part.queries,
                  results: (_y = (_x = part.results) == null ? void 0 : _x.map((result) => ({
                    attributes: result.attributes,
                    fileId: result.file_id,
                    filename: result.filename,
                    score: result.score,
                    text: result.text
                  }))) != null ? _y : null
                }
              });
              break;
            }
            case "code_interpreter_call": {
              content.push({
                type: "tool-call",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName("code_interpreter"),
                input: JSON.stringify({
                  code: part.code,
                  containerId: part.container_id
                }),
                providerExecuted: true
              });
              content.push({
                type: "tool-result",
                toolCallId: part.id,
                toolName: toolNameMapping.toCustomToolName("code_interpreter"),
                result: {
                  outputs: part.outputs
                }
              });
              break;
            }
            case "apply_patch_call": {
              content.push({
                type: "tool-call",
                toolCallId: part.call_id,
                toolName: toolNameMapping.toCustomToolName("apply_patch"),
                input: JSON.stringify({
                  callId: part.call_id,
                  operation: part.operation
                }),
                providerMetadata: {
                  [providerOptionsName]: {
                    itemId: part.id
                  }
                }
              });
              break;
            }
          }
        }
        const providerMetadata = {
          [providerOptionsName]: {
            responseId: response.id,
            ...logprobs.length > 0 ? { logprobs } : {},
            ...typeof response.service_tier === "string" ? { serviceTier: response.service_tier } : {}
          }
        };
        const usage = response.usage;
        return {
          content,
          finishReason: {
            unified: mapOpenAIResponseFinishReason({
              finishReason: (_z = response.incomplete_details) == null ? void 0 : _z.reason,
              hasFunctionCall
            }),
            raw: (_B = (_A = response.incomplete_details) == null ? void 0 : _A.reason) != null ? _B : void 0
          },
          usage: convertOpenAIResponsesUsage(usage),
          request: { body },
          response: {
            id: response.id,
            timestamp: new Date(response.created_at * 1e3),
            modelId: response.model,
            headers: responseHeaders,
            body: rawResponse
          },
          providerMetadata,
          warnings
        };
      }
      async doStream(options) {
        const {
          args: body,
          warnings,
          webSearchToolName,
          toolNameMapping,
          store,
          providerOptionsName,
          isShellProviderExecuted
        } = await this.getArgs(options);
        const { responseHeaders, value: response } = await postJsonToApi({
          url: this.config.url({
            path: "/responses",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body: {
            ...body,
            stream: true
          },
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler(
            openaiResponsesChunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const self2 = this;
        const approvalRequestIdToDummyToolCallIdFromPrompt = extractApprovalRequestIdToToolCallIdMapping(options.prompt);
        const approvalRequestIdToDummyToolCallIdFromStream = /* @__PURE__ */ new Map();
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        let usage = void 0;
        const logprobs = [];
        let responseId = null;
        const ongoingToolCalls = {};
        const ongoingAnnotations = [];
        let activeMessagePhase;
        let hasFunctionCall = false;
        const activeReasoning = {};
        let serviceTier;
        const hostedToolSearchCallIds = [];
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L;
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                if (isResponseOutputItemAddedChunk(value)) {
                  if (value.item.type === "function_call") {
                    ongoingToolCalls[value.output_index] = {
                      toolName: value.item.name,
                      toolCallId: value.item.call_id
                    };
                    controller.enqueue({
                      type: "tool-input-start",
                      id: value.item.call_id,
                      toolName: value.item.name
                    });
                  } else if (value.item.type === "custom_tool_call") {
                    const toolName = toolNameMapping.toCustomToolName(
                      value.item.name
                    );
                    ongoingToolCalls[value.output_index] = {
                      toolName,
                      toolCallId: value.item.call_id
                    };
                    controller.enqueue({
                      type: "tool-input-start",
                      id: value.item.call_id,
                      toolName
                    });
                  } else if (value.item.type === "web_search_call") {
                    ongoingToolCalls[value.output_index] = {
                      toolName: toolNameMapping.toCustomToolName(
                        webSearchToolName != null ? webSearchToolName : "web_search"
                      ),
                      toolCallId: value.item.id
                    };
                    controller.enqueue({
                      type: "tool-input-start",
                      id: value.item.id,
                      toolName: toolNameMapping.toCustomToolName(
                        webSearchToolName != null ? webSearchToolName : "web_search"
                      ),
                      providerExecuted: true
                    });
                    controller.enqueue({
                      type: "tool-input-end",
                      id: value.item.id
                    });
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: value.item.id,
                      toolName: toolNameMapping.toCustomToolName(
                        webSearchToolName != null ? webSearchToolName : "web_search"
                      ),
                      input: JSON.stringify({}),
                      providerExecuted: true
                    });
                  } else if (value.item.type === "computer_call") {
                    ongoingToolCalls[value.output_index] = {
                      toolName: toolNameMapping.toCustomToolName("computer_use"),
                      toolCallId: value.item.id
                    };
                    controller.enqueue({
                      type: "tool-input-start",
                      id: value.item.id,
                      toolName: toolNameMapping.toCustomToolName("computer_use"),
                      providerExecuted: true
                    });
                  } else if (value.item.type === "code_interpreter_call") {
                    ongoingToolCalls[value.output_index] = {
                      toolName: toolNameMapping.toCustomToolName("code_interpreter"),
                      toolCallId: value.item.id,
                      codeInterpreter: {
                        containerId: value.item.container_id
                      }
                    };
                    controller.enqueue({
                      type: "tool-input-start",
                      id: value.item.id,
                      toolName: toolNameMapping.toCustomToolName("code_interpreter"),
                      providerExecuted: true
                    });
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: value.item.id,
                      delta: `{"containerId":"${value.item.container_id}","code":"`
                    });
                  } else if (value.item.type === "file_search_call") {
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: value.item.id,
                      toolName: toolNameMapping.toCustomToolName("file_search"),
                      input: "{}",
                      providerExecuted: true
                    });
                  } else if (value.item.type === "image_generation_call") {
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: value.item.id,
                      toolName: toolNameMapping.toCustomToolName("image_generation"),
                      input: "{}",
                      providerExecuted: true
                    });
                  } else if (value.item.type === "tool_search_call") {
                    const toolCallId = value.item.id;
                    const toolName = toolNameMapping.toCustomToolName("tool_search");
                    const isHosted = value.item.execution === "server";
                    ongoingToolCalls[value.output_index] = {
                      toolName,
                      toolCallId,
                      toolSearchExecution: (_a31 = value.item.execution) != null ? _a31 : "server"
                    };
                    if (isHosted) {
                      controller.enqueue({
                        type: "tool-input-start",
                        id: toolCallId,
                        toolName,
                        providerExecuted: true
                      });
                    }
                  } else if (value.item.type === "tool_search_output") {
                  } else if (value.item.type === "mcp_call" || value.item.type === "mcp_list_tools" || value.item.type === "mcp_approval_request") {
                  } else if (value.item.type === "apply_patch_call") {
                    const { call_id: callId, operation } = value.item;
                    ongoingToolCalls[value.output_index] = {
                      toolName: toolNameMapping.toCustomToolName("apply_patch"),
                      toolCallId: callId,
                      applyPatch: {
                        // delete_file doesn't have diff
                        hasDiff: operation.type === "delete_file",
                        endEmitted: operation.type === "delete_file"
                      }
                    };
                    controller.enqueue({
                      type: "tool-input-start",
                      id: callId,
                      toolName: toolNameMapping.toCustomToolName("apply_patch")
                    });
                    if (operation.type === "delete_file") {
                      const inputString = JSON.stringify({
                        callId,
                        operation
                      });
                      controller.enqueue({
                        type: "tool-input-delta",
                        id: callId,
                        delta: inputString
                      });
                      controller.enqueue({
                        type: "tool-input-end",
                        id: callId
                      });
                    } else {
                      controller.enqueue({
                        type: "tool-input-delta",
                        id: callId,
                        delta: `{"callId":"${escapeJSONDelta(callId)}","operation":{"type":"${escapeJSONDelta(operation.type)}","path":"${escapeJSONDelta(operation.path)}","diff":"`
                      });
                    }
                  } else if (value.item.type === "shell_call") {
                    ongoingToolCalls[value.output_index] = {
                      toolName: toolNameMapping.toCustomToolName("shell"),
                      toolCallId: value.item.call_id
                    };
                  } else if (value.item.type === "shell_call_output") {
                  } else if (value.item.type === "message") {
                    ongoingAnnotations.splice(0, ongoingAnnotations.length);
                    activeMessagePhase = (_b27 = value.item.phase) != null ? _b27 : void 0;
                    controller.enqueue({
                      type: "text-start",
                      id: value.item.id,
                      providerMetadata: {
                        [providerOptionsName]: {
                          itemId: value.item.id,
                          ...value.item.phase != null && {
                            phase: value.item.phase
                          }
                        }
                      }
                    });
                  } else if (isResponseOutputItemAddedChunk(value) && value.item.type === "reasoning") {
                    activeReasoning[value.item.id] = {
                      encryptedContent: value.item.encrypted_content,
                      summaryParts: { 0: "active" }
                    };
                    controller.enqueue({
                      type: "reasoning-start",
                      id: `${value.item.id}:0`,
                      providerMetadata: {
                        [providerOptionsName]: {
                          itemId: value.item.id,
                          reasoningEncryptedContent: (_c = value.item.encrypted_content) != null ? _c : null
                        }
                      }
                    });
                  }
                } else if (isResponseOutputItemDoneChunk(value)) {
                  if (value.item.type === "message") {
                    const phase = (_d = value.item.phase) != null ? _d : activeMessagePhase;
                    activeMessagePhase = void 0;
                    controller.enqueue({
                      type: "text-end",
                      id: value.item.id,
                      providerMetadata: {
                        [providerOptionsName]: {
                          itemId: value.item.id,
                          ...phase != null && { phase },
                          ...ongoingAnnotations.length > 0 && {
                            annotations: ongoingAnnotations
                          }
                        }
                      }
                    });
                  } else if (value.item.type === "function_call") {
                    ongoingToolCalls[value.output_index] = void 0;
                    hasFunctionCall = true;
                    controller.enqueue({
                      type: "tool-input-end",
                      id: value.item.call_id
                    });
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: value.item.call_id,
                      toolName: value.item.name,
                      input: value.item.arguments,
                      providerMetadata: {
                        [providerOptionsName]: {
                          itemId: value.item.id
                        }
                      }
                    });
                  } else if (value.item.type === "custom_tool_call") {
                    ongoingToolCalls[value.output_index] = void 0;
                    hasFunctionCall = true;
                    const toolName = toolNameMapping.toCustomToolName(
                      value.item.name
                    );
                    controller.enqueue({
                      type: "tool-input-end",
                      id: value.item.call_id
                    });
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: value.item.call_id,
                      toolName,
                      input: JSON.stringify(value.item.input),
                      providerMetadata: {
                        [providerOptionsName]: {
                          itemId: value.item.id
                        }
                      }
                    });
                  } else if (value.item.type === "web_search_call") {
                    ongoingToolCalls[value.output_index] = void 0;
                    controller.enqueue({
                      type: "tool-result",
                      toolCallId: value.item.id,
                      toolName: toolNameMapping.toCustomToolName(
                        webSearchToolName != null ? webSearchToolName : "web_search"
                      ),
                      result: mapWebSearchOutput(value.item.action)
                    });
                  } else if (value.item.type === "computer_call") {
                    ongoingToolCalls[value.output_index] = void 0;
                    controller.enqueue({
                      type: "tool-input-end",
                      id: value.item.id
                    });
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: value.item.id,
                      toolName: toolNameMapping.toCustomToolName("computer_use"),
                      input: "",
                      providerExecuted: true
                    });
                    controller.enqueue({
                      type: "tool-result",
                      toolCallId: value.item.id,
                      toolName: toolNameMapping.toCustomToolName("computer_use"),
                      result: {
                        type: "computer_use_tool_result",
                        status: value.item.status || "completed"
                      }
                    });
                  } else if (value.item.type === "file_search_call") {
                    ongoingToolCalls[value.output_index] = void 0;
                    controller.enqueue({
                      type: "tool-result",
                      toolCallId: value.item.id,
                      toolName: toolNameMapping.toCustomToolName("file_search"),
                      result: {
                        queries: value.item.queries,
                        results: (_f = (_e = value.item.results) == null ? void 0 : _e.map((result) => ({
                          attributes: result.attributes,
                          fileId: result.file_id,
                          filename: result.filename,
                          score: result.score,
                          text: result.text
                        }))) != null ? _f : null
                      }
                    });
                  } else if (value.item.type === "code_interpreter_call") {
                    ongoingToolCalls[value.output_index] = void 0;
                    controller.enqueue({
                      type: "tool-result",
                      toolCallId: value.item.id,
                      toolName: toolNameMapping.toCustomToolName("code_interpreter"),
                      result: {
                        outputs: value.item.outputs
                      }
                    });
                  } else if (value.item.type === "image_generation_call") {
                    controller.enqueue({
                      type: "tool-result",
                      toolCallId: value.item.id,
                      toolName: toolNameMapping.toCustomToolName("image_generation"),
                      result: {
                        result: value.item.result
                      }
                    });
                  } else if (value.item.type === "tool_search_call") {
                    const toolCall = ongoingToolCalls[value.output_index];
                    const isHosted = value.item.execution === "server";
                    if (toolCall != null) {
                      const toolCallId = isHosted ? toolCall.toolCallId : (_g = value.item.call_id) != null ? _g : value.item.id;
                      if (isHosted) {
                        hostedToolSearchCallIds.push(toolCallId);
                      } else {
                        controller.enqueue({
                          type: "tool-input-start",
                          id: toolCallId,
                          toolName: toolCall.toolName
                        });
                      }
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCallId
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId,
                        toolName: toolCall.toolName,
                        input: JSON.stringify({
                          arguments: value.item.arguments,
                          call_id: isHosted ? null : toolCallId
                        }),
                        ...isHosted ? { providerExecuted: true } : {},
                        providerMetadata: {
                          [providerOptionsName]: {
                            itemId: value.item.id
                          }
                        }
                      });
                    }
                    ongoingToolCalls[value.output_index] = void 0;
                  } else if (value.item.type === "tool_search_output") {
                    const toolCallId = (_i = (_h = value.item.call_id) != null ? _h : hostedToolSearchCallIds.shift()) != null ? _i : value.item.id;
                    controller.enqueue({
                      type: "tool-result",
                      toolCallId,
                      toolName: toolNameMapping.toCustomToolName("tool_search"),
                      result: {
                        tools: value.item.tools
                      },
                      providerMetadata: {
                        [providerOptionsName]: {
                          itemId: value.item.id
                        }
                      }
                    });
                  } else if (value.item.type === "mcp_call") {
                    ongoingToolCalls[value.output_index] = void 0;
                    const approvalRequestId = (_j = value.item.approval_request_id) != null ? _j : void 0;
                    const aliasedToolCallId = approvalRequestId != null ? (_l = (_k = approvalRequestIdToDummyToolCallIdFromStream.get(
                      approvalRequestId
                    )) != null ? _k : approvalRequestIdToDummyToolCallIdFromPrompt[approvalRequestId]) != null ? _l : value.item.id : value.item.id;
                    const toolName = `mcp.${value.item.name}`;
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: aliasedToolCallId,
                      toolName,
                      input: value.item.arguments,
                      providerExecuted: true,
                      dynamic: true
                    });
                    controller.enqueue({
                      type: "tool-result",
                      toolCallId: aliasedToolCallId,
                      toolName,
                      result: {
                        type: "call",
                        serverLabel: value.item.server_label,
                        name: value.item.name,
                        arguments: value.item.arguments,
                        ...value.item.output != null ? { output: value.item.output } : {},
                        ...value.item.error != null ? { error: value.item.error } : {}
                      },
                      providerMetadata: {
                        [providerOptionsName]: {
                          itemId: value.item.id
                        }
                      }
                    });
                  } else if (value.item.type === "mcp_list_tools") {
                    ongoingToolCalls[value.output_index] = void 0;
                  } else if (value.item.type === "apply_patch_call") {
                    const toolCall = ongoingToolCalls[value.output_index];
                    if ((toolCall == null ? void 0 : toolCall.applyPatch) && !toolCall.applyPatch.endEmitted && value.item.operation.type !== "delete_file") {
                      if (!toolCall.applyPatch.hasDiff) {
                        controller.enqueue({
                          type: "tool-input-delta",
                          id: toolCall.toolCallId,
                          delta: escapeJSONDelta(value.item.operation.diff)
                        });
                      }
                      controller.enqueue({
                        type: "tool-input-delta",
                        id: toolCall.toolCallId,
                        delta: '"}}'
                      });
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall.toolCallId
                      });
                      toolCall.applyPatch.endEmitted = true;
                    }
                    if (toolCall && value.item.status === "completed") {
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: toolCall.toolCallId,
                        toolName: toolNameMapping.toCustomToolName("apply_patch"),
                        input: JSON.stringify({
                          callId: value.item.call_id,
                          operation: value.item.operation
                        }),
                        providerMetadata: {
                          [providerOptionsName]: {
                            itemId: value.item.id
                          }
                        }
                      });
                    }
                    ongoingToolCalls[value.output_index] = void 0;
                  } else if (value.item.type === "mcp_approval_request") {
                    ongoingToolCalls[value.output_index] = void 0;
                    const dummyToolCallId = (_o = (_n = (_m = self2.config).generateId) == null ? void 0 : _n.call(_m)) != null ? _o : generateId();
                    const approvalRequestId = (_p = value.item.approval_request_id) != null ? _p : value.item.id;
                    approvalRequestIdToDummyToolCallIdFromStream.set(
                      approvalRequestId,
                      dummyToolCallId
                    );
                    const toolName = `mcp.${value.item.name}`;
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: dummyToolCallId,
                      toolName,
                      input: value.item.arguments,
                      providerExecuted: true,
                      dynamic: true
                    });
                    controller.enqueue({
                      type: "tool-approval-request",
                      approvalId: approvalRequestId,
                      toolCallId: dummyToolCallId
                    });
                  } else if (value.item.type === "local_shell_call") {
                    ongoingToolCalls[value.output_index] = void 0;
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: value.item.call_id,
                      toolName: toolNameMapping.toCustomToolName("local_shell"),
                      input: JSON.stringify({
                        action: {
                          type: "exec",
                          command: value.item.action.command,
                          timeoutMs: value.item.action.timeout_ms,
                          user: value.item.action.user,
                          workingDirectory: value.item.action.working_directory,
                          env: value.item.action.env
                        }
                      }),
                      providerMetadata: {
                        [providerOptionsName]: { itemId: value.item.id }
                      }
                    });
                  } else if (value.item.type === "shell_call") {
                    ongoingToolCalls[value.output_index] = void 0;
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: value.item.call_id,
                      toolName: toolNameMapping.toCustomToolName("shell"),
                      input: JSON.stringify({
                        action: {
                          commands: value.item.action.commands
                        }
                      }),
                      ...isShellProviderExecuted && {
                        providerExecuted: true
                      },
                      providerMetadata: {
                        [providerOptionsName]: { itemId: value.item.id }
                      }
                    });
                  } else if (value.item.type === "shell_call_output") {
                    controller.enqueue({
                      type: "tool-result",
                      toolCallId: value.item.call_id,
                      toolName: toolNameMapping.toCustomToolName("shell"),
                      result: {
                        output: value.item.output.map(
                          (item) => ({
                            stdout: item.stdout,
                            stderr: item.stderr,
                            outcome: item.outcome.type === "exit" ? {
                              type: "exit",
                              exitCode: item.outcome.exit_code
                            } : { type: "timeout" }
                          })
                        )
                      }
                    });
                  } else if (value.item.type === "reasoning") {
                    const activeReasoningPart = activeReasoning[value.item.id];
                    const summaryPartIndices = Object.entries(
                      activeReasoningPart.summaryParts
                    ).filter(
                      ([_, status]) => status === "active" || status === "can-conclude"
                    ).map(([summaryIndex]) => summaryIndex);
                    for (const summaryIndex of summaryPartIndices) {
                      controller.enqueue({
                        type: "reasoning-end",
                        id: `${value.item.id}:${summaryIndex}`,
                        providerMetadata: {
                          [providerOptionsName]: {
                            itemId: value.item.id,
                            reasoningEncryptedContent: (_q = value.item.encrypted_content) != null ? _q : null
                          }
                        }
                      });
                    }
                    delete activeReasoning[value.item.id];
                  }
                } else if (isResponseFunctionCallArgumentsDeltaChunk(value)) {
                  const toolCall = ongoingToolCalls[value.output_index];
                  if (toolCall != null) {
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.toolCallId,
                      delta: value.delta
                    });
                  }
                } else if (isResponseCustomToolCallInputDeltaChunk(value)) {
                  const toolCall = ongoingToolCalls[value.output_index];
                  if (toolCall != null) {
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.toolCallId,
                      delta: value.delta
                    });
                  }
                } else if (isResponseApplyPatchCallOperationDiffDeltaChunk(value)) {
                  const toolCall = ongoingToolCalls[value.output_index];
                  if (toolCall == null ? void 0 : toolCall.applyPatch) {
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.toolCallId,
                      delta: escapeJSONDelta(value.delta)
                    });
                    toolCall.applyPatch.hasDiff = true;
                  }
                } else if (isResponseApplyPatchCallOperationDiffDoneChunk(value)) {
                  const toolCall = ongoingToolCalls[value.output_index];
                  if ((toolCall == null ? void 0 : toolCall.applyPatch) && !toolCall.applyPatch.endEmitted) {
                    if (!toolCall.applyPatch.hasDiff) {
                      controller.enqueue({
                        type: "tool-input-delta",
                        id: toolCall.toolCallId,
                        delta: escapeJSONDelta(value.diff)
                      });
                      toolCall.applyPatch.hasDiff = true;
                    }
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.toolCallId,
                      delta: '"}}'
                    });
                    controller.enqueue({
                      type: "tool-input-end",
                      id: toolCall.toolCallId
                    });
                    toolCall.applyPatch.endEmitted = true;
                  }
                } else if (isResponseImageGenerationCallPartialImageChunk(value)) {
                  controller.enqueue({
                    type: "tool-result",
                    toolCallId: value.item_id,
                    toolName: toolNameMapping.toCustomToolName("image_generation"),
                    result: {
                      result: value.partial_image_b64
                    },
                    preliminary: true
                  });
                } else if (isResponseCodeInterpreterCallCodeDeltaChunk(value)) {
                  const toolCall = ongoingToolCalls[value.output_index];
                  if (toolCall != null) {
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.toolCallId,
                      delta: escapeJSONDelta(value.delta)
                    });
                  }
                } else if (isResponseCodeInterpreterCallCodeDoneChunk(value)) {
                  const toolCall = ongoingToolCalls[value.output_index];
                  if (toolCall != null) {
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.toolCallId,
                      delta: '"}'
                    });
                    controller.enqueue({
                      type: "tool-input-end",
                      id: toolCall.toolCallId
                    });
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId: toolCall.toolCallId,
                      toolName: toolNameMapping.toCustomToolName("code_interpreter"),
                      input: JSON.stringify({
                        code: value.code,
                        containerId: toolCall.codeInterpreter.containerId
                      }),
                      providerExecuted: true
                    });
                  }
                } else if (isResponseCreatedChunk(value)) {
                  responseId = value.response.id;
                  controller.enqueue({
                    type: "response-metadata",
                    id: value.response.id,
                    timestamp: new Date(value.response.created_at * 1e3),
                    modelId: value.response.model
                  });
                } else if (isTextDeltaChunk(value)) {
                  controller.enqueue({
                    type: "text-delta",
                    id: value.item_id,
                    delta: value.delta
                  });
                  if (((_s = (_r = options.providerOptions) == null ? void 0 : _r[providerOptionsName]) == null ? void 0 : _s.logprobs) && value.logprobs) {
                    logprobs.push(value.logprobs);
                  }
                } else if (value.type === "response.reasoning_summary_part.added") {
                  if (value.summary_index > 0) {
                    const activeReasoningPart = activeReasoning[value.item_id];
                    activeReasoningPart.summaryParts[value.summary_index] = "active";
                    for (const summaryIndex of Object.keys(
                      activeReasoningPart.summaryParts
                    )) {
                      if (activeReasoningPart.summaryParts[summaryIndex] === "can-conclude") {
                        controller.enqueue({
                          type: "reasoning-end",
                          id: `${value.item_id}:${summaryIndex}`,
                          providerMetadata: {
                            [providerOptionsName]: {
                              itemId: value.item_id
                            }
                          }
                        });
                        activeReasoningPart.summaryParts[summaryIndex] = "concluded";
                      }
                    }
                    controller.enqueue({
                      type: "reasoning-start",
                      id: `${value.item_id}:${value.summary_index}`,
                      providerMetadata: {
                        [providerOptionsName]: {
                          itemId: value.item_id,
                          reasoningEncryptedContent: (_u = (_t = activeReasoning[value.item_id]) == null ? void 0 : _t.encryptedContent) != null ? _u : null
                        }
                      }
                    });
                  }
                } else if (value.type === "response.reasoning_summary_text.delta") {
                  controller.enqueue({
                    type: "reasoning-delta",
                    id: `${value.item_id}:${value.summary_index}`,
                    delta: value.delta,
                    providerMetadata: {
                      [providerOptionsName]: {
                        itemId: value.item_id
                      }
                    }
                  });
                } else if (value.type === "response.reasoning_summary_part.done") {
                  if (store) {
                    controller.enqueue({
                      type: "reasoning-end",
                      id: `${value.item_id}:${value.summary_index}`,
                      providerMetadata: {
                        [providerOptionsName]: {
                          itemId: value.item_id
                        }
                      }
                    });
                    activeReasoning[value.item_id].summaryParts[value.summary_index] = "concluded";
                  } else {
                    activeReasoning[value.item_id].summaryParts[value.summary_index] = "can-conclude";
                  }
                } else if (isResponseFinishedChunk(value)) {
                  finishReason = {
                    unified: mapOpenAIResponseFinishReason({
                      finishReason: (_v = value.response.incomplete_details) == null ? void 0 : _v.reason,
                      hasFunctionCall
                    }),
                    raw: (_x = (_w = value.response.incomplete_details) == null ? void 0 : _w.reason) != null ? _x : void 0
                  };
                  usage = value.response.usage;
                  if (typeof value.response.service_tier === "string") {
                    serviceTier = value.response.service_tier;
                  }
                } else if (isResponseFailedChunk(value)) {
                  const incompleteReason = (_y = value.response.incomplete_details) == null ? void 0 : _y.reason;
                  finishReason = {
                    unified: incompleteReason ? mapOpenAIResponseFinishReason({
                      finishReason: incompleteReason,
                      hasFunctionCall
                    }) : "error",
                    raw: incompleteReason != null ? incompleteReason : "error"
                  };
                  usage = (_z = value.response.usage) != null ? _z : void 0;
                } else if (isResponseAnnotationAddedChunk(value)) {
                  ongoingAnnotations.push(value.annotation);
                  if (value.annotation.type === "url_citation") {
                    controller.enqueue({
                      type: "source",
                      sourceType: "url",
                      id: (_C = (_B = (_A = self2.config).generateId) == null ? void 0 : _B.call(_A)) != null ? _C : generateId(),
                      url: value.annotation.url,
                      title: value.annotation.title
                    });
                  } else if (value.annotation.type === "file_citation") {
                    controller.enqueue({
                      type: "source",
                      sourceType: "document",
                      id: (_F = (_E = (_D = self2.config).generateId) == null ? void 0 : _E.call(_D)) != null ? _F : generateId(),
                      mediaType: "text/plain",
                      title: value.annotation.filename,
                      filename: value.annotation.filename,
                      providerMetadata: {
                        [providerOptionsName]: {
                          type: value.annotation.type,
                          fileId: value.annotation.file_id,
                          index: value.annotation.index
                        }
                      }
                    });
                  } else if (value.annotation.type === "container_file_citation") {
                    controller.enqueue({
                      type: "source",
                      sourceType: "document",
                      id: (_I = (_H = (_G = self2.config).generateId) == null ? void 0 : _H.call(_G)) != null ? _I : generateId(),
                      mediaType: "text/plain",
                      title: value.annotation.filename,
                      filename: value.annotation.filename,
                      providerMetadata: {
                        [providerOptionsName]: {
                          type: value.annotation.type,
                          fileId: value.annotation.file_id,
                          containerId: value.annotation.container_id
                        }
                      }
                    });
                  } else if (value.annotation.type === "file_path") {
                    controller.enqueue({
                      type: "source",
                      sourceType: "document",
                      id: (_L = (_K = (_J = self2.config).generateId) == null ? void 0 : _K.call(_J)) != null ? _L : generateId(),
                      mediaType: "application/octet-stream",
                      title: value.annotation.file_id,
                      filename: value.annotation.file_id,
                      providerMetadata: {
                        [providerOptionsName]: {
                          type: value.annotation.type,
                          fileId: value.annotation.file_id,
                          index: value.annotation.index
                        }
                      }
                    });
                  }
                } else if (isErrorChunk(value)) {
                  controller.enqueue({ type: "error", error: value });
                }
              },
              flush(controller) {
                const providerMetadata = {
                  [providerOptionsName]: {
                    responseId,
                    ...logprobs.length > 0 ? { logprobs } : {},
                    ...serviceTier !== void 0 ? { serviceTier } : {}
                  }
                };
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage: convertOpenAIResponsesUsage(usage),
                  providerMetadata
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    openaiSpeechModelOptionsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          instructions: external_exports.string().nullish(),
          speed: external_exports.number().min(0.25).max(4).default(1).nullish()
        })
      )
    );
    OpenAISpeechModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
      }
      get provider() {
        return this.config.provider;
      }
      async getArgs({
        text: text2,
        voice = "alloy",
        outputFormat = "mp3",
        speed,
        instructions,
        language,
        providerOptions
      }) {
        const warnings = [];
        const openAIOptions = await parseProviderOptions({
          provider: "openai",
          providerOptions,
          schema: openaiSpeechModelOptionsSchema
        });
        const requestBody = {
          model: this.modelId,
          input: text2,
          voice,
          response_format: "mp3",
          speed,
          instructions
        };
        if (outputFormat) {
          if (["mp3", "opus", "aac", "flac", "wav", "pcm"].includes(outputFormat)) {
            requestBody.response_format = outputFormat;
          } else {
            warnings.push({
              type: "unsupported",
              feature: "outputFormat",
              details: `Unsupported output format: ${outputFormat}. Using mp3 instead.`
            });
          }
        }
        if (openAIOptions) {
          const speechModelOptions = {};
          for (const key in speechModelOptions) {
            const value = speechModelOptions[key];
            if (value !== void 0) {
              requestBody[key] = value;
            }
          }
        }
        if (language) {
          warnings.push({
            type: "unsupported",
            feature: "language",
            details: `OpenAI speech models do not support language selection. Language parameter "${language}" was ignored.`
          });
        }
        return {
          requestBody,
          warnings
        };
      }
      async doGenerate(options) {
        var _a31, _b27, _c;
        const currentDate = (_c = (_b27 = (_a31 = this.config._internal) == null ? void 0 : _a31.currentDate) == null ? void 0 : _b27.call(_a31)) != null ? _c : /* @__PURE__ */ new Date();
        const { requestBody, warnings } = await this.getArgs(options);
        const {
          value: audio,
          responseHeaders,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: this.config.url({
            path: "/audio/speech",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body: requestBody,
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createBinaryResponseHandler(),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        return {
          audio,
          warnings,
          request: {
            body: JSON.stringify(requestBody)
          },
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: responseHeaders,
            body: rawResponse
          }
        };
      }
    };
    openaiTranscriptionResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          text: external_exports.string(),
          language: external_exports.string().nullish(),
          duration: external_exports.number().nullish(),
          words: external_exports.array(
            external_exports.object({
              word: external_exports.string(),
              start: external_exports.number(),
              end: external_exports.number()
            })
          ).nullish(),
          segments: external_exports.array(
            external_exports.object({
              id: external_exports.number(),
              seek: external_exports.number(),
              start: external_exports.number(),
              end: external_exports.number(),
              text: external_exports.string(),
              tokens: external_exports.array(external_exports.number()),
              temperature: external_exports.number(),
              avg_logprob: external_exports.number(),
              compression_ratio: external_exports.number(),
              no_speech_prob: external_exports.number()
            })
          ).nullish()
        })
      )
    );
    openAITranscriptionModelOptions = lazySchema(
      () => zodSchema(
        external_exports.object({
          /**
           * Additional information to include in the transcription response.
           */
          include: external_exports.array(external_exports.string()).optional(),
          /**
           * The language of the input audio in ISO-639-1 format.
           */
          language: external_exports.string().optional(),
          /**
           * An optional text to guide the model's style or continue a previous audio segment.
           */
          prompt: external_exports.string().optional(),
          /**
           * The sampling temperature, between 0 and 1.
           * @default 0
           */
          temperature: external_exports.number().min(0).max(1).default(0).optional(),
          /**
           * The timestamp granularities to populate for this transcription.
           * @default ['segment']
           */
          timestampGranularities: external_exports.array(external_exports.enum(["word", "segment"])).default(["segment"]).optional()
        })
      )
    );
    languageMap = {
      afrikaans: "af",
      arabic: "ar",
      armenian: "hy",
      azerbaijani: "az",
      belarusian: "be",
      bosnian: "bs",
      bulgarian: "bg",
      catalan: "ca",
      chinese: "zh",
      croatian: "hr",
      czech: "cs",
      danish: "da",
      dutch: "nl",
      english: "en",
      estonian: "et",
      finnish: "fi",
      french: "fr",
      galician: "gl",
      german: "de",
      greek: "el",
      hebrew: "he",
      hindi: "hi",
      hungarian: "hu",
      icelandic: "is",
      indonesian: "id",
      italian: "it",
      japanese: "ja",
      kannada: "kn",
      kazakh: "kk",
      korean: "ko",
      latvian: "lv",
      lithuanian: "lt",
      macedonian: "mk",
      malay: "ms",
      marathi: "mr",
      maori: "mi",
      nepali: "ne",
      norwegian: "no",
      persian: "fa",
      polish: "pl",
      portuguese: "pt",
      romanian: "ro",
      russian: "ru",
      serbian: "sr",
      slovak: "sk",
      slovenian: "sl",
      spanish: "es",
      swahili: "sw",
      swedish: "sv",
      tagalog: "tl",
      tamil: "ta",
      thai: "th",
      turkish: "tr",
      ukrainian: "uk",
      urdu: "ur",
      vietnamese: "vi",
      welsh: "cy"
    };
    OpenAITranscriptionModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
      }
      get provider() {
        return this.config.provider;
      }
      async getArgs({
        audio,
        mediaType,
        providerOptions
      }) {
        const warnings = [];
        const openAIOptions = await parseProviderOptions({
          provider: "openai",
          providerOptions,
          schema: openAITranscriptionModelOptions
        });
        const formData = new FormData();
        const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
        formData.append("model", this.modelId);
        const fileExtension = mediaTypeToExtension(mediaType);
        formData.append(
          "file",
          new File([blob], "audio", { type: mediaType }),
          `audio.${fileExtension}`
        );
        if (openAIOptions) {
          const transcriptionModelOptions = {
            include: openAIOptions.include,
            language: openAIOptions.language,
            prompt: openAIOptions.prompt,
            // https://platform.openai.com/docs/api-reference/audio/createTranscription#audio_createtranscription-response_format
            // prefer verbose_json to get segments for models that support it
            response_format: [
              "gpt-4o-transcribe",
              "gpt-4o-mini-transcribe"
            ].includes(this.modelId) ? "json" : "verbose_json",
            temperature: openAIOptions.temperature,
            timestamp_granularities: openAIOptions.timestampGranularities
          };
          for (const [key, value] of Object.entries(transcriptionModelOptions)) {
            if (value != null) {
              if (Array.isArray(value)) {
                for (const item of value) {
                  formData.append(`${key}[]`, String(item));
                }
              } else {
                formData.append(key, String(value));
              }
            }
          }
        }
        return {
          formData,
          warnings
        };
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h;
        const currentDate = (_c = (_b27 = (_a31 = this.config._internal) == null ? void 0 : _a31.currentDate) == null ? void 0 : _b27.call(_a31)) != null ? _c : /* @__PURE__ */ new Date();
        const { formData, warnings } = await this.getArgs(options);
        const {
          value: response,
          responseHeaders,
          rawValue: rawResponse
        } = await postFormDataToApi({
          url: this.config.url({
            path: "/audio/transcriptions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          formData,
          failedResponseHandler: openaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            openaiTranscriptionResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const language = response.language != null && response.language in languageMap ? languageMap[response.language] : void 0;
        return {
          text: response.text,
          segments: (_g = (_f = (_d = response.segments) == null ? void 0 : _d.map((segment) => ({
            text: segment.text,
            startSecond: segment.start,
            endSecond: segment.end
          }))) != null ? _f : (_e = response.words) == null ? void 0 : _e.map((word) => ({
            text: word.word,
            startSecond: word.start,
            endSecond: word.end
          }))) != null ? _g : [],
          language,
          durationInSeconds: (_h = response.duration) != null ? _h : void 0,
          warnings,
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: responseHeaders,
            body: rawResponse
          }
        };
      }
    };
    VERSION4 = true ? "3.0.49" : "0.0.0-test";
    openai = createOpenAI();
  }
});

// node_modules/@ai-sdk/deepseek/dist/index.mjs
function convertToDeepSeekChatMessages({
  prompt,
  responseFormat
}) {
  var _a31;
  const messages = [];
  const warnings = [];
  if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
    if (responseFormat.schema == null) {
      messages.push({
        role: "system",
        content: "Return JSON."
      });
    } else {
      messages.push({
        role: "system",
        content: "Return JSON that conforms to the following schema: " + JSON.stringify(responseFormat.schema)
      });
      warnings.push({
        type: "compatibility",
        feature: "responseFormat JSON schema",
        details: "JSON response schema is injected into the system message."
      });
    }
  }
  let lastUserMessageIndex = -1;
  for (let i = prompt.length - 1; i >= 0; i--) {
    if (prompt[i].role === "user") {
      lastUserMessageIndex = i;
      break;
    }
  }
  let index = -1;
  for (const { role, content } of prompt) {
    index++;
    switch (role) {
      case "system": {
        messages.push({ role: "system", content });
        break;
      }
      case "user": {
        let userContent = "";
        for (const part of content) {
          if (part.type === "text") {
            userContent += part.text;
          } else {
            warnings.push({
              type: "unsupported",
              feature: `user message part type: ${part.type}`
            });
          }
        }
        messages.push({
          role: "user",
          content: userContent
        });
        break;
      }
      case "assistant": {
        let text2 = "";
        let reasoning;
        const toolCalls = [];
        for (const part of content) {
          switch (part.type) {
            case "text": {
              text2 += part.text;
              break;
            }
            case "reasoning": {
              if (index <= lastUserMessageIndex) {
                break;
              }
              if (reasoning == null) {
                reasoning = part.text;
              } else {
                reasoning += part.text;
              }
              break;
            }
            case "tool-call": {
              toolCalls.push({
                id: part.toolCallId,
                type: "function",
                function: {
                  name: part.toolName,
                  arguments: JSON.stringify(part.input)
                }
              });
              break;
            }
          }
        }
        messages.push({
          role: "assistant",
          content: text2,
          reasoning_content: reasoning,
          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
        });
        break;
      }
      case "tool": {
        for (const toolResponse of content) {
          if (toolResponse.type === "tool-approval-response") {
            continue;
          }
          const output = toolResponse.output;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = (_a31 = output.reason) != null ? _a31 : "Tool execution denied.";
              break;
            case "content":
            case "json":
            case "error-json":
              contentValue = JSON.stringify(output.value);
              break;
          }
          messages.push({
            role: "tool",
            tool_call_id: toolResponse.toolCallId,
            content: contentValue
          });
        }
        break;
      }
      default: {
        warnings.push({
          type: "unsupported",
          feature: `message role: ${role}`
        });
        break;
      }
    }
  }
  return { messages, warnings };
}
function convertDeepSeekUsage(usage) {
  var _a31, _b27, _c, _d, _e;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = (_a31 = usage.prompt_tokens) != null ? _a31 : 0;
  const completionTokens = (_b27 = usage.completion_tokens) != null ? _b27 : 0;
  const cacheReadTokens = (_c = usage.prompt_cache_hit_tokens) != null ? _c : 0;
  const reasoningTokens = (_e = (_d = usage.completion_tokens_details) == null ? void 0 : _d.reasoning_tokens) != null ? _e : 0;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens - cacheReadTokens,
      cacheRead: cacheReadTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: completionTokens,
      text: completionTokens - reasoningTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function prepareTools({
  tools,
  toolChoice
}) {
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const deepseekTools = [];
  for (const tool3 of tools) {
    if (tool3.type === "provider") {
      toolWarnings.push({
        type: "unsupported",
        feature: `provider-defined tool ${tool3.id}`
      });
    } else {
      deepseekTools.push({
        type: "function",
        function: {
          name: tool3.name,
          description: tool3.description,
          parameters: tool3.inputSchema,
          ...tool3.strict != null ? { strict: tool3.strict } : {}
        }
      });
    }
  }
  if (toolChoice == null) {
    return { tools: deepseekTools, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice == null ? void 0 : toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
    case "required":
      return { tools: deepseekTools, toolChoice: type, toolWarnings };
    case "tool":
      return {
        tools: deepseekTools,
        toolChoice: {
          type: "function",
          function: { name: toolChoice.toolName }
        },
        toolWarnings
      };
    default: {
      return {
        tools: deepseekTools,
        toolChoice: void 0,
        toolWarnings: [
          ...toolWarnings,
          {
            type: "unsupported",
            feature: `tool choice type: ${type}`
          }
        ]
      };
    }
  }
}
function getResponseMetadata3({
  id,
  model,
  created
}) {
  return {
    id: id != null ? id : void 0,
    modelId: model != null ? model : void 0,
    timestamp: created != null ? new Date(created * 1e3) : void 0
  };
}
function mapDeepSeekFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "content_filter":
      return "content-filter";
    case "tool_calls":
      return "tool-calls";
    case "insufficient_system_resource":
      return "error";
    default:
      return "other";
  }
}
function createDeepSeek(options = {}) {
  var _a31;
  const baseURL = withoutTrailingSlash(
    (_a31 = options.baseURL) != null ? _a31 : "https://api.deepseek.com"
  );
  const getHeaders = () => withUserAgentSuffix(
    {
      Authorization: `Bearer ${loadApiKey({
        apiKey: options.apiKey,
        environmentVariableName: "DEEPSEEK_API_KEY",
        description: "DeepSeek API key"
      })}`,
      ...options.headers
    },
    `ai-sdk/deepseek/${VERSION5}`
  );
  const createLanguageModel = (modelId) => {
    return new DeepSeekChatLanguageModel(modelId, {
      provider: `deepseek.chat`,
      url: ({ path: path33 }) => `${baseURL}${path33}`,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const provider = (modelId) => createLanguageModel(modelId);
  provider.specificationVersion = "v3";
  provider.languageModel = createLanguageModel;
  provider.chat = createLanguageModel;
  provider.embeddingModel = (modelId) => {
    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
  };
  provider.textEmbeddingModel = provider.embeddingModel;
  provider.imageModel = (modelId) => {
    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
  };
  return provider;
}
var tokenUsageSchema, deepSeekErrorSchema, deepseekChatResponseSchema, deepseekChatChunkSchema, deepseekLanguageModelOptions, DeepSeekChatLanguageModel, VERSION5, deepseek;
var init_dist7 = __esm({
  "node_modules/@ai-sdk/deepseek/dist/index.mjs"() {
    "use strict";
    init_dist3();
    init_dist5();
    init_dist3();
    init_dist5();
    init_dist5();
    init_v42();
    init_v42();
    tokenUsageSchema = external_exports.object({
      prompt_tokens: external_exports.number().nullish(),
      completion_tokens: external_exports.number().nullish(),
      prompt_cache_hit_tokens: external_exports.number().nullish(),
      prompt_cache_miss_tokens: external_exports.number().nullish(),
      total_tokens: external_exports.number().nullish(),
      completion_tokens_details: external_exports.object({
        reasoning_tokens: external_exports.number().nullish()
      }).nullish()
    }).nullish();
    deepSeekErrorSchema = external_exports.object({
      error: external_exports.object({
        message: external_exports.string(),
        type: external_exports.string().nullish(),
        param: external_exports.any().nullish(),
        code: external_exports.union([external_exports.string(), external_exports.number()]).nullish()
      })
    });
    deepseekChatResponseSchema = external_exports.object({
      id: external_exports.string().nullish(),
      created: external_exports.number().nullish(),
      model: external_exports.string().nullish(),
      choices: external_exports.array(
        external_exports.object({
          message: external_exports.object({
            role: external_exports.literal("assistant").nullish(),
            content: external_exports.string().nullish(),
            reasoning_content: external_exports.string().nullish(),
            tool_calls: external_exports.array(
              external_exports.object({
                id: external_exports.string().nullish(),
                function: external_exports.object({
                  name: external_exports.string(),
                  arguments: external_exports.string()
                })
              })
            ).nullish()
          }),
          finish_reason: external_exports.string().nullish()
        })
      ),
      usage: tokenUsageSchema
    });
    deepseekChatChunkSchema = lazySchema(
      () => zodSchema(
        external_exports.union([
          external_exports.object({
            id: external_exports.string().nullish(),
            created: external_exports.number().nullish(),
            model: external_exports.string().nullish(),
            choices: external_exports.array(
              external_exports.object({
                delta: external_exports.object({
                  role: external_exports.enum(["assistant"]).nullish(),
                  content: external_exports.string().nullish(),
                  reasoning_content: external_exports.string().nullish(),
                  tool_calls: external_exports.array(
                    external_exports.object({
                      index: external_exports.number(),
                      id: external_exports.string().nullish(),
                      function: external_exports.object({
                        name: external_exports.string().nullish(),
                        arguments: external_exports.string().nullish()
                      })
                    })
                  ).nullish()
                }).nullish(),
                finish_reason: external_exports.string().nullish()
              })
            ),
            usage: tokenUsageSchema
          }),
          deepSeekErrorSchema
        ])
      )
    );
    deepseekLanguageModelOptions = external_exports.object({
      /**
       * Type of thinking to use. Defaults to `enabled`.
       */
      thinking: external_exports.object({
        type: external_exports.enum(["enabled", "disabled"]).optional()
      }).optional()
    });
    DeepSeekChatLanguageModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.supportedUrls = {};
        this.modelId = modelId;
        this.config = config3;
        this.failedResponseHandler = createJsonErrorResponseHandler({
          errorSchema: deepSeekErrorSchema,
          errorToMessage: (error73) => error73.error.message
        });
      }
      get provider() {
        return this.config.provider;
      }
      get providerOptionsName() {
        return this.config.provider.split(".")[0].trim();
      }
      async getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        providerOptions,
        stopSequences,
        responseFormat,
        seed,
        toolChoice,
        tools
      }) {
        var _a31, _b27;
        const deepseekOptions = (_a31 = await parseProviderOptions({
          provider: this.providerOptionsName,
          providerOptions,
          schema: deepseekLanguageModelOptions
        })) != null ? _a31 : {};
        const { messages, warnings } = convertToDeepSeekChatMessages({
          prompt,
          responseFormat
        });
        if (topK != null) {
          warnings.push({ type: "unsupported", feature: "topK" });
        }
        if (seed != null) {
          warnings.push({ type: "unsupported", feature: "seed" });
        }
        const {
          tools: deepseekTools,
          toolChoice: deepseekToolChoices,
          toolWarnings
        } = prepareTools({
          tools,
          toolChoice
        });
        return {
          args: {
            model: this.modelId,
            max_tokens: maxOutputTokens,
            temperature,
            top_p: topP,
            frequency_penalty: frequencyPenalty,
            presence_penalty: presencePenalty,
            response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? { type: "json_object" } : void 0,
            stop: stopSequences,
            messages,
            tools: deepseekTools,
            tool_choice: deepseekToolChoices,
            thinking: ((_b27 = deepseekOptions.thinking) == null ? void 0 : _b27.type) != null ? { type: deepseekOptions.thinking.type } : void 0
          },
          warnings: [...warnings, ...toolWarnings]
        };
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d;
        const { args, warnings } = await this.getArgs({ ...options });
        const {
          responseHeaders,
          value: responseBody,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body: args,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            deepseekChatResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const choice2 = responseBody.choices[0];
        const content = [];
        const reasoning = choice2.message.reasoning_content;
        if (reasoning != null && reasoning.length > 0) {
          content.push({
            type: "reasoning",
            text: reasoning
          });
        }
        if (choice2.message.tool_calls != null) {
          for (const toolCall of choice2.message.tool_calls) {
            content.push({
              type: "tool-call",
              toolCallId: (_a31 = toolCall.id) != null ? _a31 : generateId(),
              toolName: toolCall.function.name,
              input: toolCall.function.arguments
            });
          }
        }
        const text2 = choice2.message.content;
        if (text2 != null && text2.length > 0) {
          content.push({ type: "text", text: text2 });
        }
        return {
          content,
          finishReason: {
            unified: mapDeepSeekFinishReason(choice2.finish_reason),
            raw: (_b27 = choice2.finish_reason) != null ? _b27 : void 0
          },
          usage: convertDeepSeekUsage(responseBody.usage),
          providerMetadata: {
            [this.providerOptionsName]: {
              promptCacheHitTokens: (_c = responseBody.usage) == null ? void 0 : _c.prompt_cache_hit_tokens,
              promptCacheMissTokens: (_d = responseBody.usage) == null ? void 0 : _d.prompt_cache_miss_tokens
            }
          },
          request: { body: args },
          response: {
            ...getResponseMetadata3(responseBody),
            headers: responseHeaders,
            body: rawResponse
          },
          warnings
        };
      }
      async doStream(options) {
        const { args, warnings } = await this.getArgs({ ...options });
        const body = {
          ...args,
          stream: true,
          stream_options: { include_usage: true }
        };
        const { responseHeaders, value: response } = await postJsonToApi({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler(
            deepseekChatChunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const toolCalls = [];
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        let usage = void 0;
        let isFirstChunk = true;
        const providerOptionsName = this.providerOptionsName;
        let isActiveReasoning = false;
        let isActiveText = false;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                if ("error" in value) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: value.error.message });
                  return;
                }
                if (isFirstChunk) {
                  isFirstChunk = false;
                  controller.enqueue({
                    type: "response-metadata",
                    ...getResponseMetadata3(value)
                  });
                }
                if (value.usage != null) {
                  usage = value.usage;
                }
                const choice2 = value.choices[0];
                if ((choice2 == null ? void 0 : choice2.finish_reason) != null) {
                  finishReason = {
                    unified: mapDeepSeekFinishReason(choice2.finish_reason),
                    raw: choice2.finish_reason
                  };
                }
                if ((choice2 == null ? void 0 : choice2.delta) == null) {
                  return;
                }
                const delta = choice2.delta;
                const reasoningContent = delta.reasoning_content;
                if (reasoningContent) {
                  if (!isActiveReasoning) {
                    controller.enqueue({
                      type: "reasoning-start",
                      id: "reasoning-0"
                    });
                    isActiveReasoning = true;
                  }
                  controller.enqueue({
                    type: "reasoning-delta",
                    id: "reasoning-0",
                    delta: reasoningContent
                  });
                }
                if (delta.content) {
                  if (!isActiveText) {
                    controller.enqueue({ type: "text-start", id: "txt-0" });
                    isActiveText = true;
                  }
                  if (isActiveReasoning) {
                    controller.enqueue({
                      type: "reasoning-end",
                      id: "reasoning-0"
                    });
                    isActiveReasoning = false;
                  }
                  controller.enqueue({
                    type: "text-delta",
                    id: "txt-0",
                    delta: delta.content
                  });
                }
                if (delta.tool_calls != null) {
                  if (isActiveReasoning) {
                    controller.enqueue({
                      type: "reasoning-end",
                      id: "reasoning-0"
                    });
                    isActiveReasoning = false;
                  }
                  for (const toolCallDelta of delta.tool_calls) {
                    const index = toolCallDelta.index;
                    if (toolCalls[index] == null) {
                      if (toolCallDelta.id == null) {
                        throw new InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'id' to be a string.`
                        });
                      }
                      if (((_a31 = toolCallDelta.function) == null ? void 0 : _a31.name) == null) {
                        throw new InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'function.name' to be a string.`
                        });
                      }
                      controller.enqueue({
                        type: "tool-input-start",
                        id: toolCallDelta.id,
                        toolName: toolCallDelta.function.name
                      });
                      toolCalls[index] = {
                        id: toolCallDelta.id,
                        type: "function",
                        function: {
                          name: toolCallDelta.function.name,
                          arguments: (_b27 = toolCallDelta.function.arguments) != null ? _b27 : ""
                        },
                        hasFinished: false
                      };
                      const toolCall2 = toolCalls[index];
                      if (((_c = toolCall2.function) == null ? void 0 : _c.name) != null && ((_d = toolCall2.function) == null ? void 0 : _d.arguments) != null) {
                        if (toolCall2.function.arguments.length > 0) {
                          controller.enqueue({
                            type: "tool-input-delta",
                            id: toolCall2.id,
                            delta: toolCall2.function.arguments
                          });
                        }
                        if (isParsableJson(toolCall2.function.arguments)) {
                          controller.enqueue({
                            type: "tool-input-end",
                            id: toolCall2.id
                          });
                          controller.enqueue({
                            type: "tool-call",
                            toolCallId: (_e = toolCall2.id) != null ? _e : generateId(),
                            toolName: toolCall2.function.name,
                            input: toolCall2.function.arguments
                          });
                          toolCall2.hasFinished = true;
                        }
                      }
                      continue;
                    }
                    const toolCall = toolCalls[index];
                    if (toolCall.hasFinished) {
                      continue;
                    }
                    if (((_f = toolCallDelta.function) == null ? void 0 : _f.arguments) != null) {
                      toolCall.function.arguments += (_h = (_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null ? _h : "";
                    }
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.id,
                      delta: (_i = toolCallDelta.function.arguments) != null ? _i : ""
                    });
                    if (((_j = toolCall.function) == null ? void 0 : _j.name) != null && ((_k = toolCall.function) == null ? void 0 : _k.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: (_l = toolCall.id) != null ? _l : generateId(),
                        toolName: toolCall.function.name,
                        input: toolCall.function.arguments
                      });
                      toolCall.hasFinished = true;
                    }
                  }
                }
              },
              flush(controller) {
                var _a31, _b27, _c;
                if (isActiveReasoning) {
                  controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
                }
                if (isActiveText) {
                  controller.enqueue({ type: "text-end", id: "txt-0" });
                }
                for (const toolCall of toolCalls.filter(
                  (toolCall2) => !toolCall2.hasFinished
                )) {
                  controller.enqueue({
                    type: "tool-input-end",
                    id: toolCall.id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: (_a31 = toolCall.id) != null ? _a31 : generateId(),
                    toolName: toolCall.function.name,
                    input: toolCall.function.arguments
                  });
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage: convertDeepSeekUsage(usage),
                  providerMetadata: {
                    [providerOptionsName]: {
                      promptCacheHitTokens: (_b27 = usage == null ? void 0 : usage.prompt_cache_hit_tokens) != null ? _b27 : void 0,
                      promptCacheMissTokens: (_c = usage == null ? void 0 : usage.prompt_cache_miss_tokens) != null ? _c : void 0
                    }
                  }
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    VERSION5 = true ? "2.0.26" : "0.0.0-test";
    deepseek = createDeepSeek();
  }
});

// node_modules/zhipu-ai-provider/node_modules/@ai-sdk/provider/dist/index.mjs
function getErrorMessage3(error73) {
  if (error73 == null) {
    return "unknown error";
  }
  if (typeof error73 === "string") {
    return error73;
  }
  if (error73 instanceof Error) {
    return error73.message;
  }
  return JSON.stringify(error73);
}
var marker16, symbol17, _a17, _b16, AISDKError2, name15, marker22, symbol22, _a22, _b22, APICallError2, name22, marker32, symbol32, _a32, _b32, EmptyResponseBodyError2, name32, marker42, symbol42, _a42, _b42, InvalidArgumentError2, name42, marker52, symbol52, _a52, _b52, InvalidPromptError2, name52, marker62, symbol62, _a62, _b62, InvalidResponseDataError2, name62, marker72, symbol72, _a72, _b72, JSONParseError2, name72, marker82, symbol82, _a82, _b82, LoadAPIKeyError2, name82, marker92, symbol92, _a92, _b92, LoadSettingError2, name92, marker102, symbol102, _a102, _b102, NoContentGeneratedError2, name102, marker112, symbol112, _a112, _b112, NoSuchModelError2, name112, marker122, symbol122, _a122, _b122, TooManyEmbeddingValuesForCallError2, name122, marker132, symbol132, _a132, _b132, TypeValidationError2, name132, marker142, symbol142, _a142, _b142, UnsupportedFunctionalityError2;
var init_dist8 = __esm({
  "node_modules/zhipu-ai-provider/node_modules/@ai-sdk/provider/dist/index.mjs"() {
    "use strict";
    marker16 = "vercel.ai.error";
    symbol17 = Symbol.for(marker16);
    AISDKError2 = class _AISDKError2 extends (_b16 = Error, _a17 = symbol17, _b16) {
      /**
       * Creates an AI SDK Error.
       *
       * @param {Object} params - The parameters for creating the error.
       * @param {string} params.name - The name of the error.
       * @param {string} params.message - The error message.
       * @param {unknown} [params.cause] - The underlying cause of the error.
       */
      constructor({
        name: name143,
        message,
        cause
      }) {
        super(message);
        this[_a17] = true;
        this.name = name143;
        this.cause = cause;
      }
      /**
       * Checks if the given error is an AI SDK Error.
       * @param {unknown} error - The error to check.
       * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
       */
      static isInstance(error73) {
        return _AISDKError2.hasMarker(error73, marker16);
      }
      static hasMarker(error73, marker153) {
        const markerSymbol = Symbol.for(marker153);
        return error73 != null && typeof error73 === "object" && markerSymbol in error73 && typeof error73[markerSymbol] === "boolean" && error73[markerSymbol] === true;
      }
    };
    name15 = "AI_APICallError";
    marker22 = `vercel.ai.error.${name15}`;
    symbol22 = Symbol.for(marker22);
    APICallError2 = class extends (_b22 = AISDKError2, _a22 = symbol22, _b22) {
      constructor({
        message,
        url: url4,
        requestBodyValues,
        statusCode,
        responseHeaders,
        responseBody,
        cause,
        isRetryable = statusCode != null && (statusCode === 408 || // request timeout
        statusCode === 409 || // conflict
        statusCode === 429 || // too many requests
        statusCode >= 500),
        // server error
        data
      }) {
        super({ name: name15, message, cause });
        this[_a22] = true;
        this.url = url4;
        this.requestBodyValues = requestBodyValues;
        this.statusCode = statusCode;
        this.responseHeaders = responseHeaders;
        this.responseBody = responseBody;
        this.isRetryable = isRetryable;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker22);
      }
    };
    name22 = "AI_EmptyResponseBodyError";
    marker32 = `vercel.ai.error.${name22}`;
    symbol32 = Symbol.for(marker32);
    EmptyResponseBodyError2 = class extends (_b32 = AISDKError2, _a32 = symbol32, _b32) {
      // used in isInstance
      constructor({ message = "Empty response body" } = {}) {
        super({ name: name22, message });
        this[_a32] = true;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker32);
      }
    };
    name32 = "AI_InvalidArgumentError";
    marker42 = `vercel.ai.error.${name32}`;
    symbol42 = Symbol.for(marker42);
    InvalidArgumentError2 = class extends (_b42 = AISDKError2, _a42 = symbol42, _b42) {
      constructor({
        message,
        cause,
        argument
      }) {
        super({ name: name32, message, cause });
        this[_a42] = true;
        this.argument = argument;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker42);
      }
    };
    name42 = "AI_InvalidPromptError";
    marker52 = `vercel.ai.error.${name42}`;
    symbol52 = Symbol.for(marker52);
    InvalidPromptError2 = class extends (_b52 = AISDKError2, _a52 = symbol52, _b52) {
      constructor({
        prompt,
        message,
        cause
      }) {
        super({ name: name42, message: `Invalid prompt: ${message}`, cause });
        this[_a52] = true;
        this.prompt = prompt;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker52);
      }
    };
    name52 = "AI_InvalidResponseDataError";
    marker62 = `vercel.ai.error.${name52}`;
    symbol62 = Symbol.for(marker62);
    InvalidResponseDataError2 = class extends (_b62 = AISDKError2, _a62 = symbol62, _b62) {
      constructor({
        data,
        message = `Invalid response data: ${JSON.stringify(data)}.`
      }) {
        super({ name: name52, message });
        this[_a62] = true;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker62);
      }
    };
    name62 = "AI_JSONParseError";
    marker72 = `vercel.ai.error.${name62}`;
    symbol72 = Symbol.for(marker72);
    JSONParseError2 = class extends (_b72 = AISDKError2, _a72 = symbol72, _b72) {
      constructor({ text: text2, cause }) {
        super({
          name: name62,
          message: `JSON parsing failed: Text: ${text2}.
Error message: ${getErrorMessage3(cause)}`,
          cause
        });
        this[_a72] = true;
        this.text = text2;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker72);
      }
    };
    name72 = "AI_LoadAPIKeyError";
    marker82 = `vercel.ai.error.${name72}`;
    symbol82 = Symbol.for(marker82);
    LoadAPIKeyError2 = class extends (_b82 = AISDKError2, _a82 = symbol82, _b82) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name72, message });
        this[_a82] = true;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker82);
      }
    };
    name82 = "AI_LoadSettingError";
    marker92 = `vercel.ai.error.${name82}`;
    symbol92 = Symbol.for(marker92);
    LoadSettingError2 = class extends (_b92 = AISDKError2, _a92 = symbol92, _b92) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name82, message });
        this[_a92] = true;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker92);
      }
    };
    name92 = "AI_NoContentGeneratedError";
    marker102 = `vercel.ai.error.${name92}`;
    symbol102 = Symbol.for(marker102);
    NoContentGeneratedError2 = class extends (_b102 = AISDKError2, _a102 = symbol102, _b102) {
      // used in isInstance
      constructor({
        message = "No content generated."
      } = {}) {
        super({ name: name92, message });
        this[_a102] = true;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker102);
      }
    };
    name102 = "AI_NoSuchModelError";
    marker112 = `vercel.ai.error.${name102}`;
    symbol112 = Symbol.for(marker112);
    NoSuchModelError2 = class extends (_b112 = AISDKError2, _a112 = symbol112, _b112) {
      constructor({
        errorName = name102,
        modelId,
        modelType,
        message = `No such ${modelType}: ${modelId}`
      }) {
        super({ name: errorName, message });
        this[_a112] = true;
        this.modelId = modelId;
        this.modelType = modelType;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker112);
      }
    };
    name112 = "AI_TooManyEmbeddingValuesForCallError";
    marker122 = `vercel.ai.error.${name112}`;
    symbol122 = Symbol.for(marker122);
    TooManyEmbeddingValuesForCallError2 = class extends (_b122 = AISDKError2, _a122 = symbol122, _b122) {
      constructor(options) {
        super({
          name: name112,
          message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
        });
        this[_a122] = true;
        this.provider = options.provider;
        this.modelId = options.modelId;
        this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
        this.values = options.values;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker122);
      }
    };
    name122 = "AI_TypeValidationError";
    marker132 = `vercel.ai.error.${name122}`;
    symbol132 = Symbol.for(marker132);
    TypeValidationError2 = class _TypeValidationError2 extends (_b132 = AISDKError2, _a132 = symbol132, _b132) {
      constructor({ value, cause }) {
        super({
          name: name122,
          message: `Type validation failed: Value: ${JSON.stringify(value)}.
Error message: ${getErrorMessage3(cause)}`,
          cause
        });
        this[_a132] = true;
        this.value = value;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker132);
      }
      /**
       * Wraps an error into a TypeValidationError.
       * If the cause is already a TypeValidationError with the same value, it returns the cause.
       * Otherwise, it creates a new TypeValidationError.
       *
       * @param {Object} params - The parameters for wrapping the error.
       * @param {unknown} params.value - The value that failed validation.
       * @param {unknown} params.cause - The original error or cause of the validation failure.
       * @returns {TypeValidationError} A TypeValidationError instance.
       */
      static wrap({
        value,
        cause
      }) {
        return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
      }
    };
    name132 = "AI_UnsupportedFunctionalityError";
    marker142 = `vercel.ai.error.${name132}`;
    symbol142 = Symbol.for(marker142);
    UnsupportedFunctionalityError2 = class extends (_b142 = AISDKError2, _a142 = symbol142, _b142) {
      constructor({
        functionality,
        message = `'${functionality}' functionality not supported.`
      }) {
        super({ name: name132, message });
        this[_a142] = true;
        this.functionality = functionality;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker142);
      }
    };
  }
});

// node_modules/@standard-schema/spec/dist/index.js
var init_dist9 = __esm({
  "node_modules/@standard-schema/spec/dist/index.js"() {
    "use strict";
  }
});

// node_modules/zhipu-ai-provider/node_modules/@ai-sdk/provider-utils/dist/index.mjs
function combineHeaders2(...headers) {
  return headers.reduce(
    (combinedHeaders, currentHeaders) => ({
      ...combinedHeaders,
      ...currentHeaders != null ? currentHeaders : {}
    }),
    {}
  );
}
function extractResponseHeaders2(response) {
  return Object.fromEntries([...response.headers]);
}
function isAbortError2(error73) {
  return (error73 instanceof Error || error73 instanceof DOMException) && (error73.name === "AbortError" || error73.name === "ResponseAborted" || // Next.js
  error73.name === "TimeoutError");
}
function handleFetchError2({
  error: error73,
  url: url4,
  requestBodyValues
}) {
  if (isAbortError2(error73)) {
    return error73;
  }
  if (error73 instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES2.includes(error73.message.toLowerCase())) {
    const cause = error73.cause;
    if (cause != null) {
      return new APICallError2({
        message: `Cannot connect to API: ${cause.message}`,
        cause,
        url: url4,
        requestBodyValues,
        isRetryable: true
        // retry when network error
      });
    }
  }
  return error73;
}
function getRuntimeEnvironmentUserAgent2(globalThisAny = globalThis) {
  var _a211, _b27, _c;
  if (globalThisAny.window) {
    return `runtime/browser`;
  }
  if ((_a211 = globalThisAny.navigator) == null ? void 0 : _a211.userAgent) {
    return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
  }
  if ((_c = (_b27 = globalThisAny.process) == null ? void 0 : _b27.versions) == null ? void 0 : _c.node) {
    return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
  }
  if (globalThisAny.EdgeRuntime) {
    return `runtime/vercel-edge`;
  }
  return "runtime/unknown";
}
function normalizeHeaders2(headers) {
  if (headers == null) {
    return {};
  }
  const normalized = {};
  if (headers instanceof Headers) {
    headers.forEach((value, key) => {
      normalized[key.toLowerCase()] = value;
    });
  } else {
    if (!Array.isArray(headers)) {
      headers = Object.entries(headers);
    }
    for (const [key, value] of headers) {
      if (value != null) {
        normalized[key.toLowerCase()] = value;
      }
    }
  }
  return normalized;
}
function withUserAgentSuffix2(headers, ...userAgentSuffixParts) {
  const normalizedHeaders = new Headers(normalizeHeaders2(headers));
  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
  normalizedHeaders.set(
    "user-agent",
    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
  );
  return Object.fromEntries(normalizedHeaders.entries());
}
function loadApiKey2({
  apiKey,
  environmentVariableName,
  apiKeyParameterName = "apiKey",
  description
}) {
  if (typeof apiKey === "string") {
    return apiKey;
  }
  if (apiKey != null) {
    throw new LoadAPIKeyError2({
      message: `${description} API key must be a string.`
    });
  }
  if (typeof process === "undefined") {
    throw new LoadAPIKeyError2({
      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
    });
  }
  apiKey = process.env[environmentVariableName];
  if (apiKey == null) {
    throw new LoadAPIKeyError2({
      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
    });
  }
  if (typeof apiKey !== "string") {
    throw new LoadAPIKeyError2({
      message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
    });
  }
  return apiKey;
}
function _parse3(text2) {
  const obj = JSON.parse(text2);
  if (obj === null || typeof obj !== "object") {
    return obj;
  }
  if (suspectProtoRx2.test(text2) === false && suspectConstructorRx2.test(text2) === false) {
    return obj;
  }
  return filter3(obj);
}
function filter3(obj) {
  let next = [obj];
  while (next.length) {
    const nodes = next;
    next = [];
    for (const node of nodes) {
      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      for (const key in node) {
        const value = node[key];
        if (value && typeof value === "object") {
          next.push(value);
        }
      }
    }
  }
  return obj;
}
function secureJsonParse2(text2) {
  const { stackTraceLimit } = Error;
  try {
    Error.stackTraceLimit = 0;
  } catch (e) {
    return _parse3(text2);
  }
  try {
    return _parse3(text2);
  } finally {
    Error.stackTraceLimit = stackTraceLimit;
  }
}
function validator(validate) {
  return { [validatorSymbol]: true, validate };
}
function isValidator(value) {
  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
}
function asValidator(value) {
  return isValidator(value) ? value : typeof value === "function" ? value() : standardSchemaValidator(value);
}
function standardSchemaValidator(standardSchema4) {
  return validator(async (value) => {
    const result = await standardSchema4["~standard"].validate(value);
    return result.issues == null ? { success: true, value: result.value } : {
      success: false,
      error: new TypeValidationError2({
        value,
        cause: result.issues
      })
    };
  });
}
async function validateTypes2({
  value,
  schema
}) {
  const result = await safeValidateTypes2({ value, schema });
  if (!result.success) {
    throw TypeValidationError2.wrap({ value, cause: result.error });
  }
  return result.value;
}
async function safeValidateTypes2({
  value,
  schema
}) {
  const validator2 = asValidator(schema);
  try {
    if (validator2.validate == null) {
      return { success: true, value, rawValue: value };
    }
    const result = await validator2.validate(value);
    if (result.success) {
      return { success: true, value: result.value, rawValue: value };
    }
    return {
      success: false,
      error: TypeValidationError2.wrap({ value, cause: result.error }),
      rawValue: value
    };
  } catch (error73) {
    return {
      success: false,
      error: TypeValidationError2.wrap({ value, cause: error73 }),
      rawValue: value
    };
  }
}
async function parseJSON2({
  text: text2,
  schema
}) {
  try {
    const value = secureJsonParse2(text2);
    if (schema == null) {
      return value;
    }
    return validateTypes2({ value, schema });
  } catch (error73) {
    if (JSONParseError2.isInstance(error73) || TypeValidationError2.isInstance(error73)) {
      throw error73;
    }
    throw new JSONParseError2({ text: text2, cause: error73 });
  }
}
async function safeParseJSON2({
  text: text2,
  schema
}) {
  try {
    const value = secureJsonParse2(text2);
    if (schema == null) {
      return { success: true, value, rawValue: value };
    }
    return await safeValidateTypes2({ value, schema });
  } catch (error73) {
    return {
      success: false,
      error: JSONParseError2.isInstance(error73) ? error73 : new JSONParseError2({ text: text2, cause: error73 }),
      rawValue: void 0
    };
  }
}
function isParsableJson2(input) {
  try {
    secureJsonParse2(input);
    return true;
  } catch (e) {
    return false;
  }
}
function parseJsonEventStream2({
  stream: stream4,
  schema
}) {
  return stream4.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream2()).pipeThrough(
    new TransformStream({
      async transform({ data }, controller) {
        if (data === "[DONE]") {
          return;
        }
        controller.enqueue(await safeParseJSON2({ text: data, schema }));
      }
    })
  );
}
function convertUint8ArrayToBase642(array4) {
  let latin1string = "";
  for (let i = 0; i < array4.length; i++) {
    latin1string += String.fromCodePoint(array4[i]);
  }
  return btoa3(latin1string);
}
function withoutTrailingSlash2(url4) {
  return url4 == null ? void 0 : url4.replace(/\/$/, "");
}
var name16, marker17, symbol18, _a18, _b17, DownloadError2, DEFAULT_MAX_DOWNLOAD_SIZE2, createIdGenerator2, generateId2, FETCH_FAILED_ERROR_MESSAGES2, VERSION6, suspectProtoRx2, suspectConstructorRx2, validatorSymbol, getOriginalFetch22, postJsonToApi2, postToApi2, createJsonErrorResponseHandler2, createEventSourceResponseHandler2, createJsonResponseHandler2, ALPHA_NUMERIC2, btoa3, atob3;
var init_dist10 = __esm({
  "node_modules/zhipu-ai-provider/node_modules/@ai-sdk/provider-utils/dist/index.mjs"() {
    "use strict";
    init_dist8();
    init_dist8();
    init_dist8();
    init_dist8();
    init_dist8();
    init_dist8();
    init_dist8();
    init_stream();
    init_dist8();
    init_dist8();
    init_v42();
    init_v3();
    init_v3();
    init_v3();
    init_dist9();
    name16 = "AI_DownloadError";
    marker17 = `vercel.ai.error.${name16}`;
    symbol18 = Symbol.for(marker17);
    DownloadError2 = class extends (_b17 = AISDKError2, _a18 = symbol18, _b17) {
      constructor({
        url: url4,
        statusCode,
        statusText,
        cause,
        message = cause == null ? `Failed to download ${url4}: ${statusCode} ${statusText}` : `Failed to download ${url4}: ${cause}`
      }) {
        super({ name: name16, message, cause });
        this[_a18] = true;
        this.url = url4;
        this.statusCode = statusCode;
        this.statusText = statusText;
      }
      static isInstance(error73) {
        return AISDKError2.hasMarker(error73, marker17);
      }
    };
    DEFAULT_MAX_DOWNLOAD_SIZE2 = 2 * 1024 * 1024 * 1024;
    createIdGenerator2 = ({
      prefix,
      size = 16,
      alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
      separator = "-"
    } = {}) => {
      const generator = () => {
        const alphabetLength = alphabet.length;
        const chars = new Array(size);
        for (let i = 0; i < size; i++) {
          chars[i] = alphabet[Math.random() * alphabetLength | 0];
        }
        return chars.join("");
      };
      if (prefix == null) {
        return generator;
      }
      if (alphabet.includes(separator)) {
        throw new InvalidArgumentError2({
          argument: "separator",
          message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
        });
      }
      return () => `${prefix}${separator}${generator()}`;
    };
    generateId2 = createIdGenerator2();
    FETCH_FAILED_ERROR_MESSAGES2 = ["fetch failed", "failed to fetch"];
    VERSION6 = true ? "3.0.22" : "0.0.0-test";
    suspectProtoRx2 = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
    suspectConstructorRx2 = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
    validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
    getOriginalFetch22 = () => globalThis.fetch;
    postJsonToApi2 = async ({
      url: url4,
      headers,
      body,
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    }) => postToApi2({
      url: url4,
      headers: {
        "Content-Type": "application/json",
        ...headers
      },
      body: {
        content: JSON.stringify(body),
        values: body
      },
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    });
    postToApi2 = async ({
      url: url4,
      headers = {},
      body,
      successfulResponseHandler,
      failedResponseHandler,
      abortSignal,
      fetch: fetch2 = getOriginalFetch22()
    }) => {
      try {
        const response = await fetch2(url4, {
          method: "POST",
          headers: withUserAgentSuffix2(
            headers,
            `ai-sdk/provider-utils/${VERSION6}`,
            getRuntimeEnvironmentUserAgent2()
          ),
          body: body.content,
          signal: abortSignal
        });
        const responseHeaders = extractResponseHeaders2(response);
        if (!response.ok) {
          let errorInformation;
          try {
            errorInformation = await failedResponseHandler({
              response,
              url: url4,
              requestBodyValues: body.values
            });
          } catch (error73) {
            if (isAbortError2(error73) || APICallError2.isInstance(error73)) {
              throw error73;
            }
            throw new APICallError2({
              message: "Failed to process error response",
              cause: error73,
              statusCode: response.status,
              url: url4,
              responseHeaders,
              requestBodyValues: body.values
            });
          }
          throw errorInformation.value;
        }
        try {
          return await successfulResponseHandler({
            response,
            url: url4,
            requestBodyValues: body.values
          });
        } catch (error73) {
          if (error73 instanceof Error) {
            if (isAbortError2(error73) || APICallError2.isInstance(error73)) {
              throw error73;
            }
          }
          throw new APICallError2({
            message: "Failed to process successful response",
            cause: error73,
            statusCode: response.status,
            url: url4,
            responseHeaders,
            requestBodyValues: body.values
          });
        }
      } catch (error73) {
        throw handleFetchError2({ error: error73, url: url4, requestBodyValues: body.values });
      }
    };
    createJsonErrorResponseHandler2 = ({
      errorSchema,
      errorToMessage,
      isRetryable
    }) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const responseHeaders = extractResponseHeaders2(response);
      if (responseBody.trim() === "") {
        return {
          responseHeaders,
          value: new APICallError2({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
      try {
        const parsedError = await parseJSON2({
          text: responseBody,
          schema: errorSchema
        });
        return {
          responseHeaders,
          value: new APICallError2({
            message: errorToMessage(parsedError),
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            data: parsedError,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
          })
        };
      } catch (parseError) {
        return {
          responseHeaders,
          value: new APICallError2({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
    };
    createEventSourceResponseHandler2 = (chunkSchema2) => async ({ response }) => {
      const responseHeaders = extractResponseHeaders2(response);
      if (response.body == null) {
        throw new EmptyResponseBodyError2({});
      }
      return {
        responseHeaders,
        value: parseJsonEventStream2({
          stream: response.body,
          schema: chunkSchema2
        })
      };
    };
    createJsonResponseHandler2 = (responseSchema2) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const parsedResult = await safeParseJSON2({
        text: responseBody,
        schema: responseSchema2
      });
      const responseHeaders = extractResponseHeaders2(response);
      if (!parsedResult.success) {
        throw new APICallError2({
          message: "Invalid JSON response",
          cause: parsedResult.error,
          statusCode: response.status,
          responseHeaders,
          responseBody,
          url: url4,
          requestBodyValues
        });
      }
      return {
        responseHeaders,
        value: parsedResult.value,
        rawValue: parsedResult.rawValue
      };
    };
    ALPHA_NUMERIC2 = new Set(
      "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
    );
    ({ btoa: btoa3, atob: atob3 } = globalThis);
  }
});

// node_modules/zhipu-ai-provider/dist/index.mjs
// @__NO_SIDE_EFFECTS__
function $constructor2(name28, initializer32, params) {
  var _a37;
  function init(inst, def) {
    if (!inst._zod) {
      Object.defineProperty(inst, "_zod", {
        value: {
          def,
          constr: _,
          traits: /* @__PURE__ */ new Set()
        },
        enumerable: false
      });
    }
    if (inst._zod.traits.has(name28)) {
      return;
    }
    inst._zod.traits.add(name28);
    initializer32(inst, def);
    const proto = _.prototype;
    const keys2 = Object.keys(proto);
    for (let i = 0; i < keys2.length; i++) {
      const k = keys2[i];
      if (!(k in inst)) {
        inst[k] = proto[k].bind(inst);
      }
    }
  }
  const Parent = (_a37 = params == null ? void 0 : params.Parent) != null ? _a37 : Object;
  class Definition extends Parent {
  }
  Object.defineProperty(Definition, "name", { value: name28 });
  function _(def) {
    var _a57;
    var _a47;
    const inst = (params == null ? void 0 : params.Parent) ? new Definition() : this;
    init(inst, def);
    (_a57 = (_a47 = inst._zod).deferred) != null ? _a57 : _a47.deferred = [];
    for (const fn of inst._zod.deferred) {
      fn();
    }
    return inst;
  }
  Object.defineProperty(_, "init", { value: init });
  Object.defineProperty(_, Symbol.hasInstance, {
    value: (inst) => {
      var _a47, _b27;
      if ((params == null ? void 0 : params.Parent) && inst instanceof params.Parent)
        return true;
      return (_b27 = (_a47 = inst == null ? void 0 : inst._zod) == null ? void 0 : _a47.traits) == null ? void 0 : _b27.has(name28);
    }
  });
  Object.defineProperty(_, "name", { value: name28 });
  return _;
}
function config2(newConfig) {
  if (newConfig)
    Object.assign(globalConfig2, newConfig);
  return globalConfig2;
}
function assertEqual2(val) {
  return val;
}
function assertNotEqual2(val) {
  return val;
}
function assertIs2(_arg) {
}
function assertNever2(_x) {
  throw new Error("Unexpected value in exhaustive check");
}
function assert2(_) {
}
function getEnumValues2(entries) {
  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
  return values;
}
function joinValues2(array22, separator = "|") {
  return array22.map((val) => stringifyPrimitive2(val)).join(separator);
}
function jsonStringifyReplacer2(_, value) {
  if (typeof value === "bigint")
    return value.toString();
  return value;
}
function cached2(getter) {
  const set22 = false;
  return {
    get value() {
      if (!set22) {
        const value = getter();
        Object.defineProperty(this, "value", { value });
        return value;
      }
      throw new Error("cached value already set");
    }
  };
}
function nullish3(input) {
  return input === null || input === void 0;
}
function cleanRegex2(source) {
  const start = source.startsWith("^") ? 1 : 0;
  const end = source.endsWith("$") ? source.length - 1 : source.length;
  return source.slice(start, end);
}
function floatSafeRemainder3(val, step) {
  const valDecCount = (val.toString().split(".")[1] || "").length;
  const stepString = step.toString();
  let stepDecCount = (stepString.split(".")[1] || "").length;
  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
    const match = stepString.match(/\d?e-(\d?)/);
    if (match == null ? void 0 : match[1]) {
      stepDecCount = Number.parseInt(match[1]);
    }
  }
  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
  return valInt % stepInt / 10 ** decCount;
}
function defineLazy2(object22, key, getter) {
  let value = void 0;
  Object.defineProperty(object22, key, {
    get() {
      if (value === EVALUATING2) {
        return void 0;
      }
      if (value === void 0) {
        value = EVALUATING2;
        value = getter();
      }
      return value;
    },
    set(v) {
      Object.defineProperty(object22, key, {
        value: v
        // configurable: true,
      });
    },
    configurable: true
  });
}
function objectClone2(obj) {
  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
}
function assignProp2(target, prop, value) {
  Object.defineProperty(target, prop, {
    value,
    writable: true,
    enumerable: true,
    configurable: true
  });
}
function mergeDefs2(...defs) {
  const mergedDescriptors = {};
  for (const def of defs) {
    const descriptors = Object.getOwnPropertyDescriptors(def);
    Object.assign(mergedDescriptors, descriptors);
  }
  return Object.defineProperties({}, mergedDescriptors);
}
function cloneDef2(schema) {
  return mergeDefs2(schema._zod.def);
}
function getElementAtPath2(obj, path33) {
  if (!path33)
    return obj;
  return path33.reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
}
function promiseAllObject2(promisesObj) {
  const keys2 = Object.keys(promisesObj);
  const promises6 = keys2.map((key) => promisesObj[key]);
  return Promise.all(promises6).then((results) => {
    const resolvedObj = {};
    for (let i = 0; i < keys2.length; i++) {
      resolvedObj[keys2[i]] = results[i];
    }
    return resolvedObj;
  });
}
function randomString2(length = 10) {
  const chars = "abcdefghijklmnopqrstuvwxyz";
  let str = "";
  for (let i = 0; i < length; i++) {
    str += chars[Math.floor(Math.random() * chars.length)];
  }
  return str;
}
function esc2(str) {
  return JSON.stringify(str);
}
function slugify2(input) {
  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
}
function isObject4(data) {
  return typeof data === "object" && data !== null && !Array.isArray(data);
}
function isPlainObject3(o) {
  if (isObject4(o) === false)
    return false;
  const ctor = o.constructor;
  if (ctor === void 0)
    return true;
  if (typeof ctor !== "function")
    return true;
  const prot = ctor.prototype;
  if (isObject4(prot) === false)
    return false;
  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
    return false;
  }
  return true;
}
function shallowClone2(o) {
  if (isPlainObject3(o))
    return { ...o };
  if (Array.isArray(o))
    return [...o];
  return o;
}
function numKeys2(data) {
  let keyCount = 0;
  for (const key in data) {
    if (Object.prototype.hasOwnProperty.call(data, key)) {
      keyCount++;
    }
  }
  return keyCount;
}
function escapeRegex2(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone2(inst, def, params) {
  const cl = new inst._zod.constr(def != null ? def : inst._zod.def);
  if (!def || (params == null ? void 0 : params.parent))
    cl._zod.parent = inst;
  return cl;
}
function normalizeParams2(_params) {
  const params = _params;
  if (!params)
    return {};
  if (typeof params === "string")
    return { error: () => params };
  if ((params == null ? void 0 : params.message) !== void 0) {
    if ((params == null ? void 0 : params.error) !== void 0)
      throw new Error("Cannot specify both `message` and `error` params");
    params.error = params.message;
  }
  delete params.message;
  if (typeof params.error === "string")
    return { ...params, error: () => params.error };
  return params;
}
function createTransparentProxy2(getter) {
  let target;
  return new Proxy({}, {
    get(_, prop, receiver) {
      target != null ? target : target = getter();
      return Reflect.get(target, prop, receiver);
    },
    set(_, prop, value, receiver) {
      target != null ? target : target = getter();
      return Reflect.set(target, prop, value, receiver);
    },
    has(_, prop) {
      target != null ? target : target = getter();
      return Reflect.has(target, prop);
    },
    deleteProperty(_, prop) {
      target != null ? target : target = getter();
      return Reflect.deleteProperty(target, prop);
    },
    ownKeys(_) {
      target != null ? target : target = getter();
      return Reflect.ownKeys(target);
    },
    getOwnPropertyDescriptor(_, prop) {
      target != null ? target : target = getter();
      return Reflect.getOwnPropertyDescriptor(target, prop);
    },
    defineProperty(_, prop, descriptor) {
      target != null ? target : target = getter();
      return Reflect.defineProperty(target, prop, descriptor);
    }
  });
}
function stringifyPrimitive2(value) {
  if (typeof value === "bigint")
    return value.toString() + "n";
  if (typeof value === "string")
    return `"${value}"`;
  return `${value}`;
}
function optionalKeys2(shape) {
  return Object.keys(shape).filter((k) => {
    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
  });
}
function pick2(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".pick() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs2(schema._zod.def, {
    get shape() {
      const newShape = {};
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        newShape[key] = currDef.shape[key];
      }
      assignProp2(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone2(schema, def);
}
function omit2(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".omit() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs2(schema._zod.def, {
    get shape() {
      const newShape = { ...schema._zod.def.shape };
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        delete newShape[key];
      }
      assignProp2(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone2(schema, def);
}
function extend3(schema, shape) {
  if (!isPlainObject3(shape)) {
    throw new Error("Invalid input to extend: expected a plain object");
  }
  const checks = schema._zod.def.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    const existingShape = schema._zod.def.shape;
    for (const key in shape) {
      if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
      }
    }
  }
  const def = mergeDefs2(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp2(this, "shape", _shape);
      return _shape;
    }
  });
  return clone2(schema, def);
}
function safeExtend2(schema, shape) {
  if (!isPlainObject3(shape)) {
    throw new Error("Invalid input to safeExtend: expected a plain object");
  }
  const def = mergeDefs2(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp2(this, "shape", _shape);
      return _shape;
    }
  });
  return clone2(schema, def);
}
function merge3(a, b) {
  const def = mergeDefs2(a._zod.def, {
    get shape() {
      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
      assignProp2(this, "shape", _shape);
      return _shape;
    },
    get catchall() {
      return b._zod.def.catchall;
    },
    checks: []
    // delete existing checks
  });
  return clone2(a, def);
}
function partial2(Class22, schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".partial() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs2(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in oldShape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = Class22 ? new Class22({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      } else {
        for (const key in oldShape) {
          shape[key] = Class22 ? new Class22({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      }
      assignProp2(this, "shape", shape);
      return shape;
    },
    checks: []
  });
  return clone2(schema, def);
}
function required2(Class22, schema, mask) {
  const def = mergeDefs2(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in shape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = new Class22({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      } else {
        for (const key in oldShape) {
          shape[key] = new Class22({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      }
      assignProp2(this, "shape", shape);
      return shape;
    }
  });
  return clone2(schema, def);
}
function aborted2(x, startIndex = 0) {
  var _a37;
  if (x.aborted === true)
    return true;
  for (let i = startIndex; i < x.issues.length; i++) {
    if (((_a37 = x.issues[i]) == null ? void 0 : _a37.continue) !== true) {
      return true;
    }
  }
  return false;
}
function prefixIssues2(path33, issues) {
  return issues.map((iss) => {
    var _a47;
    var _a37;
    (_a47 = (_a37 = iss).path) != null ? _a47 : _a37.path = [];
    iss.path.unshift(path33);
    return iss;
  });
}
function unwrapMessage2(message) {
  return typeof message === "string" ? message : message == null ? void 0 : message.message;
}
function finalizeIssue2(iss, ctx, config22) {
  var _a37, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k;
  const full = { ...iss, path: (_a37 = iss.path) != null ? _a37 : [] };
  if (!iss.message) {
    const message = (_k = (_j = (_h = (_f = unwrapMessage2((_d = (_c = (_b27 = iss.inst) == null ? void 0 : _b27._zod.def) == null ? void 0 : _c.error) == null ? void 0 : _d.call(_c, iss))) != null ? _f : unwrapMessage2((_e = ctx == null ? void 0 : ctx.error) == null ? void 0 : _e.call(ctx, iss))) != null ? _h : unwrapMessage2((_g = config22.customError) == null ? void 0 : _g.call(config22, iss))) != null ? _j : unwrapMessage2((_i = config22.localeError) == null ? void 0 : _i.call(config22, iss))) != null ? _k : "Invalid input";
    full.message = message;
  }
  delete full.inst;
  delete full.continue;
  if (!(ctx == null ? void 0 : ctx.reportInput)) {
    delete full.input;
  }
  return full;
}
function getSizableOrigin2(input) {
  if (input instanceof Set)
    return "set";
  if (input instanceof Map)
    return "map";
  if (input instanceof File)
    return "file";
  return "unknown";
}
function getLengthableOrigin2(input) {
  if (Array.isArray(input))
    return "array";
  if (typeof input === "string")
    return "string";
  return "unknown";
}
function parsedType2(data) {
  const t = typeof data;
  switch (t) {
    case "number": {
      return Number.isNaN(data) ? "nan" : "number";
    }
    case "object": {
      if (data === null) {
        return "null";
      }
      if (Array.isArray(data)) {
        return "array";
      }
      const obj = data;
      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
        return obj.constructor.name;
      }
    }
  }
  return t;
}
function issue2(...args) {
  const [iss, input, inst] = args;
  if (typeof iss === "string") {
    return {
      message: iss,
      code: "custom",
      input,
      inst
    };
  }
  return { ...iss };
}
function cleanEnum2(obj) {
  return Object.entries(obj).filter(([k, _]) => {
    return Number.isNaN(Number.parseInt(k, 10));
  }).map((el) => el[1]);
}
function base64ToUint8Array2(base6432) {
  const binaryString = atob(base6432);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  return bytes;
}
function uint8ArrayToBase642(bytes) {
  let binaryString = "";
  for (let i = 0; i < bytes.length; i++) {
    binaryString += String.fromCharCode(bytes[i]);
  }
  return btoa(binaryString);
}
function base64urlToUint8Array2(base64url32) {
  const base6432 = base64url32.replace(/-/g, "+").replace(/_/g, "/");
  const padding = "=".repeat((4 - base6432.length % 4) % 4);
  return base64ToUint8Array2(base6432 + padding);
}
function uint8ArrayToBase64url2(bytes) {
  return uint8ArrayToBase642(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
}
function hexToUint8Array2(hex32) {
  const cleanHex = hex32.replace(/^0x/, "");
  if (cleanHex.length % 2 !== 0) {
    throw new Error("Invalid hex string length");
  }
  const bytes = new Uint8Array(cleanHex.length / 2);
  for (let i = 0; i < cleanHex.length; i += 2) {
    bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
  }
  return bytes;
}
function uint8ArrayToHex2(bytes) {
  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
}
function flattenError2(error482, mapper = (issue22) => issue22.message) {
  const fieldErrors = {};
  const formErrors = [];
  for (const sub of error482.issues) {
    if (sub.path.length > 0) {
      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
      fieldErrors[sub.path[0]].push(mapper(sub));
    } else {
      formErrors.push(mapper(sub));
    }
  }
  return { formErrors, fieldErrors };
}
function formatError2(error482, mapper = (issue22) => issue22.message) {
  const fieldErrors = { _errors: [] };
  const processError = (error492) => {
    for (const issue22 of error492.issues) {
      if (issue22.code === "invalid_union" && issue22.errors.length) {
        issue22.errors.map((issues) => processError({ issues }));
      } else if (issue22.code === "invalid_key") {
        processError({ issues: issue22.issues });
      } else if (issue22.code === "invalid_element") {
        processError({ issues: issue22.issues });
      } else if (issue22.path.length === 0) {
        fieldErrors._errors.push(mapper(issue22));
      } else {
        let curr = fieldErrors;
        let i = 0;
        while (i < issue22.path.length) {
          const el = issue22.path[i];
          const terminal = i === issue22.path.length - 1;
          if (!terminal) {
            curr[el] = curr[el] || { _errors: [] };
          } else {
            curr[el] = curr[el] || { _errors: [] };
            curr[el]._errors.push(mapper(issue22));
          }
          curr = curr[el];
          i++;
        }
      }
    }
  };
  processError(error482);
  return fieldErrors;
}
function treeifyError2(error482, mapper = (issue22) => issue22.message) {
  const result = { errors: [] };
  const processError = (error492, path33 = []) => {
    var _a47, _b27, _c, _d;
    var _a37, _b28;
    for (const issue22 of error492.issues) {
      if (issue22.code === "invalid_union" && issue22.errors.length) {
        issue22.errors.map((issues) => processError({ issues }, issue22.path));
      } else if (issue22.code === "invalid_key") {
        processError({ issues: issue22.issues }, issue22.path);
      } else if (issue22.code === "invalid_element") {
        processError({ issues: issue22.issues }, issue22.path);
      } else {
        const fullpath = [...path33, ...issue22.path];
        if (fullpath.length === 0) {
          result.errors.push(mapper(issue22));
          continue;
        }
        let curr = result;
        let i = 0;
        while (i < fullpath.length) {
          const el = fullpath[i];
          const terminal = i === fullpath.length - 1;
          if (typeof el === "string") {
            (_a47 = curr.properties) != null ? _a47 : curr.properties = {};
            (_b27 = (_a37 = curr.properties)[el]) != null ? _b27 : _a37[el] = { errors: [] };
            curr = curr.properties[el];
          } else {
            (_c = curr.items) != null ? _c : curr.items = [];
            (_d = (_b28 = curr.items)[el]) != null ? _d : _b28[el] = { errors: [] };
            curr = curr.items[el];
          }
          if (terminal) {
            curr.errors.push(mapper(issue22));
          }
          i++;
        }
      }
    }
  };
  processError(error482);
  return result;
}
function toDotPath2(_path) {
  const segs = [];
  const path33 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
  for (const seg of path33) {
    if (typeof seg === "number")
      segs.push(`[${seg}]`);
    else if (typeof seg === "symbol")
      segs.push(`[${JSON.stringify(String(seg))}]`);
    else if (/[^\w$]/.test(seg))
      segs.push(`[${JSON.stringify(seg)}]`);
    else {
      if (segs.length)
        segs.push(".");
      segs.push(seg);
    }
  }
  return segs.join("");
}
function prettifyError2(error482) {
  var _a37;
  const lines = [];
  const issues = [...error482.issues].sort((a, b) => {
    var _a47, _b27;
    return ((_a47 = a.path) != null ? _a47 : []).length - ((_b27 = b.path) != null ? _b27 : []).length;
  });
  for (const issue22 of issues) {
    lines.push(`\u2716 ${issue22.message}`);
    if ((_a37 = issue22.path) == null ? void 0 : _a37.length)
      lines.push(`  \u2192 at ${toDotPath2(issue22.path)}`);
  }
  return lines.join("\n");
}
function emoji3() {
  return new RegExp(_emoji3, "u");
}
function timeSource2(args) {
  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
  return regex;
}
function time3(args) {
  return new RegExp(`^${timeSource2(args)}$`);
}
function datetime3(args) {
  const time32 = timeSource2({ precision: args.precision });
  const opts = ["Z"];
  if (args.local)
    opts.push("");
  if (args.offset)
    opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
  const timeRegex2 = `${time32}(?:${opts.join("|")})`;
  return new RegExp(`^${dateSource2}T(?:${timeRegex2})$`);
}
function fixedBase642(bodyLength, padding) {
  return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
}
function fixedBase64url2(length) {
  return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
}
function handleCheckPropertyResult2(result, payload, property2) {
  if (result.issues.length) {
    payload.issues.push(...prefixIssues2(property2, result.issues));
  }
}
function isValidBase642(data) {
  if (data === "")
    return true;
  if (data.length % 4 !== 0)
    return false;
  try {
    atob(data);
    return true;
  } catch (e) {
    return false;
  }
}
function isValidBase64URL2(data) {
  if (!base64url3.test(data))
    return false;
  const base6432 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
  const padded = base6432.padEnd(Math.ceil(base6432.length / 4) * 4, "=");
  return isValidBase642(padded);
}
function isValidJWT3(token, algorithm = null) {
  try {
    const tokensParts = token.split(".");
    if (tokensParts.length !== 3)
      return false;
    const [header] = tokensParts;
    if (!header)
      return false;
    const parsedHeader = JSON.parse(atob(header));
    if ("typ" in parsedHeader && (parsedHeader == null ? void 0 : parsedHeader.typ) !== "JWT")
      return false;
    if (!parsedHeader.alg)
      return false;
    if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
      return false;
    return true;
  } catch (e) {
    return false;
  }
}
function handleArrayResult2(result, final, index) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues2(index, result.issues));
  }
  final.value[index] = result.value;
}
function handlePropertyResult2(result, final, key, input, isOptionalOut) {
  if (result.issues.length) {
    if (isOptionalOut && !(key in input)) {
      return;
    }
    final.issues.push(...prefixIssues2(key, result.issues));
  }
  if (result.value === void 0) {
    if (key in input) {
      final.value[key] = void 0;
    }
  } else {
    final.value[key] = result.value;
  }
}
function normalizeDef2(def) {
  var _a37, _b27, _c, _d;
  const keys2 = Object.keys(def.shape);
  for (const k of keys2) {
    if (!((_d = (_c = (_b27 = (_a37 = def.shape) == null ? void 0 : _a37[k]) == null ? void 0 : _b27._zod) == null ? void 0 : _c.traits) == null ? void 0 : _d.has("$ZodType"))) {
      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
    }
  }
  const okeys = optionalKeys2(def.shape);
  return {
    ...def,
    keys: keys2,
    keySet: new Set(keys2),
    numKeys: keys2.length,
    optionalKeys: new Set(okeys)
  };
}
function handleCatchall2(proms, input, payload, ctx, def, inst) {
  const unrecognized = [];
  const keySet = def.keySet;
  const _catchall = def.catchall._zod;
  const t = _catchall.def.type;
  const isOptionalOut = _catchall.optout === "optional";
  for (const key in input) {
    if (keySet.has(key))
      continue;
    if (t === "never") {
      unrecognized.push(key);
      continue;
    }
    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
    if (r instanceof Promise) {
      proms.push(r.then((r2) => handlePropertyResult2(r2, payload, key, input, isOptionalOut)));
    } else {
      handlePropertyResult2(r, payload, key, input, isOptionalOut);
    }
  }
  if (unrecognized.length) {
    payload.issues.push({
      code: "unrecognized_keys",
      keys: unrecognized,
      input,
      inst
    });
  }
  if (!proms.length)
    return payload;
  return Promise.all(proms).then(() => {
    return payload;
  });
}
function handleUnionResults2(results, final, inst, ctx) {
  for (const result of results) {
    if (result.issues.length === 0) {
      final.value = result.value;
      return final;
    }
  }
  const nonaborted = results.filter((r) => !aborted2(r));
  if (nonaborted.length === 1) {
    final.value = nonaborted[0].value;
    return nonaborted[0];
  }
  final.issues.push({
    code: "invalid_union",
    input: final.value,
    inst,
    errors: results.map((result) => result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())))
  });
  return final;
}
function handleExclusiveUnionResults2(results, final, inst, ctx) {
  const successes = results.filter((r) => r.issues.length === 0);
  if (successes.length === 1) {
    final.value = successes[0].value;
    return final;
  }
  if (successes.length === 0) {
    final.issues.push({
      code: "invalid_union",
      input: final.value,
      inst,
      errors: results.map((result) => result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())))
    });
  } else {
    final.issues.push({
      code: "invalid_union",
      input: final.value,
      inst,
      errors: [],
      inclusive: false
    });
  }
  return final;
}
function mergeValues3(a, b) {
  if (a === b) {
    return { valid: true, data: a };
  }
  if (a instanceof Date && b instanceof Date && +a === +b) {
    return { valid: true, data: a };
  }
  if (isPlainObject3(a) && isPlainObject3(b)) {
    const bKeys = Object.keys(b);
    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues3(a[key], b[key]);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
        };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  }
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) {
      return { valid: false, mergeErrorPath: [] };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues3(itemA, itemB);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
        };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  }
  return { valid: false, mergeErrorPath: [] };
}
function handleIntersectionResults2(result, left, right) {
  const unrecKeys = /* @__PURE__ */ new Map();
  let unrecIssue;
  for (const iss of left.issues) {
    if (iss.code === "unrecognized_keys") {
      unrecIssue != null ? unrecIssue : unrecIssue = iss;
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).l = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  for (const iss of right.issues) {
    if (iss.code === "unrecognized_keys") {
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).r = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
  if (bothKeys.length && unrecIssue) {
    result.issues.push({ ...unrecIssue, keys: bothKeys });
  }
  if (aborted2(result))
    return result;
  const merged = mergeValues3(left.value, right.value);
  if (!merged.valid) {
    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
  }
  result.value = merged.data;
  return result;
}
function handleTupleResult2(result, final, index) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues2(index, result.issues));
  }
  final.value[index] = result.value;
}
function handleMapResult2(keyResult, valueResult, final, key, input, inst, ctx) {
  if (keyResult.issues.length) {
    if (propertyKeyTypes2.has(typeof key)) {
      final.issues.push(...prefixIssues2(key, keyResult.issues));
    } else {
      final.issues.push({
        code: "invalid_key",
        origin: "map",
        input,
        inst,
        issues: keyResult.issues.map((iss) => finalizeIssue2(iss, ctx, config2()))
      });
    }
  }
  if (valueResult.issues.length) {
    if (propertyKeyTypes2.has(typeof key)) {
      final.issues.push(...prefixIssues2(key, valueResult.issues));
    } else {
      final.issues.push({
        origin: "map",
        code: "invalid_element",
        input,
        inst,
        key,
        issues: valueResult.issues.map((iss) => finalizeIssue2(iss, ctx, config2()))
      });
    }
  }
  final.value.set(keyResult.value, valueResult.value);
}
function handleSetResult2(result, final) {
  if (result.issues.length) {
    final.issues.push(...result.issues);
  }
  final.value.add(result.value);
}
function handleOptionalResult2(result, input) {
  if (result.issues.length && input === void 0) {
    return { issues: [], value: void 0 };
  }
  return result;
}
function handleDefaultResult2(payload, def) {
  if (payload.value === void 0) {
    payload.value = def.defaultValue;
  }
  return payload;
}
function handleNonOptionalResult2(payload, inst) {
  if (!payload.issues.length && payload.value === void 0) {
    payload.issues.push({
      code: "invalid_type",
      expected: "nonoptional",
      input: payload.value,
      inst
    });
  }
  return payload;
}
function handlePipeResult2(left, next, ctx) {
  if (left.issues.length) {
    left.aborted = true;
    return left;
  }
  return next._zod.run({ value: left.value, issues: left.issues }, ctx);
}
function handleCodecAResult2(result, def, ctx) {
  if (result.issues.length) {
    result.aborted = true;
    return result;
  }
  const direction = ctx.direction || "forward";
  if (direction === "forward") {
    const transformed = def.transform(result.value, result);
    if (transformed instanceof Promise) {
      return transformed.then((value) => handleCodecTxResult2(result, value, def.out, ctx));
    }
    return handleCodecTxResult2(result, transformed, def.out, ctx);
  } else {
    const transformed = def.reverseTransform(result.value, result);
    if (transformed instanceof Promise) {
      return transformed.then((value) => handleCodecTxResult2(result, value, def.in, ctx));
    }
    return handleCodecTxResult2(result, transformed, def.in, ctx);
  }
}
function handleCodecTxResult2(left, value, nextSchema, ctx) {
  if (left.issues.length) {
    left.aborted = true;
    return left;
  }
  return nextSchema._zod.run({ value, issues: left.issues }, ctx);
}
function handleReadonlyResult2(payload) {
  payload.value = Object.freeze(payload.value);
  return payload;
}
function handleRefineResult2(result, payload, input, inst) {
  var _a37;
  if (!result) {
    const _iss = {
      code: "custom",
      input,
      inst,
      // incorporates params.error into issue reporting
      path: [...(_a37 = inst._zod.def.path) != null ? _a37 : []],
      // incorporates params.error into issue reporting
      continue: !inst._zod.def.abort
      // params: inst._zod.def.params,
    };
    if (inst._zod.def.params)
      _iss.params = inst._zod.def.params;
    payload.issues.push(issue2(_iss));
  }
}
function ar_default2() {
  return {
    localeError: error48()
  };
}
function az_default2() {
  return {
    localeError: error210()
  };
}
function getBelarusianPlural2(count, one, few, many) {
  const absCount = Math.abs(count);
  const lastDigit = absCount % 10;
  const lastTwoDigits = absCount % 100;
  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
    return many;
  }
  if (lastDigit === 1) {
    return one;
  }
  if (lastDigit >= 2 && lastDigit <= 4) {
    return few;
  }
  return many;
}
function be_default2() {
  return {
    localeError: error310()
  };
}
function bg_default2() {
  return {
    localeError: error49()
  };
}
function ca_default2() {
  return {
    localeError: error52()
  };
}
function cs_default2() {
  return {
    localeError: error62()
  };
}
function da_default2() {
  return {
    localeError: error72()
  };
}
function de_default2() {
  return {
    localeError: error82()
  };
}
function en_default3() {
  return {
    localeError: error92()
  };
}
function eo_default2() {
  return {
    localeError: error102()
  };
}
function es_default2() {
  return {
    localeError: error112()
  };
}
function fa_default2() {
  return {
    localeError: error122()
  };
}
function fi_default2() {
  return {
    localeError: error132()
  };
}
function fr_default2() {
  return {
    localeError: error142()
  };
}
function fr_CA_default2() {
  return {
    localeError: error152()
  };
}
function he_default2() {
  return {
    localeError: error162()
  };
}
function hu_default2() {
  return {
    localeError: error172()
  };
}
function getArmenianPlural2(count, one, many) {
  return Math.abs(count) === 1 ? one : many;
}
function withDefiniteArticle2(word) {
  if (!word)
    return "";
  const vowels = ["\u0561", "\u0565", "\u0568", "\u056B", "\u0578", "\u0578\u0582", "\u0585"];
  const lastChar = word[word.length - 1];
  return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
}
function hy_default2() {
  return {
    localeError: error182()
  };
}
function id_default2() {
  return {
    localeError: error192()
  };
}
function is_default2() {
  return {
    localeError: error202()
  };
}
function it_default2() {
  return {
    localeError: error212()
  };
}
function ja_default2() {
  return {
    localeError: error222()
  };
}
function ka_default2() {
  return {
    localeError: error232()
  };
}
function km_default2() {
  return {
    localeError: error242()
  };
}
function kh_default2() {
  return km_default2();
}
function ko_default2() {
  return {
    localeError: error252()
  };
}
function getUnitTypeFromNumber2(number42) {
  const abs = Math.abs(number42);
  const last = abs % 10;
  const last2 = abs % 100;
  if (last2 >= 11 && last2 <= 19 || last === 0)
    return "many";
  if (last === 1)
    return "one";
  return "few";
}
function lt_default2() {
  return {
    localeError: error262()
  };
}
function mk_default2() {
  return {
    localeError: error272()
  };
}
function ms_default2() {
  return {
    localeError: error282()
  };
}
function nl_default2() {
  return {
    localeError: error292()
  };
}
function no_default2() {
  return {
    localeError: error302()
  };
}
function ota_default2() {
  return {
    localeError: error312()
  };
}
function ps_default2() {
  return {
    localeError: error322()
  };
}
function pl_default2() {
  return {
    localeError: error332()
  };
}
function pt_default2() {
  return {
    localeError: error342()
  };
}
function getRussianPlural2(count, one, few, many) {
  const absCount = Math.abs(count);
  const lastDigit = absCount % 10;
  const lastTwoDigits = absCount % 100;
  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
    return many;
  }
  if (lastDigit === 1) {
    return one;
  }
  if (lastDigit >= 2 && lastDigit <= 4) {
    return few;
  }
  return many;
}
function ru_default2() {
  return {
    localeError: error352()
  };
}
function sl_default2() {
  return {
    localeError: error362()
  };
}
function sv_default2() {
  return {
    localeError: error372()
  };
}
function ta_default2() {
  return {
    localeError: error382()
  };
}
function th_default2() {
  return {
    localeError: error392()
  };
}
function tr_default2() {
  return {
    localeError: error402()
  };
}
function uk_default2() {
  return {
    localeError: error412()
  };
}
function ua_default2() {
  return uk_default2();
}
function ur_default2() {
  return {
    localeError: error422()
  };
}
function uz_default2() {
  return {
    localeError: error432()
  };
}
function vi_default2() {
  return {
    localeError: error442()
  };
}
function zh_CN_default2() {
  return {
    localeError: error452()
  };
}
function zh_TW_default2() {
  return {
    localeError: error462()
  };
}
function yo_default2() {
  return {
    localeError: error472()
  };
}
function registry2() {
  return new $ZodRegistry2();
}
// @__NO_SIDE_EFFECTS__
function _string2(Class22, params) {
  return new Class22({
    type: "string",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedString2(Class22, params) {
  return new Class22({
    type: "string",
    coerce: true,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _email2(Class22, params) {
  return new Class22({
    type: "string",
    format: "email",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _guid2(Class22, params) {
  return new Class22({
    type: "string",
    format: "guid",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuid2(Class22, params) {
  return new Class22({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv42(Class22, params) {
  return new Class22({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v4",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv62(Class22, params) {
  return new Class22({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v6",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv72(Class22, params) {
  return new Class22({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v7",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _url2(Class22, params) {
  return new Class22({
    type: "string",
    format: "url",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _emoji22(Class22, params) {
  return new Class22({
    type: "string",
    format: "emoji",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nanoid2(Class22, params) {
  return new Class22({
    type: "string",
    format: "nanoid",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid3(Class22, params) {
  return new Class22({
    type: "string",
    format: "cuid",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid22(Class22, params) {
  return new Class22({
    type: "string",
    format: "cuid2",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ulid2(Class22, params) {
  return new Class22({
    type: "string",
    format: "ulid",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _xid2(Class22, params) {
  return new Class22({
    type: "string",
    format: "xid",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ksuid2(Class22, params) {
  return new Class22({
    type: "string",
    format: "ksuid",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv42(Class22, params) {
  return new Class22({
    type: "string",
    format: "ipv4",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv62(Class22, params) {
  return new Class22({
    type: "string",
    format: "ipv6",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _mac2(Class22, params) {
  return new Class22({
    type: "string",
    format: "mac",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv42(Class22, params) {
  return new Class22({
    type: "string",
    format: "cidrv4",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv62(Class22, params) {
  return new Class22({
    type: "string",
    format: "cidrv6",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base642(Class22, params) {
  return new Class22({
    type: "string",
    format: "base64",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base64url2(Class22, params) {
  return new Class22({
    type: "string",
    format: "base64url",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _e1642(Class22, params) {
  return new Class22({
    type: "string",
    format: "e164",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _jwt2(Class22, params) {
  return new Class22({
    type: "string",
    format: "jwt",
    check: "string_format",
    abort: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDateTime2(Class22, params) {
  return new Class22({
    type: "string",
    format: "datetime",
    check: "string_format",
    offset: false,
    local: false,
    precision: null,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDate2(Class22, params) {
  return new Class22({
    type: "string",
    format: "date",
    check: "string_format",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoTime2(Class22, params) {
  return new Class22({
    type: "string",
    format: "time",
    check: "string_format",
    precision: null,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDuration2(Class22, params) {
  return new Class22({
    type: "string",
    format: "duration",
    check: "string_format",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _number2(Class22, params) {
  return new Class22({
    type: "number",
    checks: [],
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedNumber2(Class22, params) {
  return new Class22({
    type: "number",
    coerce: true,
    checks: [],
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int2(Class22, params) {
  return new Class22({
    type: "number",
    check: "number_format",
    abort: false,
    format: "safeint",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _float322(Class22, params) {
  return new Class22({
    type: "number",
    check: "number_format",
    abort: false,
    format: "float32",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _float642(Class22, params) {
  return new Class22({
    type: "number",
    check: "number_format",
    abort: false,
    format: "float64",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int322(Class22, params) {
  return new Class22({
    type: "number",
    check: "number_format",
    abort: false,
    format: "int32",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uint322(Class22, params) {
  return new Class22({
    type: "number",
    check: "number_format",
    abort: false,
    format: "uint32",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _boolean2(Class22, params) {
  return new Class22({
    type: "boolean",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedBoolean2(Class22, params) {
  return new Class22({
    type: "boolean",
    coerce: true,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _bigint2(Class22, params) {
  return new Class22({
    type: "bigint",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedBigint2(Class22, params) {
  return new Class22({
    type: "bigint",
    coerce: true,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int642(Class22, params) {
  return new Class22({
    type: "bigint",
    check: "bigint_format",
    abort: false,
    format: "int64",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uint642(Class22, params) {
  return new Class22({
    type: "bigint",
    check: "bigint_format",
    abort: false,
    format: "uint64",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _symbol2(Class22, params) {
  return new Class22({
    type: "symbol",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _undefined22(Class22, params) {
  return new Class22({
    type: "undefined",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _null22(Class22, params) {
  return new Class22({
    type: "null",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _any2(Class22) {
  return new Class22({
    type: "any"
  });
}
// @__NO_SIDE_EFFECTS__
function _unknown2(Class22) {
  return new Class22({
    type: "unknown"
  });
}
// @__NO_SIDE_EFFECTS__
function _never2(Class22, params) {
  return new Class22({
    type: "never",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _void3(Class22, params) {
  return new Class22({
    type: "void",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _date2(Class22, params) {
  return new Class22({
    type: "date",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedDate2(Class22, params) {
  return new Class22({
    type: "date",
    coerce: true,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nan2(Class22, params) {
  return new Class22({
    type: "nan",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _lt2(value, params) {
  return new $ZodCheckLessThan2({
    check: "less_than",
    ...normalizeParams2(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _lte2(value, params) {
  return new $ZodCheckLessThan2({
    check: "less_than",
    ...normalizeParams2(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _gt2(value, params) {
  return new $ZodCheckGreaterThan2({
    check: "greater_than",
    ...normalizeParams2(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _gte2(value, params) {
  return new $ZodCheckGreaterThan2({
    check: "greater_than",
    ...normalizeParams2(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _positive2(params) {
  return /* @__PURE__ */ _gt2(0, params);
}
// @__NO_SIDE_EFFECTS__
function _negative2(params) {
  return /* @__PURE__ */ _lt2(0, params);
}
// @__NO_SIDE_EFFECTS__
function _nonpositive2(params) {
  return /* @__PURE__ */ _lte2(0, params);
}
// @__NO_SIDE_EFFECTS__
function _nonnegative2(params) {
  return /* @__PURE__ */ _gte2(0, params);
}
// @__NO_SIDE_EFFECTS__
function _multipleOf2(value, params) {
  return new $ZodCheckMultipleOf2({
    check: "multiple_of",
    ...normalizeParams2(params),
    value
  });
}
// @__NO_SIDE_EFFECTS__
function _maxSize2(maximum, params) {
  return new $ZodCheckMaxSize2({
    check: "max_size",
    ...normalizeParams2(params),
    maximum
  });
}
// @__NO_SIDE_EFFECTS__
function _minSize2(minimum, params) {
  return new $ZodCheckMinSize2({
    check: "min_size",
    ...normalizeParams2(params),
    minimum
  });
}
// @__NO_SIDE_EFFECTS__
function _size2(size, params) {
  return new $ZodCheckSizeEquals2({
    check: "size_equals",
    ...normalizeParams2(params),
    size
  });
}
// @__NO_SIDE_EFFECTS__
function _maxLength2(maximum, params) {
  const ch = new $ZodCheckMaxLength2({
    check: "max_length",
    ...normalizeParams2(params),
    maximum
  });
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _minLength2(minimum, params) {
  return new $ZodCheckMinLength2({
    check: "min_length",
    ...normalizeParams2(params),
    minimum
  });
}
// @__NO_SIDE_EFFECTS__
function _length2(length, params) {
  return new $ZodCheckLengthEquals2({
    check: "length_equals",
    ...normalizeParams2(params),
    length
  });
}
// @__NO_SIDE_EFFECTS__
function _regex2(pattern, params) {
  return new $ZodCheckRegex2({
    check: "string_format",
    format: "regex",
    ...normalizeParams2(params),
    pattern
  });
}
// @__NO_SIDE_EFFECTS__
function _lowercase2(params) {
  return new $ZodCheckLowerCase2({
    check: "string_format",
    format: "lowercase",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uppercase2(params) {
  return new $ZodCheckUpperCase2({
    check: "string_format",
    format: "uppercase",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _includes2(includes, params) {
  return new $ZodCheckIncludes2({
    check: "string_format",
    format: "includes",
    ...normalizeParams2(params),
    includes
  });
}
// @__NO_SIDE_EFFECTS__
function _startsWith2(prefix, params) {
  return new $ZodCheckStartsWith2({
    check: "string_format",
    format: "starts_with",
    ...normalizeParams2(params),
    prefix
  });
}
// @__NO_SIDE_EFFECTS__
function _endsWith2(suffix, params) {
  return new $ZodCheckEndsWith2({
    check: "string_format",
    format: "ends_with",
    ...normalizeParams2(params),
    suffix
  });
}
// @__NO_SIDE_EFFECTS__
function _property2(property2, schema, params) {
  return new $ZodCheckProperty2({
    check: "property",
    property: property2,
    schema,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _mime2(types, params) {
  return new $ZodCheckMimeType2({
    check: "mime_type",
    mime: types,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _overwrite2(tx) {
  return new $ZodCheckOverwrite2({
    check: "overwrite",
    tx
  });
}
// @__NO_SIDE_EFFECTS__
function _normalize2(form) {
  return /* @__PURE__ */ _overwrite2((input) => input.normalize(form));
}
// @__NO_SIDE_EFFECTS__
function _trim2() {
  return /* @__PURE__ */ _overwrite2((input) => input.trim());
}
// @__NO_SIDE_EFFECTS__
function _toLowerCase2() {
  return /* @__PURE__ */ _overwrite2((input) => input.toLowerCase());
}
// @__NO_SIDE_EFFECTS__
function _toUpperCase2() {
  return /* @__PURE__ */ _overwrite2((input) => input.toUpperCase());
}
// @__NO_SIDE_EFFECTS__
function _slugify2() {
  return /* @__PURE__ */ _overwrite2((input) => slugify2(input));
}
// @__NO_SIDE_EFFECTS__
function _array2(Class22, element, params) {
  return new Class22({
    type: "array",
    element,
    // get element() {
    //   return element;
    // },
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _union2(Class22, options, params) {
  return new Class22({
    type: "union",
    options,
    ...normalizeParams2(params)
  });
}
function _xor2(Class22, options, params) {
  return new Class22({
    type: "union",
    options,
    inclusive: false,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _discriminatedUnion2(Class22, discriminator, options, params) {
  return new Class22({
    type: "union",
    options,
    discriminator,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _intersection2(Class22, left, right) {
  return new Class22({
    type: "intersection",
    left,
    right
  });
}
// @__NO_SIDE_EFFECTS__
function _tuple2(Class22, items, _paramsOrRest, _params) {
  const hasRest = _paramsOrRest instanceof $ZodType2;
  const params = hasRest ? _params : _paramsOrRest;
  const rest = hasRest ? _paramsOrRest : null;
  return new Class22({
    type: "tuple",
    items,
    rest,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _record2(Class22, keyType, valueType, params) {
  return new Class22({
    type: "record",
    keyType,
    valueType,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _map2(Class22, keyType, valueType, params) {
  return new Class22({
    type: "map",
    keyType,
    valueType,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _set2(Class22, valueType, params) {
  return new Class22({
    type: "set",
    valueType,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _enum3(Class22, values, params) {
  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
  return new Class22({
    type: "enum",
    entries,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nativeEnum2(Class22, entries, params) {
  return new Class22({
    type: "enum",
    entries,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _literal2(Class22, value, params) {
  return new Class22({
    type: "literal",
    values: Array.isArray(value) ? value : [value],
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _file2(Class22, params) {
  return new Class22({
    type: "file",
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _transform2(Class22, fn) {
  return new Class22({
    type: "transform",
    transform: fn
  });
}
// @__NO_SIDE_EFFECTS__
function _optional2(Class22, innerType) {
  return new Class22({
    type: "optional",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _nullable2(Class22, innerType) {
  return new Class22({
    type: "nullable",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _default3(Class22, innerType, defaultValue) {
  return new Class22({
    type: "default",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : shallowClone2(defaultValue);
    }
  });
}
// @__NO_SIDE_EFFECTS__
function _nonoptional2(Class22, innerType, params) {
  return new Class22({
    type: "nonoptional",
    innerType,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _success2(Class22, innerType) {
  return new Class22({
    type: "success",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _catch3(Class22, innerType, catchValue) {
  return new Class22({
    type: "catch",
    innerType,
    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
  });
}
// @__NO_SIDE_EFFECTS__
function _pipe2(Class22, in_, out) {
  return new Class22({
    type: "pipe",
    in: in_,
    out
  });
}
// @__NO_SIDE_EFFECTS__
function _readonly2(Class22, innerType) {
  return new Class22({
    type: "readonly",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _templateLiteral2(Class22, parts, params) {
  return new Class22({
    type: "template_literal",
    parts,
    ...normalizeParams2(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _lazy2(Class22, getter) {
  return new Class22({
    type: "lazy",
    getter
  });
}
// @__NO_SIDE_EFFECTS__
function _promise2(Class22, innerType) {
  return new Class22({
    type: "promise",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _custom2(Class22, fn, _params) {
  var _a37;
  const norm = normalizeParams2(_params);
  (_a37 = norm.abort) != null ? _a37 : norm.abort = true;
  const schema = new Class22({
    type: "custom",
    check: "custom",
    fn,
    ...norm
  });
  return schema;
}
// @__NO_SIDE_EFFECTS__
function _refine2(Class22, fn, _params) {
  const schema = new Class22({
    type: "custom",
    check: "custom",
    fn,
    ...normalizeParams2(_params)
  });
  return schema;
}
// @__NO_SIDE_EFFECTS__
function _superRefine2(fn) {
  const ch = /* @__PURE__ */ _check2((payload) => {
    payload.addIssue = (issue22) => {
      var _a37, _b27, _c, _d;
      if (typeof issue22 === "string") {
        payload.issues.push(issue2(issue22, payload.value, ch._zod.def));
      } else {
        const _issue = issue22;
        if (_issue.fatal)
          _issue.continue = false;
        (_a37 = _issue.code) != null ? _a37 : _issue.code = "custom";
        (_b27 = _issue.input) != null ? _b27 : _issue.input = payload.value;
        (_c = _issue.inst) != null ? _c : _issue.inst = ch;
        (_d = _issue.continue) != null ? _d : _issue.continue = !ch._zod.def.abort;
        payload.issues.push(issue2(_issue));
      }
    };
    return fn(payload.value, payload);
  });
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _check2(fn, params) {
  const ch = new $ZodCheck2({
    check: "custom",
    ...normalizeParams2(params)
  });
  ch._zod.check = fn;
  return ch;
}
// @__NO_SIDE_EFFECTS__
function describe3(description) {
  const ch = new $ZodCheck2({ check: "describe" });
  ch._zod.onattach = [
    (inst) => {
      var _a37;
      const existing = (_a37 = globalRegistry2.get(inst)) != null ? _a37 : {};
      globalRegistry2.add(inst, { ...existing, description });
    }
  ];
  ch._zod.check = () => {
  };
  return ch;
}
// @__NO_SIDE_EFFECTS__
function meta3(metadata) {
  const ch = new $ZodCheck2({ check: "meta" });
  ch._zod.onattach = [
    (inst) => {
      var _a37;
      const existing = (_a37 = globalRegistry2.get(inst)) != null ? _a37 : {};
      globalRegistry2.add(inst, { ...existing, ...metadata });
    }
  ];
  ch._zod.check = () => {
  };
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _stringbool2(Classes, _params) {
  var _a37, _b27, _c, _d, _e;
  const params = normalizeParams2(_params);
  let truthyArray = (_a37 = params.truthy) != null ? _a37 : ["true", "1", "yes", "on", "y", "enabled"];
  let falsyArray = (_b27 = params.falsy) != null ? _b27 : ["false", "0", "no", "off", "n", "disabled"];
  if (params.case !== "sensitive") {
    truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
    falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
  }
  const truthySet = new Set(truthyArray);
  const falsySet = new Set(falsyArray);
  const _Codec = (_c = Classes.Codec) != null ? _c : $ZodCodec2;
  const _Boolean = (_d = Classes.Boolean) != null ? _d : $ZodBoolean2;
  const _String = (_e = Classes.String) != null ? _e : $ZodString2;
  const stringSchema = new _String({ type: "string", error: params.error });
  const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
  const codec22 = new _Codec({
    type: "pipe",
    in: stringSchema,
    out: booleanSchema,
    transform: (input, payload) => {
      let data = input;
      if (params.case !== "sensitive")
        data = data.toLowerCase();
      if (truthySet.has(data)) {
        return true;
      } else if (falsySet.has(data)) {
        return false;
      } else {
        payload.issues.push({
          code: "invalid_value",
          expected: "stringbool",
          values: [...truthySet, ...falsySet],
          input: payload.value,
          inst: codec22,
          continue: false
        });
        return {};
      }
    },
    reverseTransform: (input, _payload) => {
      if (input === true) {
        return truthyArray[0] || "true";
      } else {
        return falsyArray[0] || "false";
      }
    },
    error: params.error
  });
  return codec22;
}
// @__NO_SIDE_EFFECTS__
function _stringFormat2(Class22, format, fnOrRegex, _params = {}) {
  const params = normalizeParams2(_params);
  const def = {
    ...normalizeParams2(_params),
    check: "string_format",
    type: "string",
    format,
    fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
    ...params
  };
  if (fnOrRegex instanceof RegExp) {
    def.pattern = fnOrRegex;
  }
  const inst = new Class22(def);
  return inst;
}
function initializeContext2(params) {
  var _a37, _b27, _c, _d, _e, _f, _g, _h, _i;
  let target = (_a37 = params == null ? void 0 : params.target) != null ? _a37 : "draft-2020-12";
  if (target === "draft-4")
    target = "draft-04";
  if (target === "draft-7")
    target = "draft-07";
  return {
    processors: (_b27 = params.processors) != null ? _b27 : {},
    metadataRegistry: (_c = params == null ? void 0 : params.metadata) != null ? _c : globalRegistry2,
    target,
    unrepresentable: (_d = params == null ? void 0 : params.unrepresentable) != null ? _d : "throw",
    override: (_e = params == null ? void 0 : params.override) != null ? _e : () => {
    },
    io: (_f = params == null ? void 0 : params.io) != null ? _f : "output",
    counter: 0,
    seen: /* @__PURE__ */ new Map(),
    cycles: (_g = params == null ? void 0 : params.cycles) != null ? _g : "ref",
    reused: (_h = params == null ? void 0 : params.reused) != null ? _h : "inline",
    external: (_i = params == null ? void 0 : params.external) != null ? _i : void 0
  };
}
function process3(schema, ctx, _params = { path: [], schemaPath: [] }) {
  var _a47, _b27, _c;
  var _a37;
  const def = schema._zod.def;
  const seen = ctx.seen.get(schema);
  if (seen) {
    seen.count++;
    const isCycle = _params.schemaPath.includes(schema);
    if (isCycle) {
      seen.cycle = _params.path;
    }
    return seen.schema;
  }
  const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
  ctx.seen.set(schema, result);
  const overrideSchema = (_b27 = (_a47 = schema._zod).toJSONSchema) == null ? void 0 : _b27.call(_a47);
  if (overrideSchema) {
    result.schema = overrideSchema;
  } else {
    const params = {
      ..._params,
      schemaPath: [..._params.schemaPath, schema],
      path: _params.path
    };
    if (schema._zod.processJSONSchema) {
      schema._zod.processJSONSchema(ctx, result.schema, params);
    } else {
      const _json = result.schema;
      const processor = ctx.processors[def.type];
      if (!processor) {
        throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
      }
      processor(schema, ctx, _json, params);
    }
    const parent = schema._zod.parent;
    if (parent) {
      if (!result.ref)
        result.ref = parent;
      process3(parent, ctx, params);
      ctx.seen.get(parent).isParent = true;
    }
  }
  const meta32 = ctx.metadataRegistry.get(schema);
  if (meta32)
    Object.assign(result.schema, meta32);
  if (ctx.io === "input" && isTransforming2(schema)) {
    delete result.schema.examples;
    delete result.schema.default;
  }
  if (ctx.io === "input" && result.schema._prefault)
    (_c = (_a37 = result.schema).default) != null ? _c : _a37.default = result.schema._prefault;
  delete result.schema._prefault;
  const _result = ctx.seen.get(schema);
  return _result.schema;
}
function extractDefs2(ctx, schema) {
  var _a37, _b27, _c, _d;
  const root2 = ctx.seen.get(schema);
  if (!root2)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const idToSchema = /* @__PURE__ */ new Map();
  for (const entry of ctx.seen.entries()) {
    const id = (_a37 = ctx.metadataRegistry.get(entry[0])) == null ? void 0 : _a37.id;
    if (id) {
      const existing = idToSchema.get(id);
      if (existing && existing !== entry[0]) {
        throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
      }
      idToSchema.set(id, entry[0]);
    }
  }
  const makeURI = (entry) => {
    var _a47, _b28, _c2, _d2, _e;
    const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
    if (ctx.external) {
      const externalId = (_a47 = ctx.external.registry.get(entry[0])) == null ? void 0 : _a47.id;
      const uriGenerator = (_b28 = ctx.external.uri) != null ? _b28 : (id2) => id2;
      if (externalId) {
        return { ref: uriGenerator(externalId) };
      }
      const id = (_d2 = (_c2 = entry[1].defId) != null ? _c2 : entry[1].schema.id) != null ? _d2 : `schema${ctx.counter++}`;
      entry[1].defId = id;
      return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
    }
    if (entry[1] === root2) {
      return { ref: "#" };
    }
    const uriPrefix = `#`;
    const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
    const defId = (_e = entry[1].schema.id) != null ? _e : `__schema${ctx.counter++}`;
    return { defId, ref: defUriPrefix + defId };
  };
  const extractToDef = (entry) => {
    if (entry[1].schema.$ref) {
      return;
    }
    const seen = entry[1];
    const { ref, defId } = makeURI(entry);
    seen.def = { ...seen.schema };
    if (defId)
      seen.defId = defId;
    const schema2 = seen.schema;
    for (const key in schema2) {
      delete schema2[key];
    }
    schema2.$ref = ref;
  };
  if (ctx.cycles === "throw") {
    for (const entry of ctx.seen.entries()) {
      const seen = entry[1];
      if (seen.cycle) {
        throw new Error(`Cycle detected: #/${(_b27 = seen.cycle) == null ? void 0 : _b27.join("/")}/<root>

Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
      }
    }
  }
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (schema === entry[0]) {
      extractToDef(entry);
      continue;
    }
    if (ctx.external) {
      const ext = (_c = ctx.external.registry.get(entry[0])) == null ? void 0 : _c.id;
      if (schema !== entry[0] && ext) {
        extractToDef(entry);
        continue;
      }
    }
    const id = (_d = ctx.metadataRegistry.get(entry[0])) == null ? void 0 : _d.id;
    if (id) {
      extractToDef(entry);
      continue;
    }
    if (seen.cycle) {
      extractToDef(entry);
      continue;
    }
    if (seen.count > 1) {
      if (ctx.reused === "ref") {
        extractToDef(entry);
        continue;
      }
    }
  }
}
function finalize2(ctx, schema) {
  var _a37, _b27, _c, _d, _e;
  const root2 = ctx.seen.get(schema);
  if (!root2)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const flattenRef = (zodSchema4) => {
    var _a47, _b28, _c2;
    const seen = ctx.seen.get(zodSchema4);
    if (seen.ref === null)
      return;
    const schema2 = (_a47 = seen.def) != null ? _a47 : seen.schema;
    const _cached = { ...schema2 };
    const ref = seen.ref;
    seen.ref = null;
    if (ref) {
      flattenRef(ref);
      const refSeen = ctx.seen.get(ref);
      const refSchema = refSeen.schema;
      if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
        schema2.allOf = (_b28 = schema2.allOf) != null ? _b28 : [];
        schema2.allOf.push(refSchema);
      } else {
        Object.assign(schema2, refSchema);
      }
      Object.assign(schema2, _cached);
      const isParentRef = zodSchema4._zod.parent === ref;
      if (isParentRef) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (!(key in _cached)) {
            delete schema2[key];
          }
        }
      }
      if (refSchema.$ref) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
            delete schema2[key];
          }
        }
      }
    }
    const parent = zodSchema4._zod.parent;
    if (parent && parent !== ref) {
      flattenRef(parent);
      const parentSeen = ctx.seen.get(parent);
      if (parentSeen == null ? void 0 : parentSeen.schema.$ref) {
        schema2.$ref = parentSeen.schema.$ref;
        if (parentSeen.def) {
          for (const key in schema2) {
            if (key === "$ref" || key === "allOf")
              continue;
            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
              delete schema2[key];
            }
          }
        }
      }
    }
    ctx.override({
      zodSchema: zodSchema4,
      jsonSchema: schema2,
      path: (_c2 = seen.path) != null ? _c2 : []
    });
  };
  for (const entry of [...ctx.seen.entries()].reverse()) {
    flattenRef(entry[0]);
  }
  const result = {};
  if (ctx.target === "draft-2020-12") {
    result.$schema = "https://json-schema.org/draft/2020-12/schema";
  } else if (ctx.target === "draft-07") {
    result.$schema = "http://json-schema.org/draft-07/schema#";
  } else if (ctx.target === "draft-04") {
    result.$schema = "http://json-schema.org/draft-04/schema#";
  } else if (ctx.target === "openapi-3.0") {
  } else {
  }
  if ((_a37 = ctx.external) == null ? void 0 : _a37.uri) {
    const id = (_b27 = ctx.external.registry.get(schema)) == null ? void 0 : _b27.id;
    if (!id)
      throw new Error("Schema is missing an `id` property");
    result.$id = ctx.external.uri(id);
  }
  Object.assign(result, (_c = root2.def) != null ? _c : root2.schema);
  const defs = (_e = (_d = ctx.external) == null ? void 0 : _d.defs) != null ? _e : {};
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (seen.def && seen.defId) {
      defs[seen.defId] = seen.def;
    }
  }
  if (ctx.external) {
  } else {
    if (Object.keys(defs).length > 0) {
      if (ctx.target === "draft-2020-12") {
        result.$defs = defs;
      } else {
        result.definitions = defs;
      }
    }
  }
  try {
    const finalized = JSON.parse(JSON.stringify(result));
    Object.defineProperty(finalized, "~standard", {
      value: {
        ...schema["~standard"],
        jsonSchema: {
          input: createStandardJSONSchemaMethod2(schema, "input", ctx.processors),
          output: createStandardJSONSchemaMethod2(schema, "output", ctx.processors)
        }
      },
      enumerable: false,
      writable: false
    });
    return finalized;
  } catch (_err) {
    throw new Error("Error converting schema to JSON.");
  }
}
function isTransforming2(_schema, _ctx) {
  const ctx = _ctx != null ? _ctx : { seen: /* @__PURE__ */ new Set() };
  if (ctx.seen.has(_schema))
    return false;
  ctx.seen.add(_schema);
  const def = _schema._zod.def;
  if (def.type === "transform")
    return true;
  if (def.type === "array")
    return isTransforming2(def.element, ctx);
  if (def.type === "set")
    return isTransforming2(def.valueType, ctx);
  if (def.type === "lazy")
    return isTransforming2(def.getter(), ctx);
  if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
    return isTransforming2(def.innerType, ctx);
  }
  if (def.type === "intersection") {
    return isTransforming2(def.left, ctx) || isTransforming2(def.right, ctx);
  }
  if (def.type === "record" || def.type === "map") {
    return isTransforming2(def.keyType, ctx) || isTransforming2(def.valueType, ctx);
  }
  if (def.type === "pipe") {
    return isTransforming2(def.in, ctx) || isTransforming2(def.out, ctx);
  }
  if (def.type === "object") {
    for (const key in def.shape) {
      if (isTransforming2(def.shape[key], ctx))
        return true;
    }
    return false;
  }
  if (def.type === "union") {
    for (const option of def.options) {
      if (isTransforming2(option, ctx))
        return true;
    }
    return false;
  }
  if (def.type === "tuple") {
    for (const item of def.items) {
      if (isTransforming2(item, ctx))
        return true;
    }
    if (def.rest && isTransforming2(def.rest, ctx))
      return true;
    return false;
  }
  return false;
}
function toJSONSchema2(input, params) {
  if ("_idmap" in input) {
    const registry22 = input;
    const ctx2 = initializeContext2({ ...params, processors: allProcessors2 });
    const defs = {};
    for (const entry of registry22._idmap.entries()) {
      const [_, schema] = entry;
      process3(schema, ctx2);
    }
    const schemas = {};
    const external = {
      registry: registry22,
      uri: params == null ? void 0 : params.uri,
      defs
    };
    ctx2.external = external;
    for (const entry of registry22._idmap.entries()) {
      const [key, schema] = entry;
      extractDefs2(ctx2, schema);
      schemas[key] = finalize2(ctx2, schema);
    }
    if (Object.keys(defs).length > 0) {
      const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
      schemas.__shared = {
        [defsSegment]: defs
      };
    }
    return { schemas };
  }
  const ctx = initializeContext2({ ...params, processors: allProcessors2 });
  process3(input, ctx);
  extractDefs2(ctx, input);
  return finalize2(ctx, input);
}
function datetime22(params) {
  return /* @__PURE__ */ _isoDateTime2(ZodISODateTime2, params);
}
function date22(params) {
  return /* @__PURE__ */ _isoDate2(ZodISODate2, params);
}
function time22(params) {
  return /* @__PURE__ */ _isoTime2(ZodISOTime2, params);
}
function duration22(params) {
  return /* @__PURE__ */ _isoDuration2(ZodISODuration2, params);
}
function string22(params) {
  return /* @__PURE__ */ _string2(ZodString3, params);
}
function email22(params) {
  return /* @__PURE__ */ _email2(ZodEmail2, params);
}
function guid22(params) {
  return /* @__PURE__ */ _guid2(ZodGUID2, params);
}
function uuid22(params) {
  return /* @__PURE__ */ _uuid2(ZodUUID2, params);
}
function uuidv42(params) {
  return /* @__PURE__ */ _uuidv42(ZodUUID2, params);
}
function uuidv62(params) {
  return /* @__PURE__ */ _uuidv62(ZodUUID2, params);
}
function uuidv72(params) {
  return /* @__PURE__ */ _uuidv72(ZodUUID2, params);
}
function url3(params) {
  return /* @__PURE__ */ _url2(ZodURL2, params);
}
function httpUrl2(params) {
  return /* @__PURE__ */ _url2(ZodURL2, {
    protocol: /^https?$/,
    hostname: regexes_exports2.domain,
    ...util_exports2.normalizeParams(params)
  });
}
function emoji22(params) {
  return /* @__PURE__ */ _emoji22(ZodEmoji2, params);
}
function nanoid22(params) {
  return /* @__PURE__ */ _nanoid2(ZodNanoID2, params);
}
function cuid32(params) {
  return /* @__PURE__ */ _cuid3(ZodCUID3, params);
}
function cuid222(params) {
  return /* @__PURE__ */ _cuid22(ZodCUID22, params);
}
function ulid22(params) {
  return /* @__PURE__ */ _ulid2(ZodULID2, params);
}
function xid22(params) {
  return /* @__PURE__ */ _xid2(ZodXID2, params);
}
function ksuid22(params) {
  return /* @__PURE__ */ _ksuid2(ZodKSUID2, params);
}
function ipv422(params) {
  return /* @__PURE__ */ _ipv42(ZodIPv42, params);
}
function mac22(params) {
  return /* @__PURE__ */ _mac2(ZodMAC2, params);
}
function ipv622(params) {
  return /* @__PURE__ */ _ipv62(ZodIPv62, params);
}
function cidrv422(params) {
  return /* @__PURE__ */ _cidrv42(ZodCIDRv42, params);
}
function cidrv622(params) {
  return /* @__PURE__ */ _cidrv62(ZodCIDRv62, params);
}
function base6422(params) {
  return /* @__PURE__ */ _base642(ZodBase642, params);
}
function base64url22(params) {
  return /* @__PURE__ */ _base64url2(ZodBase64URL2, params);
}
function e16422(params) {
  return /* @__PURE__ */ _e1642(ZodE1642, params);
}
function jwt2(params) {
  return /* @__PURE__ */ _jwt2(ZodJWT2, params);
}
function stringFormat2(format, fnOrRegex, _params = {}) {
  return /* @__PURE__ */ _stringFormat2(ZodCustomStringFormat2, format, fnOrRegex, _params);
}
function hostname22(_params) {
  return /* @__PURE__ */ _stringFormat2(ZodCustomStringFormat2, "hostname", regexes_exports2.hostname, _params);
}
function hex22(_params) {
  return /* @__PURE__ */ _stringFormat2(ZodCustomStringFormat2, "hex", regexes_exports2.hex, _params);
}
function hash2(alg, params) {
  var _a37;
  const enc = (_a37 = params == null ? void 0 : params.enc) != null ? _a37 : "hex";
  const format = `${alg}_${enc}`;
  const regex = regexes_exports2[format];
  if (!regex)
    throw new Error(`Unrecognized hash format: ${format}`);
  return /* @__PURE__ */ _stringFormat2(ZodCustomStringFormat2, format, regex, params);
}
function number22(params) {
  return /* @__PURE__ */ _number2(ZodNumber3, params);
}
function int2(params) {
  return /* @__PURE__ */ _int2(ZodNumberFormat2, params);
}
function float322(params) {
  return /* @__PURE__ */ _float322(ZodNumberFormat2, params);
}
function float642(params) {
  return /* @__PURE__ */ _float642(ZodNumberFormat2, params);
}
function int322(params) {
  return /* @__PURE__ */ _int322(ZodNumberFormat2, params);
}
function uint322(params) {
  return /* @__PURE__ */ _uint322(ZodNumberFormat2, params);
}
function boolean22(params) {
  return /* @__PURE__ */ _boolean2(ZodBoolean3, params);
}
function bigint22(params) {
  return /* @__PURE__ */ _bigint2(ZodBigInt3, params);
}
function int642(params) {
  return /* @__PURE__ */ _int642(ZodBigIntFormat2, params);
}
function uint642(params) {
  return /* @__PURE__ */ _uint642(ZodBigIntFormat2, params);
}
function symbol19(params) {
  return /* @__PURE__ */ _symbol2(ZodSymbol3, params);
}
function _undefined32(params) {
  return /* @__PURE__ */ _undefined22(ZodUndefined3, params);
}
function _null32(params) {
  return /* @__PURE__ */ _null22(ZodNull3, params);
}
function any2() {
  return /* @__PURE__ */ _any2(ZodAny3);
}
function unknown2() {
  return /* @__PURE__ */ _unknown2(ZodUnknown3);
}
function never2(params) {
  return /* @__PURE__ */ _never2(ZodNever3, params);
}
function _void22(params) {
  return /* @__PURE__ */ _void3(ZodVoid3, params);
}
function date32(params) {
  return /* @__PURE__ */ _date2(ZodDate3, params);
}
function array2(element, params) {
  return /* @__PURE__ */ _array2(ZodArray3, element, params);
}
function keyof2(schema) {
  const shape = schema._zod.def.shape;
  return _enum22(Object.keys(shape));
}
function object2(shape, params) {
  const def = {
    type: "object",
    shape: shape != null ? shape : {},
    ...util_exports2.normalizeParams(params)
  };
  return new ZodObject3(def);
}
function strictObject2(shape, params) {
  return new ZodObject3({
    type: "object",
    shape,
    catchall: never2(),
    ...util_exports2.normalizeParams(params)
  });
}
function looseObject2(shape, params) {
  return new ZodObject3({
    type: "object",
    shape,
    catchall: unknown2(),
    ...util_exports2.normalizeParams(params)
  });
}
function union2(options, params) {
  return new ZodUnion3({
    type: "union",
    options,
    ...util_exports2.normalizeParams(params)
  });
}
function xor2(options, params) {
  return new ZodXor2({
    type: "union",
    options,
    inclusive: false,
    ...util_exports2.normalizeParams(params)
  });
}
function discriminatedUnion2(discriminator, options, params) {
  return new ZodDiscriminatedUnion3({
    type: "union",
    options,
    discriminator,
    ...util_exports2.normalizeParams(params)
  });
}
function intersection2(left, right) {
  return new ZodIntersection3({
    type: "intersection",
    left,
    right
  });
}
function tuple2(items, _paramsOrRest, _params) {
  const hasRest = _paramsOrRest instanceof $ZodType2;
  const params = hasRest ? _params : _paramsOrRest;
  const rest = hasRest ? _paramsOrRest : null;
  return new ZodTuple3({
    type: "tuple",
    items,
    rest,
    ...util_exports2.normalizeParams(params)
  });
}
function record2(keyType, valueType, params) {
  return new ZodRecord3({
    type: "record",
    keyType,
    valueType,
    ...util_exports2.normalizeParams(params)
  });
}
function partialRecord2(keyType, valueType, params) {
  const k = clone2(keyType);
  k._zod.values = void 0;
  return new ZodRecord3({
    type: "record",
    keyType: k,
    valueType,
    ...util_exports2.normalizeParams(params)
  });
}
function looseRecord2(keyType, valueType, params) {
  return new ZodRecord3({
    type: "record",
    keyType,
    valueType,
    mode: "loose",
    ...util_exports2.normalizeParams(params)
  });
}
function map2(keyType, valueType, params) {
  return new ZodMap3({
    type: "map",
    keyType,
    valueType,
    ...util_exports2.normalizeParams(params)
  });
}
function set2(valueType, params) {
  return new ZodSet3({
    type: "set",
    valueType,
    ...util_exports2.normalizeParams(params)
  });
}
function _enum22(values, params) {
  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
  return new ZodEnum3({
    type: "enum",
    entries,
    ...util_exports2.normalizeParams(params)
  });
}
function nativeEnum2(entries, params) {
  return new ZodEnum3({
    type: "enum",
    entries,
    ...util_exports2.normalizeParams(params)
  });
}
function literal2(value, params) {
  return new ZodLiteral3({
    type: "literal",
    values: Array.isArray(value) ? value : [value],
    ...util_exports2.normalizeParams(params)
  });
}
function file2(params) {
  return /* @__PURE__ */ _file2(ZodFile2, params);
}
function transform3(fn) {
  return new ZodTransform2({
    type: "transform",
    transform: fn
  });
}
function optional2(innerType) {
  return new ZodOptional3({
    type: "optional",
    innerType
  });
}
function exactOptional2(innerType) {
  return new ZodExactOptional2({
    type: "optional",
    innerType
  });
}
function nullable2(innerType) {
  return new ZodNullable3({
    type: "nullable",
    innerType
  });
}
function nullish22(innerType) {
  return optional2(nullable2(innerType));
}
function _default22(innerType, defaultValue) {
  return new ZodDefault3({
    type: "default",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports2.shallowClone(defaultValue);
    }
  });
}
function prefault2(innerType, defaultValue) {
  return new ZodPrefault2({
    type: "prefault",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports2.shallowClone(defaultValue);
    }
  });
}
function nonoptional2(innerType, params) {
  return new ZodNonOptional2({
    type: "nonoptional",
    innerType,
    ...util_exports2.normalizeParams(params)
  });
}
function success2(innerType) {
  return new ZodSuccess2({
    type: "success",
    innerType
  });
}
function _catch22(innerType, catchValue) {
  return new ZodCatch3({
    type: "catch",
    innerType,
    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
  });
}
function nan2(params) {
  return /* @__PURE__ */ _nan2(ZodNaN3, params);
}
function pipe2(in_, out) {
  return new ZodPipe2({
    type: "pipe",
    in: in_,
    out
    // ...util.normalizeParams(params),
  });
}
function codec2(in_, out, params) {
  return new ZodCodec2({
    type: "pipe",
    in: in_,
    out,
    transform: params.decode,
    reverseTransform: params.encode
  });
}
function readonly2(innerType) {
  return new ZodReadonly3({
    type: "readonly",
    innerType
  });
}
function templateLiteral2(parts, params) {
  return new ZodTemplateLiteral2({
    type: "template_literal",
    parts,
    ...util_exports2.normalizeParams(params)
  });
}
function lazy2(getter) {
  return new ZodLazy3({
    type: "lazy",
    getter
  });
}
function promise2(innerType) {
  return new ZodPromise3({
    type: "promise",
    innerType
  });
}
function _function2(params) {
  var _a37, _b27;
  return new ZodFunction3({
    type: "function",
    input: Array.isArray(params == null ? void 0 : params.input) ? tuple2(params == null ? void 0 : params.input) : (_a37 = params == null ? void 0 : params.input) != null ? _a37 : array2(unknown2()),
    output: (_b27 = params == null ? void 0 : params.output) != null ? _b27 : unknown2()
  });
}
function check2(fn) {
  const ch = new $ZodCheck2({
    check: "custom"
    // ...util.normalizeParams(params),
  });
  ch._zod.check = fn;
  return ch;
}
function custom2(fn, _params) {
  return /* @__PURE__ */ _custom2(ZodCustom2, fn != null ? fn : () => true, _params);
}
function refine2(fn, _params = {}) {
  return /* @__PURE__ */ _refine2(ZodCustom2, fn, _params);
}
function superRefine2(fn) {
  return /* @__PURE__ */ _superRefine2(fn);
}
function _instanceof2(cls, params = {}) {
  const inst = new ZodCustom2({
    type: "custom",
    check: "custom",
    fn: (data) => data instanceof cls,
    abort: true,
    ...util_exports2.normalizeParams(params)
  });
  inst._zod.bag.Class = cls;
  inst._zod.check = (payload) => {
    var _a37;
    if (!(payload.value instanceof cls)) {
      payload.issues.push({
        code: "invalid_type",
        expected: cls.name,
        input: payload.value,
        inst,
        path: [...(_a37 = inst._zod.def.path) != null ? _a37 : []]
      });
    }
  };
  return inst;
}
function json2(params) {
  const jsonSchema4 = lazy2(() => {
    return union2([string22(params), number22(), boolean22(), _null32(), array2(jsonSchema4), record2(string22(), jsonSchema4)]);
  });
  return jsonSchema4;
}
function preprocess2(fn, schema) {
  return pipe2(transform3(fn), schema);
}
function setErrorMap2(map22) {
  config2({
    customError: map22
  });
}
function getErrorMap3() {
  return config2().customError;
}
function detectVersion2(schema, defaultTarget) {
  const $schema = schema.$schema;
  if ($schema === "https://json-schema.org/draft/2020-12/schema") {
    return "draft-2020-12";
  }
  if ($schema === "http://json-schema.org/draft-07/schema#") {
    return "draft-7";
  }
  if ($schema === "http://json-schema.org/draft-04/schema#") {
    return "draft-4";
  }
  return defaultTarget != null ? defaultTarget : "draft-2020-12";
}
function resolveRef2(ref, ctx) {
  if (!ref.startsWith("#")) {
    throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
  }
  const path33 = ref.slice(1).split("/").filter(Boolean);
  if (path33.length === 0) {
    return ctx.rootSchema;
  }
  const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
  if (path33[0] === defsKey) {
    const key = path33[1];
    if (!key || !ctx.defs[key]) {
      throw new Error(`Reference not found: ${ref}`);
    }
    return ctx.defs[key];
  }
  throw new Error(`Reference not found: ${ref}`);
}
function convertBaseSchema2(schema, ctx) {
  if (schema.not !== void 0) {
    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
      return z2.never();
    }
    throw new Error("not is not supported in Zod (except { not: {} } for never)");
  }
  if (schema.unevaluatedItems !== void 0) {
    throw new Error("unevaluatedItems is not supported");
  }
  if (schema.unevaluatedProperties !== void 0) {
    throw new Error("unevaluatedProperties is not supported");
  }
  if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
    throw new Error("Conditional schemas (if/then/else) are not supported");
  }
  if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
    throw new Error("dependentSchemas and dependentRequired are not supported");
  }
  if (schema.$ref) {
    const refPath = schema.$ref;
    if (ctx.refs.has(refPath)) {
      return ctx.refs.get(refPath);
    }
    if (ctx.processing.has(refPath)) {
      return z2.lazy(() => {
        if (!ctx.refs.has(refPath)) {
          throw new Error(`Circular reference not resolved: ${refPath}`);
        }
        return ctx.refs.get(refPath);
      });
    }
    ctx.processing.add(refPath);
    const resolved = resolveRef2(refPath, ctx);
    const zodSchema22 = convertSchema2(resolved, ctx);
    ctx.refs.set(refPath, zodSchema22);
    ctx.processing.delete(refPath);
    return zodSchema22;
  }
  if (schema.enum !== void 0) {
    const enumValues = schema.enum;
    if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
      return z2.null();
    }
    if (enumValues.length === 0) {
      return z2.never();
    }
    if (enumValues.length === 1) {
      return z2.literal(enumValues[0]);
    }
    if (enumValues.every((v) => typeof v === "string")) {
      return z2.enum(enumValues);
    }
    const literalSchemas = enumValues.map((v) => z2.literal(v));
    if (literalSchemas.length < 2) {
      return literalSchemas[0];
    }
    return z2.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
  }
  if (schema.const !== void 0) {
    return z2.literal(schema.const);
  }
  const type = schema.type;
  if (Array.isArray(type)) {
    const typeSchemas = type.map((t) => {
      const typeSchema = { ...schema, type: t };
      return convertBaseSchema2(typeSchema, ctx);
    });
    if (typeSchemas.length === 0) {
      return z2.never();
    }
    if (typeSchemas.length === 1) {
      return typeSchemas[0];
    }
    return z2.union(typeSchemas);
  }
  if (!type) {
    return z2.any();
  }
  let zodSchema4;
  switch (type) {
    case "string": {
      let stringSchema = z2.string();
      if (schema.format) {
        const format = schema.format;
        if (format === "email") {
          stringSchema = stringSchema.check(z2.email());
        } else if (format === "uri" || format === "uri-reference") {
          stringSchema = stringSchema.check(z2.url());
        } else if (format === "uuid" || format === "guid") {
          stringSchema = stringSchema.check(z2.uuid());
        } else if (format === "date-time") {
          stringSchema = stringSchema.check(z2.iso.datetime());
        } else if (format === "date") {
          stringSchema = stringSchema.check(z2.iso.date());
        } else if (format === "time") {
          stringSchema = stringSchema.check(z2.iso.time());
        } else if (format === "duration") {
          stringSchema = stringSchema.check(z2.iso.duration());
        } else if (format === "ipv4") {
          stringSchema = stringSchema.check(z2.ipv4());
        } else if (format === "ipv6") {
          stringSchema = stringSchema.check(z2.ipv6());
        } else if (format === "mac") {
          stringSchema = stringSchema.check(z2.mac());
        } else if (format === "cidr") {
          stringSchema = stringSchema.check(z2.cidrv4());
        } else if (format === "cidr-v6") {
          stringSchema = stringSchema.check(z2.cidrv6());
        } else if (format === "base64") {
          stringSchema = stringSchema.check(z2.base64());
        } else if (format === "base64url") {
          stringSchema = stringSchema.check(z2.base64url());
        } else if (format === "e164") {
          stringSchema = stringSchema.check(z2.e164());
        } else if (format === "jwt") {
          stringSchema = stringSchema.check(z2.jwt());
        } else if (format === "emoji") {
          stringSchema = stringSchema.check(z2.emoji());
        } else if (format === "nanoid") {
          stringSchema = stringSchema.check(z2.nanoid());
        } else if (format === "cuid") {
          stringSchema = stringSchema.check(z2.cuid());
        } else if (format === "cuid2") {
          stringSchema = stringSchema.check(z2.cuid2());
        } else if (format === "ulid") {
          stringSchema = stringSchema.check(z2.ulid());
        } else if (format === "xid") {
          stringSchema = stringSchema.check(z2.xid());
        } else if (format === "ksuid") {
          stringSchema = stringSchema.check(z2.ksuid());
        }
      }
      if (typeof schema.minLength === "number") {
        stringSchema = stringSchema.min(schema.minLength);
      }
      if (typeof schema.maxLength === "number") {
        stringSchema = stringSchema.max(schema.maxLength);
      }
      if (schema.pattern) {
        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
      }
      zodSchema4 = stringSchema;
      break;
    }
    case "number":
    case "integer": {
      let numberSchema = type === "integer" ? z2.number().int() : z2.number();
      if (typeof schema.minimum === "number") {
        numberSchema = numberSchema.min(schema.minimum);
      }
      if (typeof schema.maximum === "number") {
        numberSchema = numberSchema.max(schema.maximum);
      }
      if (typeof schema.exclusiveMinimum === "number") {
        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
        numberSchema = numberSchema.gt(schema.minimum);
      }
      if (typeof schema.exclusiveMaximum === "number") {
        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
        numberSchema = numberSchema.lt(schema.maximum);
      }
      if (typeof schema.multipleOf === "number") {
        numberSchema = numberSchema.multipleOf(schema.multipleOf);
      }
      zodSchema4 = numberSchema;
      break;
    }
    case "boolean": {
      zodSchema4 = z2.boolean();
      break;
    }
    case "null": {
      zodSchema4 = z2.null();
      break;
    }
    case "object": {
      const shape = {};
      const properties = schema.properties || {};
      const requiredSet = new Set(schema.required || []);
      for (const [key, propSchema] of Object.entries(properties)) {
        const propZodSchema = convertSchema2(propSchema, ctx);
        shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
      }
      if (schema.propertyNames) {
        const keySchema3 = convertSchema2(schema.propertyNames, ctx);
        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema2(schema.additionalProperties, ctx) : z2.any();
        if (Object.keys(shape).length === 0) {
          zodSchema4 = z2.record(keySchema3, valueSchema);
          break;
        }
        const objectSchema2 = z2.object(shape).passthrough();
        const recordSchema = z2.looseRecord(keySchema3, valueSchema);
        zodSchema4 = z2.intersection(objectSchema2, recordSchema);
        break;
      }
      if (schema.patternProperties) {
        const patternProps = schema.patternProperties;
        const patternKeys = Object.keys(patternProps);
        const looseRecords = [];
        for (const pattern of patternKeys) {
          const patternValue = convertSchema2(patternProps[pattern], ctx);
          const keySchema3 = z2.string().regex(new RegExp(pattern));
          looseRecords.push(z2.looseRecord(keySchema3, patternValue));
        }
        const schemasToIntersect = [];
        if (Object.keys(shape).length > 0) {
          schemasToIntersect.push(z2.object(shape).passthrough());
        }
        schemasToIntersect.push(...looseRecords);
        if (schemasToIntersect.length === 0) {
          zodSchema4 = z2.object({}).passthrough();
        } else if (schemasToIntersect.length === 1) {
          zodSchema4 = schemasToIntersect[0];
        } else {
          let result = z2.intersection(schemasToIntersect[0], schemasToIntersect[1]);
          for (let i = 2; i < schemasToIntersect.length; i++) {
            result = z2.intersection(result, schemasToIntersect[i]);
          }
          zodSchema4 = result;
        }
        break;
      }
      const objectSchema = z2.object(shape);
      if (schema.additionalProperties === false) {
        zodSchema4 = objectSchema.strict();
      } else if (typeof schema.additionalProperties === "object") {
        zodSchema4 = objectSchema.catchall(convertSchema2(schema.additionalProperties, ctx));
      } else {
        zodSchema4 = objectSchema.passthrough();
      }
      break;
    }
    case "array": {
      const prefixItems = schema.prefixItems;
      const items = schema.items;
      if (prefixItems && Array.isArray(prefixItems)) {
        const tupleItems = prefixItems.map((item) => convertSchema2(item, ctx));
        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema2(items, ctx) : void 0;
        if (rest) {
          zodSchema4 = z2.tuple(tupleItems).rest(rest);
        } else {
          zodSchema4 = z2.tuple(tupleItems);
        }
        if (typeof schema.minItems === "number") {
          zodSchema4 = zodSchema4.check(z2.minLength(schema.minItems));
        }
        if (typeof schema.maxItems === "number") {
          zodSchema4 = zodSchema4.check(z2.maxLength(schema.maxItems));
        }
      } else if (Array.isArray(items)) {
        const tupleItems = items.map((item) => convertSchema2(item, ctx));
        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema2(schema.additionalItems, ctx) : void 0;
        if (rest) {
          zodSchema4 = z2.tuple(tupleItems).rest(rest);
        } else {
          zodSchema4 = z2.tuple(tupleItems);
        }
        if (typeof schema.minItems === "number") {
          zodSchema4 = zodSchema4.check(z2.minLength(schema.minItems));
        }
        if (typeof schema.maxItems === "number") {
          zodSchema4 = zodSchema4.check(z2.maxLength(schema.maxItems));
        }
      } else if (items !== void 0) {
        const element = convertSchema2(items, ctx);
        let arraySchema = z2.array(element);
        if (typeof schema.minItems === "number") {
          arraySchema = arraySchema.min(schema.minItems);
        }
        if (typeof schema.maxItems === "number") {
          arraySchema = arraySchema.max(schema.maxItems);
        }
        zodSchema4 = arraySchema;
      } else {
        zodSchema4 = z2.array(z2.any());
      }
      break;
    }
    default:
      throw new Error(`Unsupported type: ${type}`);
  }
  if (schema.description) {
    zodSchema4 = zodSchema4.describe(schema.description);
  }
  if (schema.default !== void 0) {
    zodSchema4 = zodSchema4.default(schema.default);
  }
  return zodSchema4;
}
function convertSchema2(schema, ctx) {
  if (typeof schema === "boolean") {
    return schema ? z2.any() : z2.never();
  }
  let baseSchema = convertBaseSchema2(schema, ctx);
  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
  if (schema.anyOf && Array.isArray(schema.anyOf)) {
    const options = schema.anyOf.map((s) => convertSchema2(s, ctx));
    const anyOfUnion = z2.union(options);
    baseSchema = hasExplicitType ? z2.intersection(baseSchema, anyOfUnion) : anyOfUnion;
  }
  if (schema.oneOf && Array.isArray(schema.oneOf)) {
    const options = schema.oneOf.map((s) => convertSchema2(s, ctx));
    const oneOfUnion = z2.xor(options);
    baseSchema = hasExplicitType ? z2.intersection(baseSchema, oneOfUnion) : oneOfUnion;
  }
  if (schema.allOf && Array.isArray(schema.allOf)) {
    if (schema.allOf.length === 0) {
      baseSchema = hasExplicitType ? baseSchema : z2.any();
    } else {
      let result = hasExplicitType ? baseSchema : convertSchema2(schema.allOf[0], ctx);
      const startIdx = hasExplicitType ? 0 : 1;
      for (let i = startIdx; i < schema.allOf.length; i++) {
        result = z2.intersection(result, convertSchema2(schema.allOf[i], ctx));
      }
      baseSchema = result;
    }
  }
  if (schema.nullable === true && ctx.version === "openapi-3.0") {
    baseSchema = z2.nullable(baseSchema);
  }
  if (schema.readOnly === true) {
    baseSchema = z2.readonly(baseSchema);
  }
  const extraMeta = {};
  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
  for (const key of coreMetadataKeys) {
    if (key in schema) {
      extraMeta[key] = schema[key];
    }
  }
  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
  for (const key of contentMetadataKeys) {
    if (key in schema) {
      extraMeta[key] = schema[key];
    }
  }
  for (const key of Object.keys(schema)) {
    if (!RECOGNIZED_KEYS2.has(key)) {
      extraMeta[key] = schema[key];
    }
  }
  if (Object.keys(extraMeta).length > 0) {
    ctx.registry.add(baseSchema, extraMeta);
  }
  return baseSchema;
}
function fromJSONSchema2(schema, params) {
  var _a37;
  if (typeof schema === "boolean") {
    return schema ? z2.any() : z2.never();
  }
  const version22 = detectVersion2(schema, params == null ? void 0 : params.defaultTarget);
  const defs = schema.$defs || schema.definitions || {};
  const ctx = {
    version: version22,
    defs,
    refs: /* @__PURE__ */ new Map(),
    processing: /* @__PURE__ */ new Set(),
    rootSchema: schema,
    registry: (_a37 = params == null ? void 0 : params.registry) != null ? _a37 : globalRegistry2
  };
  return convertSchema2(schema, ctx);
}
function string32(params) {
  return /* @__PURE__ */ _coercedString2(ZodString3, params);
}
function number32(params) {
  return /* @__PURE__ */ _coercedNumber2(ZodNumber3, params);
}
function boolean32(params) {
  return /* @__PURE__ */ _coercedBoolean2(ZodBoolean3, params);
}
function bigint32(params) {
  return /* @__PURE__ */ _coercedBigint2(ZodBigInt3, params);
}
function date42(params) {
  return /* @__PURE__ */ _coercedDate2(ZodDate3, params);
}
function convertToZhipuChatMessages(prompt) {
  const messages = [];
  for (let i = 0; i < prompt.length; i++) {
    const { role, content } = prompt[i];
    const isLastMessage = i === prompt.length - 1;
    switch (role) {
      case "system": {
        messages.push({ role: "system", content });
        break;
      }
      case "user": {
        if (content.length === 1 && content[0].type === "text") {
          messages.push({ role: "user", content: content[0].text });
          break;
        }
        if (content.every((part) => part.type === "text")) {
          messages.push({
            role: "user",
            content: content.map((part) => part.text).join("")
          });
          break;
        }
        messages.push({
          role: "user",
          content: content.map((part) => {
            var _a37;
            switch (part.type) {
              case "text": {
                return { type: "text", text: part.text };
              }
              case "file": {
                if (part.mediaType.startsWith("image/")) {
                  return {
                    type: "image_url",
                    image_url: {
                      url: part.data instanceof URL ? part.data.toString() : typeof part.data === "string" ? part.data : `data:${(_a37 = part.mediaType) != null ? _a37 : "image/jpeg"};base64,${convertUint8ArrayToBase642(part.data)}`
                    }
                  };
                }
                if (part.mediaType.startsWith("video/") && part.data instanceof URL) {
                  return {
                    type: "video_url",
                    video_url: {
                      url: part.data.toString()
                    }
                  };
                }
                throw new UnsupportedFunctionalityError2({
                  functionality: "File content parts in user messages"
                });
              }
            }
          })
        });
        break;
      }
      case "assistant": {
        let text2 = "";
        const toolCalls = [];
        for (const part of content) {
          switch (part.type) {
            case "text": {
              text2 += part.text;
              break;
            }
            case "reasoning": {
              break;
            }
            case "tool-call": {
              toolCalls.push({
                id: part.toolCallId,
                type: "function",
                function: {
                  name: part.toolName,
                  arguments: JSON.stringify(part.input)
                }
              });
              break;
            }
            default: {
              const _exhaustiveCheck = part;
              throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
            }
          }
        }
        messages.push({
          role: "assistant",
          content: text2,
          prefix: isLastMessage ? true : void 0,
          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
        });
        break;
      }
      case "tool": {
        for (const toolResponse of content) {
          const output = toolResponse.output;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "content":
            case "json":
            case "error-json":
              contentValue = JSON.stringify(output.value);
              break;
          }
          messages.push({
            role: "tool",
            content: contentValue,
            tool_call_id: toolResponse.toolCallId
          });
        }
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return messages;
}
function mapZhipuFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "tool_calls":
      return "tool-calls";
    case "sensitive":
      return "content-filter";
    case "network_error":
      return "error";
    default:
      return "unknown";
  }
}
function getResponseMetadata4({
  id,
  model,
  created
}) {
  return {
    id: id != null ? id : void 0,
    modelId: model != null ? model : void 0,
    timestamp: created != null ? new Date(created * 1e3) : void 0
  };
}
function createZhipu(options = {}) {
  var _a37;
  const baseURL = (_a37 = withoutTrailingSlash2(options.baseURL)) != null ? _a37 : "https://open.bigmodel.cn/api/paas/v4";
  const getHeaders = () => ({
    Authorization: `Bearer ${loadApiKey2({
      apiKey: options.apiKey,
      environmentVariableName: "ZHIPU_API_KEY",
      description: "ZHIPU API key"
    })}`,
    ...options.headers
  });
  const createChatModel = (modelId, settings = {}) => new ZhipuChatLanguageModel(modelId, settings, {
    provider: "zhipu.chat",
    baseURL,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createEmbeddingModel = (modelId, settings = {}) => new ZhipuEmbeddingModel(modelId, settings, {
    provider: "zhipu.embedding",
    baseURL,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createImageModel = (modelId) => new ZhipuImageModel(modelId, {
    provider: "zhipu.image",
    url: ({ path: path33 }) => `${baseURL}${path33}`,
    headers: getHeaders,
    fetch: options.fetch,
    _internal: {
      currentDate: () => /* @__PURE__ */ new Date()
    }
  });
  const provider = function(modelId, settings) {
    if (new.target) {
      throw new Error(
        "The Zhipu model function cannot be called with the new keyword."
      );
    }
    return createChatModel(modelId, settings);
  };
  provider.languageModel = createChatModel;
  provider.chat = createChatModel;
  provider.textEmbeddingModel = createEmbeddingModel;
  provider.image = createImageModel;
  provider.imageModel = createImageModel;
  return provider;
}
var __defProp2, __export2, external_exports3, core_exports22, NEVER2, $brand2, $ZodAsyncError2, $ZodEncodeError2, globalConfig2, util_exports2, EVALUATING2, captureStackTrace2, allowsEval2, getParsedType3, propertyKeyTypes2, primitiveTypes2, NUMBER_FORMAT_RANGES2, BIGINT_FORMAT_RANGES2, Class2, initializer3, $ZodError2, $ZodRealError2, _parse4, parse3, _parseAsync2, parseAsync3, _safeParse2, safeParse3, _safeParseAsync2, safeParseAsync3, _encode2, encode5, _decode2, decode3, _encodeAsync2, encodeAsync3, _decodeAsync2, decodeAsync3, _safeEncode2, safeEncode3, _safeDecode2, safeDecode3, _safeEncodeAsync2, safeEncodeAsync3, _safeDecodeAsync2, safeDecodeAsync3, regexes_exports2, cuid4, cuid23, ulid3, xid3, ksuid3, nanoid3, duration3, extendedDuration2, guid3, uuid3, uuid42, uuid62, uuid72, email3, html5Email2, rfc5322Email2, unicodeEmail2, idnEmail2, browserEmail2, _emoji3, ipv43, ipv63, mac3, cidrv43, cidrv63, base643, base64url3, hostname3, domain2, e1643, dateSource2, date5, string4, bigint4, integer2, number4, boolean4, _null4, _undefined4, lowercase2, uppercase2, hex3, md5_hex2, md5_base642, md5_base64url2, sha1_hex2, sha1_base642, sha1_base64url2, sha256_hex2, sha256_base642, sha256_base64url2, sha384_hex2, sha384_base642, sha384_base64url2, sha512_hex2, sha512_base642, sha512_base64url2, $ZodCheck2, numericOriginMap2, $ZodCheckLessThan2, $ZodCheckGreaterThan2, $ZodCheckMultipleOf2, $ZodCheckNumberFormat2, $ZodCheckBigIntFormat2, $ZodCheckMaxSize2, $ZodCheckMinSize2, $ZodCheckSizeEquals2, $ZodCheckMaxLength2, $ZodCheckMinLength2, $ZodCheckLengthEquals2, $ZodCheckStringFormat2, $ZodCheckRegex2, $ZodCheckLowerCase2, $ZodCheckUpperCase2, $ZodCheckIncludes2, $ZodCheckStartsWith2, $ZodCheckEndsWith2, $ZodCheckProperty2, $ZodCheckMimeType2, $ZodCheckOverwrite2, Doc2, version2, $ZodType2, $ZodString2, $ZodStringFormat2, $ZodGUID2, $ZodUUID2, $ZodEmail2, $ZodURL2, $ZodEmoji2, $ZodNanoID2, $ZodCUID3, $ZodCUID22, $ZodULID2, $ZodXID2, $ZodKSUID2, $ZodISODateTime2, $ZodISODate2, $ZodISOTime2, $ZodISODuration2, $ZodIPv42, $ZodIPv62, $ZodMAC2, $ZodCIDRv42, $ZodCIDRv62, $ZodBase642, $ZodBase64URL2, $ZodE1642, $ZodJWT2, $ZodCustomStringFormat2, $ZodNumber2, $ZodNumberFormat2, $ZodBoolean2, $ZodBigInt2, $ZodBigIntFormat2, $ZodSymbol2, $ZodUndefined2, $ZodNull2, $ZodAny2, $ZodUnknown2, $ZodNever2, $ZodVoid2, $ZodDate2, $ZodArray2, $ZodObject2, $ZodObjectJIT2, $ZodUnion2, $ZodXor2, $ZodDiscriminatedUnion2, $ZodIntersection2, $ZodTuple2, $ZodRecord2, $ZodMap2, $ZodSet2, $ZodEnum2, $ZodLiteral2, $ZodFile2, $ZodTransform2, $ZodOptional2, $ZodExactOptional2, $ZodNullable2, $ZodDefault2, $ZodPrefault2, $ZodNonOptional2, $ZodSuccess2, $ZodCatch2, $ZodNaN2, $ZodPipe2, $ZodCodec2, $ZodReadonly2, $ZodTemplateLiteral2, $ZodFunction2, $ZodPromise2, $ZodLazy2, $ZodCustom2, locales_exports2, error48, error210, error310, error49, error52, error62, error72, error82, error92, error102, error112, error122, error132, error142, error152, error162, error172, error182, error192, error202, error212, error222, error232, error242, error252, capitalizeFirstCharacter2, error262, error272, error282, error292, error302, error312, error322, error332, error342, error352, error362, error372, error382, error392, error402, error412, error422, error432, error442, error452, error462, error472, _a19, $output2, $input2, $ZodRegistry2, _a23, globalRegistry2, TimePrecision2, createToJSONSchemaMethod2, createStandardJSONSchemaMethod2, formatMap2, stringProcessor2, numberProcessor2, booleanProcessor2, bigintProcessor2, symbolProcessor2, nullProcessor2, undefinedProcessor2, voidProcessor2, neverProcessor2, anyProcessor2, unknownProcessor2, dateProcessor2, enumProcessor2, literalProcessor2, nanProcessor2, templateLiteralProcessor2, fileProcessor2, successProcessor2, customProcessor2, functionProcessor2, transformProcessor2, mapProcessor2, setProcessor2, arrayProcessor2, objectProcessor2, unionProcessor2, intersectionProcessor2, tupleProcessor2, recordProcessor2, nullableProcessor2, nonoptionalProcessor2, defaultProcessor2, prefaultProcessor2, catchProcessor2, pipeProcessor2, readonlyProcessor2, promiseProcessor2, optionalProcessor2, lazyProcessor2, allProcessors2, JSONSchemaGenerator2, json_schema_exports2, schemas_exports22, checks_exports22, iso_exports2, ZodISODateTime2, ZodISODate2, ZodISOTime2, ZodISODuration2, initializer22, ZodError3, ZodRealError2, parse22, parseAsync22, safeParse22, safeParseAsync22, encode22, decode22, encodeAsync22, decodeAsync22, safeEncode22, safeDecode22, safeEncodeAsync22, safeDecodeAsync22, ZodType3, _ZodString2, ZodString3, ZodStringFormat2, ZodEmail2, ZodGUID2, ZodUUID2, ZodURL2, ZodEmoji2, ZodNanoID2, ZodCUID3, ZodCUID22, ZodULID2, ZodXID2, ZodKSUID2, ZodIPv42, ZodMAC2, ZodIPv62, ZodCIDRv42, ZodCIDRv62, ZodBase642, ZodBase64URL2, ZodE1642, ZodJWT2, ZodCustomStringFormat2, ZodNumber3, ZodNumberFormat2, ZodBoolean3, ZodBigInt3, ZodBigIntFormat2, ZodSymbol3, ZodUndefined3, ZodNull3, ZodAny3, ZodUnknown3, ZodNever3, ZodVoid3, ZodDate3, ZodArray3, ZodObject3, ZodUnion3, ZodXor2, ZodDiscriminatedUnion3, ZodIntersection3, ZodTuple3, ZodRecord3, ZodMap3, ZodSet3, ZodEnum3, ZodLiteral3, ZodFile2, ZodTransform2, ZodOptional3, ZodExactOptional2, ZodNullable3, ZodDefault3, ZodPrefault2, ZodNonOptional2, ZodSuccess2, ZodCatch3, ZodNaN3, ZodPipe2, ZodCodec2, ZodReadonly3, ZodTemplateLiteral2, ZodLazy3, ZodPromise3, ZodFunction3, ZodCustom2, describe22, meta22, stringbool2, ZodIssueCode3, ZodFirstPartyTypeKind3, z2, RECOGNIZED_KEYS2, coerce_exports2, zhipuErrorDataSchema, zhipuFailedResponseHandler, defaultZhipuErrorStructure, ZhipuChatLanguageModel, zhipuChatResponseSchema, zhipuChatChunkSchema, ZhipuEmbeddingModel, ZhipuTextEmbeddingResponseSchema, sizeSchema, ZhipuImageModel, zhipuImageResponseSchema, zhipu, zai;
var init_dist11 = __esm({
  "node_modules/zhipu-ai-provider/dist/index.mjs"() {
    "use strict";
    init_dist10();
    init_dist8();
    init_dist10();
    init_dist8();
    init_dist10();
    init_dist10();
    init_dist8();
    init_dist10();
    init_dist10();
    __defProp2 = Object.defineProperty;
    __export2 = (target, all3) => {
      for (var name28 in all3)
        __defProp2(target, name28, { get: all3[name28], enumerable: true });
    };
    external_exports3 = {};
    __export2(external_exports3, {
      $brand: () => $brand2,
      $input: () => $input2,
      $output: () => $output2,
      NEVER: () => NEVER2,
      TimePrecision: () => TimePrecision2,
      ZodAny: () => ZodAny3,
      ZodArray: () => ZodArray3,
      ZodBase64: () => ZodBase642,
      ZodBase64URL: () => ZodBase64URL2,
      ZodBigInt: () => ZodBigInt3,
      ZodBigIntFormat: () => ZodBigIntFormat2,
      ZodBoolean: () => ZodBoolean3,
      ZodCIDRv4: () => ZodCIDRv42,
      ZodCIDRv6: () => ZodCIDRv62,
      ZodCUID: () => ZodCUID3,
      ZodCUID2: () => ZodCUID22,
      ZodCatch: () => ZodCatch3,
      ZodCodec: () => ZodCodec2,
      ZodCustom: () => ZodCustom2,
      ZodCustomStringFormat: () => ZodCustomStringFormat2,
      ZodDate: () => ZodDate3,
      ZodDefault: () => ZodDefault3,
      ZodDiscriminatedUnion: () => ZodDiscriminatedUnion3,
      ZodE164: () => ZodE1642,
      ZodEmail: () => ZodEmail2,
      ZodEmoji: () => ZodEmoji2,
      ZodEnum: () => ZodEnum3,
      ZodError: () => ZodError3,
      ZodExactOptional: () => ZodExactOptional2,
      ZodFile: () => ZodFile2,
      ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind3,
      ZodFunction: () => ZodFunction3,
      ZodGUID: () => ZodGUID2,
      ZodIPv4: () => ZodIPv42,
      ZodIPv6: () => ZodIPv62,
      ZodISODate: () => ZodISODate2,
      ZodISODateTime: () => ZodISODateTime2,
      ZodISODuration: () => ZodISODuration2,
      ZodISOTime: () => ZodISOTime2,
      ZodIntersection: () => ZodIntersection3,
      ZodIssueCode: () => ZodIssueCode3,
      ZodJWT: () => ZodJWT2,
      ZodKSUID: () => ZodKSUID2,
      ZodLazy: () => ZodLazy3,
      ZodLiteral: () => ZodLiteral3,
      ZodMAC: () => ZodMAC2,
      ZodMap: () => ZodMap3,
      ZodNaN: () => ZodNaN3,
      ZodNanoID: () => ZodNanoID2,
      ZodNever: () => ZodNever3,
      ZodNonOptional: () => ZodNonOptional2,
      ZodNull: () => ZodNull3,
      ZodNullable: () => ZodNullable3,
      ZodNumber: () => ZodNumber3,
      ZodNumberFormat: () => ZodNumberFormat2,
      ZodObject: () => ZodObject3,
      ZodOptional: () => ZodOptional3,
      ZodPipe: () => ZodPipe2,
      ZodPrefault: () => ZodPrefault2,
      ZodPromise: () => ZodPromise3,
      ZodReadonly: () => ZodReadonly3,
      ZodRealError: () => ZodRealError2,
      ZodRecord: () => ZodRecord3,
      ZodSet: () => ZodSet3,
      ZodString: () => ZodString3,
      ZodStringFormat: () => ZodStringFormat2,
      ZodSuccess: () => ZodSuccess2,
      ZodSymbol: () => ZodSymbol3,
      ZodTemplateLiteral: () => ZodTemplateLiteral2,
      ZodTransform: () => ZodTransform2,
      ZodTuple: () => ZodTuple3,
      ZodType: () => ZodType3,
      ZodULID: () => ZodULID2,
      ZodURL: () => ZodURL2,
      ZodUUID: () => ZodUUID2,
      ZodUndefined: () => ZodUndefined3,
      ZodUnion: () => ZodUnion3,
      ZodUnknown: () => ZodUnknown3,
      ZodVoid: () => ZodVoid3,
      ZodXID: () => ZodXID2,
      ZodXor: () => ZodXor2,
      _ZodString: () => _ZodString2,
      _default: () => _default22,
      _function: () => _function2,
      any: () => any2,
      array: () => array2,
      base64: () => base6422,
      base64url: () => base64url22,
      bigint: () => bigint22,
      boolean: () => boolean22,
      catch: () => _catch22,
      check: () => check2,
      cidrv4: () => cidrv422,
      cidrv6: () => cidrv622,
      clone: () => clone2,
      codec: () => codec2,
      coerce: () => coerce_exports2,
      config: () => config2,
      core: () => core_exports22,
      cuid: () => cuid32,
      cuid2: () => cuid222,
      custom: () => custom2,
      date: () => date32,
      decode: () => decode22,
      decodeAsync: () => decodeAsync22,
      describe: () => describe22,
      discriminatedUnion: () => discriminatedUnion2,
      e164: () => e16422,
      email: () => email22,
      emoji: () => emoji22,
      encode: () => encode22,
      encodeAsync: () => encodeAsync22,
      endsWith: () => _endsWith2,
      enum: () => _enum22,
      exactOptional: () => exactOptional2,
      file: () => file2,
      flattenError: () => flattenError2,
      float32: () => float322,
      float64: () => float642,
      formatError: () => formatError2,
      fromJSONSchema: () => fromJSONSchema2,
      function: () => _function2,
      getErrorMap: () => getErrorMap3,
      globalRegistry: () => globalRegistry2,
      gt: () => _gt2,
      gte: () => _gte2,
      guid: () => guid22,
      hash: () => hash2,
      hex: () => hex22,
      hostname: () => hostname22,
      httpUrl: () => httpUrl2,
      includes: () => _includes2,
      instanceof: () => _instanceof2,
      int: () => int2,
      int32: () => int322,
      int64: () => int642,
      intersection: () => intersection2,
      ipv4: () => ipv422,
      ipv6: () => ipv622,
      iso: () => iso_exports2,
      json: () => json2,
      jwt: () => jwt2,
      keyof: () => keyof2,
      ksuid: () => ksuid22,
      lazy: () => lazy2,
      length: () => _length2,
      literal: () => literal2,
      locales: () => locales_exports2,
      looseObject: () => looseObject2,
      looseRecord: () => looseRecord2,
      lowercase: () => _lowercase2,
      lt: () => _lt2,
      lte: () => _lte2,
      mac: () => mac22,
      map: () => map2,
      maxLength: () => _maxLength2,
      maxSize: () => _maxSize2,
      meta: () => meta22,
      mime: () => _mime2,
      minLength: () => _minLength2,
      minSize: () => _minSize2,
      multipleOf: () => _multipleOf2,
      nan: () => nan2,
      nanoid: () => nanoid22,
      nativeEnum: () => nativeEnum2,
      negative: () => _negative2,
      never: () => never2,
      nonnegative: () => _nonnegative2,
      nonoptional: () => nonoptional2,
      nonpositive: () => _nonpositive2,
      normalize: () => _normalize2,
      null: () => _null32,
      nullable: () => nullable2,
      nullish: () => nullish22,
      number: () => number22,
      object: () => object2,
      optional: () => optional2,
      overwrite: () => _overwrite2,
      parse: () => parse22,
      parseAsync: () => parseAsync22,
      partialRecord: () => partialRecord2,
      pipe: () => pipe2,
      positive: () => _positive2,
      prefault: () => prefault2,
      preprocess: () => preprocess2,
      prettifyError: () => prettifyError2,
      promise: () => promise2,
      property: () => _property2,
      readonly: () => readonly2,
      record: () => record2,
      refine: () => refine2,
      regex: () => _regex2,
      regexes: () => regexes_exports2,
      registry: () => registry2,
      safeDecode: () => safeDecode22,
      safeDecodeAsync: () => safeDecodeAsync22,
      safeEncode: () => safeEncode22,
      safeEncodeAsync: () => safeEncodeAsync22,
      safeParse: () => safeParse22,
      safeParseAsync: () => safeParseAsync22,
      set: () => set2,
      setErrorMap: () => setErrorMap2,
      size: () => _size2,
      slugify: () => _slugify2,
      startsWith: () => _startsWith2,
      strictObject: () => strictObject2,
      string: () => string22,
      stringFormat: () => stringFormat2,
      stringbool: () => stringbool2,
      success: () => success2,
      superRefine: () => superRefine2,
      symbol: () => symbol19,
      templateLiteral: () => templateLiteral2,
      toJSONSchema: () => toJSONSchema2,
      toLowerCase: () => _toLowerCase2,
      toUpperCase: () => _toUpperCase2,
      transform: () => transform3,
      treeifyError: () => treeifyError2,
      trim: () => _trim2,
      tuple: () => tuple2,
      uint32: () => uint322,
      uint64: () => uint642,
      ulid: () => ulid22,
      undefined: () => _undefined32,
      union: () => union2,
      unknown: () => unknown2,
      uppercase: () => _uppercase2,
      url: () => url3,
      util: () => util_exports2,
      uuid: () => uuid22,
      uuidv4: () => uuidv42,
      uuidv6: () => uuidv62,
      uuidv7: () => uuidv72,
      void: () => _void22,
      xid: () => xid22,
      xor: () => xor2
    });
    core_exports22 = {};
    __export2(core_exports22, {
      $ZodAny: () => $ZodAny2,
      $ZodArray: () => $ZodArray2,
      $ZodAsyncError: () => $ZodAsyncError2,
      $ZodBase64: () => $ZodBase642,
      $ZodBase64URL: () => $ZodBase64URL2,
      $ZodBigInt: () => $ZodBigInt2,
      $ZodBigIntFormat: () => $ZodBigIntFormat2,
      $ZodBoolean: () => $ZodBoolean2,
      $ZodCIDRv4: () => $ZodCIDRv42,
      $ZodCIDRv6: () => $ZodCIDRv62,
      $ZodCUID: () => $ZodCUID3,
      $ZodCUID2: () => $ZodCUID22,
      $ZodCatch: () => $ZodCatch2,
      $ZodCheck: () => $ZodCheck2,
      $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat2,
      $ZodCheckEndsWith: () => $ZodCheckEndsWith2,
      $ZodCheckGreaterThan: () => $ZodCheckGreaterThan2,
      $ZodCheckIncludes: () => $ZodCheckIncludes2,
      $ZodCheckLengthEquals: () => $ZodCheckLengthEquals2,
      $ZodCheckLessThan: () => $ZodCheckLessThan2,
      $ZodCheckLowerCase: () => $ZodCheckLowerCase2,
      $ZodCheckMaxLength: () => $ZodCheckMaxLength2,
      $ZodCheckMaxSize: () => $ZodCheckMaxSize2,
      $ZodCheckMimeType: () => $ZodCheckMimeType2,
      $ZodCheckMinLength: () => $ZodCheckMinLength2,
      $ZodCheckMinSize: () => $ZodCheckMinSize2,
      $ZodCheckMultipleOf: () => $ZodCheckMultipleOf2,
      $ZodCheckNumberFormat: () => $ZodCheckNumberFormat2,
      $ZodCheckOverwrite: () => $ZodCheckOverwrite2,
      $ZodCheckProperty: () => $ZodCheckProperty2,
      $ZodCheckRegex: () => $ZodCheckRegex2,
      $ZodCheckSizeEquals: () => $ZodCheckSizeEquals2,
      $ZodCheckStartsWith: () => $ZodCheckStartsWith2,
      $ZodCheckStringFormat: () => $ZodCheckStringFormat2,
      $ZodCheckUpperCase: () => $ZodCheckUpperCase2,
      $ZodCodec: () => $ZodCodec2,
      $ZodCustom: () => $ZodCustom2,
      $ZodCustomStringFormat: () => $ZodCustomStringFormat2,
      $ZodDate: () => $ZodDate2,
      $ZodDefault: () => $ZodDefault2,
      $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion2,
      $ZodE164: () => $ZodE1642,
      $ZodEmail: () => $ZodEmail2,
      $ZodEmoji: () => $ZodEmoji2,
      $ZodEncodeError: () => $ZodEncodeError2,
      $ZodEnum: () => $ZodEnum2,
      $ZodError: () => $ZodError2,
      $ZodExactOptional: () => $ZodExactOptional2,
      $ZodFile: () => $ZodFile2,
      $ZodFunction: () => $ZodFunction2,
      $ZodGUID: () => $ZodGUID2,
      $ZodIPv4: () => $ZodIPv42,
      $ZodIPv6: () => $ZodIPv62,
      $ZodISODate: () => $ZodISODate2,
      $ZodISODateTime: () => $ZodISODateTime2,
      $ZodISODuration: () => $ZodISODuration2,
      $ZodISOTime: () => $ZodISOTime2,
      $ZodIntersection: () => $ZodIntersection2,
      $ZodJWT: () => $ZodJWT2,
      $ZodKSUID: () => $ZodKSUID2,
      $ZodLazy: () => $ZodLazy2,
      $ZodLiteral: () => $ZodLiteral2,
      $ZodMAC: () => $ZodMAC2,
      $ZodMap: () => $ZodMap2,
      $ZodNaN: () => $ZodNaN2,
      $ZodNanoID: () => $ZodNanoID2,
      $ZodNever: () => $ZodNever2,
      $ZodNonOptional: () => $ZodNonOptional2,
      $ZodNull: () => $ZodNull2,
      $ZodNullable: () => $ZodNullable2,
      $ZodNumber: () => $ZodNumber2,
      $ZodNumberFormat: () => $ZodNumberFormat2,
      $ZodObject: () => $ZodObject2,
      $ZodObjectJIT: () => $ZodObjectJIT2,
      $ZodOptional: () => $ZodOptional2,
      $ZodPipe: () => $ZodPipe2,
      $ZodPrefault: () => $ZodPrefault2,
      $ZodPromise: () => $ZodPromise2,
      $ZodReadonly: () => $ZodReadonly2,
      $ZodRealError: () => $ZodRealError2,
      $ZodRecord: () => $ZodRecord2,
      $ZodRegistry: () => $ZodRegistry2,
      $ZodSet: () => $ZodSet2,
      $ZodString: () => $ZodString2,
      $ZodStringFormat: () => $ZodStringFormat2,
      $ZodSuccess: () => $ZodSuccess2,
      $ZodSymbol: () => $ZodSymbol2,
      $ZodTemplateLiteral: () => $ZodTemplateLiteral2,
      $ZodTransform: () => $ZodTransform2,
      $ZodTuple: () => $ZodTuple2,
      $ZodType: () => $ZodType2,
      $ZodULID: () => $ZodULID2,
      $ZodURL: () => $ZodURL2,
      $ZodUUID: () => $ZodUUID2,
      $ZodUndefined: () => $ZodUndefined2,
      $ZodUnion: () => $ZodUnion2,
      $ZodUnknown: () => $ZodUnknown2,
      $ZodVoid: () => $ZodVoid2,
      $ZodXID: () => $ZodXID2,
      $ZodXor: () => $ZodXor2,
      $brand: () => $brand2,
      $constructor: () => $constructor2,
      $input: () => $input2,
      $output: () => $output2,
      Doc: () => Doc2,
      JSONSchema: () => json_schema_exports2,
      JSONSchemaGenerator: () => JSONSchemaGenerator2,
      NEVER: () => NEVER2,
      TimePrecision: () => TimePrecision2,
      _any: () => _any2,
      _array: () => _array2,
      _base64: () => _base642,
      _base64url: () => _base64url2,
      _bigint: () => _bigint2,
      _boolean: () => _boolean2,
      _catch: () => _catch3,
      _check: () => _check2,
      _cidrv4: () => _cidrv42,
      _cidrv6: () => _cidrv62,
      _coercedBigint: () => _coercedBigint2,
      _coercedBoolean: () => _coercedBoolean2,
      _coercedDate: () => _coercedDate2,
      _coercedNumber: () => _coercedNumber2,
      _coercedString: () => _coercedString2,
      _cuid: () => _cuid3,
      _cuid2: () => _cuid22,
      _custom: () => _custom2,
      _date: () => _date2,
      _decode: () => _decode2,
      _decodeAsync: () => _decodeAsync2,
      _default: () => _default3,
      _discriminatedUnion: () => _discriminatedUnion2,
      _e164: () => _e1642,
      _email: () => _email2,
      _emoji: () => _emoji22,
      _encode: () => _encode2,
      _encodeAsync: () => _encodeAsync2,
      _endsWith: () => _endsWith2,
      _enum: () => _enum3,
      _file: () => _file2,
      _float32: () => _float322,
      _float64: () => _float642,
      _gt: () => _gt2,
      _gte: () => _gte2,
      _guid: () => _guid2,
      _includes: () => _includes2,
      _int: () => _int2,
      _int32: () => _int322,
      _int64: () => _int642,
      _intersection: () => _intersection2,
      _ipv4: () => _ipv42,
      _ipv6: () => _ipv62,
      _isoDate: () => _isoDate2,
      _isoDateTime: () => _isoDateTime2,
      _isoDuration: () => _isoDuration2,
      _isoTime: () => _isoTime2,
      _jwt: () => _jwt2,
      _ksuid: () => _ksuid2,
      _lazy: () => _lazy2,
      _length: () => _length2,
      _literal: () => _literal2,
      _lowercase: () => _lowercase2,
      _lt: () => _lt2,
      _lte: () => _lte2,
      _mac: () => _mac2,
      _map: () => _map2,
      _max: () => _lte2,
      _maxLength: () => _maxLength2,
      _maxSize: () => _maxSize2,
      _mime: () => _mime2,
      _min: () => _gte2,
      _minLength: () => _minLength2,
      _minSize: () => _minSize2,
      _multipleOf: () => _multipleOf2,
      _nan: () => _nan2,
      _nanoid: () => _nanoid2,
      _nativeEnum: () => _nativeEnum2,
      _negative: () => _negative2,
      _never: () => _never2,
      _nonnegative: () => _nonnegative2,
      _nonoptional: () => _nonoptional2,
      _nonpositive: () => _nonpositive2,
      _normalize: () => _normalize2,
      _null: () => _null22,
      _nullable: () => _nullable2,
      _number: () => _number2,
      _optional: () => _optional2,
      _overwrite: () => _overwrite2,
      _parse: () => _parse4,
      _parseAsync: () => _parseAsync2,
      _pipe: () => _pipe2,
      _positive: () => _positive2,
      _promise: () => _promise2,
      _property: () => _property2,
      _readonly: () => _readonly2,
      _record: () => _record2,
      _refine: () => _refine2,
      _regex: () => _regex2,
      _safeDecode: () => _safeDecode2,
      _safeDecodeAsync: () => _safeDecodeAsync2,
      _safeEncode: () => _safeEncode2,
      _safeEncodeAsync: () => _safeEncodeAsync2,
      _safeParse: () => _safeParse2,
      _safeParseAsync: () => _safeParseAsync2,
      _set: () => _set2,
      _size: () => _size2,
      _slugify: () => _slugify2,
      _startsWith: () => _startsWith2,
      _string: () => _string2,
      _stringFormat: () => _stringFormat2,
      _stringbool: () => _stringbool2,
      _success: () => _success2,
      _superRefine: () => _superRefine2,
      _symbol: () => _symbol2,
      _templateLiteral: () => _templateLiteral2,
      _toLowerCase: () => _toLowerCase2,
      _toUpperCase: () => _toUpperCase2,
      _transform: () => _transform2,
      _trim: () => _trim2,
      _tuple: () => _tuple2,
      _uint32: () => _uint322,
      _uint64: () => _uint642,
      _ulid: () => _ulid2,
      _undefined: () => _undefined22,
      _union: () => _union2,
      _unknown: () => _unknown2,
      _uppercase: () => _uppercase2,
      _url: () => _url2,
      _uuid: () => _uuid2,
      _uuidv4: () => _uuidv42,
      _uuidv6: () => _uuidv62,
      _uuidv7: () => _uuidv72,
      _void: () => _void3,
      _xid: () => _xid2,
      _xor: () => _xor2,
      clone: () => clone2,
      config: () => config2,
      createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod2,
      createToJSONSchemaMethod: () => createToJSONSchemaMethod2,
      decode: () => decode3,
      decodeAsync: () => decodeAsync3,
      describe: () => describe3,
      encode: () => encode5,
      encodeAsync: () => encodeAsync3,
      extractDefs: () => extractDefs2,
      finalize: () => finalize2,
      flattenError: () => flattenError2,
      formatError: () => formatError2,
      globalConfig: () => globalConfig2,
      globalRegistry: () => globalRegistry2,
      initializeContext: () => initializeContext2,
      isValidBase64: () => isValidBase642,
      isValidBase64URL: () => isValidBase64URL2,
      isValidJWT: () => isValidJWT3,
      locales: () => locales_exports2,
      meta: () => meta3,
      parse: () => parse3,
      parseAsync: () => parseAsync3,
      prettifyError: () => prettifyError2,
      process: () => process3,
      regexes: () => regexes_exports2,
      registry: () => registry2,
      safeDecode: () => safeDecode3,
      safeDecodeAsync: () => safeDecodeAsync3,
      safeEncode: () => safeEncode3,
      safeEncodeAsync: () => safeEncodeAsync3,
      safeParse: () => safeParse3,
      safeParseAsync: () => safeParseAsync3,
      toDotPath: () => toDotPath2,
      toJSONSchema: () => toJSONSchema2,
      treeifyError: () => treeifyError2,
      util: () => util_exports2,
      version: () => version2
    });
    NEVER2 = Object.freeze({
      status: "aborted"
    });
    $brand2 = /* @__PURE__ */ Symbol("zod_brand");
    $ZodAsyncError2 = class extends Error {
      constructor() {
        super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
      }
    };
    $ZodEncodeError2 = class extends Error {
      constructor(name28) {
        super(`Encountered unidirectional transform during encode: ${name28}`);
        this.name = "ZodEncodeError";
      }
    };
    globalConfig2 = {};
    util_exports2 = {};
    __export2(util_exports2, {
      BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES2,
      Class: () => Class2,
      NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES2,
      aborted: () => aborted2,
      allowsEval: () => allowsEval2,
      assert: () => assert2,
      assertEqual: () => assertEqual2,
      assertIs: () => assertIs2,
      assertNever: () => assertNever2,
      assertNotEqual: () => assertNotEqual2,
      assignProp: () => assignProp2,
      base64ToUint8Array: () => base64ToUint8Array2,
      base64urlToUint8Array: () => base64urlToUint8Array2,
      cached: () => cached2,
      captureStackTrace: () => captureStackTrace2,
      cleanEnum: () => cleanEnum2,
      cleanRegex: () => cleanRegex2,
      clone: () => clone2,
      cloneDef: () => cloneDef2,
      createTransparentProxy: () => createTransparentProxy2,
      defineLazy: () => defineLazy2,
      esc: () => esc2,
      escapeRegex: () => escapeRegex2,
      extend: () => extend3,
      finalizeIssue: () => finalizeIssue2,
      floatSafeRemainder: () => floatSafeRemainder3,
      getElementAtPath: () => getElementAtPath2,
      getEnumValues: () => getEnumValues2,
      getLengthableOrigin: () => getLengthableOrigin2,
      getParsedType: () => getParsedType3,
      getSizableOrigin: () => getSizableOrigin2,
      hexToUint8Array: () => hexToUint8Array2,
      isObject: () => isObject4,
      isPlainObject: () => isPlainObject3,
      issue: () => issue2,
      joinValues: () => joinValues2,
      jsonStringifyReplacer: () => jsonStringifyReplacer2,
      merge: () => merge3,
      mergeDefs: () => mergeDefs2,
      normalizeParams: () => normalizeParams2,
      nullish: () => nullish3,
      numKeys: () => numKeys2,
      objectClone: () => objectClone2,
      omit: () => omit2,
      optionalKeys: () => optionalKeys2,
      parsedType: () => parsedType2,
      partial: () => partial2,
      pick: () => pick2,
      prefixIssues: () => prefixIssues2,
      primitiveTypes: () => primitiveTypes2,
      promiseAllObject: () => promiseAllObject2,
      propertyKeyTypes: () => propertyKeyTypes2,
      randomString: () => randomString2,
      required: () => required2,
      safeExtend: () => safeExtend2,
      shallowClone: () => shallowClone2,
      slugify: () => slugify2,
      stringifyPrimitive: () => stringifyPrimitive2,
      uint8ArrayToBase64: () => uint8ArrayToBase642,
      uint8ArrayToBase64url: () => uint8ArrayToBase64url2,
      uint8ArrayToHex: () => uint8ArrayToHex2,
      unwrapMessage: () => unwrapMessage2
    });
    EVALUATING2 = /* @__PURE__ */ Symbol("evaluating");
    captureStackTrace2 = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
    };
    allowsEval2 = cached2(() => {
      var _a37;
      if (typeof navigator !== "undefined" && ((_a37 = navigator == null ? void 0 : navigator.userAgent) == null ? void 0 : _a37.includes("Cloudflare"))) {
        return false;
      }
      try {
        const F = Function;
        new F("");
        return true;
      } catch (_) {
        return false;
      }
    });
    getParsedType3 = (data) => {
      const t = typeof data;
      switch (t) {
        case "undefined":
          return "undefined";
        case "string":
          return "string";
        case "number":
          return Number.isNaN(data) ? "nan" : "number";
        case "boolean":
          return "boolean";
        case "function":
          return "function";
        case "bigint":
          return "bigint";
        case "symbol":
          return "symbol";
        case "object":
          if (Array.isArray(data)) {
            return "array";
          }
          if (data === null) {
            return "null";
          }
          if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
            return "promise";
          }
          if (typeof Map !== "undefined" && data instanceof Map) {
            return "map";
          }
          if (typeof Set !== "undefined" && data instanceof Set) {
            return "set";
          }
          if (typeof Date !== "undefined" && data instanceof Date) {
            return "date";
          }
          if (typeof File !== "undefined" && data instanceof File) {
            return "file";
          }
          return "object";
        default:
          throw new Error(`Unknown data type: ${t}`);
      }
    };
    propertyKeyTypes2 = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
    primitiveTypes2 = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
    NUMBER_FORMAT_RANGES2 = {
      safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
      int32: [-2147483648, 2147483647],
      uint32: [0, 4294967295],
      float32: [-34028234663852886e22, 34028234663852886e22],
      float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
    };
    BIGINT_FORMAT_RANGES2 = {
      int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
      uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
    };
    Class2 = class {
      constructor(..._args) {
      }
    };
    initializer3 = (inst, def) => {
      inst.name = "$ZodError";
      Object.defineProperty(inst, "_zod", {
        value: inst._zod,
        enumerable: false
      });
      Object.defineProperty(inst, "issues", {
        value: def,
        enumerable: false
      });
      inst.message = JSON.stringify(def, jsonStringifyReplacer2, 2);
      Object.defineProperty(inst, "toString", {
        value: () => inst.message,
        enumerable: false
      });
    };
    $ZodError2 = /* @__PURE__ */ $constructor2("$ZodError", initializer3);
    $ZodRealError2 = /* @__PURE__ */ $constructor2("$ZodError", initializer3, { Parent: Error });
    _parse4 = (_Err) => (schema, value, _ctx, _params) => {
      var _a37;
      const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
      const result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise) {
        throw new $ZodAsyncError2();
      }
      if (result.issues.length) {
        const e = new ((_a37 = _params == null ? void 0 : _params.Err) != null ? _a37 : _Err)(result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())));
        captureStackTrace2(e, _params == null ? void 0 : _params.callee);
        throw e;
      }
      return result.value;
    };
    parse3 = /* @__PURE__ */ _parse4($ZodRealError2);
    _parseAsync2 = (_Err) => async (schema, value, _ctx, params) => {
      var _a37;
      const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
      let result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise)
        result = await result;
      if (result.issues.length) {
        const e = new ((_a37 = params == null ? void 0 : params.Err) != null ? _a37 : _Err)(result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())));
        captureStackTrace2(e, params == null ? void 0 : params.callee);
        throw e;
      }
      return result.value;
    };
    parseAsync3 = /* @__PURE__ */ _parseAsync2($ZodRealError2);
    _safeParse2 = (_Err) => (schema, value, _ctx) => {
      const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
      const result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise) {
        throw new $ZodAsyncError2();
      }
      return result.issues.length ? {
        success: false,
        error: new (_Err != null ? _Err : $ZodError2)(result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())))
      } : { success: true, data: result.value };
    };
    safeParse3 = /* @__PURE__ */ _safeParse2($ZodRealError2);
    _safeParseAsync2 = (_Err) => async (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
      let result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise)
        result = await result;
      return result.issues.length ? {
        success: false,
        error: new _Err(result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())))
      } : { success: true, data: result.value };
    };
    safeParseAsync3 = /* @__PURE__ */ _safeParseAsync2($ZodRealError2);
    _encode2 = (_Err) => (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return _parse4(_Err)(schema, value, ctx);
    };
    encode5 = /* @__PURE__ */ _encode2($ZodRealError2);
    _decode2 = (_Err) => (schema, value, _ctx) => {
      return _parse4(_Err)(schema, value, _ctx);
    };
    decode3 = /* @__PURE__ */ _decode2($ZodRealError2);
    _encodeAsync2 = (_Err) => async (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return _parseAsync2(_Err)(schema, value, ctx);
    };
    encodeAsync3 = /* @__PURE__ */ _encodeAsync2($ZodRealError2);
    _decodeAsync2 = (_Err) => async (schema, value, _ctx) => {
      return _parseAsync2(_Err)(schema, value, _ctx);
    };
    decodeAsync3 = /* @__PURE__ */ _decodeAsync2($ZodRealError2);
    _safeEncode2 = (_Err) => (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return _safeParse2(_Err)(schema, value, ctx);
    };
    safeEncode3 = /* @__PURE__ */ _safeEncode2($ZodRealError2);
    _safeDecode2 = (_Err) => (schema, value, _ctx) => {
      return _safeParse2(_Err)(schema, value, _ctx);
    };
    safeDecode3 = /* @__PURE__ */ _safeDecode2($ZodRealError2);
    _safeEncodeAsync2 = (_Err) => async (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return _safeParseAsync2(_Err)(schema, value, ctx);
    };
    safeEncodeAsync3 = /* @__PURE__ */ _safeEncodeAsync2($ZodRealError2);
    _safeDecodeAsync2 = (_Err) => async (schema, value, _ctx) => {
      return _safeParseAsync2(_Err)(schema, value, _ctx);
    };
    safeDecodeAsync3 = /* @__PURE__ */ _safeDecodeAsync2($ZodRealError2);
    regexes_exports2 = {};
    __export2(regexes_exports2, {
      base64: () => base643,
      base64url: () => base64url3,
      bigint: () => bigint4,
      boolean: () => boolean4,
      browserEmail: () => browserEmail2,
      cidrv4: () => cidrv43,
      cidrv6: () => cidrv63,
      cuid: () => cuid4,
      cuid2: () => cuid23,
      date: () => date5,
      datetime: () => datetime3,
      domain: () => domain2,
      duration: () => duration3,
      e164: () => e1643,
      email: () => email3,
      emoji: () => emoji3,
      extendedDuration: () => extendedDuration2,
      guid: () => guid3,
      hex: () => hex3,
      hostname: () => hostname3,
      html5Email: () => html5Email2,
      idnEmail: () => idnEmail2,
      integer: () => integer2,
      ipv4: () => ipv43,
      ipv6: () => ipv63,
      ksuid: () => ksuid3,
      lowercase: () => lowercase2,
      mac: () => mac3,
      md5_base64: () => md5_base642,
      md5_base64url: () => md5_base64url2,
      md5_hex: () => md5_hex2,
      nanoid: () => nanoid3,
      null: () => _null4,
      number: () => number4,
      rfc5322Email: () => rfc5322Email2,
      sha1_base64: () => sha1_base642,
      sha1_base64url: () => sha1_base64url2,
      sha1_hex: () => sha1_hex2,
      sha256_base64: () => sha256_base642,
      sha256_base64url: () => sha256_base64url2,
      sha256_hex: () => sha256_hex2,
      sha384_base64: () => sha384_base642,
      sha384_base64url: () => sha384_base64url2,
      sha384_hex: () => sha384_hex2,
      sha512_base64: () => sha512_base642,
      sha512_base64url: () => sha512_base64url2,
      sha512_hex: () => sha512_hex2,
      string: () => string4,
      time: () => time3,
      ulid: () => ulid3,
      undefined: () => _undefined4,
      unicodeEmail: () => unicodeEmail2,
      uppercase: () => uppercase2,
      uuid: () => uuid3,
      uuid4: () => uuid42,
      uuid6: () => uuid62,
      uuid7: () => uuid72,
      xid: () => xid3
    });
    cuid4 = /^[cC][^\s-]{8,}$/;
    cuid23 = /^[0-9a-z]+$/;
    ulid3 = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
    xid3 = /^[0-9a-vA-V]{20}$/;
    ksuid3 = /^[A-Za-z0-9]{27}$/;
    nanoid3 = /^[a-zA-Z0-9_-]{21}$/;
    duration3 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
    extendedDuration2 = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
    guid3 = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
    uuid3 = (version22) => {
      if (!version22)
        return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
      return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version22}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
    };
    uuid42 = /* @__PURE__ */ uuid3(4);
    uuid62 = /* @__PURE__ */ uuid3(6);
    uuid72 = /* @__PURE__ */ uuid3(7);
    email3 = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
    html5Email2 = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
    rfc5322Email2 = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    unicodeEmail2 = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
    idnEmail2 = unicodeEmail2;
    browserEmail2 = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
    _emoji3 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
    ipv43 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
    ipv63 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
    mac3 = (delimiter) => {
      const escapedDelim = escapeRegex2(delimiter != null ? delimiter : ":");
      return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
    };
    cidrv43 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
    cidrv63 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
    base643 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
    base64url3 = /^[A-Za-z0-9_-]*$/;
    hostname3 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
    domain2 = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
    e1643 = /^\+[1-9]\d{6,14}$/;
    dateSource2 = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
    date5 = /* @__PURE__ */ new RegExp(`^${dateSource2}$`);
    string4 = (params) => {
      var _a37, _b27;
      const regex = params ? `[\\s\\S]{${(_a37 = params == null ? void 0 : params.minimum) != null ? _a37 : 0},${(_b27 = params == null ? void 0 : params.maximum) != null ? _b27 : ""}}` : `[\\s\\S]*`;
      return new RegExp(`^${regex}$`);
    };
    bigint4 = /^-?\d+n?$/;
    integer2 = /^-?\d+$/;
    number4 = /^-?\d+(?:\.\d+)?$/;
    boolean4 = /^(?:true|false)$/i;
    _null4 = /^null$/i;
    _undefined4 = /^undefined$/i;
    lowercase2 = /^[^A-Z]*$/;
    uppercase2 = /^[^a-z]*$/;
    hex3 = /^[0-9a-fA-F]*$/;
    md5_hex2 = /^[0-9a-fA-F]{32}$/;
    md5_base642 = /* @__PURE__ */ fixedBase642(22, "==");
    md5_base64url2 = /* @__PURE__ */ fixedBase64url2(22);
    sha1_hex2 = /^[0-9a-fA-F]{40}$/;
    sha1_base642 = /* @__PURE__ */ fixedBase642(27, "=");
    sha1_base64url2 = /* @__PURE__ */ fixedBase64url2(27);
    sha256_hex2 = /^[0-9a-fA-F]{64}$/;
    sha256_base642 = /* @__PURE__ */ fixedBase642(43, "=");
    sha256_base64url2 = /* @__PURE__ */ fixedBase64url2(43);
    sha384_hex2 = /^[0-9a-fA-F]{96}$/;
    sha384_base642 = /* @__PURE__ */ fixedBase642(64, "");
    sha384_base64url2 = /* @__PURE__ */ fixedBase64url2(64);
    sha512_hex2 = /^[0-9a-fA-F]{128}$/;
    sha512_base642 = /* @__PURE__ */ fixedBase642(86, "==");
    sha512_base64url2 = /* @__PURE__ */ fixedBase64url2(86);
    $ZodCheck2 = /* @__PURE__ */ $constructor2("$ZodCheck", (inst, def) => {
      var _a47, _b27;
      var _a37;
      (_a47 = inst._zod) != null ? _a47 : inst._zod = {};
      inst._zod.def = def;
      (_b27 = (_a37 = inst._zod).onattach) != null ? _b27 : _a37.onattach = [];
    });
    numericOriginMap2 = {
      number: "number",
      bigint: "bigint",
      object: "date"
    };
    $ZodCheckLessThan2 = /* @__PURE__ */ $constructor2("$ZodCheckLessThan", (inst, def) => {
      $ZodCheck2.init(inst, def);
      const origin2 = numericOriginMap2[typeof def.value];
      inst._zod.onattach.push((inst2) => {
        var _a37;
        const bag = inst2._zod.bag;
        const curr = (_a37 = def.inclusive ? bag.maximum : bag.exclusiveMaximum) != null ? _a37 : Number.POSITIVE_INFINITY;
        if (def.value < curr) {
          if (def.inclusive)
            bag.maximum = def.value;
          else
            bag.exclusiveMaximum = def.value;
        }
      });
      inst._zod.check = (payload) => {
        if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
          return;
        }
        payload.issues.push({
          origin: origin2,
          code: "too_big",
          maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
          input: payload.value,
          inclusive: def.inclusive,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckGreaterThan2 = /* @__PURE__ */ $constructor2("$ZodCheckGreaterThan", (inst, def) => {
      $ZodCheck2.init(inst, def);
      const origin2 = numericOriginMap2[typeof def.value];
      inst._zod.onattach.push((inst2) => {
        var _a37;
        const bag = inst2._zod.bag;
        const curr = (_a37 = def.inclusive ? bag.minimum : bag.exclusiveMinimum) != null ? _a37 : Number.NEGATIVE_INFINITY;
        if (def.value > curr) {
          if (def.inclusive)
            bag.minimum = def.value;
          else
            bag.exclusiveMinimum = def.value;
        }
      });
      inst._zod.check = (payload) => {
        if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
          return;
        }
        payload.issues.push({
          origin: origin2,
          code: "too_small",
          minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
          input: payload.value,
          inclusive: def.inclusive,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckMultipleOf2 = /* @__PURE__ */ $constructor2("$ZodCheckMultipleOf", (inst, def) => {
      $ZodCheck2.init(inst, def);
      inst._zod.onattach.push((inst2) => {
        var _a47;
        var _a37;
        (_a47 = (_a37 = inst2._zod.bag).multipleOf) != null ? _a47 : _a37.multipleOf = def.value;
      });
      inst._zod.check = (payload) => {
        if (typeof payload.value !== typeof def.value)
          throw new Error("Cannot mix number and bigint in multiple_of check.");
        const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder3(payload.value, def.value) === 0;
        if (isMultiple)
          return;
        payload.issues.push({
          origin: typeof payload.value,
          code: "not_multiple_of",
          divisor: def.value,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckNumberFormat2 = /* @__PURE__ */ $constructor2("$ZodCheckNumberFormat", (inst, def) => {
      var _a37;
      $ZodCheck2.init(inst, def);
      def.format = def.format || "float64";
      const isInt = (_a37 = def.format) == null ? void 0 : _a37.includes("int");
      const origin2 = isInt ? "int" : "number";
      const [minimum, maximum] = NUMBER_FORMAT_RANGES2[def.format];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.format = def.format;
        bag.minimum = minimum;
        bag.maximum = maximum;
        if (isInt)
          bag.pattern = integer2;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        if (isInt) {
          if (!Number.isInteger(input)) {
            payload.issues.push({
              expected: origin2,
              format: def.format,
              code: "invalid_type",
              continue: false,
              input,
              inst
            });
            return;
          }
          if (!Number.isSafeInteger(input)) {
            if (input > 0) {
              payload.issues.push({
                input,
                code: "too_big",
                maximum: Number.MAX_SAFE_INTEGER,
                note: "Integers must be within the safe integer range.",
                inst,
                origin: origin2,
                inclusive: true,
                continue: !def.abort
              });
            } else {
              payload.issues.push({
                input,
                code: "too_small",
                minimum: Number.MIN_SAFE_INTEGER,
                note: "Integers must be within the safe integer range.",
                inst,
                origin: origin2,
                inclusive: true,
                continue: !def.abort
              });
            }
            return;
          }
        }
        if (input < minimum) {
          payload.issues.push({
            origin: "number",
            input,
            code: "too_small",
            minimum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
        if (input > maximum) {
          payload.issues.push({
            origin: "number",
            input,
            code: "too_big",
            maximum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodCheckBigIntFormat2 = /* @__PURE__ */ $constructor2("$ZodCheckBigIntFormat", (inst, def) => {
      $ZodCheck2.init(inst, def);
      const [minimum, maximum] = BIGINT_FORMAT_RANGES2[def.format];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.format = def.format;
        bag.minimum = minimum;
        bag.maximum = maximum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        if (input < minimum) {
          payload.issues.push({
            origin: "bigint",
            input,
            code: "too_small",
            minimum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
        if (input > maximum) {
          payload.issues.push({
            origin: "bigint",
            input,
            code: "too_big",
            maximum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodCheckMaxSize2 = /* @__PURE__ */ $constructor2("$ZodCheckMaxSize", (inst, def) => {
      var _a47;
      var _a37;
      $ZodCheck2.init(inst, def);
      (_a47 = (_a37 = inst._zod.def).when) != null ? _a47 : _a37.when = (payload) => {
        const val = payload.value;
        return !nullish3(val) && val.size !== void 0;
      };
      inst._zod.onattach.push((inst2) => {
        var _a57;
        const curr = (_a57 = inst2._zod.bag.maximum) != null ? _a57 : Number.POSITIVE_INFINITY;
        if (def.maximum < curr)
          inst2._zod.bag.maximum = def.maximum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const size = input.size;
        if (size <= def.maximum)
          return;
        payload.issues.push({
          origin: getSizableOrigin2(input),
          code: "too_big",
          maximum: def.maximum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckMinSize2 = /* @__PURE__ */ $constructor2("$ZodCheckMinSize", (inst, def) => {
      var _a47;
      var _a37;
      $ZodCheck2.init(inst, def);
      (_a47 = (_a37 = inst._zod.def).when) != null ? _a47 : _a37.when = (payload) => {
        const val = payload.value;
        return !nullish3(val) && val.size !== void 0;
      };
      inst._zod.onattach.push((inst2) => {
        var _a57;
        const curr = (_a57 = inst2._zod.bag.minimum) != null ? _a57 : Number.NEGATIVE_INFINITY;
        if (def.minimum > curr)
          inst2._zod.bag.minimum = def.minimum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const size = input.size;
        if (size >= def.minimum)
          return;
        payload.issues.push({
          origin: getSizableOrigin2(input),
          code: "too_small",
          minimum: def.minimum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckSizeEquals2 = /* @__PURE__ */ $constructor2("$ZodCheckSizeEquals", (inst, def) => {
      var _a47;
      var _a37;
      $ZodCheck2.init(inst, def);
      (_a47 = (_a37 = inst._zod.def).when) != null ? _a47 : _a37.when = (payload) => {
        const val = payload.value;
        return !nullish3(val) && val.size !== void 0;
      };
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.minimum = def.size;
        bag.maximum = def.size;
        bag.size = def.size;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const size = input.size;
        if (size === def.size)
          return;
        const tooBig = size > def.size;
        payload.issues.push({
          origin: getSizableOrigin2(input),
          ...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size },
          inclusive: true,
          exact: true,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckMaxLength2 = /* @__PURE__ */ $constructor2("$ZodCheckMaxLength", (inst, def) => {
      var _a47;
      var _a37;
      $ZodCheck2.init(inst, def);
      (_a47 = (_a37 = inst._zod.def).when) != null ? _a47 : _a37.when = (payload) => {
        const val = payload.value;
        return !nullish3(val) && val.length !== void 0;
      };
      inst._zod.onattach.push((inst2) => {
        var _a57;
        const curr = (_a57 = inst2._zod.bag.maximum) != null ? _a57 : Number.POSITIVE_INFINITY;
        if (def.maximum < curr)
          inst2._zod.bag.maximum = def.maximum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const length = input.length;
        if (length <= def.maximum)
          return;
        const origin2 = getLengthableOrigin2(input);
        payload.issues.push({
          origin: origin2,
          code: "too_big",
          maximum: def.maximum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckMinLength2 = /* @__PURE__ */ $constructor2("$ZodCheckMinLength", (inst, def) => {
      var _a47;
      var _a37;
      $ZodCheck2.init(inst, def);
      (_a47 = (_a37 = inst._zod.def).when) != null ? _a47 : _a37.when = (payload) => {
        const val = payload.value;
        return !nullish3(val) && val.length !== void 0;
      };
      inst._zod.onattach.push((inst2) => {
        var _a57;
        const curr = (_a57 = inst2._zod.bag.minimum) != null ? _a57 : Number.NEGATIVE_INFINITY;
        if (def.minimum > curr)
          inst2._zod.bag.minimum = def.minimum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const length = input.length;
        if (length >= def.minimum)
          return;
        const origin2 = getLengthableOrigin2(input);
        payload.issues.push({
          origin: origin2,
          code: "too_small",
          minimum: def.minimum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckLengthEquals2 = /* @__PURE__ */ $constructor2("$ZodCheckLengthEquals", (inst, def) => {
      var _a47;
      var _a37;
      $ZodCheck2.init(inst, def);
      (_a47 = (_a37 = inst._zod.def).when) != null ? _a47 : _a37.when = (payload) => {
        const val = payload.value;
        return !nullish3(val) && val.length !== void 0;
      };
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.minimum = def.length;
        bag.maximum = def.length;
        bag.length = def.length;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const length = input.length;
        if (length === def.length)
          return;
        const origin2 = getLengthableOrigin2(input);
        const tooBig = length > def.length;
        payload.issues.push({
          origin: origin2,
          ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
          inclusive: true,
          exact: true,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckStringFormat2 = /* @__PURE__ */ $constructor2("$ZodCheckStringFormat", (inst, def) => {
      var _a47, _b27;
      var _a37, _b28;
      $ZodCheck2.init(inst, def);
      inst._zod.onattach.push((inst2) => {
        var _a57;
        const bag = inst2._zod.bag;
        bag.format = def.format;
        if (def.pattern) {
          (_a57 = bag.patterns) != null ? _a57 : bag.patterns = /* @__PURE__ */ new Set();
          bag.patterns.add(def.pattern);
        }
      });
      if (def.pattern)
        (_a47 = (_a37 = inst._zod).check) != null ? _a47 : _a37.check = (payload) => {
          def.pattern.lastIndex = 0;
          if (def.pattern.test(payload.value))
            return;
          payload.issues.push({
            origin: "string",
            code: "invalid_format",
            format: def.format,
            input: payload.value,
            ...def.pattern ? { pattern: def.pattern.toString() } : {},
            inst,
            continue: !def.abort
          });
        };
      else
        (_b27 = (_b28 = inst._zod).check) != null ? _b27 : _b28.check = () => {
        };
    });
    $ZodCheckRegex2 = /* @__PURE__ */ $constructor2("$ZodCheckRegex", (inst, def) => {
      $ZodCheckStringFormat2.init(inst, def);
      inst._zod.check = (payload) => {
        def.pattern.lastIndex = 0;
        if (def.pattern.test(payload.value))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "regex",
          input: payload.value,
          pattern: def.pattern.toString(),
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckLowerCase2 = /* @__PURE__ */ $constructor2("$ZodCheckLowerCase", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = lowercase2;
      $ZodCheckStringFormat2.init(inst, def);
    });
    $ZodCheckUpperCase2 = /* @__PURE__ */ $constructor2("$ZodCheckUpperCase", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = uppercase2;
      $ZodCheckStringFormat2.init(inst, def);
    });
    $ZodCheckIncludes2 = /* @__PURE__ */ $constructor2("$ZodCheckIncludes", (inst, def) => {
      $ZodCheck2.init(inst, def);
      const escapedRegex = escapeRegex2(def.includes);
      const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
      def.pattern = pattern;
      inst._zod.onattach.push((inst2) => {
        var _a37;
        const bag = inst2._zod.bag;
        (_a37 = bag.patterns) != null ? _a37 : bag.patterns = /* @__PURE__ */ new Set();
        bag.patterns.add(pattern);
      });
      inst._zod.check = (payload) => {
        if (payload.value.includes(def.includes, def.position))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "includes",
          includes: def.includes,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckStartsWith2 = /* @__PURE__ */ $constructor2("$ZodCheckStartsWith", (inst, def) => {
      var _a37;
      $ZodCheck2.init(inst, def);
      const pattern = new RegExp(`^${escapeRegex2(def.prefix)}.*`);
      (_a37 = def.pattern) != null ? _a37 : def.pattern = pattern;
      inst._zod.onattach.push((inst2) => {
        var _a47;
        const bag = inst2._zod.bag;
        (_a47 = bag.patterns) != null ? _a47 : bag.patterns = /* @__PURE__ */ new Set();
        bag.patterns.add(pattern);
      });
      inst._zod.check = (payload) => {
        if (payload.value.startsWith(def.prefix))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "starts_with",
          prefix: def.prefix,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckEndsWith2 = /* @__PURE__ */ $constructor2("$ZodCheckEndsWith", (inst, def) => {
      var _a37;
      $ZodCheck2.init(inst, def);
      const pattern = new RegExp(`.*${escapeRegex2(def.suffix)}$`);
      (_a37 = def.pattern) != null ? _a37 : def.pattern = pattern;
      inst._zod.onattach.push((inst2) => {
        var _a47;
        const bag = inst2._zod.bag;
        (_a47 = bag.patterns) != null ? _a47 : bag.patterns = /* @__PURE__ */ new Set();
        bag.patterns.add(pattern);
      });
      inst._zod.check = (payload) => {
        if (payload.value.endsWith(def.suffix))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "ends_with",
          suffix: def.suffix,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckProperty2 = /* @__PURE__ */ $constructor2("$ZodCheckProperty", (inst, def) => {
      $ZodCheck2.init(inst, def);
      inst._zod.check = (payload) => {
        const result = def.schema._zod.run({
          value: payload.value[def.property],
          issues: []
        }, {});
        if (result instanceof Promise) {
          return result.then((result2) => handleCheckPropertyResult2(result2, payload, def.property));
        }
        handleCheckPropertyResult2(result, payload, def.property);
        return;
      };
    });
    $ZodCheckMimeType2 = /* @__PURE__ */ $constructor2("$ZodCheckMimeType", (inst, def) => {
      $ZodCheck2.init(inst, def);
      const mimeSet = new Set(def.mime);
      inst._zod.onattach.push((inst2) => {
        inst2._zod.bag.mime = def.mime;
      });
      inst._zod.check = (payload) => {
        if (mimeSet.has(payload.value.type))
          return;
        payload.issues.push({
          code: "invalid_value",
          values: def.mime,
          input: payload.value.type,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCheckOverwrite2 = /* @__PURE__ */ $constructor2("$ZodCheckOverwrite", (inst, def) => {
      $ZodCheck2.init(inst, def);
      inst._zod.check = (payload) => {
        payload.value = def.tx(payload.value);
      };
    });
    Doc2 = class {
      constructor(args = []) {
        this.content = [];
        this.indent = 0;
        if (this)
          this.args = args;
      }
      indented(fn) {
        this.indent += 1;
        fn(this);
        this.indent -= 1;
      }
      write(arg) {
        if (typeof arg === "function") {
          arg(this, { execution: "sync" });
          arg(this, { execution: "async" });
          return;
        }
        const content = arg;
        const lines = content.split("\n").filter((x) => x);
        const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
        const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
        for (const line of dedented) {
          this.content.push(line);
        }
      }
      compile() {
        var _a37;
        const F = Function;
        const args = this == null ? void 0 : this.args;
        const content = (_a37 = this == null ? void 0 : this.content) != null ? _a37 : [``];
        const lines = [...content.map((x) => `  ${x}`)];
        return new F(...args, lines.join("\n"));
      }
    };
    version2 = {
      major: 4,
      minor: 3,
      patch: 5
    };
    $ZodType2 = /* @__PURE__ */ $constructor2("$ZodType", (inst, def) => {
      var _a47, _b27, _c;
      var _a37;
      inst != null ? inst : inst = {};
      inst._zod.def = def;
      inst._zod.bag = inst._zod.bag || {};
      inst._zod.version = version2;
      const checks = [...(_a47 = inst._zod.def.checks) != null ? _a47 : []];
      if (inst._zod.traits.has("$ZodCheck")) {
        checks.unshift(inst);
      }
      for (const ch of checks) {
        for (const fn of ch._zod.onattach) {
          fn(inst);
        }
      }
      if (checks.length === 0) {
        (_b27 = (_a37 = inst._zod).deferred) != null ? _b27 : _a37.deferred = [];
        (_c = inst._zod.deferred) == null ? void 0 : _c.push(() => {
          inst._zod.run = inst._zod.parse;
        });
      } else {
        const runChecks = (payload, checks2, ctx) => {
          let isAborted2 = aborted2(payload);
          let asyncResult;
          for (const ch of checks2) {
            if (ch._zod.def.when) {
              const shouldRun = ch._zod.def.when(payload);
              if (!shouldRun)
                continue;
            } else if (isAborted2) {
              continue;
            }
            const currLen = payload.issues.length;
            const _ = ch._zod.check(payload);
            if (_ instanceof Promise && (ctx == null ? void 0 : ctx.async) === false) {
              throw new $ZodAsyncError2();
            }
            if (asyncResult || _ instanceof Promise) {
              asyncResult = (asyncResult != null ? asyncResult : Promise.resolve()).then(async () => {
                await _;
                const nextLen = payload.issues.length;
                if (nextLen === currLen)
                  return;
                if (!isAborted2)
                  isAborted2 = aborted2(payload, currLen);
              });
            } else {
              const nextLen = payload.issues.length;
              if (nextLen === currLen)
                continue;
              if (!isAborted2)
                isAborted2 = aborted2(payload, currLen);
            }
          }
          if (asyncResult) {
            return asyncResult.then(() => {
              return payload;
            });
          }
          return payload;
        };
        const handleCanaryResult = (canary, payload, ctx) => {
          if (aborted2(canary)) {
            canary.aborted = true;
            return canary;
          }
          const checkResult = runChecks(payload, checks, ctx);
          if (checkResult instanceof Promise) {
            if (ctx.async === false)
              throw new $ZodAsyncError2();
            return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
          }
          return inst._zod.parse(checkResult, ctx);
        };
        inst._zod.run = (payload, ctx) => {
          if (ctx.skipChecks) {
            return inst._zod.parse(payload, ctx);
          }
          if (ctx.direction === "backward") {
            const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
            if (canary instanceof Promise) {
              return canary.then((canary2) => {
                return handleCanaryResult(canary2, payload, ctx);
              });
            }
            return handleCanaryResult(canary, payload, ctx);
          }
          const result = inst._zod.parse(payload, ctx);
          if (result instanceof Promise) {
            if (ctx.async === false)
              throw new $ZodAsyncError2();
            return result.then((result2) => runChecks(result2, checks, ctx));
          }
          return runChecks(result, checks, ctx);
        };
      }
      defineLazy2(inst, "~standard", () => ({
        validate: (value) => {
          var _a57;
          try {
            const r = safeParse3(inst, value);
            return r.success ? { value: r.data } : { issues: (_a57 = r.error) == null ? void 0 : _a57.issues };
          } catch (_) {
            return safeParseAsync3(inst, value).then((r) => {
              var _a67;
              return r.success ? { value: r.data } : { issues: (_a67 = r.error) == null ? void 0 : _a67.issues };
            });
          }
        },
        vendor: "zod",
        version: 1
      }));
    });
    $ZodString2 = /* @__PURE__ */ $constructor2("$ZodString", (inst, def) => {
      var _a37, _b27, _c;
      $ZodType2.init(inst, def);
      inst._zod.pattern = (_c = [...(_b27 = (_a37 = inst == null ? void 0 : inst._zod.bag) == null ? void 0 : _a37.patterns) != null ? _b27 : []].pop()) != null ? _c : string4(inst._zod.bag);
      inst._zod.parse = (payload, _) => {
        if (def.coerce)
          try {
            payload.value = String(payload.value);
          } catch (_2) {
          }
        if (typeof payload.value === "string")
          return payload;
        payload.issues.push({
          expected: "string",
          code: "invalid_type",
          input: payload.value,
          inst
        });
        return payload;
      };
    });
    $ZodStringFormat2 = /* @__PURE__ */ $constructor2("$ZodStringFormat", (inst, def) => {
      $ZodCheckStringFormat2.init(inst, def);
      $ZodString2.init(inst, def);
    });
    $ZodGUID2 = /* @__PURE__ */ $constructor2("$ZodGUID", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = guid3;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodUUID2 = /* @__PURE__ */ $constructor2("$ZodUUID", (inst, def) => {
      var _a37, _b27;
      if (def.version) {
        const versionMap = {
          v1: 1,
          v2: 2,
          v3: 3,
          v4: 4,
          v5: 5,
          v6: 6,
          v7: 7,
          v8: 8
        };
        const v = versionMap[def.version];
        if (v === void 0)
          throw new Error(`Invalid UUID version: "${def.version}"`);
        (_a37 = def.pattern) != null ? _a37 : def.pattern = uuid3(v);
      } else
        (_b27 = def.pattern) != null ? _b27 : def.pattern = uuid3();
      $ZodStringFormat2.init(inst, def);
    });
    $ZodEmail2 = /* @__PURE__ */ $constructor2("$ZodEmail", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = email3;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodURL2 = /* @__PURE__ */ $constructor2("$ZodURL", (inst, def) => {
      $ZodStringFormat2.init(inst, def);
      inst._zod.check = (payload) => {
        try {
          const trimmed = payload.value.trim();
          const url22 = new URL(trimmed);
          if (def.hostname) {
            def.hostname.lastIndex = 0;
            if (!def.hostname.test(url22.hostname)) {
              payload.issues.push({
                code: "invalid_format",
                format: "url",
                note: "Invalid hostname",
                pattern: def.hostname.source,
                input: payload.value,
                inst,
                continue: !def.abort
              });
            }
          }
          if (def.protocol) {
            def.protocol.lastIndex = 0;
            if (!def.protocol.test(url22.protocol.endsWith(":") ? url22.protocol.slice(0, -1) : url22.protocol)) {
              payload.issues.push({
                code: "invalid_format",
                format: "url",
                note: "Invalid protocol",
                pattern: def.protocol.source,
                input: payload.value,
                inst,
                continue: !def.abort
              });
            }
          }
          if (def.normalize) {
            payload.value = url22.href;
          } else {
            payload.value = trimmed;
          }
          return;
        } catch (_) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodEmoji2 = /* @__PURE__ */ $constructor2("$ZodEmoji", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = emoji3();
      $ZodStringFormat2.init(inst, def);
    });
    $ZodNanoID2 = /* @__PURE__ */ $constructor2("$ZodNanoID", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = nanoid3;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodCUID3 = /* @__PURE__ */ $constructor2("$ZodCUID", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = cuid4;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodCUID22 = /* @__PURE__ */ $constructor2("$ZodCUID2", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = cuid23;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodULID2 = /* @__PURE__ */ $constructor2("$ZodULID", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = ulid3;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodXID2 = /* @__PURE__ */ $constructor2("$ZodXID", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = xid3;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodKSUID2 = /* @__PURE__ */ $constructor2("$ZodKSUID", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = ksuid3;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodISODateTime2 = /* @__PURE__ */ $constructor2("$ZodISODateTime", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = datetime3(def);
      $ZodStringFormat2.init(inst, def);
    });
    $ZodISODate2 = /* @__PURE__ */ $constructor2("$ZodISODate", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = date5;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodISOTime2 = /* @__PURE__ */ $constructor2("$ZodISOTime", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = time3(def);
      $ZodStringFormat2.init(inst, def);
    });
    $ZodISODuration2 = /* @__PURE__ */ $constructor2("$ZodISODuration", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = duration3;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodIPv42 = /* @__PURE__ */ $constructor2("$ZodIPv4", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = ipv43;
      $ZodStringFormat2.init(inst, def);
      inst._zod.bag.format = `ipv4`;
    });
    $ZodIPv62 = /* @__PURE__ */ $constructor2("$ZodIPv6", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = ipv63;
      $ZodStringFormat2.init(inst, def);
      inst._zod.bag.format = `ipv6`;
      inst._zod.check = (payload) => {
        try {
          new URL(`http://[${payload.value}]`);
        } catch (e) {
          payload.issues.push({
            code: "invalid_format",
            format: "ipv6",
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodMAC2 = /* @__PURE__ */ $constructor2("$ZodMAC", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = mac3(def.delimiter);
      $ZodStringFormat2.init(inst, def);
      inst._zod.bag.format = `mac`;
    });
    $ZodCIDRv42 = /* @__PURE__ */ $constructor2("$ZodCIDRv4", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = cidrv43;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodCIDRv62 = /* @__PURE__ */ $constructor2("$ZodCIDRv6", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = cidrv63;
      $ZodStringFormat2.init(inst, def);
      inst._zod.check = (payload) => {
        const parts = payload.value.split("/");
        try {
          if (parts.length !== 2)
            throw new Error();
          const [address, prefix] = parts;
          if (!prefix)
            throw new Error();
          const prefixNum = Number(prefix);
          if (`${prefixNum}` !== prefix)
            throw new Error();
          if (prefixNum < 0 || prefixNum > 128)
            throw new Error();
          new URL(`http://[${address}]`);
        } catch (e) {
          payload.issues.push({
            code: "invalid_format",
            format: "cidrv6",
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    $ZodBase642 = /* @__PURE__ */ $constructor2("$ZodBase64", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = base643;
      $ZodStringFormat2.init(inst, def);
      inst._zod.bag.contentEncoding = "base64";
      inst._zod.check = (payload) => {
        if (isValidBase642(payload.value))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: "base64",
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodBase64URL2 = /* @__PURE__ */ $constructor2("$ZodBase64URL", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = base64url3;
      $ZodStringFormat2.init(inst, def);
      inst._zod.bag.contentEncoding = "base64url";
      inst._zod.check = (payload) => {
        if (isValidBase64URL2(payload.value))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: "base64url",
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodE1642 = /* @__PURE__ */ $constructor2("$ZodE164", (inst, def) => {
      var _a37;
      (_a37 = def.pattern) != null ? _a37 : def.pattern = e1643;
      $ZodStringFormat2.init(inst, def);
    });
    $ZodJWT2 = /* @__PURE__ */ $constructor2("$ZodJWT", (inst, def) => {
      $ZodStringFormat2.init(inst, def);
      inst._zod.check = (payload) => {
        if (isValidJWT3(payload.value, def.alg))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: "jwt",
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodCustomStringFormat2 = /* @__PURE__ */ $constructor2("$ZodCustomStringFormat", (inst, def) => {
      $ZodStringFormat2.init(inst, def);
      inst._zod.check = (payload) => {
        if (def.fn(payload.value))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: def.format,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    $ZodNumber2 = /* @__PURE__ */ $constructor2("$ZodNumber", (inst, def) => {
      var _a37;
      $ZodType2.init(inst, def);
      inst._zod.pattern = (_a37 = inst._zod.bag.pattern) != null ? _a37 : number4;
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce)
          try {
            payload.value = Number(payload.value);
          } catch (_) {
          }
        const input = payload.value;
        if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
          return payload;
        }
        const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
        payload.issues.push({
          expected: "number",
          code: "invalid_type",
          input,
          inst,
          ...received ? { received } : {}
        });
        return payload;
      };
    });
    $ZodNumberFormat2 = /* @__PURE__ */ $constructor2("$ZodNumberFormat", (inst, def) => {
      $ZodCheckNumberFormat2.init(inst, def);
      $ZodNumber2.init(inst, def);
    });
    $ZodBoolean2 = /* @__PURE__ */ $constructor2("$ZodBoolean", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.pattern = boolean4;
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce)
          try {
            payload.value = Boolean(payload.value);
          } catch (_) {
          }
        const input = payload.value;
        if (typeof input === "boolean")
          return payload;
        payload.issues.push({
          expected: "boolean",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodBigInt2 = /* @__PURE__ */ $constructor2("$ZodBigInt", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.pattern = bigint4;
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce)
          try {
            payload.value = BigInt(payload.value);
          } catch (_) {
          }
        if (typeof payload.value === "bigint")
          return payload;
        payload.issues.push({
          expected: "bigint",
          code: "invalid_type",
          input: payload.value,
          inst
        });
        return payload;
      };
    });
    $ZodBigIntFormat2 = /* @__PURE__ */ $constructor2("$ZodBigIntFormat", (inst, def) => {
      $ZodCheckBigIntFormat2.init(inst, def);
      $ZodBigInt2.init(inst, def);
    });
    $ZodSymbol2 = /* @__PURE__ */ $constructor2("$ZodSymbol", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (typeof input === "symbol")
          return payload;
        payload.issues.push({
          expected: "symbol",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodUndefined2 = /* @__PURE__ */ $constructor2("$ZodUndefined", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.pattern = _undefined4;
      inst._zod.values = /* @__PURE__ */ new Set([void 0]);
      inst._zod.optin = "optional";
      inst._zod.optout = "optional";
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (typeof input === "undefined")
          return payload;
        payload.issues.push({
          expected: "undefined",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodNull2 = /* @__PURE__ */ $constructor2("$ZodNull", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.pattern = _null4;
      inst._zod.values = /* @__PURE__ */ new Set([null]);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (input === null)
          return payload;
        payload.issues.push({
          expected: "null",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodAny2 = /* @__PURE__ */ $constructor2("$ZodAny", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload) => payload;
    });
    $ZodUnknown2 = /* @__PURE__ */ $constructor2("$ZodUnknown", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload) => payload;
    });
    $ZodNever2 = /* @__PURE__ */ $constructor2("$ZodNever", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        payload.issues.push({
          expected: "never",
          code: "invalid_type",
          input: payload.value,
          inst
        });
        return payload;
      };
    });
    $ZodVoid2 = /* @__PURE__ */ $constructor2("$ZodVoid", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (typeof input === "undefined")
          return payload;
        payload.issues.push({
          expected: "void",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodDate2 = /* @__PURE__ */ $constructor2("$ZodDate", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce) {
          try {
            payload.value = new Date(payload.value);
          } catch (_err) {
          }
        }
        const input = payload.value;
        const isDate2 = input instanceof Date;
        const isValidDate = isDate2 && !Number.isNaN(input.getTime());
        if (isValidDate)
          return payload;
        payload.issues.push({
          expected: "date",
          code: "invalid_type",
          input,
          ...isDate2 ? { received: "Invalid Date" } : {},
          inst
        });
        return payload;
      };
    });
    $ZodArray2 = /* @__PURE__ */ $constructor2("$ZodArray", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!Array.isArray(input)) {
          payload.issues.push({
            expected: "array",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        payload.value = Array(input.length);
        const proms = [];
        for (let i = 0; i < input.length; i++) {
          const item = input[i];
          const result = def.element._zod.run({
            value: item,
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => handleArrayResult2(result2, payload, i)));
          } else {
            handleArrayResult2(result, payload, i);
          }
        }
        if (proms.length) {
          return Promise.all(proms).then(() => payload);
        }
        return payload;
      };
    });
    $ZodObject2 = /* @__PURE__ */ $constructor2("$ZodObject", (inst, def) => {
      $ZodType2.init(inst, def);
      const desc = Object.getOwnPropertyDescriptor(def, "shape");
      if (!(desc == null ? void 0 : desc.get)) {
        const sh = def.shape;
        Object.defineProperty(def, "shape", {
          get: () => {
            const newSh = { ...sh };
            Object.defineProperty(def, "shape", {
              value: newSh
            });
            return newSh;
          }
        });
      }
      const _normalized = cached2(() => normalizeDef2(def));
      defineLazy2(inst._zod, "propValues", () => {
        var _a37;
        const shape = def.shape;
        const propValues = {};
        for (const key in shape) {
          const field = shape[key]._zod;
          if (field.values) {
            (_a37 = propValues[key]) != null ? _a37 : propValues[key] = /* @__PURE__ */ new Set();
            for (const v of field.values)
              propValues[key].add(v);
          }
        }
        return propValues;
      });
      const isObject22 = isObject4;
      const catchall = def.catchall;
      let value;
      inst._zod.parse = (payload, ctx) => {
        value != null ? value : value = _normalized.value;
        const input = payload.value;
        if (!isObject22(input)) {
          payload.issues.push({
            expected: "object",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        payload.value = {};
        const proms = [];
        const shape = value.shape;
        for (const key of value.keys) {
          const el = shape[key];
          const isOptionalOut = el._zod.optout === "optional";
          const r = el._zod.run({ value: input[key], issues: [] }, ctx);
          if (r instanceof Promise) {
            proms.push(r.then((r2) => handlePropertyResult2(r2, payload, key, input, isOptionalOut)));
          } else {
            handlePropertyResult2(r, payload, key, input, isOptionalOut);
          }
        }
        if (!catchall) {
          return proms.length ? Promise.all(proms).then(() => payload) : payload;
        }
        return handleCatchall2(proms, input, payload, ctx, _normalized.value, inst);
      };
    });
    $ZodObjectJIT2 = /* @__PURE__ */ $constructor2("$ZodObjectJIT", (inst, def) => {
      $ZodObject2.init(inst, def);
      const superParse = inst._zod.parse;
      const _normalized = cached2(() => normalizeDef2(def));
      const generateFastpass = (shape) => {
        var _a37;
        const doc = new Doc2(["shape", "payload", "ctx"]);
        const normalized = _normalized.value;
        const parseStr = (key) => {
          const k = esc2(key);
          return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
        };
        doc.write(`const input = payload.value;`);
        const ids = /* @__PURE__ */ Object.create(null);
        let counter = 0;
        for (const key of normalized.keys) {
          ids[key] = `key_${counter++}`;
        }
        doc.write(`const newResult = {};`);
        for (const key of normalized.keys) {
          const id = ids[key];
          const k = esc2(key);
          const schema = shape[key];
          const isOptionalOut = ((_a37 = schema == null ? void 0 : schema._zod) == null ? void 0 : _a37.optout) === "optional";
          doc.write(`const ${id} = ${parseStr(key)};`);
          if (isOptionalOut) {
            doc.write(`
        if (${id}.issues.length) {
          if (${k} in input) {
            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
              ...iss,
              path: iss.path ? [${k}, ...iss.path] : [${k}]
            })));
          }
        }
        
        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }
        
      `);
          } else {
            doc.write(`
        if (${id}.issues.length) {
          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
            ...iss,
            path: iss.path ? [${k}, ...iss.path] : [${k}]
          })));
        }
        
        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }
        
      `);
          }
        }
        doc.write(`payload.value = newResult;`);
        doc.write(`return payload;`);
        const fn = doc.compile();
        return (payload, ctx) => fn(shape, payload, ctx);
      };
      let fastpass;
      const isObject22 = isObject4;
      const jit = !globalConfig2.jitless;
      const allowsEval22 = allowsEval2;
      const fastEnabled = jit && allowsEval22.value;
      const catchall = def.catchall;
      let value;
      inst._zod.parse = (payload, ctx) => {
        value != null ? value : value = _normalized.value;
        const input = payload.value;
        if (!isObject22(input)) {
          payload.issues.push({
            expected: "object",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        if (jit && fastEnabled && (ctx == null ? void 0 : ctx.async) === false && ctx.jitless !== true) {
          if (!fastpass)
            fastpass = generateFastpass(def.shape);
          payload = fastpass(payload, ctx);
          if (!catchall)
            return payload;
          return handleCatchall2([], input, payload, ctx, value, inst);
        }
        return superParse(payload, ctx);
      };
    });
    $ZodUnion2 = /* @__PURE__ */ $constructor2("$ZodUnion", (inst, def) => {
      $ZodType2.init(inst, def);
      defineLazy2(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
      defineLazy2(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
      defineLazy2(inst._zod, "values", () => {
        if (def.options.every((o) => o._zod.values)) {
          return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
        }
        return void 0;
      });
      defineLazy2(inst._zod, "pattern", () => {
        if (def.options.every((o) => o._zod.pattern)) {
          const patterns = def.options.map((o) => o._zod.pattern);
          return new RegExp(`^(${patterns.map((p3) => cleanRegex2(p3.source)).join("|")})$`);
        }
        return void 0;
      });
      const single = def.options.length === 1;
      const first = def.options[0]._zod.run;
      inst._zod.parse = (payload, ctx) => {
        if (single) {
          return first(payload, ctx);
        }
        let async = false;
        const results = [];
        for (const option of def.options) {
          const result = option._zod.run({
            value: payload.value,
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            results.push(result);
            async = true;
          } else {
            if (result.issues.length === 0)
              return result;
            results.push(result);
          }
        }
        if (!async)
          return handleUnionResults2(results, payload, inst, ctx);
        return Promise.all(results).then((results2) => {
          return handleUnionResults2(results2, payload, inst, ctx);
        });
      };
    });
    $ZodXor2 = /* @__PURE__ */ $constructor2("$ZodXor", (inst, def) => {
      $ZodUnion2.init(inst, def);
      def.inclusive = false;
      const single = def.options.length === 1;
      const first = def.options[0]._zod.run;
      inst._zod.parse = (payload, ctx) => {
        if (single) {
          return first(payload, ctx);
        }
        let async = false;
        const results = [];
        for (const option of def.options) {
          const result = option._zod.run({
            value: payload.value,
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            results.push(result);
            async = true;
          } else {
            results.push(result);
          }
        }
        if (!async)
          return handleExclusiveUnionResults2(results, payload, inst, ctx);
        return Promise.all(results).then((results2) => {
          return handleExclusiveUnionResults2(results2, payload, inst, ctx);
        });
      };
    });
    $ZodDiscriminatedUnion2 = /* @__PURE__ */ $constructor2("$ZodDiscriminatedUnion", (inst, def) => {
      def.inclusive = false;
      $ZodUnion2.init(inst, def);
      const _super = inst._zod.parse;
      defineLazy2(inst._zod, "propValues", () => {
        const propValues = {};
        for (const option of def.options) {
          const pv = option._zod.propValues;
          if (!pv || Object.keys(pv).length === 0)
            throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
          for (const [k, v] of Object.entries(pv)) {
            if (!propValues[k])
              propValues[k] = /* @__PURE__ */ new Set();
            for (const val of v) {
              propValues[k].add(val);
            }
          }
        }
        return propValues;
      });
      const disc = cached2(() => {
        var _a37;
        const opts = def.options;
        const map22 = /* @__PURE__ */ new Map();
        for (const o of opts) {
          const values = (_a37 = o._zod.propValues) == null ? void 0 : _a37[def.discriminator];
          if (!values || values.size === 0)
            throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
          for (const v of values) {
            if (map22.has(v)) {
              throw new Error(`Duplicate discriminator value "${String(v)}"`);
            }
            map22.set(v, o);
          }
        }
        return map22;
      });
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!isObject4(input)) {
          payload.issues.push({
            code: "invalid_type",
            expected: "object",
            input,
            inst
          });
          return payload;
        }
        const opt = disc.value.get(input == null ? void 0 : input[def.discriminator]);
        if (opt) {
          return opt._zod.run(payload, ctx);
        }
        if (def.unionFallback) {
          return _super(payload, ctx);
        }
        payload.issues.push({
          code: "invalid_union",
          errors: [],
          note: "No matching discriminator",
          discriminator: def.discriminator,
          input,
          path: [def.discriminator],
          inst
        });
        return payload;
      };
    });
    $ZodIntersection2 = /* @__PURE__ */ $constructor2("$ZodIntersection", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        const left = def.left._zod.run({ value: input, issues: [] }, ctx);
        const right = def.right._zod.run({ value: input, issues: [] }, ctx);
        const async = left instanceof Promise || right instanceof Promise;
        if (async) {
          return Promise.all([left, right]).then(([left2, right2]) => {
            return handleIntersectionResults2(payload, left2, right2);
          });
        }
        return handleIntersectionResults2(payload, left, right);
      };
    });
    $ZodTuple2 = /* @__PURE__ */ $constructor2("$ZodTuple", (inst, def) => {
      $ZodType2.init(inst, def);
      const items = def.items;
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!Array.isArray(input)) {
          payload.issues.push({
            input,
            inst,
            expected: "tuple",
            code: "invalid_type"
          });
          return payload;
        }
        payload.value = [];
        const proms = [];
        const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
        const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
        if (!def.rest) {
          const tooBig = input.length > items.length;
          const tooSmall = input.length < optStart - 1;
          if (tooBig || tooSmall) {
            payload.issues.push({
              ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
              input,
              inst,
              origin: "array"
            });
            return payload;
          }
        }
        let i = -1;
        for (const item of items) {
          i++;
          if (i >= input.length) {
            if (i >= optStart)
              continue;
          }
          const result = item._zod.run({
            value: input[i],
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => handleTupleResult2(result2, payload, i)));
          } else {
            handleTupleResult2(result, payload, i);
          }
        }
        if (def.rest) {
          const rest = input.slice(items.length);
          for (const el of rest) {
            i++;
            const result = def.rest._zod.run({
              value: el,
              issues: []
            }, ctx);
            if (result instanceof Promise) {
              proms.push(result.then((result2) => handleTupleResult2(result2, payload, i)));
            } else {
              handleTupleResult2(result, payload, i);
            }
          }
        }
        if (proms.length)
          return Promise.all(proms).then(() => payload);
        return payload;
      };
    });
    $ZodRecord2 = /* @__PURE__ */ $constructor2("$ZodRecord", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!isPlainObject3(input)) {
          payload.issues.push({
            expected: "record",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        const proms = [];
        const values = def.keyType._zod.values;
        if (values) {
          payload.value = {};
          const recordKeys = /* @__PURE__ */ new Set();
          for (const key of values) {
            if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
              recordKeys.add(typeof key === "number" ? key.toString() : key);
              const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
              if (result instanceof Promise) {
                proms.push(result.then((result2) => {
                  if (result2.issues.length) {
                    payload.issues.push(...prefixIssues2(key, result2.issues));
                  }
                  payload.value[key] = result2.value;
                }));
              } else {
                if (result.issues.length) {
                  payload.issues.push(...prefixIssues2(key, result.issues));
                }
                payload.value[key] = result.value;
              }
            }
          }
          let unrecognized;
          for (const key in input) {
            if (!recordKeys.has(key)) {
              unrecognized = unrecognized != null ? unrecognized : [];
              unrecognized.push(key);
            }
          }
          if (unrecognized && unrecognized.length > 0) {
            payload.issues.push({
              code: "unrecognized_keys",
              input,
              inst,
              keys: unrecognized
            });
          }
        } else {
          payload.value = {};
          for (const key of Reflect.ownKeys(input)) {
            if (key === "__proto__")
              continue;
            let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
            if (keyResult instanceof Promise) {
              throw new Error("Async schemas not supported in object keys currently");
            }
            const checkNumericKey = typeof key === "string" && number4.test(key) && keyResult.issues.length && keyResult.issues.some((iss) => iss.code === "invalid_type" && iss.expected === "number");
            if (checkNumericKey) {
              const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
              if (retryResult instanceof Promise) {
                throw new Error("Async schemas not supported in object keys currently");
              }
              if (retryResult.issues.length === 0) {
                keyResult = retryResult;
              }
            }
            if (keyResult.issues.length) {
              if (def.mode === "loose") {
                payload.value[key] = input[key];
              } else {
                payload.issues.push({
                  code: "invalid_key",
                  origin: "record",
                  issues: keyResult.issues.map((iss) => finalizeIssue2(iss, ctx, config2())),
                  input: key,
                  path: [key],
                  inst
                });
              }
              continue;
            }
            const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
            if (result instanceof Promise) {
              proms.push(result.then((result2) => {
                if (result2.issues.length) {
                  payload.issues.push(...prefixIssues2(key, result2.issues));
                }
                payload.value[keyResult.value] = result2.value;
              }));
            } else {
              if (result.issues.length) {
                payload.issues.push(...prefixIssues2(key, result.issues));
              }
              payload.value[keyResult.value] = result.value;
            }
          }
        }
        if (proms.length) {
          return Promise.all(proms).then(() => payload);
        }
        return payload;
      };
    });
    $ZodMap2 = /* @__PURE__ */ $constructor2("$ZodMap", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!(input instanceof Map)) {
          payload.issues.push({
            expected: "map",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        const proms = [];
        payload.value = /* @__PURE__ */ new Map();
        for (const [key, value] of input) {
          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
          const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
          if (keyResult instanceof Promise || valueResult instanceof Promise) {
            proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
              handleMapResult2(keyResult2, valueResult2, payload, key, input, inst, ctx);
            }));
          } else {
            handleMapResult2(keyResult, valueResult, payload, key, input, inst, ctx);
          }
        }
        if (proms.length)
          return Promise.all(proms).then(() => payload);
        return payload;
      };
    });
    $ZodSet2 = /* @__PURE__ */ $constructor2("$ZodSet", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!(input instanceof Set)) {
          payload.issues.push({
            input,
            inst,
            expected: "set",
            code: "invalid_type"
          });
          return payload;
        }
        const proms = [];
        payload.value = /* @__PURE__ */ new Set();
        for (const item of input) {
          const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => handleSetResult2(result2, payload)));
          } else
            handleSetResult2(result, payload);
        }
        if (proms.length)
          return Promise.all(proms).then(() => payload);
        return payload;
      };
    });
    $ZodEnum2 = /* @__PURE__ */ $constructor2("$ZodEnum", (inst, def) => {
      $ZodType2.init(inst, def);
      const values = getEnumValues2(def.entries);
      const valuesSet = new Set(values);
      inst._zod.values = valuesSet;
      inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes2.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex2(o) : o.toString()).join("|")})$`);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (valuesSet.has(input)) {
          return payload;
        }
        payload.issues.push({
          code: "invalid_value",
          values,
          input,
          inst
        });
        return payload;
      };
    });
    $ZodLiteral2 = /* @__PURE__ */ $constructor2("$ZodLiteral", (inst, def) => {
      $ZodType2.init(inst, def);
      if (def.values.length === 0) {
        throw new Error("Cannot create literal schema with no valid values");
      }
      const values = new Set(def.values);
      inst._zod.values = values;
      inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex2(o) : o ? escapeRegex2(o.toString()) : String(o)).join("|")})$`);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (values.has(input)) {
          return payload;
        }
        payload.issues.push({
          code: "invalid_value",
          values: def.values,
          input,
          inst
        });
        return payload;
      };
    });
    $ZodFile2 = /* @__PURE__ */ $constructor2("$ZodFile", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (input instanceof File)
          return payload;
        payload.issues.push({
          expected: "file",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    $ZodTransform2 = /* @__PURE__ */ $constructor2("$ZodTransform", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          throw new $ZodEncodeError2(inst.constructor.name);
        }
        const _out = def.transform(payload.value, payload);
        if (ctx.async) {
          const output = _out instanceof Promise ? _out : Promise.resolve(_out);
          return output.then((output2) => {
            payload.value = output2;
            return payload;
          });
        }
        if (_out instanceof Promise) {
          throw new $ZodAsyncError2();
        }
        payload.value = _out;
        return payload;
      };
    });
    $ZodOptional2 = /* @__PURE__ */ $constructor2("$ZodOptional", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.optin = "optional";
      inst._zod.optout = "optional";
      defineLazy2(inst._zod, "values", () => {
        return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
      });
      defineLazy2(inst._zod, "pattern", () => {
        const pattern = def.innerType._zod.pattern;
        return pattern ? new RegExp(`^(${cleanRegex2(pattern.source)})?$`) : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        if (def.innerType._zod.optin === "optional") {
          const result = def.innerType._zod.run(payload, ctx);
          if (result instanceof Promise)
            return result.then((r) => handleOptionalResult2(r, payload.value));
          return handleOptionalResult2(result, payload.value);
        }
        if (payload.value === void 0) {
          return payload;
        }
        return def.innerType._zod.run(payload, ctx);
      };
    });
    $ZodExactOptional2 = /* @__PURE__ */ $constructor2("$ZodExactOptional", (inst, def) => {
      $ZodOptional2.init(inst, def);
      defineLazy2(inst._zod, "values", () => def.innerType._zod.values);
      defineLazy2(inst._zod, "pattern", () => def.innerType._zod.pattern);
      inst._zod.parse = (payload, ctx) => {
        return def.innerType._zod.run(payload, ctx);
      };
    });
    $ZodNullable2 = /* @__PURE__ */ $constructor2("$ZodNullable", (inst, def) => {
      $ZodType2.init(inst, def);
      defineLazy2(inst._zod, "optin", () => def.innerType._zod.optin);
      defineLazy2(inst._zod, "optout", () => def.innerType._zod.optout);
      defineLazy2(inst._zod, "pattern", () => {
        const pattern = def.innerType._zod.pattern;
        return pattern ? new RegExp(`^(${cleanRegex2(pattern.source)}|null)$`) : void 0;
      });
      defineLazy2(inst._zod, "values", () => {
        return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        if (payload.value === null)
          return payload;
        return def.innerType._zod.run(payload, ctx);
      };
    });
    $ZodDefault2 = /* @__PURE__ */ $constructor2("$ZodDefault", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.optin = "optional";
      defineLazy2(inst._zod, "values", () => def.innerType._zod.values);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        if (payload.value === void 0) {
          payload.value = def.defaultValue;
          return payload;
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => handleDefaultResult2(result2, def));
        }
        return handleDefaultResult2(result, def);
      };
    });
    $ZodPrefault2 = /* @__PURE__ */ $constructor2("$ZodPrefault", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.optin = "optional";
      defineLazy2(inst._zod, "values", () => def.innerType._zod.values);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        if (payload.value === void 0) {
          payload.value = def.defaultValue;
        }
        return def.innerType._zod.run(payload, ctx);
      };
    });
    $ZodNonOptional2 = /* @__PURE__ */ $constructor2("$ZodNonOptional", (inst, def) => {
      $ZodType2.init(inst, def);
      defineLazy2(inst._zod, "values", () => {
        const v = def.innerType._zod.values;
        return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => handleNonOptionalResult2(result2, inst));
        }
        return handleNonOptionalResult2(result, inst);
      };
    });
    $ZodSuccess2 = /* @__PURE__ */ $constructor2("$ZodSuccess", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          throw new $ZodEncodeError2("ZodSuccess");
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => {
            payload.value = result2.issues.length === 0;
            return payload;
          });
        }
        payload.value = result.issues.length === 0;
        return payload;
      };
    });
    $ZodCatch2 = /* @__PURE__ */ $constructor2("$ZodCatch", (inst, def) => {
      $ZodType2.init(inst, def);
      defineLazy2(inst._zod, "optin", () => def.innerType._zod.optin);
      defineLazy2(inst._zod, "optout", () => def.innerType._zod.optout);
      defineLazy2(inst._zod, "values", () => def.innerType._zod.values);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => {
            payload.value = result2.value;
            if (result2.issues.length) {
              payload.value = def.catchValue({
                ...payload,
                error: {
                  issues: result2.issues.map((iss) => finalizeIssue2(iss, ctx, config2()))
                },
                input: payload.value
              });
              payload.issues = [];
            }
            return payload;
          });
        }
        payload.value = result.value;
        if (result.issues.length) {
          payload.value = def.catchValue({
            ...payload,
            error: {
              issues: result.issues.map((iss) => finalizeIssue2(iss, ctx, config2()))
            },
            input: payload.value
          });
          payload.issues = [];
        }
        return payload;
      };
    });
    $ZodNaN2 = /* @__PURE__ */ $constructor2("$ZodNaN", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
          payload.issues.push({
            input: payload.value,
            inst,
            expected: "nan",
            code: "invalid_type"
          });
          return payload;
        }
        return payload;
      };
    });
    $ZodPipe2 = /* @__PURE__ */ $constructor2("$ZodPipe", (inst, def) => {
      $ZodType2.init(inst, def);
      defineLazy2(inst._zod, "values", () => def.in._zod.values);
      defineLazy2(inst._zod, "optin", () => def.in._zod.optin);
      defineLazy2(inst._zod, "optout", () => def.out._zod.optout);
      defineLazy2(inst._zod, "propValues", () => def.in._zod.propValues);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          const right = def.out._zod.run(payload, ctx);
          if (right instanceof Promise) {
            return right.then((right2) => handlePipeResult2(right2, def.in, ctx));
          }
          return handlePipeResult2(right, def.in, ctx);
        }
        const left = def.in._zod.run(payload, ctx);
        if (left instanceof Promise) {
          return left.then((left2) => handlePipeResult2(left2, def.out, ctx));
        }
        return handlePipeResult2(left, def.out, ctx);
      };
    });
    $ZodCodec2 = /* @__PURE__ */ $constructor2("$ZodCodec", (inst, def) => {
      $ZodType2.init(inst, def);
      defineLazy2(inst._zod, "values", () => def.in._zod.values);
      defineLazy2(inst._zod, "optin", () => def.in._zod.optin);
      defineLazy2(inst._zod, "optout", () => def.out._zod.optout);
      defineLazy2(inst._zod, "propValues", () => def.in._zod.propValues);
      inst._zod.parse = (payload, ctx) => {
        const direction = ctx.direction || "forward";
        if (direction === "forward") {
          const left = def.in._zod.run(payload, ctx);
          if (left instanceof Promise) {
            return left.then((left2) => handleCodecAResult2(left2, def, ctx));
          }
          return handleCodecAResult2(left, def, ctx);
        } else {
          const right = def.out._zod.run(payload, ctx);
          if (right instanceof Promise) {
            return right.then((right2) => handleCodecAResult2(right2, def, ctx));
          }
          return handleCodecAResult2(right, def, ctx);
        }
      };
    });
    $ZodReadonly2 = /* @__PURE__ */ $constructor2("$ZodReadonly", (inst, def) => {
      $ZodType2.init(inst, def);
      defineLazy2(inst._zod, "propValues", () => def.innerType._zod.propValues);
      defineLazy2(inst._zod, "values", () => def.innerType._zod.values);
      defineLazy2(inst._zod, "optin", () => {
        var _a37, _b27;
        return (_b27 = (_a37 = def.innerType) == null ? void 0 : _a37._zod) == null ? void 0 : _b27.optin;
      });
      defineLazy2(inst._zod, "optout", () => {
        var _a37, _b27;
        return (_b27 = (_a37 = def.innerType) == null ? void 0 : _a37._zod) == null ? void 0 : _b27.optout;
      });
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then(handleReadonlyResult2);
        }
        return handleReadonlyResult2(result);
      };
    });
    $ZodTemplateLiteral2 = /* @__PURE__ */ $constructor2("$ZodTemplateLiteral", (inst, def) => {
      $ZodType2.init(inst, def);
      const regexParts = [];
      for (const part of def.parts) {
        if (typeof part === "object" && part !== null) {
          if (!part._zod.pattern) {
            throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
          }
          const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
          if (!source)
            throw new Error(`Invalid template literal part: ${part._zod.traits}`);
          const start = source.startsWith("^") ? 1 : 0;
          const end = source.endsWith("$") ? source.length - 1 : source.length;
          regexParts.push(source.slice(start, end));
        } else if (part === null || primitiveTypes2.has(typeof part)) {
          regexParts.push(escapeRegex2(`${part}`));
        } else {
          throw new Error(`Invalid template literal part: ${part}`);
        }
      }
      inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
      inst._zod.parse = (payload, _ctx) => {
        var _a37;
        if (typeof payload.value !== "string") {
          payload.issues.push({
            input: payload.value,
            inst,
            expected: "string",
            code: "invalid_type"
          });
          return payload;
        }
        inst._zod.pattern.lastIndex = 0;
        if (!inst._zod.pattern.test(payload.value)) {
          payload.issues.push({
            input: payload.value,
            inst,
            code: "invalid_format",
            format: (_a37 = def.format) != null ? _a37 : "template_literal",
            pattern: inst._zod.pattern.source
          });
          return payload;
        }
        return payload;
      };
    });
    $ZodFunction2 = /* @__PURE__ */ $constructor2("$ZodFunction", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._def = def;
      inst._zod.def = def;
      inst.implement = (func) => {
        if (typeof func !== "function") {
          throw new Error("implement() must be called with a function");
        }
        return function(...args) {
          const parsedArgs = inst._def.input ? parse3(inst._def.input, args) : args;
          const result = Reflect.apply(func, this, parsedArgs);
          if (inst._def.output) {
            return parse3(inst._def.output, result);
          }
          return result;
        };
      };
      inst.implementAsync = (func) => {
        if (typeof func !== "function") {
          throw new Error("implementAsync() must be called with a function");
        }
        return async function(...args) {
          const parsedArgs = inst._def.input ? await parseAsync3(inst._def.input, args) : args;
          const result = await Reflect.apply(func, this, parsedArgs);
          if (inst._def.output) {
            return await parseAsync3(inst._def.output, result);
          }
          return result;
        };
      };
      inst._zod.parse = (payload, _ctx) => {
        if (typeof payload.value !== "function") {
          payload.issues.push({
            code: "invalid_type",
            expected: "function",
            input: payload.value,
            inst
          });
          return payload;
        }
        const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise";
        if (hasPromiseOutput) {
          payload.value = inst.implementAsync(payload.value);
        } else {
          payload.value = inst.implement(payload.value);
        }
        return payload;
      };
      inst.input = (...args) => {
        const F = inst.constructor;
        if (Array.isArray(args[0])) {
          return new F({
            type: "function",
            input: new $ZodTuple2({
              type: "tuple",
              items: args[0],
              rest: args[1]
            }),
            output: inst._def.output
          });
        }
        return new F({
          type: "function",
          input: args[0],
          output: inst._def.output
        });
      };
      inst.output = (output) => {
        const F = inst.constructor;
        return new F({
          type: "function",
          input: inst._def.input,
          output
        });
      };
      return inst;
    });
    $ZodPromise2 = /* @__PURE__ */ $constructor2("$ZodPromise", (inst, def) => {
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
      };
    });
    $ZodLazy2 = /* @__PURE__ */ $constructor2("$ZodLazy", (inst, def) => {
      $ZodType2.init(inst, def);
      defineLazy2(inst._zod, "innerType", () => def.getter());
      defineLazy2(inst._zod, "pattern", () => {
        var _a37, _b27;
        return (_b27 = (_a37 = inst._zod.innerType) == null ? void 0 : _a37._zod) == null ? void 0 : _b27.pattern;
      });
      defineLazy2(inst._zod, "propValues", () => {
        var _a37, _b27;
        return (_b27 = (_a37 = inst._zod.innerType) == null ? void 0 : _a37._zod) == null ? void 0 : _b27.propValues;
      });
      defineLazy2(inst._zod, "optin", () => {
        var _a37, _b27, _c;
        return (_c = (_b27 = (_a37 = inst._zod.innerType) == null ? void 0 : _a37._zod) == null ? void 0 : _b27.optin) != null ? _c : void 0;
      });
      defineLazy2(inst._zod, "optout", () => {
        var _a37, _b27, _c;
        return (_c = (_b27 = (_a37 = inst._zod.innerType) == null ? void 0 : _a37._zod) == null ? void 0 : _b27.optout) != null ? _c : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        const inner = inst._zod.innerType;
        return inner._zod.run(payload, ctx);
      };
    });
    $ZodCustom2 = /* @__PURE__ */ $constructor2("$ZodCustom", (inst, def) => {
      $ZodCheck2.init(inst, def);
      $ZodType2.init(inst, def);
      inst._zod.parse = (payload, _) => {
        return payload;
      };
      inst._zod.check = (payload) => {
        const input = payload.value;
        const r = def.fn(input);
        if (r instanceof Promise) {
          return r.then((r2) => handleRefineResult2(r2, payload, input, inst));
        }
        handleRefineResult2(r, payload, input, inst);
        return;
      };
    });
    locales_exports2 = {};
    __export2(locales_exports2, {
      ar: () => ar_default2,
      az: () => az_default2,
      be: () => be_default2,
      bg: () => bg_default2,
      ca: () => ca_default2,
      cs: () => cs_default2,
      da: () => da_default2,
      de: () => de_default2,
      en: () => en_default3,
      eo: () => eo_default2,
      es: () => es_default2,
      fa: () => fa_default2,
      fi: () => fi_default2,
      fr: () => fr_default2,
      frCA: () => fr_CA_default2,
      he: () => he_default2,
      hu: () => hu_default2,
      hy: () => hy_default2,
      id: () => id_default2,
      is: () => is_default2,
      it: () => it_default2,
      ja: () => ja_default2,
      ka: () => ka_default2,
      kh: () => kh_default2,
      km: () => km_default2,
      ko: () => ko_default2,
      lt: () => lt_default2,
      mk: () => mk_default2,
      ms: () => ms_default2,
      nl: () => nl_default2,
      no: () => no_default2,
      ota: () => ota_default2,
      pl: () => pl_default2,
      ps: () => ps_default2,
      pt: () => pt_default2,
      ru: () => ru_default2,
      sl: () => sl_default2,
      sv: () => sv_default2,
      ta: () => ta_default2,
      th: () => th_default2,
      tr: () => tr_default2,
      ua: () => ua_default2,
      uk: () => uk_default2,
      ur: () => ur_default2,
      uz: () => uz_default2,
      vi: () => vi_default2,
      yo: () => yo_default2,
      zhCN: () => zh_CN_default2,
      zhTW: () => zh_TW_default2
    });
    error48 = () => {
      const Sizable = {
        string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
        file: { unit: "\u0628\u0627\u064A\u062A", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
        array: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
        set: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0645\u062F\u062E\u0644",
        email: "\u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A",
        url: "\u0631\u0627\u0628\u0637",
        emoji: "\u0625\u064A\u0645\u0648\u062C\u064A",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u062A\u0627\u0631\u064A\u062E \u0648\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        date: "\u062A\u0627\u0631\u064A\u062E \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        time: "\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        duration: "\u0645\u062F\u0629 \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        ipv4: "\u0639\u0646\u0648\u0627\u0646 IPv4",
        ipv6: "\u0639\u0646\u0648\u0627\u0646 IPv6",
        cidrv4: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv4",
        cidrv6: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv6",
        base64: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64-encoded",
        base64url: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64url-encoded",
        json_string: "\u0646\u064E\u0635 \u0639\u0644\u0649 \u0647\u064A\u0626\u0629 JSON",
        e164: "\u0631\u0642\u0645 \u0647\u0627\u062A\u0641 \u0628\u0645\u0639\u064A\u0627\u0631 E.164",
        jwt: "JWT",
        template_literal: "\u0645\u062F\u062E\u0644"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 instanceof ${issue22.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
            }
            return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u0627\u062E\u062A\u064A\u0627\u0631 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062A\u0648\u0642\u0639 \u0627\u0646\u062A\u0642\u0627\u0621 \u0623\u062D\u062F \u0647\u0630\u0647 \u0627\u0644\u062E\u064A\u0627\u0631\u0627\u062A: ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return ` \u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${(_c = issue22.origin) != null ? _c : "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0639\u0646\u0635\u0631"}`;
            return `\u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${(_e = issue22.origin) != null ? _e : "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue22.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue22.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0628\u062F\u0623 \u0628\u0640 "${issue22.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0646\u062A\u0647\u064A \u0628\u0640 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u062A\u0636\u0645\u0651\u064E\u0646 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0637\u0627\u0628\u0642 \u0627\u0644\u0646\u0645\u0637 ${_issue.pattern}`;
            return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`;
          }
          case "not_multiple_of":
            return `\u0631\u0642\u0645 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0645\u0646 \u0645\u0636\u0627\u0639\u0641\u0627\u062A ${issue22.divisor}`;
          case "unrecognized_keys":
            return `\u0645\u0639\u0631\u0641${issue22.keys.length > 1 ? "\u0627\u062A" : ""} \u063A\u0631\u064A\u0628${issue22.keys.length > 1 ? "\u0629" : ""}: ${joinValues2(issue22.keys, "\u060C ")}`;
          case "invalid_key":
            return `\u0645\u0639\u0631\u0641 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue22.origin}`;
          case "invalid_union":
            return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
          case "invalid_element":
            return `\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue22.origin}`;
          default:
            return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
        }
      };
    };
    error210 = () => {
      const Sizable = {
        string: { unit: "simvol", verb: "olmal\u0131d\u0131r" },
        file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
        array: { unit: "element", verb: "olmal\u0131d\u0131r" },
        set: { unit: "element", verb: "olmal\u0131d\u0131r" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "email address",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datetime",
        date: "ISO date",
        time: "ISO time",
        duration: "ISO duration",
        ipv4: "IPv4 address",
        ipv6: "IPv6 address",
        cidrv4: "IPv4 range",
        cidrv6: "IPv6 range",
        base64: "base64-encoded string",
        base64url: "base64url-encoded string",
        json_string: "JSON string",
        e164: "E.164 number",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n instanceof ${issue22.expected}, daxil olan ${received}`;
            }
            return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${expected}, daxil olan ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${stringifyPrimitive2(issue22.values[0])}`;
            return `Yanl\u0131\u015F se\xE7im: a\u015Fa\u011F\u0131dak\u0131lardan biri olmal\u0131d\u0131r: ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${(_c = issue22.origin) != null ? _c : "d\u0259y\u0259r"} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "element"}`;
            return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${(_e = issue22.origin) != null ? _e : "d\u0259y\u0259r"} ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue22.origin} ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue22.origin} ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Yanl\u0131\u015F m\u0259tn: "${_issue.prefix}" il\u0259 ba\u015Flamal\u0131d\u0131r`;
            if (_issue.format === "ends_with")
              return `Yanl\u0131\u015F m\u0259tn: "${_issue.suffix}" il\u0259 bitm\u0259lidir`;
            if (_issue.format === "includes")
              return `Yanl\u0131\u015F m\u0259tn: "${_issue.includes}" daxil olmal\u0131d\u0131r`;
            if (_issue.format === "regex")
              return `Yanl\u0131\u015F m\u0259tn: ${_issue.pattern} \u015Fablonuna uy\u011Fun olmal\u0131d\u0131r`;
            return `Yanl\u0131\u015F ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Yanl\u0131\u015F \u0259d\u0259d: ${issue22.divisor} il\u0259 b\xF6l\xFCn\u0259 bil\u0259n olmal\u0131d\u0131r`;
          case "unrecognized_keys":
            return `Tan\u0131nmayan a\xE7ar${issue22.keys.length > 1 ? "lar" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `${issue22.origin} daxilind\u0259 yanl\u0131\u015F a\xE7ar`;
          case "invalid_union":
            return "Yanl\u0131\u015F d\u0259y\u0259r";
          case "invalid_element":
            return `${issue22.origin} daxilind\u0259 yanl\u0131\u015F d\u0259y\u0259r`;
          default:
            return `Yanl\u0131\u015F d\u0259y\u0259r`;
        }
      };
    };
    error310 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "\u0441\u0456\u043C\u0432\u0430\u043B",
            few: "\u0441\u0456\u043C\u0432\u0430\u043B\u044B",
            many: "\u0441\u0456\u043C\u0432\u0430\u043B\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        },
        array: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        },
        set: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        },
        file: {
          unit: {
            one: "\u0431\u0430\u0439\u0442",
            few: "\u0431\u0430\u0439\u0442\u044B",
            many: "\u0431\u0430\u0439\u0442\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0443\u0432\u043E\u0434",
        email: "email \u0430\u0434\u0440\u0430\u0441",
        url: "URL",
        emoji: "\u044D\u043C\u043E\u0434\u0437\u0456",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0434\u0430\u0442\u0430 \u0456 \u0447\u0430\u0441",
        date: "ISO \u0434\u0430\u0442\u0430",
        time: "ISO \u0447\u0430\u0441",
        duration: "ISO \u043F\u0440\u0430\u0446\u044F\u0433\u043B\u0430\u0441\u0446\u044C",
        ipv4: "IPv4 \u0430\u0434\u0440\u0430\u0441",
        ipv6: "IPv6 \u0430\u0434\u0440\u0430\u0441",
        cidrv4: "IPv4 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
        cidrv6: "IPv6 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
        base64: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64",
        base64url: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64url",
        json_string: "JSON \u0440\u0430\u0434\u043E\u043A",
        e164: "\u043D\u0443\u043C\u0430\u0440 E.164",
        jwt: "JWT",
        template_literal: "\u0443\u0432\u043E\u0434"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u043B\u0456\u043A",
        array: "\u043C\u0430\u0441\u0456\u045E"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F instanceof ${issue22.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
            }
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0432\u0430\u0440\u044B\u044F\u043D\u0442: \u0447\u0430\u043A\u0430\u045E\u0441\u044F \u0430\u0434\u0437\u0456\u043D \u0437 ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              const maxValue = Number(issue22.maximum);
              const unit = getBelarusianPlural2(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${(_c = issue22.origin) != null ? _c : "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue22.maximum.toString()} ${unit}`;
            }
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${(_d = issue22.origin) != null ? _d : "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              const minValue = Number(issue22.minimum);
              const unit = getBelarusianPlural2(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue22.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue22.minimum.toString()} ${unit}`;
            }
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue22.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u043F\u0430\u0447\u044B\u043D\u0430\u0446\u0446\u0430 \u0437 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u0430\u043A\u0430\u043D\u0447\u0432\u0430\u0446\u0446\u0430 \u043D\u0430 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u043C\u044F\u0448\u0447\u0430\u0446\u044C "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0430\u0434\u043F\u0430\u0432\u044F\u0434\u0430\u0446\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043B\u0456\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0431\u044B\u0446\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue22.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u0430\u0441\u043F\u0430\u0437\u043D\u0430\u043D\u044B ${issue22.keys.length > 1 ? "\u043A\u043B\u044E\u0447\u044B" : "\u043A\u043B\u044E\u0447"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043A\u043B\u044E\u0447 \u0443 ${issue22.origin}`;
          case "invalid_union":
            return "\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434";
          case "invalid_element":
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u0430\u0435 \u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435 \u045E ${issue22.origin}`;
          default:
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434`;
        }
      };
    };
    error49 = () => {
      const Sizable = {
        string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
        file: { unit: "\u0431\u0430\u0439\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
        array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
        set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0432\u0445\u043E\u0434",
        email: "\u0438\u043C\u0435\u0439\u043B \u0430\u0434\u0440\u0435\u0441",
        url: "URL",
        emoji: "\u0435\u043C\u043E\u0434\u0436\u0438",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0432\u0440\u0435\u043C\u0435",
        date: "ISO \u0434\u0430\u0442\u0430",
        time: "ISO \u0432\u0440\u0435\u043C\u0435",
        duration: "ISO \u043F\u0440\u043E\u0434\u044A\u043B\u0436\u0438\u0442\u0435\u043B\u043D\u043E\u0441\u0442",
        ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
        ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
        cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        base64: "base64-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
        base64url: "base64url-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
        json_string: "JSON \u043D\u0438\u0437",
        e164: "E.164 \u043D\u043E\u043C\u0435\u0440",
        jwt: "JWT",
        template_literal: "\u0432\u0445\u043E\u0434"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0447\u0438\u0441\u043B\u043E",
        array: "\u043C\u0430\u0441\u0438\u0432"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D instanceof ${issue22.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
            }
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u043E\u043F\u0446\u0438\u044F: \u043E\u0447\u0430\u043A\u0432\u0430\u043D\u043E \u0435\u0434\u043D\u043E \u043E\u0442 ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${(_c = issue22.origin) != null ? _c : "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430"}`;
            return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${(_e = issue22.origin) != null ? _e : "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue22.origin} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue22.origin} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u0432\u0430 \u0441 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u0432\u044A\u0440\u0448\u0432\u0430 \u0441 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0432\u043A\u043B\u044E\u0447\u0432\u0430 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0441\u044A\u0432\u043F\u0430\u0434\u0430 \u0441 ${_issue.pattern}`;
            let invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D";
            if (_issue.format === "emoji")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
            if (_issue.format === "datetime")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
            if (_issue.format === "date")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
            if (_issue.format === "time")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
            if (_issue.format === "duration")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
            return `${invalid_adj} ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E \u0447\u0438\u0441\u043B\u043E: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0431\u044A\u0434\u0435 \u043A\u0440\u0430\u0442\u043D\u043E \u043D\u0430 ${issue22.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u0430\u0437\u043F\u043E\u0437\u043D\u0430\u0442${issue22.keys.length > 1 ? "\u0438" : ""} \u043A\u043B\u044E\u0447${issue22.keys.length > 1 ? "\u043E\u0432\u0435" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043A\u043B\u044E\u0447 \u0432 ${issue22.origin}`;
          case "invalid_union":
            return "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434";
          case "invalid_element":
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442 \u0432 ${issue22.origin}`;
          default:
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434`;
        }
      };
    };
    error52 = () => {
      const Sizable = {
        string: { unit: "car\xE0cters", verb: "contenir" },
        file: { unit: "bytes", verb: "contenir" },
        array: { unit: "elements", verb: "contenir" },
        set: { unit: "elements", verb: "contenir" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "entrada",
        email: "adre\xE7a electr\xF2nica",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data i hora ISO",
        date: "data ISO",
        time: "hora ISO",
        duration: "durada ISO",
        ipv4: "adre\xE7a IPv4",
        ipv6: "adre\xE7a IPv6",
        cidrv4: "rang IPv4",
        cidrv6: "rang IPv6",
        base64: "cadena codificada en base64",
        base64url: "cadena codificada en base64url",
        json_string: "cadena JSON",
        e164: "n\xFAmero E.164",
        jwt: "JWT",
        template_literal: "entrada"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Tipus inv\xE0lid: s'esperava instanceof ${issue22.expected}, s'ha rebut ${received}`;
            }
            return `Tipus inv\xE0lid: s'esperava ${expected}, s'ha rebut ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Valor inv\xE0lid: s'esperava ${stringifyPrimitive2(issue22.values[0])}`;
            return `Opci\xF3 inv\xE0lida: s'esperava una de ${joinValues2(issue22.values, " o ")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "com a m\xE0xim" : "menys de";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Massa gran: s'esperava que ${(_c = issue22.origin) != null ? _c : "el valor"} contingu\xE9s ${adj} ${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elements"}`;
            return `Massa gran: s'esperava que ${(_e = issue22.origin) != null ? _e : "el valor"} fos ${adj} ${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? "com a m\xEDnim" : "m\xE9s de";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Massa petit: s'esperava que ${issue22.origin} contingu\xE9s ${adj} ${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Massa petit: s'esperava que ${issue22.origin} fos ${adj} ${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `Format inv\xE0lid: ha de comen\xE7ar amb "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Format inv\xE0lid: ha d'acabar amb "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Format inv\xE0lid: ha d'incloure "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Format inv\xE0lid: ha de coincidir amb el patr\xF3 ${_issue.pattern}`;
            return `Format inv\xE0lid per a ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `N\xFAmero inv\xE0lid: ha de ser m\xFAltiple de ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Clau${issue22.keys.length > 1 ? "s" : ""} no reconeguda${issue22.keys.length > 1 ? "s" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Clau inv\xE0lida a ${issue22.origin}`;
          case "invalid_union":
            return "Entrada inv\xE0lida";
          // Could also be "Tipus d'unió invàlid" but "Entrada invàlida" is more general
          case "invalid_element":
            return `Element inv\xE0lid a ${issue22.origin}`;
          default:
            return `Entrada inv\xE0lida`;
        }
      };
    };
    error62 = () => {
      const Sizable = {
        string: { unit: "znak\u016F", verb: "m\xEDt" },
        file: { unit: "bajt\u016F", verb: "m\xEDt" },
        array: { unit: "prvk\u016F", verb: "m\xEDt" },
        set: { unit: "prvk\u016F", verb: "m\xEDt" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "regul\xE1rn\xED v\xFDraz",
        email: "e-mailov\xE1 adresa",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "datum a \u010Das ve form\xE1tu ISO",
        date: "datum ve form\xE1tu ISO",
        time: "\u010Das ve form\xE1tu ISO",
        duration: "doba trv\xE1n\xED ISO",
        ipv4: "IPv4 adresa",
        ipv6: "IPv6 adresa",
        cidrv4: "rozsah IPv4",
        cidrv6: "rozsah IPv6",
        base64: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64",
        base64url: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64url",
        json_string: "\u0159et\u011Bzec ve form\xE1tu JSON",
        e164: "\u010D\xEDslo E.164",
        jwt: "JWT",
        template_literal: "vstup"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u010D\xEDslo",
        string: "\u0159et\u011Bzec",
        function: "funkce",
        array: "pole"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f, _g, _h, _i;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no instanceof ${issue22.expected}, obdr\u017Eeno ${received}`;
            }
            return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${expected}, obdr\u017Eeno ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${stringifyPrimitive2(issue22.values[0])}`;
            return `Neplatn\xE1 mo\u017Enost: o\u010Dek\xE1v\xE1na jedna z hodnot ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${(_c = issue22.origin) != null ? _c : "hodnota"} mus\xED m\xEDt ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "prvk\u016F"}`;
            }
            return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${(_e = issue22.origin) != null ? _e : "hodnota"} mus\xED b\xFDt ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${(_f = issue22.origin) != null ? _f : "hodnota"} mus\xED m\xEDt ${adj}${issue22.minimum.toString()} ${(_g = sizing.unit) != null ? _g : "prvk\u016F"}`;
            }
            return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${(_h = issue22.origin) != null ? _h : "hodnota"} mus\xED b\xFDt ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED za\u010D\xEDnat na "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED kon\u010Dit na "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED obsahovat "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED odpov\xEDdat vzoru ${_issue.pattern}`;
            return `Neplatn\xFD form\xE1t ${(_i = FormatDictionary[_issue.format]) != null ? _i : issue22.format}`;
          }
          case "not_multiple_of":
            return `Neplatn\xE9 \u010D\xEDslo: mus\xED b\xFDt n\xE1sobkem ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Nezn\xE1m\xE9 kl\xED\u010De: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Neplatn\xFD kl\xED\u010D v ${issue22.origin}`;
          case "invalid_union":
            return "Neplatn\xFD vstup";
          case "invalid_element":
            return `Neplatn\xE1 hodnota v ${issue22.origin}`;
          default:
            return `Neplatn\xFD vstup`;
        }
      };
    };
    error72 = () => {
      const Sizable = {
        string: { unit: "tegn", verb: "havde" },
        file: { unit: "bytes", verb: "havde" },
        array: { unit: "elementer", verb: "indeholdt" },
        set: { unit: "elementer", verb: "indeholdt" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "e-mailadresse",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO dato- og klokkesl\xE6t",
        date: "ISO-dato",
        time: "ISO-klokkesl\xE6t",
        duration: "ISO-varighed",
        ipv4: "IPv4-omr\xE5de",
        ipv6: "IPv6-omr\xE5de",
        cidrv4: "IPv4-spektrum",
        cidrv6: "IPv6-spektrum",
        base64: "base64-kodet streng",
        base64url: "base64url-kodet streng",
        json_string: "JSON-streng",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        string: "streng",
        number: "tal",
        boolean: "boolean",
        array: "liste",
        object: "objekt",
        set: "s\xE6t",
        file: "fil"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Ugyldigt input: forventede instanceof ${issue22.expected}, fik ${received}`;
            }
            return `Ugyldigt input: forventede ${expected}, fik ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Ugyldig v\xE6rdi: forventede ${stringifyPrimitive2(issue22.values[0])}`;
            return `Ugyldigt valg: forventede en af f\xF8lgende ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            const origin2 = (_c = TypeDictionary[issue22.origin]) != null ? _c : issue22.origin;
            if (sizing)
              return `For stor: forventede ${origin2 != null ? origin2 : "value"} ${sizing.verb} ${adj} ${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementer"}`;
            return `For stor: forventede ${origin2 != null ? origin2 : "value"} havde ${adj} ${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            const origin2 = (_e = TypeDictionary[issue22.origin]) != null ? _e : issue22.origin;
            if (sizing) {
              return `For lille: forventede ${origin2} ${sizing.verb} ${adj} ${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `For lille: forventede ${origin2} havde ${adj} ${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Ugyldig streng: skal starte med "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Ugyldig streng: skal ende med "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Ugyldig streng: skal indeholde "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Ugyldig streng: skal matche m\xF8nsteret ${_issue.pattern}`;
            return `Ugyldig ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Ugyldigt tal: skal v\xE6re deleligt med ${issue22.divisor}`;
          case "unrecognized_keys":
            return `${issue22.keys.length > 1 ? "Ukendte n\xF8gler" : "Ukendt n\xF8gle"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Ugyldig n\xF8gle i ${issue22.origin}`;
          case "invalid_union":
            return "Ugyldigt input: matcher ingen af de tilladte typer";
          case "invalid_element":
            return `Ugyldig v\xE6rdi i ${issue22.origin}`;
          default:
            return `Ugyldigt input`;
        }
      };
    };
    error82 = () => {
      const Sizable = {
        string: { unit: "Zeichen", verb: "zu haben" },
        file: { unit: "Bytes", verb: "zu haben" },
        array: { unit: "Elemente", verb: "zu haben" },
        set: { unit: "Elemente", verb: "zu haben" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "Eingabe",
        email: "E-Mail-Adresse",
        url: "URL",
        emoji: "Emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-Datum und -Uhrzeit",
        date: "ISO-Datum",
        time: "ISO-Uhrzeit",
        duration: "ISO-Dauer",
        ipv4: "IPv4-Adresse",
        ipv6: "IPv6-Adresse",
        cidrv4: "IPv4-Bereich",
        cidrv6: "IPv6-Bereich",
        base64: "Base64-codierter String",
        base64url: "Base64-URL-codierter String",
        json_string: "JSON-String",
        e164: "E.164-Nummer",
        jwt: "JWT",
        template_literal: "Eingabe"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "Zahl",
        array: "Array"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Ung\xFCltige Eingabe: erwartet instanceof ${issue22.expected}, erhalten ${received}`;
            }
            return `Ung\xFCltige Eingabe: erwartet ${expected}, erhalten ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Ung\xFCltige Eingabe: erwartet ${stringifyPrimitive2(issue22.values[0])}`;
            return `Ung\xFCltige Option: erwartet eine von ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Zu gro\xDF: erwartet, dass ${(_c = issue22.origin) != null ? _c : "Wert"} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "Elemente"} hat`;
            return `Zu gro\xDF: erwartet, dass ${(_e = issue22.origin) != null ? _e : "Wert"} ${adj}${issue22.maximum.toString()} ist`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Zu klein: erwartet, dass ${issue22.origin} ${adj}${issue22.minimum.toString()} ${sizing.unit} hat`;
            }
            return `Zu klein: erwartet, dass ${issue22.origin} ${adj}${issue22.minimum.toString()} ist`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Ung\xFCltiger String: muss mit "${_issue.prefix}" beginnen`;
            if (_issue.format === "ends_with")
              return `Ung\xFCltiger String: muss mit "${_issue.suffix}" enden`;
            if (_issue.format === "includes")
              return `Ung\xFCltiger String: muss "${_issue.includes}" enthalten`;
            if (_issue.format === "regex")
              return `Ung\xFCltiger String: muss dem Muster ${_issue.pattern} entsprechen`;
            return `Ung\xFCltig: ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Ung\xFCltige Zahl: muss ein Vielfaches von ${issue22.divisor} sein`;
          case "unrecognized_keys":
            return `${issue22.keys.length > 1 ? "Unbekannte Schl\xFCssel" : "Unbekannter Schl\xFCssel"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Ung\xFCltiger Schl\xFCssel in ${issue22.origin}`;
          case "invalid_union":
            return "Ung\xFCltige Eingabe";
          case "invalid_element":
            return `Ung\xFCltiger Wert in ${issue22.origin}`;
          default:
            return `Ung\xFCltige Eingabe`;
        }
      };
    };
    error92 = () => {
      const Sizable = {
        string: { unit: "characters", verb: "to have" },
        file: { unit: "bytes", verb: "to have" },
        array: { unit: "items", verb: "to have" },
        set: { unit: "items", verb: "to have" },
        map: { unit: "entries", verb: "to have" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "email address",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datetime",
        date: "ISO date",
        time: "ISO time",
        duration: "ISO duration",
        ipv4: "IPv4 address",
        ipv6: "IPv6 address",
        mac: "MAC address",
        cidrv4: "IPv4 range",
        cidrv6: "IPv6 range",
        base64: "base64-encoded string",
        base64url: "base64url-encoded string",
        json_string: "JSON string",
        e164: "E.164 number",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        // Compatibility: "nan" -> "NaN" for display
        nan: "NaN"
        // All other type names omitted - they fall back to raw values via ?? operator
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            return `Invalid input: expected ${expected}, received ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Invalid input: expected ${stringifyPrimitive2(issue22.values[0])}`;
            return `Invalid option: expected one of ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Too big: expected ${(_c = issue22.origin) != null ? _c : "value"} to have ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elements"}`;
            return `Too big: expected ${(_e = issue22.origin) != null ? _e : "value"} to be ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Too small: expected ${issue22.origin} to have ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Too small: expected ${issue22.origin} to be ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `Invalid string: must start with "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Invalid string: must end with "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Invalid string: must include "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Invalid string: must match pattern ${_issue.pattern}`;
            return `Invalid ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Invalid number: must be a multiple of ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Unrecognized key${issue22.keys.length > 1 ? "s" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Invalid key in ${issue22.origin}`;
          case "invalid_union":
            return "Invalid input";
          case "invalid_element":
            return `Invalid value in ${issue22.origin}`;
          default:
            return `Invalid input`;
        }
      };
    };
    error102 = () => {
      const Sizable = {
        string: { unit: "karaktrojn", verb: "havi" },
        file: { unit: "bajtojn", verb: "havi" },
        array: { unit: "elementojn", verb: "havi" },
        set: { unit: "elementojn", verb: "havi" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "enigo",
        email: "retadreso",
        url: "URL",
        emoji: "emo\u011Dio",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-datotempo",
        date: "ISO-dato",
        time: "ISO-tempo",
        duration: "ISO-da\u016Dro",
        ipv4: "IPv4-adreso",
        ipv6: "IPv6-adreso",
        cidrv4: "IPv4-rango",
        cidrv6: "IPv6-rango",
        base64: "64-ume kodita karaktraro",
        base64url: "URL-64-ume kodita karaktraro",
        json_string: "JSON-karaktraro",
        e164: "E.164-nombro",
        jwt: "JWT",
        template_literal: "enigo"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "nombro",
        array: "tabelo",
        null: "senvalora"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Nevalida enigo: atendi\u011Dis instanceof ${issue22.expected}, ricevi\u011Dis ${received}`;
            }
            return `Nevalida enigo: atendi\u011Dis ${expected}, ricevi\u011Dis ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Nevalida enigo: atendi\u011Dis ${stringifyPrimitive2(issue22.values[0])}`;
            return `Nevalida opcio: atendi\u011Dis unu el ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Tro granda: atendi\u011Dis ke ${(_c = issue22.origin) != null ? _c : "valoro"} havu ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementojn"}`;
            return `Tro granda: atendi\u011Dis ke ${(_e = issue22.origin) != null ? _e : "valoro"} havu ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Tro malgranda: atendi\u011Dis ke ${issue22.origin} havu ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Tro malgranda: atendi\u011Dis ke ${issue22.origin} estu ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Nevalida karaktraro: devas komenci\u011Di per "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Nevalida karaktraro: devas fini\u011Di per "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Nevalida karaktraro: devas inkluzivi "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Nevalida karaktraro: devas kongrui kun la modelo ${_issue.pattern}`;
            return `Nevalida ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Nevalida nombro: devas esti oblo de ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Nekonata${issue22.keys.length > 1 ? "j" : ""} \u015Dlosilo${issue22.keys.length > 1 ? "j" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Nevalida \u015Dlosilo en ${issue22.origin}`;
          case "invalid_union":
            return "Nevalida enigo";
          case "invalid_element":
            return `Nevalida valoro en ${issue22.origin}`;
          default:
            return `Nevalida enigo`;
        }
      };
    };
    error112 = () => {
      const Sizable = {
        string: { unit: "caracteres", verb: "tener" },
        file: { unit: "bytes", verb: "tener" },
        array: { unit: "elementos", verb: "tener" },
        set: { unit: "elementos", verb: "tener" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "entrada",
        email: "direcci\xF3n de correo electr\xF3nico",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "fecha y hora ISO",
        date: "fecha ISO",
        time: "hora ISO",
        duration: "duraci\xF3n ISO",
        ipv4: "direcci\xF3n IPv4",
        ipv6: "direcci\xF3n IPv6",
        cidrv4: "rango IPv4",
        cidrv6: "rango IPv6",
        base64: "cadena codificada en base64",
        base64url: "URL codificada en base64",
        json_string: "cadena JSON",
        e164: "n\xFAmero E.164",
        jwt: "JWT",
        template_literal: "entrada"
      };
      const TypeDictionary = {
        nan: "NaN",
        string: "texto",
        number: "n\xFAmero",
        boolean: "booleano",
        array: "arreglo",
        object: "objeto",
        set: "conjunto",
        file: "archivo",
        date: "fecha",
        bigint: "n\xFAmero grande",
        symbol: "s\xEDmbolo",
        undefined: "indefinido",
        null: "nulo",
        function: "funci\xF3n",
        map: "mapa",
        record: "registro",
        tuple: "tupla",
        enum: "enumeraci\xF3n",
        union: "uni\xF3n",
        literal: "literal",
        promise: "promesa",
        void: "vac\xEDo",
        never: "nunca",
        unknown: "desconocido",
        any: "cualquiera"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f, _g, _h;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Entrada inv\xE1lida: se esperaba instanceof ${issue22.expected}, recibido ${received}`;
            }
            return `Entrada inv\xE1lida: se esperaba ${expected}, recibido ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Entrada inv\xE1lida: se esperaba ${stringifyPrimitive2(issue22.values[0])}`;
            return `Opci\xF3n inv\xE1lida: se esperaba una de ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            const origin2 = (_c = TypeDictionary[issue22.origin]) != null ? _c : issue22.origin;
            if (sizing)
              return `Demasiado grande: se esperaba que ${origin2 != null ? origin2 : "valor"} tuviera ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementos"}`;
            return `Demasiado grande: se esperaba que ${origin2 != null ? origin2 : "valor"} fuera ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            const origin2 = (_e = TypeDictionary[issue22.origin]) != null ? _e : issue22.origin;
            if (sizing) {
              return `Demasiado peque\xF1o: se esperaba que ${origin2} tuviera ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Demasiado peque\xF1o: se esperaba que ${origin2} fuera ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Cadena inv\xE1lida: debe comenzar con "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Cadena inv\xE1lida: debe terminar en "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Cadena inv\xE1lida: debe incluir "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Cadena inv\xE1lida: debe coincidir con el patr\xF3n ${_issue.pattern}`;
            return `Inv\xE1lido ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `N\xFAmero inv\xE1lido: debe ser m\xFAltiplo de ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Llave${issue22.keys.length > 1 ? "s" : ""} desconocida${issue22.keys.length > 1 ? "s" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Llave inv\xE1lida en ${(_g = TypeDictionary[issue22.origin]) != null ? _g : issue22.origin}`;
          case "invalid_union":
            return "Entrada inv\xE1lida";
          case "invalid_element":
            return `Valor inv\xE1lido en ${(_h = TypeDictionary[issue22.origin]) != null ? _h : issue22.origin}`;
          default:
            return `Entrada inv\xE1lida`;
        }
      };
    };
    error122 = () => {
      const Sizable = {
        string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
        file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
        array: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
        set: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0648\u0631\u0648\u062F\u06CC",
        email: "\u0622\u062F\u0631\u0633 \u0627\u06CC\u0645\u06CC\u0644",
        url: "URL",
        emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u062A\u0627\u0631\u06CC\u062E \u0648 \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
        date: "\u062A\u0627\u0631\u06CC\u062E \u0627\u06CC\u0632\u0648",
        time: "\u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
        duration: "\u0645\u062F\u062A \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
        ipv4: "IPv4 \u0622\u062F\u0631\u0633",
        ipv6: "IPv6 \u0622\u062F\u0631\u0633",
        cidrv4: "IPv4 \u062F\u0627\u0645\u0646\u0647",
        cidrv6: "IPv6 \u062F\u0627\u0645\u0646\u0647",
        base64: "base64-encoded \u0631\u0634\u062A\u0647",
        base64url: "base64url-encoded \u0631\u0634\u062A\u0647",
        json_string: "JSON \u0631\u0634\u062A\u0647",
        e164: "E.164 \u0639\u062F\u062F",
        jwt: "JWT",
        template_literal: "\u0648\u0631\u0648\u062F\u06CC"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0639\u062F\u062F",
        array: "\u0622\u0631\u0627\u06CC\u0647"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A instanceof ${issue22.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
            }
            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
          }
          case "invalid_value":
            if (issue22.values.length === 1) {
              return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${stringifyPrimitive2(issue22.values[0])} \u0645\u06CC\u200C\u0628\u0648\u062F`;
            }
            return `\u06AF\u0632\u06CC\u0646\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A \u06CC\u06A9\u06CC \u0627\u0632 ${joinValues2(issue22.values, "|")} \u0645\u06CC\u200C\u0628\u0648\u062F`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${(_c = issue22.origin) != null ? _c : "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0639\u0646\u0635\u0631"} \u0628\u0627\u0634\u062F`;
            }
            return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${(_e = issue22.origin) != null ? _e : "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue22.maximum.toString()} \u0628\u0627\u0634\u062F`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue22.origin} \u0628\u0627\u06CC\u062F ${adj}${issue22.minimum.toString()} ${sizing.unit} \u0628\u0627\u0634\u062F`;
            }
            return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue22.origin} \u0628\u0627\u06CC\u062F ${adj}${issue22.minimum.toString()} \u0628\u0627\u0634\u062F`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.prefix}" \u0634\u0631\u0648\u0639 \u0634\u0648\u062F`;
            }
            if (_issue.format === "ends_with") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.suffix}" \u062A\u0645\u0627\u0645 \u0634\u0648\u062F`;
            }
            if (_issue.format === "includes") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0634\u0627\u0645\u0644 "${_issue.includes}" \u0628\u0627\u0634\u062F`;
            }
            if (_issue.format === "regex") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 \u0627\u0644\u06AF\u0648\u06CC ${_issue.pattern} \u0645\u0637\u0627\u0628\u0642\u062A \u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F`;
            }
            return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
          }
          case "not_multiple_of":
            return `\u0639\u062F\u062F \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0645\u0636\u0631\u0628 ${issue22.divisor} \u0628\u0627\u0634\u062F`;
          case "unrecognized_keys":
            return `\u06A9\u0644\u06CC\u062F${issue22.keys.length > 1 ? "\u0647\u0627\u06CC" : ""} \u0646\u0627\u0634\u0646\u0627\u0633: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u06A9\u0644\u06CC\u062F \u0646\u0627\u0634\u0646\u0627\u0633 \u062F\u0631 ${issue22.origin}`;
          case "invalid_union":
            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
          case "invalid_element":
            return `\u0645\u0642\u062F\u0627\u0631 \u0646\u0627\u0645\u0639\u062A\u0628\u0631 \u062F\u0631 ${issue22.origin}`;
          default:
            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
        }
      };
    };
    error132 = () => {
      const Sizable = {
        string: { unit: "merkki\xE4", subject: "merkkijonon" },
        file: { unit: "tavua", subject: "tiedoston" },
        array: { unit: "alkiota", subject: "listan" },
        set: { unit: "alkiota", subject: "joukon" },
        number: { unit: "", subject: "luvun" },
        bigint: { unit: "", subject: "suuren kokonaisluvun" },
        int: { unit: "", subject: "kokonaisluvun" },
        date: { unit: "", subject: "p\xE4iv\xE4m\xE4\xE4r\xE4n" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "s\xE4\xE4nn\xF6llinen lauseke",
        email: "s\xE4hk\xF6postiosoite",
        url: "URL-osoite",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-aikaleima",
        date: "ISO-p\xE4iv\xE4m\xE4\xE4r\xE4",
        time: "ISO-aika",
        duration: "ISO-kesto",
        ipv4: "IPv4-osoite",
        ipv6: "IPv6-osoite",
        cidrv4: "IPv4-alue",
        cidrv6: "IPv6-alue",
        base64: "base64-koodattu merkkijono",
        base64url: "base64url-koodattu merkkijono",
        json_string: "JSON-merkkijono",
        e164: "E.164-luku",
        jwt: "JWT",
        template_literal: "templaattimerkkijono"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Virheellinen tyyppi: odotettiin instanceof ${issue22.expected}, oli ${received}`;
            }
            return `Virheellinen tyyppi: odotettiin ${expected}, oli ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Virheellinen sy\xF6te: t\xE4ytyy olla ${stringifyPrimitive2(issue22.values[0])}`;
            return `Virheellinen valinta: t\xE4ytyy olla yksi seuraavista: ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Liian suuri: ${sizing.subject} t\xE4ytyy olla ${adj}${issue22.maximum.toString()} ${sizing.unit}`.trim();
            }
            return `Liian suuri: arvon t\xE4ytyy olla ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Liian pieni: ${sizing.subject} t\xE4ytyy olla ${adj}${issue22.minimum.toString()} ${sizing.unit}`.trim();
            }
            return `Liian pieni: arvon t\xE4ytyy olla ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Virheellinen sy\xF6te: t\xE4ytyy alkaa "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Virheellinen sy\xF6te: t\xE4ytyy loppua "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Virheellinen sy\xF6te: t\xE4ytyy sis\xE4lt\xE4\xE4 "${_issue.includes}"`;
            if (_issue.format === "regex") {
              return `Virheellinen sy\xF6te: t\xE4ytyy vastata s\xE4\xE4nn\xF6llist\xE4 lauseketta ${_issue.pattern}`;
            }
            return `Virheellinen ${(_c = FormatDictionary[_issue.format]) != null ? _c : issue22.format}`;
          }
          case "not_multiple_of":
            return `Virheellinen luku: t\xE4ytyy olla luvun ${issue22.divisor} monikerta`;
          case "unrecognized_keys":
            return `${issue22.keys.length > 1 ? "Tuntemattomat avaimet" : "Tuntematon avain"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return "Virheellinen avain tietueessa";
          case "invalid_union":
            return "Virheellinen unioni";
          case "invalid_element":
            return "Virheellinen arvo joukossa";
          default:
            return `Virheellinen sy\xF6te`;
        }
      };
    };
    error142 = () => {
      const Sizable = {
        string: { unit: "caract\xE8res", verb: "avoir" },
        file: { unit: "octets", verb: "avoir" },
        array: { unit: "\xE9l\xE9ments", verb: "avoir" },
        set: { unit: "\xE9l\xE9ments", verb: "avoir" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "entr\xE9e",
        email: "adresse e-mail",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "date et heure ISO",
        date: "date ISO",
        time: "heure ISO",
        duration: "dur\xE9e ISO",
        ipv4: "adresse IPv4",
        ipv6: "adresse IPv6",
        cidrv4: "plage IPv4",
        cidrv6: "plage IPv6",
        base64: "cha\xEEne encod\xE9e en base64",
        base64url: "cha\xEEne encod\xE9e en base64url",
        json_string: "cha\xEEne JSON",
        e164: "num\xE9ro E.164",
        jwt: "JWT",
        template_literal: "entr\xE9e"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "nombre",
        array: "tableau"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Entr\xE9e invalide : instanceof ${issue22.expected} attendu, ${received} re\xE7u`;
            }
            return `Entr\xE9e invalide : ${expected} attendu, ${received} re\xE7u`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Entr\xE9e invalide : ${stringifyPrimitive2(issue22.values[0])} attendu`;
            return `Option invalide : une valeur parmi ${joinValues2(issue22.values, "|")} attendue`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Trop grand : ${(_c = issue22.origin) != null ? _c : "valeur"} doit ${sizing.verb} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\xE9l\xE9ment(s)"}`;
            return `Trop grand : ${(_e = issue22.origin) != null ? _e : "valeur"} doit \xEAtre ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Trop petit : ${issue22.origin} doit ${sizing.verb} ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Trop petit : ${issue22.origin} doit \xEAtre ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Cha\xEEne invalide : doit correspondre au mod\xE8le ${_issue.pattern}`;
            return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format} invalide`;
          }
          case "not_multiple_of":
            return `Nombre invalide : doit \xEAtre un multiple de ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Cl\xE9${issue22.keys.length > 1 ? "s" : ""} non reconnue${issue22.keys.length > 1 ? "s" : ""} : ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Cl\xE9 invalide dans ${issue22.origin}`;
          case "invalid_union":
            return "Entr\xE9e invalide";
          case "invalid_element":
            return `Valeur invalide dans ${issue22.origin}`;
          default:
            return `Entr\xE9e invalide`;
        }
      };
    };
    error152 = () => {
      const Sizable = {
        string: { unit: "caract\xE8res", verb: "avoir" },
        file: { unit: "octets", verb: "avoir" },
        array: { unit: "\xE9l\xE9ments", verb: "avoir" },
        set: { unit: "\xE9l\xE9ments", verb: "avoir" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "entr\xE9e",
        email: "adresse courriel",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "date-heure ISO",
        date: "date ISO",
        time: "heure ISO",
        duration: "dur\xE9e ISO",
        ipv4: "adresse IPv4",
        ipv6: "adresse IPv6",
        cidrv4: "plage IPv4",
        cidrv6: "plage IPv6",
        base64: "cha\xEEne encod\xE9e en base64",
        base64url: "cha\xEEne encod\xE9e en base64url",
        json_string: "cha\xEEne JSON",
        e164: "num\xE9ro E.164",
        jwt: "JWT",
        template_literal: "entr\xE9e"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Entr\xE9e invalide : attendu instanceof ${issue22.expected}, re\xE7u ${received}`;
            }
            return `Entr\xE9e invalide : attendu ${expected}, re\xE7u ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Entr\xE9e invalide : attendu ${stringifyPrimitive2(issue22.values[0])}`;
            return `Option invalide : attendu l'une des valeurs suivantes ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "\u2264" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Trop grand : attendu que ${(_c = issue22.origin) != null ? _c : "la valeur"} ait ${adj}${issue22.maximum.toString()} ${sizing.unit}`;
            return `Trop grand : attendu que ${(_d = issue22.origin) != null ? _d : "la valeur"} soit ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? "\u2265" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Trop petit : attendu que ${issue22.origin} ait ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Trop petit : attendu que ${issue22.origin} soit ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Cha\xEEne invalide : doit correspondre au motif ${_issue.pattern}`;
            return `${(_e = FormatDictionary[_issue.format]) != null ? _e : issue22.format} invalide`;
          }
          case "not_multiple_of":
            return `Nombre invalide : doit \xEAtre un multiple de ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Cl\xE9${issue22.keys.length > 1 ? "s" : ""} non reconnue${issue22.keys.length > 1 ? "s" : ""} : ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Cl\xE9 invalide dans ${issue22.origin}`;
          case "invalid_union":
            return "Entr\xE9e invalide";
          case "invalid_element":
            return `Valeur invalide dans ${issue22.origin}`;
          default:
            return `Entr\xE9e invalide`;
        }
      };
    };
    error162 = () => {
      const TypeNames = {
        string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
        number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
        boolean: { label: "\u05E2\u05E8\u05DA \u05D1\u05D5\u05DC\u05D9\u05D0\u05E0\u05D9", gender: "m" },
        bigint: { label: "BigInt", gender: "m" },
        date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA", gender: "m" },
        array: { label: "\u05DE\u05E2\u05E8\u05DA", gender: "m" },
        object: { label: "\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8", gender: "m" },
        null: { label: "\u05E2\u05E8\u05DA \u05E8\u05D9\u05E7 (null)", gender: "m" },
        undefined: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05DE\u05D5\u05D2\u05D3\u05E8 (undefined)", gender: "m" },
        symbol: { label: "\u05E1\u05D9\u05DE\u05D1\u05D5\u05DC (Symbol)", gender: "m" },
        function: { label: "\u05E4\u05D5\u05E0\u05E7\u05E6\u05D9\u05D4", gender: "f" },
        map: { label: "\u05DE\u05E4\u05D4 (Map)", gender: "f" },
        set: { label: "\u05E7\u05D1\u05D5\u05E6\u05D4 (Set)", gender: "f" },
        file: { label: "\u05E7\u05D5\u05D1\u05E5", gender: "m" },
        promise: { label: "Promise", gender: "m" },
        NaN: { label: "NaN", gender: "m" },
        unknown: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05D9\u05D3\u05D5\u05E2", gender: "m" },
        value: { label: "\u05E2\u05E8\u05DA", gender: "m" }
      };
      const Sizable = {
        string: { unit: "\u05EA\u05D5\u05D5\u05D9\u05DD", shortLabel: "\u05E7\u05E6\u05E8", longLabel: "\u05D0\u05E8\u05D5\u05DA" },
        file: { unit: "\u05D1\u05D9\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
        array: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
        set: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
        number: { unit: "", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }
        // no unit
      };
      const typeEntry = (t) => t ? TypeNames[t] : void 0;
      const typeLabel = (t) => {
        const e = typeEntry(t);
        if (e)
          return e.label;
        return t != null ? t : TypeNames.unknown.label;
      };
      const withDefinite = (t) => `\u05D4${typeLabel(t)}`;
      const verbFor = (t) => {
        var _a37;
        const e = typeEntry(t);
        const gender = (_a37 = e == null ? void 0 : e.gender) != null ? _a37 : "m";
        return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA";
      };
      const getSizing = (origin2) => {
        var _a37;
        if (!origin2)
          return null;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      };
      const FormatDictionary = {
        regex: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        email: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05D0\u05D9\u05DE\u05D9\u05D9\u05DC", gender: "f" },
        url: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05E8\u05E9\u05EA", gender: "f" },
        emoji: { label: "\u05D0\u05D9\u05DE\u05D5\u05D2'\u05D9", gender: "m" },
        uuid: { label: "UUID", gender: "m" },
        nanoid: { label: "nanoid", gender: "m" },
        guid: { label: "GUID", gender: "m" },
        cuid: { label: "cuid", gender: "m" },
        cuid2: { label: "cuid2", gender: "m" },
        ulid: { label: "ULID", gender: "m" },
        xid: { label: "XID", gender: "m" },
        ksuid: { label: "KSUID", gender: "m" },
        datetime: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA \u05D5\u05D6\u05DE\u05DF ISO", gender: "m" },
        date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA ISO", gender: "m" },
        time: { label: "\u05D6\u05DE\u05DF ISO", gender: "m" },
        duration: { label: "\u05DE\u05E9\u05DA \u05D6\u05DE\u05DF ISO", gender: "m" },
        ipv4: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv4", gender: "f" },
        ipv6: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv6", gender: "f" },
        cidrv4: { label: "\u05D8\u05D5\u05D5\u05D7 IPv4", gender: "m" },
        cidrv6: { label: "\u05D8\u05D5\u05D5\u05D7 IPv6", gender: "m" },
        base64: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64", gender: "f" },
        base64url: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64 \u05DC\u05DB\u05EA\u05D5\u05D1\u05D5\u05EA \u05E8\u05E9\u05EA", gender: "f" },
        json_string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA JSON", gender: "f" },
        e164: { label: "\u05DE\u05E1\u05E4\u05E8 E.164", gender: "m" },
        jwt: { label: "JWT", gender: "m" },
        ends_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        includes: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        lowercase: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        starts_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        uppercase: { label: "\u05E7\u05DC\u05D8", gender: "m" }
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
        switch (issue22.code) {
          case "invalid_type": {
            const expectedKey = issue22.expected;
            const expected = (_a37 = TypeDictionary[expectedKey != null ? expectedKey : ""]) != null ? _a37 : typeLabel(expectedKey);
            const receivedType = parsedType2(issue22.input);
            const received = (_d = (_c = TypeDictionary[receivedType]) != null ? _c : (_b27 = TypeNames[receivedType]) == null ? void 0 : _b27.label) != null ? _d : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA instanceof ${issue22.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
            }
            return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
          }
          case "invalid_value": {
            if (issue22.values.length === 1) {
              return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05E2\u05E8\u05DA \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA ${stringifyPrimitive2(issue22.values[0])}`;
            }
            const stringified = issue22.values.map((v) => stringifyPrimitive2(v));
            if (issue22.values.length === 2) {
              return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${stringified[0]} \u05D0\u05D5 ${stringified[1]}`;
            }
            const lastValue = stringified[stringified.length - 1];
            const restValues = stringified.slice(0, -1).join(", ");
            return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${restValues} \u05D0\u05D5 ${lastValue}`;
          }
          case "too_big": {
            const sizing = getSizing(issue22.origin);
            const subject = withDefinite((_e = issue22.origin) != null ? _e : "value");
            if (issue22.origin === "string") {
              return `${(_f = sizing == null ? void 0 : sizing.longLabel) != null ? _f : "\u05D0\u05E8\u05D5\u05DA"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue22.maximum.toString()} ${(_g = sizing == null ? void 0 : sizing.unit) != null ? _g : ""} ${issue22.inclusive ? "\u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA" : "\u05DC\u05DB\u05DC \u05D4\u05D9\u05D5\u05EA\u05E8"}`.trim();
            }
            if (issue22.origin === "number") {
              const comparison = issue22.inclusive ? `\u05E7\u05D8\u05DF \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue22.maximum}` : `\u05E7\u05D8\u05DF \u05DE-${issue22.maximum}`;
              return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
            }
            if (issue22.origin === "array" || issue22.origin === "set") {
              const verb = issue22.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
              const comparison = issue22.inclusive ? `${issue22.maximum} ${(_h = sizing == null ? void 0 : sizing.unit) != null ? _h : ""} \u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA` : `\u05E4\u05D7\u05D5\u05EA \u05DE-${issue22.maximum} ${(_i = sizing == null ? void 0 : sizing.unit) != null ? _i : ""}`;
              return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
            }
            const adj = issue22.inclusive ? "<=" : "<";
            const be = verbFor((_j = issue22.origin) != null ? _j : "value");
            if (sizing == null ? void 0 : sizing.unit) {
              return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue22.maximum.toString()} ${sizing.unit}`;
            }
            return `${(_k = sizing == null ? void 0 : sizing.longLabel) != null ? _k : "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const sizing = getSizing(issue22.origin);
            const subject = withDefinite((_l = issue22.origin) != null ? _l : "value");
            if (issue22.origin === "string") {
              return `${(_m = sizing == null ? void 0 : sizing.shortLabel) != null ? _m : "\u05E7\u05E6\u05E8"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue22.minimum.toString()} ${(_n = sizing == null ? void 0 : sizing.unit) != null ? _n : ""} ${issue22.inclusive ? "\u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8" : "\u05DC\u05E4\u05D7\u05D5\u05EA"}`.trim();
            }
            if (issue22.origin === "number") {
              const comparison = issue22.inclusive ? `\u05D2\u05D3\u05D5\u05DC \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue22.minimum}` : `\u05D2\u05D3\u05D5\u05DC \u05DE-${issue22.minimum}`;
              return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
            }
            if (issue22.origin === "array" || issue22.origin === "set") {
              const verb = issue22.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
              if (issue22.minimum === 1 && issue22.inclusive) {
                const singularPhrase = issue22.origin === "set" ? "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3" : "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3";
                return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${singularPhrase}`;
              }
              const comparison = issue22.inclusive ? `${issue22.minimum} ${(_o = sizing == null ? void 0 : sizing.unit) != null ? _o : ""} \u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8` : `\u05D9\u05D5\u05EA\u05E8 \u05DE-${issue22.minimum} ${(_p = sizing == null ? void 0 : sizing.unit) != null ? _p : ""}`;
              return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
            }
            const adj = issue22.inclusive ? ">=" : ">";
            const be = verbFor((_q = issue22.origin) != null ? _q : "value");
            if (sizing == null ? void 0 : sizing.unit) {
              return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `${(_r = sizing == null ? void 0 : sizing.shortLabel) != null ? _r : "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D7\u05D9\u05DC \u05D1 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05E1\u05EA\u05D9\u05D9\u05DD \u05D1 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05DB\u05DC\u05D5\u05DC "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${_issue.pattern}`;
            const nounEntry = FormatDictionary[_issue.format];
            const noun = (_s = nounEntry == null ? void 0 : nounEntry.label) != null ? _s : _issue.format;
            const gender = (_t = nounEntry == null ? void 0 : nounEntry.gender) != null ? _t : "m";
            const adjective = gender === "f" ? "\u05EA\u05E7\u05D9\u05E0\u05D4" : "\u05EA\u05E7\u05D9\u05DF";
            return `${noun} \u05DC\u05D0 ${adjective}`;
          }
          case "not_multiple_of":
            return `\u05DE\u05E1\u05E4\u05E8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA \u05DE\u05DB\u05E4\u05DC\u05D4 \u05E9\u05DC ${issue22.divisor}`;
          case "unrecognized_keys":
            return `\u05DE\u05E4\u05EA\u05D7${issue22.keys.length > 1 ? "\u05D5\u05EA" : ""} \u05DC\u05D0 \u05DE\u05D6\u05D5\u05D4${issue22.keys.length > 1 ? "\u05D9\u05DD" : "\u05D4"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key": {
            return `\u05E9\u05D3\u05D4 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8`;
          }
          case "invalid_union":
            return "\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF";
          case "invalid_element": {
            const place = withDefinite((_u = issue22.origin) != null ? _u : "array");
            return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${place}`;
          }
          default:
            return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF`;
        }
      };
    };
    error172 = () => {
      const Sizable = {
        string: { unit: "karakter", verb: "legyen" },
        file: { unit: "byte", verb: "legyen" },
        array: { unit: "elem", verb: "legyen" },
        set: { unit: "elem", verb: "legyen" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "bemenet",
        email: "email c\xEDm",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO id\u0151b\xE9lyeg",
        date: "ISO d\xE1tum",
        time: "ISO id\u0151",
        duration: "ISO id\u0151intervallum",
        ipv4: "IPv4 c\xEDm",
        ipv6: "IPv6 c\xEDm",
        cidrv4: "IPv4 tartom\xE1ny",
        cidrv6: "IPv6 tartom\xE1ny",
        base64: "base64-k\xF3dolt string",
        base64url: "base64url-k\xF3dolt string",
        json_string: "JSON string",
        e164: "E.164 sz\xE1m",
        jwt: "JWT",
        template_literal: "bemenet"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "sz\xE1m",
        array: "t\xF6mb"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue22.expected}, a kapott \xE9rt\xE9k ${received}`;
            }
            return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive2(issue22.values[0])}`;
            return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `T\xFAl nagy: ${(_c = issue22.origin) != null ? _c : "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elem"}`;
            return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${(_e = issue22.origin) != null ? _e : "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue22.origin} m\xE9rete t\xFAl kicsi ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue22.origin} t\xFAl kicsi ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\xC9rv\xE9nytelen string: "${_issue.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`;
            if (_issue.format === "ends_with")
              return `\xC9rv\xE9nytelen string: "${_issue.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`;
            if (_issue.format === "includes")
              return `\xC9rv\xE9nytelen string: "${_issue.includes}" \xE9rt\xE9ket kell tartalmaznia`;
            if (_issue.format === "regex")
              return `\xC9rv\xE9nytelen string: ${_issue.pattern} mint\xE1nak kell megfelelnie`;
            return `\xC9rv\xE9nytelen ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\xC9rv\xE9nytelen sz\xE1m: ${issue22.divisor} t\xF6bbsz\xF6r\xF6s\xE9nek kell lennie`;
          case "unrecognized_keys":
            return `Ismeretlen kulcs${issue22.keys.length > 1 ? "s" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\xC9rv\xE9nytelen kulcs ${issue22.origin}`;
          case "invalid_union":
            return "\xC9rv\xE9nytelen bemenet";
          case "invalid_element":
            return `\xC9rv\xE9nytelen \xE9rt\xE9k: ${issue22.origin}`;
          default:
            return `\xC9rv\xE9nytelen bemenet`;
        }
      };
    };
    error182 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "\u0576\u0577\u0561\u0576",
            many: "\u0576\u0577\u0561\u0576\u0576\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        },
        file: {
          unit: {
            one: "\u0562\u0561\u0575\u0569",
            many: "\u0562\u0561\u0575\u0569\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        },
        array: {
          unit: {
            one: "\u057F\u0561\u0580\u0580",
            many: "\u057F\u0561\u0580\u0580\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        },
        set: {
          unit: {
            one: "\u057F\u0561\u0580\u0580",
            many: "\u057F\u0561\u0580\u0580\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0574\u0578\u0582\u057F\u0584",
        email: "\u0567\u056C. \u0570\u0561\u057D\u0581\u0565",
        url: "URL",
        emoji: "\u0567\u0574\u0578\u057B\u056B",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E \u0587 \u056A\u0561\u0574",
        date: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E",
        time: "ISO \u056A\u0561\u0574",
        duration: "ISO \u057F\u0587\u0578\u0572\u0578\u0582\u0569\u0575\u0578\u0582\u0576",
        ipv4: "IPv4 \u0570\u0561\u057D\u0581\u0565",
        ipv6: "IPv6 \u0570\u0561\u057D\u0581\u0565",
        cidrv4: "IPv4 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
        cidrv6: "IPv6 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
        base64: "base64 \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
        base64url: "base64url \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
        json_string: "JSON \u057F\u0578\u0572",
        e164: "E.164 \u0570\u0561\u0574\u0561\u0580",
        jwt: "JWT",
        template_literal: "\u0574\u0578\u0582\u057F\u0584"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0569\u056B\u057E",
        array: "\u0566\u0561\u0576\u0563\u057E\u0561\u056E"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 instanceof ${issue22.expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
            }
            return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${stringifyPrimitive2(issue22.values[1])}`;
            return `\u054D\u056D\u0561\u056C \u057F\u0561\u0580\u0562\u0565\u0580\u0561\u056F\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 \u0570\u0565\u057F\u0587\u0575\u0561\u056C\u0576\u0565\u0580\u056B\u0581 \u0574\u0565\u056F\u0568\u055D ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              const maxValue = Number(issue22.maximum);
              const unit = getArmenianPlural2(maxValue, sizing.unit.one, sizing.unit.many);
              return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle2((_c = issue22.origin) != null ? _c : "\u0561\u0580\u056A\u0565\u0584")} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue22.maximum.toString()} ${unit}`;
            }
            return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle2((_d = issue22.origin) != null ? _d : "\u0561\u0580\u056A\u0565\u0584")} \u056C\u056B\u0576\u056B ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              const minValue = Number(issue22.minimum);
              const unit = getArmenianPlural2(minValue, sizing.unit.one, sizing.unit.many);
              return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle2(issue22.origin)} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue22.minimum.toString()} ${unit}`;
            }
            return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle2(issue22.origin)} \u056C\u056B\u0576\u056B ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057D\u056F\u057D\u057E\u056B "${_issue.prefix}"-\u0578\u057E`;
            if (_issue.format === "ends_with")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0561\u057E\u0561\u0580\u057F\u057E\u056B "${_issue.suffix}"-\u0578\u057E`;
            if (_issue.format === "includes")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057A\u0561\u0580\u0578\u0582\u0576\u0561\u056F\u056B "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0570\u0561\u0574\u0561\u057A\u0561\u057F\u0561\u057D\u056D\u0561\u0576\u056B ${_issue.pattern} \u0571\u0587\u0561\u0579\u0561\u0583\u056B\u0576`;
            return `\u054D\u056D\u0561\u056C ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u054D\u056D\u0561\u056C \u0569\u056B\u057E\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0562\u0561\u0566\u0574\u0561\u057A\u0561\u057F\u056B\u056F \u056C\u056B\u0576\u056B ${issue22.divisor}-\u056B`;
          case "unrecognized_keys":
            return `\u0549\u0573\u0561\u0576\u0561\u0579\u057E\u0561\u056E \u0562\u0561\u0576\u0561\u056C\u056B${issue22.keys.length > 1 ? "\u0576\u0565\u0580" : ""}. ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u054D\u056D\u0561\u056C \u0562\u0561\u0576\u0561\u056C\u056B ${withDefiniteArticle2(issue22.origin)}-\u0578\u0582\u0574`;
          case "invalid_union":
            return "\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574";
          case "invalid_element":
            return `\u054D\u056D\u0561\u056C \u0561\u0580\u056A\u0565\u0584 ${withDefiniteArticle2(issue22.origin)}-\u0578\u0582\u0574`;
          default:
            return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574`;
        }
      };
    };
    error192 = () => {
      const Sizable = {
        string: { unit: "karakter", verb: "memiliki" },
        file: { unit: "byte", verb: "memiliki" },
        array: { unit: "item", verb: "memiliki" },
        set: { unit: "item", verb: "memiliki" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "alamat email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "tanggal dan waktu format ISO",
        date: "tanggal format ISO",
        time: "jam format ISO",
        duration: "durasi format ISO",
        ipv4: "alamat IPv4",
        ipv6: "alamat IPv6",
        cidrv4: "rentang alamat IPv4",
        cidrv6: "rentang alamat IPv6",
        base64: "string dengan enkode base64",
        base64url: "string dengan enkode base64url",
        json_string: "string JSON",
        e164: "angka E.164",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Input tidak valid: diharapkan instanceof ${issue22.expected}, diterima ${received}`;
            }
            return `Input tidak valid: diharapkan ${expected}, diterima ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Input tidak valid: diharapkan ${stringifyPrimitive2(issue22.values[0])}`;
            return `Pilihan tidak valid: diharapkan salah satu dari ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Terlalu besar: diharapkan ${(_c = issue22.origin) != null ? _c : "value"} memiliki ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elemen"}`;
            return `Terlalu besar: diharapkan ${(_e = issue22.origin) != null ? _e : "value"} menjadi ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Terlalu kecil: diharapkan ${issue22.origin} memiliki ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Terlalu kecil: diharapkan ${issue22.origin} menjadi ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `String tidak valid: harus dimulai dengan "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `String tidak valid: harus berakhir dengan "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `String tidak valid: harus menyertakan "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `String tidak valid: harus sesuai pola ${_issue.pattern}`;
            return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format} tidak valid`;
          }
          case "not_multiple_of":
            return `Angka tidak valid: harus kelipatan dari ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Kunci tidak dikenali ${issue22.keys.length > 1 ? "s" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Kunci tidak valid di ${issue22.origin}`;
          case "invalid_union":
            return "Input tidak valid";
          case "invalid_element":
            return `Nilai tidak valid di ${issue22.origin}`;
          default:
            return `Input tidak valid`;
        }
      };
    };
    error202 = () => {
      const Sizable = {
        string: { unit: "stafi", verb: "a\xF0 hafa" },
        file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
        array: { unit: "hluti", verb: "a\xF0 hafa" },
        set: { unit: "hluti", verb: "a\xF0 hafa" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "gildi",
        email: "netfang",
        url: "vefsl\xF3\xF0",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO dagsetning og t\xEDmi",
        date: "ISO dagsetning",
        time: "ISO t\xEDmi",
        duration: "ISO t\xEDmalengd",
        ipv4: "IPv4 address",
        ipv6: "IPv6 address",
        cidrv4: "IPv4 range",
        cidrv6: "IPv6 range",
        base64: "base64-encoded strengur",
        base64url: "base64url-encoded strengur",
        json_string: "JSON strengur",
        e164: "E.164 t\xF6lugildi",
        jwt: "JWT",
        template_literal: "gildi"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "n\xFAmer",
        array: "fylki"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera instanceof ${issue22.expected}`;
            }
            return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera ${expected}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Rangt gildi: gert r\xE1\xF0 fyrir ${stringifyPrimitive2(issue22.values[0])}`;
            return `\xD3gilt val: m\xE1 vera eitt af eftirfarandi ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${(_c = issue22.origin) != null ? _c : "gildi"} hafi ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "hluti"}`;
            return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${(_e = issue22.origin) != null ? _e : "gildi"} s\xE9 ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue22.origin} hafi ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue22.origin} s\xE9 ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\xD3gildur strengur: ver\xF0ur a\xF0 byrja \xE1 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\xD3gildur strengur: ver\xF0ur a\xF0 enda \xE1 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\xD3gildur strengur: ver\xF0ur a\xF0 innihalda "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\xD3gildur strengur: ver\xF0ur a\xF0 fylgja mynstri ${_issue.pattern}`;
            return `Rangt ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `R\xF6ng tala: ver\xF0ur a\xF0 vera margfeldi af ${issue22.divisor}`;
          case "unrecognized_keys":
            return `\xD3\xFEekkt ${issue22.keys.length > 1 ? "ir lyklar" : "ur lykill"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Rangur lykill \xED ${issue22.origin}`;
          case "invalid_union":
            return "Rangt gildi";
          case "invalid_element":
            return `Rangt gildi \xED ${issue22.origin}`;
          default:
            return `Rangt gildi`;
        }
      };
    };
    error212 = () => {
      const Sizable = {
        string: { unit: "caratteri", verb: "avere" },
        file: { unit: "byte", verb: "avere" },
        array: { unit: "elementi", verb: "avere" },
        set: { unit: "elementi", verb: "avere" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "indirizzo email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data e ora ISO",
        date: "data ISO",
        time: "ora ISO",
        duration: "durata ISO",
        ipv4: "indirizzo IPv4",
        ipv6: "indirizzo IPv6",
        cidrv4: "intervallo IPv4",
        cidrv6: "intervallo IPv6",
        base64: "stringa codificata in base64",
        base64url: "URL codificata in base64",
        json_string: "stringa JSON",
        e164: "numero E.164",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "numero",
        array: "vettore"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Input non valido: atteso instanceof ${issue22.expected}, ricevuto ${received}`;
            }
            return `Input non valido: atteso ${expected}, ricevuto ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Input non valido: atteso ${stringifyPrimitive2(issue22.values[0])}`;
            return `Opzione non valida: atteso uno tra ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Troppo grande: ${(_c = issue22.origin) != null ? _c : "valore"} deve avere ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementi"}`;
            return `Troppo grande: ${(_e = issue22.origin) != null ? _e : "valore"} deve essere ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Troppo piccolo: ${issue22.origin} deve avere ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Troppo piccolo: ${issue22.origin} deve essere ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Stringa non valida: deve iniziare con "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Stringa non valida: deve terminare con "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Stringa non valida: deve includere "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
            return `Invalid ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Numero non valido: deve essere un multiplo di ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Chiav${issue22.keys.length > 1 ? "i" : "e"} non riconosciut${issue22.keys.length > 1 ? "e" : "a"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Chiave non valida in ${issue22.origin}`;
          case "invalid_union":
            return "Input non valido";
          case "invalid_element":
            return `Valore non valido in ${issue22.origin}`;
          default:
            return `Input non valido`;
        }
      };
    };
    error222 = () => {
      const Sizable = {
        string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
        file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
        array: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" },
        set: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u5165\u529B\u5024",
        email: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9",
        url: "URL",
        emoji: "\u7D75\u6587\u5B57",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO\u65E5\u6642",
        date: "ISO\u65E5\u4ED8",
        time: "ISO\u6642\u523B",
        duration: "ISO\u671F\u9593",
        ipv4: "IPv4\u30A2\u30C9\u30EC\u30B9",
        ipv6: "IPv6\u30A2\u30C9\u30EC\u30B9",
        cidrv4: "IPv4\u7BC4\u56F2",
        cidrv6: "IPv6\u7BC4\u56F2",
        base64: "base64\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
        base64url: "base64url\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
        json_string: "JSON\u6587\u5B57\u5217",
        e164: "E.164\u756A\u53F7",
        jwt: "JWT",
        template_literal: "\u5165\u529B\u5024"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u6570\u5024",
        array: "\u914D\u5217"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u7121\u52B9\u306A\u5165\u529B: instanceof ${issue22.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
            }
            return `\u7121\u52B9\u306A\u5165\u529B: ${expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u7121\u52B9\u306A\u5165\u529B: ${stringifyPrimitive2(issue22.values[0])}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F`;
            return `\u7121\u52B9\u306A\u9078\u629E: ${joinValues2(issue22.values, "\u3001")}\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          case "too_big": {
            const adj = issue22.inclusive ? "\u4EE5\u4E0B\u3067\u3042\u308B" : "\u3088\u308A\u5C0F\u3055\u3044";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u5927\u304D\u3059\u304E\u308B\u5024: ${(_c = issue22.origin) != null ? _c : "\u5024"}\u306F${issue22.maximum.toString()}${(_d = sizing.unit) != null ? _d : "\u8981\u7D20"}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            return `\u5927\u304D\u3059\u304E\u308B\u5024: ${(_e = issue22.origin) != null ? _e : "\u5024"}\u306F${issue22.maximum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? "\u4EE5\u4E0A\u3067\u3042\u308B" : "\u3088\u308A\u5927\u304D\u3044";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue22.origin}\u306F${issue22.minimum.toString()}${sizing.unit}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue22.origin}\u306F${issue22.minimum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.prefix}"\u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            if (_issue.format === "ends_with")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.suffix}"\u3067\u7D42\u308F\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            if (_issue.format === "includes")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.includes}"\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            if (_issue.format === "regex")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: \u30D1\u30BF\u30FC\u30F3${_issue.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            return `\u7121\u52B9\u306A${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u7121\u52B9\u306A\u6570\u5024: ${issue22.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          case "unrecognized_keys":
            return `\u8A8D\u8B58\u3055\u308C\u3066\u3044\u306A\u3044\u30AD\u30FC${issue22.keys.length > 1 ? "\u7FA4" : ""}: ${joinValues2(issue22.keys, "\u3001")}`;
          case "invalid_key":
            return `${issue22.origin}\u5185\u306E\u7121\u52B9\u306A\u30AD\u30FC`;
          case "invalid_union":
            return "\u7121\u52B9\u306A\u5165\u529B";
          case "invalid_element":
            return `${issue22.origin}\u5185\u306E\u7121\u52B9\u306A\u5024`;
          default:
            return `\u7121\u52B9\u306A\u5165\u529B`;
        }
      };
    };
    error232 = () => {
      const Sizable = {
        string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
        file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
        array: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
        set: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0",
        email: "\u10D4\u10DA-\u10E4\u10DD\u10E1\u10E2\u10D8\u10E1 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
        url: "URL",
        emoji: "\u10D4\u10DB\u10DD\u10EF\u10D8",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8-\u10D3\u10E0\u10DD",
        date: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8",
        time: "\u10D3\u10E0\u10DD",
        duration: "\u10EE\u10D0\u10DC\u10D2\u10E0\u10EB\u10DA\u10D8\u10D5\u10DD\u10D1\u10D0",
        ipv4: "IPv4 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
        ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
        cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
        cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
        base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
        jwt: "JWT",
        template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
        string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
        function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
        array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 instanceof ${issue22.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
            }
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D0\u10E0\u10D8\u10D0\u10DC\u10E2\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8\u10D0 \u10D4\u10E0\u10D7-\u10D4\u10E0\u10D7\u10D8 ${joinValues2(issue22.values, "|")}-\u10D3\u10D0\u10DC`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${(_c = issue22.origin) != null ? _c : "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} ${sizing.verb} ${adj}${issue22.maximum.toString()} ${sizing.unit}`;
            return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${(_d = issue22.origin) != null ? _d : "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue22.origin} ${sizing.verb} ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue22.origin} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
            }
            if (_issue.format === "ends_with")
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
            if (_issue.format === "includes")
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
            if (_issue.format === "regex")
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E0\u10D8\u10EA\u10EE\u10D5\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10E7\u10DD\u10E1 ${issue22.divisor}-\u10D8\u10E1 \u10EF\u10D4\u10E0\u10D0\u10D3\u10D8`;
          case "unrecognized_keys":
            return `\u10E3\u10EA\u10DC\u10DD\u10D1\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1${issue22.keys.length > 1 ? "\u10D4\u10D1\u10D8" : "\u10D8"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1\u10D8 ${issue22.origin}-\u10E8\u10D8`;
          case "invalid_union":
            return "\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0";
          case "invalid_element":
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0 ${issue22.origin}-\u10E8\u10D8`;
          default:
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0`;
        }
      };
    };
    error242 = () => {
      const Sizable = {
        string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
        file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
        array: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
        set: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B",
        email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B",
        url: "URL",
        emoji: "\u179F\u1789\u17D2\u1789\u17B6\u17A2\u17B6\u179A\u1798\u17D2\u1798\u178E\u17CD",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 \u1793\u17B7\u1784\u1798\u17C9\u17C4\u1784 ISO",
        date: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 ISO",
        time: "\u1798\u17C9\u17C4\u1784 ISO",
        duration: "\u179A\u1799\u17C8\u1796\u17C1\u179B ISO",
        ipv4: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
        ipv6: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
        cidrv4: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
        cidrv6: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
        base64: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64",
        base64url: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64url",
        json_string: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A JSON",
        e164: "\u179B\u17C1\u1781 E.164",
        jwt: "JWT",
        template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u179B\u17C1\u1781",
        array: "\u17A2\u17B6\u179A\u17C1 (Array)",
        null: "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A instanceof ${issue22.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
            }
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u1787\u1798\u17D2\u179A\u17BE\u179F\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1787\u17B6\u1798\u17BD\u1799\u1780\u17D2\u1793\u17BB\u1784\u1785\u17C6\u178E\u17C4\u1798 ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${(_c = issue22.origin) != null ? _c : "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u1792\u17B6\u178F\u17BB"}`;
            return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${(_e = issue22.origin) != null ? _e : "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue22.origin} ${adj} ${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue22.origin} ${adj} ${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1785\u17B6\u1794\u17CB\u1795\u17D2\u178F\u17BE\u1798\u178A\u17C4\u1799 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1794\u1789\u17D2\u1785\u1794\u17CB\u178A\u17C4\u1799 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${_issue.pattern}`;
            return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${issue22.divisor}`;
          case "unrecognized_keys":
            return `\u179A\u1780\u1783\u17BE\u1789\u179F\u17C4\u1798\u17B7\u1793\u179F\u17D2\u1782\u17B6\u179B\u17CB\u17D6 ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u179F\u17C4\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue22.origin}`;
          case "invalid_union":
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
          case "invalid_element":
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue22.origin}`;
          default:
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
        }
      };
    };
    error252 = () => {
      const Sizable = {
        string: { unit: "\uBB38\uC790", verb: "to have" },
        file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
        array: { unit: "\uAC1C", verb: "to have" },
        set: { unit: "\uAC1C", verb: "to have" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\uC785\uB825",
        email: "\uC774\uBA54\uC77C \uC8FC\uC18C",
        url: "URL",
        emoji: "\uC774\uBAA8\uC9C0",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \uB0A0\uC9DC\uC2DC\uAC04",
        date: "ISO \uB0A0\uC9DC",
        time: "ISO \uC2DC\uAC04",
        duration: "ISO \uAE30\uAC04",
        ipv4: "IPv4 \uC8FC\uC18C",
        ipv6: "IPv6 \uC8FC\uC18C",
        cidrv4: "IPv4 \uBC94\uC704",
        cidrv6: "IPv6 \uBC94\uC704",
        base64: "base64 \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
        base64url: "base64url \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
        json_string: "JSON \uBB38\uC790\uC5F4",
        e164: "E.164 \uBC88\uD638",
        jwt: "JWT",
        template_literal: "\uC785\uB825"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f, _g, _h, _i;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 instanceof ${issue22.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
            }
            return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${stringifyPrimitive2(issue22.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`;
            return `\uC798\uBABB\uB41C \uC635\uC158: ${joinValues2(issue22.values, "\uB610\uB294 ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
          case "too_big": {
            const adj = issue22.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC";
            const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
            const sizing = getSizing(issue22.origin);
            const unit = (_c = sizing == null ? void 0 : sizing.unit) != null ? _c : "\uC694\uC18C";
            if (sizing)
              return `${(_d = issue22.origin) != null ? _d : "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue22.maximum.toString()}${unit} ${adj}${suffix}`;
            return `${(_e = issue22.origin) != null ? _e : "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue22.maximum.toString()} ${adj}${suffix}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC";
            const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
            const sizing = getSizing(issue22.origin);
            const unit = (_f = sizing == null ? void 0 : sizing.unit) != null ? _f : "\uC694\uC18C";
            if (sizing) {
              return `${(_g = issue22.origin) != null ? _g : "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue22.minimum.toString()}${unit} ${adj}${suffix}`;
            }
            return `${(_h = issue22.origin) != null ? _h : "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue22.minimum.toString()} ${adj}${suffix}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.prefix}"(\uC73C)\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4`;
            }
            if (_issue.format === "ends_with")
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.suffix}"(\uC73C)\uB85C \uB05D\uB098\uC57C \uD569\uB2C8\uB2E4`;
            if (_issue.format === "includes")
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`;
            if (_issue.format === "regex")
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${_issue.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`;
            return `\uC798\uBABB\uB41C ${(_i = FormatDictionary[_issue.format]) != null ? _i : issue22.format}`;
          }
          case "not_multiple_of":
            return `\uC798\uBABB\uB41C \uC22B\uC790: ${issue22.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
          case "unrecognized_keys":
            return `\uC778\uC2DD\uD560 \uC218 \uC5C6\uB294 \uD0A4: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\uC798\uBABB\uB41C \uD0A4: ${issue22.origin}`;
          case "invalid_union":
            return `\uC798\uBABB\uB41C \uC785\uB825`;
          case "invalid_element":
            return `\uC798\uBABB\uB41C \uAC12: ${issue22.origin}`;
          default:
            return `\uC798\uBABB\uB41C \uC785\uB825`;
        }
      };
    };
    capitalizeFirstCharacter2 = (text2) => {
      return text2.charAt(0).toUpperCase() + text2.slice(1);
    };
    error262 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "simbolis",
            few: "simboliai",
            many: "simboli\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi b\u016Bti ne ilgesn\u0117 kaip",
              notInclusive: "turi b\u016Bti trumpesn\u0117 kaip"
            },
            bigger: {
              inclusive: "turi b\u016Bti ne trumpesn\u0117 kaip",
              notInclusive: "turi b\u016Bti ilgesn\u0117 kaip"
            }
          }
        },
        file: {
          unit: {
            one: "baitas",
            few: "baitai",
            many: "bait\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi b\u016Bti ne didesnis kaip",
              notInclusive: "turi b\u016Bti ma\u017Eesnis kaip"
            },
            bigger: {
              inclusive: "turi b\u016Bti ne ma\u017Eesnis kaip",
              notInclusive: "turi b\u016Bti didesnis kaip"
            }
          }
        },
        array: {
          unit: {
            one: "element\u0105",
            few: "elementus",
            many: "element\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi tur\u0117ti ne daugiau kaip",
              notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
            },
            bigger: {
              inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
              notInclusive: "turi tur\u0117ti daugiau kaip"
            }
          }
        },
        set: {
          unit: {
            one: "element\u0105",
            few: "elementus",
            many: "element\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi tur\u0117ti ne daugiau kaip",
              notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
            },
            bigger: {
              inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
              notInclusive: "turi tur\u0117ti daugiau kaip"
            }
          }
        }
      };
      function getSizing(origin2, unitType, inclusive, targetShouldBe) {
        var _a37;
        const result = (_a37 = Sizable[origin2]) != null ? _a37 : null;
        if (result === null)
          return result;
        return {
          unit: result.unit[unitType],
          verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
        };
      }
      const FormatDictionary = {
        regex: "\u012Fvestis",
        email: "el. pa\u0161to adresas",
        url: "URL",
        emoji: "jaustukas",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO data ir laikas",
        date: "ISO data",
        time: "ISO laikas",
        duration: "ISO trukm\u0117",
        ipv4: "IPv4 adresas",
        ipv6: "IPv6 adresas",
        cidrv4: "IPv4 tinklo prefiksas (CIDR)",
        cidrv6: "IPv6 tinklo prefiksas (CIDR)",
        base64: "base64 u\u017Ekoduota eilut\u0117",
        base64url: "base64url u\u017Ekoduota eilut\u0117",
        json_string: "JSON eilut\u0117",
        e164: "E.164 numeris",
        jwt: "JWT",
        template_literal: "\u012Fvestis"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "skai\u010Dius",
        bigint: "sveikasis skai\u010Dius",
        string: "eilut\u0117",
        boolean: "login\u0117 reik\u0161m\u0117",
        undefined: "neapibr\u0117\u017Eta reik\u0161m\u0117",
        function: "funkcija",
        symbol: "simbolis",
        array: "masyvas",
        object: "objektas",
        null: "nulin\u0117 reik\u0161m\u0117"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Gautas tipas ${received}, o tik\u0117tasi - instanceof ${issue22.expected}`;
            }
            return `Gautas tipas ${received}, o tik\u0117tasi - ${expected}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Privalo b\u016Bti ${stringifyPrimitive2(issue22.values[0])}`;
            return `Privalo b\u016Bti vienas i\u0161 ${joinValues2(issue22.values, "|")} pasirinkim\u0173`;
          case "too_big": {
            const origin2 = (_c = TypeDictionary[issue22.origin]) != null ? _c : issue22.origin;
            const sizing = getSizing(issue22.origin, getUnitTypeFromNumber2(Number(issue22.maximum)), (_d = issue22.inclusive) != null ? _d : false, "smaller");
            if (sizing == null ? void 0 : sizing.verb)
              return `${capitalizeFirstCharacter2((_e = origin2 != null ? origin2 : issue22.origin) != null ? _e : "reik\u0161m\u0117")} ${sizing.verb} ${issue22.maximum.toString()} ${(_f = sizing.unit) != null ? _f : "element\u0173"}`;
            const adj = issue22.inclusive ? "ne didesnis kaip" : "ma\u017Eesnis kaip";
            return `${capitalizeFirstCharacter2((_g = origin2 != null ? origin2 : issue22.origin) != null ? _g : "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue22.maximum.toString()} ${sizing == null ? void 0 : sizing.unit}`;
          }
          case "too_small": {
            const origin2 = (_h = TypeDictionary[issue22.origin]) != null ? _h : issue22.origin;
            const sizing = getSizing(issue22.origin, getUnitTypeFromNumber2(Number(issue22.minimum)), (_i = issue22.inclusive) != null ? _i : false, "bigger");
            if (sizing == null ? void 0 : sizing.verb)
              return `${capitalizeFirstCharacter2((_j = origin2 != null ? origin2 : issue22.origin) != null ? _j : "reik\u0161m\u0117")} ${sizing.verb} ${issue22.minimum.toString()} ${(_k = sizing.unit) != null ? _k : "element\u0173"}`;
            const adj = issue22.inclusive ? "ne ma\u017Eesnis kaip" : "didesnis kaip";
            return `${capitalizeFirstCharacter2((_l = origin2 != null ? origin2 : issue22.origin) != null ? _l : "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue22.minimum.toString()} ${sizing == null ? void 0 : sizing.unit}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `Eilut\u0117 privalo prasid\u0117ti "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Eilut\u0117 privalo pasibaigti "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Eilut\u0117 privalo \u012Ftraukti "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Eilut\u0117 privalo atitikti ${_issue.pattern}`;
            return `Neteisingas ${(_m = FormatDictionary[_issue.format]) != null ? _m : issue22.format}`;
          }
          case "not_multiple_of":
            return `Skai\u010Dius privalo b\u016Bti ${issue22.divisor} kartotinis.`;
          case "unrecognized_keys":
            return `Neatpa\u017Eint${issue22.keys.length > 1 ? "i" : "as"} rakt${issue22.keys.length > 1 ? "ai" : "as"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return "Rastas klaidingas raktas";
          case "invalid_union":
            return "Klaidinga \u012Fvestis";
          case "invalid_element": {
            const origin2 = (_n = TypeDictionary[issue22.origin]) != null ? _n : issue22.origin;
            return `${capitalizeFirstCharacter2((_o = origin2 != null ? origin2 : issue22.origin) != null ? _o : "reik\u0161m\u0117")} turi klaiding\u0105 \u012Fvest\u012F`;
          }
          default:
            return "Klaidinga \u012Fvestis";
        }
      };
    };
    error272 = () => {
      const Sizable = {
        string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
        file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
        array: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
        set: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0432\u043D\u0435\u0441",
        email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430",
        url: "URL",
        emoji: "\u0435\u043C\u043E\u045F\u0438",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0434\u0430\u0442\u0443\u043C \u0438 \u0432\u0440\u0435\u043C\u0435",
        date: "ISO \u0434\u0430\u0442\u0443\u043C",
        time: "ISO \u0432\u0440\u0435\u043C\u0435",
        duration: "ISO \u0432\u0440\u0435\u043C\u0435\u0442\u0440\u0430\u0435\u045A\u0435",
        ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441\u0430",
        ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441\u0430",
        cidrv4: "IPv4 \u043E\u043F\u0441\u0435\u0433",
        cidrv6: "IPv6 \u043E\u043F\u0441\u0435\u0433",
        base64: "base64-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
        base64url: "base64url-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
        json_string: "JSON \u043D\u0438\u0437\u0430",
        e164: "E.164 \u0431\u0440\u043E\u0458",
        jwt: "JWT",
        template_literal: "\u0432\u043D\u0435\u0441"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0431\u0440\u043E\u0458",
        array: "\u043D\u0438\u0437\u0430"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 instanceof ${issue22.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
            }
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Invalid input: expected ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u0413\u0440\u0435\u0448\u0430\u043D\u0430 \u043E\u043F\u0446\u0438\u0458\u0430: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 \u0435\u0434\u043D\u0430 ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${(_c = issue22.origin) != null ? _c : "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0438"}`;
            return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${(_e = issue22.origin) != null ? _e : "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue22.origin} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue22.origin} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u043D\u0443\u0432\u0430 \u0441\u043E "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u0432\u0440\u0448\u0443\u0432\u0430 \u0441\u043E "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${_issue.pattern}`;
            return `Invalid ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${issue22.divisor}`;
          case "unrecognized_keys":
            return `${issue22.keys.length > 1 ? "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D\u0438 \u043A\u043B\u0443\u0447\u0435\u0432\u0438" : "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D \u043A\u043B\u0443\u0447"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u043A\u043B\u0443\u0447 \u0432\u043E ${issue22.origin}`;
          case "invalid_union":
            return "\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441";
          case "invalid_element":
            return `\u0413\u0440\u0435\u0448\u043D\u0430 \u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442 \u0432\u043E ${issue22.origin}`;
          default:
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441`;
        }
      };
    };
    error282 = () => {
      const Sizable = {
        string: { unit: "aksara", verb: "mempunyai" },
        file: { unit: "bait", verb: "mempunyai" },
        array: { unit: "elemen", verb: "mempunyai" },
        set: { unit: "elemen", verb: "mempunyai" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "alamat e-mel",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "tarikh masa ISO",
        date: "tarikh ISO",
        time: "masa ISO",
        duration: "tempoh ISO",
        ipv4: "alamat IPv4",
        ipv6: "alamat IPv6",
        cidrv4: "julat IPv4",
        cidrv6: "julat IPv6",
        base64: "string dikodkan base64",
        base64url: "string dikodkan base64url",
        json_string: "string JSON",
        e164: "nombor E.164",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "nombor"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Input tidak sah: dijangka instanceof ${issue22.expected}, diterima ${received}`;
            }
            return `Input tidak sah: dijangka ${expected}, diterima ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Input tidak sah: dijangka ${stringifyPrimitive2(issue22.values[0])}`;
            return `Pilihan tidak sah: dijangka salah satu daripada ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Terlalu besar: dijangka ${(_c = issue22.origin) != null ? _c : "nilai"} ${sizing.verb} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elemen"}`;
            return `Terlalu besar: dijangka ${(_e = issue22.origin) != null ? _e : "nilai"} adalah ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Terlalu kecil: dijangka ${issue22.origin} ${sizing.verb} ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Terlalu kecil: dijangka ${issue22.origin} adalah ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `String tidak sah: mesti bermula dengan "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `String tidak sah: mesti berakhir dengan "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `String tidak sah: mesti mengandungi "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`;
            return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format} tidak sah`;
          }
          case "not_multiple_of":
            return `Nombor tidak sah: perlu gandaan ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Kunci tidak dikenali: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Kunci tidak sah dalam ${issue22.origin}`;
          case "invalid_union":
            return "Input tidak sah";
          case "invalid_element":
            return `Nilai tidak sah dalam ${issue22.origin}`;
          default:
            return `Input tidak sah`;
        }
      };
    };
    error292 = () => {
      const Sizable = {
        string: { unit: "tekens", verb: "heeft" },
        file: { unit: "bytes", verb: "heeft" },
        array: { unit: "elementen", verb: "heeft" },
        set: { unit: "elementen", verb: "heeft" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "invoer",
        email: "emailadres",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datum en tijd",
        date: "ISO datum",
        time: "ISO tijd",
        duration: "ISO duur",
        ipv4: "IPv4-adres",
        ipv6: "IPv6-adres",
        cidrv4: "IPv4-bereik",
        cidrv6: "IPv6-bereik",
        base64: "base64-gecodeerde tekst",
        base64url: "base64 URL-gecodeerde tekst",
        json_string: "JSON string",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "invoer"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "getal"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Ongeldige invoer: verwacht instanceof ${issue22.expected}, ontving ${received}`;
            }
            return `Ongeldige invoer: verwacht ${expected}, ontving ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Ongeldige invoer: verwacht ${stringifyPrimitive2(issue22.values[0])}`;
            return `Ongeldige optie: verwacht \xE9\xE9n van ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            const longName = issue22.origin === "date" ? "laat" : issue22.origin === "string" ? "lang" : "groot";
            if (sizing)
              return `Te ${longName}: verwacht dat ${(_c = issue22.origin) != null ? _c : "waarde"} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementen"} ${sizing.verb}`;
            return `Te ${longName}: verwacht dat ${(_e = issue22.origin) != null ? _e : "waarde"} ${adj}${issue22.maximum.toString()} is`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            const shortName = issue22.origin === "date" ? "vroeg" : issue22.origin === "string" ? "kort" : "klein";
            if (sizing) {
              return `Te ${shortName}: verwacht dat ${issue22.origin} ${adj}${issue22.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
            }
            return `Te ${shortName}: verwacht dat ${issue22.origin} ${adj}${issue22.minimum.toString()} is`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `Ongeldige tekst: moet met "${_issue.prefix}" beginnen`;
            }
            if (_issue.format === "ends_with")
              return `Ongeldige tekst: moet op "${_issue.suffix}" eindigen`;
            if (_issue.format === "includes")
              return `Ongeldige tekst: moet "${_issue.includes}" bevatten`;
            if (_issue.format === "regex")
              return `Ongeldige tekst: moet overeenkomen met patroon ${_issue.pattern}`;
            return `Ongeldig: ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Ongeldig getal: moet een veelvoud van ${issue22.divisor} zijn`;
          case "unrecognized_keys":
            return `Onbekende key${issue22.keys.length > 1 ? "s" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Ongeldige key in ${issue22.origin}`;
          case "invalid_union":
            return "Ongeldige invoer";
          case "invalid_element":
            return `Ongeldige waarde in ${issue22.origin}`;
          default:
            return `Ongeldige invoer`;
        }
      };
    };
    error302 = () => {
      const Sizable = {
        string: { unit: "tegn", verb: "\xE5 ha" },
        file: { unit: "bytes", verb: "\xE5 ha" },
        array: { unit: "elementer", verb: "\xE5 inneholde" },
        set: { unit: "elementer", verb: "\xE5 inneholde" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "e-postadresse",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO dato- og klokkeslett",
        date: "ISO-dato",
        time: "ISO-klokkeslett",
        duration: "ISO-varighet",
        ipv4: "IPv4-omr\xE5de",
        ipv6: "IPv6-omr\xE5de",
        cidrv4: "IPv4-spekter",
        cidrv6: "IPv6-spekter",
        base64: "base64-enkodet streng",
        base64url: "base64url-enkodet streng",
        json_string: "JSON-streng",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "tall",
        array: "liste"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Ugyldig input: forventet instanceof ${issue22.expected}, fikk ${received}`;
            }
            return `Ugyldig input: forventet ${expected}, fikk ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Ugyldig verdi: forventet ${stringifyPrimitive2(issue22.values[0])}`;
            return `Ugyldig valg: forventet en av ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `For stor(t): forventet ${(_c = issue22.origin) != null ? _c : "value"} til \xE5 ha ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementer"}`;
            return `For stor(t): forventet ${(_e = issue22.origin) != null ? _e : "value"} til \xE5 ha ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `For lite(n): forventet ${issue22.origin} til \xE5 ha ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `For lite(n): forventet ${issue22.origin} til \xE5 ha ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Ugyldig streng: m\xE5 starte med "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Ugyldig streng: m\xE5 ende med "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Ugyldig streng: m\xE5 inneholde "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${_issue.pattern}`;
            return `Ugyldig ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${issue22.divisor}`;
          case "unrecognized_keys":
            return `${issue22.keys.length > 1 ? "Ukjente n\xF8kler" : "Ukjent n\xF8kkel"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Ugyldig n\xF8kkel i ${issue22.origin}`;
          case "invalid_union":
            return "Ugyldig input";
          case "invalid_element":
            return `Ugyldig verdi i ${issue22.origin}`;
          default:
            return `Ugyldig input`;
        }
      };
    };
    error312 = () => {
      const Sizable = {
        string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
        file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
        array: { unit: "unsur", verb: "olmal\u0131d\u0131r" },
        set: { unit: "unsur", verb: "olmal\u0131d\u0131r" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "giren",
        email: "epostag\xE2h",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO heng\xE2m\u0131",
        date: "ISO tarihi",
        time: "ISO zaman\u0131",
        duration: "ISO m\xFCddeti",
        ipv4: "IPv4 ni\u015F\xE2n\u0131",
        ipv6: "IPv6 ni\u015F\xE2n\u0131",
        cidrv4: "IPv4 menzili",
        cidrv6: "IPv6 menzili",
        base64: "base64-\u015Fifreli metin",
        base64url: "base64url-\u015Fifreli metin",
        json_string: "JSON metin",
        e164: "E.164 say\u0131s\u0131",
        jwt: "JWT",
        template_literal: "giren"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "numara",
        array: "saf",
        null: "gayb"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `F\xE2sit giren: umulan instanceof ${issue22.expected}, al\u0131nan ${received}`;
            }
            return `F\xE2sit giren: umulan ${expected}, al\u0131nan ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `F\xE2sit giren: umulan ${stringifyPrimitive2(issue22.values[0])}`;
            return `F\xE2sit tercih: m\xFBteberler ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Fazla b\xFCy\xFCk: ${(_c = issue22.origin) != null ? _c : "value"}, ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elements"} sahip olmal\u0131yd\u0131.`;
            return `Fazla b\xFCy\xFCk: ${(_e = issue22.origin) != null ? _e : "value"}, ${adj}${issue22.maximum.toString()} olmal\u0131yd\u0131.`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Fazla k\xFC\xE7\xFCk: ${issue22.origin}, ${adj}${issue22.minimum.toString()} ${sizing.unit} sahip olmal\u0131yd\u0131.`;
            }
            return `Fazla k\xFC\xE7\xFCk: ${issue22.origin}, ${adj}${issue22.minimum.toString()} olmal\u0131yd\u0131.`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `F\xE2sit metin: "${_issue.prefix}" ile ba\u015Flamal\u0131.`;
            if (_issue.format === "ends_with")
              return `F\xE2sit metin: "${_issue.suffix}" ile bitmeli.`;
            if (_issue.format === "includes")
              return `F\xE2sit metin: "${_issue.includes}" ihtiv\xE2 etmeli.`;
            if (_issue.format === "regex")
              return `F\xE2sit metin: ${_issue.pattern} nak\u015F\u0131na uymal\u0131.`;
            return `F\xE2sit ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `F\xE2sit say\u0131: ${issue22.divisor} kat\u0131 olmal\u0131yd\u0131.`;
          case "unrecognized_keys":
            return `Tan\u0131nmayan anahtar ${issue22.keys.length > 1 ? "s" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `${issue22.origin} i\xE7in tan\u0131nmayan anahtar var.`;
          case "invalid_union":
            return "Giren tan\u0131namad\u0131.";
          case "invalid_element":
            return `${issue22.origin} i\xE7in tan\u0131nmayan k\u0131ymet var.`;
          default:
            return `K\u0131ymet tan\u0131namad\u0131.`;
        }
      };
    };
    error322 = () => {
      const Sizable = {
        string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
        file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
        array: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
        set: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0648\u0631\u0648\u062F\u064A",
        email: "\u0628\u0631\u06CC\u069A\u0646\u0627\u0644\u06CC\u06A9",
        url: "\u06CC\u0648 \u0622\u0631 \u0627\u0644",
        emoji: "\u0627\u06CC\u0645\u0648\u062C\u064A",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u0646\u06CC\u067C\u0647 \u0627\u0648 \u0648\u062E\u062A",
        date: "\u0646\u06D0\u067C\u0647",
        time: "\u0648\u062E\u062A",
        duration: "\u0645\u0648\u062F\u0647",
        ipv4: "\u062F IPv4 \u067E\u062A\u0647",
        ipv6: "\u062F IPv6 \u067E\u062A\u0647",
        cidrv4: "\u062F IPv4 \u0633\u0627\u062D\u0647",
        cidrv6: "\u062F IPv6 \u0633\u0627\u062D\u0647",
        base64: "base64-encoded \u0645\u062A\u0646",
        base64url: "base64url-encoded \u0645\u062A\u0646",
        json_string: "JSON \u0645\u062A\u0646",
        e164: "\u062F E.164 \u0634\u0645\u06D0\u0631\u0647",
        jwt: "JWT",
        template_literal: "\u0648\u0631\u0648\u062F\u064A"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0639\u062F\u062F",
        array: "\u0627\u0631\u06D0"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F instanceof ${issue22.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
            }
            return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
          }
          case "invalid_value":
            if (issue22.values.length === 1) {
              return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${stringifyPrimitive2(issue22.values[0])} \u0648\u0627\u06CC`;
            }
            return `\u0646\u0627\u0633\u0645 \u0627\u0646\u062A\u062E\u0627\u0628: \u0628\u0627\u06CC\u062F \u06CC\u0648 \u0644\u0647 ${joinValues2(issue22.values, "|")} \u0685\u062E\u0647 \u0648\u0627\u06CC`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${(_c = issue22.origin) != null ? _c : "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0639\u0646\u0635\u0631\u0648\u0646\u0647"} \u0648\u0644\u0631\u064A`;
            }
            return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${(_e = issue22.origin) != null ? _e : "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue22.maximum.toString()} \u0648\u064A`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue22.origin} \u0628\u0627\u06CC\u062F ${adj}${issue22.minimum.toString()} ${sizing.unit} \u0648\u0644\u0631\u064A`;
            }
            return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue22.origin} \u0628\u0627\u06CC\u062F ${adj}${issue22.minimum.toString()} \u0648\u064A`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.prefix}" \u0633\u0631\u0647 \u067E\u06CC\u0644 \u0634\u064A`;
            }
            if (_issue.format === "ends_with") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.suffix}" \u0633\u0631\u0647 \u067E\u0627\u06CC \u062A\u0647 \u0648\u0631\u0633\u064A\u0696\u064A`;
            }
            if (_issue.format === "includes") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F "${_issue.includes}" \u0648\u0644\u0631\u064A`;
            }
            if (_issue.format === "regex") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F ${_issue.pattern} \u0633\u0631\u0647 \u0645\u0637\u0627\u0628\u0642\u062A \u0648\u0644\u0631\u064A`;
            }
            return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`;
          }
          case "not_multiple_of":
            return `\u0646\u0627\u0633\u0645 \u0639\u062F\u062F: \u0628\u0627\u06CC\u062F \u062F ${issue22.divisor} \u0645\u0636\u0631\u0628 \u0648\u064A`;
          case "unrecognized_keys":
            return `\u0646\u0627\u0633\u0645 ${issue22.keys.length > 1 ? "\u06A9\u0644\u06CC\u0689\u0648\u0646\u0647" : "\u06A9\u0644\u06CC\u0689"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u0646\u0627\u0633\u0645 \u06A9\u0644\u06CC\u0689 \u067E\u0647 ${issue22.origin} \u06A9\u06D0`;
          case "invalid_union":
            return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
          case "invalid_element":
            return `\u0646\u0627\u0633\u0645 \u0639\u0646\u0635\u0631 \u067E\u0647 ${issue22.origin} \u06A9\u06D0`;
          default:
            return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
        }
      };
    };
    error332 = () => {
      const Sizable = {
        string: { unit: "znak\xF3w", verb: "mie\u0107" },
        file: { unit: "bajt\xF3w", verb: "mie\u0107" },
        array: { unit: "element\xF3w", verb: "mie\u0107" },
        set: { unit: "element\xF3w", verb: "mie\u0107" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "wyra\u017Cenie",
        email: "adres email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data i godzina w formacie ISO",
        date: "data w formacie ISO",
        time: "godzina w formacie ISO",
        duration: "czas trwania ISO",
        ipv4: "adres IPv4",
        ipv6: "adres IPv6",
        cidrv4: "zakres IPv4",
        cidrv6: "zakres IPv6",
        base64: "ci\u0105g znak\xF3w zakodowany w formacie base64",
        base64url: "ci\u0105g znak\xF3w zakodowany w formacie base64url",
        json_string: "ci\u0105g znak\xF3w w formacie JSON",
        e164: "liczba E.164",
        jwt: "JWT",
        template_literal: "wej\u015Bcie"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "liczba",
        array: "tablica"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f, _g, _h, _i;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano instanceof ${issue22.expected}, otrzymano ${received}`;
            }
            return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${expected}, otrzymano ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${stringifyPrimitive2(issue22.values[0])}`;
            return `Nieprawid\u0142owa opcja: oczekiwano jednej z warto\u015Bci ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Za du\u017Ca warto\u015B\u0107: oczekiwano, \u017Ce ${(_c = issue22.origin) != null ? _c : "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "element\xF3w"}`;
            }
            return `Zbyt du\u017C(y/a/e): oczekiwano, \u017Ce ${(_e = issue22.origin) != null ? _e : "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Za ma\u0142a warto\u015B\u0107: oczekiwano, \u017Ce ${(_f = issue22.origin) != null ? _f : "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue22.minimum.toString()} ${(_g = sizing.unit) != null ? _g : "element\xF3w"}`;
            }
            return `Zbyt ma\u0142(y/a/e): oczekiwano, \u017Ce ${(_h = issue22.origin) != null ? _h : "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zaczyna\u0107 si\u0119 od "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi ko\u0144czy\u0107 si\u0119 na "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${_issue.pattern}`;
            return `Nieprawid\u0142ow(y/a/e) ${(_i = FormatDictionary[_issue.format]) != null ? _i : issue22.format}`;
          }
          case "not_multiple_of":
            return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Nierozpoznane klucze${issue22.keys.length > 1 ? "s" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Nieprawid\u0142owy klucz w ${issue22.origin}`;
          case "invalid_union":
            return "Nieprawid\u0142owe dane wej\u015Bciowe";
          case "invalid_element":
            return `Nieprawid\u0142owa warto\u015B\u0107 w ${issue22.origin}`;
          default:
            return `Nieprawid\u0142owe dane wej\u015Bciowe`;
        }
      };
    };
    error342 = () => {
      const Sizable = {
        string: { unit: "caracteres", verb: "ter" },
        file: { unit: "bytes", verb: "ter" },
        array: { unit: "itens", verb: "ter" },
        set: { unit: "itens", verb: "ter" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "padr\xE3o",
        email: "endere\xE7o de e-mail",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data e hora ISO",
        date: "data ISO",
        time: "hora ISO",
        duration: "dura\xE7\xE3o ISO",
        ipv4: "endere\xE7o IPv4",
        ipv6: "endere\xE7o IPv6",
        cidrv4: "faixa de IPv4",
        cidrv6: "faixa de IPv6",
        base64: "texto codificado em base64",
        base64url: "URL codificada em base64",
        json_string: "texto JSON",
        e164: "n\xFAmero E.164",
        jwt: "JWT",
        template_literal: "entrada"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "n\xFAmero",
        null: "nulo"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Tipo inv\xE1lido: esperado instanceof ${issue22.expected}, recebido ${received}`;
            }
            return `Tipo inv\xE1lido: esperado ${expected}, recebido ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Entrada inv\xE1lida: esperado ${stringifyPrimitive2(issue22.values[0])}`;
            return `Op\xE7\xE3o inv\xE1lida: esperada uma das ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Muito grande: esperado que ${(_c = issue22.origin) != null ? _c : "valor"} tivesse ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementos"}`;
            return `Muito grande: esperado que ${(_e = issue22.origin) != null ? _e : "valor"} fosse ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Muito pequeno: esperado que ${issue22.origin} tivesse ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Muito pequeno: esperado que ${issue22.origin} fosse ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Texto inv\xE1lido: deve come\xE7ar com "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Texto inv\xE1lido: deve terminar com "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Texto inv\xE1lido: deve incluir "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${_issue.pattern}`;
            return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format} inv\xE1lido`;
          }
          case "not_multiple_of":
            return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Chave${issue22.keys.length > 1 ? "s" : ""} desconhecida${issue22.keys.length > 1 ? "s" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Chave inv\xE1lida em ${issue22.origin}`;
          case "invalid_union":
            return "Entrada inv\xE1lida";
          case "invalid_element":
            return `Valor inv\xE1lido em ${issue22.origin}`;
          default:
            return `Campo inv\xE1lido`;
        }
      };
    };
    error352 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "\u0441\u0438\u043C\u0432\u043E\u043B",
            few: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430",
            many: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        },
        file: {
          unit: {
            one: "\u0431\u0430\u0439\u0442",
            few: "\u0431\u0430\u0439\u0442\u0430",
            many: "\u0431\u0430\u0439\u0442"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        },
        array: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        },
        set: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0432\u0432\u043E\u0434",
        email: "email \u0430\u0434\u0440\u0435\u0441",
        url: "URL",
        emoji: "\u044D\u043C\u043E\u0434\u0437\u0438",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F",
        date: "ISO \u0434\u0430\u0442\u0430",
        time: "ISO \u0432\u0440\u0435\u043C\u044F",
        duration: "ISO \u0434\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C",
        ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
        ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
        cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        base64: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64",
        base64url: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64url",
        json_string: "JSON \u0441\u0442\u0440\u043E\u043A\u0430",
        e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
        jwt: "JWT",
        template_literal: "\u0432\u0432\u043E\u0434"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0447\u0438\u0441\u043B\u043E",
        array: "\u043C\u0430\u0441\u0441\u0438\u0432"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C instanceof ${issue22.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
            }
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0434\u043D\u043E \u0438\u0437 ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              const maxValue = Number(issue22.maximum);
              const unit = getRussianPlural2(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${(_c = issue22.origin) != null ? _c : "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue22.maximum.toString()} ${unit}`;
            }
            return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${(_d = issue22.origin) != null ? _d : "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              const minValue = Number(issue22.minimum);
              const unit = getRussianPlural2(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue22.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue22.minimum.toString()} ${unit}`;
            }
            return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue22.origin} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0437\u0430\u043A\u0430\u043D\u0447\u0438\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue22.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D\u043D${issue22.keys.length > 1 ? "\u044B\u0435" : "\u044B\u0439"} \u043A\u043B\u044E\u0447${issue22.keys.length > 1 ? "\u0438" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u043A\u043B\u044E\u0447 \u0432 ${issue22.origin}`;
          case "invalid_union":
            return "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435";
          case "invalid_element":
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0432 ${issue22.origin}`;
          default:
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435`;
        }
      };
    };
    error362 = () => {
      const Sizable = {
        string: { unit: "znakov", verb: "imeti" },
        file: { unit: "bajtov", verb: "imeti" },
        array: { unit: "elementov", verb: "imeti" },
        set: { unit: "elementov", verb: "imeti" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "vnos",
        email: "e-po\u0161tni naslov",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datum in \u010Das",
        date: "ISO datum",
        time: "ISO \u010Das",
        duration: "ISO trajanje",
        ipv4: "IPv4 naslov",
        ipv6: "IPv6 naslov",
        cidrv4: "obseg IPv4",
        cidrv6: "obseg IPv6",
        base64: "base64 kodiran niz",
        base64url: "base64url kodiran niz",
        json_string: "JSON niz",
        e164: "E.164 \u0161tevilka",
        jwt: "JWT",
        template_literal: "vnos"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0161tevilo",
        array: "tabela"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Neveljaven vnos: pri\u010Dakovano instanceof ${issue22.expected}, prejeto ${received}`;
            }
            return `Neveljaven vnos: pri\u010Dakovano ${expected}, prejeto ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Neveljaven vnos: pri\u010Dakovano ${stringifyPrimitive2(issue22.values[0])}`;
            return `Neveljavna mo\u017Enost: pri\u010Dakovano eno izmed ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Preveliko: pri\u010Dakovano, da bo ${(_c = issue22.origin) != null ? _c : "vrednost"} imelo ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "elementov"}`;
            return `Preveliko: pri\u010Dakovano, da bo ${(_e = issue22.origin) != null ? _e : "vrednost"} ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Premajhno: pri\u010Dakovano, da bo ${issue22.origin} imelo ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Premajhno: pri\u010Dakovano, da bo ${issue22.origin} ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `Neveljaven niz: mora se za\u010Deti z "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Neveljaven niz: mora se kon\u010Dati z "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Neveljaven niz: mora vsebovati "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`;
            return `Neveljaven ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Neprepoznan${issue22.keys.length > 1 ? "i klju\u010Di" : " klju\u010D"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Neveljaven klju\u010D v ${issue22.origin}`;
          case "invalid_union":
            return "Neveljaven vnos";
          case "invalid_element":
            return `Neveljavna vrednost v ${issue22.origin}`;
          default:
            return "Neveljaven vnos";
        }
      };
    };
    error372 = () => {
      const Sizable = {
        string: { unit: "tecken", verb: "att ha" },
        file: { unit: "bytes", verb: "att ha" },
        array: { unit: "objekt", verb: "att inneh\xE5lla" },
        set: { unit: "objekt", verb: "att inneh\xE5lla" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "regulj\xE4rt uttryck",
        email: "e-postadress",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-datum och tid",
        date: "ISO-datum",
        time: "ISO-tid",
        duration: "ISO-varaktighet",
        ipv4: "IPv4-intervall",
        ipv6: "IPv6-intervall",
        cidrv4: "IPv4-spektrum",
        cidrv6: "IPv6-spektrum",
        base64: "base64-kodad str\xE4ng",
        base64url: "base64url-kodad str\xE4ng",
        json_string: "JSON-str\xE4ng",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "mall-literal"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "antal",
        array: "lista"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f, _g, _h, _i, _j;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Ogiltig inmatning: f\xF6rv\xE4ntat instanceof ${issue22.expected}, fick ${received}`;
            }
            return `Ogiltig inmatning: f\xF6rv\xE4ntat ${expected}, fick ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Ogiltig inmatning: f\xF6rv\xE4ntat ${stringifyPrimitive2(issue22.values[0])}`;
            return `Ogiltigt val: f\xF6rv\xE4ntade en av ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `F\xF6r stor(t): f\xF6rv\xE4ntade ${(_c = issue22.origin) != null ? _c : "v\xE4rdet"} att ha ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "element"}`;
            }
            return `F\xF6r stor(t): f\xF6rv\xE4ntat ${(_e = issue22.origin) != null ? _e : "v\xE4rdet"} att ha ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `F\xF6r lite(t): f\xF6rv\xE4ntade ${(_f = issue22.origin) != null ? _f : "v\xE4rdet"} att ha ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `F\xF6r lite(t): f\xF6rv\xE4ntade ${(_g = issue22.origin) != null ? _g : "v\xE4rdet"} att ha ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `Ogiltig str\xE4ng: m\xE5ste b\xF6rja med "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Ogiltig str\xE4ng: m\xE5ste sluta med "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${_issue.pattern}"`;
            return `Ogiltig(t) ${(_h = FormatDictionary[_issue.format]) != null ? _h : issue22.format}`;
          }
          case "not_multiple_of":
            return `Ogiltigt tal: m\xE5ste vara en multipel av ${issue22.divisor}`;
          case "unrecognized_keys":
            return `${issue22.keys.length > 1 ? "Ok\xE4nda nycklar" : "Ok\xE4nd nyckel"}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Ogiltig nyckel i ${(_i = issue22.origin) != null ? _i : "v\xE4rdet"}`;
          case "invalid_union":
            return "Ogiltig input";
          case "invalid_element":
            return `Ogiltigt v\xE4rde i ${(_j = issue22.origin) != null ? _j : "v\xE4rdet"}`;
          default:
            return `Ogiltig input`;
        }
      };
    };
    error382 = () => {
      const Sizable = {
        string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
        file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
        array: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
        set: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1",
        email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0BA4\u0BC7\u0BA4\u0BBF \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
        date: "ISO \u0BA4\u0BC7\u0BA4\u0BBF",
        time: "ISO \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
        duration: "ISO \u0B95\u0BBE\u0BB2 \u0B85\u0BB3\u0BB5\u0BC1",
        ipv4: "IPv4 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
        ipv6: "IPv6 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
        cidrv4: "IPv4 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
        cidrv6: "IPv6 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
        base64: "base64-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
        base64url: "base64url-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
        json_string: "JSON \u0B9A\u0BB0\u0BAE\u0BCD",
        e164: "E.164 \u0B8E\u0BA3\u0BCD",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0B8E\u0BA3\u0BCD",
        array: "\u0B85\u0BA3\u0BBF",
        null: "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 instanceof ${issue22.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
            }
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0BB0\u0BC1\u0BAA\u0BCD\u0BAA\u0BAE\u0BCD: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${joinValues2(issue22.values, "|")} \u0B87\u0BB2\u0BCD \u0B92\u0BA9\u0BCD\u0BB1\u0BC1`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${(_c = issue22.origin) != null ? _c : "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD"} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            }
            return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${(_e = issue22.origin) != null ? _e : "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue22.maximum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue22.origin} ${adj}${issue22.minimum.toString()} ${sizing.unit} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            }
            return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue22.origin} ${adj}${issue22.minimum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.prefix}" \u0B87\u0BB2\u0BCD \u0BA4\u0BCA\u0B9F\u0B99\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            if (_issue.format === "ends_with")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.suffix}" \u0B87\u0BB2\u0BCD \u0BAE\u0BC1\u0B9F\u0BBF\u0BB5\u0B9F\u0BC8\u0BAF \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            if (_issue.format === "includes")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            if (_issue.format === "regex")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${_issue.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${issue22.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
          case "unrecognized_keys":
            return `\u0B85\u0B9F\u0BC8\u0BAF\u0BBE\u0BB3\u0BAE\u0BCD \u0BA4\u0BC6\u0BB0\u0BBF\u0BAF\u0BBE\u0BA4 \u0BB5\u0BBF\u0B9A\u0BC8${issue22.keys.length > 1 ? "\u0B95\u0BB3\u0BCD" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `${issue22.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0B9A\u0BC8`;
          case "invalid_union":
            return "\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1";
          case "invalid_element":
            return `${issue22.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1`;
          default:
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1`;
        }
      };
    };
    error392 = () => {
      const Sizable = {
        string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
        file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
        array: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
        set: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19",
        email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25",
        url: "URL",
        emoji: "\u0E2D\u0E34\u0E42\u0E21\u0E08\u0E34",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
        date: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E41\u0E1A\u0E1A ISO",
        time: "\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
        duration: "\u0E0A\u0E48\u0E27\u0E07\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
        ipv4: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv4",
        ipv6: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv6",
        cidrv4: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv4",
        cidrv6: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv6",
        base64: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64",
        base64url: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64 \u0E2A\u0E33\u0E2B\u0E23\u0E31\u0E1A URL",
        json_string: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A JSON",
        e164: "\u0E40\u0E1A\u0E2D\u0E23\u0E4C\u0E42\u0E17\u0E23\u0E28\u0E31\u0E1E\u0E17\u0E4C\u0E23\u0E30\u0E2B\u0E27\u0E48\u0E32\u0E07\u0E1B\u0E23\u0E30\u0E40\u0E17\u0E28 (E.164)",
        jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT",
        template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02",
        array: "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)",
        null: "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 instanceof ${issue22.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
            }
            return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19\u0E2B\u0E19\u0E36\u0E48\u0E07\u0E43\u0E19 ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19" : "\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${(_c = issue22.origin) != null ? _c : "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23"}`;
            return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${(_e = issue22.origin) != null ? _e : "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22" : "\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue22.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue22.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E02\u0E36\u0E49\u0E19\u0E15\u0E49\u0E19\u0E14\u0E49\u0E27\u0E22 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E25\u0E07\u0E17\u0E49\u0E32\u0E22\u0E14\u0E49\u0E27\u0E22 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${_issue.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`;
            if (_issue.format === "regex")
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${_issue.pattern}`;
            return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${issue22.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`;
          case "unrecognized_keys":
            return `\u0E1E\u0E1A\u0E04\u0E35\u0E22\u0E4C\u0E17\u0E35\u0E48\u0E44\u0E21\u0E48\u0E23\u0E39\u0E49\u0E08\u0E31\u0E01: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u0E04\u0E35\u0E22\u0E4C\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue22.origin}`;
          case "invalid_union":
            return "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E44\u0E21\u0E48\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E22\u0E39\u0E40\u0E19\u0E35\u0E22\u0E19\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14\u0E44\u0E27\u0E49";
          case "invalid_element":
            return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue22.origin}`;
          default:
            return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07`;
        }
      };
    };
    error402 = () => {
      const Sizable = {
        string: { unit: "karakter", verb: "olmal\u0131" },
        file: { unit: "bayt", verb: "olmal\u0131" },
        array: { unit: "\xF6\u011Fe", verb: "olmal\u0131" },
        set: { unit: "\xF6\u011Fe", verb: "olmal\u0131" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "girdi",
        email: "e-posta adresi",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO tarih ve saat",
        date: "ISO tarih",
        time: "ISO saat",
        duration: "ISO s\xFCre",
        ipv4: "IPv4 adresi",
        ipv6: "IPv6 adresi",
        cidrv4: "IPv4 aral\u0131\u011F\u0131",
        cidrv6: "IPv6 aral\u0131\u011F\u0131",
        base64: "base64 ile \u015Fifrelenmi\u015F metin",
        base64url: "base64url ile \u015Fifrelenmi\u015F metin",
        json_string: "JSON dizesi",
        e164: "E.164 say\u0131s\u0131",
        jwt: "JWT",
        template_literal: "\u015Eablon dizesi"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Ge\xE7ersiz de\u011Fer: beklenen instanceof ${issue22.expected}, al\u0131nan ${received}`;
            }
            return `Ge\xE7ersiz de\u011Fer: beklenen ${expected}, al\u0131nan ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Ge\xE7ersiz de\u011Fer: beklenen ${stringifyPrimitive2(issue22.values[0])}`;
            return `Ge\xE7ersiz se\xE7enek: a\u015Fa\u011F\u0131dakilerden biri olmal\u0131: ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\xC7ok b\xFCy\xFCk: beklenen ${(_c = issue22.origin) != null ? _c : "de\u011Fer"} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\xF6\u011Fe"}`;
            return `\xC7ok b\xFCy\xFCk: beklenen ${(_e = issue22.origin) != null ? _e : "de\u011Fer"} ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue22.origin} ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue22.origin} ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Ge\xE7ersiz metin: "${_issue.prefix}" ile ba\u015Flamal\u0131`;
            if (_issue.format === "ends_with")
              return `Ge\xE7ersiz metin: "${_issue.suffix}" ile bitmeli`;
            if (_issue.format === "includes")
              return `Ge\xE7ersiz metin: "${_issue.includes}" i\xE7ermeli`;
            if (_issue.format === "regex")
              return `Ge\xE7ersiz metin: ${_issue.pattern} desenine uymal\u0131`;
            return `Ge\xE7ersiz ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `Ge\xE7ersiz say\u0131: ${issue22.divisor} ile tam b\xF6l\xFCnebilmeli`;
          case "unrecognized_keys":
            return `Tan\u0131nmayan anahtar${issue22.keys.length > 1 ? "lar" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `${issue22.origin} i\xE7inde ge\xE7ersiz anahtar`;
          case "invalid_union":
            return "Ge\xE7ersiz de\u011Fer";
          case "invalid_element":
            return `${issue22.origin} i\xE7inde ge\xE7ersiz de\u011Fer`;
          default:
            return `Ge\xE7ersiz de\u011Fer`;
        }
      };
    };
    error412 = () => {
      const Sizable = {
        string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
        file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
        array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
        set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456",
        email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438",
        url: "URL",
        emoji: "\u0435\u043C\u043E\u0434\u0437\u0456",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u0434\u0430\u0442\u0430 \u0442\u0430 \u0447\u0430\u0441 ISO",
        date: "\u0434\u0430\u0442\u0430 ISO",
        time: "\u0447\u0430\u0441 ISO",
        duration: "\u0442\u0440\u0438\u0432\u0430\u043B\u0456\u0441\u0442\u044C ISO",
        ipv4: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv4",
        ipv6: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv6",
        cidrv4: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv4",
        cidrv6: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv6",
        base64: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64",
        base64url: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64url",
        json_string: "\u0440\u044F\u0434\u043E\u043A JSON",
        e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
        jwt: "JWT",
        template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0447\u0438\u0441\u043B\u043E",
        array: "\u043C\u0430\u0441\u0438\u0432"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F instanceof ${issue22.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
            }
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0430 \u043E\u043F\u0446\u0456\u044F: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F \u043E\u0434\u043D\u0435 \u0437 ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${(_c = issue22.origin) != null ? _c : "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} ${sizing.verb} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432"}`;
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${(_e = issue22.origin) != null ? _e : "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} \u0431\u0443\u0434\u0435 ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue22.origin} ${sizing.verb} ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue22.origin} \u0431\u0443\u0434\u0435 ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043F\u043E\u0447\u0438\u043D\u0430\u0442\u0438\u0441\u044F \u0437 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0437\u0430\u043A\u0456\u043D\u0447\u0443\u0432\u0430\u0442\u0438\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${issue22.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u043E\u0437\u043F\u0456\u0437\u043D\u0430\u043D\u0438\u0439 \u043A\u043B\u044E\u0447${issue22.keys.length > 1 ? "\u0456" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u043A\u043B\u044E\u0447 \u0443 ${issue22.origin}`;
          case "invalid_union":
            return "\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456";
          case "invalid_element":
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F \u0443 ${issue22.origin}`;
          default:
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456`;
        }
      };
    };
    error422 = () => {
      const Sizable = {
        string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
        file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
        array: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" },
        set: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0627\u0646 \u067E\u0679",
        email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633",
        url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644",
        emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
        uuid: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        uuidv4: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 4",
        uuidv6: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 6",
        nanoid: "\u0646\u06CC\u0646\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        guid: "\u062C\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        cuid: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        cuid2: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC 2",
        ulid: "\u06CC\u0648 \u0627\u06CC\u0644 \u0622\u0626\u06CC \u0688\u06CC",
        xid: "\u0627\u06CC\u06A9\u0633 \u0622\u0626\u06CC \u0688\u06CC",
        ksuid: "\u06A9\u06D2 \u0627\u06CC\u0633 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        datetime: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0688\u06CC\u0679 \u0679\u0627\u0626\u0645",
        date: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u062A\u0627\u0631\u06CC\u062E",
        time: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0648\u0642\u062A",
        duration: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0645\u062F\u062A",
        ipv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0627\u06CC\u0688\u0631\u06CC\u0633",
        ipv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0627\u06CC\u0688\u0631\u06CC\u0633",
        cidrv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0631\u06CC\u0646\u062C",
        cidrv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0631\u06CC\u0646\u062C",
        base64: "\u0628\u06CC\u0633 64 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
        base64url: "\u0628\u06CC\u0633 64 \u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
        json_string: "\u062C\u06D2 \u0627\u06CC\u0633 \u0627\u0648 \u0627\u06CC\u0646 \u0633\u0679\u0631\u0646\u06AF",
        e164: "\u0627\u06CC 164 \u0646\u0645\u0628\u0631",
        jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC",
        template_literal: "\u0627\u0646 \u067E\u0679"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0646\u0645\u0628\u0631",
        array: "\u0622\u0631\u06D2",
        null: "\u0646\u0644"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: instanceof ${issue22.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
            }
            return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${stringifyPrimitive2(issue22.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
            return `\u063A\u0644\u0637 \u0622\u067E\u0634\u0646: ${joinValues2(issue22.values, "|")} \u0645\u06CC\u06BA \u0633\u06D2 \u0627\u06CC\u06A9 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${(_c = issue22.origin) != null ? _c : "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u06D2 ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u0639\u0646\u0627\u0635\u0631"} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
            return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${(_e = issue22.origin) != null ? _e : "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u0627 ${adj}${issue22.maximum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue22.origin} \u06A9\u06D2 ${adj}${issue22.minimum.toString()} ${sizing.unit} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
            }
            return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue22.origin} \u06A9\u0627 ${adj}${issue22.minimum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.prefix}" \u0633\u06D2 \u0634\u0631\u0648\u0639 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            }
            if (_issue.format === "ends_with")
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.suffix}" \u067E\u0631 \u062E\u062A\u0645 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            if (_issue.format === "includes")
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            if (_issue.format === "regex")
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${_issue.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            return `\u063A\u0644\u0637 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${issue22.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
          case "unrecognized_keys":
            return `\u063A\u06CC\u0631 \u062A\u0633\u0644\u06CC\u0645 \u0634\u062F\u06C1 \u06A9\u06CC${issue22.keys.length > 1 ? "\u0632" : ""}: ${joinValues2(issue22.keys, "\u060C ")}`;
          case "invalid_key":
            return `${issue22.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u06A9\u06CC`;
          case "invalid_union":
            return "\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679";
          case "invalid_element":
            return `${issue22.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u0648\u06CC\u0644\u06CC\u0648`;
          default:
            return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679`;
        }
      };
    };
    error432 = () => {
      const Sizable = {
        string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
        file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
        array: { unit: "element", verb: "bo\u2018lishi kerak" },
        set: { unit: "element", verb: "bo\u2018lishi kerak" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "kirish",
        email: "elektron pochta manzili",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO sana va vaqti",
        date: "ISO sana",
        time: "ISO vaqt",
        duration: "ISO davomiylik",
        ipv4: "IPv4 manzil",
        ipv6: "IPv6 manzil",
        mac: "MAC manzil",
        cidrv4: "IPv4 diapazon",
        cidrv6: "IPv6 diapazon",
        base64: "base64 kodlangan satr",
        base64url: "base64url kodlangan satr",
        json_string: "JSON satr",
        e164: "E.164 raqam",
        jwt: "JWT",
        template_literal: "kirish"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "raqam",
        array: "massiv"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `Noto\u2018g\u2018ri kirish: kutilgan instanceof ${issue22.expected}, qabul qilingan ${received}`;
            }
            return `Noto\u2018g\u2018ri kirish: kutilgan ${expected}, qabul qilingan ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `Noto\u2018g\u2018ri kirish: kutilgan ${stringifyPrimitive2(issue22.values[0])}`;
            return `Noto\u2018g\u2018ri variant: quyidagilardan biri kutilgan ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Juda katta: kutilgan ${(_c = issue22.origin) != null ? _c : "qiymat"} ${adj}${issue22.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
            return `Juda katta: kutilgan ${(_d = issue22.origin) != null ? _d : "qiymat"} ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Juda kichik: kutilgan ${issue22.origin} ${adj}${issue22.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
            }
            return `Juda kichik: kutilgan ${issue22.origin} ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Noto\u2018g\u2018ri satr: "${_issue.prefix}" bilan boshlanishi kerak`;
            if (_issue.format === "ends_with")
              return `Noto\u2018g\u2018ri satr: "${_issue.suffix}" bilan tugashi kerak`;
            if (_issue.format === "includes")
              return `Noto\u2018g\u2018ri satr: "${_issue.includes}" ni o\u2018z ichiga olishi kerak`;
            if (_issue.format === "regex")
              return `Noto\u2018g\u2018ri satr: ${_issue.pattern} shabloniga mos kelishi kerak`;
            return `Noto\u2018g\u2018ri ${(_e = FormatDictionary[_issue.format]) != null ? _e : issue22.format}`;
          }
          case "not_multiple_of":
            return `Noto\u2018g\u2018ri raqam: ${issue22.divisor} ning karralisi bo\u2018lishi kerak`;
          case "unrecognized_keys":
            return `Noma\u2019lum kalit${issue22.keys.length > 1 ? "lar" : ""}: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `${issue22.origin} dagi kalit noto\u2018g\u2018ri`;
          case "invalid_union":
            return "Noto\u2018g\u2018ri kirish";
          case "invalid_element":
            return `${issue22.origin} da noto\u2018g\u2018ri qiymat`;
          default:
            return `Noto\u2018g\u2018ri kirish`;
        }
      };
    };
    error442 = () => {
      const Sizable = {
        string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
        file: { unit: "byte", verb: "c\xF3" },
        array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" },
        set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u0111\u1EA7u v\xE0o",
        email: "\u0111\u1ECBa ch\u1EC9 email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ng\xE0y gi\u1EDD ISO",
        date: "ng\xE0y ISO",
        time: "gi\u1EDD ISO",
        duration: "kho\u1EA3ng th\u1EDDi gian ISO",
        ipv4: "\u0111\u1ECBa ch\u1EC9 IPv4",
        ipv6: "\u0111\u1ECBa ch\u1EC9 IPv6",
        cidrv4: "d\u1EA3i IPv4",
        cidrv6: "d\u1EA3i IPv6",
        base64: "chu\u1ED7i m\xE3 h\xF3a base64",
        base64url: "chu\u1ED7i m\xE3 h\xF3a base64url",
        json_string: "chu\u1ED7i JSON",
        e164: "s\u1ED1 E.164",
        jwt: "JWT",
        template_literal: "\u0111\u1EA7u v\xE0o"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "s\u1ED1",
        array: "m\u1EA3ng"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i instanceof ${issue22.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
            }
            return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${stringifyPrimitive2(issue22.values[0])}`;
            return `T\xF9y ch\u1ECDn kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i m\u1ED9t trong c\xE1c gi\xE1 tr\u1ECB ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${(_c = issue22.origin) != null ? _c : "gi\xE1 tr\u1ECB"} ${sizing.verb} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "ph\u1EA7n t\u1EED"}`;
            return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${(_e = issue22.origin) != null ? _e : "gi\xE1 tr\u1ECB"} ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue22.origin} ${sizing.verb} ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue22.origin} ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i k\u1EBFt th\xFAc b\u1EB1ng "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${_issue.pattern}`;
            return `${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format} kh\xF4ng h\u1EE3p l\u1EC7`;
          }
          case "not_multiple_of":
            return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${issue22.divisor}`;
          case "unrecognized_keys":
            return `Kh\xF3a kh\xF4ng \u0111\u01B0\u1EE3c nh\u1EADn d\u1EA1ng: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `Kh\xF3a kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue22.origin}`;
          case "invalid_union":
            return "\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7";
          case "invalid_element":
            return `Gi\xE1 tr\u1ECB kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue22.origin}`;
          default:
            return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7`;
        }
      };
    };
    error452 = () => {
      const Sizable = {
        string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
        file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
        array: { unit: "\u9879", verb: "\u5305\u542B" },
        set: { unit: "\u9879", verb: "\u5305\u542B" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u8F93\u5165",
        email: "\u7535\u5B50\u90AE\u4EF6",
        url: "URL",
        emoji: "\u8868\u60C5\u7B26\u53F7",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO\u65E5\u671F\u65F6\u95F4",
        date: "ISO\u65E5\u671F",
        time: "ISO\u65F6\u95F4",
        duration: "ISO\u65F6\u957F",
        ipv4: "IPv4\u5730\u5740",
        ipv6: "IPv6\u5730\u5740",
        cidrv4: "IPv4\u7F51\u6BB5",
        cidrv6: "IPv6\u7F51\u6BB5",
        base64: "base64\u7F16\u7801\u5B57\u7B26\u4E32",
        base64url: "base64url\u7F16\u7801\u5B57\u7B26\u4E32",
        json_string: "JSON\u5B57\u7B26\u4E32",
        e164: "E.164\u53F7\u7801",
        jwt: "JWT",
        template_literal: "\u8F93\u5165"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u6570\u5B57",
        array: "\u6570\u7EC4",
        null: "\u7A7A\u503C(null)"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B instanceof ${issue22.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
            }
            return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u65E0\u6548\u9009\u9879\uFF1A\u671F\u671B\u4EE5\u4E0B\u4E4B\u4E00 ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${(_c = issue22.origin) != null ? _c : "\u503C"} ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u4E2A\u5143\u7D20"}`;
            return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${(_e = issue22.origin) != null ? _e : "\u503C"} ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue22.origin} ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue22.origin} ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.prefix}" \u5F00\u5934`;
            if (_issue.format === "ends_with")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.suffix}" \u7ED3\u5C3E`;
            if (_issue.format === "includes")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${_issue.pattern}`;
            return `\u65E0\u6548${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${issue22.divisor} \u7684\u500D\u6570`;
          case "unrecognized_keys":
            return `\u51FA\u73B0\u672A\u77E5\u7684\u952E(key): ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `${issue22.origin} \u4E2D\u7684\u952E(key)\u65E0\u6548`;
          case "invalid_union":
            return "\u65E0\u6548\u8F93\u5165";
          case "invalid_element":
            return `${issue22.origin} \u4E2D\u5305\u542B\u65E0\u6548\u503C(value)`;
          default:
            return `\u65E0\u6548\u8F93\u5165`;
        }
      };
    };
    error462 = () => {
      const Sizable = {
        string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
        file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
        array: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" },
        set: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u8F38\u5165",
        email: "\u90F5\u4EF6\u5730\u5740",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u65E5\u671F\u6642\u9593",
        date: "ISO \u65E5\u671F",
        time: "ISO \u6642\u9593",
        duration: "ISO \u671F\u9593",
        ipv4: "IPv4 \u4F4D\u5740",
        ipv6: "IPv6 \u4F4D\u5740",
        cidrv4: "IPv4 \u7BC4\u570D",
        cidrv6: "IPv6 \u7BC4\u570D",
        base64: "base64 \u7DE8\u78BC\u5B57\u4E32",
        base64url: "base64url \u7DE8\u78BC\u5B57\u4E32",
        json_string: "JSON \u5B57\u4E32",
        e164: "E.164 \u6578\u503C",
        jwt: "JWT",
        template_literal: "\u8F38\u5165"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d, _e, _f;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA instanceof ${issue22.expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
            }
            return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${stringifyPrimitive2(issue22.values[0])}`;
            return `\u7121\u6548\u7684\u9078\u9805\uFF1A\u9810\u671F\u70BA\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00 ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${(_c = issue22.origin) != null ? _c : "\u503C"} \u61C9\u70BA ${adj}${issue22.maximum.toString()} ${(_d = sizing.unit) != null ? _d : "\u500B\u5143\u7D20"}`;
            return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${(_e = issue22.origin) != null ? _e : "\u503C"} \u61C9\u70BA ${adj}${issue22.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing) {
              return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue22.origin} \u61C9\u70BA ${adj}${issue22.minimum.toString()} ${sizing.unit}`;
            }
            return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue22.origin} \u61C9\u70BA ${adj}${issue22.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with") {
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.prefix}" \u958B\u982D`;
            }
            if (_issue.format === "ends_with")
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.suffix}" \u7D50\u5C3E`;
            if (_issue.format === "includes")
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${_issue.pattern}`;
            return `\u7121\u6548\u7684 ${(_f = FormatDictionary[_issue.format]) != null ? _f : issue22.format}`;
          }
          case "not_multiple_of":
            return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${issue22.divisor} \u7684\u500D\u6578`;
          case "unrecognized_keys":
            return `\u7121\u6CD5\u8B58\u5225\u7684\u9375\u503C${issue22.keys.length > 1 ? "\u5011" : ""}\uFF1A${joinValues2(issue22.keys, "\u3001")}`;
          case "invalid_key":
            return `${issue22.origin} \u4E2D\u6709\u7121\u6548\u7684\u9375\u503C`;
          case "invalid_union":
            return "\u7121\u6548\u7684\u8F38\u5165\u503C";
          case "invalid_element":
            return `${issue22.origin} \u4E2D\u6709\u7121\u6548\u7684\u503C`;
          default:
            return `\u7121\u6548\u7684\u8F38\u5165\u503C`;
        }
      };
    };
    error472 = () => {
      const Sizable = {
        string: { unit: "\xE0mi", verb: "n\xED" },
        file: { unit: "bytes", verb: "n\xED" },
        array: { unit: "nkan", verb: "n\xED" },
        set: { unit: "nkan", verb: "n\xED" }
      };
      function getSizing(origin2) {
        var _a37;
        return (_a37 = Sizable[origin2]) != null ? _a37 : null;
      }
      const FormatDictionary = {
        regex: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9",
        email: "\xE0d\xEDr\u1EB9\u0301s\xEC \xECm\u1EB9\u0301l\xEC",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\xE0k\xF3k\xF2 ISO",
        date: "\u1ECDj\u1ECD\u0301 ISO",
        time: "\xE0k\xF3k\xF2 ISO",
        duration: "\xE0k\xF3k\xF2 t\xF3 p\xE9 ISO",
        ipv4: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv4",
        ipv6: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv6",
        cidrv4: "\xE0gb\xE8gb\xE8 IPv4",
        cidrv6: "\xE0gb\xE8gb\xE8 IPv6",
        base64: "\u1ECD\u0300r\u1ECD\u0300 t\xED a k\u1ECD\u0301 n\xED base64",
        base64url: "\u1ECD\u0300r\u1ECD\u0300 base64url",
        json_string: "\u1ECD\u0300r\u1ECD\u0300 JSON",
        e164: "n\u1ECD\u0301mb\xE0 E.164",
        jwt: "JWT",
        template_literal: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "n\u1ECD\u0301mb\xE0",
        array: "akop\u1ECD"
      };
      return (issue22) => {
        var _a37, _b27, _c, _d;
        switch (issue22.code) {
          case "invalid_type": {
            const expected = (_a37 = TypeDictionary[issue22.expected]) != null ? _a37 : issue22.expected;
            const receivedType = parsedType2(issue22.input);
            const received = (_b27 = TypeDictionary[receivedType]) != null ? _b27 : receivedType;
            if (/^[A-Z]/.test(issue22.expected)) {
              return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi instanceof ${issue22.expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
            }
            return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
          }
          case "invalid_value":
            if (issue22.values.length === 1)
              return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${stringifyPrimitive2(issue22.values[0])}`;
            return `\xC0\u1E63\xE0y\xE0n a\u1E63\xEC\u1E63e: yan \u1ECD\u0300kan l\xE1ra ${joinValues2(issue22.values, "|")}`;
          case "too_big": {
            const adj = issue22.inclusive ? "<=" : "<";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${(_c = issue22.origin) != null ? _c : "iye"} ${sizing.verb} ${adj}${issue22.maximum} ${sizing.unit}`;
            return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue22.maximum}`;
          }
          case "too_small": {
            const adj = issue22.inclusive ? ">=" : ">";
            const sizing = getSizing(issue22.origin);
            if (sizing)
              return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue22.origin} ${sizing.verb} ${adj}${issue22.minimum} ${sizing.unit}`;
            return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue22.minimum}`;
          }
          case "invalid_format": {
            const _issue = issue22;
            if (_issue.format === "starts_with")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\u1EB9\u0300r\u1EB9\u0300 p\u1EB9\u0300l\xFA "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 par\xED p\u1EB9\u0300l\xFA "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 n\xED "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\xE1 \xE0p\u1EB9\u1EB9r\u1EB9 mu ${_issue.pattern}`;
            return `A\u1E63\xEC\u1E63e: ${(_d = FormatDictionary[_issue.format]) != null ? _d : issue22.format}`;
          }
          case "not_multiple_of":
            return `N\u1ECD\u0301mb\xE0 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 j\u1EB9\u0301 \xE8y\xE0 p\xEDp\xEDn ti ${issue22.divisor}`;
          case "unrecognized_keys":
            return `B\u1ECDt\xECn\xEC \xE0\xECm\u1ECD\u0300: ${joinValues2(issue22.keys, ", ")}`;
          case "invalid_key":
            return `B\u1ECDt\xECn\xEC a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue22.origin}`;
          case "invalid_union":
            return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
          case "invalid_element":
            return `Iye a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue22.origin}`;
          default:
            return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
        }
      };
    };
    $output2 = /* @__PURE__ */ Symbol("ZodOutput");
    $input2 = /* @__PURE__ */ Symbol("ZodInput");
    $ZodRegistry2 = class {
      constructor() {
        this._map = /* @__PURE__ */ new WeakMap();
        this._idmap = /* @__PURE__ */ new Map();
      }
      add(schema, ..._meta) {
        const meta32 = _meta[0];
        this._map.set(schema, meta32);
        if (meta32 && typeof meta32 === "object" && "id" in meta32) {
          this._idmap.set(meta32.id, schema);
        }
        return this;
      }
      clear() {
        this._map = /* @__PURE__ */ new WeakMap();
        this._idmap = /* @__PURE__ */ new Map();
        return this;
      }
      remove(schema) {
        const meta32 = this._map.get(schema);
        if (meta32 && typeof meta32 === "object" && "id" in meta32) {
          this._idmap.delete(meta32.id);
        }
        this._map.delete(schema);
        return this;
      }
      get(schema) {
        var _a37;
        const p3 = schema._zod.parent;
        if (p3) {
          const pm = { ...(_a37 = this.get(p3)) != null ? _a37 : {} };
          delete pm.id;
          const f = { ...pm, ...this._map.get(schema) };
          return Object.keys(f).length ? f : void 0;
        }
        return this._map.get(schema);
      }
      has(schema) {
        return this._map.has(schema);
      }
    };
    (_a23 = (_a19 = globalThis).__zod_globalRegistry) != null ? _a23 : _a19.__zod_globalRegistry = registry2();
    globalRegistry2 = globalThis.__zod_globalRegistry;
    TimePrecision2 = {
      Any: null,
      Minute: -1,
      Second: 0,
      Millisecond: 3,
      Microsecond: 6
    };
    createToJSONSchemaMethod2 = (schema, processors = {}) => (params) => {
      const ctx = initializeContext2({ ...params, processors });
      process3(schema, ctx);
      extractDefs2(ctx, schema);
      return finalize2(ctx, schema);
    };
    createStandardJSONSchemaMethod2 = (schema, io2, processors = {}) => (params) => {
      const { libraryOptions, target } = params != null ? params : {};
      const ctx = initializeContext2({ ...libraryOptions != null ? libraryOptions : {}, target, io: io2, processors });
      process3(schema, ctx);
      extractDefs2(ctx, schema);
      return finalize2(ctx, schema);
    };
    formatMap2 = {
      guid: "uuid",
      url: "uri",
      datetime: "date-time",
      json_string: "json-string",
      regex: ""
      // do not set
    };
    stringProcessor2 = (schema, ctx, _json, _params) => {
      var _a37;
      const json22 = _json;
      json22.type = "string";
      const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
      if (typeof minimum === "number")
        json22.minLength = minimum;
      if (typeof maximum === "number")
        json22.maxLength = maximum;
      if (format) {
        json22.format = (_a37 = formatMap2[format]) != null ? _a37 : format;
        if (json22.format === "")
          delete json22.format;
        if (format === "time") {
          delete json22.format;
        }
      }
      if (contentEncoding)
        json22.contentEncoding = contentEncoding;
      if (patterns && patterns.size > 0) {
        const regexes = [...patterns];
        if (regexes.length === 1)
          json22.pattern = regexes[0].source;
        else if (regexes.length > 1) {
          json22.allOf = [
            ...regexes.map((regex) => ({
              ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
              pattern: regex.source
            }))
          ];
        }
      }
    };
    numberProcessor2 = (schema, ctx, _json, _params) => {
      const json22 = _json;
      const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
      if (typeof format === "string" && format.includes("int"))
        json22.type = "integer";
      else
        json22.type = "number";
      if (typeof exclusiveMinimum === "number") {
        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
          json22.minimum = exclusiveMinimum;
          json22.exclusiveMinimum = true;
        } else {
          json22.exclusiveMinimum = exclusiveMinimum;
        }
      }
      if (typeof minimum === "number") {
        json22.minimum = minimum;
        if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
          if (exclusiveMinimum >= minimum)
            delete json22.minimum;
          else
            delete json22.exclusiveMinimum;
        }
      }
      if (typeof exclusiveMaximum === "number") {
        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
          json22.maximum = exclusiveMaximum;
          json22.exclusiveMaximum = true;
        } else {
          json22.exclusiveMaximum = exclusiveMaximum;
        }
      }
      if (typeof maximum === "number") {
        json22.maximum = maximum;
        if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
          if (exclusiveMaximum <= maximum)
            delete json22.maximum;
          else
            delete json22.exclusiveMaximum;
        }
      }
      if (typeof multipleOf === "number")
        json22.multipleOf = multipleOf;
    };
    booleanProcessor2 = (_schema, _ctx, json22, _params) => {
      json22.type = "boolean";
    };
    bigintProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("BigInt cannot be represented in JSON Schema");
      }
    };
    symbolProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Symbols cannot be represented in JSON Schema");
      }
    };
    nullProcessor2 = (_schema, ctx, json22, _params) => {
      if (ctx.target === "openapi-3.0") {
        json22.type = "string";
        json22.nullable = true;
        json22.enum = [null];
      } else {
        json22.type = "null";
      }
    };
    undefinedProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Undefined cannot be represented in JSON Schema");
      }
    };
    voidProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Void cannot be represented in JSON Schema");
      }
    };
    neverProcessor2 = (_schema, _ctx, json22, _params) => {
      json22.not = {};
    };
    anyProcessor2 = (_schema, _ctx, _json, _params) => {
    };
    unknownProcessor2 = (_schema, _ctx, _json, _params) => {
    };
    dateProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Date cannot be represented in JSON Schema");
      }
    };
    enumProcessor2 = (schema, _ctx, json22, _params) => {
      const def = schema._zod.def;
      const values = getEnumValues2(def.entries);
      if (values.every((v) => typeof v === "number"))
        json22.type = "number";
      if (values.every((v) => typeof v === "string"))
        json22.type = "string";
      json22.enum = values;
    };
    literalProcessor2 = (schema, ctx, json22, _params) => {
      const def = schema._zod.def;
      const vals = [];
      for (const val of def.values) {
        if (val === void 0) {
          if (ctx.unrepresentable === "throw") {
            throw new Error("Literal `undefined` cannot be represented in JSON Schema");
          } else {
          }
        } else if (typeof val === "bigint") {
          if (ctx.unrepresentable === "throw") {
            throw new Error("BigInt literals cannot be represented in JSON Schema");
          } else {
            vals.push(Number(val));
          }
        } else {
          vals.push(val);
        }
      }
      if (vals.length === 0) {
      } else if (vals.length === 1) {
        const val = vals[0];
        json22.type = val === null ? "null" : typeof val;
        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
          json22.enum = [val];
        } else {
          json22.const = val;
        }
      } else {
        if (vals.every((v) => typeof v === "number"))
          json22.type = "number";
        if (vals.every((v) => typeof v === "string"))
          json22.type = "string";
        if (vals.every((v) => typeof v === "boolean"))
          json22.type = "boolean";
        if (vals.every((v) => v === null))
          json22.type = "null";
        json22.enum = vals;
      }
    };
    nanProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("NaN cannot be represented in JSON Schema");
      }
    };
    templateLiteralProcessor2 = (schema, _ctx, json22, _params) => {
      const _json = json22;
      const pattern = schema._zod.pattern;
      if (!pattern)
        throw new Error("Pattern not found in template literal");
      _json.type = "string";
      _json.pattern = pattern.source;
    };
    fileProcessor2 = (schema, _ctx, json22, _params) => {
      const _json = json22;
      const file22 = {
        type: "string",
        format: "binary",
        contentEncoding: "binary"
      };
      const { minimum, maximum, mime } = schema._zod.bag;
      if (minimum !== void 0)
        file22.minLength = minimum;
      if (maximum !== void 0)
        file22.maxLength = maximum;
      if (mime) {
        if (mime.length === 1) {
          file22.contentMediaType = mime[0];
          Object.assign(_json, file22);
        } else {
          Object.assign(_json, file22);
          _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
        }
      } else {
        Object.assign(_json, file22);
      }
    };
    successProcessor2 = (_schema, _ctx, json22, _params) => {
      json22.type = "boolean";
    };
    customProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Custom types cannot be represented in JSON Schema");
      }
    };
    functionProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Function types cannot be represented in JSON Schema");
      }
    };
    transformProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Transforms cannot be represented in JSON Schema");
      }
    };
    mapProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Map cannot be represented in JSON Schema");
      }
    };
    setProcessor2 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Set cannot be represented in JSON Schema");
      }
    };
    arrayProcessor2 = (schema, ctx, _json, params) => {
      const json22 = _json;
      const def = schema._zod.def;
      const { minimum, maximum } = schema._zod.bag;
      if (typeof minimum === "number")
        json22.minItems = minimum;
      if (typeof maximum === "number")
        json22.maxItems = maximum;
      json22.type = "array";
      json22.items = process3(def.element, ctx, { ...params, path: [...params.path, "items"] });
    };
    objectProcessor2 = (schema, ctx, _json, params) => {
      var _a37;
      const json22 = _json;
      const def = schema._zod.def;
      json22.type = "object";
      json22.properties = {};
      const shape = def.shape;
      for (const key in shape) {
        json22.properties[key] = process3(shape[key], ctx, {
          ...params,
          path: [...params.path, "properties", key]
        });
      }
      const allKeys = new Set(Object.keys(shape));
      const requiredKeys = new Set([...allKeys].filter((key) => {
        const v = def.shape[key]._zod;
        if (ctx.io === "input") {
          return v.optin === void 0;
        } else {
          return v.optout === void 0;
        }
      }));
      if (requiredKeys.size > 0) {
        json22.required = Array.from(requiredKeys);
      }
      if (((_a37 = def.catchall) == null ? void 0 : _a37._zod.def.type) === "never") {
        json22.additionalProperties = false;
      } else if (!def.catchall) {
        if (ctx.io === "output")
          json22.additionalProperties = false;
      } else if (def.catchall) {
        json22.additionalProperties = process3(def.catchall, ctx, {
          ...params,
          path: [...params.path, "additionalProperties"]
        });
      }
    };
    unionProcessor2 = (schema, ctx, json22, params) => {
      const def = schema._zod.def;
      const isExclusive = def.inclusive === false;
      const options = def.options.map((x, i) => process3(x, ctx, {
        ...params,
        path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
      }));
      if (isExclusive) {
        json22.oneOf = options;
      } else {
        json22.anyOf = options;
      }
    };
    intersectionProcessor2 = (schema, ctx, json22, params) => {
      const def = schema._zod.def;
      const a = process3(def.left, ctx, {
        ...params,
        path: [...params.path, "allOf", 0]
      });
      const b = process3(def.right, ctx, {
        ...params,
        path: [...params.path, "allOf", 1]
      });
      const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
      const allOf = [
        ...isSimpleIntersection(a) ? a.allOf : [a],
        ...isSimpleIntersection(b) ? b.allOf : [b]
      ];
      json22.allOf = allOf;
    };
    tupleProcessor2 = (schema, ctx, _json, params) => {
      const json22 = _json;
      const def = schema._zod.def;
      json22.type = "array";
      const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
      const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
      const prefixItems = def.items.map((x, i) => process3(x, ctx, {
        ...params,
        path: [...params.path, prefixPath, i]
      }));
      const rest = def.rest ? process3(def.rest, ctx, {
        ...params,
        path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
      }) : null;
      if (ctx.target === "draft-2020-12") {
        json22.prefixItems = prefixItems;
        if (rest) {
          json22.items = rest;
        }
      } else if (ctx.target === "openapi-3.0") {
        json22.items = {
          anyOf: prefixItems
        };
        if (rest) {
          json22.items.anyOf.push(rest);
        }
        json22.minItems = prefixItems.length;
        if (!rest) {
          json22.maxItems = prefixItems.length;
        }
      } else {
        json22.items = prefixItems;
        if (rest) {
          json22.additionalItems = rest;
        }
      }
      const { minimum, maximum } = schema._zod.bag;
      if (typeof minimum === "number")
        json22.minItems = minimum;
      if (typeof maximum === "number")
        json22.maxItems = maximum;
    };
    recordProcessor2 = (schema, ctx, _json, params) => {
      const json22 = _json;
      const def = schema._zod.def;
      json22.type = "object";
      const keyType = def.keyType;
      const keyBag = keyType._zod.bag;
      const patterns = keyBag == null ? void 0 : keyBag.patterns;
      if (def.mode === "loose" && patterns && patterns.size > 0) {
        const valueSchema = process3(def.valueType, ctx, {
          ...params,
          path: [...params.path, "patternProperties", "*"]
        });
        json22.patternProperties = {};
        for (const pattern of patterns) {
          json22.patternProperties[pattern.source] = valueSchema;
        }
      } else {
        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
          json22.propertyNames = process3(def.keyType, ctx, {
            ...params,
            path: [...params.path, "propertyNames"]
          });
        }
        json22.additionalProperties = process3(def.valueType, ctx, {
          ...params,
          path: [...params.path, "additionalProperties"]
        });
      }
      const keyValues = keyType._zod.values;
      if (keyValues) {
        const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
        if (validKeyValues.length > 0) {
          json22.required = validKeyValues;
        }
      }
    };
    nullableProcessor2 = (schema, ctx, json22, params) => {
      const def = schema._zod.def;
      const inner = process3(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      if (ctx.target === "openapi-3.0") {
        seen.ref = def.innerType;
        json22.nullable = true;
      } else {
        json22.anyOf = [inner, { type: "null" }];
      }
    };
    nonoptionalProcessor2 = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      process3(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
    };
    defaultProcessor2 = (schema, ctx, json22, params) => {
      const def = schema._zod.def;
      process3(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      json22.default = JSON.parse(JSON.stringify(def.defaultValue));
    };
    prefaultProcessor2 = (schema, ctx, json22, params) => {
      const def = schema._zod.def;
      process3(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      if (ctx.io === "input")
        json22._prefault = JSON.parse(JSON.stringify(def.defaultValue));
    };
    catchProcessor2 = (schema, ctx, json22, params) => {
      const def = schema._zod.def;
      process3(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      let catchValue;
      try {
        catchValue = def.catchValue(void 0);
      } catch (e) {
        throw new Error("Dynamic catch values are not supported in JSON Schema");
      }
      json22.default = catchValue;
    };
    pipeProcessor2 = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
      process3(innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = innerType;
    };
    readonlyProcessor2 = (schema, ctx, json22, params) => {
      const def = schema._zod.def;
      process3(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      json22.readOnly = true;
    };
    promiseProcessor2 = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      process3(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
    };
    optionalProcessor2 = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      process3(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
    };
    lazyProcessor2 = (schema, ctx, _json, params) => {
      const innerType = schema._zod.innerType;
      process3(innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = innerType;
    };
    allProcessors2 = {
      string: stringProcessor2,
      number: numberProcessor2,
      boolean: booleanProcessor2,
      bigint: bigintProcessor2,
      symbol: symbolProcessor2,
      null: nullProcessor2,
      undefined: undefinedProcessor2,
      void: voidProcessor2,
      never: neverProcessor2,
      any: anyProcessor2,
      unknown: unknownProcessor2,
      date: dateProcessor2,
      enum: enumProcessor2,
      literal: literalProcessor2,
      nan: nanProcessor2,
      template_literal: templateLiteralProcessor2,
      file: fileProcessor2,
      success: successProcessor2,
      custom: customProcessor2,
      function: functionProcessor2,
      transform: transformProcessor2,
      map: mapProcessor2,
      set: setProcessor2,
      array: arrayProcessor2,
      object: objectProcessor2,
      union: unionProcessor2,
      intersection: intersectionProcessor2,
      tuple: tupleProcessor2,
      record: recordProcessor2,
      nullable: nullableProcessor2,
      nonoptional: nonoptionalProcessor2,
      default: defaultProcessor2,
      prefault: prefaultProcessor2,
      catch: catchProcessor2,
      pipe: pipeProcessor2,
      readonly: readonlyProcessor2,
      promise: promiseProcessor2,
      optional: optionalProcessor2,
      lazy: lazyProcessor2
    };
    JSONSchemaGenerator2 = class {
      /** @deprecated Access via ctx instead */
      get metadataRegistry() {
        return this.ctx.metadataRegistry;
      }
      /** @deprecated Access via ctx instead */
      get target() {
        return this.ctx.target;
      }
      /** @deprecated Access via ctx instead */
      get unrepresentable() {
        return this.ctx.unrepresentable;
      }
      /** @deprecated Access via ctx instead */
      get override() {
        return this.ctx.override;
      }
      /** @deprecated Access via ctx instead */
      get io() {
        return this.ctx.io;
      }
      /** @deprecated Access via ctx instead */
      get counter() {
        return this.ctx.counter;
      }
      set counter(value) {
        this.ctx.counter = value;
      }
      /** @deprecated Access via ctx instead */
      get seen() {
        return this.ctx.seen;
      }
      constructor(params) {
        var _a37;
        let normalizedTarget = (_a37 = params == null ? void 0 : params.target) != null ? _a37 : "draft-2020-12";
        if (normalizedTarget === "draft-4")
          normalizedTarget = "draft-04";
        if (normalizedTarget === "draft-7")
          normalizedTarget = "draft-07";
        this.ctx = initializeContext2({
          processors: allProcessors2,
          target: normalizedTarget,
          ...(params == null ? void 0 : params.metadata) && { metadata: params.metadata },
          ...(params == null ? void 0 : params.unrepresentable) && { unrepresentable: params.unrepresentable },
          ...(params == null ? void 0 : params.override) && { override: params.override },
          ...(params == null ? void 0 : params.io) && { io: params.io }
        });
      }
      /**
       * Process a schema to prepare it for JSON Schema generation.
       * This must be called before emit().
       */
      process(schema, _params = { path: [], schemaPath: [] }) {
        return process3(schema, this.ctx, _params);
      }
      /**
       * Emit the final JSON Schema after processing.
       * Must call process() first.
       */
      emit(schema, _params) {
        if (_params) {
          if (_params.cycles)
            this.ctx.cycles = _params.cycles;
          if (_params.reused)
            this.ctx.reused = _params.reused;
          if (_params.external)
            this.ctx.external = _params.external;
        }
        extractDefs2(this.ctx, schema);
        const result = finalize2(this.ctx, schema);
        const { "~standard": _, ...plainResult } = result;
        return plainResult;
      }
    };
    json_schema_exports2 = {};
    schemas_exports22 = {};
    __export2(schemas_exports22, {
      ZodAny: () => ZodAny3,
      ZodArray: () => ZodArray3,
      ZodBase64: () => ZodBase642,
      ZodBase64URL: () => ZodBase64URL2,
      ZodBigInt: () => ZodBigInt3,
      ZodBigIntFormat: () => ZodBigIntFormat2,
      ZodBoolean: () => ZodBoolean3,
      ZodCIDRv4: () => ZodCIDRv42,
      ZodCIDRv6: () => ZodCIDRv62,
      ZodCUID: () => ZodCUID3,
      ZodCUID2: () => ZodCUID22,
      ZodCatch: () => ZodCatch3,
      ZodCodec: () => ZodCodec2,
      ZodCustom: () => ZodCustom2,
      ZodCustomStringFormat: () => ZodCustomStringFormat2,
      ZodDate: () => ZodDate3,
      ZodDefault: () => ZodDefault3,
      ZodDiscriminatedUnion: () => ZodDiscriminatedUnion3,
      ZodE164: () => ZodE1642,
      ZodEmail: () => ZodEmail2,
      ZodEmoji: () => ZodEmoji2,
      ZodEnum: () => ZodEnum3,
      ZodExactOptional: () => ZodExactOptional2,
      ZodFile: () => ZodFile2,
      ZodFunction: () => ZodFunction3,
      ZodGUID: () => ZodGUID2,
      ZodIPv4: () => ZodIPv42,
      ZodIPv6: () => ZodIPv62,
      ZodIntersection: () => ZodIntersection3,
      ZodJWT: () => ZodJWT2,
      ZodKSUID: () => ZodKSUID2,
      ZodLazy: () => ZodLazy3,
      ZodLiteral: () => ZodLiteral3,
      ZodMAC: () => ZodMAC2,
      ZodMap: () => ZodMap3,
      ZodNaN: () => ZodNaN3,
      ZodNanoID: () => ZodNanoID2,
      ZodNever: () => ZodNever3,
      ZodNonOptional: () => ZodNonOptional2,
      ZodNull: () => ZodNull3,
      ZodNullable: () => ZodNullable3,
      ZodNumber: () => ZodNumber3,
      ZodNumberFormat: () => ZodNumberFormat2,
      ZodObject: () => ZodObject3,
      ZodOptional: () => ZodOptional3,
      ZodPipe: () => ZodPipe2,
      ZodPrefault: () => ZodPrefault2,
      ZodPromise: () => ZodPromise3,
      ZodReadonly: () => ZodReadonly3,
      ZodRecord: () => ZodRecord3,
      ZodSet: () => ZodSet3,
      ZodString: () => ZodString3,
      ZodStringFormat: () => ZodStringFormat2,
      ZodSuccess: () => ZodSuccess2,
      ZodSymbol: () => ZodSymbol3,
      ZodTemplateLiteral: () => ZodTemplateLiteral2,
      ZodTransform: () => ZodTransform2,
      ZodTuple: () => ZodTuple3,
      ZodType: () => ZodType3,
      ZodULID: () => ZodULID2,
      ZodURL: () => ZodURL2,
      ZodUUID: () => ZodUUID2,
      ZodUndefined: () => ZodUndefined3,
      ZodUnion: () => ZodUnion3,
      ZodUnknown: () => ZodUnknown3,
      ZodVoid: () => ZodVoid3,
      ZodXID: () => ZodXID2,
      ZodXor: () => ZodXor2,
      _ZodString: () => _ZodString2,
      _default: () => _default22,
      _function: () => _function2,
      any: () => any2,
      array: () => array2,
      base64: () => base6422,
      base64url: () => base64url22,
      bigint: () => bigint22,
      boolean: () => boolean22,
      catch: () => _catch22,
      check: () => check2,
      cidrv4: () => cidrv422,
      cidrv6: () => cidrv622,
      codec: () => codec2,
      cuid: () => cuid32,
      cuid2: () => cuid222,
      custom: () => custom2,
      date: () => date32,
      describe: () => describe22,
      discriminatedUnion: () => discriminatedUnion2,
      e164: () => e16422,
      email: () => email22,
      emoji: () => emoji22,
      enum: () => _enum22,
      exactOptional: () => exactOptional2,
      file: () => file2,
      float32: () => float322,
      float64: () => float642,
      function: () => _function2,
      guid: () => guid22,
      hash: () => hash2,
      hex: () => hex22,
      hostname: () => hostname22,
      httpUrl: () => httpUrl2,
      instanceof: () => _instanceof2,
      int: () => int2,
      int32: () => int322,
      int64: () => int642,
      intersection: () => intersection2,
      ipv4: () => ipv422,
      ipv6: () => ipv622,
      json: () => json2,
      jwt: () => jwt2,
      keyof: () => keyof2,
      ksuid: () => ksuid22,
      lazy: () => lazy2,
      literal: () => literal2,
      looseObject: () => looseObject2,
      looseRecord: () => looseRecord2,
      mac: () => mac22,
      map: () => map2,
      meta: () => meta22,
      nan: () => nan2,
      nanoid: () => nanoid22,
      nativeEnum: () => nativeEnum2,
      never: () => never2,
      nonoptional: () => nonoptional2,
      null: () => _null32,
      nullable: () => nullable2,
      nullish: () => nullish22,
      number: () => number22,
      object: () => object2,
      optional: () => optional2,
      partialRecord: () => partialRecord2,
      pipe: () => pipe2,
      prefault: () => prefault2,
      preprocess: () => preprocess2,
      promise: () => promise2,
      readonly: () => readonly2,
      record: () => record2,
      refine: () => refine2,
      set: () => set2,
      strictObject: () => strictObject2,
      string: () => string22,
      stringFormat: () => stringFormat2,
      stringbool: () => stringbool2,
      success: () => success2,
      superRefine: () => superRefine2,
      symbol: () => symbol19,
      templateLiteral: () => templateLiteral2,
      transform: () => transform3,
      tuple: () => tuple2,
      uint32: () => uint322,
      uint64: () => uint642,
      ulid: () => ulid22,
      undefined: () => _undefined32,
      union: () => union2,
      unknown: () => unknown2,
      url: () => url3,
      uuid: () => uuid22,
      uuidv4: () => uuidv42,
      uuidv6: () => uuidv62,
      uuidv7: () => uuidv72,
      void: () => _void22,
      xid: () => xid22,
      xor: () => xor2
    });
    checks_exports22 = {};
    __export2(checks_exports22, {
      endsWith: () => _endsWith2,
      gt: () => _gt2,
      gte: () => _gte2,
      includes: () => _includes2,
      length: () => _length2,
      lowercase: () => _lowercase2,
      lt: () => _lt2,
      lte: () => _lte2,
      maxLength: () => _maxLength2,
      maxSize: () => _maxSize2,
      mime: () => _mime2,
      minLength: () => _minLength2,
      minSize: () => _minSize2,
      multipleOf: () => _multipleOf2,
      negative: () => _negative2,
      nonnegative: () => _nonnegative2,
      nonpositive: () => _nonpositive2,
      normalize: () => _normalize2,
      overwrite: () => _overwrite2,
      positive: () => _positive2,
      property: () => _property2,
      regex: () => _regex2,
      size: () => _size2,
      slugify: () => _slugify2,
      startsWith: () => _startsWith2,
      toLowerCase: () => _toLowerCase2,
      toUpperCase: () => _toUpperCase2,
      trim: () => _trim2,
      uppercase: () => _uppercase2
    });
    iso_exports2 = {};
    __export2(iso_exports2, {
      ZodISODate: () => ZodISODate2,
      ZodISODateTime: () => ZodISODateTime2,
      ZodISODuration: () => ZodISODuration2,
      ZodISOTime: () => ZodISOTime2,
      date: () => date22,
      datetime: () => datetime22,
      duration: () => duration22,
      time: () => time22
    });
    ZodISODateTime2 = /* @__PURE__ */ $constructor2("ZodISODateTime", (inst, def) => {
      $ZodISODateTime2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodISODate2 = /* @__PURE__ */ $constructor2("ZodISODate", (inst, def) => {
      $ZodISODate2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodISOTime2 = /* @__PURE__ */ $constructor2("ZodISOTime", (inst, def) => {
      $ZodISOTime2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodISODuration2 = /* @__PURE__ */ $constructor2("ZodISODuration", (inst, def) => {
      $ZodISODuration2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    initializer22 = (inst, issues) => {
      $ZodError2.init(inst, issues);
      inst.name = "ZodError";
      Object.defineProperties(inst, {
        format: {
          value: (mapper) => formatError2(inst, mapper)
          // enumerable: false,
        },
        flatten: {
          value: (mapper) => flattenError2(inst, mapper)
          // enumerable: false,
        },
        addIssue: {
          value: (issue22) => {
            inst.issues.push(issue22);
            inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer2, 2);
          }
          // enumerable: false,
        },
        addIssues: {
          value: (issues2) => {
            inst.issues.push(...issues2);
            inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer2, 2);
          }
          // enumerable: false,
        },
        isEmpty: {
          get() {
            return inst.issues.length === 0;
          }
          // enumerable: false,
        }
      });
    };
    ZodError3 = /* @__PURE__ */ $constructor2("ZodError", initializer22);
    ZodRealError2 = /* @__PURE__ */ $constructor2("ZodError", initializer22, {
      Parent: Error
    });
    parse22 = /* @__PURE__ */ _parse4(ZodRealError2);
    parseAsync22 = /* @__PURE__ */ _parseAsync2(ZodRealError2);
    safeParse22 = /* @__PURE__ */ _safeParse2(ZodRealError2);
    safeParseAsync22 = /* @__PURE__ */ _safeParseAsync2(ZodRealError2);
    encode22 = /* @__PURE__ */ _encode2(ZodRealError2);
    decode22 = /* @__PURE__ */ _decode2(ZodRealError2);
    encodeAsync22 = /* @__PURE__ */ _encodeAsync2(ZodRealError2);
    decodeAsync22 = /* @__PURE__ */ _decodeAsync2(ZodRealError2);
    safeEncode22 = /* @__PURE__ */ _safeEncode2(ZodRealError2);
    safeDecode22 = /* @__PURE__ */ _safeDecode2(ZodRealError2);
    safeEncodeAsync22 = /* @__PURE__ */ _safeEncodeAsync2(ZodRealError2);
    safeDecodeAsync22 = /* @__PURE__ */ _safeDecodeAsync2(ZodRealError2);
    ZodType3 = /* @__PURE__ */ $constructor2("ZodType", (inst, def) => {
      $ZodType2.init(inst, def);
      Object.assign(inst["~standard"], {
        jsonSchema: {
          input: createStandardJSONSchemaMethod2(inst, "input"),
          output: createStandardJSONSchemaMethod2(inst, "output")
        }
      });
      inst.toJSONSchema = createToJSONSchemaMethod2(inst, {});
      inst.def = def;
      inst.type = def.type;
      Object.defineProperty(inst, "_def", { value: def });
      inst.check = (...checks) => {
        var _a37;
        return inst.clone(util_exports2.mergeDefs(def, {
          checks: [
            ...(_a37 = def.checks) != null ? _a37 : [],
            ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
          ]
        }), {
          parent: true
        });
      };
      inst.with = inst.check;
      inst.clone = (def2, params) => clone2(inst, def2, params);
      inst.brand = () => inst;
      inst.register = (reg, meta32) => {
        reg.add(inst, meta32);
        return inst;
      };
      inst.parse = (data, params) => parse22(inst, data, params, { callee: inst.parse });
      inst.safeParse = (data, params) => safeParse22(inst, data, params);
      inst.parseAsync = async (data, params) => parseAsync22(inst, data, params, { callee: inst.parseAsync });
      inst.safeParseAsync = async (data, params) => safeParseAsync22(inst, data, params);
      inst.spa = inst.safeParseAsync;
      inst.encode = (data, params) => encode22(inst, data, params);
      inst.decode = (data, params) => decode22(inst, data, params);
      inst.encodeAsync = async (data, params) => encodeAsync22(inst, data, params);
      inst.decodeAsync = async (data, params) => decodeAsync22(inst, data, params);
      inst.safeEncode = (data, params) => safeEncode22(inst, data, params);
      inst.safeDecode = (data, params) => safeDecode22(inst, data, params);
      inst.safeEncodeAsync = async (data, params) => safeEncodeAsync22(inst, data, params);
      inst.safeDecodeAsync = async (data, params) => safeDecodeAsync22(inst, data, params);
      inst.refine = (check22, params) => inst.check(refine2(check22, params));
      inst.superRefine = (refinement) => inst.check(superRefine2(refinement));
      inst.overwrite = (fn) => inst.check(/* @__PURE__ */ _overwrite2(fn));
      inst.optional = () => optional2(inst);
      inst.exactOptional = () => exactOptional2(inst);
      inst.nullable = () => nullable2(inst);
      inst.nullish = () => optional2(nullable2(inst));
      inst.nonoptional = (params) => nonoptional2(inst, params);
      inst.array = () => array2(inst);
      inst.or = (arg) => union2([inst, arg]);
      inst.and = (arg) => intersection2(inst, arg);
      inst.transform = (tx) => pipe2(inst, transform3(tx));
      inst.default = (def2) => _default22(inst, def2);
      inst.prefault = (def2) => prefault2(inst, def2);
      inst.catch = (params) => _catch22(inst, params);
      inst.pipe = (target) => pipe2(inst, target);
      inst.readonly = () => readonly2(inst);
      inst.describe = (description) => {
        const cl = inst.clone();
        globalRegistry2.add(cl, { description });
        return cl;
      };
      Object.defineProperty(inst, "description", {
        get() {
          var _a37;
          return (_a37 = globalRegistry2.get(inst)) == null ? void 0 : _a37.description;
        },
        configurable: true
      });
      inst.meta = (...args) => {
        if (args.length === 0) {
          return globalRegistry2.get(inst);
        }
        const cl = inst.clone();
        globalRegistry2.add(cl, args[0]);
        return cl;
      };
      inst.isOptional = () => inst.safeParse(void 0).success;
      inst.isNullable = () => inst.safeParse(null).success;
      inst.apply = (fn) => fn(inst);
      return inst;
    });
    _ZodString2 = /* @__PURE__ */ $constructor2("_ZodString", (inst, def) => {
      var _a37, _b27, _c;
      $ZodString2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => stringProcessor2(inst, ctx, json22, params);
      const bag = inst._zod.bag;
      inst.format = (_a37 = bag.format) != null ? _a37 : null;
      inst.minLength = (_b27 = bag.minimum) != null ? _b27 : null;
      inst.maxLength = (_c = bag.maximum) != null ? _c : null;
      inst.regex = (...args) => inst.check(/* @__PURE__ */ _regex2(...args));
      inst.includes = (...args) => inst.check(/* @__PURE__ */ _includes2(...args));
      inst.startsWith = (...args) => inst.check(/* @__PURE__ */ _startsWith2(...args));
      inst.endsWith = (...args) => inst.check(/* @__PURE__ */ _endsWith2(...args));
      inst.min = (...args) => inst.check(/* @__PURE__ */ _minLength2(...args));
      inst.max = (...args) => inst.check(/* @__PURE__ */ _maxLength2(...args));
      inst.length = (...args) => inst.check(/* @__PURE__ */ _length2(...args));
      inst.nonempty = (...args) => inst.check(/* @__PURE__ */ _minLength2(1, ...args));
      inst.lowercase = (params) => inst.check(/* @__PURE__ */ _lowercase2(params));
      inst.uppercase = (params) => inst.check(/* @__PURE__ */ _uppercase2(params));
      inst.trim = () => inst.check(/* @__PURE__ */ _trim2());
      inst.normalize = (...args) => inst.check(/* @__PURE__ */ _normalize2(...args));
      inst.toLowerCase = () => inst.check(/* @__PURE__ */ _toLowerCase2());
      inst.toUpperCase = () => inst.check(/* @__PURE__ */ _toUpperCase2());
      inst.slugify = () => inst.check(/* @__PURE__ */ _slugify2());
    });
    ZodString3 = /* @__PURE__ */ $constructor2("ZodString", (inst, def) => {
      $ZodString2.init(inst, def);
      _ZodString2.init(inst, def);
      inst.email = (params) => inst.check(/* @__PURE__ */ _email2(ZodEmail2, params));
      inst.url = (params) => inst.check(/* @__PURE__ */ _url2(ZodURL2, params));
      inst.jwt = (params) => inst.check(/* @__PURE__ */ _jwt2(ZodJWT2, params));
      inst.emoji = (params) => inst.check(/* @__PURE__ */ _emoji22(ZodEmoji2, params));
      inst.guid = (params) => inst.check(/* @__PURE__ */ _guid2(ZodGUID2, params));
      inst.uuid = (params) => inst.check(/* @__PURE__ */ _uuid2(ZodUUID2, params));
      inst.uuidv4 = (params) => inst.check(/* @__PURE__ */ _uuidv42(ZodUUID2, params));
      inst.uuidv6 = (params) => inst.check(/* @__PURE__ */ _uuidv62(ZodUUID2, params));
      inst.uuidv7 = (params) => inst.check(/* @__PURE__ */ _uuidv72(ZodUUID2, params));
      inst.nanoid = (params) => inst.check(/* @__PURE__ */ _nanoid2(ZodNanoID2, params));
      inst.guid = (params) => inst.check(/* @__PURE__ */ _guid2(ZodGUID2, params));
      inst.cuid = (params) => inst.check(/* @__PURE__ */ _cuid3(ZodCUID3, params));
      inst.cuid2 = (params) => inst.check(/* @__PURE__ */ _cuid22(ZodCUID22, params));
      inst.ulid = (params) => inst.check(/* @__PURE__ */ _ulid2(ZodULID2, params));
      inst.base64 = (params) => inst.check(/* @__PURE__ */ _base642(ZodBase642, params));
      inst.base64url = (params) => inst.check(/* @__PURE__ */ _base64url2(ZodBase64URL2, params));
      inst.xid = (params) => inst.check(/* @__PURE__ */ _xid2(ZodXID2, params));
      inst.ksuid = (params) => inst.check(/* @__PURE__ */ _ksuid2(ZodKSUID2, params));
      inst.ipv4 = (params) => inst.check(/* @__PURE__ */ _ipv42(ZodIPv42, params));
      inst.ipv6 = (params) => inst.check(/* @__PURE__ */ _ipv62(ZodIPv62, params));
      inst.cidrv4 = (params) => inst.check(/* @__PURE__ */ _cidrv42(ZodCIDRv42, params));
      inst.cidrv6 = (params) => inst.check(/* @__PURE__ */ _cidrv62(ZodCIDRv62, params));
      inst.e164 = (params) => inst.check(/* @__PURE__ */ _e1642(ZodE1642, params));
      inst.datetime = (params) => inst.check(datetime22(params));
      inst.date = (params) => inst.check(date22(params));
      inst.time = (params) => inst.check(time22(params));
      inst.duration = (params) => inst.check(duration22(params));
    });
    ZodStringFormat2 = /* @__PURE__ */ $constructor2("ZodStringFormat", (inst, def) => {
      $ZodStringFormat2.init(inst, def);
      _ZodString2.init(inst, def);
    });
    ZodEmail2 = /* @__PURE__ */ $constructor2("ZodEmail", (inst, def) => {
      $ZodEmail2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodGUID2 = /* @__PURE__ */ $constructor2("ZodGUID", (inst, def) => {
      $ZodGUID2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodUUID2 = /* @__PURE__ */ $constructor2("ZodUUID", (inst, def) => {
      $ZodUUID2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodURL2 = /* @__PURE__ */ $constructor2("ZodURL", (inst, def) => {
      $ZodURL2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodEmoji2 = /* @__PURE__ */ $constructor2("ZodEmoji", (inst, def) => {
      $ZodEmoji2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodNanoID2 = /* @__PURE__ */ $constructor2("ZodNanoID", (inst, def) => {
      $ZodNanoID2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodCUID3 = /* @__PURE__ */ $constructor2("ZodCUID", (inst, def) => {
      $ZodCUID3.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodCUID22 = /* @__PURE__ */ $constructor2("ZodCUID2", (inst, def) => {
      $ZodCUID22.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodULID2 = /* @__PURE__ */ $constructor2("ZodULID", (inst, def) => {
      $ZodULID2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodXID2 = /* @__PURE__ */ $constructor2("ZodXID", (inst, def) => {
      $ZodXID2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodKSUID2 = /* @__PURE__ */ $constructor2("ZodKSUID", (inst, def) => {
      $ZodKSUID2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodIPv42 = /* @__PURE__ */ $constructor2("ZodIPv4", (inst, def) => {
      $ZodIPv42.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodMAC2 = /* @__PURE__ */ $constructor2("ZodMAC", (inst, def) => {
      $ZodMAC2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodIPv62 = /* @__PURE__ */ $constructor2("ZodIPv6", (inst, def) => {
      $ZodIPv62.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodCIDRv42 = /* @__PURE__ */ $constructor2("ZodCIDRv4", (inst, def) => {
      $ZodCIDRv42.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodCIDRv62 = /* @__PURE__ */ $constructor2("ZodCIDRv6", (inst, def) => {
      $ZodCIDRv62.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodBase642 = /* @__PURE__ */ $constructor2("ZodBase64", (inst, def) => {
      $ZodBase642.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodBase64URL2 = /* @__PURE__ */ $constructor2("ZodBase64URL", (inst, def) => {
      $ZodBase64URL2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodE1642 = /* @__PURE__ */ $constructor2("ZodE164", (inst, def) => {
      $ZodE1642.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodJWT2 = /* @__PURE__ */ $constructor2("ZodJWT", (inst, def) => {
      $ZodJWT2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodCustomStringFormat2 = /* @__PURE__ */ $constructor2("ZodCustomStringFormat", (inst, def) => {
      $ZodCustomStringFormat2.init(inst, def);
      ZodStringFormat2.init(inst, def);
    });
    ZodNumber3 = /* @__PURE__ */ $constructor2("ZodNumber", (inst, def) => {
      var _a37, _b27, _c, _d, _e, _f, _g, _h, _i;
      $ZodNumber2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => numberProcessor2(inst, ctx, json22, params);
      inst.gt = (value, params) => inst.check(/* @__PURE__ */ _gt2(value, params));
      inst.gte = (value, params) => inst.check(/* @__PURE__ */ _gte2(value, params));
      inst.min = (value, params) => inst.check(/* @__PURE__ */ _gte2(value, params));
      inst.lt = (value, params) => inst.check(/* @__PURE__ */ _lt2(value, params));
      inst.lte = (value, params) => inst.check(/* @__PURE__ */ _lte2(value, params));
      inst.max = (value, params) => inst.check(/* @__PURE__ */ _lte2(value, params));
      inst.int = (params) => inst.check(int2(params));
      inst.safe = (params) => inst.check(int2(params));
      inst.positive = (params) => inst.check(/* @__PURE__ */ _gt2(0, params));
      inst.nonnegative = (params) => inst.check(/* @__PURE__ */ _gte2(0, params));
      inst.negative = (params) => inst.check(/* @__PURE__ */ _lt2(0, params));
      inst.nonpositive = (params) => inst.check(/* @__PURE__ */ _lte2(0, params));
      inst.multipleOf = (value, params) => inst.check(/* @__PURE__ */ _multipleOf2(value, params));
      inst.step = (value, params) => inst.check(/* @__PURE__ */ _multipleOf2(value, params));
      inst.finite = () => inst;
      const bag = inst._zod.bag;
      inst.minValue = (_c = Math.max((_a37 = bag.minimum) != null ? _a37 : Number.NEGATIVE_INFINITY, (_b27 = bag.exclusiveMinimum) != null ? _b27 : Number.NEGATIVE_INFINITY)) != null ? _c : null;
      inst.maxValue = (_f = Math.min((_d = bag.maximum) != null ? _d : Number.POSITIVE_INFINITY, (_e = bag.exclusiveMaximum) != null ? _e : Number.POSITIVE_INFINITY)) != null ? _f : null;
      inst.isInt = ((_g = bag.format) != null ? _g : "").includes("int") || Number.isSafeInteger((_h = bag.multipleOf) != null ? _h : 0.5);
      inst.isFinite = true;
      inst.format = (_i = bag.format) != null ? _i : null;
    });
    ZodNumberFormat2 = /* @__PURE__ */ $constructor2("ZodNumberFormat", (inst, def) => {
      $ZodNumberFormat2.init(inst, def);
      ZodNumber3.init(inst, def);
    });
    ZodBoolean3 = /* @__PURE__ */ $constructor2("ZodBoolean", (inst, def) => {
      $ZodBoolean2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => booleanProcessor2(inst, ctx, json22, params);
    });
    ZodBigInt3 = /* @__PURE__ */ $constructor2("ZodBigInt", (inst, def) => {
      var _a37, _b27, _c;
      $ZodBigInt2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => bigintProcessor2(inst, ctx, json22, params);
      inst.gte = (value, params) => inst.check(/* @__PURE__ */ _gte2(value, params));
      inst.min = (value, params) => inst.check(/* @__PURE__ */ _gte2(value, params));
      inst.gt = (value, params) => inst.check(/* @__PURE__ */ _gt2(value, params));
      inst.gte = (value, params) => inst.check(/* @__PURE__ */ _gte2(value, params));
      inst.min = (value, params) => inst.check(/* @__PURE__ */ _gte2(value, params));
      inst.lt = (value, params) => inst.check(/* @__PURE__ */ _lt2(value, params));
      inst.lte = (value, params) => inst.check(/* @__PURE__ */ _lte2(value, params));
      inst.max = (value, params) => inst.check(/* @__PURE__ */ _lte2(value, params));
      inst.positive = (params) => inst.check(/* @__PURE__ */ _gt2(BigInt(0), params));
      inst.negative = (params) => inst.check(/* @__PURE__ */ _lt2(BigInt(0), params));
      inst.nonpositive = (params) => inst.check(/* @__PURE__ */ _lte2(BigInt(0), params));
      inst.nonnegative = (params) => inst.check(/* @__PURE__ */ _gte2(BigInt(0), params));
      inst.multipleOf = (value, params) => inst.check(/* @__PURE__ */ _multipleOf2(value, params));
      const bag = inst._zod.bag;
      inst.minValue = (_a37 = bag.minimum) != null ? _a37 : null;
      inst.maxValue = (_b27 = bag.maximum) != null ? _b27 : null;
      inst.format = (_c = bag.format) != null ? _c : null;
    });
    ZodBigIntFormat2 = /* @__PURE__ */ $constructor2("ZodBigIntFormat", (inst, def) => {
      $ZodBigIntFormat2.init(inst, def);
      ZodBigInt3.init(inst, def);
    });
    ZodSymbol3 = /* @__PURE__ */ $constructor2("ZodSymbol", (inst, def) => {
      $ZodSymbol2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => symbolProcessor2(inst, ctx, json22, params);
    });
    ZodUndefined3 = /* @__PURE__ */ $constructor2("ZodUndefined", (inst, def) => {
      $ZodUndefined2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => undefinedProcessor2(inst, ctx, json22, params);
    });
    ZodNull3 = /* @__PURE__ */ $constructor2("ZodNull", (inst, def) => {
      $ZodNull2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => nullProcessor2(inst, ctx, json22, params);
    });
    ZodAny3 = /* @__PURE__ */ $constructor2("ZodAny", (inst, def) => {
      $ZodAny2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => anyProcessor2(inst, ctx, json22, params);
    });
    ZodUnknown3 = /* @__PURE__ */ $constructor2("ZodUnknown", (inst, def) => {
      $ZodUnknown2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => unknownProcessor2(inst, ctx, json22, params);
    });
    ZodNever3 = /* @__PURE__ */ $constructor2("ZodNever", (inst, def) => {
      $ZodNever2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => neverProcessor2(inst, ctx, json22, params);
    });
    ZodVoid3 = /* @__PURE__ */ $constructor2("ZodVoid", (inst, def) => {
      $ZodVoid2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => voidProcessor2(inst, ctx, json22, params);
    });
    ZodDate3 = /* @__PURE__ */ $constructor2("ZodDate", (inst, def) => {
      $ZodDate2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => dateProcessor2(inst, ctx, json22, params);
      inst.min = (value, params) => inst.check(/* @__PURE__ */ _gte2(value, params));
      inst.max = (value, params) => inst.check(/* @__PURE__ */ _lte2(value, params));
      const c = inst._zod.bag;
      inst.minDate = c.minimum ? new Date(c.minimum) : null;
      inst.maxDate = c.maximum ? new Date(c.maximum) : null;
    });
    ZodArray3 = /* @__PURE__ */ $constructor2("ZodArray", (inst, def) => {
      $ZodArray2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => arrayProcessor2(inst, ctx, json22, params);
      inst.element = def.element;
      inst.min = (minLength, params) => inst.check(/* @__PURE__ */ _minLength2(minLength, params));
      inst.nonempty = (params) => inst.check(/* @__PURE__ */ _minLength2(1, params));
      inst.max = (maxLength, params) => inst.check(/* @__PURE__ */ _maxLength2(maxLength, params));
      inst.length = (len, params) => inst.check(/* @__PURE__ */ _length2(len, params));
      inst.unwrap = () => inst.element;
    });
    ZodObject3 = /* @__PURE__ */ $constructor2("ZodObject", (inst, def) => {
      $ZodObjectJIT2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => objectProcessor2(inst, ctx, json22, params);
      util_exports2.defineLazy(inst, "shape", () => {
        return def.shape;
      });
      inst.keyof = () => _enum22(Object.keys(inst._zod.def.shape));
      inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
      inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown2() });
      inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown2() });
      inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never2() });
      inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
      inst.extend = (incoming) => {
        return util_exports2.extend(inst, incoming);
      };
      inst.safeExtend = (incoming) => {
        return util_exports2.safeExtend(inst, incoming);
      };
      inst.merge = (other) => util_exports2.merge(inst, other);
      inst.pick = (mask) => util_exports2.pick(inst, mask);
      inst.omit = (mask) => util_exports2.omit(inst, mask);
      inst.partial = (...args) => util_exports2.partial(ZodOptional3, inst, args[0]);
      inst.required = (...args) => util_exports2.required(ZodNonOptional2, inst, args[0]);
    });
    ZodUnion3 = /* @__PURE__ */ $constructor2("ZodUnion", (inst, def) => {
      $ZodUnion2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => unionProcessor2(inst, ctx, json22, params);
      inst.options = def.options;
    });
    ZodXor2 = /* @__PURE__ */ $constructor2("ZodXor", (inst, def) => {
      ZodUnion3.init(inst, def);
      $ZodXor2.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => unionProcessor2(inst, ctx, json22, params);
      inst.options = def.options;
    });
    ZodDiscriminatedUnion3 = /* @__PURE__ */ $constructor2("ZodDiscriminatedUnion", (inst, def) => {
      ZodUnion3.init(inst, def);
      $ZodDiscriminatedUnion2.init(inst, def);
    });
    ZodIntersection3 = /* @__PURE__ */ $constructor2("ZodIntersection", (inst, def) => {
      $ZodIntersection2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => intersectionProcessor2(inst, ctx, json22, params);
    });
    ZodTuple3 = /* @__PURE__ */ $constructor2("ZodTuple", (inst, def) => {
      $ZodTuple2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => tupleProcessor2(inst, ctx, json22, params);
      inst.rest = (rest) => inst.clone({
        ...inst._zod.def,
        rest
      });
    });
    ZodRecord3 = /* @__PURE__ */ $constructor2("ZodRecord", (inst, def) => {
      $ZodRecord2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => recordProcessor2(inst, ctx, json22, params);
      inst.keyType = def.keyType;
      inst.valueType = def.valueType;
    });
    ZodMap3 = /* @__PURE__ */ $constructor2("ZodMap", (inst, def) => {
      $ZodMap2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => mapProcessor2(inst, ctx, json22, params);
      inst.keyType = def.keyType;
      inst.valueType = def.valueType;
      inst.min = (...args) => inst.check(/* @__PURE__ */ _minSize2(...args));
      inst.nonempty = (params) => inst.check(/* @__PURE__ */ _minSize2(1, params));
      inst.max = (...args) => inst.check(/* @__PURE__ */ _maxSize2(...args));
      inst.size = (...args) => inst.check(/* @__PURE__ */ _size2(...args));
    });
    ZodSet3 = /* @__PURE__ */ $constructor2("ZodSet", (inst, def) => {
      $ZodSet2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => setProcessor2(inst, ctx, json22, params);
      inst.min = (...args) => inst.check(/* @__PURE__ */ _minSize2(...args));
      inst.nonempty = (params) => inst.check(/* @__PURE__ */ _minSize2(1, params));
      inst.max = (...args) => inst.check(/* @__PURE__ */ _maxSize2(...args));
      inst.size = (...args) => inst.check(/* @__PURE__ */ _size2(...args));
    });
    ZodEnum3 = /* @__PURE__ */ $constructor2("ZodEnum", (inst, def) => {
      $ZodEnum2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => enumProcessor2(inst, ctx, json22, params);
      inst.enum = def.entries;
      inst.options = Object.values(def.entries);
      const keys2 = new Set(Object.keys(def.entries));
      inst.extract = (values, params) => {
        const newEntries = {};
        for (const value of values) {
          if (keys2.has(value)) {
            newEntries[value] = def.entries[value];
          } else
            throw new Error(`Key ${value} not found in enum`);
        }
        return new ZodEnum3({
          ...def,
          checks: [],
          ...util_exports2.normalizeParams(params),
          entries: newEntries
        });
      };
      inst.exclude = (values, params) => {
        const newEntries = { ...def.entries };
        for (const value of values) {
          if (keys2.has(value)) {
            delete newEntries[value];
          } else
            throw new Error(`Key ${value} not found in enum`);
        }
        return new ZodEnum3({
          ...def,
          checks: [],
          ...util_exports2.normalizeParams(params),
          entries: newEntries
        });
      };
    });
    ZodLiteral3 = /* @__PURE__ */ $constructor2("ZodLiteral", (inst, def) => {
      $ZodLiteral2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => literalProcessor2(inst, ctx, json22, params);
      inst.values = new Set(def.values);
      Object.defineProperty(inst, "value", {
        get() {
          if (def.values.length > 1) {
            throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
          }
          return def.values[0];
        }
      });
    });
    ZodFile2 = /* @__PURE__ */ $constructor2("ZodFile", (inst, def) => {
      $ZodFile2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => fileProcessor2(inst, ctx, json22, params);
      inst.min = (size, params) => inst.check(/* @__PURE__ */ _minSize2(size, params));
      inst.max = (size, params) => inst.check(/* @__PURE__ */ _maxSize2(size, params));
      inst.mime = (types, params) => inst.check(/* @__PURE__ */ _mime2(Array.isArray(types) ? types : [types], params));
    });
    ZodTransform2 = /* @__PURE__ */ $constructor2("ZodTransform", (inst, def) => {
      $ZodTransform2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => transformProcessor2(inst, ctx, json22, params);
      inst._zod.parse = (payload, _ctx) => {
        if (_ctx.direction === "backward") {
          throw new $ZodEncodeError2(inst.constructor.name);
        }
        payload.addIssue = (issue22) => {
          var _a37, _b27, _c;
          if (typeof issue22 === "string") {
            payload.issues.push(util_exports2.issue(issue22, payload.value, def));
          } else {
            const _issue = issue22;
            if (_issue.fatal)
              _issue.continue = false;
            (_a37 = _issue.code) != null ? _a37 : _issue.code = "custom";
            (_b27 = _issue.input) != null ? _b27 : _issue.input = payload.value;
            (_c = _issue.inst) != null ? _c : _issue.inst = inst;
            payload.issues.push(util_exports2.issue(_issue));
          }
        };
        const output = def.transform(payload.value, payload);
        if (output instanceof Promise) {
          return output.then((output2) => {
            payload.value = output2;
            return payload;
          });
        }
        payload.value = output;
        return payload;
      };
    });
    ZodOptional3 = /* @__PURE__ */ $constructor2("ZodOptional", (inst, def) => {
      $ZodOptional2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => optionalProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodExactOptional2 = /* @__PURE__ */ $constructor2("ZodExactOptional", (inst, def) => {
      $ZodExactOptional2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => optionalProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodNullable3 = /* @__PURE__ */ $constructor2("ZodNullable", (inst, def) => {
      $ZodNullable2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => nullableProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodDefault3 = /* @__PURE__ */ $constructor2("ZodDefault", (inst, def) => {
      $ZodDefault2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => defaultProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
      inst.removeDefault = inst.unwrap;
    });
    ZodPrefault2 = /* @__PURE__ */ $constructor2("ZodPrefault", (inst, def) => {
      $ZodPrefault2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => prefaultProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodNonOptional2 = /* @__PURE__ */ $constructor2("ZodNonOptional", (inst, def) => {
      $ZodNonOptional2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => nonoptionalProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodSuccess2 = /* @__PURE__ */ $constructor2("ZodSuccess", (inst, def) => {
      $ZodSuccess2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => successProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodCatch3 = /* @__PURE__ */ $constructor2("ZodCatch", (inst, def) => {
      $ZodCatch2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => catchProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
      inst.removeCatch = inst.unwrap;
    });
    ZodNaN3 = /* @__PURE__ */ $constructor2("ZodNaN", (inst, def) => {
      $ZodNaN2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => nanProcessor2(inst, ctx, json22, params);
    });
    ZodPipe2 = /* @__PURE__ */ $constructor2("ZodPipe", (inst, def) => {
      $ZodPipe2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => pipeProcessor2(inst, ctx, json22, params);
      inst.in = def.in;
      inst.out = def.out;
    });
    ZodCodec2 = /* @__PURE__ */ $constructor2("ZodCodec", (inst, def) => {
      ZodPipe2.init(inst, def);
      $ZodCodec2.init(inst, def);
    });
    ZodReadonly3 = /* @__PURE__ */ $constructor2("ZodReadonly", (inst, def) => {
      $ZodReadonly2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => readonlyProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodTemplateLiteral2 = /* @__PURE__ */ $constructor2("ZodTemplateLiteral", (inst, def) => {
      $ZodTemplateLiteral2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => templateLiteralProcessor2(inst, ctx, json22, params);
    });
    ZodLazy3 = /* @__PURE__ */ $constructor2("ZodLazy", (inst, def) => {
      $ZodLazy2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => lazyProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.getter();
    });
    ZodPromise3 = /* @__PURE__ */ $constructor2("ZodPromise", (inst, def) => {
      $ZodPromise2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => promiseProcessor2(inst, ctx, json22, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    ZodFunction3 = /* @__PURE__ */ $constructor2("ZodFunction", (inst, def) => {
      $ZodFunction2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => functionProcessor2(inst, ctx, json22, params);
    });
    ZodCustom2 = /* @__PURE__ */ $constructor2("ZodCustom", (inst, def) => {
      $ZodCustom2.init(inst, def);
      ZodType3.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json22, params) => customProcessor2(inst, ctx, json22, params);
    });
    describe22 = describe3;
    meta22 = meta3;
    stringbool2 = (...args) => /* @__PURE__ */ _stringbool2({
      Codec: ZodCodec2,
      Boolean: ZodBoolean3,
      String: ZodString3
    }, ...args);
    ZodIssueCode3 = {
      invalid_type: "invalid_type",
      too_big: "too_big",
      too_small: "too_small",
      invalid_format: "invalid_format",
      not_multiple_of: "not_multiple_of",
      unrecognized_keys: "unrecognized_keys",
      invalid_union: "invalid_union",
      invalid_key: "invalid_key",
      invalid_element: "invalid_element",
      invalid_value: "invalid_value",
      custom: "custom"
    };
    /* @__PURE__ */ (function(ZodFirstPartyTypeKind22) {
    })(ZodFirstPartyTypeKind3 || (ZodFirstPartyTypeKind3 = {}));
    z2 = {
      ...schemas_exports22,
      ...checks_exports22,
      iso: iso_exports2
    };
    RECOGNIZED_KEYS2 = /* @__PURE__ */ new Set([
      // Schema identification
      "$schema",
      "$ref",
      "$defs",
      "definitions",
      // Core schema keywords
      "$id",
      "id",
      "$comment",
      "$anchor",
      "$vocabulary",
      "$dynamicRef",
      "$dynamicAnchor",
      // Type
      "type",
      "enum",
      "const",
      // Composition
      "anyOf",
      "oneOf",
      "allOf",
      "not",
      // Object
      "properties",
      "required",
      "additionalProperties",
      "patternProperties",
      "propertyNames",
      "minProperties",
      "maxProperties",
      // Array
      "items",
      "prefixItems",
      "additionalItems",
      "minItems",
      "maxItems",
      "uniqueItems",
      "contains",
      "minContains",
      "maxContains",
      // String
      "minLength",
      "maxLength",
      "pattern",
      "format",
      // Number
      "minimum",
      "maximum",
      "exclusiveMinimum",
      "exclusiveMaximum",
      "multipleOf",
      // Already handled metadata
      "description",
      "default",
      // Content
      "contentEncoding",
      "contentMediaType",
      "contentSchema",
      // Unsupported (error-throwing)
      "unevaluatedItems",
      "unevaluatedProperties",
      "if",
      "then",
      "else",
      "dependentSchemas",
      "dependentRequired",
      // OpenAPI
      "nullable",
      "readOnly"
    ]);
    coerce_exports2 = {};
    __export2(coerce_exports2, {
      bigint: () => bigint32,
      boolean: () => boolean32,
      date: () => date42,
      number: () => number32,
      string: () => string32
    });
    config2(en_default3());
    zhipuErrorDataSchema = external_exports3.object({
      error: external_exports3.object({
        message: external_exports3.string(),
        code: external_exports3.union([external_exports3.string(), external_exports3.number()]).nullish()
      })
    });
    zhipuFailedResponseHandler = createJsonErrorResponseHandler2({
      errorSchema: zhipuErrorDataSchema,
      errorToMessage: (data) => data.error.message
    });
    defaultZhipuErrorStructure = {
      errorSchema: zhipuErrorDataSchema,
      errorToMessage: (data) => data.error.message
    };
    ZhipuChatLanguageModel = class {
      /**
       * Constructs a new ZhipuChatLanguageModel.
       * @param modelId - The model identifier.
       * @param settings - Settings for the chat.
       * @param config - Model configuration.
       */
      constructor(modelId, settings, config22) {
        this.specificationVersion = "v2";
        this.defaultObjectGenerationMode = "json";
        this.supportedUrls = {
          "image/*": [/^data:image\/[a-zA-Z]+;base64,/, /^https?:\/\/.+$/i],
          "video/*": [/^https?:\/\/.+\.(mp4|webm|ogg)$/i]
        };
        var _a37;
        this.modelId = modelId.toLocaleLowerCase();
        this.settings = settings;
        this.config = config22;
        this.config.isMultiModel = this.modelId.includes("v");
        this.config.isReasoningModel = this.modelId.includes("z") || this.modelId.includes("thinking") || ((_a37 = settings.thinking) == null ? void 0 : _a37.type) === "enabled";
      }
      /**
       * Getter for the provider name.
       */
      get provider() {
        return this.config.provider;
      }
      getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        stopSequences,
        responseFormat,
        seed,
        tools,
        toolChoice
      }) {
        var _a37;
        const warnings = [];
        if (!this.config.isMultiModel && prompt.every(
          (msg) => msg.role === "user" && !msg.content.every((part) => part.type === "text")
        )) {
          warnings.push({
            type: "other",
            message: "Non-vision models does not support message parts"
          });
        }
        if (topK != null) {
          warnings.push({
            type: "unsupported-setting",
            setting: "topK"
          });
        }
        if (frequencyPenalty != null) {
          warnings.push({
            type: "unsupported-setting",
            setting: "frequencyPenalty"
          });
        }
        if (presencePenalty != null) {
          warnings.push({
            type: "unsupported-setting",
            setting: "presencePenalty"
          });
        }
        if (stopSequences != null && this.config.isMultiModel) {
          warnings.push({
            type: "unsupported-setting",
            setting: "stopSequences",
            details: "Stop sequences are not supported for vision model"
          });
        }
        if (stopSequences != null && stopSequences.length > 1) {
          warnings.push({
            type: "unsupported-setting",
            setting: "stopSequences",
            details: "Only supports one stop sequence"
          });
        }
        if (seed != null) {
          warnings.push({
            type: "unsupported-setting",
            setting: "seed"
          });
        }
        if (responseFormat && responseFormat.type === "json" && (this.config.isMultiModel || this.config.isReasoningModel)) {
          warnings.push({
            type: "unsupported-setting",
            setting: "responseFormat",
            details: "JSON response format is not supported with vision and reasoning models."
          });
        }
        if (tools && tools.length > 0 && this.config.isMultiModel) {
          warnings.push({
            type: "unsupported-setting",
            setting: "tools",
            details: "Tools are not supported with vision models."
          });
        }
        if (tools && tools.length > 0 && tools.some((tool3) => tool3.type !== "function")) {
          warnings.push({
            type: "unsupported-setting",
            setting: "tools",
            details: "Provider-defined tools are not implemented"
          });
        }
        if (responseFormat && responseFormat.type === "json" && responseFormat.schema) {
          warnings.push({
            type: "unsupported-setting",
            setting: "responseFormat",
            details: "Structured output with schema is not supported, use json response format instead."
          });
        }
        if ((toolChoice == null ? void 0 : toolChoice.type) !== "auto") {
          warnings.push({
            type: "unsupported-setting",
            setting: "toolChoice",
            details: "Only 'auto' tool choice is supported"
          });
        }
        const baseArgs = {
          // model id:
          model: this.modelId,
          // model specific settings:
          user_id: this.settings.userId,
          do_sample: this.settings.doSample,
          request_id: this.settings.requestId,
          // thinking mode for GLM-4.5+ models:
          thinking: this.settings.thinking ? {
            type: this.settings.thinking.type,
            ...this.settings.thinking.clearThinking !== void 0 && {
              clear_thinking: this.settings.thinking.clearThinking
            }
          } : void 0,
          // standardized settings:
          max_tokens: maxOutputTokens,
          temperature,
          top_p: topP,
          // response format:
          response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? { type: "json_object" } : void 0,
          // messages:
          messages: convertToZhipuChatMessages(prompt),
          // tools:
          tool_choice: "auto",
          tools: (_a37 = tools == null ? void 0 : tools.filter((tool3) => tool3.type === "function").map((tool3) => {
            var _a47;
            return {
              type: "function",
              function: {
                name: tool3.name,
                description: (_a47 = tool3.description) != null ? _a47 : void 0,
                parameters: tool3.inputSchema
              }
            };
          })) != null ? _a37 : void 0
          // TODO: add provider-specific tool (web_search|retrieval)
        };
        return {
          args: baseArgs,
          warnings
        };
      }
      async doGenerate(options) {
        var _a37, _b27, _c;
        const { args, warnings } = this.getArgs(options);
        const providerOptions = options.providerOptions || {};
        const zhipuOptions = providerOptions.zhipu || {};
        const fullArgs = {
          ...args,
          // merge any zhipu-specific options last to allow overrides
          ...zhipuOptions
        };
        const {
          value: response,
          rawValue: rawResponse,
          responseHeaders
        } = await postJsonToApi2({
          url: `${this.config.baseURL}/chat/completions`,
          headers: combineHeaders2(this.config.headers(), options.headers),
          body: fullArgs,
          failedResponseHandler: zhipuFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler2(
            zhipuChatResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const responseData = response;
        const choice2 = responseData.choices[0];
        const content = [];
        const responseText = responseData.choices[0].message.content;
        const responseReasoningText = responseData.choices[0].message.reasoning_content;
        if (responseReasoningText) {
          content.push({
            type: "reasoning",
            text: responseReasoningText
          });
        }
        if (responseText) {
          if (this.config.isReasoningModel && responseText.includes("<think>")) {
            content.push(
              {
                type: "reasoning",
                text: responseText.split("<think>")[1].split("</think>")[0]
              },
              {
                type: "text",
                text: responseText.split("</think>")[1]
              }
            );
          } else {
            content.push({
              type: "text",
              text: responseText
            });
          }
        }
        if (responseData.choices[0].message.tool_calls) {
          for (const toolCall of responseData.choices[0].message.tool_calls) {
            content.push({
              type: "tool-call",
              toolCallId: toolCall.id,
              toolName: toolCall.function.name,
              input: toolCall.function.arguments,
              providerExecuted: toolCall.type === "function" ? false : true
            });
          }
        }
        return {
          content,
          finishReason: mapZhipuFinishReason(choice2.finish_reason),
          usage: {
            totalTokens: (_b27 = (_a37 = responseData.usage) == null ? void 0 : _a37.total_tokens) != null ? _b27 : NaN,
            inputTokens: responseData.usage.prompt_tokens,
            outputTokens: (_c = responseData.usage.completion_tokens) != null ? _c : NaN
          },
          request: { body: fullArgs },
          response: {
            ...getResponseMetadata4(responseData),
            headers: responseHeaders,
            body: rawResponse
          },
          warnings
        };
      }
      async doStream(options) {
        const { args } = this.getArgs(options);
        const providerOptions = options.providerOptions || {};
        const zhipuOptions = providerOptions.zhipu || {};
        const body = { ...args, ...zhipuOptions, stream: true };
        const { responseHeaders, value: response } = await postJsonToApi2({
          url: `${this.config.baseURL}/chat/completions`,
          headers: combineHeaders2(this.config.headers(), options.headers),
          body,
          failedResponseHandler: zhipuFailedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler2(zhipuChatChunkSchema),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const toolCalls = [];
        let finishReason = "unknown";
        const usage = {
          inputTokens: void 0,
          outputTokens: void 0,
          totalTokens: void 0
        };
        let isFirstChunk = true;
        let isActiveReasoning = false;
        let isActiveText = false;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              transform(chunk, controller) {
                var _a37, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (chunk.success == false) {
                  finishReason = "error";
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                if ("error" in value) {
                  finishReason = "error";
                  controller.enqueue({ type: "error", error: value.error });
                  return;
                }
                if (isFirstChunk) {
                  isFirstChunk = false;
                  controller.enqueue({
                    type: "response-metadata",
                    ...getResponseMetadata4(value)
                  });
                  controller.enqueue({
                    type: "text-start",
                    id: "0"
                  });
                }
                if (value.usage != null) {
                  usage.inputTokens = (_a37 = value.usage.prompt_tokens) != null ? _a37 : void 0;
                  usage.outputTokens = (_b27 = value.usage.completion_tokens) != null ? _b27 : void 0;
                  usage.totalTokens = (_c = value.usage.total_tokens) != null ? _c : void 0;
                }
                const choice2 = value.choices[0];
                if ((choice2 == null ? void 0 : choice2.finish_reason) != null) {
                  if (choice2.finish_reason === "network_error") {
                    controller.enqueue({
                      type: "error",
                      error: new Error(`Error: Network Error`)
                    });
                    return;
                  }
                  finishReason = mapZhipuFinishReason(choice2.finish_reason);
                }
                if ((choice2 == null ? void 0 : choice2.delta) == null) {
                  return;
                }
                const delta = choice2.delta;
                if (delta.reasoning_content != null) {
                  if (!isActiveReasoning) {
                    controller.enqueue({
                      type: "reasoning-start",
                      id: "reasoning-0"
                    });
                    isActiveReasoning = true;
                  }
                  controller.enqueue({
                    id: "reasoning-0",
                    type: "reasoning-delta",
                    delta: delta.reasoning_content
                  });
                }
                if (delta.content != null) {
                  if (!isActiveText) {
                    controller.enqueue({ type: "text-start", id: "txt-0" });
                    isActiveText = true;
                  }
                  controller.enqueue({
                    id: "txt-0",
                    type: "text-delta",
                    delta: delta.content
                  });
                }
                if (delta.tool_calls != null) {
                  for (const toolCallDelta of delta.tool_calls) {
                    const index = toolCallDelta.index;
                    if (toolCalls[index] == null) {
                      if (toolCallDelta.id == null) {
                        throw new InvalidResponseDataError2({
                          data: toolCallDelta,
                          message: `Expected 'id' to be a string.`
                        });
                      }
                      if (((_d = toolCallDelta.function) == null ? void 0 : _d.name) == null) {
                        throw new InvalidResponseDataError2({
                          data: toolCallDelta,
                          message: `Expected 'function.name' to be a string.`
                        });
                      }
                      controller.enqueue({
                        type: "tool-input-start",
                        id: toolCallDelta.id,
                        toolName: toolCallDelta.function.name
                      });
                      toolCalls[index] = {
                        id: toolCallDelta.id,
                        type: "function",
                        function: {
                          name: toolCallDelta.function.name,
                          arguments: (_e = toolCallDelta.function.arguments) != null ? _e : ""
                        },
                        hasFinished: false
                      };
                      const toolCall2 = toolCalls[index];
                      if (((_f = toolCall2.function) == null ? void 0 : _f.name) != null && ((_g = toolCall2.function) == null ? void 0 : _g.arguments) != null) {
                        if (toolCall2.function.arguments.length > 0) {
                          controller.enqueue({
                            type: "tool-input-start",
                            id: toolCall2.id,
                            toolName: toolCall2.function.name
                          });
                        }
                        if (isParsableJson2(toolCall2.function.arguments)) {
                          controller.enqueue({
                            type: "tool-input-end",
                            id: toolCall2.id
                          });
                          controller.enqueue({
                            type: "tool-call",
                            toolCallId: (_h = toolCall2.id) != null ? _h : generateId2(),
                            toolName: toolCall2.function.name,
                            input: toolCall2.function.arguments
                          });
                          toolCall2.hasFinished = true;
                        }
                      }
                      continue;
                    }
                    const toolCall = toolCalls[index];
                    if (toolCall.hasFinished) {
                      continue;
                    }
                    if (((_i = toolCallDelta.function) == null ? void 0 : _i.arguments) != null) {
                      toolCall.function.arguments += (_k = (_j = toolCallDelta.function) == null ? void 0 : _j.arguments) != null ? _k : "";
                    }
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.id,
                      delta: (_l = toolCallDelta.function.arguments) != null ? _l : ""
                    });
                    if (((_m = toolCall.function) == null ? void 0 : _m.name) != null && ((_n = toolCall.function) == null ? void 0 : _n.arguments) != null && isParsableJson2(toolCall.function.arguments)) {
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: (_o = toolCall.id) != null ? _o : generateId2(),
                        toolName: toolCall.function.name,
                        input: toolCall.function.arguments
                      });
                      toolCall.hasFinished = true;
                    }
                  }
                }
              },
              flush(controller) {
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    zhipuChatResponseSchema = external_exports3.object({
      id: external_exports3.string().nullish(),
      created: external_exports3.number().nullish(),
      model: external_exports3.string().nullish(),
      choices: external_exports3.array(
        external_exports3.object({
          message: external_exports3.object({
            role: external_exports3.literal("assistant"),
            content: external_exports3.string().nullish(),
            reasoning_content: external_exports3.string().nullish(),
            tool_calls: external_exports3.array(
              external_exports3.object({
                id: external_exports3.string(),
                index: external_exports3.number().nullish(),
                type: external_exports3.literal("function"),
                function: external_exports3.object({ name: external_exports3.string(), arguments: external_exports3.string() })
              })
            ).nullish()
          }),
          index: external_exports3.number(),
          finish_reason: external_exports3.string().nullish()
        })
      ),
      usage: external_exports3.object({
        prompt_tokens: external_exports3.number(),
        completion_tokens: external_exports3.number().nullish(),
        total_tokens: external_exports3.number().nullish()
      }),
      web_search: external_exports3.object({
        icon: external_exports3.string(),
        title: external_exports3.string(),
        link: external_exports3.string(),
        media: external_exports3.string(),
        content: external_exports3.string()
      }).nullish()
    });
    zhipuChatChunkSchema = external_exports3.object({
      id: external_exports3.string().nullish(),
      created: external_exports3.number().nullish(),
      model: external_exports3.string().nullish(),
      choices: external_exports3.array(
        external_exports3.object({
          delta: external_exports3.object({
            role: external_exports3.enum(["assistant"]).optional(),
            content: external_exports3.string().nullish(),
            reasoning_content: external_exports3.string().nullish(),
            tool_calls: external_exports3.array(
              external_exports3.object({
                id: external_exports3.string(),
                index: external_exports3.number(),
                type: external_exports3.literal("function"),
                function: external_exports3.object({ name: external_exports3.string(), arguments: external_exports3.string() })
              })
            ).nullish()
          }),
          finish_reason: external_exports3.string().nullish(),
          index: external_exports3.number()
        })
      ),
      usage: external_exports3.object({
        prompt_tokens: external_exports3.number(),
        completion_tokens: external_exports3.number().nullish(),
        total_tokens: external_exports3.number().nullish()
      }).nullish(),
      web_search: external_exports3.object({
        icon: external_exports3.string(),
        title: external_exports3.string(),
        link: external_exports3.string(),
        media: external_exports3.string(),
        content: external_exports3.string()
      }).nullish()
    });
    ZhipuEmbeddingModel = class {
      constructor(modelId, settings, config22) {
        this.specificationVersion = "v2";
        this.modelId = modelId;
        this.settings = settings;
        this.config = config22;
      }
      get provider() {
        return this.config.provider;
      }
      get maxEmbeddingsPerCall() {
        var _a37;
        return (_a37 = this.config.maxEmbeddingsPerCall) != null ? _a37 : 64;
      }
      get supportsParallelCalls() {
        var _a37;
        return (_a37 = this.config.supportsParallelCalls) != null ? _a37 : true;
      }
      async doEmbed({
        values,
        abortSignal,
        headers
      }) {
        if (values.length > this.maxEmbeddingsPerCall) {
          throw new TooManyEmbeddingValuesForCallError2({
            provider: this.provider,
            modelId: this.modelId,
            maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
            values
          });
        }
        const { responseHeaders, value: response } = await postJsonToApi2({
          url: `${this.config.baseURL}/embeddings`,
          headers: combineHeaders2(this.config.headers(), headers),
          body: {
            model: this.modelId,
            input: values,
            dimensions: this.settings.dimensions
          },
          failedResponseHandler: zhipuFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler2(
            ZhipuTextEmbeddingResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        const typedResponse = response;
        return {
          embeddings: typedResponse.data.map((item) => item.embedding),
          usage: typedResponse.usage ? { tokens: typedResponse.usage.prompt_tokens } : void 0,
          response: { headers: responseHeaders },
          // @ts-expect-error - Temporary for Vercel AI SDK V6 compatibility
          warnings: []
        };
      }
    };
    ZhipuTextEmbeddingResponseSchema = external_exports3.object({
      data: external_exports3.array(
        external_exports3.object({
          embedding: external_exports3.array(external_exports3.number()),
          index: external_exports3.number().nullish(),
          object: external_exports3.string().nullish()
        })
      ),
      usage: external_exports3.object({
        prompt_tokens: external_exports3.number(),
        total_tokens: external_exports3.number().nullish()
      }).nullish()
    });
    sizeSchema = external_exports3.object({
      width: external_exports3.number().min(512, "Width must be at least 512px").max(2048, "Width must be at most 2048px").refine((val) => val % 16 === 0, "Width must be divisible by 16"),
      height: external_exports3.number().min(512, "Height must be at least 512px").max(2048, "Height must be at most 2048px").refine((val) => val % 16 === 0, "Height must be divisible by 16")
    }).refine(
      ({ width, height }) => width * height <= Math.pow(2, 21),
      "Total size (width \xD7 height) must be <= 2^21 pixels"
    );
    ZhipuImageModel = class {
      constructor(modelId, config22) {
        this.modelId = modelId;
        this.config = config22;
        this.specificationVersion = "v2";
        this.maxImagesPerCall = 10;
      }
      get provider() {
        return this.config.provider;
      }
      async doGenerate({
        prompt,
        n,
        size,
        aspectRatio,
        seed,
        providerOptions,
        headers,
        abortSignal
      }) {
        var _a37, _b27, _c, _d;
        const warnings = [];
        const zhipuProviderOptions = providerOptions ? (_a37 = providerOptions.zhipu) != null ? _a37 : {} : {};
        if (n != null) {
          warnings.push({
            type: "unsupported-setting",
            setting: "n",
            details: "This model does not support multiple images per call."
          });
        }
        if (aspectRatio != null) {
          warnings.push({
            type: "unsupported-setting",
            setting: "aspectRatio",
            details: "This model does not support aspect ratio. Use `size` instead."
          });
        }
        if (seed != null) {
          warnings.push({ type: "unsupported-setting", setting: "seed" });
        }
        if (size != null && !sizeSchema.safeParse({
          width: parseInt(size.split("x")[0]),
          height: parseInt(size.split("x")[1])
        }).success) {
          throw new Error(
            "Invalid size. Size must be an object with width and height, both divisible by 16, and within the range of 512 to 2048 pixels."
          );
        }
        const currentDate = (_d = (_c = (_b27 = this.config._internal) == null ? void 0 : _b27.currentDate) == null ? void 0 : _c.call(_b27)) != null ? _d : /* @__PURE__ */ new Date();
        const { value: response, responseHeaders } = await postJsonToApi2({
          url: this.config.url({
            path: "/images/generations",
            modelId: this.modelId
          }),
          headers: combineHeaders2(this.config.headers(), headers),
          body: {
            model: this.modelId,
            prompt,
            size,
            ...zhipuProviderOptions != null ? zhipuProviderOptions : {}
          },
          failedResponseHandler: createJsonErrorResponseHandler2(
            defaultZhipuErrorStructure
          ),
          successfulResponseHandler: createJsonResponseHandler2(
            zhipuImageResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        const typedResponse = response;
        const images = await Promise.all(
          typedResponse.data.map(async (item) => {
            const imageResponse = await fetch(item.url, { signal: abortSignal });
            const arrayBuffer = await imageResponse.arrayBuffer();
            return new Uint8Array(arrayBuffer);
          })
        );
        return {
          images,
          warnings,
          providerMetadata: {
            zhipu: {
              images: typedResponse.data.map((item) => {
                return {
                  url: item.url
                };
              })
            }
          },
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: responseHeaders
          }
        };
      }
    };
    zhipuImageResponseSchema = external_exports3.object({
      created: external_exports3.number(),
      data: external_exports3.array(external_exports3.object({ url: external_exports3.url() }))
    });
    zhipu = createZhipu();
    zai = createZhipu({ baseURL: "https://api.z.ai/api/paas/v4" });
  }
});

// node_modules/@ai-sdk/provider/dist/index.js
var require_dist6 = __commonJS({
  "node_modules/@ai-sdk/provider/dist/index.js"(exports2, module2) {
    "use strict";
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name143 in all3)
        __defProp4(target, name143, { get: all3[name143], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var src_exports = {};
    __export4(src_exports, {
      AISDKError: () => AISDKError5,
      APICallError: () => APICallError5,
      EmptyResponseBodyError: () => EmptyResponseBodyError5,
      InvalidArgumentError: () => InvalidArgumentError6,
      InvalidPromptError: () => InvalidPromptError5,
      InvalidResponseDataError: () => InvalidResponseDataError5,
      JSONParseError: () => JSONParseError5,
      LoadAPIKeyError: () => LoadAPIKeyError5,
      LoadSettingError: () => LoadSettingError5,
      NoContentGeneratedError: () => NoContentGeneratedError5,
      NoSuchModelError: () => NoSuchModelError5,
      TooManyEmbeddingValuesForCallError: () => TooManyEmbeddingValuesForCallError5,
      TypeValidationError: () => TypeValidationError5,
      UnsupportedFunctionalityError: () => UnsupportedFunctionalityError5,
      getErrorMessage: () => getErrorMessage6,
      isJSONArray: () => isJSONArray,
      isJSONObject: () => isJSONObject,
      isJSONValue: () => isJSONValue
    });
    module2.exports = __toCommonJS2(src_exports);
    var marker29 = "vercel.ai.error";
    var symbol30 = Symbol.for(marker29);
    var _a31;
    var _b27;
    var AISDKError5 = class _AISDKError5 extends (_b27 = Error, _a31 = symbol30, _b27) {
      /**
       * Creates an AI SDK Error.
       *
       * @param {Object} params - The parameters for creating the error.
       * @param {string} params.name - The name of the error.
       * @param {string} params.message - The error message.
       * @param {unknown} [params.cause] - The underlying cause of the error.
       */
      constructor({
        name: name143,
        message,
        cause
      }) {
        super(message);
        this[_a31] = true;
        this.name = name143;
        this.cause = cause;
      }
      /**
       * Checks if the given error is an AI SDK Error.
       * @param {unknown} error - The error to check.
       * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
       */
      static isInstance(error73) {
        return _AISDKError5.hasMarker(error73, marker29);
      }
      static hasMarker(error73, marker153) {
        const markerSymbol = Symbol.for(marker153);
        return error73 != null && typeof error73 === "object" && markerSymbol in error73 && typeof error73[markerSymbol] === "boolean" && error73[markerSymbol] === true;
      }
    };
    var name28 = "AI_APICallError";
    var marker210 = `vercel.ai.error.${name28}`;
    var symbol211 = Symbol.for(marker210);
    var _a211;
    var _b28;
    var APICallError5 = class extends (_b28 = AISDKError5, _a211 = symbol211, _b28) {
      constructor({
        message,
        url: url4,
        requestBodyValues,
        statusCode,
        responseHeaders,
        responseBody,
        cause,
        isRetryable = statusCode != null && (statusCode === 408 || // request timeout
        statusCode === 409 || // conflict
        statusCode === 429 || // too many requests
        statusCode >= 500),
        // server error
        data
      }) {
        super({ name: name28, message, cause });
        this[_a211] = true;
        this.url = url4;
        this.requestBodyValues = requestBodyValues;
        this.statusCode = statusCode;
        this.responseHeaders = responseHeaders;
        this.responseBody = responseBody;
        this.isRetryable = isRetryable;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker210);
      }
    };
    var name29 = "AI_EmptyResponseBodyError";
    var marker37 = `vercel.ai.error.${name29}`;
    var symbol37 = Symbol.for(marker37);
    var _a37;
    var _b36;
    var EmptyResponseBodyError5 = class extends (_b36 = AISDKError5, _a37 = symbol37, _b36) {
      // used in isInstance
      constructor({ message = "Empty response body" } = {}) {
        super({ name: name29, message });
        this[_a37] = true;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker37);
      }
    };
    function getErrorMessage6(error73) {
      if (error73 == null) {
        return "unknown error";
      }
      if (typeof error73 === "string") {
        return error73;
      }
      if (error73 instanceof Error) {
        return error73.message;
      }
      return JSON.stringify(error73);
    }
    var name37 = "AI_InvalidArgumentError";
    var marker47 = `vercel.ai.error.${name37}`;
    var symbol47 = Symbol.for(marker47);
    var _a47;
    var _b46;
    var InvalidArgumentError6 = class extends (_b46 = AISDKError5, _a47 = symbol47, _b46) {
      constructor({
        message,
        cause,
        argument
      }) {
        super({ name: name37, message, cause });
        this[_a47] = true;
        this.argument = argument;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker47);
      }
    };
    var name47 = "AI_InvalidPromptError";
    var marker57 = `vercel.ai.error.${name47}`;
    var symbol57 = Symbol.for(marker57);
    var _a57;
    var _b56;
    var InvalidPromptError5 = class extends (_b56 = AISDKError5, _a57 = symbol57, _b56) {
      constructor({
        prompt,
        message,
        cause
      }) {
        super({ name: name47, message: `Invalid prompt: ${message}`, cause });
        this[_a57] = true;
        this.prompt = prompt;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker57);
      }
    };
    var name57 = "AI_InvalidResponseDataError";
    var marker67 = `vercel.ai.error.${name57}`;
    var symbol67 = Symbol.for(marker67);
    var _a67;
    var _b66;
    var InvalidResponseDataError5 = class extends (_b66 = AISDKError5, _a67 = symbol67, _b66) {
      constructor({
        data,
        message = `Invalid response data: ${JSON.stringify(data)}.`
      }) {
        super({ name: name57, message });
        this[_a67] = true;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker67);
      }
    };
    var name67 = "AI_JSONParseError";
    var marker77 = `vercel.ai.error.${name67}`;
    var symbol77 = Symbol.for(marker77);
    var _a77;
    var _b76;
    var JSONParseError5 = class extends (_b76 = AISDKError5, _a77 = symbol77, _b76) {
      constructor({ text: text2, cause }) {
        super({
          name: name67,
          message: `JSON parsing failed: Text: ${text2}.
Error message: ${getErrorMessage6(cause)}`,
          cause
        });
        this[_a77] = true;
        this.text = text2;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker77);
      }
    };
    var name77 = "AI_LoadAPIKeyError";
    var marker87 = `vercel.ai.error.${name77}`;
    var symbol87 = Symbol.for(marker87);
    var _a87;
    var _b86;
    var LoadAPIKeyError5 = class extends (_b86 = AISDKError5, _a87 = symbol87, _b86) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name77, message });
        this[_a87] = true;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker87);
      }
    };
    var name86 = "AI_LoadSettingError";
    var marker96 = `vercel.ai.error.${name86}`;
    var symbol96 = Symbol.for(marker96);
    var _a96;
    var _b95;
    var LoadSettingError5 = class extends (_b95 = AISDKError5, _a96 = symbol96, _b95) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name86, message });
        this[_a96] = true;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker96);
      }
    };
    var name96 = "AI_NoContentGeneratedError";
    var marker106 = `vercel.ai.error.${name96}`;
    var symbol106 = Symbol.for(marker106);
    var _a106;
    var _b105;
    var NoContentGeneratedError5 = class extends (_b105 = AISDKError5, _a106 = symbol106, _b105) {
      // used in isInstance
      constructor({
        message = "No content generated."
      } = {}) {
        super({ name: name96, message });
        this[_a106] = true;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker106);
      }
    };
    var name106 = "AI_NoSuchModelError";
    var marker116 = `vercel.ai.error.${name106}`;
    var symbol116 = Symbol.for(marker116);
    var _a116;
    var _b115;
    var NoSuchModelError5 = class extends (_b115 = AISDKError5, _a116 = symbol116, _b115) {
      constructor({
        errorName = name106,
        modelId,
        modelType,
        message = `No such ${modelType}: ${modelId}`
      }) {
        super({ name: errorName, message });
        this[_a116] = true;
        this.modelId = modelId;
        this.modelType = modelType;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker116);
      }
    };
    var name116 = "AI_TooManyEmbeddingValuesForCallError";
    var marker126 = `vercel.ai.error.${name116}`;
    var symbol126 = Symbol.for(marker126);
    var _a126;
    var _b125;
    var TooManyEmbeddingValuesForCallError5 = class extends (_b125 = AISDKError5, _a126 = symbol126, _b125) {
      constructor(options) {
        super({
          name: name116,
          message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
        });
        this[_a126] = true;
        this.provider = options.provider;
        this.modelId = options.modelId;
        this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
        this.values = options.values;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker126);
      }
    };
    var name126 = "AI_TypeValidationError";
    var marker136 = `vercel.ai.error.${name126}`;
    var symbol136 = Symbol.for(marker136);
    var _a136;
    var _b135;
    var TypeValidationError5 = class _TypeValidationError5 extends (_b135 = AISDKError5, _a136 = symbol136, _b135) {
      constructor({
        value,
        cause,
        context: context2
      }) {
        let contextPrefix = "Type validation failed";
        if (context2 == null ? void 0 : context2.field) {
          contextPrefix += ` for ${context2.field}`;
        }
        if ((context2 == null ? void 0 : context2.entityName) || (context2 == null ? void 0 : context2.entityId)) {
          contextPrefix += " (";
          const parts = [];
          if (context2.entityName) {
            parts.push(context2.entityName);
          }
          if (context2.entityId) {
            parts.push(`id: "${context2.entityId}"`);
          }
          contextPrefix += parts.join(", ");
          contextPrefix += ")";
        }
        super({
          name: name126,
          message: `${contextPrefix}: Value: ${JSON.stringify(value)}.
Error message: ${getErrorMessage6(cause)}`,
          cause
        });
        this[_a136] = true;
        this.value = value;
        this.context = context2;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker136);
      }
      /**
       * Wraps an error into a TypeValidationError.
       * If the cause is already a TypeValidationError with the same value and context, it returns the cause.
       * Otherwise, it creates a new TypeValidationError.
       *
       * @param {Object} params - The parameters for wrapping the error.
       * @param {unknown} params.value - The value that failed validation.
       * @param {unknown} params.cause - The original error or cause of the validation failure.
       * @param {TypeValidationContext} params.context - Optional context about what is being validated.
       * @returns {TypeValidationError} A TypeValidationError instance.
       */
      static wrap({
        value,
        cause,
        context: context2
      }) {
        var _a153, _b152, _c;
        if (_TypeValidationError5.isInstance(cause) && cause.value === value && ((_a153 = cause.context) == null ? void 0 : _a153.field) === (context2 == null ? void 0 : context2.field) && ((_b152 = cause.context) == null ? void 0 : _b152.entityName) === (context2 == null ? void 0 : context2.entityName) && ((_c = cause.context) == null ? void 0 : _c.entityId) === (context2 == null ? void 0 : context2.entityId)) {
          return cause;
        }
        return new _TypeValidationError5({ value, cause, context: context2 });
      }
    };
    var name136 = "AI_UnsupportedFunctionalityError";
    var marker146 = `vercel.ai.error.${name136}`;
    var symbol146 = Symbol.for(marker146);
    var _a146;
    var _b145;
    var UnsupportedFunctionalityError5 = class extends (_b145 = AISDKError5, _a146 = symbol146, _b145) {
      constructor({
        functionality,
        message = `'${functionality}' functionality not supported.`
      }) {
        super({ name: name136, message });
        this[_a146] = true;
        this.functionality = functionality;
      }
      static isInstance(error73) {
        return AISDKError5.hasMarker(error73, marker146);
      }
    };
    function isJSONValue(value) {
      if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
        return true;
      }
      if (Array.isArray(value)) {
        return value.every(isJSONValue);
      }
      if (typeof value === "object") {
        return Object.entries(value).every(
          ([key, val]) => typeof key === "string" && (val === void 0 || isJSONValue(val))
        );
      }
      return false;
    }
    function isJSONArray(value) {
      return Array.isArray(value) && value.every(isJSONValue);
    }
    function isJSONObject(value) {
      return value != null && typeof value === "object" && Object.entries(value).every(
        ([key, val]) => typeof key === "string" && (val === void 0 || isJSONValue(val))
      );
    }
  }
});

// node_modules/zod/v4/core/core.cjs
var require_core = __commonJS({
  "node_modules/zod/v4/core/core.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.globalConfig = exports2.$ZodEncodeError = exports2.$ZodAsyncError = exports2.$brand = exports2.NEVER = void 0;
    exports2.$constructor = $constructor3;
    exports2.config = config3;
    exports2.NEVER = Object.freeze({
      status: "aborted"
    });
    function $constructor3(name28, initializer4, params) {
      function init(inst, def) {
        if (!inst._zod) {
          Object.defineProperty(inst, "_zod", {
            value: {
              def,
              constr: _,
              traits: /* @__PURE__ */ new Set()
            },
            enumerable: false
          });
        }
        if (inst._zod.traits.has(name28)) {
          return;
        }
        inst._zod.traits.add(name28);
        initializer4(inst, def);
        const proto = _.prototype;
        const keys2 = Object.keys(proto);
        for (let i = 0; i < keys2.length; i++) {
          const k = keys2[i];
          if (!(k in inst)) {
            inst[k] = proto[k].bind(inst);
          }
        }
      }
      const Parent = params?.Parent ?? Object;
      class Definition extends Parent {
      }
      Object.defineProperty(Definition, "name", { value: name28 });
      function _(def) {
        var _a31;
        const inst = params?.Parent ? new Definition() : this;
        init(inst, def);
        (_a31 = inst._zod).deferred ?? (_a31.deferred = []);
        for (const fn of inst._zod.deferred) {
          fn();
        }
        return inst;
      }
      Object.defineProperty(_, "init", { value: init });
      Object.defineProperty(_, Symbol.hasInstance, {
        value: (inst) => {
          if (params?.Parent && inst instanceof params.Parent)
            return true;
          return inst?._zod?.traits?.has(name28);
        }
      });
      Object.defineProperty(_, "name", { value: name28 });
      return _;
    }
    exports2.$brand = /* @__PURE__ */ Symbol("zod_brand");
    var $ZodAsyncError3 = class extends Error {
      constructor() {
        super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
      }
    };
    exports2.$ZodAsyncError = $ZodAsyncError3;
    var $ZodEncodeError3 = class extends Error {
      constructor(name28) {
        super(`Encountered unidirectional transform during encode: ${name28}`);
        this.name = "ZodEncodeError";
      }
    };
    exports2.$ZodEncodeError = $ZodEncodeError3;
    exports2.globalConfig = {};
    function config3(newConfig) {
      if (newConfig)
        Object.assign(exports2.globalConfig, newConfig);
      return exports2.globalConfig;
    }
  }
});

// node_modules/zod/v4/core/util.cjs
var require_util4 = __commonJS({
  "node_modules/zod/v4/core/util.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Class = exports2.BIGINT_FORMAT_RANGES = exports2.NUMBER_FORMAT_RANGES = exports2.primitiveTypes = exports2.propertyKeyTypes = exports2.getParsedType = exports2.allowsEval = exports2.captureStackTrace = void 0;
    exports2.assertEqual = assertEqual3;
    exports2.assertNotEqual = assertNotEqual3;
    exports2.assertIs = assertIs3;
    exports2.assertNever = assertNever3;
    exports2.assert = assert3;
    exports2.getEnumValues = getEnumValues3;
    exports2.joinValues = joinValues3;
    exports2.jsonStringifyReplacer = jsonStringifyReplacer3;
    exports2.cached = cached3;
    exports2.nullish = nullish4;
    exports2.cleanRegex = cleanRegex3;
    exports2.floatSafeRemainder = floatSafeRemainder4;
    exports2.defineLazy = defineLazy3;
    exports2.objectClone = objectClone3;
    exports2.assignProp = assignProp3;
    exports2.mergeDefs = mergeDefs3;
    exports2.cloneDef = cloneDef3;
    exports2.getElementAtPath = getElementAtPath3;
    exports2.promiseAllObject = promiseAllObject3;
    exports2.randomString = randomString3;
    exports2.esc = esc3;
    exports2.slugify = slugify3;
    exports2.isObject = isObject5;
    exports2.isPlainObject = isPlainObject4;
    exports2.shallowClone = shallowClone3;
    exports2.numKeys = numKeys3;
    exports2.escapeRegex = escapeRegex3;
    exports2.clone = clone3;
    exports2.normalizeParams = normalizeParams3;
    exports2.createTransparentProxy = createTransparentProxy3;
    exports2.stringifyPrimitive = stringifyPrimitive3;
    exports2.optionalKeys = optionalKeys3;
    exports2.pick = pick3;
    exports2.omit = omit3;
    exports2.extend = extend4;
    exports2.safeExtend = safeExtend3;
    exports2.merge = merge4;
    exports2.partial = partial3;
    exports2.required = required3;
    exports2.aborted = aborted3;
    exports2.prefixIssues = prefixIssues3;
    exports2.unwrapMessage = unwrapMessage3;
    exports2.finalizeIssue = finalizeIssue3;
    exports2.getSizableOrigin = getSizableOrigin3;
    exports2.getLengthableOrigin = getLengthableOrigin3;
    exports2.parsedType = parsedType3;
    exports2.issue = issue3;
    exports2.cleanEnum = cleanEnum3;
    exports2.base64ToUint8Array = base64ToUint8Array3;
    exports2.uint8ArrayToBase64 = uint8ArrayToBase643;
    exports2.base64urlToUint8Array = base64urlToUint8Array3;
    exports2.uint8ArrayToBase64url = uint8ArrayToBase64url3;
    exports2.hexToUint8Array = hexToUint8Array3;
    exports2.uint8ArrayToHex = uint8ArrayToHex3;
    function assertEqual3(val) {
      return val;
    }
    function assertNotEqual3(val) {
      return val;
    }
    function assertIs3(_arg) {
    }
    function assertNever3(_x) {
      throw new Error("Unexpected value in exhaustive check");
    }
    function assert3(_) {
    }
    function getEnumValues3(entries) {
      const numericValues = Object.values(entries).filter((v) => typeof v === "number");
      const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
      return values;
    }
    function joinValues3(array4, separator = "|") {
      return array4.map((val) => stringifyPrimitive3(val)).join(separator);
    }
    function jsonStringifyReplacer3(_, value) {
      if (typeof value === "bigint")
        return value.toString();
      return value;
    }
    function cached3(getter) {
      const set3 = false;
      return {
        get value() {
          if (!set3) {
            const value = getter();
            Object.defineProperty(this, "value", { value });
            return value;
          }
          throw new Error("cached value already set");
        }
      };
    }
    function nullish4(input) {
      return input === null || input === void 0;
    }
    function cleanRegex3(source) {
      const start = source.startsWith("^") ? 1 : 0;
      const end = source.endsWith("$") ? source.length - 1 : source.length;
      return source.slice(start, end);
    }
    function floatSafeRemainder4(val, step) {
      const valDecCount = (val.toString().split(".")[1] || "").length;
      const stepString = step.toString();
      let stepDecCount = (stepString.split(".")[1] || "").length;
      if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
        const match = stepString.match(/\d?e-(\d?)/);
        if (match?.[1]) {
          stepDecCount = Number.parseInt(match[1]);
        }
      }
      const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
      const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
      const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
      return valInt % stepInt / 10 ** decCount;
    }
    var EVALUATING3 = /* @__PURE__ */ Symbol("evaluating");
    function defineLazy3(object4, key, getter) {
      let value = void 0;
      Object.defineProperty(object4, key, {
        get() {
          if (value === EVALUATING3) {
            return void 0;
          }
          if (value === void 0) {
            value = EVALUATING3;
            value = getter();
          }
          return value;
        },
        set(v) {
          Object.defineProperty(object4, key, {
            value: v
            // configurable: true,
          });
        },
        configurable: true
      });
    }
    function objectClone3(obj) {
      return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
    }
    function assignProp3(target, prop, value) {
      Object.defineProperty(target, prop, {
        value,
        writable: true,
        enumerable: true,
        configurable: true
      });
    }
    function mergeDefs3(...defs) {
      const mergedDescriptors = {};
      for (const def of defs) {
        const descriptors = Object.getOwnPropertyDescriptors(def);
        Object.assign(mergedDescriptors, descriptors);
      }
      return Object.defineProperties({}, mergedDescriptors);
    }
    function cloneDef3(schema) {
      return mergeDefs3(schema._zod.def);
    }
    function getElementAtPath3(obj, path33) {
      if (!path33)
        return obj;
      return path33.reduce((acc, key) => acc?.[key], obj);
    }
    function promiseAllObject3(promisesObj) {
      const keys2 = Object.keys(promisesObj);
      const promises6 = keys2.map((key) => promisesObj[key]);
      return Promise.all(promises6).then((results) => {
        const resolvedObj = {};
        for (let i = 0; i < keys2.length; i++) {
          resolvedObj[keys2[i]] = results[i];
        }
        return resolvedObj;
      });
    }
    function randomString3(length = 10) {
      const chars = "abcdefghijklmnopqrstuvwxyz";
      let str = "";
      for (let i = 0; i < length; i++) {
        str += chars[Math.floor(Math.random() * chars.length)];
      }
      return str;
    }
    function esc3(str) {
      return JSON.stringify(str);
    }
    function slugify3(input) {
      return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
    }
    exports2.captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
    };
    function isObject5(data) {
      return typeof data === "object" && data !== null && !Array.isArray(data);
    }
    exports2.allowsEval = cached3(() => {
      if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
        return false;
      }
      try {
        const F = Function;
        new F("");
        return true;
      } catch (_) {
        return false;
      }
    });
    function isPlainObject4(o) {
      if (isObject5(o) === false)
        return false;
      const ctor = o.constructor;
      if (ctor === void 0)
        return true;
      if (typeof ctor !== "function")
        return true;
      const prot = ctor.prototype;
      if (isObject5(prot) === false)
        return false;
      if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
        return false;
      }
      return true;
    }
    function shallowClone3(o) {
      if (isPlainObject4(o))
        return { ...o };
      if (Array.isArray(o))
        return [...o];
      return o;
    }
    function numKeys3(data) {
      let keyCount = 0;
      for (const key in data) {
        if (Object.prototype.hasOwnProperty.call(data, key)) {
          keyCount++;
        }
      }
      return keyCount;
    }
    var getParsedType4 = (data) => {
      const t = typeof data;
      switch (t) {
        case "undefined":
          return "undefined";
        case "string":
          return "string";
        case "number":
          return Number.isNaN(data) ? "nan" : "number";
        case "boolean":
          return "boolean";
        case "function":
          return "function";
        case "bigint":
          return "bigint";
        case "symbol":
          return "symbol";
        case "object":
          if (Array.isArray(data)) {
            return "array";
          }
          if (data === null) {
            return "null";
          }
          if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
            return "promise";
          }
          if (typeof Map !== "undefined" && data instanceof Map) {
            return "map";
          }
          if (typeof Set !== "undefined" && data instanceof Set) {
            return "set";
          }
          if (typeof Date !== "undefined" && data instanceof Date) {
            return "date";
          }
          if (typeof File !== "undefined" && data instanceof File) {
            return "file";
          }
          return "object";
        default:
          throw new Error(`Unknown data type: ${t}`);
      }
    };
    exports2.getParsedType = getParsedType4;
    exports2.propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
    exports2.primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
    function escapeRegex3(str) {
      return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
    }
    function clone3(inst, def, params) {
      const cl = new inst._zod.constr(def ?? inst._zod.def);
      if (!def || params?.parent)
        cl._zod.parent = inst;
      return cl;
    }
    function normalizeParams3(_params) {
      const params = _params;
      if (!params)
        return {};
      if (typeof params === "string")
        return { error: () => params };
      if (params?.message !== void 0) {
        if (params?.error !== void 0)
          throw new Error("Cannot specify both `message` and `error` params");
        params.error = params.message;
      }
      delete params.message;
      if (typeof params.error === "string")
        return { ...params, error: () => params.error };
      return params;
    }
    function createTransparentProxy3(getter) {
      let target;
      return new Proxy({}, {
        get(_, prop, receiver) {
          target ?? (target = getter());
          return Reflect.get(target, prop, receiver);
        },
        set(_, prop, value, receiver) {
          target ?? (target = getter());
          return Reflect.set(target, prop, value, receiver);
        },
        has(_, prop) {
          target ?? (target = getter());
          return Reflect.has(target, prop);
        },
        deleteProperty(_, prop) {
          target ?? (target = getter());
          return Reflect.deleteProperty(target, prop);
        },
        ownKeys(_) {
          target ?? (target = getter());
          return Reflect.ownKeys(target);
        },
        getOwnPropertyDescriptor(_, prop) {
          target ?? (target = getter());
          return Reflect.getOwnPropertyDescriptor(target, prop);
        },
        defineProperty(_, prop, descriptor) {
          target ?? (target = getter());
          return Reflect.defineProperty(target, prop, descriptor);
        }
      });
    }
    function stringifyPrimitive3(value) {
      if (typeof value === "bigint")
        return value.toString() + "n";
      if (typeof value === "string")
        return `"${value}"`;
      return `${value}`;
    }
    function optionalKeys3(shape) {
      return Object.keys(shape).filter((k) => {
        return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
      });
    }
    exports2.NUMBER_FORMAT_RANGES = {
      safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
      int32: [-2147483648, 2147483647],
      uint32: [0, 4294967295],
      float32: [-34028234663852886e22, 34028234663852886e22],
      float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
    };
    exports2.BIGINT_FORMAT_RANGES = {
      int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
      uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
    };
    function pick3(schema, mask) {
      const currDef = schema._zod.def;
      const checks = currDef.checks;
      const hasChecks = checks && checks.length > 0;
      if (hasChecks) {
        throw new Error(".pick() cannot be used on object schemas containing refinements");
      }
      const def = mergeDefs3(schema._zod.def, {
        get shape() {
          const newShape = {};
          for (const key in mask) {
            if (!(key in currDef.shape)) {
              throw new Error(`Unrecognized key: "${key}"`);
            }
            if (!mask[key])
              continue;
            newShape[key] = currDef.shape[key];
          }
          assignProp3(this, "shape", newShape);
          return newShape;
        },
        checks: []
      });
      return clone3(schema, def);
    }
    function omit3(schema, mask) {
      const currDef = schema._zod.def;
      const checks = currDef.checks;
      const hasChecks = checks && checks.length > 0;
      if (hasChecks) {
        throw new Error(".omit() cannot be used on object schemas containing refinements");
      }
      const def = mergeDefs3(schema._zod.def, {
        get shape() {
          const newShape = { ...schema._zod.def.shape };
          for (const key in mask) {
            if (!(key in currDef.shape)) {
              throw new Error(`Unrecognized key: "${key}"`);
            }
            if (!mask[key])
              continue;
            delete newShape[key];
          }
          assignProp3(this, "shape", newShape);
          return newShape;
        },
        checks: []
      });
      return clone3(schema, def);
    }
    function extend4(schema, shape) {
      if (!isPlainObject4(shape)) {
        throw new Error("Invalid input to extend: expected a plain object");
      }
      const checks = schema._zod.def.checks;
      const hasChecks = checks && checks.length > 0;
      if (hasChecks) {
        const existingShape = schema._zod.def.shape;
        for (const key in shape) {
          if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
            throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
          }
        }
      }
      const def = mergeDefs3(schema._zod.def, {
        get shape() {
          const _shape = { ...schema._zod.def.shape, ...shape };
          assignProp3(this, "shape", _shape);
          return _shape;
        }
      });
      return clone3(schema, def);
    }
    function safeExtend3(schema, shape) {
      if (!isPlainObject4(shape)) {
        throw new Error("Invalid input to safeExtend: expected a plain object");
      }
      const def = mergeDefs3(schema._zod.def, {
        get shape() {
          const _shape = { ...schema._zod.def.shape, ...shape };
          assignProp3(this, "shape", _shape);
          return _shape;
        }
      });
      return clone3(schema, def);
    }
    function merge4(a, b) {
      const def = mergeDefs3(a._zod.def, {
        get shape() {
          const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
          assignProp3(this, "shape", _shape);
          return _shape;
        },
        get catchall() {
          return b._zod.def.catchall;
        },
        checks: []
        // delete existing checks
      });
      return clone3(a, def);
    }
    function partial3(Class4, schema, mask) {
      const currDef = schema._zod.def;
      const checks = currDef.checks;
      const hasChecks = checks && checks.length > 0;
      if (hasChecks) {
        throw new Error(".partial() cannot be used on object schemas containing refinements");
      }
      const def = mergeDefs3(schema._zod.def, {
        get shape() {
          const oldShape = schema._zod.def.shape;
          const shape = { ...oldShape };
          if (mask) {
            for (const key in mask) {
              if (!(key in oldShape)) {
                throw new Error(`Unrecognized key: "${key}"`);
              }
              if (!mask[key])
                continue;
              shape[key] = Class4 ? new Class4({
                type: "optional",
                innerType: oldShape[key]
              }) : oldShape[key];
            }
          } else {
            for (const key in oldShape) {
              shape[key] = Class4 ? new Class4({
                type: "optional",
                innerType: oldShape[key]
              }) : oldShape[key];
            }
          }
          assignProp3(this, "shape", shape);
          return shape;
        },
        checks: []
      });
      return clone3(schema, def);
    }
    function required3(Class4, schema, mask) {
      const def = mergeDefs3(schema._zod.def, {
        get shape() {
          const oldShape = schema._zod.def.shape;
          const shape = { ...oldShape };
          if (mask) {
            for (const key in mask) {
              if (!(key in shape)) {
                throw new Error(`Unrecognized key: "${key}"`);
              }
              if (!mask[key])
                continue;
              shape[key] = new Class4({
                type: "nonoptional",
                innerType: oldShape[key]
              });
            }
          } else {
            for (const key in oldShape) {
              shape[key] = new Class4({
                type: "nonoptional",
                innerType: oldShape[key]
              });
            }
          }
          assignProp3(this, "shape", shape);
          return shape;
        }
      });
      return clone3(schema, def);
    }
    function aborted3(x, startIndex = 0) {
      if (x.aborted === true)
        return true;
      for (let i = startIndex; i < x.issues.length; i++) {
        if (x.issues[i]?.continue !== true) {
          return true;
        }
      }
      return false;
    }
    function prefixIssues3(path33, issues) {
      return issues.map((iss) => {
        var _a31;
        (_a31 = iss).path ?? (_a31.path = []);
        iss.path.unshift(path33);
        return iss;
      });
    }
    function unwrapMessage3(message) {
      return typeof message === "string" ? message : message?.message;
    }
    function finalizeIssue3(iss, ctx, config3) {
      const full = { ...iss, path: iss.path ?? [] };
      if (!iss.message) {
        const message = unwrapMessage3(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage3(ctx?.error?.(iss)) ?? unwrapMessage3(config3.customError?.(iss)) ?? unwrapMessage3(config3.localeError?.(iss)) ?? "Invalid input";
        full.message = message;
      }
      delete full.inst;
      delete full.continue;
      if (!ctx?.reportInput) {
        delete full.input;
      }
      return full;
    }
    function getSizableOrigin3(input) {
      if (input instanceof Set)
        return "set";
      if (input instanceof Map)
        return "map";
      if (input instanceof File)
        return "file";
      return "unknown";
    }
    function getLengthableOrigin3(input) {
      if (Array.isArray(input))
        return "array";
      if (typeof input === "string")
        return "string";
      return "unknown";
    }
    function parsedType3(data) {
      const t = typeof data;
      switch (t) {
        case "number": {
          return Number.isNaN(data) ? "nan" : "number";
        }
        case "object": {
          if (data === null) {
            return "null";
          }
          if (Array.isArray(data)) {
            return "array";
          }
          const obj = data;
          if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
            return obj.constructor.name;
          }
        }
      }
      return t;
    }
    function issue3(...args) {
      const [iss, input, inst] = args;
      if (typeof iss === "string") {
        return {
          message: iss,
          code: "custom",
          input,
          inst
        };
      }
      return { ...iss };
    }
    function cleanEnum3(obj) {
      return Object.entries(obj).filter(([k, _]) => {
        return Number.isNaN(Number.parseInt(k, 10));
      }).map((el) => el[1]);
    }
    function base64ToUint8Array3(base644) {
      const binaryString = atob(base644);
      const bytes = new Uint8Array(binaryString.length);
      for (let i = 0; i < binaryString.length; i++) {
        bytes[i] = binaryString.charCodeAt(i);
      }
      return bytes;
    }
    function uint8ArrayToBase643(bytes) {
      let binaryString = "";
      for (let i = 0; i < bytes.length; i++) {
        binaryString += String.fromCharCode(bytes[i]);
      }
      return btoa(binaryString);
    }
    function base64urlToUint8Array3(base64url4) {
      const base644 = base64url4.replace(/-/g, "+").replace(/_/g, "/");
      const padding = "=".repeat((4 - base644.length % 4) % 4);
      return base64ToUint8Array3(base644 + padding);
    }
    function uint8ArrayToBase64url3(bytes) {
      return uint8ArrayToBase643(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
    }
    function hexToUint8Array3(hex4) {
      const cleanHex = hex4.replace(/^0x/, "");
      if (cleanHex.length % 2 !== 0) {
        throw new Error("Invalid hex string length");
      }
      const bytes = new Uint8Array(cleanHex.length / 2);
      for (let i = 0; i < cleanHex.length; i += 2) {
        bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
      }
      return bytes;
    }
    function uint8ArrayToHex3(bytes) {
      return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
    }
    var Class3 = class {
      constructor(..._args) {
      }
    };
    exports2.Class = Class3;
  }
});

// node_modules/zod/v4/core/errors.cjs
var require_errors = __commonJS({
  "node_modules/zod/v4/core/errors.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.$ZodRealError = exports2.$ZodError = void 0;
    exports2.flattenError = flattenError3;
    exports2.formatError = formatError3;
    exports2.treeifyError = treeifyError3;
    exports2.toDotPath = toDotPath3;
    exports2.prettifyError = prettifyError3;
    var core_js_1 = require_core();
    var util4 = __importStar(require_util4());
    var initializer4 = (inst, def) => {
      inst.name = "$ZodError";
      Object.defineProperty(inst, "_zod", {
        value: inst._zod,
        enumerable: false
      });
      Object.defineProperty(inst, "issues", {
        value: def,
        enumerable: false
      });
      inst.message = JSON.stringify(def, util4.jsonStringifyReplacer, 2);
      Object.defineProperty(inst, "toString", {
        value: () => inst.message,
        enumerable: false
      });
    };
    exports2.$ZodError = (0, core_js_1.$constructor)("$ZodError", initializer4);
    exports2.$ZodRealError = (0, core_js_1.$constructor)("$ZodError", initializer4, { Parent: Error });
    function flattenError3(error73, mapper = (issue3) => issue3.message) {
      const fieldErrors = {};
      const formErrors = [];
      for (const sub of error73.issues) {
        if (sub.path.length > 0) {
          fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
          fieldErrors[sub.path[0]].push(mapper(sub));
        } else {
          formErrors.push(mapper(sub));
        }
      }
      return { formErrors, fieldErrors };
    }
    function formatError3(error73, mapper = (issue3) => issue3.message) {
      const fieldErrors = { _errors: [] };
      const processError = (error74) => {
        for (const issue3 of error74.issues) {
          if (issue3.code === "invalid_union" && issue3.errors.length) {
            issue3.errors.map((issues) => processError({ issues }));
          } else if (issue3.code === "invalid_key") {
            processError({ issues: issue3.issues });
          } else if (issue3.code === "invalid_element") {
            processError({ issues: issue3.issues });
          } else if (issue3.path.length === 0) {
            fieldErrors._errors.push(mapper(issue3));
          } else {
            let curr = fieldErrors;
            let i = 0;
            while (i < issue3.path.length) {
              const el = issue3.path[i];
              const terminal = i === issue3.path.length - 1;
              if (!terminal) {
                curr[el] = curr[el] || { _errors: [] };
              } else {
                curr[el] = curr[el] || { _errors: [] };
                curr[el]._errors.push(mapper(issue3));
              }
              curr = curr[el];
              i++;
            }
          }
        }
      };
      processError(error73);
      return fieldErrors;
    }
    function treeifyError3(error73, mapper = (issue3) => issue3.message) {
      const result = { errors: [] };
      const processError = (error74, path33 = []) => {
        var _a31, _b27;
        for (const issue3 of error74.issues) {
          if (issue3.code === "invalid_union" && issue3.errors.length) {
            issue3.errors.map((issues) => processError({ issues }, issue3.path));
          } else if (issue3.code === "invalid_key") {
            processError({ issues: issue3.issues }, issue3.path);
          } else if (issue3.code === "invalid_element") {
            processError({ issues: issue3.issues }, issue3.path);
          } else {
            const fullpath = [...path33, ...issue3.path];
            if (fullpath.length === 0) {
              result.errors.push(mapper(issue3));
              continue;
            }
            let curr = result;
            let i = 0;
            while (i < fullpath.length) {
              const el = fullpath[i];
              const terminal = i === fullpath.length - 1;
              if (typeof el === "string") {
                curr.properties ?? (curr.properties = {});
                (_a31 = curr.properties)[el] ?? (_a31[el] = { errors: [] });
                curr = curr.properties[el];
              } else {
                curr.items ?? (curr.items = []);
                (_b27 = curr.items)[el] ?? (_b27[el] = { errors: [] });
                curr = curr.items[el];
              }
              if (terminal) {
                curr.errors.push(mapper(issue3));
              }
              i++;
            }
          }
        }
      };
      processError(error73);
      return result;
    }
    function toDotPath3(_path) {
      const segs = [];
      const path33 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
      for (const seg of path33) {
        if (typeof seg === "number")
          segs.push(`[${seg}]`);
        else if (typeof seg === "symbol")
          segs.push(`[${JSON.stringify(String(seg))}]`);
        else if (/[^\w$]/.test(seg))
          segs.push(`[${JSON.stringify(seg)}]`);
        else {
          if (segs.length)
            segs.push(".");
          segs.push(seg);
        }
      }
      return segs.join("");
    }
    function prettifyError3(error73) {
      const lines = [];
      const issues = [...error73.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
      for (const issue3 of issues) {
        lines.push(`\u2716 ${issue3.message}`);
        if (issue3.path?.length)
          lines.push(`  \u2192 at ${toDotPath3(issue3.path)}`);
      }
      return lines.join("\n");
    }
  }
});

// node_modules/zod/v4/core/parse.cjs
var require_parse4 = __commonJS({
  "node_modules/zod/v4/core/parse.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.safeDecodeAsync = exports2._safeDecodeAsync = exports2.safeEncodeAsync = exports2._safeEncodeAsync = exports2.safeDecode = exports2._safeDecode = exports2.safeEncode = exports2._safeEncode = exports2.decodeAsync = exports2._decodeAsync = exports2.encodeAsync = exports2._encodeAsync = exports2.decode = exports2._decode = exports2.encode = exports2._encode = exports2.safeParseAsync = exports2._safeParseAsync = exports2.safeParse = exports2._safeParse = exports2.parseAsync = exports2._parseAsync = exports2.parse = exports2._parse = void 0;
    var core = __importStar(require_core());
    var errors = __importStar(require_errors());
    var util4 = __importStar(require_util4());
    var _parse7 = (_Err) => (schema, value, _ctx, _params) => {
      const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
      const result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise) {
        throw new core.$ZodAsyncError();
      }
      if (result.issues.length) {
        const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config())));
        util4.captureStackTrace(e, _params?.callee);
        throw e;
      }
      return result.value;
    };
    exports2._parse = _parse7;
    exports2.parse = (0, exports2._parse)(errors.$ZodRealError);
    var _parseAsync3 = (_Err) => async (schema, value, _ctx, params) => {
      const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
      let result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise)
        result = await result;
      if (result.issues.length) {
        const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config())));
        util4.captureStackTrace(e, params?.callee);
        throw e;
      }
      return result.value;
    };
    exports2._parseAsync = _parseAsync3;
    exports2.parseAsync = (0, exports2._parseAsync)(errors.$ZodRealError);
    var _safeParse3 = (_Err) => (schema, value, _ctx) => {
      const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
      const result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise) {
        throw new core.$ZodAsyncError();
      }
      return result.issues.length ? {
        success: false,
        error: new (_Err ?? errors.$ZodError)(result.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config())))
      } : { success: true, data: result.value };
    };
    exports2._safeParse = _safeParse3;
    exports2.safeParse = (0, exports2._safeParse)(errors.$ZodRealError);
    var _safeParseAsync3 = (_Err) => async (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
      let result = schema._zod.run({ value, issues: [] }, ctx);
      if (result instanceof Promise)
        result = await result;
      return result.issues.length ? {
        success: false,
        error: new _Err(result.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config())))
      } : { success: true, data: result.value };
    };
    exports2._safeParseAsync = _safeParseAsync3;
    exports2.safeParseAsync = (0, exports2._safeParseAsync)(errors.$ZodRealError);
    var _encode3 = (_Err) => (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return (0, exports2._parse)(_Err)(schema, value, ctx);
    };
    exports2._encode = _encode3;
    exports2.encode = (0, exports2._encode)(errors.$ZodRealError);
    var _decode3 = (_Err) => (schema, value, _ctx) => {
      return (0, exports2._parse)(_Err)(schema, value, _ctx);
    };
    exports2._decode = _decode3;
    exports2.decode = (0, exports2._decode)(errors.$ZodRealError);
    var _encodeAsync3 = (_Err) => async (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return (0, exports2._parseAsync)(_Err)(schema, value, ctx);
    };
    exports2._encodeAsync = _encodeAsync3;
    exports2.encodeAsync = (0, exports2._encodeAsync)(errors.$ZodRealError);
    var _decodeAsync3 = (_Err) => async (schema, value, _ctx) => {
      return (0, exports2._parseAsync)(_Err)(schema, value, _ctx);
    };
    exports2._decodeAsync = _decodeAsync3;
    exports2.decodeAsync = (0, exports2._decodeAsync)(errors.$ZodRealError);
    var _safeEncode3 = (_Err) => (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return (0, exports2._safeParse)(_Err)(schema, value, ctx);
    };
    exports2._safeEncode = _safeEncode3;
    exports2.safeEncode = (0, exports2._safeEncode)(errors.$ZodRealError);
    var _safeDecode3 = (_Err) => (schema, value, _ctx) => {
      return (0, exports2._safeParse)(_Err)(schema, value, _ctx);
    };
    exports2._safeDecode = _safeDecode3;
    exports2.safeDecode = (0, exports2._safeDecode)(errors.$ZodRealError);
    var _safeEncodeAsync3 = (_Err) => async (schema, value, _ctx) => {
      const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
      return (0, exports2._safeParseAsync)(_Err)(schema, value, ctx);
    };
    exports2._safeEncodeAsync = _safeEncodeAsync3;
    exports2.safeEncodeAsync = (0, exports2._safeEncodeAsync)(errors.$ZodRealError);
    var _safeDecodeAsync3 = (_Err) => async (schema, value, _ctx) => {
      return (0, exports2._safeParseAsync)(_Err)(schema, value, _ctx);
    };
    exports2._safeDecodeAsync = _safeDecodeAsync3;
    exports2.safeDecodeAsync = (0, exports2._safeDecodeAsync)(errors.$ZodRealError);
  }
});

// node_modules/zod/v4/core/regexes.cjs
var require_regexes = __commonJS({
  "node_modules/zod/v4/core/regexes.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.sha384_hex = exports2.sha256_base64url = exports2.sha256_base64 = exports2.sha256_hex = exports2.sha1_base64url = exports2.sha1_base64 = exports2.sha1_hex = exports2.md5_base64url = exports2.md5_base64 = exports2.md5_hex = exports2.hex = exports2.uppercase = exports2.lowercase = exports2.undefined = exports2.null = exports2.boolean = exports2.number = exports2.integer = exports2.bigint = exports2.string = exports2.date = exports2.e164 = exports2.domain = exports2.hostname = exports2.base64url = exports2.base64 = exports2.cidrv6 = exports2.cidrv4 = exports2.mac = exports2.ipv6 = exports2.ipv4 = exports2.browserEmail = exports2.idnEmail = exports2.unicodeEmail = exports2.rfc5322Email = exports2.html5Email = exports2.email = exports2.uuid7 = exports2.uuid6 = exports2.uuid4 = exports2.uuid = exports2.guid = exports2.extendedDuration = exports2.duration = exports2.nanoid = exports2.ksuid = exports2.xid = exports2.ulid = exports2.cuid2 = exports2.cuid = void 0;
    exports2.sha512_base64url = exports2.sha512_base64 = exports2.sha512_hex = exports2.sha384_base64url = exports2.sha384_base64 = void 0;
    exports2.emoji = emoji4;
    exports2.time = time4;
    exports2.datetime = datetime4;
    var util4 = __importStar(require_util4());
    exports2.cuid = /^[cC][^\s-]{8,}$/;
    exports2.cuid2 = /^[0-9a-z]+$/;
    exports2.ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
    exports2.xid = /^[0-9a-vA-V]{20}$/;
    exports2.ksuid = /^[A-Za-z0-9]{27}$/;
    exports2.nanoid = /^[a-zA-Z0-9_-]{21}$/;
    exports2.duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
    exports2.extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
    exports2.guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
    var uuid5 = (version3) => {
      if (!version3)
        return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
      return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version3}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
    };
    exports2.uuid = uuid5;
    exports2.uuid4 = (0, exports2.uuid)(4);
    exports2.uuid6 = (0, exports2.uuid)(6);
    exports2.uuid7 = (0, exports2.uuid)(7);
    exports2.email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
    exports2.html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
    exports2.rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    exports2.unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
    exports2.idnEmail = exports2.unicodeEmail;
    exports2.browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
    var _emoji4 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
    function emoji4() {
      return new RegExp(_emoji4, "u");
    }
    exports2.ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
    exports2.ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
    var mac4 = (delimiter) => {
      const escapedDelim = util4.escapeRegex(delimiter ?? ":");
      return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
    };
    exports2.mac = mac4;
    exports2.cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
    exports2.cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
    exports2.base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
    exports2.base64url = /^[A-Za-z0-9_-]*$/;
    exports2.hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
    exports2.domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
    exports2.e164 = /^\+[1-9]\d{6,14}$/;
    var dateSource3 = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
    exports2.date = new RegExp(`^${dateSource3}$`);
    function timeSource3(args) {
      const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
      const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
      return regex;
    }
    function time4(args) {
      return new RegExp(`^${timeSource3(args)}$`);
    }
    function datetime4(args) {
      const time5 = timeSource3({ precision: args.precision });
      const opts = ["Z"];
      if (args.local)
        opts.push("");
      if (args.offset)
        opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
      const timeRegex2 = `${time5}(?:${opts.join("|")})`;
      return new RegExp(`^${dateSource3}T(?:${timeRegex2})$`);
    }
    var string5 = (params) => {
      const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
      return new RegExp(`^${regex}$`);
    };
    exports2.string = string5;
    exports2.bigint = /^-?\d+n?$/;
    exports2.integer = /^-?\d+$/;
    exports2.number = /^-?\d+(?:\.\d+)?$/;
    exports2.boolean = /^(?:true|false)$/i;
    var _null5 = /^null$/i;
    exports2.null = _null5;
    var _undefined5 = /^undefined$/i;
    exports2.undefined = _undefined5;
    exports2.lowercase = /^[^A-Z]*$/;
    exports2.uppercase = /^[^a-z]*$/;
    exports2.hex = /^[0-9a-fA-F]*$/;
    function fixedBase643(bodyLength, padding) {
      return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
    }
    function fixedBase64url3(length) {
      return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
    }
    exports2.md5_hex = /^[0-9a-fA-F]{32}$/;
    exports2.md5_base64 = fixedBase643(22, "==");
    exports2.md5_base64url = fixedBase64url3(22);
    exports2.sha1_hex = /^[0-9a-fA-F]{40}$/;
    exports2.sha1_base64 = fixedBase643(27, "=");
    exports2.sha1_base64url = fixedBase64url3(27);
    exports2.sha256_hex = /^[0-9a-fA-F]{64}$/;
    exports2.sha256_base64 = fixedBase643(43, "=");
    exports2.sha256_base64url = fixedBase64url3(43);
    exports2.sha384_hex = /^[0-9a-fA-F]{96}$/;
    exports2.sha384_base64 = fixedBase643(64, "");
    exports2.sha384_base64url = fixedBase64url3(64);
    exports2.sha512_hex = /^[0-9a-fA-F]{128}$/;
    exports2.sha512_base64 = fixedBase643(86, "==");
    exports2.sha512_base64url = fixedBase64url3(86);
  }
});

// node_modules/zod/v4/core/checks.cjs
var require_checks = __commonJS({
  "node_modules/zod/v4/core/checks.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.$ZodCheckOverwrite = exports2.$ZodCheckMimeType = exports2.$ZodCheckProperty = exports2.$ZodCheckEndsWith = exports2.$ZodCheckStartsWith = exports2.$ZodCheckIncludes = exports2.$ZodCheckUpperCase = exports2.$ZodCheckLowerCase = exports2.$ZodCheckRegex = exports2.$ZodCheckStringFormat = exports2.$ZodCheckLengthEquals = exports2.$ZodCheckMinLength = exports2.$ZodCheckMaxLength = exports2.$ZodCheckSizeEquals = exports2.$ZodCheckMinSize = exports2.$ZodCheckMaxSize = exports2.$ZodCheckBigIntFormat = exports2.$ZodCheckNumberFormat = exports2.$ZodCheckMultipleOf = exports2.$ZodCheckGreaterThan = exports2.$ZodCheckLessThan = exports2.$ZodCheck = void 0;
    var core = __importStar(require_core());
    var regexes = __importStar(require_regexes());
    var util4 = __importStar(require_util4());
    exports2.$ZodCheck = core.$constructor("$ZodCheck", (inst, def) => {
      var _a31;
      inst._zod ?? (inst._zod = {});
      inst._zod.def = def;
      (_a31 = inst._zod).onattach ?? (_a31.onattach = []);
    });
    var numericOriginMap3 = {
      number: "number",
      bigint: "bigint",
      object: "date"
    };
    exports2.$ZodCheckLessThan = core.$constructor("$ZodCheckLessThan", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      const origin2 = numericOriginMap3[typeof def.value];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
        if (def.value < curr) {
          if (def.inclusive)
            bag.maximum = def.value;
          else
            bag.exclusiveMaximum = def.value;
        }
      });
      inst._zod.check = (payload) => {
        if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
          return;
        }
        payload.issues.push({
          origin: origin2,
          code: "too_big",
          maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
          input: payload.value,
          inclusive: def.inclusive,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckGreaterThan = core.$constructor("$ZodCheckGreaterThan", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      const origin2 = numericOriginMap3[typeof def.value];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
        if (def.value > curr) {
          if (def.inclusive)
            bag.minimum = def.value;
          else
            bag.exclusiveMinimum = def.value;
        }
      });
      inst._zod.check = (payload) => {
        if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
          return;
        }
        payload.issues.push({
          origin: origin2,
          code: "too_small",
          minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
          input: payload.value,
          inclusive: def.inclusive,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckMultipleOf = /* @__PURE__ */ core.$constructor("$ZodCheckMultipleOf", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      inst._zod.onattach.push((inst2) => {
        var _a31;
        (_a31 = inst2._zod.bag).multipleOf ?? (_a31.multipleOf = def.value);
      });
      inst._zod.check = (payload) => {
        if (typeof payload.value !== typeof def.value)
          throw new Error("Cannot mix number and bigint in multiple_of check.");
        const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : util4.floatSafeRemainder(payload.value, def.value) === 0;
        if (isMultiple)
          return;
        payload.issues.push({
          origin: typeof payload.value,
          code: "not_multiple_of",
          divisor: def.value,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckNumberFormat = core.$constructor("$ZodCheckNumberFormat", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      def.format = def.format || "float64";
      const isInt = def.format?.includes("int");
      const origin2 = isInt ? "int" : "number";
      const [minimum, maximum] = util4.NUMBER_FORMAT_RANGES[def.format];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.format = def.format;
        bag.minimum = minimum;
        bag.maximum = maximum;
        if (isInt)
          bag.pattern = regexes.integer;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        if (isInt) {
          if (!Number.isInteger(input)) {
            payload.issues.push({
              expected: origin2,
              format: def.format,
              code: "invalid_type",
              continue: false,
              input,
              inst
            });
            return;
          }
          if (!Number.isSafeInteger(input)) {
            if (input > 0) {
              payload.issues.push({
                input,
                code: "too_big",
                maximum: Number.MAX_SAFE_INTEGER,
                note: "Integers must be within the safe integer range.",
                inst,
                origin: origin2,
                inclusive: true,
                continue: !def.abort
              });
            } else {
              payload.issues.push({
                input,
                code: "too_small",
                minimum: Number.MIN_SAFE_INTEGER,
                note: "Integers must be within the safe integer range.",
                inst,
                origin: origin2,
                inclusive: true,
                continue: !def.abort
              });
            }
            return;
          }
        }
        if (input < minimum) {
          payload.issues.push({
            origin: "number",
            input,
            code: "too_small",
            minimum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
        if (input > maximum) {
          payload.issues.push({
            origin: "number",
            input,
            code: "too_big",
            maximum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    exports2.$ZodCheckBigIntFormat = core.$constructor("$ZodCheckBigIntFormat", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      const [minimum, maximum] = util4.BIGINT_FORMAT_RANGES[def.format];
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.format = def.format;
        bag.minimum = minimum;
        bag.maximum = maximum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        if (input < minimum) {
          payload.issues.push({
            origin: "bigint",
            input,
            code: "too_small",
            minimum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
        if (input > maximum) {
          payload.issues.push({
            origin: "bigint",
            input,
            code: "too_big",
            maximum,
            inclusive: true,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    exports2.$ZodCheckMaxSize = core.$constructor("$ZodCheckMaxSize", (inst, def) => {
      var _a31;
      exports2.$ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !util4.nullish(val) && val.size !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
        if (def.maximum < curr)
          inst2._zod.bag.maximum = def.maximum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const size = input.size;
        if (size <= def.maximum)
          return;
        payload.issues.push({
          origin: util4.getSizableOrigin(input),
          code: "too_big",
          maximum: def.maximum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckMinSize = core.$constructor("$ZodCheckMinSize", (inst, def) => {
      var _a31;
      exports2.$ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !util4.nullish(val) && val.size !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
        if (def.minimum > curr)
          inst2._zod.bag.minimum = def.minimum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const size = input.size;
        if (size >= def.minimum)
          return;
        payload.issues.push({
          origin: util4.getSizableOrigin(input),
          code: "too_small",
          minimum: def.minimum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckSizeEquals = core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
      var _a31;
      exports2.$ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !util4.nullish(val) && val.size !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.minimum = def.size;
        bag.maximum = def.size;
        bag.size = def.size;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const size = input.size;
        if (size === def.size)
          return;
        const tooBig = size > def.size;
        payload.issues.push({
          origin: util4.getSizableOrigin(input),
          ...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size },
          inclusive: true,
          exact: true,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckMaxLength = core.$constructor("$ZodCheckMaxLength", (inst, def) => {
      var _a31;
      exports2.$ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !util4.nullish(val) && val.length !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
        if (def.maximum < curr)
          inst2._zod.bag.maximum = def.maximum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const length = input.length;
        if (length <= def.maximum)
          return;
        const origin2 = util4.getLengthableOrigin(input);
        payload.issues.push({
          origin: origin2,
          code: "too_big",
          maximum: def.maximum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckMinLength = core.$constructor("$ZodCheckMinLength", (inst, def) => {
      var _a31;
      exports2.$ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !util4.nullish(val) && val.length !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
        if (def.minimum > curr)
          inst2._zod.bag.minimum = def.minimum;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const length = input.length;
        if (length >= def.minimum)
          return;
        const origin2 = util4.getLengthableOrigin(input);
        payload.issues.push({
          origin: origin2,
          code: "too_small",
          minimum: def.minimum,
          inclusive: true,
          input,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckLengthEquals = core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
      var _a31;
      exports2.$ZodCheck.init(inst, def);
      (_a31 = inst._zod.def).when ?? (_a31.when = (payload) => {
        const val = payload.value;
        return !util4.nullish(val) && val.length !== void 0;
      });
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.minimum = def.length;
        bag.maximum = def.length;
        bag.length = def.length;
      });
      inst._zod.check = (payload) => {
        const input = payload.value;
        const length = input.length;
        if (length === def.length)
          return;
        const origin2 = util4.getLengthableOrigin(input);
        const tooBig = length > def.length;
        payload.issues.push({
          origin: origin2,
          ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
          inclusive: true,
          exact: true,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckStringFormat = core.$constructor("$ZodCheckStringFormat", (inst, def) => {
      var _a31, _b27;
      exports2.$ZodCheck.init(inst, def);
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.format = def.format;
        if (def.pattern) {
          bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
          bag.patterns.add(def.pattern);
        }
      });
      if (def.pattern)
        (_a31 = inst._zod).check ?? (_a31.check = (payload) => {
          def.pattern.lastIndex = 0;
          if (def.pattern.test(payload.value))
            return;
          payload.issues.push({
            origin: "string",
            code: "invalid_format",
            format: def.format,
            input: payload.value,
            ...def.pattern ? { pattern: def.pattern.toString() } : {},
            inst,
            continue: !def.abort
          });
        });
      else
        (_b27 = inst._zod).check ?? (_b27.check = () => {
        });
    });
    exports2.$ZodCheckRegex = core.$constructor("$ZodCheckRegex", (inst, def) => {
      exports2.$ZodCheckStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        def.pattern.lastIndex = 0;
        if (def.pattern.test(payload.value))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "regex",
          input: payload.value,
          pattern: def.pattern.toString(),
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckLowerCase = core.$constructor("$ZodCheckLowerCase", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.lowercase);
      exports2.$ZodCheckStringFormat.init(inst, def);
    });
    exports2.$ZodCheckUpperCase = core.$constructor("$ZodCheckUpperCase", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.uppercase);
      exports2.$ZodCheckStringFormat.init(inst, def);
    });
    exports2.$ZodCheckIncludes = core.$constructor("$ZodCheckIncludes", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      const escapedRegex = util4.escapeRegex(def.includes);
      const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
      def.pattern = pattern;
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
        bag.patterns.add(pattern);
      });
      inst._zod.check = (payload) => {
        if (payload.value.includes(def.includes, def.position))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "includes",
          includes: def.includes,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckStartsWith = core.$constructor("$ZodCheckStartsWith", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      const pattern = new RegExp(`^${util4.escapeRegex(def.prefix)}.*`);
      def.pattern ?? (def.pattern = pattern);
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
        bag.patterns.add(pattern);
      });
      inst._zod.check = (payload) => {
        if (payload.value.startsWith(def.prefix))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "starts_with",
          prefix: def.prefix,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckEndsWith = core.$constructor("$ZodCheckEndsWith", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      const pattern = new RegExp(`.*${util4.escapeRegex(def.suffix)}$`);
      def.pattern ?? (def.pattern = pattern);
      inst._zod.onattach.push((inst2) => {
        const bag = inst2._zod.bag;
        bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
        bag.patterns.add(pattern);
      });
      inst._zod.check = (payload) => {
        if (payload.value.endsWith(def.suffix))
          return;
        payload.issues.push({
          origin: "string",
          code: "invalid_format",
          format: "ends_with",
          suffix: def.suffix,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    function handleCheckPropertyResult3(result, payload, property2) {
      if (result.issues.length) {
        payload.issues.push(...util4.prefixIssues(property2, result.issues));
      }
    }
    exports2.$ZodCheckProperty = core.$constructor("$ZodCheckProperty", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      inst._zod.check = (payload) => {
        const result = def.schema._zod.run({
          value: payload.value[def.property],
          issues: []
        }, {});
        if (result instanceof Promise) {
          return result.then((result2) => handleCheckPropertyResult3(result2, payload, def.property));
        }
        handleCheckPropertyResult3(result, payload, def.property);
        return;
      };
    });
    exports2.$ZodCheckMimeType = core.$constructor("$ZodCheckMimeType", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      const mimeSet = new Set(def.mime);
      inst._zod.onattach.push((inst2) => {
        inst2._zod.bag.mime = def.mime;
      });
      inst._zod.check = (payload) => {
        if (mimeSet.has(payload.value.type))
          return;
        payload.issues.push({
          code: "invalid_value",
          values: def.mime,
          input: payload.value.type,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCheckOverwrite = core.$constructor("$ZodCheckOverwrite", (inst, def) => {
      exports2.$ZodCheck.init(inst, def);
      inst._zod.check = (payload) => {
        payload.value = def.tx(payload.value);
      };
    });
  }
});

// node_modules/zod/v4/core/doc.cjs
var require_doc = __commonJS({
  "node_modules/zod/v4/core/doc.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Doc = void 0;
    var Doc3 = class {
      constructor(args = []) {
        this.content = [];
        this.indent = 0;
        if (this)
          this.args = args;
      }
      indented(fn) {
        this.indent += 1;
        fn(this);
        this.indent -= 1;
      }
      write(arg) {
        if (typeof arg === "function") {
          arg(this, { execution: "sync" });
          arg(this, { execution: "async" });
          return;
        }
        const content = arg;
        const lines = content.split("\n").filter((x) => x);
        const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
        const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
        for (const line of dedented) {
          this.content.push(line);
        }
      }
      compile() {
        const F = Function;
        const args = this?.args;
        const content = this?.content ?? [``];
        const lines = [...content.map((x) => `  ${x}`)];
        return new F(...args, lines.join("\n"));
      }
    };
    exports2.Doc = Doc3;
  }
});

// node_modules/zod/v4/core/versions.cjs
var require_versions = __commonJS({
  "node_modules/zod/v4/core/versions.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.version = void 0;
    exports2.version = {
      major: 4,
      minor: 3,
      patch: 6
    };
  }
});

// node_modules/zod/v4/core/schemas.cjs
var require_schemas = __commonJS({
  "node_modules/zod/v4/core/schemas.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.$ZodTuple = exports2.$ZodIntersection = exports2.$ZodDiscriminatedUnion = exports2.$ZodXor = exports2.$ZodUnion = exports2.$ZodObjectJIT = exports2.$ZodObject = exports2.$ZodArray = exports2.$ZodDate = exports2.$ZodVoid = exports2.$ZodNever = exports2.$ZodUnknown = exports2.$ZodAny = exports2.$ZodNull = exports2.$ZodUndefined = exports2.$ZodSymbol = exports2.$ZodBigIntFormat = exports2.$ZodBigInt = exports2.$ZodBoolean = exports2.$ZodNumberFormat = exports2.$ZodNumber = exports2.$ZodCustomStringFormat = exports2.$ZodJWT = exports2.$ZodE164 = exports2.$ZodBase64URL = exports2.$ZodBase64 = exports2.$ZodCIDRv6 = exports2.$ZodCIDRv4 = exports2.$ZodMAC = exports2.$ZodIPv6 = exports2.$ZodIPv4 = exports2.$ZodISODuration = exports2.$ZodISOTime = exports2.$ZodISODate = exports2.$ZodISODateTime = exports2.$ZodKSUID = exports2.$ZodXID = exports2.$ZodULID = exports2.$ZodCUID2 = exports2.$ZodCUID = exports2.$ZodNanoID = exports2.$ZodEmoji = exports2.$ZodURL = exports2.$ZodEmail = exports2.$ZodUUID = exports2.$ZodGUID = exports2.$ZodStringFormat = exports2.$ZodString = exports2.clone = exports2.$ZodType = void 0;
    exports2.$ZodCustom = exports2.$ZodLazy = exports2.$ZodPromise = exports2.$ZodFunction = exports2.$ZodTemplateLiteral = exports2.$ZodReadonly = exports2.$ZodCodec = exports2.$ZodPipe = exports2.$ZodNaN = exports2.$ZodCatch = exports2.$ZodSuccess = exports2.$ZodNonOptional = exports2.$ZodPrefault = exports2.$ZodDefault = exports2.$ZodNullable = exports2.$ZodExactOptional = exports2.$ZodOptional = exports2.$ZodTransform = exports2.$ZodFile = exports2.$ZodLiteral = exports2.$ZodEnum = exports2.$ZodSet = exports2.$ZodMap = exports2.$ZodRecord = void 0;
    exports2.isValidBase64 = isValidBase643;
    exports2.isValidBase64URL = isValidBase64URL3;
    exports2.isValidJWT = isValidJWT4;
    var checks = __importStar(require_checks());
    var core = __importStar(require_core());
    var doc_js_1 = require_doc();
    var parse_js_1 = require_parse4();
    var regexes = __importStar(require_regexes());
    var util4 = __importStar(require_util4());
    var versions_js_1 = require_versions();
    exports2.$ZodType = core.$constructor("$ZodType", (inst, def) => {
      var _a31;
      inst ?? (inst = {});
      inst._zod.def = def;
      inst._zod.bag = inst._zod.bag || {};
      inst._zod.version = versions_js_1.version;
      const checks2 = [...inst._zod.def.checks ?? []];
      if (inst._zod.traits.has("$ZodCheck")) {
        checks2.unshift(inst);
      }
      for (const ch of checks2) {
        for (const fn of ch._zod.onattach) {
          fn(inst);
        }
      }
      if (checks2.length === 0) {
        (_a31 = inst._zod).deferred ?? (_a31.deferred = []);
        inst._zod.deferred?.push(() => {
          inst._zod.run = inst._zod.parse;
        });
      } else {
        const runChecks = (payload, checks3, ctx) => {
          let isAborted2 = util4.aborted(payload);
          let asyncResult;
          for (const ch of checks3) {
            if (ch._zod.def.when) {
              const shouldRun = ch._zod.def.when(payload);
              if (!shouldRun)
                continue;
            } else if (isAborted2) {
              continue;
            }
            const currLen = payload.issues.length;
            const _ = ch._zod.check(payload);
            if (_ instanceof Promise && ctx?.async === false) {
              throw new core.$ZodAsyncError();
            }
            if (asyncResult || _ instanceof Promise) {
              asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
                await _;
                const nextLen = payload.issues.length;
                if (nextLen === currLen)
                  return;
                if (!isAborted2)
                  isAborted2 = util4.aborted(payload, currLen);
              });
            } else {
              const nextLen = payload.issues.length;
              if (nextLen === currLen)
                continue;
              if (!isAborted2)
                isAborted2 = util4.aborted(payload, currLen);
            }
          }
          if (asyncResult) {
            return asyncResult.then(() => {
              return payload;
            });
          }
          return payload;
        };
        const handleCanaryResult = (canary, payload, ctx) => {
          if (util4.aborted(canary)) {
            canary.aborted = true;
            return canary;
          }
          const checkResult = runChecks(payload, checks2, ctx);
          if (checkResult instanceof Promise) {
            if (ctx.async === false)
              throw new core.$ZodAsyncError();
            return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
          }
          return inst._zod.parse(checkResult, ctx);
        };
        inst._zod.run = (payload, ctx) => {
          if (ctx.skipChecks) {
            return inst._zod.parse(payload, ctx);
          }
          if (ctx.direction === "backward") {
            const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
            if (canary instanceof Promise) {
              return canary.then((canary2) => {
                return handleCanaryResult(canary2, payload, ctx);
              });
            }
            return handleCanaryResult(canary, payload, ctx);
          }
          const result = inst._zod.parse(payload, ctx);
          if (result instanceof Promise) {
            if (ctx.async === false)
              throw new core.$ZodAsyncError();
            return result.then((result2) => runChecks(result2, checks2, ctx));
          }
          return runChecks(result, checks2, ctx);
        };
      }
      util4.defineLazy(inst, "~standard", () => ({
        validate: (value) => {
          try {
            const r = (0, parse_js_1.safeParse)(inst, value);
            return r.success ? { value: r.data } : { issues: r.error?.issues };
          } catch (_) {
            return (0, parse_js_1.safeParseAsync)(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
          }
        },
        vendor: "zod",
        version: 1
      }));
    });
    var util_js_1 = require_util4();
    Object.defineProperty(exports2, "clone", { enumerable: true, get: function() {
      return util_js_1.clone;
    } });
    exports2.$ZodString = core.$constructor("$ZodString", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? regexes.string(inst._zod.bag);
      inst._zod.parse = (payload, _) => {
        if (def.coerce)
          try {
            payload.value = String(payload.value);
          } catch (_2) {
          }
        if (typeof payload.value === "string")
          return payload;
        payload.issues.push({
          expected: "string",
          code: "invalid_type",
          input: payload.value,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodStringFormat = core.$constructor("$ZodStringFormat", (inst, def) => {
      checks.$ZodCheckStringFormat.init(inst, def);
      exports2.$ZodString.init(inst, def);
    });
    exports2.$ZodGUID = core.$constructor("$ZodGUID", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.guid);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodUUID = core.$constructor("$ZodUUID", (inst, def) => {
      if (def.version) {
        const versionMap = {
          v1: 1,
          v2: 2,
          v3: 3,
          v4: 4,
          v5: 5,
          v6: 6,
          v7: 7,
          v8: 8
        };
        const v = versionMap[def.version];
        if (v === void 0)
          throw new Error(`Invalid UUID version: "${def.version}"`);
        def.pattern ?? (def.pattern = regexes.uuid(v));
      } else
        def.pattern ?? (def.pattern = regexes.uuid());
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodEmail = core.$constructor("$ZodEmail", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.email);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodURL = core.$constructor("$ZodURL", (inst, def) => {
      exports2.$ZodStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        try {
          const trimmed = payload.value.trim();
          const url4 = new URL(trimmed);
          if (def.hostname) {
            def.hostname.lastIndex = 0;
            if (!def.hostname.test(url4.hostname)) {
              payload.issues.push({
                code: "invalid_format",
                format: "url",
                note: "Invalid hostname",
                pattern: def.hostname.source,
                input: payload.value,
                inst,
                continue: !def.abort
              });
            }
          }
          if (def.protocol) {
            def.protocol.lastIndex = 0;
            if (!def.protocol.test(url4.protocol.endsWith(":") ? url4.protocol.slice(0, -1) : url4.protocol)) {
              payload.issues.push({
                code: "invalid_format",
                format: "url",
                note: "Invalid protocol",
                pattern: def.protocol.source,
                input: payload.value,
                inst,
                continue: !def.abort
              });
            }
          }
          if (def.normalize) {
            payload.value = url4.href;
          } else {
            payload.value = trimmed;
          }
          return;
        } catch (_) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    exports2.$ZodEmoji = core.$constructor("$ZodEmoji", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.emoji());
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodNanoID = core.$constructor("$ZodNanoID", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.nanoid);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodCUID = core.$constructor("$ZodCUID", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.cuid);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodCUID2 = core.$constructor("$ZodCUID2", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.cuid2);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodULID = core.$constructor("$ZodULID", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.ulid);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodXID = core.$constructor("$ZodXID", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.xid);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodKSUID = core.$constructor("$ZodKSUID", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.ksuid);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodISODateTime = core.$constructor("$ZodISODateTime", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.datetime(def));
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodISODate = core.$constructor("$ZodISODate", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.date);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodISOTime = core.$constructor("$ZodISOTime", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.time(def));
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodISODuration = core.$constructor("$ZodISODuration", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.duration);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodIPv4 = core.$constructor("$ZodIPv4", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.ipv4);
      exports2.$ZodStringFormat.init(inst, def);
      inst._zod.bag.format = `ipv4`;
    });
    exports2.$ZodIPv6 = core.$constructor("$ZodIPv6", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.ipv6);
      exports2.$ZodStringFormat.init(inst, def);
      inst._zod.bag.format = `ipv6`;
      inst._zod.check = (payload) => {
        try {
          new URL(`http://[${payload.value}]`);
        } catch {
          payload.issues.push({
            code: "invalid_format",
            format: "ipv6",
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    exports2.$ZodMAC = core.$constructor("$ZodMAC", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.mac(def.delimiter));
      exports2.$ZodStringFormat.init(inst, def);
      inst._zod.bag.format = `mac`;
    });
    exports2.$ZodCIDRv4 = core.$constructor("$ZodCIDRv4", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.cidrv4);
      exports2.$ZodStringFormat.init(inst, def);
    });
    exports2.$ZodCIDRv6 = core.$constructor("$ZodCIDRv6", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.cidrv6);
      exports2.$ZodStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        const parts = payload.value.split("/");
        try {
          if (parts.length !== 2)
            throw new Error();
          const [address, prefix] = parts;
          if (!prefix)
            throw new Error();
          const prefixNum = Number(prefix);
          if (`${prefixNum}` !== prefix)
            throw new Error();
          if (prefixNum < 0 || prefixNum > 128)
            throw new Error();
          new URL(`http://[${address}]`);
        } catch {
          payload.issues.push({
            code: "invalid_format",
            format: "cidrv6",
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      };
    });
    function isValidBase643(data) {
      if (data === "")
        return true;
      if (data.length % 4 !== 0)
        return false;
      try {
        atob(data);
        return true;
      } catch {
        return false;
      }
    }
    exports2.$ZodBase64 = core.$constructor("$ZodBase64", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.base64);
      exports2.$ZodStringFormat.init(inst, def);
      inst._zod.bag.contentEncoding = "base64";
      inst._zod.check = (payload) => {
        if (isValidBase643(payload.value))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: "base64",
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    function isValidBase64URL3(data) {
      if (!regexes.base64url.test(data))
        return false;
      const base644 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
      const padded = base644.padEnd(Math.ceil(base644.length / 4) * 4, "=");
      return isValidBase643(padded);
    }
    exports2.$ZodBase64URL = core.$constructor("$ZodBase64URL", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.base64url);
      exports2.$ZodStringFormat.init(inst, def);
      inst._zod.bag.contentEncoding = "base64url";
      inst._zod.check = (payload) => {
        if (isValidBase64URL3(payload.value))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: "base64url",
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodE164 = core.$constructor("$ZodE164", (inst, def) => {
      def.pattern ?? (def.pattern = regexes.e164);
      exports2.$ZodStringFormat.init(inst, def);
    });
    function isValidJWT4(token, algorithm = null) {
      try {
        const tokensParts = token.split(".");
        if (tokensParts.length !== 3)
          return false;
        const [header] = tokensParts;
        if (!header)
          return false;
        const parsedHeader = JSON.parse(atob(header));
        if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
          return false;
        if (!parsedHeader.alg)
          return false;
        if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
          return false;
        return true;
      } catch {
        return false;
      }
    }
    exports2.$ZodJWT = core.$constructor("$ZodJWT", (inst, def) => {
      exports2.$ZodStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        if (isValidJWT4(payload.value, def.alg))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: "jwt",
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodCustomStringFormat = core.$constructor("$ZodCustomStringFormat", (inst, def) => {
      exports2.$ZodStringFormat.init(inst, def);
      inst._zod.check = (payload) => {
        if (def.fn(payload.value))
          return;
        payload.issues.push({
          code: "invalid_format",
          format: def.format,
          input: payload.value,
          inst,
          continue: !def.abort
        });
      };
    });
    exports2.$ZodNumber = core.$constructor("$ZodNumber", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.pattern = inst._zod.bag.pattern ?? regexes.number;
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce)
          try {
            payload.value = Number(payload.value);
          } catch (_) {
          }
        const input = payload.value;
        if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
          return payload;
        }
        const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
        payload.issues.push({
          expected: "number",
          code: "invalid_type",
          input,
          inst,
          ...received ? { received } : {}
        });
        return payload;
      };
    });
    exports2.$ZodNumberFormat = core.$constructor("$ZodNumberFormat", (inst, def) => {
      checks.$ZodCheckNumberFormat.init(inst, def);
      exports2.$ZodNumber.init(inst, def);
    });
    exports2.$ZodBoolean = core.$constructor("$ZodBoolean", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.pattern = regexes.boolean;
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce)
          try {
            payload.value = Boolean(payload.value);
          } catch (_) {
          }
        const input = payload.value;
        if (typeof input === "boolean")
          return payload;
        payload.issues.push({
          expected: "boolean",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodBigInt = core.$constructor("$ZodBigInt", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.pattern = regexes.bigint;
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce)
          try {
            payload.value = BigInt(payload.value);
          } catch (_) {
          }
        if (typeof payload.value === "bigint")
          return payload;
        payload.issues.push({
          expected: "bigint",
          code: "invalid_type",
          input: payload.value,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodBigIntFormat = core.$constructor("$ZodBigIntFormat", (inst, def) => {
      checks.$ZodCheckBigIntFormat.init(inst, def);
      exports2.$ZodBigInt.init(inst, def);
    });
    exports2.$ZodSymbol = core.$constructor("$ZodSymbol", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (typeof input === "symbol")
          return payload;
        payload.issues.push({
          expected: "symbol",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodUndefined = core.$constructor("$ZodUndefined", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.pattern = regexes.undefined;
      inst._zod.values = /* @__PURE__ */ new Set([void 0]);
      inst._zod.optin = "optional";
      inst._zod.optout = "optional";
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (typeof input === "undefined")
          return payload;
        payload.issues.push({
          expected: "undefined",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodNull = core.$constructor("$ZodNull", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.pattern = regexes.null;
      inst._zod.values = /* @__PURE__ */ new Set([null]);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (input === null)
          return payload;
        payload.issues.push({
          expected: "null",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodAny = core.$constructor("$ZodAny", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload) => payload;
    });
    exports2.$ZodUnknown = core.$constructor("$ZodUnknown", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload) => payload;
    });
    exports2.$ZodNever = core.$constructor("$ZodNever", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        payload.issues.push({
          expected: "never",
          code: "invalid_type",
          input: payload.value,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodVoid = core.$constructor("$ZodVoid", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (typeof input === "undefined")
          return payload;
        payload.issues.push({
          expected: "void",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodDate = core.$constructor("$ZodDate", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        if (def.coerce) {
          try {
            payload.value = new Date(payload.value);
          } catch (_err) {
          }
        }
        const input = payload.value;
        const isDate2 = input instanceof Date;
        const isValidDate = isDate2 && !Number.isNaN(input.getTime());
        if (isValidDate)
          return payload;
        payload.issues.push({
          expected: "date",
          code: "invalid_type",
          input,
          ...isDate2 ? { received: "Invalid Date" } : {},
          inst
        });
        return payload;
      };
    });
    function handleArrayResult3(result, final, index) {
      if (result.issues.length) {
        final.issues.push(...util4.prefixIssues(index, result.issues));
      }
      final.value[index] = result.value;
    }
    exports2.$ZodArray = core.$constructor("$ZodArray", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!Array.isArray(input)) {
          payload.issues.push({
            expected: "array",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        payload.value = Array(input.length);
        const proms = [];
        for (let i = 0; i < input.length; i++) {
          const item = input[i];
          const result = def.element._zod.run({
            value: item,
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => handleArrayResult3(result2, payload, i)));
          } else {
            handleArrayResult3(result, payload, i);
          }
        }
        if (proms.length) {
          return Promise.all(proms).then(() => payload);
        }
        return payload;
      };
    });
    function handlePropertyResult3(result, final, key, input, isOptionalOut) {
      if (result.issues.length) {
        if (isOptionalOut && !(key in input)) {
          return;
        }
        final.issues.push(...util4.prefixIssues(key, result.issues));
      }
      if (result.value === void 0) {
        if (key in input) {
          final.value[key] = void 0;
        }
      } else {
        final.value[key] = result.value;
      }
    }
    function normalizeDef3(def) {
      const keys2 = Object.keys(def.shape);
      for (const k of keys2) {
        if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
          throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
        }
      }
      const okeys = util4.optionalKeys(def.shape);
      return {
        ...def,
        keys: keys2,
        keySet: new Set(keys2),
        numKeys: keys2.length,
        optionalKeys: new Set(okeys)
      };
    }
    function handleCatchall3(proms, input, payload, ctx, def, inst) {
      const unrecognized = [];
      const keySet = def.keySet;
      const _catchall = def.catchall._zod;
      const t = _catchall.def.type;
      const isOptionalOut = _catchall.optout === "optional";
      for (const key in input) {
        if (keySet.has(key))
          continue;
        if (t === "never") {
          unrecognized.push(key);
          continue;
        }
        const r = _catchall.run({ value: input[key], issues: [] }, ctx);
        if (r instanceof Promise) {
          proms.push(r.then((r2) => handlePropertyResult3(r2, payload, key, input, isOptionalOut)));
        } else {
          handlePropertyResult3(r, payload, key, input, isOptionalOut);
        }
      }
      if (unrecognized.length) {
        payload.issues.push({
          code: "unrecognized_keys",
          keys: unrecognized,
          input,
          inst
        });
      }
      if (!proms.length)
        return payload;
      return Promise.all(proms).then(() => {
        return payload;
      });
    }
    exports2.$ZodObject = core.$constructor("$ZodObject", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      const desc = Object.getOwnPropertyDescriptor(def, "shape");
      if (!desc?.get) {
        const sh = def.shape;
        Object.defineProperty(def, "shape", {
          get: () => {
            const newSh = { ...sh };
            Object.defineProperty(def, "shape", {
              value: newSh
            });
            return newSh;
          }
        });
      }
      const _normalized = util4.cached(() => normalizeDef3(def));
      util4.defineLazy(inst._zod, "propValues", () => {
        const shape = def.shape;
        const propValues = {};
        for (const key in shape) {
          const field = shape[key]._zod;
          if (field.values) {
            propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
            for (const v of field.values)
              propValues[key].add(v);
          }
        }
        return propValues;
      });
      const isObject5 = util4.isObject;
      const catchall = def.catchall;
      let value;
      inst._zod.parse = (payload, ctx) => {
        value ?? (value = _normalized.value);
        const input = payload.value;
        if (!isObject5(input)) {
          payload.issues.push({
            expected: "object",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        payload.value = {};
        const proms = [];
        const shape = value.shape;
        for (const key of value.keys) {
          const el = shape[key];
          const isOptionalOut = el._zod.optout === "optional";
          const r = el._zod.run({ value: input[key], issues: [] }, ctx);
          if (r instanceof Promise) {
            proms.push(r.then((r2) => handlePropertyResult3(r2, payload, key, input, isOptionalOut)));
          } else {
            handlePropertyResult3(r, payload, key, input, isOptionalOut);
          }
        }
        if (!catchall) {
          return proms.length ? Promise.all(proms).then(() => payload) : payload;
        }
        return handleCatchall3(proms, input, payload, ctx, _normalized.value, inst);
      };
    });
    exports2.$ZodObjectJIT = core.$constructor("$ZodObjectJIT", (inst, def) => {
      exports2.$ZodObject.init(inst, def);
      const superParse = inst._zod.parse;
      const _normalized = util4.cached(() => normalizeDef3(def));
      const generateFastpass = (shape) => {
        const doc = new doc_js_1.Doc(["shape", "payload", "ctx"]);
        const normalized = _normalized.value;
        const parseStr = (key) => {
          const k = util4.esc(key);
          return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
        };
        doc.write(`const input = payload.value;`);
        const ids = /* @__PURE__ */ Object.create(null);
        let counter = 0;
        for (const key of normalized.keys) {
          ids[key] = `key_${counter++}`;
        }
        doc.write(`const newResult = {};`);
        for (const key of normalized.keys) {
          const id = ids[key];
          const k = util4.esc(key);
          const schema = shape[key];
          const isOptionalOut = schema?._zod?.optout === "optional";
          doc.write(`const ${id} = ${parseStr(key)};`);
          if (isOptionalOut) {
            doc.write(`
        if (${id}.issues.length) {
          if (${k} in input) {
            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
              ...iss,
              path: iss.path ? [${k}, ...iss.path] : [${k}]
            })));
          }
        }
        
        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }
        
      `);
          } else {
            doc.write(`
        if (${id}.issues.length) {
          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
            ...iss,
            path: iss.path ? [${k}, ...iss.path] : [${k}]
          })));
        }
        
        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }
        
      `);
          }
        }
        doc.write(`payload.value = newResult;`);
        doc.write(`return payload;`);
        const fn = doc.compile();
        return (payload, ctx) => fn(shape, payload, ctx);
      };
      let fastpass;
      const isObject5 = util4.isObject;
      const jit = !core.globalConfig.jitless;
      const allowsEval3 = util4.allowsEval;
      const fastEnabled = jit && allowsEval3.value;
      const catchall = def.catchall;
      let value;
      inst._zod.parse = (payload, ctx) => {
        value ?? (value = _normalized.value);
        const input = payload.value;
        if (!isObject5(input)) {
          payload.issues.push({
            expected: "object",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
          if (!fastpass)
            fastpass = generateFastpass(def.shape);
          payload = fastpass(payload, ctx);
          if (!catchall)
            return payload;
          return handleCatchall3([], input, payload, ctx, value, inst);
        }
        return superParse(payload, ctx);
      };
    });
    function handleUnionResults3(results, final, inst, ctx) {
      for (const result of results) {
        if (result.issues.length === 0) {
          final.value = result.value;
          return final;
        }
      }
      const nonaborted = results.filter((r) => !util4.aborted(r));
      if (nonaborted.length === 1) {
        final.value = nonaborted[0].value;
        return nonaborted[0];
      }
      final.issues.push({
        code: "invalid_union",
        input: final.value,
        inst,
        errors: results.map((result) => result.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config())))
      });
      return final;
    }
    exports2.$ZodUnion = core.$constructor("$ZodUnion", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      util4.defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
      util4.defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
      util4.defineLazy(inst._zod, "values", () => {
        if (def.options.every((o) => o._zod.values)) {
          return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
        }
        return void 0;
      });
      util4.defineLazy(inst._zod, "pattern", () => {
        if (def.options.every((o) => o._zod.pattern)) {
          const patterns = def.options.map((o) => o._zod.pattern);
          return new RegExp(`^(${patterns.map((p3) => util4.cleanRegex(p3.source)).join("|")})$`);
        }
        return void 0;
      });
      const single = def.options.length === 1;
      const first = def.options[0]._zod.run;
      inst._zod.parse = (payload, ctx) => {
        if (single) {
          return first(payload, ctx);
        }
        let async = false;
        const results = [];
        for (const option of def.options) {
          const result = option._zod.run({
            value: payload.value,
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            results.push(result);
            async = true;
          } else {
            if (result.issues.length === 0)
              return result;
            results.push(result);
          }
        }
        if (!async)
          return handleUnionResults3(results, payload, inst, ctx);
        return Promise.all(results).then((results2) => {
          return handleUnionResults3(results2, payload, inst, ctx);
        });
      };
    });
    function handleExclusiveUnionResults3(results, final, inst, ctx) {
      const successes = results.filter((r) => r.issues.length === 0);
      if (successes.length === 1) {
        final.value = successes[0].value;
        return final;
      }
      if (successes.length === 0) {
        final.issues.push({
          code: "invalid_union",
          input: final.value,
          inst,
          errors: results.map((result) => result.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config())))
        });
      } else {
        final.issues.push({
          code: "invalid_union",
          input: final.value,
          inst,
          errors: [],
          inclusive: false
        });
      }
      return final;
    }
    exports2.$ZodXor = core.$constructor("$ZodXor", (inst, def) => {
      exports2.$ZodUnion.init(inst, def);
      def.inclusive = false;
      const single = def.options.length === 1;
      const first = def.options[0]._zod.run;
      inst._zod.parse = (payload, ctx) => {
        if (single) {
          return first(payload, ctx);
        }
        let async = false;
        const results = [];
        for (const option of def.options) {
          const result = option._zod.run({
            value: payload.value,
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            results.push(result);
            async = true;
          } else {
            results.push(result);
          }
        }
        if (!async)
          return handleExclusiveUnionResults3(results, payload, inst, ctx);
        return Promise.all(results).then((results2) => {
          return handleExclusiveUnionResults3(results2, payload, inst, ctx);
        });
      };
    });
    exports2.$ZodDiscriminatedUnion = /* @__PURE__ */ core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
      def.inclusive = false;
      exports2.$ZodUnion.init(inst, def);
      const _super = inst._zod.parse;
      util4.defineLazy(inst._zod, "propValues", () => {
        const propValues = {};
        for (const option of def.options) {
          const pv = option._zod.propValues;
          if (!pv || Object.keys(pv).length === 0)
            throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
          for (const [k, v] of Object.entries(pv)) {
            if (!propValues[k])
              propValues[k] = /* @__PURE__ */ new Set();
            for (const val of v) {
              propValues[k].add(val);
            }
          }
        }
        return propValues;
      });
      const disc = util4.cached(() => {
        const opts = def.options;
        const map3 = /* @__PURE__ */ new Map();
        for (const o of opts) {
          const values = o._zod.propValues?.[def.discriminator];
          if (!values || values.size === 0)
            throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
          for (const v of values) {
            if (map3.has(v)) {
              throw new Error(`Duplicate discriminator value "${String(v)}"`);
            }
            map3.set(v, o);
          }
        }
        return map3;
      });
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!util4.isObject(input)) {
          payload.issues.push({
            code: "invalid_type",
            expected: "object",
            input,
            inst
          });
          return payload;
        }
        const opt = disc.value.get(input?.[def.discriminator]);
        if (opt) {
          return opt._zod.run(payload, ctx);
        }
        if (def.unionFallback) {
          return _super(payload, ctx);
        }
        payload.issues.push({
          code: "invalid_union",
          errors: [],
          note: "No matching discriminator",
          discriminator: def.discriminator,
          input,
          path: [def.discriminator],
          inst
        });
        return payload;
      };
    });
    exports2.$ZodIntersection = core.$constructor("$ZodIntersection", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        const left = def.left._zod.run({ value: input, issues: [] }, ctx);
        const right = def.right._zod.run({ value: input, issues: [] }, ctx);
        const async = left instanceof Promise || right instanceof Promise;
        if (async) {
          return Promise.all([left, right]).then(([left2, right2]) => {
            return handleIntersectionResults3(payload, left2, right2);
          });
        }
        return handleIntersectionResults3(payload, left, right);
      };
    });
    function mergeValues4(a, b) {
      if (a === b) {
        return { valid: true, data: a };
      }
      if (a instanceof Date && b instanceof Date && +a === +b) {
        return { valid: true, data: a };
      }
      if (util4.isPlainObject(a) && util4.isPlainObject(b)) {
        const bKeys = Object.keys(b);
        const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
        const newObj = { ...a, ...b };
        for (const key of sharedKeys) {
          const sharedValue = mergeValues4(a[key], b[key]);
          if (!sharedValue.valid) {
            return {
              valid: false,
              mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
            };
          }
          newObj[key] = sharedValue.data;
        }
        return { valid: true, data: newObj };
      }
      if (Array.isArray(a) && Array.isArray(b)) {
        if (a.length !== b.length) {
          return { valid: false, mergeErrorPath: [] };
        }
        const newArray = [];
        for (let index = 0; index < a.length; index++) {
          const itemA = a[index];
          const itemB = b[index];
          const sharedValue = mergeValues4(itemA, itemB);
          if (!sharedValue.valid) {
            return {
              valid: false,
              mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
            };
          }
          newArray.push(sharedValue.data);
        }
        return { valid: true, data: newArray };
      }
      return { valid: false, mergeErrorPath: [] };
    }
    function handleIntersectionResults3(result, left, right) {
      const unrecKeys = /* @__PURE__ */ new Map();
      let unrecIssue;
      for (const iss of left.issues) {
        if (iss.code === "unrecognized_keys") {
          unrecIssue ?? (unrecIssue = iss);
          for (const k of iss.keys) {
            if (!unrecKeys.has(k))
              unrecKeys.set(k, {});
            unrecKeys.get(k).l = true;
          }
        } else {
          result.issues.push(iss);
        }
      }
      for (const iss of right.issues) {
        if (iss.code === "unrecognized_keys") {
          for (const k of iss.keys) {
            if (!unrecKeys.has(k))
              unrecKeys.set(k, {});
            unrecKeys.get(k).r = true;
          }
        } else {
          result.issues.push(iss);
        }
      }
      const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
      if (bothKeys.length && unrecIssue) {
        result.issues.push({ ...unrecIssue, keys: bothKeys });
      }
      if (util4.aborted(result))
        return result;
      const merged = mergeValues4(left.value, right.value);
      if (!merged.valid) {
        throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
      }
      result.value = merged.data;
      return result;
    }
    exports2.$ZodTuple = core.$constructor("$ZodTuple", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      const items = def.items;
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!Array.isArray(input)) {
          payload.issues.push({
            input,
            inst,
            expected: "tuple",
            code: "invalid_type"
          });
          return payload;
        }
        payload.value = [];
        const proms = [];
        const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
        const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
        if (!def.rest) {
          const tooBig = input.length > items.length;
          const tooSmall = input.length < optStart - 1;
          if (tooBig || tooSmall) {
            payload.issues.push({
              ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
              input,
              inst,
              origin: "array"
            });
            return payload;
          }
        }
        let i = -1;
        for (const item of items) {
          i++;
          if (i >= input.length) {
            if (i >= optStart)
              continue;
          }
          const result = item._zod.run({
            value: input[i],
            issues: []
          }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => handleTupleResult3(result2, payload, i)));
          } else {
            handleTupleResult3(result, payload, i);
          }
        }
        if (def.rest) {
          const rest = input.slice(items.length);
          for (const el of rest) {
            i++;
            const result = def.rest._zod.run({
              value: el,
              issues: []
            }, ctx);
            if (result instanceof Promise) {
              proms.push(result.then((result2) => handleTupleResult3(result2, payload, i)));
            } else {
              handleTupleResult3(result, payload, i);
            }
          }
        }
        if (proms.length)
          return Promise.all(proms).then(() => payload);
        return payload;
      };
    });
    function handleTupleResult3(result, final, index) {
      if (result.issues.length) {
        final.issues.push(...util4.prefixIssues(index, result.issues));
      }
      final.value[index] = result.value;
    }
    exports2.$ZodRecord = core.$constructor("$ZodRecord", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!util4.isPlainObject(input)) {
          payload.issues.push({
            expected: "record",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        const proms = [];
        const values = def.keyType._zod.values;
        if (values) {
          payload.value = {};
          const recordKeys = /* @__PURE__ */ new Set();
          for (const key of values) {
            if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
              recordKeys.add(typeof key === "number" ? key.toString() : key);
              const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
              if (result instanceof Promise) {
                proms.push(result.then((result2) => {
                  if (result2.issues.length) {
                    payload.issues.push(...util4.prefixIssues(key, result2.issues));
                  }
                  payload.value[key] = result2.value;
                }));
              } else {
                if (result.issues.length) {
                  payload.issues.push(...util4.prefixIssues(key, result.issues));
                }
                payload.value[key] = result.value;
              }
            }
          }
          let unrecognized;
          for (const key in input) {
            if (!recordKeys.has(key)) {
              unrecognized = unrecognized ?? [];
              unrecognized.push(key);
            }
          }
          if (unrecognized && unrecognized.length > 0) {
            payload.issues.push({
              code: "unrecognized_keys",
              input,
              inst,
              keys: unrecognized
            });
          }
        } else {
          payload.value = {};
          for (const key of Reflect.ownKeys(input)) {
            if (key === "__proto__")
              continue;
            let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
            if (keyResult instanceof Promise) {
              throw new Error("Async schemas not supported in object keys currently");
            }
            const checkNumericKey = typeof key === "string" && regexes.number.test(key) && keyResult.issues.length;
            if (checkNumericKey) {
              const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
              if (retryResult instanceof Promise) {
                throw new Error("Async schemas not supported in object keys currently");
              }
              if (retryResult.issues.length === 0) {
                keyResult = retryResult;
              }
            }
            if (keyResult.issues.length) {
              if (def.mode === "loose") {
                payload.value[key] = input[key];
              } else {
                payload.issues.push({
                  code: "invalid_key",
                  origin: "record",
                  issues: keyResult.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config())),
                  input: key,
                  path: [key],
                  inst
                });
              }
              continue;
            }
            const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
            if (result instanceof Promise) {
              proms.push(result.then((result2) => {
                if (result2.issues.length) {
                  payload.issues.push(...util4.prefixIssues(key, result2.issues));
                }
                payload.value[keyResult.value] = result2.value;
              }));
            } else {
              if (result.issues.length) {
                payload.issues.push(...util4.prefixIssues(key, result.issues));
              }
              payload.value[keyResult.value] = result.value;
            }
          }
        }
        if (proms.length) {
          return Promise.all(proms).then(() => payload);
        }
        return payload;
      };
    });
    exports2.$ZodMap = core.$constructor("$ZodMap", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!(input instanceof Map)) {
          payload.issues.push({
            expected: "map",
            code: "invalid_type",
            input,
            inst
          });
          return payload;
        }
        const proms = [];
        payload.value = /* @__PURE__ */ new Map();
        for (const [key, value] of input) {
          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
          const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
          if (keyResult instanceof Promise || valueResult instanceof Promise) {
            proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
              handleMapResult3(keyResult2, valueResult2, payload, key, input, inst, ctx);
            }));
          } else {
            handleMapResult3(keyResult, valueResult, payload, key, input, inst, ctx);
          }
        }
        if (proms.length)
          return Promise.all(proms).then(() => payload);
        return payload;
      };
    });
    function handleMapResult3(keyResult, valueResult, final, key, input, inst, ctx) {
      if (keyResult.issues.length) {
        if (util4.propertyKeyTypes.has(typeof key)) {
          final.issues.push(...util4.prefixIssues(key, keyResult.issues));
        } else {
          final.issues.push({
            code: "invalid_key",
            origin: "map",
            input,
            inst,
            issues: keyResult.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config()))
          });
        }
      }
      if (valueResult.issues.length) {
        if (util4.propertyKeyTypes.has(typeof key)) {
          final.issues.push(...util4.prefixIssues(key, valueResult.issues));
        } else {
          final.issues.push({
            origin: "map",
            code: "invalid_element",
            input,
            inst,
            key,
            issues: valueResult.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config()))
          });
        }
      }
      final.value.set(keyResult.value, valueResult.value);
    }
    exports2.$ZodSet = core.$constructor("$ZodSet", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        const input = payload.value;
        if (!(input instanceof Set)) {
          payload.issues.push({
            input,
            inst,
            expected: "set",
            code: "invalid_type"
          });
          return payload;
        }
        const proms = [];
        payload.value = /* @__PURE__ */ new Set();
        for (const item of input) {
          const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => handleSetResult3(result2, payload)));
          } else
            handleSetResult3(result, payload);
        }
        if (proms.length)
          return Promise.all(proms).then(() => payload);
        return payload;
      };
    });
    function handleSetResult3(result, final) {
      if (result.issues.length) {
        final.issues.push(...result.issues);
      }
      final.value.add(result.value);
    }
    exports2.$ZodEnum = core.$constructor("$ZodEnum", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      const values = util4.getEnumValues(def.entries);
      const valuesSet = new Set(values);
      inst._zod.values = valuesSet;
      inst._zod.pattern = new RegExp(`^(${values.filter((k) => util4.propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? util4.escapeRegex(o) : o.toString()).join("|")})$`);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (valuesSet.has(input)) {
          return payload;
        }
        payload.issues.push({
          code: "invalid_value",
          values,
          input,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodLiteral = core.$constructor("$ZodLiteral", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      if (def.values.length === 0) {
        throw new Error("Cannot create literal schema with no valid values");
      }
      const values = new Set(def.values);
      inst._zod.values = values;
      inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? util4.escapeRegex(o) : o ? util4.escapeRegex(o.toString()) : String(o)).join("|")})$`);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (values.has(input)) {
          return payload;
        }
        payload.issues.push({
          code: "invalid_value",
          values: def.values,
          input,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodFile = core.$constructor("$ZodFile", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        const input = payload.value;
        if (input instanceof File)
          return payload;
        payload.issues.push({
          expected: "file",
          code: "invalid_type",
          input,
          inst
        });
        return payload;
      };
    });
    exports2.$ZodTransform = core.$constructor("$ZodTransform", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          throw new core.$ZodEncodeError(inst.constructor.name);
        }
        const _out = def.transform(payload.value, payload);
        if (ctx.async) {
          const output = _out instanceof Promise ? _out : Promise.resolve(_out);
          return output.then((output2) => {
            payload.value = output2;
            return payload;
          });
        }
        if (_out instanceof Promise) {
          throw new core.$ZodAsyncError();
        }
        payload.value = _out;
        return payload;
      };
    });
    function handleOptionalResult3(result, input) {
      if (result.issues.length && input === void 0) {
        return { issues: [], value: void 0 };
      }
      return result;
    }
    exports2.$ZodOptional = core.$constructor("$ZodOptional", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.optin = "optional";
      inst._zod.optout = "optional";
      util4.defineLazy(inst._zod, "values", () => {
        return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
      });
      util4.defineLazy(inst._zod, "pattern", () => {
        const pattern = def.innerType._zod.pattern;
        return pattern ? new RegExp(`^(${util4.cleanRegex(pattern.source)})?$`) : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        if (def.innerType._zod.optin === "optional") {
          const result = def.innerType._zod.run(payload, ctx);
          if (result instanceof Promise)
            return result.then((r) => handleOptionalResult3(r, payload.value));
          return handleOptionalResult3(result, payload.value);
        }
        if (payload.value === void 0) {
          return payload;
        }
        return def.innerType._zod.run(payload, ctx);
      };
    });
    exports2.$ZodExactOptional = core.$constructor("$ZodExactOptional", (inst, def) => {
      exports2.$ZodOptional.init(inst, def);
      util4.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      util4.defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
      inst._zod.parse = (payload, ctx) => {
        return def.innerType._zod.run(payload, ctx);
      };
    });
    exports2.$ZodNullable = core.$constructor("$ZodNullable", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      util4.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
      util4.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
      util4.defineLazy(inst._zod, "pattern", () => {
        const pattern = def.innerType._zod.pattern;
        return pattern ? new RegExp(`^(${util4.cleanRegex(pattern.source)}|null)$`) : void 0;
      });
      util4.defineLazy(inst._zod, "values", () => {
        return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        if (payload.value === null)
          return payload;
        return def.innerType._zod.run(payload, ctx);
      };
    });
    exports2.$ZodDefault = core.$constructor("$ZodDefault", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.optin = "optional";
      util4.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        if (payload.value === void 0) {
          payload.value = def.defaultValue;
          return payload;
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => handleDefaultResult3(result2, def));
        }
        return handleDefaultResult3(result, def);
      };
    });
    function handleDefaultResult3(payload, def) {
      if (payload.value === void 0) {
        payload.value = def.defaultValue;
      }
      return payload;
    }
    exports2.$ZodPrefault = core.$constructor("$ZodPrefault", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.optin = "optional";
      util4.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        if (payload.value === void 0) {
          payload.value = def.defaultValue;
        }
        return def.innerType._zod.run(payload, ctx);
      };
    });
    exports2.$ZodNonOptional = core.$constructor("$ZodNonOptional", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      util4.defineLazy(inst._zod, "values", () => {
        const v = def.innerType._zod.values;
        return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
      });
      inst._zod.parse = (payload, ctx) => {
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => handleNonOptionalResult3(result2, inst));
        }
        return handleNonOptionalResult3(result, inst);
      };
    });
    function handleNonOptionalResult3(payload, inst) {
      if (!payload.issues.length && payload.value === void 0) {
        payload.issues.push({
          code: "invalid_type",
          expected: "nonoptional",
          input: payload.value,
          inst
        });
      }
      return payload;
    }
    exports2.$ZodSuccess = core.$constructor("$ZodSuccess", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          throw new core.$ZodEncodeError("ZodSuccess");
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => {
            payload.value = result2.issues.length === 0;
            return payload;
          });
        }
        payload.value = result.issues.length === 0;
        return payload;
      };
    });
    exports2.$ZodCatch = core.$constructor("$ZodCatch", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      util4.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
      util4.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
      util4.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then((result2) => {
            payload.value = result2.value;
            if (result2.issues.length) {
              payload.value = def.catchValue({
                ...payload,
                error: {
                  issues: result2.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config()))
                },
                input: payload.value
              });
              payload.issues = [];
            }
            return payload;
          });
        }
        payload.value = result.value;
        if (result.issues.length) {
          payload.value = def.catchValue({
            ...payload,
            error: {
              issues: result.issues.map((iss) => util4.finalizeIssue(iss, ctx, core.config()))
            },
            input: payload.value
          });
          payload.issues = [];
        }
        return payload;
      };
    });
    exports2.$ZodNaN = core.$constructor("$ZodNaN", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, _ctx) => {
        if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
          payload.issues.push({
            input: payload.value,
            inst,
            expected: "nan",
            code: "invalid_type"
          });
          return payload;
        }
        return payload;
      };
    });
    exports2.$ZodPipe = core.$constructor("$ZodPipe", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      util4.defineLazy(inst._zod, "values", () => def.in._zod.values);
      util4.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
      util4.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
      util4.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          const right = def.out._zod.run(payload, ctx);
          if (right instanceof Promise) {
            return right.then((right2) => handlePipeResult3(right2, def.in, ctx));
          }
          return handlePipeResult3(right, def.in, ctx);
        }
        const left = def.in._zod.run(payload, ctx);
        if (left instanceof Promise) {
          return left.then((left2) => handlePipeResult3(left2, def.out, ctx));
        }
        return handlePipeResult3(left, def.out, ctx);
      };
    });
    function handlePipeResult3(left, next, ctx) {
      if (left.issues.length) {
        left.aborted = true;
        return left;
      }
      return next._zod.run({ value: left.value, issues: left.issues }, ctx);
    }
    exports2.$ZodCodec = core.$constructor("$ZodCodec", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      util4.defineLazy(inst._zod, "values", () => def.in._zod.values);
      util4.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
      util4.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
      util4.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
      inst._zod.parse = (payload, ctx) => {
        const direction = ctx.direction || "forward";
        if (direction === "forward") {
          const left = def.in._zod.run(payload, ctx);
          if (left instanceof Promise) {
            return left.then((left2) => handleCodecAResult3(left2, def, ctx));
          }
          return handleCodecAResult3(left, def, ctx);
        } else {
          const right = def.out._zod.run(payload, ctx);
          if (right instanceof Promise) {
            return right.then((right2) => handleCodecAResult3(right2, def, ctx));
          }
          return handleCodecAResult3(right, def, ctx);
        }
      };
    });
    function handleCodecAResult3(result, def, ctx) {
      if (result.issues.length) {
        result.aborted = true;
        return result;
      }
      const direction = ctx.direction || "forward";
      if (direction === "forward") {
        const transformed = def.transform(result.value, result);
        if (transformed instanceof Promise) {
          return transformed.then((value) => handleCodecTxResult3(result, value, def.out, ctx));
        }
        return handleCodecTxResult3(result, transformed, def.out, ctx);
      } else {
        const transformed = def.reverseTransform(result.value, result);
        if (transformed instanceof Promise) {
          return transformed.then((value) => handleCodecTxResult3(result, value, def.in, ctx));
        }
        return handleCodecTxResult3(result, transformed, def.in, ctx);
      }
    }
    function handleCodecTxResult3(left, value, nextSchema, ctx) {
      if (left.issues.length) {
        left.aborted = true;
        return left;
      }
      return nextSchema._zod.run({ value, issues: left.issues }, ctx);
    }
    exports2.$ZodReadonly = core.$constructor("$ZodReadonly", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      util4.defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
      util4.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
      util4.defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
      util4.defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
      inst._zod.parse = (payload, ctx) => {
        if (ctx.direction === "backward") {
          return def.innerType._zod.run(payload, ctx);
        }
        const result = def.innerType._zod.run(payload, ctx);
        if (result instanceof Promise) {
          return result.then(handleReadonlyResult3);
        }
        return handleReadonlyResult3(result);
      };
    });
    function handleReadonlyResult3(payload) {
      payload.value = Object.freeze(payload.value);
      return payload;
    }
    exports2.$ZodTemplateLiteral = core.$constructor("$ZodTemplateLiteral", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      const regexParts = [];
      for (const part of def.parts) {
        if (typeof part === "object" && part !== null) {
          if (!part._zod.pattern) {
            throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
          }
          const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
          if (!source)
            throw new Error(`Invalid template literal part: ${part._zod.traits}`);
          const start = source.startsWith("^") ? 1 : 0;
          const end = source.endsWith("$") ? source.length - 1 : source.length;
          regexParts.push(source.slice(start, end));
        } else if (part === null || util4.primitiveTypes.has(typeof part)) {
          regexParts.push(util4.escapeRegex(`${part}`));
        } else {
          throw new Error(`Invalid template literal part: ${part}`);
        }
      }
      inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
      inst._zod.parse = (payload, _ctx) => {
        if (typeof payload.value !== "string") {
          payload.issues.push({
            input: payload.value,
            inst,
            expected: "string",
            code: "invalid_type"
          });
          return payload;
        }
        inst._zod.pattern.lastIndex = 0;
        if (!inst._zod.pattern.test(payload.value)) {
          payload.issues.push({
            input: payload.value,
            inst,
            code: "invalid_format",
            format: def.format ?? "template_literal",
            pattern: inst._zod.pattern.source
          });
          return payload;
        }
        return payload;
      };
    });
    exports2.$ZodFunction = core.$constructor("$ZodFunction", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._def = def;
      inst._zod.def = def;
      inst.implement = (func) => {
        if (typeof func !== "function") {
          throw new Error("implement() must be called with a function");
        }
        return function(...args) {
          const parsedArgs = inst._def.input ? (0, parse_js_1.parse)(inst._def.input, args) : args;
          const result = Reflect.apply(func, this, parsedArgs);
          if (inst._def.output) {
            return (0, parse_js_1.parse)(inst._def.output, result);
          }
          return result;
        };
      };
      inst.implementAsync = (func) => {
        if (typeof func !== "function") {
          throw new Error("implementAsync() must be called with a function");
        }
        return async function(...args) {
          const parsedArgs = inst._def.input ? await (0, parse_js_1.parseAsync)(inst._def.input, args) : args;
          const result = await Reflect.apply(func, this, parsedArgs);
          if (inst._def.output) {
            return await (0, parse_js_1.parseAsync)(inst._def.output, result);
          }
          return result;
        };
      };
      inst._zod.parse = (payload, _ctx) => {
        if (typeof payload.value !== "function") {
          payload.issues.push({
            code: "invalid_type",
            expected: "function",
            input: payload.value,
            inst
          });
          return payload;
        }
        const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise";
        if (hasPromiseOutput) {
          payload.value = inst.implementAsync(payload.value);
        } else {
          payload.value = inst.implement(payload.value);
        }
        return payload;
      };
      inst.input = (...args) => {
        const F = inst.constructor;
        if (Array.isArray(args[0])) {
          return new F({
            type: "function",
            input: new exports2.$ZodTuple({
              type: "tuple",
              items: args[0],
              rest: args[1]
            }),
            output: inst._def.output
          });
        }
        return new F({
          type: "function",
          input: args[0],
          output: inst._def.output
        });
      };
      inst.output = (output) => {
        const F = inst.constructor;
        return new F({
          type: "function",
          input: inst._def.input,
          output
        });
      };
      return inst;
    });
    exports2.$ZodPromise = core.$constructor("$ZodPromise", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, ctx) => {
        return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
      };
    });
    exports2.$ZodLazy = core.$constructor("$ZodLazy", (inst, def) => {
      exports2.$ZodType.init(inst, def);
      util4.defineLazy(inst._zod, "innerType", () => def.getter());
      util4.defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
      util4.defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
      util4.defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
      util4.defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? void 0);
      inst._zod.parse = (payload, ctx) => {
        const inner = inst._zod.innerType;
        return inner._zod.run(payload, ctx);
      };
    });
    exports2.$ZodCustom = core.$constructor("$ZodCustom", (inst, def) => {
      checks.$ZodCheck.init(inst, def);
      exports2.$ZodType.init(inst, def);
      inst._zod.parse = (payload, _) => {
        return payload;
      };
      inst._zod.check = (payload) => {
        const input = payload.value;
        const r = def.fn(input);
        if (r instanceof Promise) {
          return r.then((r2) => handleRefineResult3(r2, payload, input, inst));
        }
        handleRefineResult3(r, payload, input, inst);
        return;
      };
    });
    function handleRefineResult3(result, payload, input, inst) {
      if (!result) {
        const _iss = {
          code: "custom",
          input,
          inst,
          // incorporates params.error into issue reporting
          path: [...inst._zod.def.path ?? []],
          // incorporates params.error into issue reporting
          continue: !inst._zod.def.abort
          // params: inst._zod.def.params,
        };
        if (inst._zod.def.params)
          _iss.params = inst._zod.def.params;
        payload.issues.push(util4.issue(_iss));
      }
    }
  }
});

// node_modules/zod/v4/locales/ar.cjs
var require_ar = __commonJS({
  "node_modules/zod/v4/locales/ar.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
        file: { unit: "\u0628\u0627\u064A\u062A", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
        array: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
        set: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0645\u062F\u062E\u0644",
        email: "\u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A",
        url: "\u0631\u0627\u0628\u0637",
        emoji: "\u0625\u064A\u0645\u0648\u062C\u064A",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u062A\u0627\u0631\u064A\u062E \u0648\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        date: "\u062A\u0627\u0631\u064A\u062E \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        time: "\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        duration: "\u0645\u062F\u0629 \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
        ipv4: "\u0639\u0646\u0648\u0627\u0646 IPv4",
        ipv6: "\u0639\u0646\u0648\u0627\u0646 IPv6",
        cidrv4: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv4",
        cidrv6: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv6",
        base64: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64-encoded",
        base64url: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64url-encoded",
        json_string: "\u0646\u064E\u0635 \u0639\u0644\u0649 \u0647\u064A\u0626\u0629 JSON",
        e164: "\u0631\u0642\u0645 \u0647\u0627\u062A\u0641 \u0628\u0645\u0639\u064A\u0627\u0631 E.164",
        jwt: "JWT",
        template_literal: "\u0645\u062F\u062E\u0644"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 instanceof ${issue3.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
            }
            return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u0627\u062E\u062A\u064A\u0627\u0631 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062A\u0648\u0642\u0639 \u0627\u0646\u062A\u0642\u0627\u0621 \u0623\u062D\u062F \u0647\u0630\u0647 \u0627\u0644\u062E\u064A\u0627\u0631\u0627\u062A: ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return ` \u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue3.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"}`;
            return `\u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue3.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue3.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue3.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0628\u062F\u0623 \u0628\u0640 "${issue3.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0646\u062A\u0647\u064A \u0628\u0640 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u062A\u0636\u0645\u0651\u064E\u0646 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0637\u0627\u0628\u0642 \u0627\u0644\u0646\u0645\u0637 ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`;
          }
          case "not_multiple_of":
            return `\u0631\u0642\u0645 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0645\u0646 \u0645\u0636\u0627\u0639\u0641\u0627\u062A ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u0645\u0639\u0631\u0641${issue3.keys.length > 1 ? "\u0627\u062A" : ""} \u063A\u0631\u064A\u0628${issue3.keys.length > 1 ? "\u0629" : ""}: ${util4.joinValues(issue3.keys, "\u060C ")}`;
          case "invalid_key":
            return `\u0645\u0639\u0631\u0641 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue3.origin}`;
          case "invalid_union":
            return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
          case "invalid_element":
            return `\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue3.origin}`;
          default:
            return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/az.cjs
var require_az = __commonJS({
  "node_modules/zod/v4/locales/az.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "simvol", verb: "olmal\u0131d\u0131r" },
        file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
        array: { unit: "element", verb: "olmal\u0131d\u0131r" },
        set: { unit: "element", verb: "olmal\u0131d\u0131r" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "email address",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datetime",
        date: "ISO date",
        time: "ISO time",
        duration: "ISO duration",
        ipv4: "IPv4 address",
        ipv6: "IPv6 address",
        cidrv4: "IPv4 range",
        cidrv6: "IPv6 range",
        base64: "base64-encoded string",
        base64url: "base64url-encoded string",
        json_string: "JSON string",
        e164: "E.164 number",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n instanceof ${issue3.expected}, daxil olan ${received}`;
            }
            return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${expected}, daxil olan ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Yanl\u0131\u015F se\xE7im: a\u015Fa\u011F\u0131dak\u0131lardan biri olmal\u0131d\u0131r: ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue3.origin ?? "d\u0259y\u0259r"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "element"}`;
            return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue3.origin ?? "d\u0259y\u0259r"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Yanl\u0131\u015F m\u0259tn: "${_issue.prefix}" il\u0259 ba\u015Flamal\u0131d\u0131r`;
            if (_issue.format === "ends_with")
              return `Yanl\u0131\u015F m\u0259tn: "${_issue.suffix}" il\u0259 bitm\u0259lidir`;
            if (_issue.format === "includes")
              return `Yanl\u0131\u015F m\u0259tn: "${_issue.includes}" daxil olmal\u0131d\u0131r`;
            if (_issue.format === "regex")
              return `Yanl\u0131\u015F m\u0259tn: ${_issue.pattern} \u015Fablonuna uy\u011Fun olmal\u0131d\u0131r`;
            return `Yanl\u0131\u015F ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Yanl\u0131\u015F \u0259d\u0259d: ${issue3.divisor} il\u0259 b\xF6l\xFCn\u0259 bil\u0259n olmal\u0131d\u0131r`;
          case "unrecognized_keys":
            return `Tan\u0131nmayan a\xE7ar${issue3.keys.length > 1 ? "lar" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} daxilind\u0259 yanl\u0131\u015F a\xE7ar`;
          case "invalid_union":
            return "Yanl\u0131\u015F d\u0259y\u0259r";
          case "invalid_element":
            return `${issue3.origin} daxilind\u0259 yanl\u0131\u015F d\u0259y\u0259r`;
          default:
            return `Yanl\u0131\u015F d\u0259y\u0259r`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/be.cjs
var require_be = __commonJS({
  "node_modules/zod/v4/locales/be.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    function getBelarusianPlural3(count, one, few, many) {
      const absCount = Math.abs(count);
      const lastDigit = absCount % 10;
      const lastTwoDigits = absCount % 100;
      if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
        return many;
      }
      if (lastDigit === 1) {
        return one;
      }
      if (lastDigit >= 2 && lastDigit <= 4) {
        return few;
      }
      return many;
    }
    var error73 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "\u0441\u0456\u043C\u0432\u0430\u043B",
            few: "\u0441\u0456\u043C\u0432\u0430\u043B\u044B",
            many: "\u0441\u0456\u043C\u0432\u0430\u043B\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        },
        array: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        },
        set: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        },
        file: {
          unit: {
            one: "\u0431\u0430\u0439\u0442",
            few: "\u0431\u0430\u0439\u0442\u044B",
            many: "\u0431\u0430\u0439\u0442\u0430\u045E"
          },
          verb: "\u043C\u0435\u0446\u044C"
        }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0443\u0432\u043E\u0434",
        email: "email \u0430\u0434\u0440\u0430\u0441",
        url: "URL",
        emoji: "\u044D\u043C\u043E\u0434\u0437\u0456",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0434\u0430\u0442\u0430 \u0456 \u0447\u0430\u0441",
        date: "ISO \u0434\u0430\u0442\u0430",
        time: "ISO \u0447\u0430\u0441",
        duration: "ISO \u043F\u0440\u0430\u0446\u044F\u0433\u043B\u0430\u0441\u0446\u044C",
        ipv4: "IPv4 \u0430\u0434\u0440\u0430\u0441",
        ipv6: "IPv6 \u0430\u0434\u0440\u0430\u0441",
        cidrv4: "IPv4 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
        cidrv6: "IPv6 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
        base64: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64",
        base64url: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64url",
        json_string: "JSON \u0440\u0430\u0434\u043E\u043A",
        e164: "\u043D\u0443\u043C\u0430\u0440 E.164",
        jwt: "JWT",
        template_literal: "\u0443\u0432\u043E\u0434"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u043B\u0456\u043A",
        array: "\u043C\u0430\u0441\u0456\u045E"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F instanceof ${issue3.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
            }
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0432\u0430\u0440\u044B\u044F\u043D\u0442: \u0447\u0430\u043A\u0430\u045E\u0441\u044F \u0430\u0434\u0437\u0456\u043D \u0437 ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const maxValue = Number(issue3.maximum);
              const unit = getBelarusianPlural3(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue3.maximum.toString()} ${unit}`;
            }
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const minValue = Number(issue3.minimum);
              const unit = getBelarusianPlural3(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue3.minimum.toString()} ${unit}`;
            }
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u043F\u0430\u0447\u044B\u043D\u0430\u0446\u0446\u0430 \u0437 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u0430\u043A\u0430\u043D\u0447\u0432\u0430\u0446\u0446\u0430 \u043D\u0430 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u043C\u044F\u0448\u0447\u0430\u0446\u044C "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0430\u0434\u043F\u0430\u0432\u044F\u0434\u0430\u0446\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043B\u0456\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0431\u044B\u0446\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u0430\u0441\u043F\u0430\u0437\u043D\u0430\u043D\u044B ${issue3.keys.length > 1 ? "\u043A\u043B\u044E\u0447\u044B" : "\u043A\u043B\u044E\u0447"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043A\u043B\u044E\u0447 \u0443 ${issue3.origin}`;
          case "invalid_union":
            return "\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434";
          case "invalid_element":
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u0430\u0435 \u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435 \u045E ${issue3.origin}`;
          default:
            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/bg.cjs
var require_bg = __commonJS({
  "node_modules/zod/v4/locales/bg.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
        file: { unit: "\u0431\u0430\u0439\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
        array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
        set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0432\u0445\u043E\u0434",
        email: "\u0438\u043C\u0435\u0439\u043B \u0430\u0434\u0440\u0435\u0441",
        url: "URL",
        emoji: "\u0435\u043C\u043E\u0434\u0436\u0438",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0432\u0440\u0435\u043C\u0435",
        date: "ISO \u0434\u0430\u0442\u0430",
        time: "ISO \u0432\u0440\u0435\u043C\u0435",
        duration: "ISO \u043F\u0440\u043E\u0434\u044A\u043B\u0436\u0438\u0442\u0435\u043B\u043D\u043E\u0441\u0442",
        ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
        ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
        cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        base64: "base64-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
        base64url: "base64url-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
        json_string: "JSON \u043D\u0438\u0437",
        e164: "E.164 \u043D\u043E\u043C\u0435\u0440",
        jwt: "JWT",
        template_literal: "\u0432\u0445\u043E\u0434"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0447\u0438\u0441\u043B\u043E",
        array: "\u043C\u0430\u0441\u0438\u0432"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D instanceof ${issue3.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
            }
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u043E\u043F\u0446\u0438\u044F: \u043E\u0447\u0430\u043A\u0432\u0430\u043D\u043E \u0435\u0434\u043D\u043E \u043E\u0442 ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue3.origin ?? "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430"}`;
            return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue3.origin ?? "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue3.origin} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue3.origin} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u0432\u0430 \u0441 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u0432\u044A\u0440\u0448\u0432\u0430 \u0441 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0432\u043A\u043B\u044E\u0447\u0432\u0430 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0441\u044A\u0432\u043F\u0430\u0434\u0430 \u0441 ${_issue.pattern}`;
            let invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D";
            if (_issue.format === "emoji")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
            if (_issue.format === "datetime")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
            if (_issue.format === "date")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
            if (_issue.format === "time")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
            if (_issue.format === "duration")
              invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
            return `${invalid_adj} ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E \u0447\u0438\u0441\u043B\u043E: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0431\u044A\u0434\u0435 \u043A\u0440\u0430\u0442\u043D\u043E \u043D\u0430 ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u0430\u0437\u043F\u043E\u0437\u043D\u0430\u0442${issue3.keys.length > 1 ? "\u0438" : ""} \u043A\u043B\u044E\u0447${issue3.keys.length > 1 ? "\u043E\u0432\u0435" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043A\u043B\u044E\u0447 \u0432 ${issue3.origin}`;
          case "invalid_union":
            return "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434";
          case "invalid_element":
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442 \u0432 ${issue3.origin}`;
          default:
            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ca.cjs
var require_ca = __commonJS({
  "node_modules/zod/v4/locales/ca.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "car\xE0cters", verb: "contenir" },
        file: { unit: "bytes", verb: "contenir" },
        array: { unit: "elements", verb: "contenir" },
        set: { unit: "elements", verb: "contenir" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "entrada",
        email: "adre\xE7a electr\xF2nica",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data i hora ISO",
        date: "data ISO",
        time: "hora ISO",
        duration: "durada ISO",
        ipv4: "adre\xE7a IPv4",
        ipv6: "adre\xE7a IPv6",
        cidrv4: "rang IPv4",
        cidrv6: "rang IPv6",
        base64: "cadena codificada en base64",
        base64url: "cadena codificada en base64url",
        json_string: "cadena JSON",
        e164: "n\xFAmero E.164",
        jwt: "JWT",
        template_literal: "entrada"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Tipus inv\xE0lid: s'esperava instanceof ${issue3.expected}, s'ha rebut ${received}`;
            }
            return `Tipus inv\xE0lid: s'esperava ${expected}, s'ha rebut ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Valor inv\xE0lid: s'esperava ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Opci\xF3 inv\xE0lida: s'esperava una de ${util4.joinValues(issue3.values, " o ")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "com a m\xE0xim" : "menys de";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Massa gran: s'esperava que ${issue3.origin ?? "el valor"} contingu\xE9s ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "elements"}`;
            return `Massa gran: s'esperava que ${issue3.origin ?? "el valor"} fos ${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "com a m\xEDnim" : "m\xE9s de";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Massa petit: s'esperava que ${issue3.origin} contingu\xE9s ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Massa petit: s'esperava que ${issue3.origin} fos ${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Format inv\xE0lid: ha de comen\xE7ar amb "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Format inv\xE0lid: ha d'acabar amb "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Format inv\xE0lid: ha d'incloure "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Format inv\xE0lid: ha de coincidir amb el patr\xF3 ${_issue.pattern}`;
            return `Format inv\xE0lid per a ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `N\xFAmero inv\xE0lid: ha de ser m\xFAltiple de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Clau${issue3.keys.length > 1 ? "s" : ""} no reconeguda${issue3.keys.length > 1 ? "s" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Clau inv\xE0lida a ${issue3.origin}`;
          case "invalid_union":
            return "Entrada inv\xE0lida";
          // Could also be "Tipus d'unió invàlid" but "Entrada invàlida" is more general
          case "invalid_element":
            return `Element inv\xE0lid a ${issue3.origin}`;
          default:
            return `Entrada inv\xE0lida`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/cs.cjs
var require_cs = __commonJS({
  "node_modules/zod/v4/locales/cs.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "znak\u016F", verb: "m\xEDt" },
        file: { unit: "bajt\u016F", verb: "m\xEDt" },
        array: { unit: "prvk\u016F", verb: "m\xEDt" },
        set: { unit: "prvk\u016F", verb: "m\xEDt" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "regul\xE1rn\xED v\xFDraz",
        email: "e-mailov\xE1 adresa",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "datum a \u010Das ve form\xE1tu ISO",
        date: "datum ve form\xE1tu ISO",
        time: "\u010Das ve form\xE1tu ISO",
        duration: "doba trv\xE1n\xED ISO",
        ipv4: "IPv4 adresa",
        ipv6: "IPv6 adresa",
        cidrv4: "rozsah IPv4",
        cidrv6: "rozsah IPv6",
        base64: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64",
        base64url: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64url",
        json_string: "\u0159et\u011Bzec ve form\xE1tu JSON",
        e164: "\u010D\xEDslo E.164",
        jwt: "JWT",
        template_literal: "vstup"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u010D\xEDslo",
        string: "\u0159et\u011Bzec",
        function: "funkce",
        array: "pole"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no instanceof ${issue3.expected}, obdr\u017Eeno ${received}`;
            }
            return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${expected}, obdr\u017Eeno ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Neplatn\xE1 mo\u017Enost: o\u010Dek\xE1v\xE1na jedna z hodnot ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue3.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
            }
            return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue3.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue3.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue3.minimum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
            }
            return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue3.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED za\u010D\xEDnat na "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED kon\u010Dit na "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED obsahovat "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Neplatn\xFD \u0159et\u011Bzec: mus\xED odpov\xEDdat vzoru ${_issue.pattern}`;
            return `Neplatn\xFD form\xE1t ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Neplatn\xE9 \u010D\xEDslo: mus\xED b\xFDt n\xE1sobkem ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Nezn\xE1m\xE9 kl\xED\u010De: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Neplatn\xFD kl\xED\u010D v ${issue3.origin}`;
          case "invalid_union":
            return "Neplatn\xFD vstup";
          case "invalid_element":
            return `Neplatn\xE1 hodnota v ${issue3.origin}`;
          default:
            return `Neplatn\xFD vstup`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/da.cjs
var require_da = __commonJS({
  "node_modules/zod/v4/locales/da.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "tegn", verb: "havde" },
        file: { unit: "bytes", verb: "havde" },
        array: { unit: "elementer", verb: "indeholdt" },
        set: { unit: "elementer", verb: "indeholdt" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "e-mailadresse",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO dato- og klokkesl\xE6t",
        date: "ISO-dato",
        time: "ISO-klokkesl\xE6t",
        duration: "ISO-varighed",
        ipv4: "IPv4-omr\xE5de",
        ipv6: "IPv6-omr\xE5de",
        cidrv4: "IPv4-spektrum",
        cidrv6: "IPv6-spektrum",
        base64: "base64-kodet streng",
        base64url: "base64url-kodet streng",
        json_string: "JSON-streng",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        string: "streng",
        number: "tal",
        boolean: "boolean",
        array: "liste",
        object: "objekt",
        set: "s\xE6t",
        file: "fil"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ugyldigt input: forventede instanceof ${issue3.expected}, fik ${received}`;
            }
            return `Ugyldigt input: forventede ${expected}, fik ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ugyldig v\xE6rdi: forventede ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Ugyldigt valg: forventede en af f\xF8lgende ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            if (sizing)
              return `For stor: forventede ${origin2 ?? "value"} ${sizing.verb} ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "elementer"}`;
            return `For stor: forventede ${origin2 ?? "value"} havde ${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            if (sizing) {
              return `For lille: forventede ${origin2} ${sizing.verb} ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `For lille: forventede ${origin2} havde ${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Ugyldig streng: skal starte med "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Ugyldig streng: skal ende med "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Ugyldig streng: skal indeholde "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Ugyldig streng: skal matche m\xF8nsteret ${_issue.pattern}`;
            return `Ugyldig ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ugyldigt tal: skal v\xE6re deleligt med ${issue3.divisor}`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Ukendte n\xF8gler" : "Ukendt n\xF8gle"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ugyldig n\xF8gle i ${issue3.origin}`;
          case "invalid_union":
            return "Ugyldigt input: matcher ingen af de tilladte typer";
          case "invalid_element":
            return `Ugyldig v\xE6rdi i ${issue3.origin}`;
          default:
            return `Ugyldigt input`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/de.cjs
var require_de = __commonJS({
  "node_modules/zod/v4/locales/de.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "Zeichen", verb: "zu haben" },
        file: { unit: "Bytes", verb: "zu haben" },
        array: { unit: "Elemente", verb: "zu haben" },
        set: { unit: "Elemente", verb: "zu haben" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "Eingabe",
        email: "E-Mail-Adresse",
        url: "URL",
        emoji: "Emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-Datum und -Uhrzeit",
        date: "ISO-Datum",
        time: "ISO-Uhrzeit",
        duration: "ISO-Dauer",
        ipv4: "IPv4-Adresse",
        ipv6: "IPv6-Adresse",
        cidrv4: "IPv4-Bereich",
        cidrv6: "IPv6-Bereich",
        base64: "Base64-codierter String",
        base64url: "Base64-URL-codierter String",
        json_string: "JSON-String",
        e164: "E.164-Nummer",
        jwt: "JWT",
        template_literal: "Eingabe"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "Zahl",
        array: "Array"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ung\xFCltige Eingabe: erwartet instanceof ${issue3.expected}, erhalten ${received}`;
            }
            return `Ung\xFCltige Eingabe: erwartet ${expected}, erhalten ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ung\xFCltige Eingabe: erwartet ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Ung\xFCltige Option: erwartet eine von ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Zu gro\xDF: erwartet, dass ${issue3.origin ?? "Wert"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "Elemente"} hat`;
            return `Zu gro\xDF: erwartet, dass ${issue3.origin ?? "Wert"} ${adj}${issue3.maximum.toString()} ist`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Zu klein: erwartet, dass ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} hat`;
            }
            return `Zu klein: erwartet, dass ${issue3.origin} ${adj}${issue3.minimum.toString()} ist`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Ung\xFCltiger String: muss mit "${_issue.prefix}" beginnen`;
            if (_issue.format === "ends_with")
              return `Ung\xFCltiger String: muss mit "${_issue.suffix}" enden`;
            if (_issue.format === "includes")
              return `Ung\xFCltiger String: muss "${_issue.includes}" enthalten`;
            if (_issue.format === "regex")
              return `Ung\xFCltiger String: muss dem Muster ${_issue.pattern} entsprechen`;
            return `Ung\xFCltig: ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ung\xFCltige Zahl: muss ein Vielfaches von ${issue3.divisor} sein`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Unbekannte Schl\xFCssel" : "Unbekannter Schl\xFCssel"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ung\xFCltiger Schl\xFCssel in ${issue3.origin}`;
          case "invalid_union":
            return "Ung\xFCltige Eingabe";
          case "invalid_element":
            return `Ung\xFCltiger Wert in ${issue3.origin}`;
          default:
            return `Ung\xFCltige Eingabe`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/en.cjs
var require_en = __commonJS({
  "node_modules/zod/v4/locales/en.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "characters", verb: "to have" },
        file: { unit: "bytes", verb: "to have" },
        array: { unit: "items", verb: "to have" },
        set: { unit: "items", verb: "to have" },
        map: { unit: "entries", verb: "to have" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "email address",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datetime",
        date: "ISO date",
        time: "ISO time",
        duration: "ISO duration",
        ipv4: "IPv4 address",
        ipv6: "IPv6 address",
        mac: "MAC address",
        cidrv4: "IPv4 range",
        cidrv6: "IPv6 range",
        base64: "base64-encoded string",
        base64url: "base64url-encoded string",
        json_string: "JSON string",
        e164: "E.164 number",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        // Compatibility: "nan" -> "NaN" for display
        nan: "NaN"
        // All other type names omitted - they fall back to raw values via ?? operator
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            return `Invalid input: expected ${expected}, received ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Invalid input: expected ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Invalid option: expected one of ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Too big: expected ${issue3.origin ?? "value"} to have ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elements"}`;
            return `Too big: expected ${issue3.origin ?? "value"} to be ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Too small: expected ${issue3.origin} to have ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Too small: expected ${issue3.origin} to be ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Invalid string: must start with "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Invalid string: must end with "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Invalid string: must include "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Invalid string: must match pattern ${_issue.pattern}`;
            return `Invalid ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Invalid number: must be a multiple of ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Unrecognized key${issue3.keys.length > 1 ? "s" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Invalid key in ${issue3.origin}`;
          case "invalid_union":
            return "Invalid input";
          case "invalid_element":
            return `Invalid value in ${issue3.origin}`;
          default:
            return `Invalid input`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/eo.cjs
var require_eo = __commonJS({
  "node_modules/zod/v4/locales/eo.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "karaktrojn", verb: "havi" },
        file: { unit: "bajtojn", verb: "havi" },
        array: { unit: "elementojn", verb: "havi" },
        set: { unit: "elementojn", verb: "havi" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "enigo",
        email: "retadreso",
        url: "URL",
        emoji: "emo\u011Dio",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-datotempo",
        date: "ISO-dato",
        time: "ISO-tempo",
        duration: "ISO-da\u016Dro",
        ipv4: "IPv4-adreso",
        ipv6: "IPv6-adreso",
        cidrv4: "IPv4-rango",
        cidrv6: "IPv6-rango",
        base64: "64-ume kodita karaktraro",
        base64url: "URL-64-ume kodita karaktraro",
        json_string: "JSON-karaktraro",
        e164: "E.164-nombro",
        jwt: "JWT",
        template_literal: "enigo"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "nombro",
        array: "tabelo",
        null: "senvalora"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Nevalida enigo: atendi\u011Dis instanceof ${issue3.expected}, ricevi\u011Dis ${received}`;
            }
            return `Nevalida enigo: atendi\u011Dis ${expected}, ricevi\u011Dis ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Nevalida enigo: atendi\u011Dis ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Nevalida opcio: atendi\u011Dis unu el ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Tro granda: atendi\u011Dis ke ${issue3.origin ?? "valoro"} havu ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementojn"}`;
            return `Tro granda: atendi\u011Dis ke ${issue3.origin ?? "valoro"} havu ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Tro malgranda: atendi\u011Dis ke ${issue3.origin} havu ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Tro malgranda: atendi\u011Dis ke ${issue3.origin} estu ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Nevalida karaktraro: devas komenci\u011Di per "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Nevalida karaktraro: devas fini\u011Di per "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Nevalida karaktraro: devas inkluzivi "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Nevalida karaktraro: devas kongrui kun la modelo ${_issue.pattern}`;
            return `Nevalida ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Nevalida nombro: devas esti oblo de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Nekonata${issue3.keys.length > 1 ? "j" : ""} \u015Dlosilo${issue3.keys.length > 1 ? "j" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Nevalida \u015Dlosilo en ${issue3.origin}`;
          case "invalid_union":
            return "Nevalida enigo";
          case "invalid_element":
            return `Nevalida valoro en ${issue3.origin}`;
          default:
            return `Nevalida enigo`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/es.cjs
var require_es = __commonJS({
  "node_modules/zod/v4/locales/es.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "caracteres", verb: "tener" },
        file: { unit: "bytes", verb: "tener" },
        array: { unit: "elementos", verb: "tener" },
        set: { unit: "elementos", verb: "tener" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "entrada",
        email: "direcci\xF3n de correo electr\xF3nico",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "fecha y hora ISO",
        date: "fecha ISO",
        time: "hora ISO",
        duration: "duraci\xF3n ISO",
        ipv4: "direcci\xF3n IPv4",
        ipv6: "direcci\xF3n IPv6",
        cidrv4: "rango IPv4",
        cidrv6: "rango IPv6",
        base64: "cadena codificada en base64",
        base64url: "URL codificada en base64",
        json_string: "cadena JSON",
        e164: "n\xFAmero E.164",
        jwt: "JWT",
        template_literal: "entrada"
      };
      const TypeDictionary = {
        nan: "NaN",
        string: "texto",
        number: "n\xFAmero",
        boolean: "booleano",
        array: "arreglo",
        object: "objeto",
        set: "conjunto",
        file: "archivo",
        date: "fecha",
        bigint: "n\xFAmero grande",
        symbol: "s\xEDmbolo",
        undefined: "indefinido",
        null: "nulo",
        function: "funci\xF3n",
        map: "mapa",
        record: "registro",
        tuple: "tupla",
        enum: "enumeraci\xF3n",
        union: "uni\xF3n",
        literal: "literal",
        promise: "promesa",
        void: "vac\xEDo",
        never: "nunca",
        unknown: "desconocido",
        any: "cualquiera"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Entrada inv\xE1lida: se esperaba instanceof ${issue3.expected}, recibido ${received}`;
            }
            return `Entrada inv\xE1lida: se esperaba ${expected}, recibido ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Entrada inv\xE1lida: se esperaba ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Opci\xF3n inv\xE1lida: se esperaba una de ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            if (sizing)
              return `Demasiado grande: se esperaba que ${origin2 ?? "valor"} tuviera ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementos"}`;
            return `Demasiado grande: se esperaba que ${origin2 ?? "valor"} fuera ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            if (sizing) {
              return `Demasiado peque\xF1o: se esperaba que ${origin2} tuviera ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Demasiado peque\xF1o: se esperaba que ${origin2} fuera ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Cadena inv\xE1lida: debe comenzar con "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Cadena inv\xE1lida: debe terminar en "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Cadena inv\xE1lida: debe incluir "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Cadena inv\xE1lida: debe coincidir con el patr\xF3n ${_issue.pattern}`;
            return `Inv\xE1lido ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `N\xFAmero inv\xE1lido: debe ser m\xFAltiplo de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Llave${issue3.keys.length > 1 ? "s" : ""} desconocida${issue3.keys.length > 1 ? "s" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Llave inv\xE1lida en ${TypeDictionary[issue3.origin] ?? issue3.origin}`;
          case "invalid_union":
            return "Entrada inv\xE1lida";
          case "invalid_element":
            return `Valor inv\xE1lido en ${TypeDictionary[issue3.origin] ?? issue3.origin}`;
          default:
            return `Entrada inv\xE1lida`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/fa.cjs
var require_fa = __commonJS({
  "node_modules/zod/v4/locales/fa.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
        file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
        array: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
        set: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0648\u0631\u0648\u062F\u06CC",
        email: "\u0622\u062F\u0631\u0633 \u0627\u06CC\u0645\u06CC\u0644",
        url: "URL",
        emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u062A\u0627\u0631\u06CC\u062E \u0648 \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
        date: "\u062A\u0627\u0631\u06CC\u062E \u0627\u06CC\u0632\u0648",
        time: "\u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
        duration: "\u0645\u062F\u062A \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
        ipv4: "IPv4 \u0622\u062F\u0631\u0633",
        ipv6: "IPv6 \u0622\u062F\u0631\u0633",
        cidrv4: "IPv4 \u062F\u0627\u0645\u0646\u0647",
        cidrv6: "IPv6 \u062F\u0627\u0645\u0646\u0647",
        base64: "base64-encoded \u0631\u0634\u062A\u0647",
        base64url: "base64url-encoded \u0631\u0634\u062A\u0647",
        json_string: "JSON \u0631\u0634\u062A\u0647",
        e164: "E.164 \u0639\u062F\u062F",
        jwt: "JWT",
        template_literal: "\u0648\u0631\u0648\u062F\u06CC"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0639\u062F\u062F",
        array: "\u0622\u0631\u0627\u06CC\u0647"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A instanceof ${issue3.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
            }
            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
          }
          case "invalid_value":
            if (issue3.values.length === 1) {
              return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${util4.stringifyPrimitive(issue3.values[0])} \u0645\u06CC\u200C\u0628\u0648\u062F`;
            }
            return `\u06AF\u0632\u06CC\u0646\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A \u06CC\u06A9\u06CC \u0627\u0632 ${util4.joinValues(issue3.values, "|")} \u0645\u06CC\u200C\u0628\u0648\u062F`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue3.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"} \u0628\u0627\u0634\u062F`;
            }
            return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue3.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} \u0628\u0627\u0634\u062F`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} ${sizing.unit} \u0628\u0627\u0634\u062F`;
            }
            return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} \u0628\u0627\u0634\u062F`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.prefix}" \u0634\u0631\u0648\u0639 \u0634\u0648\u062F`;
            }
            if (_issue.format === "ends_with") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.suffix}" \u062A\u0645\u0627\u0645 \u0634\u0648\u062F`;
            }
            if (_issue.format === "includes") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0634\u0627\u0645\u0644 "${_issue.includes}" \u0628\u0627\u0634\u062F`;
            }
            if (_issue.format === "regex") {
              return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 \u0627\u0644\u06AF\u0648\u06CC ${_issue.pattern} \u0645\u0637\u0627\u0628\u0642\u062A \u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F`;
            }
            return `${FormatDictionary[_issue.format] ?? issue3.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
          }
          case "not_multiple_of":
            return `\u0639\u062F\u062F \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0645\u0636\u0631\u0628 ${issue3.divisor} \u0628\u0627\u0634\u062F`;
          case "unrecognized_keys":
            return `\u06A9\u0644\u06CC\u062F${issue3.keys.length > 1 ? "\u0647\u0627\u06CC" : ""} \u0646\u0627\u0634\u0646\u0627\u0633: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u06A9\u0644\u06CC\u062F \u0646\u0627\u0634\u0646\u0627\u0633 \u062F\u0631 ${issue3.origin}`;
          case "invalid_union":
            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
          case "invalid_element":
            return `\u0645\u0642\u062F\u0627\u0631 \u0646\u0627\u0645\u0639\u062A\u0628\u0631 \u062F\u0631 ${issue3.origin}`;
          default:
            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/fi.cjs
var require_fi = __commonJS({
  "node_modules/zod/v4/locales/fi.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "merkki\xE4", subject: "merkkijonon" },
        file: { unit: "tavua", subject: "tiedoston" },
        array: { unit: "alkiota", subject: "listan" },
        set: { unit: "alkiota", subject: "joukon" },
        number: { unit: "", subject: "luvun" },
        bigint: { unit: "", subject: "suuren kokonaisluvun" },
        int: { unit: "", subject: "kokonaisluvun" },
        date: { unit: "", subject: "p\xE4iv\xE4m\xE4\xE4r\xE4n" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "s\xE4\xE4nn\xF6llinen lauseke",
        email: "s\xE4hk\xF6postiosoite",
        url: "URL-osoite",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-aikaleima",
        date: "ISO-p\xE4iv\xE4m\xE4\xE4r\xE4",
        time: "ISO-aika",
        duration: "ISO-kesto",
        ipv4: "IPv4-osoite",
        ipv6: "IPv6-osoite",
        cidrv4: "IPv4-alue",
        cidrv6: "IPv6-alue",
        base64: "base64-koodattu merkkijono",
        base64url: "base64url-koodattu merkkijono",
        json_string: "JSON-merkkijono",
        e164: "E.164-luku",
        jwt: "JWT",
        template_literal: "templaattimerkkijono"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Virheellinen tyyppi: odotettiin instanceof ${issue3.expected}, oli ${received}`;
            }
            return `Virheellinen tyyppi: odotettiin ${expected}, oli ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Virheellinen sy\xF6te: t\xE4ytyy olla ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Virheellinen valinta: t\xE4ytyy olla yksi seuraavista: ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Liian suuri: ${sizing.subject} t\xE4ytyy olla ${adj}${issue3.maximum.toString()} ${sizing.unit}`.trim();
            }
            return `Liian suuri: arvon t\xE4ytyy olla ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Liian pieni: ${sizing.subject} t\xE4ytyy olla ${adj}${issue3.minimum.toString()} ${sizing.unit}`.trim();
            }
            return `Liian pieni: arvon t\xE4ytyy olla ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Virheellinen sy\xF6te: t\xE4ytyy alkaa "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Virheellinen sy\xF6te: t\xE4ytyy loppua "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Virheellinen sy\xF6te: t\xE4ytyy sis\xE4lt\xE4\xE4 "${_issue.includes}"`;
            if (_issue.format === "regex") {
              return `Virheellinen sy\xF6te: t\xE4ytyy vastata s\xE4\xE4nn\xF6llist\xE4 lauseketta ${_issue.pattern}`;
            }
            return `Virheellinen ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Virheellinen luku: t\xE4ytyy olla luvun ${issue3.divisor} monikerta`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Tuntemattomat avaimet" : "Tuntematon avain"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return "Virheellinen avain tietueessa";
          case "invalid_union":
            return "Virheellinen unioni";
          case "invalid_element":
            return "Virheellinen arvo joukossa";
          default:
            return `Virheellinen sy\xF6te`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/fr.cjs
var require_fr = __commonJS({
  "node_modules/zod/v4/locales/fr.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "caract\xE8res", verb: "avoir" },
        file: { unit: "octets", verb: "avoir" },
        array: { unit: "\xE9l\xE9ments", verb: "avoir" },
        set: { unit: "\xE9l\xE9ments", verb: "avoir" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "entr\xE9e",
        email: "adresse e-mail",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "date et heure ISO",
        date: "date ISO",
        time: "heure ISO",
        duration: "dur\xE9e ISO",
        ipv4: "adresse IPv4",
        ipv6: "adresse IPv6",
        cidrv4: "plage IPv4",
        cidrv6: "plage IPv6",
        base64: "cha\xEEne encod\xE9e en base64",
        base64url: "cha\xEEne encod\xE9e en base64url",
        json_string: "cha\xEEne JSON",
        e164: "num\xE9ro E.164",
        jwt: "JWT",
        template_literal: "entr\xE9e"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "nombre",
        array: "tableau"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Entr\xE9e invalide : instanceof ${issue3.expected} attendu, ${received} re\xE7u`;
            }
            return `Entr\xE9e invalide : ${expected} attendu, ${received} re\xE7u`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Entr\xE9e invalide : ${util4.stringifyPrimitive(issue3.values[0])} attendu`;
            return `Option invalide : une valeur parmi ${util4.joinValues(issue3.values, "|")} attendue`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Trop grand : ${issue3.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
            return `Trop grand : ${issue3.origin ?? "valeur"} doit \xEAtre ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Trop petit : ${issue3.origin} doit ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Trop petit : ${issue3.origin} doit \xEAtre ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Cha\xEEne invalide : doit correspondre au mod\xE8le ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} invalide`;
          }
          case "not_multiple_of":
            return `Nombre invalide : doit \xEAtre un multiple de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Cl\xE9${issue3.keys.length > 1 ? "s" : ""} non reconnue${issue3.keys.length > 1 ? "s" : ""} : ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Cl\xE9 invalide dans ${issue3.origin}`;
          case "invalid_union":
            return "Entr\xE9e invalide";
          case "invalid_element":
            return `Valeur invalide dans ${issue3.origin}`;
          default:
            return `Entr\xE9e invalide`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/fr-CA.cjs
var require_fr_CA = __commonJS({
  "node_modules/zod/v4/locales/fr-CA.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "caract\xE8res", verb: "avoir" },
        file: { unit: "octets", verb: "avoir" },
        array: { unit: "\xE9l\xE9ments", verb: "avoir" },
        set: { unit: "\xE9l\xE9ments", verb: "avoir" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "entr\xE9e",
        email: "adresse courriel",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "date-heure ISO",
        date: "date ISO",
        time: "heure ISO",
        duration: "dur\xE9e ISO",
        ipv4: "adresse IPv4",
        ipv6: "adresse IPv6",
        cidrv4: "plage IPv4",
        cidrv6: "plage IPv6",
        base64: "cha\xEEne encod\xE9e en base64",
        base64url: "cha\xEEne encod\xE9e en base64url",
        json_string: "cha\xEEne JSON",
        e164: "num\xE9ro E.164",
        jwt: "JWT",
        template_literal: "entr\xE9e"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Entr\xE9e invalide : attendu instanceof ${issue3.expected}, re\xE7u ${received}`;
            }
            return `Entr\xE9e invalide : attendu ${expected}, re\xE7u ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Entr\xE9e invalide : attendu ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Option invalide : attendu l'une des valeurs suivantes ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "\u2264" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Trop grand : attendu que ${issue3.origin ?? "la valeur"} ait ${adj}${issue3.maximum.toString()} ${sizing.unit}`;
            return `Trop grand : attendu que ${issue3.origin ?? "la valeur"} soit ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "\u2265" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Trop petit : attendu que ${issue3.origin} ait ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Trop petit : attendu que ${issue3.origin} soit ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Cha\xEEne invalide : doit correspondre au motif ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} invalide`;
          }
          case "not_multiple_of":
            return `Nombre invalide : doit \xEAtre un multiple de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Cl\xE9${issue3.keys.length > 1 ? "s" : ""} non reconnue${issue3.keys.length > 1 ? "s" : ""} : ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Cl\xE9 invalide dans ${issue3.origin}`;
          case "invalid_union":
            return "Entr\xE9e invalide";
          case "invalid_element":
            return `Valeur invalide dans ${issue3.origin}`;
          default:
            return `Entr\xE9e invalide`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/he.cjs
var require_he = __commonJS({
  "node_modules/zod/v4/locales/he.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const TypeNames = {
        string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
        number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
        boolean: { label: "\u05E2\u05E8\u05DA \u05D1\u05D5\u05DC\u05D9\u05D0\u05E0\u05D9", gender: "m" },
        bigint: { label: "BigInt", gender: "m" },
        date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA", gender: "m" },
        array: { label: "\u05DE\u05E2\u05E8\u05DA", gender: "m" },
        object: { label: "\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8", gender: "m" },
        null: { label: "\u05E2\u05E8\u05DA \u05E8\u05D9\u05E7 (null)", gender: "m" },
        undefined: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05DE\u05D5\u05D2\u05D3\u05E8 (undefined)", gender: "m" },
        symbol: { label: "\u05E1\u05D9\u05DE\u05D1\u05D5\u05DC (Symbol)", gender: "m" },
        function: { label: "\u05E4\u05D5\u05E0\u05E7\u05E6\u05D9\u05D4", gender: "f" },
        map: { label: "\u05DE\u05E4\u05D4 (Map)", gender: "f" },
        set: { label: "\u05E7\u05D1\u05D5\u05E6\u05D4 (Set)", gender: "f" },
        file: { label: "\u05E7\u05D5\u05D1\u05E5", gender: "m" },
        promise: { label: "Promise", gender: "m" },
        NaN: { label: "NaN", gender: "m" },
        unknown: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05D9\u05D3\u05D5\u05E2", gender: "m" },
        value: { label: "\u05E2\u05E8\u05DA", gender: "m" }
      };
      const Sizable = {
        string: { unit: "\u05EA\u05D5\u05D5\u05D9\u05DD", shortLabel: "\u05E7\u05E6\u05E8", longLabel: "\u05D0\u05E8\u05D5\u05DA" },
        file: { unit: "\u05D1\u05D9\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
        array: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
        set: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
        number: { unit: "", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }
        // no unit
      };
      const typeEntry = (t) => t ? TypeNames[t] : void 0;
      const typeLabel = (t) => {
        const e = typeEntry(t);
        if (e)
          return e.label;
        return t ?? TypeNames.unknown.label;
      };
      const withDefinite = (t) => `\u05D4${typeLabel(t)}`;
      const verbFor = (t) => {
        const e = typeEntry(t);
        const gender = e?.gender ?? "m";
        return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA";
      };
      const getSizing = (origin2) => {
        if (!origin2)
          return null;
        return Sizable[origin2] ?? null;
      };
      const FormatDictionary = {
        regex: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        email: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05D0\u05D9\u05DE\u05D9\u05D9\u05DC", gender: "f" },
        url: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05E8\u05E9\u05EA", gender: "f" },
        emoji: { label: "\u05D0\u05D9\u05DE\u05D5\u05D2'\u05D9", gender: "m" },
        uuid: { label: "UUID", gender: "m" },
        nanoid: { label: "nanoid", gender: "m" },
        guid: { label: "GUID", gender: "m" },
        cuid: { label: "cuid", gender: "m" },
        cuid2: { label: "cuid2", gender: "m" },
        ulid: { label: "ULID", gender: "m" },
        xid: { label: "XID", gender: "m" },
        ksuid: { label: "KSUID", gender: "m" },
        datetime: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA \u05D5\u05D6\u05DE\u05DF ISO", gender: "m" },
        date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA ISO", gender: "m" },
        time: { label: "\u05D6\u05DE\u05DF ISO", gender: "m" },
        duration: { label: "\u05DE\u05E9\u05DA \u05D6\u05DE\u05DF ISO", gender: "m" },
        ipv4: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv4", gender: "f" },
        ipv6: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv6", gender: "f" },
        cidrv4: { label: "\u05D8\u05D5\u05D5\u05D7 IPv4", gender: "m" },
        cidrv6: { label: "\u05D8\u05D5\u05D5\u05D7 IPv6", gender: "m" },
        base64: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64", gender: "f" },
        base64url: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64 \u05DC\u05DB\u05EA\u05D5\u05D1\u05D5\u05EA \u05E8\u05E9\u05EA", gender: "f" },
        json_string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA JSON", gender: "f" },
        e164: { label: "\u05DE\u05E1\u05E4\u05E8 E.164", gender: "m" },
        jwt: { label: "JWT", gender: "m" },
        ends_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        includes: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        lowercase: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        starts_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
        uppercase: { label: "\u05E7\u05DC\u05D8", gender: "m" }
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expectedKey = issue3.expected;
            const expected = TypeDictionary[expectedKey ?? ""] ?? typeLabel(expectedKey);
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? TypeNames[receivedType]?.label ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA instanceof ${issue3.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
            }
            return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
          }
          case "invalid_value": {
            if (issue3.values.length === 1) {
              return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05E2\u05E8\u05DA \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA ${util4.stringifyPrimitive(issue3.values[0])}`;
            }
            const stringified = issue3.values.map((v) => util4.stringifyPrimitive(v));
            if (issue3.values.length === 2) {
              return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${stringified[0]} \u05D0\u05D5 ${stringified[1]}`;
            }
            const lastValue = stringified[stringified.length - 1];
            const restValues = stringified.slice(0, -1).join(", ");
            return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${restValues} \u05D0\u05D5 ${lastValue}`;
          }
          case "too_big": {
            const sizing = getSizing(issue3.origin);
            const subject = withDefinite(issue3.origin ?? "value");
            if (issue3.origin === "string") {
              return `${sizing?.longLabel ?? "\u05D0\u05E8\u05D5\u05DA"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue3.maximum.toString()} ${sizing?.unit ?? ""} ${issue3.inclusive ? "\u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA" : "\u05DC\u05DB\u05DC \u05D4\u05D9\u05D5\u05EA\u05E8"}`.trim();
            }
            if (issue3.origin === "number") {
              const comparison = issue3.inclusive ? `\u05E7\u05D8\u05DF \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue3.maximum}` : `\u05E7\u05D8\u05DF \u05DE-${issue3.maximum}`;
              return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
            }
            if (issue3.origin === "array" || issue3.origin === "set") {
              const verb = issue3.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
              const comparison = issue3.inclusive ? `${issue3.maximum} ${sizing?.unit ?? ""} \u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA` : `\u05E4\u05D7\u05D5\u05EA \u05DE-${issue3.maximum} ${sizing?.unit ?? ""}`;
              return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
            }
            const adj = issue3.inclusive ? "<=" : "<";
            const be = verbFor(issue3.origin ?? "value");
            if (sizing?.unit) {
              return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue3.maximum.toString()} ${sizing.unit}`;
            }
            return `${sizing?.longLabel ?? "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const sizing = getSizing(issue3.origin);
            const subject = withDefinite(issue3.origin ?? "value");
            if (issue3.origin === "string") {
              return `${sizing?.shortLabel ?? "\u05E7\u05E6\u05E8"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue3.minimum.toString()} ${sizing?.unit ?? ""} ${issue3.inclusive ? "\u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8" : "\u05DC\u05E4\u05D7\u05D5\u05EA"}`.trim();
            }
            if (issue3.origin === "number") {
              const comparison = issue3.inclusive ? `\u05D2\u05D3\u05D5\u05DC \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue3.minimum}` : `\u05D2\u05D3\u05D5\u05DC \u05DE-${issue3.minimum}`;
              return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
            }
            if (issue3.origin === "array" || issue3.origin === "set") {
              const verb = issue3.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
              if (issue3.minimum === 1 && issue3.inclusive) {
                const singularPhrase = issue3.origin === "set" ? "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3" : "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3";
                return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${singularPhrase}`;
              }
              const comparison = issue3.inclusive ? `${issue3.minimum} ${sizing?.unit ?? ""} \u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8` : `\u05D9\u05D5\u05EA\u05E8 \u05DE-${issue3.minimum} ${sizing?.unit ?? ""}`;
              return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
            }
            const adj = issue3.inclusive ? ">=" : ">";
            const be = verbFor(issue3.origin ?? "value");
            if (sizing?.unit) {
              return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `${sizing?.shortLabel ?? "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D7\u05D9\u05DC \u05D1 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05E1\u05EA\u05D9\u05D9\u05DD \u05D1 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05DB\u05DC\u05D5\u05DC "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${_issue.pattern}`;
            const nounEntry = FormatDictionary[_issue.format];
            const noun = nounEntry?.label ?? _issue.format;
            const gender = nounEntry?.gender ?? "m";
            const adjective = gender === "f" ? "\u05EA\u05E7\u05D9\u05E0\u05D4" : "\u05EA\u05E7\u05D9\u05DF";
            return `${noun} \u05DC\u05D0 ${adjective}`;
          }
          case "not_multiple_of":
            return `\u05DE\u05E1\u05E4\u05E8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA \u05DE\u05DB\u05E4\u05DC\u05D4 \u05E9\u05DC ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u05DE\u05E4\u05EA\u05D7${issue3.keys.length > 1 ? "\u05D5\u05EA" : ""} \u05DC\u05D0 \u05DE\u05D6\u05D5\u05D4${issue3.keys.length > 1 ? "\u05D9\u05DD" : "\u05D4"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key": {
            return `\u05E9\u05D3\u05D4 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8`;
          }
          case "invalid_union":
            return "\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF";
          case "invalid_element": {
            const place = withDefinite(issue3.origin ?? "array");
            return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${place}`;
          }
          default:
            return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/hu.cjs
var require_hu = __commonJS({
  "node_modules/zod/v4/locales/hu.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "karakter", verb: "legyen" },
        file: { unit: "byte", verb: "legyen" },
        array: { unit: "elem", verb: "legyen" },
        set: { unit: "elem", verb: "legyen" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "bemenet",
        email: "email c\xEDm",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO id\u0151b\xE9lyeg",
        date: "ISO d\xE1tum",
        time: "ISO id\u0151",
        duration: "ISO id\u0151intervallum",
        ipv4: "IPv4 c\xEDm",
        ipv6: "IPv6 c\xEDm",
        cidrv4: "IPv4 tartom\xE1ny",
        cidrv6: "IPv6 tartom\xE1ny",
        base64: "base64-k\xF3dolt string",
        base64url: "base64url-k\xF3dolt string",
        json_string: "JSON string",
        e164: "E.164 sz\xE1m",
        jwt: "JWT",
        template_literal: "bemenet"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "sz\xE1m",
        array: "t\xF6mb"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue3.expected}, a kapott \xE9rt\xE9k ${received}`;
            }
            return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `T\xFAl nagy: ${issue3.origin ?? "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elem"}`;
            return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${issue3.origin ?? "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue3.origin} m\xE9rete t\xFAl kicsi ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue3.origin} t\xFAl kicsi ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\xC9rv\xE9nytelen string: "${_issue.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`;
            if (_issue.format === "ends_with")
              return `\xC9rv\xE9nytelen string: "${_issue.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`;
            if (_issue.format === "includes")
              return `\xC9rv\xE9nytelen string: "${_issue.includes}" \xE9rt\xE9ket kell tartalmaznia`;
            if (_issue.format === "regex")
              return `\xC9rv\xE9nytelen string: ${_issue.pattern} mint\xE1nak kell megfelelnie`;
            return `\xC9rv\xE9nytelen ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\xC9rv\xE9nytelen sz\xE1m: ${issue3.divisor} t\xF6bbsz\xF6r\xF6s\xE9nek kell lennie`;
          case "unrecognized_keys":
            return `Ismeretlen kulcs${issue3.keys.length > 1 ? "s" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\xC9rv\xE9nytelen kulcs ${issue3.origin}`;
          case "invalid_union":
            return "\xC9rv\xE9nytelen bemenet";
          case "invalid_element":
            return `\xC9rv\xE9nytelen \xE9rt\xE9k: ${issue3.origin}`;
          default:
            return `\xC9rv\xE9nytelen bemenet`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/hy.cjs
var require_hy = __commonJS({
  "node_modules/zod/v4/locales/hy.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    function getArmenianPlural3(count, one, many) {
      return Math.abs(count) === 1 ? one : many;
    }
    function withDefiniteArticle3(word) {
      if (!word)
        return "";
      const vowels = ["\u0561", "\u0565", "\u0568", "\u056B", "\u0578", "\u0578\u0582", "\u0585"];
      const lastChar = word[word.length - 1];
      return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
    }
    var error73 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "\u0576\u0577\u0561\u0576",
            many: "\u0576\u0577\u0561\u0576\u0576\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        },
        file: {
          unit: {
            one: "\u0562\u0561\u0575\u0569",
            many: "\u0562\u0561\u0575\u0569\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        },
        array: {
          unit: {
            one: "\u057F\u0561\u0580\u0580",
            many: "\u057F\u0561\u0580\u0580\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        },
        set: {
          unit: {
            one: "\u057F\u0561\u0580\u0580",
            many: "\u057F\u0561\u0580\u0580\u0565\u0580"
          },
          verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
        }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0574\u0578\u0582\u057F\u0584",
        email: "\u0567\u056C. \u0570\u0561\u057D\u0581\u0565",
        url: "URL",
        emoji: "\u0567\u0574\u0578\u057B\u056B",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E \u0587 \u056A\u0561\u0574",
        date: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E",
        time: "ISO \u056A\u0561\u0574",
        duration: "ISO \u057F\u0587\u0578\u0572\u0578\u0582\u0569\u0575\u0578\u0582\u0576",
        ipv4: "IPv4 \u0570\u0561\u057D\u0581\u0565",
        ipv6: "IPv6 \u0570\u0561\u057D\u0581\u0565",
        cidrv4: "IPv4 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
        cidrv6: "IPv6 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
        base64: "base64 \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
        base64url: "base64url \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
        json_string: "JSON \u057F\u0578\u0572",
        e164: "E.164 \u0570\u0561\u0574\u0561\u0580",
        jwt: "JWT",
        template_literal: "\u0574\u0578\u0582\u057F\u0584"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0569\u056B\u057E",
        array: "\u0566\u0561\u0576\u0563\u057E\u0561\u056E"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 instanceof ${issue3.expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
            }
            return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${util4.stringifyPrimitive(issue3.values[1])}`;
            return `\u054D\u056D\u0561\u056C \u057F\u0561\u0580\u0562\u0565\u0580\u0561\u056F\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 \u0570\u0565\u057F\u0587\u0575\u0561\u056C\u0576\u0565\u0580\u056B\u0581 \u0574\u0565\u056F\u0568\u055D ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const maxValue = Number(issue3.maximum);
              const unit = getArmenianPlural3(maxValue, sizing.unit.one, sizing.unit.many);
              return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle3(issue3.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue3.maximum.toString()} ${unit}`;
            }
            return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle3(issue3.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056C\u056B\u0576\u056B ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const minValue = Number(issue3.minimum);
              const unit = getArmenianPlural3(minValue, sizing.unit.one, sizing.unit.many);
              return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle3(issue3.origin)} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue3.minimum.toString()} ${unit}`;
            }
            return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle3(issue3.origin)} \u056C\u056B\u0576\u056B ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057D\u056F\u057D\u057E\u056B "${_issue.prefix}"-\u0578\u057E`;
            if (_issue.format === "ends_with")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0561\u057E\u0561\u0580\u057F\u057E\u056B "${_issue.suffix}"-\u0578\u057E`;
            if (_issue.format === "includes")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057A\u0561\u0580\u0578\u0582\u0576\u0561\u056F\u056B "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0570\u0561\u0574\u0561\u057A\u0561\u057F\u0561\u057D\u056D\u0561\u0576\u056B ${_issue.pattern} \u0571\u0587\u0561\u0579\u0561\u0583\u056B\u0576`;
            return `\u054D\u056D\u0561\u056C ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u054D\u056D\u0561\u056C \u0569\u056B\u057E\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0562\u0561\u0566\u0574\u0561\u057A\u0561\u057F\u056B\u056F \u056C\u056B\u0576\u056B ${issue3.divisor}-\u056B`;
          case "unrecognized_keys":
            return `\u0549\u0573\u0561\u0576\u0561\u0579\u057E\u0561\u056E \u0562\u0561\u0576\u0561\u056C\u056B${issue3.keys.length > 1 ? "\u0576\u0565\u0580" : ""}. ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u054D\u056D\u0561\u056C \u0562\u0561\u0576\u0561\u056C\u056B ${withDefiniteArticle3(issue3.origin)}-\u0578\u0582\u0574`;
          case "invalid_union":
            return "\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574";
          case "invalid_element":
            return `\u054D\u056D\u0561\u056C \u0561\u0580\u056A\u0565\u0584 ${withDefiniteArticle3(issue3.origin)}-\u0578\u0582\u0574`;
          default:
            return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/id.cjs
var require_id = __commonJS({
  "node_modules/zod/v4/locales/id.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "karakter", verb: "memiliki" },
        file: { unit: "byte", verb: "memiliki" },
        array: { unit: "item", verb: "memiliki" },
        set: { unit: "item", verb: "memiliki" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "alamat email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "tanggal dan waktu format ISO",
        date: "tanggal format ISO",
        time: "jam format ISO",
        duration: "durasi format ISO",
        ipv4: "alamat IPv4",
        ipv6: "alamat IPv6",
        cidrv4: "rentang alamat IPv4",
        cidrv6: "rentang alamat IPv6",
        base64: "string dengan enkode base64",
        base64url: "string dengan enkode base64url",
        json_string: "string JSON",
        e164: "angka E.164",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Input tidak valid: diharapkan instanceof ${issue3.expected}, diterima ${received}`;
            }
            return `Input tidak valid: diharapkan ${expected}, diterima ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Input tidak valid: diharapkan ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Pilihan tidak valid: diharapkan salah satu dari ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Terlalu besar: diharapkan ${issue3.origin ?? "value"} memiliki ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elemen"}`;
            return `Terlalu besar: diharapkan ${issue3.origin ?? "value"} menjadi ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Terlalu kecil: diharapkan ${issue3.origin} memiliki ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Terlalu kecil: diharapkan ${issue3.origin} menjadi ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `String tidak valid: harus dimulai dengan "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `String tidak valid: harus berakhir dengan "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `String tidak valid: harus menyertakan "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `String tidak valid: harus sesuai pola ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} tidak valid`;
          }
          case "not_multiple_of":
            return `Angka tidak valid: harus kelipatan dari ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Kunci tidak dikenali ${issue3.keys.length > 1 ? "s" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Kunci tidak valid di ${issue3.origin}`;
          case "invalid_union":
            return "Input tidak valid";
          case "invalid_element":
            return `Nilai tidak valid di ${issue3.origin}`;
          default:
            return `Input tidak valid`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/is.cjs
var require_is2 = __commonJS({
  "node_modules/zod/v4/locales/is.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "stafi", verb: "a\xF0 hafa" },
        file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
        array: { unit: "hluti", verb: "a\xF0 hafa" },
        set: { unit: "hluti", verb: "a\xF0 hafa" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "gildi",
        email: "netfang",
        url: "vefsl\xF3\xF0",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO dagsetning og t\xEDmi",
        date: "ISO dagsetning",
        time: "ISO t\xEDmi",
        duration: "ISO t\xEDmalengd",
        ipv4: "IPv4 address",
        ipv6: "IPv6 address",
        cidrv4: "IPv4 range",
        cidrv6: "IPv6 range",
        base64: "base64-encoded strengur",
        base64url: "base64url-encoded strengur",
        json_string: "JSON strengur",
        e164: "E.164 t\xF6lugildi",
        jwt: "JWT",
        template_literal: "gildi"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "n\xFAmer",
        array: "fylki"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera instanceof ${issue3.expected}`;
            }
            return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera ${expected}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Rangt gildi: gert r\xE1\xF0 fyrir ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\xD3gilt val: m\xE1 vera eitt af eftirfarandi ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin ?? "gildi"} hafi ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "hluti"}`;
            return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin ?? "gildi"} s\xE9 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin} hafi ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin} s\xE9 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\xD3gildur strengur: ver\xF0ur a\xF0 byrja \xE1 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\xD3gildur strengur: ver\xF0ur a\xF0 enda \xE1 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\xD3gildur strengur: ver\xF0ur a\xF0 innihalda "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\xD3gildur strengur: ver\xF0ur a\xF0 fylgja mynstri ${_issue.pattern}`;
            return `Rangt ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `R\xF6ng tala: ver\xF0ur a\xF0 vera margfeldi af ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\xD3\xFEekkt ${issue3.keys.length > 1 ? "ir lyklar" : "ur lykill"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Rangur lykill \xED ${issue3.origin}`;
          case "invalid_union":
            return "Rangt gildi";
          case "invalid_element":
            return `Rangt gildi \xED ${issue3.origin}`;
          default:
            return `Rangt gildi`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/it.cjs
var require_it = __commonJS({
  "node_modules/zod/v4/locales/it.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "caratteri", verb: "avere" },
        file: { unit: "byte", verb: "avere" },
        array: { unit: "elementi", verb: "avere" },
        set: { unit: "elementi", verb: "avere" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "indirizzo email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data e ora ISO",
        date: "data ISO",
        time: "ora ISO",
        duration: "durata ISO",
        ipv4: "indirizzo IPv4",
        ipv6: "indirizzo IPv6",
        cidrv4: "intervallo IPv4",
        cidrv6: "intervallo IPv6",
        base64: "stringa codificata in base64",
        base64url: "URL codificata in base64",
        json_string: "stringa JSON",
        e164: "numero E.164",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "numero",
        array: "vettore"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Input non valido: atteso instanceof ${issue3.expected}, ricevuto ${received}`;
            }
            return `Input non valido: atteso ${expected}, ricevuto ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Input non valido: atteso ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Opzione non valida: atteso uno tra ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Troppo grande: ${issue3.origin ?? "valore"} deve avere ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementi"}`;
            return `Troppo grande: ${issue3.origin ?? "valore"} deve essere ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Troppo piccolo: ${issue3.origin} deve avere ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Troppo piccolo: ${issue3.origin} deve essere ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Stringa non valida: deve iniziare con "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Stringa non valida: deve terminare con "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Stringa non valida: deve includere "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
            return `Invalid ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Numero non valido: deve essere un multiplo di ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Chiav${issue3.keys.length > 1 ? "i" : "e"} non riconosciut${issue3.keys.length > 1 ? "e" : "a"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Chiave non valida in ${issue3.origin}`;
          case "invalid_union":
            return "Input non valido";
          case "invalid_element":
            return `Valore non valido in ${issue3.origin}`;
          default:
            return `Input non valido`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ja.cjs
var require_ja = __commonJS({
  "node_modules/zod/v4/locales/ja.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
        file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
        array: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" },
        set: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u5165\u529B\u5024",
        email: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9",
        url: "URL",
        emoji: "\u7D75\u6587\u5B57",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO\u65E5\u6642",
        date: "ISO\u65E5\u4ED8",
        time: "ISO\u6642\u523B",
        duration: "ISO\u671F\u9593",
        ipv4: "IPv4\u30A2\u30C9\u30EC\u30B9",
        ipv6: "IPv6\u30A2\u30C9\u30EC\u30B9",
        cidrv4: "IPv4\u7BC4\u56F2",
        cidrv6: "IPv6\u7BC4\u56F2",
        base64: "base64\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
        base64url: "base64url\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
        json_string: "JSON\u6587\u5B57\u5217",
        e164: "E.164\u756A\u53F7",
        jwt: "JWT",
        template_literal: "\u5165\u529B\u5024"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u6570\u5024",
        array: "\u914D\u5217"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u7121\u52B9\u306A\u5165\u529B: instanceof ${issue3.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
            }
            return `\u7121\u52B9\u306A\u5165\u529B: ${expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u7121\u52B9\u306A\u5165\u529B: ${util4.stringifyPrimitive(issue3.values[0])}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F`;
            return `\u7121\u52B9\u306A\u9078\u629E: ${util4.joinValues(issue3.values, "\u3001")}\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          case "too_big": {
            const adj = issue3.inclusive ? "\u4EE5\u4E0B\u3067\u3042\u308B" : "\u3088\u308A\u5C0F\u3055\u3044";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue3.origin ?? "\u5024"}\u306F${issue3.maximum.toString()}${sizing.unit ?? "\u8981\u7D20"}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue3.origin ?? "\u5024"}\u306F${issue3.maximum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "\u4EE5\u4E0A\u3067\u3042\u308B" : "\u3088\u308A\u5927\u304D\u3044";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue3.origin}\u306F${issue3.minimum.toString()}${sizing.unit}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue3.origin}\u306F${issue3.minimum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.prefix}"\u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            if (_issue.format === "ends_with")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.suffix}"\u3067\u7D42\u308F\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            if (_issue.format === "includes")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.includes}"\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            if (_issue.format === "regex")
              return `\u7121\u52B9\u306A\u6587\u5B57\u5217: \u30D1\u30BF\u30FC\u30F3${_issue.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
            return `\u7121\u52B9\u306A${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u7121\u52B9\u306A\u6570\u5024: ${issue3.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
          case "unrecognized_keys":
            return `\u8A8D\u8B58\u3055\u308C\u3066\u3044\u306A\u3044\u30AD\u30FC${issue3.keys.length > 1 ? "\u7FA4" : ""}: ${util4.joinValues(issue3.keys, "\u3001")}`;
          case "invalid_key":
            return `${issue3.origin}\u5185\u306E\u7121\u52B9\u306A\u30AD\u30FC`;
          case "invalid_union":
            return "\u7121\u52B9\u306A\u5165\u529B";
          case "invalid_element":
            return `${issue3.origin}\u5185\u306E\u7121\u52B9\u306A\u5024`;
          default:
            return `\u7121\u52B9\u306A\u5165\u529B`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ka.cjs
var require_ka = __commonJS({
  "node_modules/zod/v4/locales/ka.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
        file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
        array: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
        set: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0",
        email: "\u10D4\u10DA-\u10E4\u10DD\u10E1\u10E2\u10D8\u10E1 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
        url: "URL",
        emoji: "\u10D4\u10DB\u10DD\u10EF\u10D8",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8-\u10D3\u10E0\u10DD",
        date: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8",
        time: "\u10D3\u10E0\u10DD",
        duration: "\u10EE\u10D0\u10DC\u10D2\u10E0\u10EB\u10DA\u10D8\u10D5\u10DD\u10D1\u10D0",
        ipv4: "IPv4 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
        ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
        cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
        cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
        base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
        jwt: "JWT",
        template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
        string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
        boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
        function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
        array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 instanceof ${issue3.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
            }
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D0\u10E0\u10D8\u10D0\u10DC\u10E2\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8\u10D0 \u10D4\u10E0\u10D7-\u10D4\u10E0\u10D7\u10D8 ${util4.joinValues(issue3.values, "|")}-\u10D3\u10D0\u10DC`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit}`;
            return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
            }
            if (_issue.format === "ends_with")
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
            if (_issue.format === "includes")
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
            if (_issue.format === "regex")
              return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E0\u10D8\u10EA\u10EE\u10D5\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10E7\u10DD\u10E1 ${issue3.divisor}-\u10D8\u10E1 \u10EF\u10D4\u10E0\u10D0\u10D3\u10D8`;
          case "unrecognized_keys":
            return `\u10E3\u10EA\u10DC\u10DD\u10D1\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1${issue3.keys.length > 1 ? "\u10D4\u10D1\u10D8" : "\u10D8"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1\u10D8 ${issue3.origin}-\u10E8\u10D8`;
          case "invalid_union":
            return "\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0";
          case "invalid_element":
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0 ${issue3.origin}-\u10E8\u10D8`;
          default:
            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/km.cjs
var require_km = __commonJS({
  "node_modules/zod/v4/locales/km.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
        file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
        array: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
        set: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B",
        email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B",
        url: "URL",
        emoji: "\u179F\u1789\u17D2\u1789\u17B6\u17A2\u17B6\u179A\u1798\u17D2\u1798\u178E\u17CD",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 \u1793\u17B7\u1784\u1798\u17C9\u17C4\u1784 ISO",
        date: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 ISO",
        time: "\u1798\u17C9\u17C4\u1784 ISO",
        duration: "\u179A\u1799\u17C8\u1796\u17C1\u179B ISO",
        ipv4: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
        ipv6: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
        cidrv4: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
        cidrv6: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
        base64: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64",
        base64url: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64url",
        json_string: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A JSON",
        e164: "\u179B\u17C1\u1781 E.164",
        jwt: "JWT",
        template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u179B\u17C1\u1781",
        array: "\u17A2\u17B6\u179A\u17C1 (Array)",
        null: "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A instanceof ${issue3.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
            }
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u1787\u1798\u17D2\u179A\u17BE\u179F\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1787\u17B6\u1798\u17BD\u1799\u1780\u17D2\u1793\u17BB\u1784\u1785\u17C6\u178E\u17C4\u1798 ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "\u1792\u17B6\u178F\u17BB"}`;
            return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin} ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin} ${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1785\u17B6\u1794\u17CB\u1795\u17D2\u178F\u17BE\u1798\u178A\u17C4\u1799 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1794\u1789\u17D2\u1785\u1794\u17CB\u178A\u17C4\u1799 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${_issue.pattern}`;
            return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u179A\u1780\u1783\u17BE\u1789\u179F\u17C4\u1798\u17B7\u1793\u179F\u17D2\u1782\u17B6\u179B\u17CB\u17D6 ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u179F\u17C4\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue3.origin}`;
          case "invalid_union":
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
          case "invalid_element":
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue3.origin}`;
          default:
            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/kh.cjs
var require_kh = __commonJS({
  "node_modules/zod/v4/locales/kh.cjs"(exports2, module2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var km_js_1 = __importDefault(require_km());
    function default_1() {
      return (0, km_js_1.default)();
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ko.cjs
var require_ko = __commonJS({
  "node_modules/zod/v4/locales/ko.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\uBB38\uC790", verb: "to have" },
        file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
        array: { unit: "\uAC1C", verb: "to have" },
        set: { unit: "\uAC1C", verb: "to have" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\uC785\uB825",
        email: "\uC774\uBA54\uC77C \uC8FC\uC18C",
        url: "URL",
        emoji: "\uC774\uBAA8\uC9C0",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \uB0A0\uC9DC\uC2DC\uAC04",
        date: "ISO \uB0A0\uC9DC",
        time: "ISO \uC2DC\uAC04",
        duration: "ISO \uAE30\uAC04",
        ipv4: "IPv4 \uC8FC\uC18C",
        ipv6: "IPv6 \uC8FC\uC18C",
        cidrv4: "IPv4 \uBC94\uC704",
        cidrv6: "IPv6 \uBC94\uC704",
        base64: "base64 \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
        base64url: "base64url \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
        json_string: "JSON \uBB38\uC790\uC5F4",
        e164: "E.164 \uBC88\uD638",
        jwt: "JWT",
        template_literal: "\uC785\uB825"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 instanceof ${issue3.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
            }
            return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${util4.stringifyPrimitive(issue3.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`;
            return `\uC798\uBABB\uB41C \uC635\uC158: ${util4.joinValues(issue3.values, "\uB610\uB294 ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
          case "too_big": {
            const adj = issue3.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC";
            const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
            const sizing = getSizing(issue3.origin);
            const unit = sizing?.unit ?? "\uC694\uC18C";
            if (sizing)
              return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue3.maximum.toString()}${unit} ${adj}${suffix}`;
            return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue3.maximum.toString()} ${adj}${suffix}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC";
            const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
            const sizing = getSizing(issue3.origin);
            const unit = sizing?.unit ?? "\uC694\uC18C";
            if (sizing) {
              return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue3.minimum.toString()}${unit} ${adj}${suffix}`;
            }
            return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue3.minimum.toString()} ${adj}${suffix}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.prefix}"(\uC73C)\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4`;
            }
            if (_issue.format === "ends_with")
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.suffix}"(\uC73C)\uB85C \uB05D\uB098\uC57C \uD569\uB2C8\uB2E4`;
            if (_issue.format === "includes")
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`;
            if (_issue.format === "regex")
              return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${_issue.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`;
            return `\uC798\uBABB\uB41C ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\uC798\uBABB\uB41C \uC22B\uC790: ${issue3.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
          case "unrecognized_keys":
            return `\uC778\uC2DD\uD560 \uC218 \uC5C6\uB294 \uD0A4: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\uC798\uBABB\uB41C \uD0A4: ${issue3.origin}`;
          case "invalid_union":
            return `\uC798\uBABB\uB41C \uC785\uB825`;
          case "invalid_element":
            return `\uC798\uBABB\uB41C \uAC12: ${issue3.origin}`;
          default:
            return `\uC798\uBABB\uB41C \uC785\uB825`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/lt.cjs
var require_lt = __commonJS({
  "node_modules/zod/v4/locales/lt.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var capitalizeFirstCharacter3 = (text2) => {
      return text2.charAt(0).toUpperCase() + text2.slice(1);
    };
    function getUnitTypeFromNumber3(number5) {
      const abs = Math.abs(number5);
      const last = abs % 10;
      const last2 = abs % 100;
      if (last2 >= 11 && last2 <= 19 || last === 0)
        return "many";
      if (last === 1)
        return "one";
      return "few";
    }
    var error73 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "simbolis",
            few: "simboliai",
            many: "simboli\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi b\u016Bti ne ilgesn\u0117 kaip",
              notInclusive: "turi b\u016Bti trumpesn\u0117 kaip"
            },
            bigger: {
              inclusive: "turi b\u016Bti ne trumpesn\u0117 kaip",
              notInclusive: "turi b\u016Bti ilgesn\u0117 kaip"
            }
          }
        },
        file: {
          unit: {
            one: "baitas",
            few: "baitai",
            many: "bait\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi b\u016Bti ne didesnis kaip",
              notInclusive: "turi b\u016Bti ma\u017Eesnis kaip"
            },
            bigger: {
              inclusive: "turi b\u016Bti ne ma\u017Eesnis kaip",
              notInclusive: "turi b\u016Bti didesnis kaip"
            }
          }
        },
        array: {
          unit: {
            one: "element\u0105",
            few: "elementus",
            many: "element\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi tur\u0117ti ne daugiau kaip",
              notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
            },
            bigger: {
              inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
              notInclusive: "turi tur\u0117ti daugiau kaip"
            }
          }
        },
        set: {
          unit: {
            one: "element\u0105",
            few: "elementus",
            many: "element\u0173"
          },
          verb: {
            smaller: {
              inclusive: "turi tur\u0117ti ne daugiau kaip",
              notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
            },
            bigger: {
              inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
              notInclusive: "turi tur\u0117ti daugiau kaip"
            }
          }
        }
      };
      function getSizing(origin2, unitType, inclusive, targetShouldBe) {
        const result = Sizable[origin2] ?? null;
        if (result === null)
          return result;
        return {
          unit: result.unit[unitType],
          verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
        };
      }
      const FormatDictionary = {
        regex: "\u012Fvestis",
        email: "el. pa\u0161to adresas",
        url: "URL",
        emoji: "jaustukas",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO data ir laikas",
        date: "ISO data",
        time: "ISO laikas",
        duration: "ISO trukm\u0117",
        ipv4: "IPv4 adresas",
        ipv6: "IPv6 adresas",
        cidrv4: "IPv4 tinklo prefiksas (CIDR)",
        cidrv6: "IPv6 tinklo prefiksas (CIDR)",
        base64: "base64 u\u017Ekoduota eilut\u0117",
        base64url: "base64url u\u017Ekoduota eilut\u0117",
        json_string: "JSON eilut\u0117",
        e164: "E.164 numeris",
        jwt: "JWT",
        template_literal: "\u012Fvestis"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "skai\u010Dius",
        bigint: "sveikasis skai\u010Dius",
        string: "eilut\u0117",
        boolean: "login\u0117 reik\u0161m\u0117",
        undefined: "neapibr\u0117\u017Eta reik\u0161m\u0117",
        function: "funkcija",
        symbol: "simbolis",
        array: "masyvas",
        object: "objektas",
        null: "nulin\u0117 reik\u0161m\u0117"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Gautas tipas ${received}, o tik\u0117tasi - instanceof ${issue3.expected}`;
            }
            return `Gautas tipas ${received}, o tik\u0117tasi - ${expected}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Privalo b\u016Bti ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Privalo b\u016Bti vienas i\u0161 ${util4.joinValues(issue3.values, "|")} pasirinkim\u0173`;
          case "too_big": {
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            const sizing = getSizing(issue3.origin, getUnitTypeFromNumber3(Number(issue3.maximum)), issue3.inclusive ?? false, "smaller");
            if (sizing?.verb)
              return `${capitalizeFirstCharacter3(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue3.maximum.toString()} ${sizing.unit ?? "element\u0173"}`;
            const adj = issue3.inclusive ? "ne didesnis kaip" : "ma\u017Eesnis kaip";
            return `${capitalizeFirstCharacter3(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue3.maximum.toString()} ${sizing?.unit}`;
          }
          case "too_small": {
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            const sizing = getSizing(issue3.origin, getUnitTypeFromNumber3(Number(issue3.minimum)), issue3.inclusive ?? false, "bigger");
            if (sizing?.verb)
              return `${capitalizeFirstCharacter3(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue3.minimum.toString()} ${sizing.unit ?? "element\u0173"}`;
            const adj = issue3.inclusive ? "ne ma\u017Eesnis kaip" : "didesnis kaip";
            return `${capitalizeFirstCharacter3(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue3.minimum.toString()} ${sizing?.unit}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Eilut\u0117 privalo prasid\u0117ti "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Eilut\u0117 privalo pasibaigti "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Eilut\u0117 privalo \u012Ftraukti "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Eilut\u0117 privalo atitikti ${_issue.pattern}`;
            return `Neteisingas ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Skai\u010Dius privalo b\u016Bti ${issue3.divisor} kartotinis.`;
          case "unrecognized_keys":
            return `Neatpa\u017Eint${issue3.keys.length > 1 ? "i" : "as"} rakt${issue3.keys.length > 1 ? "ai" : "as"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return "Rastas klaidingas raktas";
          case "invalid_union":
            return "Klaidinga \u012Fvestis";
          case "invalid_element": {
            const origin2 = TypeDictionary[issue3.origin] ?? issue3.origin;
            return `${capitalizeFirstCharacter3(origin2 ?? issue3.origin ?? "reik\u0161m\u0117")} turi klaiding\u0105 \u012Fvest\u012F`;
          }
          default:
            return "Klaidinga \u012Fvestis";
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/mk.cjs
var require_mk = __commonJS({
  "node_modules/zod/v4/locales/mk.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
        file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
        array: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
        set: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0432\u043D\u0435\u0441",
        email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430",
        url: "URL",
        emoji: "\u0435\u043C\u043E\u045F\u0438",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0434\u0430\u0442\u0443\u043C \u0438 \u0432\u0440\u0435\u043C\u0435",
        date: "ISO \u0434\u0430\u0442\u0443\u043C",
        time: "ISO \u0432\u0440\u0435\u043C\u0435",
        duration: "ISO \u0432\u0440\u0435\u043C\u0435\u0442\u0440\u0430\u0435\u045A\u0435",
        ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441\u0430",
        ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441\u0430",
        cidrv4: "IPv4 \u043E\u043F\u0441\u0435\u0433",
        cidrv6: "IPv6 \u043E\u043F\u0441\u0435\u0433",
        base64: "base64-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
        base64url: "base64url-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
        json_string: "JSON \u043D\u0438\u0437\u0430",
        e164: "E.164 \u0431\u0440\u043E\u0458",
        jwt: "JWT",
        template_literal: "\u0432\u043D\u0435\u0441"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0431\u0440\u043E\u0458",
        array: "\u043D\u0438\u0437\u0430"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 instanceof ${issue3.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
            }
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Invalid input: expected ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u0413\u0440\u0435\u0448\u0430\u043D\u0430 \u043E\u043F\u0446\u0438\u0458\u0430: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 \u0435\u0434\u043D\u0430 ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0438"}`;
            return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u043D\u0443\u0432\u0430 \u0441\u043E "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u0432\u0440\u0448\u0443\u0432\u0430 \u0441\u043E "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${_issue.pattern}`;
            return `Invalid ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${issue3.divisor}`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D\u0438 \u043A\u043B\u0443\u0447\u0435\u0432\u0438" : "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D \u043A\u043B\u0443\u0447"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u043A\u043B\u0443\u0447 \u0432\u043E ${issue3.origin}`;
          case "invalid_union":
            return "\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441";
          case "invalid_element":
            return `\u0413\u0440\u0435\u0448\u043D\u0430 \u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442 \u0432\u043E ${issue3.origin}`;
          default:
            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ms.cjs
var require_ms4 = __commonJS({
  "node_modules/zod/v4/locales/ms.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "aksara", verb: "mempunyai" },
        file: { unit: "bait", verb: "mempunyai" },
        array: { unit: "elemen", verb: "mempunyai" },
        set: { unit: "elemen", verb: "mempunyai" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "alamat e-mel",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "tarikh masa ISO",
        date: "tarikh ISO",
        time: "masa ISO",
        duration: "tempoh ISO",
        ipv4: "alamat IPv4",
        ipv6: "alamat IPv6",
        cidrv4: "julat IPv4",
        cidrv6: "julat IPv6",
        base64: "string dikodkan base64",
        base64url: "string dikodkan base64url",
        json_string: "string JSON",
        e164: "nombor E.164",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "nombor"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Input tidak sah: dijangka instanceof ${issue3.expected}, diterima ${received}`;
            }
            return `Input tidak sah: dijangka ${expected}, diterima ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Input tidak sah: dijangka ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Pilihan tidak sah: dijangka salah satu daripada ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Terlalu besar: dijangka ${issue3.origin ?? "nilai"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elemen"}`;
            return `Terlalu besar: dijangka ${issue3.origin ?? "nilai"} adalah ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Terlalu kecil: dijangka ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Terlalu kecil: dijangka ${issue3.origin} adalah ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `String tidak sah: mesti bermula dengan "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `String tidak sah: mesti berakhir dengan "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `String tidak sah: mesti mengandungi "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} tidak sah`;
          }
          case "not_multiple_of":
            return `Nombor tidak sah: perlu gandaan ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Kunci tidak dikenali: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Kunci tidak sah dalam ${issue3.origin}`;
          case "invalid_union":
            return "Input tidak sah";
          case "invalid_element":
            return `Nilai tidak sah dalam ${issue3.origin}`;
          default:
            return `Input tidak sah`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/nl.cjs
var require_nl = __commonJS({
  "node_modules/zod/v4/locales/nl.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "tekens", verb: "heeft" },
        file: { unit: "bytes", verb: "heeft" },
        array: { unit: "elementen", verb: "heeft" },
        set: { unit: "elementen", verb: "heeft" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "invoer",
        email: "emailadres",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datum en tijd",
        date: "ISO datum",
        time: "ISO tijd",
        duration: "ISO duur",
        ipv4: "IPv4-adres",
        ipv6: "IPv6-adres",
        cidrv4: "IPv4-bereik",
        cidrv6: "IPv6-bereik",
        base64: "base64-gecodeerde tekst",
        base64url: "base64 URL-gecodeerde tekst",
        json_string: "JSON string",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "invoer"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "getal"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ongeldige invoer: verwacht instanceof ${issue3.expected}, ontving ${received}`;
            }
            return `Ongeldige invoer: verwacht ${expected}, ontving ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ongeldige invoer: verwacht ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Ongeldige optie: verwacht \xE9\xE9n van ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            const longName = issue3.origin === "date" ? "laat" : issue3.origin === "string" ? "lang" : "groot";
            if (sizing)
              return `Te ${longName}: verwacht dat ${issue3.origin ?? "waarde"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementen"} ${sizing.verb}`;
            return `Te ${longName}: verwacht dat ${issue3.origin ?? "waarde"} ${adj}${issue3.maximum.toString()} is`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            const shortName = issue3.origin === "date" ? "vroeg" : issue3.origin === "string" ? "kort" : "klein";
            if (sizing) {
              return `Te ${shortName}: verwacht dat ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
            }
            return `Te ${shortName}: verwacht dat ${issue3.origin} ${adj}${issue3.minimum.toString()} is`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Ongeldige tekst: moet met "${_issue.prefix}" beginnen`;
            }
            if (_issue.format === "ends_with")
              return `Ongeldige tekst: moet op "${_issue.suffix}" eindigen`;
            if (_issue.format === "includes")
              return `Ongeldige tekst: moet "${_issue.includes}" bevatten`;
            if (_issue.format === "regex")
              return `Ongeldige tekst: moet overeenkomen met patroon ${_issue.pattern}`;
            return `Ongeldig: ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ongeldig getal: moet een veelvoud van ${issue3.divisor} zijn`;
          case "unrecognized_keys":
            return `Onbekende key${issue3.keys.length > 1 ? "s" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ongeldige key in ${issue3.origin}`;
          case "invalid_union":
            return "Ongeldige invoer";
          case "invalid_element":
            return `Ongeldige waarde in ${issue3.origin}`;
          default:
            return `Ongeldige invoer`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/no.cjs
var require_no = __commonJS({
  "node_modules/zod/v4/locales/no.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "tegn", verb: "\xE5 ha" },
        file: { unit: "bytes", verb: "\xE5 ha" },
        array: { unit: "elementer", verb: "\xE5 inneholde" },
        set: { unit: "elementer", verb: "\xE5 inneholde" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "input",
        email: "e-postadresse",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO dato- og klokkeslett",
        date: "ISO-dato",
        time: "ISO-klokkeslett",
        duration: "ISO-varighet",
        ipv4: "IPv4-omr\xE5de",
        ipv6: "IPv6-omr\xE5de",
        cidrv4: "IPv4-spekter",
        cidrv6: "IPv6-spekter",
        base64: "base64-enkodet streng",
        base64url: "base64url-enkodet streng",
        json_string: "JSON-streng",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "tall",
        array: "liste"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ugyldig input: forventet instanceof ${issue3.expected}, fikk ${received}`;
            }
            return `Ugyldig input: forventet ${expected}, fikk ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ugyldig verdi: forventet ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Ugyldig valg: forventet en av ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `For stor(t): forventet ${issue3.origin ?? "value"} til \xE5 ha ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementer"}`;
            return `For stor(t): forventet ${issue3.origin ?? "value"} til \xE5 ha ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `For lite(n): forventet ${issue3.origin} til \xE5 ha ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `For lite(n): forventet ${issue3.origin} til \xE5 ha ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Ugyldig streng: m\xE5 starte med "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Ugyldig streng: m\xE5 ende med "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Ugyldig streng: m\xE5 inneholde "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${_issue.pattern}`;
            return `Ugyldig ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${issue3.divisor}`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Ukjente n\xF8kler" : "Ukjent n\xF8kkel"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ugyldig n\xF8kkel i ${issue3.origin}`;
          case "invalid_union":
            return "Ugyldig input";
          case "invalid_element":
            return `Ugyldig verdi i ${issue3.origin}`;
          default:
            return `Ugyldig input`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ota.cjs
var require_ota = __commonJS({
  "node_modules/zod/v4/locales/ota.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
        file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
        array: { unit: "unsur", verb: "olmal\u0131d\u0131r" },
        set: { unit: "unsur", verb: "olmal\u0131d\u0131r" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "giren",
        email: "epostag\xE2h",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO heng\xE2m\u0131",
        date: "ISO tarihi",
        time: "ISO zaman\u0131",
        duration: "ISO m\xFCddeti",
        ipv4: "IPv4 ni\u015F\xE2n\u0131",
        ipv6: "IPv6 ni\u015F\xE2n\u0131",
        cidrv4: "IPv4 menzili",
        cidrv6: "IPv6 menzili",
        base64: "base64-\u015Fifreli metin",
        base64url: "base64url-\u015Fifreli metin",
        json_string: "JSON metin",
        e164: "E.164 say\u0131s\u0131",
        jwt: "JWT",
        template_literal: "giren"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "numara",
        array: "saf",
        null: "gayb"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `F\xE2sit giren: umulan instanceof ${issue3.expected}, al\u0131nan ${received}`;
            }
            return `F\xE2sit giren: umulan ${expected}, al\u0131nan ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `F\xE2sit giren: umulan ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `F\xE2sit tercih: m\xFBteberler ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Fazla b\xFCy\xFCk: ${issue3.origin ?? "value"}, ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elements"} sahip olmal\u0131yd\u0131.`;
            return `Fazla b\xFCy\xFCk: ${issue3.origin ?? "value"}, ${adj}${issue3.maximum.toString()} olmal\u0131yd\u0131.`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Fazla k\xFC\xE7\xFCk: ${issue3.origin}, ${adj}${issue3.minimum.toString()} ${sizing.unit} sahip olmal\u0131yd\u0131.`;
            }
            return `Fazla k\xFC\xE7\xFCk: ${issue3.origin}, ${adj}${issue3.minimum.toString()} olmal\u0131yd\u0131.`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `F\xE2sit metin: "${_issue.prefix}" ile ba\u015Flamal\u0131.`;
            if (_issue.format === "ends_with")
              return `F\xE2sit metin: "${_issue.suffix}" ile bitmeli.`;
            if (_issue.format === "includes")
              return `F\xE2sit metin: "${_issue.includes}" ihtiv\xE2 etmeli.`;
            if (_issue.format === "regex")
              return `F\xE2sit metin: ${_issue.pattern} nak\u015F\u0131na uymal\u0131.`;
            return `F\xE2sit ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `F\xE2sit say\u0131: ${issue3.divisor} kat\u0131 olmal\u0131yd\u0131.`;
          case "unrecognized_keys":
            return `Tan\u0131nmayan anahtar ${issue3.keys.length > 1 ? "s" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} i\xE7in tan\u0131nmayan anahtar var.`;
          case "invalid_union":
            return "Giren tan\u0131namad\u0131.";
          case "invalid_element":
            return `${issue3.origin} i\xE7in tan\u0131nmayan k\u0131ymet var.`;
          default:
            return `K\u0131ymet tan\u0131namad\u0131.`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ps.cjs
var require_ps = __commonJS({
  "node_modules/zod/v4/locales/ps.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
        file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
        array: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
        set: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0648\u0631\u0648\u062F\u064A",
        email: "\u0628\u0631\u06CC\u069A\u0646\u0627\u0644\u06CC\u06A9",
        url: "\u06CC\u0648 \u0622\u0631 \u0627\u0644",
        emoji: "\u0627\u06CC\u0645\u0648\u062C\u064A",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u0646\u06CC\u067C\u0647 \u0627\u0648 \u0648\u062E\u062A",
        date: "\u0646\u06D0\u067C\u0647",
        time: "\u0648\u062E\u062A",
        duration: "\u0645\u0648\u062F\u0647",
        ipv4: "\u062F IPv4 \u067E\u062A\u0647",
        ipv6: "\u062F IPv6 \u067E\u062A\u0647",
        cidrv4: "\u062F IPv4 \u0633\u0627\u062D\u0647",
        cidrv6: "\u062F IPv6 \u0633\u0627\u062D\u0647",
        base64: "base64-encoded \u0645\u062A\u0646",
        base64url: "base64url-encoded \u0645\u062A\u0646",
        json_string: "JSON \u0645\u062A\u0646",
        e164: "\u062F E.164 \u0634\u0645\u06D0\u0631\u0647",
        jwt: "JWT",
        template_literal: "\u0648\u0631\u0648\u062F\u064A"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0639\u062F\u062F",
        array: "\u0627\u0631\u06D0"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F instanceof ${issue3.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
            }
            return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
          }
          case "invalid_value":
            if (issue3.values.length === 1) {
              return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${util4.stringifyPrimitive(issue3.values[0])} \u0648\u0627\u06CC`;
            }
            return `\u0646\u0627\u0633\u0645 \u0627\u0646\u062A\u062E\u0627\u0628: \u0628\u0627\u06CC\u062F \u06CC\u0648 \u0644\u0647 ${util4.joinValues(issue3.values, "|")} \u0685\u062E\u0647 \u0648\u0627\u06CC`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue3.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631\u0648\u0646\u0647"} \u0648\u0644\u0631\u064A`;
            }
            return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue3.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} \u0648\u064A`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} ${sizing.unit} \u0648\u0644\u0631\u064A`;
            }
            return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} \u0648\u064A`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.prefix}" \u0633\u0631\u0647 \u067E\u06CC\u0644 \u0634\u064A`;
            }
            if (_issue.format === "ends_with") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.suffix}" \u0633\u0631\u0647 \u067E\u0627\u06CC \u062A\u0647 \u0648\u0631\u0633\u064A\u0696\u064A`;
            }
            if (_issue.format === "includes") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F "${_issue.includes}" \u0648\u0644\u0631\u064A`;
            }
            if (_issue.format === "regex") {
              return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F ${_issue.pattern} \u0633\u0631\u0647 \u0645\u0637\u0627\u0628\u0642\u062A \u0648\u0644\u0631\u064A`;
            }
            return `${FormatDictionary[_issue.format] ?? issue3.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`;
          }
          case "not_multiple_of":
            return `\u0646\u0627\u0633\u0645 \u0639\u062F\u062F: \u0628\u0627\u06CC\u062F \u062F ${issue3.divisor} \u0645\u0636\u0631\u0628 \u0648\u064A`;
          case "unrecognized_keys":
            return `\u0646\u0627\u0633\u0645 ${issue3.keys.length > 1 ? "\u06A9\u0644\u06CC\u0689\u0648\u0646\u0647" : "\u06A9\u0644\u06CC\u0689"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u0646\u0627\u0633\u0645 \u06A9\u0644\u06CC\u0689 \u067E\u0647 ${issue3.origin} \u06A9\u06D0`;
          case "invalid_union":
            return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
          case "invalid_element":
            return `\u0646\u0627\u0633\u0645 \u0639\u0646\u0635\u0631 \u067E\u0647 ${issue3.origin} \u06A9\u06D0`;
          default:
            return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/pl.cjs
var require_pl = __commonJS({
  "node_modules/zod/v4/locales/pl.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "znak\xF3w", verb: "mie\u0107" },
        file: { unit: "bajt\xF3w", verb: "mie\u0107" },
        array: { unit: "element\xF3w", verb: "mie\u0107" },
        set: { unit: "element\xF3w", verb: "mie\u0107" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "wyra\u017Cenie",
        email: "adres email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data i godzina w formacie ISO",
        date: "data w formacie ISO",
        time: "godzina w formacie ISO",
        duration: "czas trwania ISO",
        ipv4: "adres IPv4",
        ipv6: "adres IPv6",
        cidrv4: "zakres IPv4",
        cidrv6: "zakres IPv6",
        base64: "ci\u0105g znak\xF3w zakodowany w formacie base64",
        base64url: "ci\u0105g znak\xF3w zakodowany w formacie base64url",
        json_string: "ci\u0105g znak\xF3w w formacie JSON",
        e164: "liczba E.164",
        jwt: "JWT",
        template_literal: "wej\u015Bcie"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "liczba",
        array: "tablica"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano instanceof ${issue3.expected}, otrzymano ${received}`;
            }
            return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${expected}, otrzymano ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Nieprawid\u0142owa opcja: oczekiwano jednej z warto\u015Bci ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Za du\u017Ca warto\u015B\u0107: oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "element\xF3w"}`;
            }
            return `Zbyt du\u017C(y/a/e): oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Za ma\u0142a warto\u015B\u0107: oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue3.minimum.toString()} ${sizing.unit ?? "element\xF3w"}`;
            }
            return `Zbyt ma\u0142(y/a/e): oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zaczyna\u0107 si\u0119 od "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi ko\u0144czy\u0107 si\u0119 na "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${_issue.pattern}`;
            return `Nieprawid\u0142ow(y/a/e) ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Nierozpoznane klucze${issue3.keys.length > 1 ? "s" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Nieprawid\u0142owy klucz w ${issue3.origin}`;
          case "invalid_union":
            return "Nieprawid\u0142owe dane wej\u015Bciowe";
          case "invalid_element":
            return `Nieprawid\u0142owa warto\u015B\u0107 w ${issue3.origin}`;
          default:
            return `Nieprawid\u0142owe dane wej\u015Bciowe`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/pt.cjs
var require_pt = __commonJS({
  "node_modules/zod/v4/locales/pt.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "caracteres", verb: "ter" },
        file: { unit: "bytes", verb: "ter" },
        array: { unit: "itens", verb: "ter" },
        set: { unit: "itens", verb: "ter" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "padr\xE3o",
        email: "endere\xE7o de e-mail",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "data e hora ISO",
        date: "data ISO",
        time: "hora ISO",
        duration: "dura\xE7\xE3o ISO",
        ipv4: "endere\xE7o IPv4",
        ipv6: "endere\xE7o IPv6",
        cidrv4: "faixa de IPv4",
        cidrv6: "faixa de IPv6",
        base64: "texto codificado em base64",
        base64url: "URL codificada em base64",
        json_string: "texto JSON",
        e164: "n\xFAmero E.164",
        jwt: "JWT",
        template_literal: "entrada"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "n\xFAmero",
        null: "nulo"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Tipo inv\xE1lido: esperado instanceof ${issue3.expected}, recebido ${received}`;
            }
            return `Tipo inv\xE1lido: esperado ${expected}, recebido ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Entrada inv\xE1lida: esperado ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Op\xE7\xE3o inv\xE1lida: esperada uma das ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Muito grande: esperado que ${issue3.origin ?? "valor"} tivesse ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementos"}`;
            return `Muito grande: esperado que ${issue3.origin ?? "valor"} fosse ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Muito pequeno: esperado que ${issue3.origin} tivesse ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Muito pequeno: esperado que ${issue3.origin} fosse ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Texto inv\xE1lido: deve come\xE7ar com "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Texto inv\xE1lido: deve terminar com "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Texto inv\xE1lido: deve incluir "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} inv\xE1lido`;
          }
          case "not_multiple_of":
            return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Chave${issue3.keys.length > 1 ? "s" : ""} desconhecida${issue3.keys.length > 1 ? "s" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Chave inv\xE1lida em ${issue3.origin}`;
          case "invalid_union":
            return "Entrada inv\xE1lida";
          case "invalid_element":
            return `Valor inv\xE1lido em ${issue3.origin}`;
          default:
            return `Campo inv\xE1lido`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ru.cjs
var require_ru = __commonJS({
  "node_modules/zod/v4/locales/ru.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    function getRussianPlural3(count, one, few, many) {
      const absCount = Math.abs(count);
      const lastDigit = absCount % 10;
      const lastTwoDigits = absCount % 100;
      if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
        return many;
      }
      if (lastDigit === 1) {
        return one;
      }
      if (lastDigit >= 2 && lastDigit <= 4) {
        return few;
      }
      return many;
    }
    var error73 = () => {
      const Sizable = {
        string: {
          unit: {
            one: "\u0441\u0438\u043C\u0432\u043E\u043B",
            few: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430",
            many: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        },
        file: {
          unit: {
            one: "\u0431\u0430\u0439\u0442",
            few: "\u0431\u0430\u0439\u0442\u0430",
            many: "\u0431\u0430\u0439\u0442"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        },
        array: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        },
        set: {
          unit: {
            one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
            few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
            many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
          },
          verb: "\u0438\u043C\u0435\u0442\u044C"
        }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0432\u0432\u043E\u0434",
        email: "email \u0430\u0434\u0440\u0435\u0441",
        url: "URL",
        emoji: "\u044D\u043C\u043E\u0434\u0437\u0438",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F",
        date: "ISO \u0434\u0430\u0442\u0430",
        time: "ISO \u0432\u0440\u0435\u043C\u044F",
        duration: "ISO \u0434\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C",
        ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
        ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
        cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
        base64: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64",
        base64url: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64url",
        json_string: "JSON \u0441\u0442\u0440\u043E\u043A\u0430",
        e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
        jwt: "JWT",
        template_literal: "\u0432\u0432\u043E\u0434"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0447\u0438\u0441\u043B\u043E",
        array: "\u043C\u0430\u0441\u0441\u0438\u0432"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C instanceof ${issue3.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
            }
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0434\u043D\u043E \u0438\u0437 ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const maxValue = Number(issue3.maximum);
              const unit = getRussianPlural3(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue3.maximum.toString()} ${unit}`;
            }
            return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              const minValue = Number(issue3.minimum);
              const unit = getRussianPlural3(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
              return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue3.minimum.toString()} ${unit}`;
            }
            return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0437\u0430\u043A\u0430\u043D\u0447\u0438\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D\u043D${issue3.keys.length > 1 ? "\u044B\u0435" : "\u044B\u0439"} \u043A\u043B\u044E\u0447${issue3.keys.length > 1 ? "\u0438" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u043A\u043B\u044E\u0447 \u0432 ${issue3.origin}`;
          case "invalid_union":
            return "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435";
          case "invalid_element":
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0432 ${issue3.origin}`;
          default:
            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/sl.cjs
var require_sl = __commonJS({
  "node_modules/zod/v4/locales/sl.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "znakov", verb: "imeti" },
        file: { unit: "bajtov", verb: "imeti" },
        array: { unit: "elementov", verb: "imeti" },
        set: { unit: "elementov", verb: "imeti" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "vnos",
        email: "e-po\u0161tni naslov",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO datum in \u010Das",
        date: "ISO datum",
        time: "ISO \u010Das",
        duration: "ISO trajanje",
        ipv4: "IPv4 naslov",
        ipv6: "IPv6 naslov",
        cidrv4: "obseg IPv4",
        cidrv6: "obseg IPv6",
        base64: "base64 kodiran niz",
        base64url: "base64url kodiran niz",
        json_string: "JSON niz",
        e164: "E.164 \u0161tevilka",
        jwt: "JWT",
        template_literal: "vnos"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0161tevilo",
        array: "tabela"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Neveljaven vnos: pri\u010Dakovano instanceof ${issue3.expected}, prejeto ${received}`;
            }
            return `Neveljaven vnos: pri\u010Dakovano ${expected}, prejeto ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Neveljaven vnos: pri\u010Dakovano ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Neveljavna mo\u017Enost: pri\u010Dakovano eno izmed ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Preveliko: pri\u010Dakovano, da bo ${issue3.origin ?? "vrednost"} imelo ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementov"}`;
            return `Preveliko: pri\u010Dakovano, da bo ${issue3.origin ?? "vrednost"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Premajhno: pri\u010Dakovano, da bo ${issue3.origin} imelo ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Premajhno: pri\u010Dakovano, da bo ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Neveljaven niz: mora se za\u010Deti z "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Neveljaven niz: mora se kon\u010Dati z "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Neveljaven niz: mora vsebovati "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`;
            return `Neveljaven ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Neprepoznan${issue3.keys.length > 1 ? "i klju\u010Di" : " klju\u010D"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Neveljaven klju\u010D v ${issue3.origin}`;
          case "invalid_union":
            return "Neveljaven vnos";
          case "invalid_element":
            return `Neveljavna vrednost v ${issue3.origin}`;
          default:
            return "Neveljaven vnos";
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/sv.cjs
var require_sv = __commonJS({
  "node_modules/zod/v4/locales/sv.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "tecken", verb: "att ha" },
        file: { unit: "bytes", verb: "att ha" },
        array: { unit: "objekt", verb: "att inneh\xE5lla" },
        set: { unit: "objekt", verb: "att inneh\xE5lla" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "regulj\xE4rt uttryck",
        email: "e-postadress",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO-datum och tid",
        date: "ISO-datum",
        time: "ISO-tid",
        duration: "ISO-varaktighet",
        ipv4: "IPv4-intervall",
        ipv6: "IPv6-intervall",
        cidrv4: "IPv4-spektrum",
        cidrv6: "IPv6-spektrum",
        base64: "base64-kodad str\xE4ng",
        base64url: "base64url-kodad str\xE4ng",
        json_string: "JSON-str\xE4ng",
        e164: "E.164-nummer",
        jwt: "JWT",
        template_literal: "mall-literal"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "antal",
        array: "lista"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ogiltig inmatning: f\xF6rv\xE4ntat instanceof ${issue3.expected}, fick ${received}`;
            }
            return `Ogiltig inmatning: f\xF6rv\xE4ntat ${expected}, fick ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ogiltig inmatning: f\xF6rv\xE4ntat ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Ogiltigt val: f\xF6rv\xE4ntade en av ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `F\xF6r stor(t): f\xF6rv\xE4ntade ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "element"}`;
            }
            return `F\xF6r stor(t): f\xF6rv\xE4ntat ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `Ogiltig str\xE4ng: m\xE5ste b\xF6rja med "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `Ogiltig str\xE4ng: m\xE5ste sluta med "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${_issue.pattern}"`;
            return `Ogiltig(t) ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ogiltigt tal: m\xE5ste vara en multipel av ${issue3.divisor}`;
          case "unrecognized_keys":
            return `${issue3.keys.length > 1 ? "Ok\xE4nda nycklar" : "Ok\xE4nd nyckel"}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Ogiltig nyckel i ${issue3.origin ?? "v\xE4rdet"}`;
          case "invalid_union":
            return "Ogiltig input";
          case "invalid_element":
            return `Ogiltigt v\xE4rde i ${issue3.origin ?? "v\xE4rdet"}`;
          default:
            return `Ogiltig input`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ta.cjs
var require_ta = __commonJS({
  "node_modules/zod/v4/locales/ta.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
        file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
        array: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
        set: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1",
        email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u0BA4\u0BC7\u0BA4\u0BBF \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
        date: "ISO \u0BA4\u0BC7\u0BA4\u0BBF",
        time: "ISO \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
        duration: "ISO \u0B95\u0BBE\u0BB2 \u0B85\u0BB3\u0BB5\u0BC1",
        ipv4: "IPv4 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
        ipv6: "IPv6 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
        cidrv4: "IPv4 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
        cidrv6: "IPv6 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
        base64: "base64-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
        base64url: "base64url-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
        json_string: "JSON \u0B9A\u0BB0\u0BAE\u0BCD",
        e164: "E.164 \u0B8E\u0BA3\u0BCD",
        jwt: "JWT",
        template_literal: "input"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0B8E\u0BA3\u0BCD",
        array: "\u0B85\u0BA3\u0BBF",
        null: "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 instanceof ${issue3.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
            }
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0BB0\u0BC1\u0BAA\u0BCD\u0BAA\u0BAE\u0BCD: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${util4.joinValues(issue3.values, "|")} \u0B87\u0BB2\u0BCD \u0B92\u0BA9\u0BCD\u0BB1\u0BC1`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD"} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            }
            return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue3.maximum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            }
            return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin} ${adj}${issue3.minimum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.prefix}" \u0B87\u0BB2\u0BCD \u0BA4\u0BCA\u0B9F\u0B99\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            if (_issue.format === "ends_with")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.suffix}" \u0B87\u0BB2\u0BCD \u0BAE\u0BC1\u0B9F\u0BBF\u0BB5\u0B9F\u0BC8\u0BAF \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            if (_issue.format === "includes")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            if (_issue.format === "regex")
              return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${_issue.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${issue3.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
          case "unrecognized_keys":
            return `\u0B85\u0B9F\u0BC8\u0BAF\u0BBE\u0BB3\u0BAE\u0BCD \u0BA4\u0BC6\u0BB0\u0BBF\u0BAF\u0BBE\u0BA4 \u0BB5\u0BBF\u0B9A\u0BC8${issue3.keys.length > 1 ? "\u0B95\u0BB3\u0BCD" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0B9A\u0BC8`;
          case "invalid_union":
            return "\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1";
          case "invalid_element":
            return `${issue3.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1`;
          default:
            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/th.cjs
var require_th = __commonJS({
  "node_modules/zod/v4/locales/th.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
        file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
        array: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
        set: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19",
        email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25",
        url: "URL",
        emoji: "\u0E2D\u0E34\u0E42\u0E21\u0E08\u0E34",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
        date: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E41\u0E1A\u0E1A ISO",
        time: "\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
        duration: "\u0E0A\u0E48\u0E27\u0E07\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
        ipv4: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv4",
        ipv6: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv6",
        cidrv4: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv4",
        cidrv6: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv6",
        base64: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64",
        base64url: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64 \u0E2A\u0E33\u0E2B\u0E23\u0E31\u0E1A URL",
        json_string: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A JSON",
        e164: "\u0E40\u0E1A\u0E2D\u0E23\u0E4C\u0E42\u0E17\u0E23\u0E28\u0E31\u0E1E\u0E17\u0E4C\u0E23\u0E30\u0E2B\u0E27\u0E48\u0E32\u0E07\u0E1B\u0E23\u0E30\u0E40\u0E17\u0E28 (E.164)",
        jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT",
        template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02",
        array: "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)",
        null: "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 instanceof ${issue3.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
            }
            return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19\u0E2B\u0E19\u0E36\u0E48\u0E07\u0E43\u0E19 ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19" : "\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23"}`;
            return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22" : "\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E02\u0E36\u0E49\u0E19\u0E15\u0E49\u0E19\u0E14\u0E49\u0E27\u0E22 "${_issue.prefix}"`;
            }
            if (_issue.format === "ends_with")
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E25\u0E07\u0E17\u0E49\u0E32\u0E22\u0E14\u0E49\u0E27\u0E22 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${_issue.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`;
            if (_issue.format === "regex")
              return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${_issue.pattern}`;
            return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${issue3.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`;
          case "unrecognized_keys":
            return `\u0E1E\u0E1A\u0E04\u0E35\u0E22\u0E4C\u0E17\u0E35\u0E48\u0E44\u0E21\u0E48\u0E23\u0E39\u0E49\u0E08\u0E31\u0E01: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u0E04\u0E35\u0E22\u0E4C\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue3.origin}`;
          case "invalid_union":
            return "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E44\u0E21\u0E48\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E22\u0E39\u0E40\u0E19\u0E35\u0E22\u0E19\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14\u0E44\u0E27\u0E49";
          case "invalid_element":
            return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue3.origin}`;
          default:
            return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/tr.cjs
var require_tr = __commonJS({
  "node_modules/zod/v4/locales/tr.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "karakter", verb: "olmal\u0131" },
        file: { unit: "bayt", verb: "olmal\u0131" },
        array: { unit: "\xF6\u011Fe", verb: "olmal\u0131" },
        set: { unit: "\xF6\u011Fe", verb: "olmal\u0131" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "girdi",
        email: "e-posta adresi",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO tarih ve saat",
        date: "ISO tarih",
        time: "ISO saat",
        duration: "ISO s\xFCre",
        ipv4: "IPv4 adresi",
        ipv6: "IPv6 adresi",
        cidrv4: "IPv4 aral\u0131\u011F\u0131",
        cidrv6: "IPv6 aral\u0131\u011F\u0131",
        base64: "base64 ile \u015Fifrelenmi\u015F metin",
        base64url: "base64url ile \u015Fifrelenmi\u015F metin",
        json_string: "JSON dizesi",
        e164: "E.164 say\u0131s\u0131",
        jwt: "JWT",
        template_literal: "\u015Eablon dizesi"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Ge\xE7ersiz de\u011Fer: beklenen instanceof ${issue3.expected}, al\u0131nan ${received}`;
            }
            return `Ge\xE7ersiz de\u011Fer: beklenen ${expected}, al\u0131nan ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Ge\xE7ersiz de\u011Fer: beklenen ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Ge\xE7ersiz se\xE7enek: a\u015Fa\u011F\u0131dakilerden biri olmal\u0131: ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\xC7ok b\xFCy\xFCk: beklenen ${issue3.origin ?? "de\u011Fer"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\xF6\u011Fe"}`;
            return `\xC7ok b\xFCy\xFCk: beklenen ${issue3.origin ?? "de\u011Fer"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Ge\xE7ersiz metin: "${_issue.prefix}" ile ba\u015Flamal\u0131`;
            if (_issue.format === "ends_with")
              return `Ge\xE7ersiz metin: "${_issue.suffix}" ile bitmeli`;
            if (_issue.format === "includes")
              return `Ge\xE7ersiz metin: "${_issue.includes}" i\xE7ermeli`;
            if (_issue.format === "regex")
              return `Ge\xE7ersiz metin: ${_issue.pattern} desenine uymal\u0131`;
            return `Ge\xE7ersiz ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Ge\xE7ersiz say\u0131: ${issue3.divisor} ile tam b\xF6l\xFCnebilmeli`;
          case "unrecognized_keys":
            return `Tan\u0131nmayan anahtar${issue3.keys.length > 1 ? "lar" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} i\xE7inde ge\xE7ersiz anahtar`;
          case "invalid_union":
            return "Ge\xE7ersiz de\u011Fer";
          case "invalid_element":
            return `${issue3.origin} i\xE7inde ge\xE7ersiz de\u011Fer`;
          default:
            return `Ge\xE7ersiz de\u011Fer`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/uk.cjs
var require_uk = __commonJS({
  "node_modules/zod/v4/locales/uk.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
        file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
        array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
        set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456",
        email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438",
        url: "URL",
        emoji: "\u0435\u043C\u043E\u0434\u0437\u0456",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\u0434\u0430\u0442\u0430 \u0442\u0430 \u0447\u0430\u0441 ISO",
        date: "\u0434\u0430\u0442\u0430 ISO",
        time: "\u0447\u0430\u0441 ISO",
        duration: "\u0442\u0440\u0438\u0432\u0430\u043B\u0456\u0441\u0442\u044C ISO",
        ipv4: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv4",
        ipv6: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv6",
        cidrv4: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv4",
        cidrv6: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv6",
        base64: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64",
        base64url: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64url",
        json_string: "\u0440\u044F\u0434\u043E\u043A JSON",
        e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
        jwt: "JWT",
        template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0447\u0438\u0441\u043B\u043E",
        array: "\u043C\u0430\u0441\u0438\u0432"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F instanceof ${issue3.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
            }
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0430 \u043E\u043F\u0446\u0456\u044F: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F \u043E\u0434\u043D\u0435 \u0437 ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432"}`;
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} \u0431\u0443\u0434\u0435 ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin} \u0431\u0443\u0434\u0435 ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043F\u043E\u0447\u0438\u043D\u0430\u0442\u0438\u0441\u044F \u0437 "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0437\u0430\u043A\u0456\u043D\u0447\u0443\u0432\u0430\u0442\u0438\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${issue3.divisor}`;
          case "unrecognized_keys":
            return `\u041D\u0435\u0440\u043E\u0437\u043F\u0456\u0437\u043D\u0430\u043D\u0438\u0439 \u043A\u043B\u044E\u0447${issue3.keys.length > 1 ? "\u0456" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u043A\u043B\u044E\u0447 \u0443 ${issue3.origin}`;
          case "invalid_union":
            return "\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456";
          case "invalid_element":
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F \u0443 ${issue3.origin}`;
          default:
            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ua.cjs
var require_ua = __commonJS({
  "node_modules/zod/v4/locales/ua.cjs"(exports2, module2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var uk_js_1 = __importDefault(require_uk());
    function default_1() {
      return (0, uk_js_1.default)();
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/ur.cjs
var require_ur = __commonJS({
  "node_modules/zod/v4/locales/ur.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
        file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
        array: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" },
        set: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0627\u0646 \u067E\u0679",
        email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633",
        url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644",
        emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
        uuid: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        uuidv4: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 4",
        uuidv6: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 6",
        nanoid: "\u0646\u06CC\u0646\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        guid: "\u062C\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        cuid: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        cuid2: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC 2",
        ulid: "\u06CC\u0648 \u0627\u06CC\u0644 \u0622\u0626\u06CC \u0688\u06CC",
        xid: "\u0627\u06CC\u06A9\u0633 \u0622\u0626\u06CC \u0688\u06CC",
        ksuid: "\u06A9\u06D2 \u0627\u06CC\u0633 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
        datetime: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0688\u06CC\u0679 \u0679\u0627\u0626\u0645",
        date: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u062A\u0627\u0631\u06CC\u062E",
        time: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0648\u0642\u062A",
        duration: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0645\u062F\u062A",
        ipv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0627\u06CC\u0688\u0631\u06CC\u0633",
        ipv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0627\u06CC\u0688\u0631\u06CC\u0633",
        cidrv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0631\u06CC\u0646\u062C",
        cidrv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0631\u06CC\u0646\u062C",
        base64: "\u0628\u06CC\u0633 64 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
        base64url: "\u0628\u06CC\u0633 64 \u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
        json_string: "\u062C\u06D2 \u0627\u06CC\u0633 \u0627\u0648 \u0627\u06CC\u0646 \u0633\u0679\u0631\u0646\u06AF",
        e164: "\u0627\u06CC 164 \u0646\u0645\u0628\u0631",
        jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC",
        template_literal: "\u0627\u0646 \u067E\u0679"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u0646\u0645\u0628\u0631",
        array: "\u0622\u0631\u06D2",
        null: "\u0646\u0644"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: instanceof ${issue3.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
            }
            return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${util4.stringifyPrimitive(issue3.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
            return `\u063A\u0644\u0637 \u0622\u067E\u0634\u0646: ${util4.joinValues(issue3.values, "|")} \u0645\u06CC\u06BA \u0633\u06D2 \u0627\u06CC\u06A9 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue3.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u06D2 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0627\u0635\u0631"} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
            return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue3.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u0627 ${adj}${issue3.maximum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue3.origin} \u06A9\u06D2 ${adj}${issue3.minimum.toString()} ${sizing.unit} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
            }
            return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue3.origin} \u06A9\u0627 ${adj}${issue3.minimum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.prefix}" \u0633\u06D2 \u0634\u0631\u0648\u0639 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            }
            if (_issue.format === "ends_with")
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.suffix}" \u067E\u0631 \u062E\u062A\u0645 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            if (_issue.format === "includes")
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            if (_issue.format === "regex")
              return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${_issue.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
            return `\u063A\u0644\u0637 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${issue3.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
          case "unrecognized_keys":
            return `\u063A\u06CC\u0631 \u062A\u0633\u0644\u06CC\u0645 \u0634\u062F\u06C1 \u06A9\u06CC${issue3.keys.length > 1 ? "\u0632" : ""}: ${util4.joinValues(issue3.keys, "\u060C ")}`;
          case "invalid_key":
            return `${issue3.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u06A9\u06CC`;
          case "invalid_union":
            return "\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679";
          case "invalid_element":
            return `${issue3.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u0648\u06CC\u0644\u06CC\u0648`;
          default:
            return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/uz.cjs
var require_uz = __commonJS({
  "node_modules/zod/v4/locales/uz.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
        file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
        array: { unit: "element", verb: "bo\u2018lishi kerak" },
        set: { unit: "element", verb: "bo\u2018lishi kerak" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "kirish",
        email: "elektron pochta manzili",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO sana va vaqti",
        date: "ISO sana",
        time: "ISO vaqt",
        duration: "ISO davomiylik",
        ipv4: "IPv4 manzil",
        ipv6: "IPv6 manzil",
        mac: "MAC manzil",
        cidrv4: "IPv4 diapazon",
        cidrv6: "IPv6 diapazon",
        base64: "base64 kodlangan satr",
        base64url: "base64url kodlangan satr",
        json_string: "JSON satr",
        e164: "E.164 raqam",
        jwt: "JWT",
        template_literal: "kirish"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "raqam",
        array: "massiv"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `Noto\u2018g\u2018ri kirish: kutilgan instanceof ${issue3.expected}, qabul qilingan ${received}`;
            }
            return `Noto\u2018g\u2018ri kirish: kutilgan ${expected}, qabul qilingan ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `Noto\u2018g\u2018ri kirish: kutilgan ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `Noto\u2018g\u2018ri variant: quyidagilardan biri kutilgan ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Juda katta: kutilgan ${issue3.origin ?? "qiymat"} ${adj}${issue3.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
            return `Juda katta: kutilgan ${issue3.origin ?? "qiymat"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Juda kichik: kutilgan ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
            }
            return `Juda kichik: kutilgan ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Noto\u2018g\u2018ri satr: "${_issue.prefix}" bilan boshlanishi kerak`;
            if (_issue.format === "ends_with")
              return `Noto\u2018g\u2018ri satr: "${_issue.suffix}" bilan tugashi kerak`;
            if (_issue.format === "includes")
              return `Noto\u2018g\u2018ri satr: "${_issue.includes}" ni o\u2018z ichiga olishi kerak`;
            if (_issue.format === "regex")
              return `Noto\u2018g\u2018ri satr: ${_issue.pattern} shabloniga mos kelishi kerak`;
            return `Noto\u2018g\u2018ri ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `Noto\u2018g\u2018ri raqam: ${issue3.divisor} ning karralisi bo\u2018lishi kerak`;
          case "unrecognized_keys":
            return `Noma\u2019lum kalit${issue3.keys.length > 1 ? "lar" : ""}: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} dagi kalit noto\u2018g\u2018ri`;
          case "invalid_union":
            return "Noto\u2018g\u2018ri kirish";
          case "invalid_element":
            return `${issue3.origin} da noto\u2018g\u2018ri qiymat`;
          default:
            return `Noto\u2018g\u2018ri kirish`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/vi.cjs
var require_vi = __commonJS({
  "node_modules/zod/v4/locales/vi.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
        file: { unit: "byte", verb: "c\xF3" },
        array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" },
        set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u0111\u1EA7u v\xE0o",
        email: "\u0111\u1ECBa ch\u1EC9 email",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ng\xE0y gi\u1EDD ISO",
        date: "ng\xE0y ISO",
        time: "gi\u1EDD ISO",
        duration: "kho\u1EA3ng th\u1EDDi gian ISO",
        ipv4: "\u0111\u1ECBa ch\u1EC9 IPv4",
        ipv6: "\u0111\u1ECBa ch\u1EC9 IPv6",
        cidrv4: "d\u1EA3i IPv4",
        cidrv6: "d\u1EA3i IPv6",
        base64: "chu\u1ED7i m\xE3 h\xF3a base64",
        base64url: "chu\u1ED7i m\xE3 h\xF3a base64url",
        json_string: "chu\u1ED7i JSON",
        e164: "s\u1ED1 E.164",
        jwt: "JWT",
        template_literal: "\u0111\u1EA7u v\xE0o"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "s\u1ED1",
        array: "m\u1EA3ng"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i instanceof ${issue3.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
            }
            return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `T\xF9y ch\u1ECDn kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i m\u1ED9t trong c\xE1c gi\xE1 tr\u1ECB ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue3.origin ?? "gi\xE1 tr\u1ECB"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "ph\u1EA7n t\u1EED"}`;
            return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue3.origin ?? "gi\xE1 tr\u1ECB"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i k\u1EBFt th\xFAc b\u1EB1ng "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${_issue.pattern}`;
            return `${FormatDictionary[_issue.format] ?? issue3.format} kh\xF4ng h\u1EE3p l\u1EC7`;
          }
          case "not_multiple_of":
            return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${issue3.divisor}`;
          case "unrecognized_keys":
            return `Kh\xF3a kh\xF4ng \u0111\u01B0\u1EE3c nh\u1EADn d\u1EA1ng: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `Kh\xF3a kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue3.origin}`;
          case "invalid_union":
            return "\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7";
          case "invalid_element":
            return `Gi\xE1 tr\u1ECB kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue3.origin}`;
          default:
            return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/zh-CN.cjs
var require_zh_CN = __commonJS({
  "node_modules/zod/v4/locales/zh-CN.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
        file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
        array: { unit: "\u9879", verb: "\u5305\u542B" },
        set: { unit: "\u9879", verb: "\u5305\u542B" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u8F93\u5165",
        email: "\u7535\u5B50\u90AE\u4EF6",
        url: "URL",
        emoji: "\u8868\u60C5\u7B26\u53F7",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO\u65E5\u671F\u65F6\u95F4",
        date: "ISO\u65E5\u671F",
        time: "ISO\u65F6\u95F4",
        duration: "ISO\u65F6\u957F",
        ipv4: "IPv4\u5730\u5740",
        ipv6: "IPv6\u5730\u5740",
        cidrv4: "IPv4\u7F51\u6BB5",
        cidrv6: "IPv6\u7F51\u6BB5",
        base64: "base64\u7F16\u7801\u5B57\u7B26\u4E32",
        base64url: "base64url\u7F16\u7801\u5B57\u7B26\u4E32",
        json_string: "JSON\u5B57\u7B26\u4E32",
        e164: "E.164\u53F7\u7801",
        jwt: "JWT",
        template_literal: "\u8F93\u5165"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "\u6570\u5B57",
        array: "\u6570\u7EC4",
        null: "\u7A7A\u503C(null)"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B instanceof ${issue3.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
            }
            return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u65E0\u6548\u9009\u9879\uFF1A\u671F\u671B\u4EE5\u4E0B\u4E4B\u4E00 ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue3.origin ?? "\u503C"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u4E2A\u5143\u7D20"}`;
            return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue3.origin ?? "\u503C"} ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.prefix}" \u5F00\u5934`;
            if (_issue.format === "ends_with")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.suffix}" \u7ED3\u5C3E`;
            if (_issue.format === "includes")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${_issue.pattern}`;
            return `\u65E0\u6548${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${issue3.divisor} \u7684\u500D\u6570`;
          case "unrecognized_keys":
            return `\u51FA\u73B0\u672A\u77E5\u7684\u952E(key): ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `${issue3.origin} \u4E2D\u7684\u952E(key)\u65E0\u6548`;
          case "invalid_union":
            return "\u65E0\u6548\u8F93\u5165";
          case "invalid_element":
            return `${issue3.origin} \u4E2D\u5305\u542B\u65E0\u6548\u503C(value)`;
          default:
            return `\u65E0\u6548\u8F93\u5165`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/zh-TW.cjs
var require_zh_TW = __commonJS({
  "node_modules/zod/v4/locales/zh-TW.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
        file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
        array: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" },
        set: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u8F38\u5165",
        email: "\u90F5\u4EF6\u5730\u5740",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "ISO \u65E5\u671F\u6642\u9593",
        date: "ISO \u65E5\u671F",
        time: "ISO \u6642\u9593",
        duration: "ISO \u671F\u9593",
        ipv4: "IPv4 \u4F4D\u5740",
        ipv6: "IPv6 \u4F4D\u5740",
        cidrv4: "IPv4 \u7BC4\u570D",
        cidrv6: "IPv6 \u7BC4\u570D",
        base64: "base64 \u7DE8\u78BC\u5B57\u4E32",
        base64url: "base64url \u7DE8\u78BC\u5B57\u4E32",
        json_string: "JSON \u5B57\u4E32",
        e164: "E.164 \u6578\u503C",
        jwt: "JWT",
        template_literal: "\u8F38\u5165"
      };
      const TypeDictionary = {
        nan: "NaN"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA instanceof ${issue3.expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
            }
            return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\u7121\u6548\u7684\u9078\u9805\uFF1A\u9810\u671F\u70BA\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00 ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue3.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u500B\u5143\u7D20"}`;
            return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue3.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue3.maximum.toString()}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing) {
              return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue3.origin} \u61C9\u70BA ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
            }
            return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue3.origin} \u61C9\u70BA ${adj}${issue3.minimum.toString()}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with") {
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.prefix}" \u958B\u982D`;
            }
            if (_issue.format === "ends_with")
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.suffix}" \u7D50\u5C3E`;
            if (_issue.format === "includes")
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${_issue.pattern}`;
            return `\u7121\u6548\u7684 ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${issue3.divisor} \u7684\u500D\u6578`;
          case "unrecognized_keys":
            return `\u7121\u6CD5\u8B58\u5225\u7684\u9375\u503C${issue3.keys.length > 1 ? "\u5011" : ""}\uFF1A${util4.joinValues(issue3.keys, "\u3001")}`;
          case "invalid_key":
            return `${issue3.origin} \u4E2D\u6709\u7121\u6548\u7684\u9375\u503C`;
          case "invalid_union":
            return "\u7121\u6548\u7684\u8F38\u5165\u503C";
          case "invalid_element":
            return `${issue3.origin} \u4E2D\u6709\u7121\u6548\u7684\u503C`;
          default:
            return `\u7121\u6548\u7684\u8F38\u5165\u503C`;
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/yo.cjs
var require_yo = __commonJS({
  "node_modules/zod/v4/locales/yo.cjs"(exports2, module2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = default_1;
    var util4 = __importStar(require_util4());
    var error73 = () => {
      const Sizable = {
        string: { unit: "\xE0mi", verb: "n\xED" },
        file: { unit: "bytes", verb: "n\xED" },
        array: { unit: "nkan", verb: "n\xED" },
        set: { unit: "nkan", verb: "n\xED" }
      };
      function getSizing(origin2) {
        return Sizable[origin2] ?? null;
      }
      const FormatDictionary = {
        regex: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9",
        email: "\xE0d\xEDr\u1EB9\u0301s\xEC \xECm\u1EB9\u0301l\xEC",
        url: "URL",
        emoji: "emoji",
        uuid: "UUID",
        uuidv4: "UUIDv4",
        uuidv6: "UUIDv6",
        nanoid: "nanoid",
        guid: "GUID",
        cuid: "cuid",
        cuid2: "cuid2",
        ulid: "ULID",
        xid: "XID",
        ksuid: "KSUID",
        datetime: "\xE0k\xF3k\xF2 ISO",
        date: "\u1ECDj\u1ECD\u0301 ISO",
        time: "\xE0k\xF3k\xF2 ISO",
        duration: "\xE0k\xF3k\xF2 t\xF3 p\xE9 ISO",
        ipv4: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv4",
        ipv6: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv6",
        cidrv4: "\xE0gb\xE8gb\xE8 IPv4",
        cidrv6: "\xE0gb\xE8gb\xE8 IPv6",
        base64: "\u1ECD\u0300r\u1ECD\u0300 t\xED a k\u1ECD\u0301 n\xED base64",
        base64url: "\u1ECD\u0300r\u1ECD\u0300 base64url",
        json_string: "\u1ECD\u0300r\u1ECD\u0300 JSON",
        e164: "n\u1ECD\u0301mb\xE0 E.164",
        jwt: "JWT",
        template_literal: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9"
      };
      const TypeDictionary = {
        nan: "NaN",
        number: "n\u1ECD\u0301mb\xE0",
        array: "akop\u1ECD"
      };
      return (issue3) => {
        switch (issue3.code) {
          case "invalid_type": {
            const expected = TypeDictionary[issue3.expected] ?? issue3.expected;
            const receivedType = util4.parsedType(issue3.input);
            const received = TypeDictionary[receivedType] ?? receivedType;
            if (/^[A-Z]/.test(issue3.expected)) {
              return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi instanceof ${issue3.expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
            }
            return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
          }
          case "invalid_value":
            if (issue3.values.length === 1)
              return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${util4.stringifyPrimitive(issue3.values[0])}`;
            return `\xC0\u1E63\xE0y\xE0n a\u1E63\xEC\u1E63e: yan \u1ECD\u0300kan l\xE1ra ${util4.joinValues(issue3.values, "|")}`;
          case "too_big": {
            const adj = issue3.inclusive ? "<=" : "<";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue3.origin ?? "iye"} ${sizing.verb} ${adj}${issue3.maximum} ${sizing.unit}`;
            return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue3.maximum}`;
          }
          case "too_small": {
            const adj = issue3.inclusive ? ">=" : ">";
            const sizing = getSizing(issue3.origin);
            if (sizing)
              return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum} ${sizing.unit}`;
            return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue3.minimum}`;
          }
          case "invalid_format": {
            const _issue = issue3;
            if (_issue.format === "starts_with")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\u1EB9\u0300r\u1EB9\u0300 p\u1EB9\u0300l\xFA "${_issue.prefix}"`;
            if (_issue.format === "ends_with")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 par\xED p\u1EB9\u0300l\xFA "${_issue.suffix}"`;
            if (_issue.format === "includes")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 n\xED "${_issue.includes}"`;
            if (_issue.format === "regex")
              return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\xE1 \xE0p\u1EB9\u1EB9r\u1EB9 mu ${_issue.pattern}`;
            return `A\u1E63\xEC\u1E63e: ${FormatDictionary[_issue.format] ?? issue3.format}`;
          }
          case "not_multiple_of":
            return `N\u1ECD\u0301mb\xE0 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 j\u1EB9\u0301 \xE8y\xE0 p\xEDp\xEDn ti ${issue3.divisor}`;
          case "unrecognized_keys":
            return `B\u1ECDt\xECn\xEC \xE0\xECm\u1ECD\u0300: ${util4.joinValues(issue3.keys, ", ")}`;
          case "invalid_key":
            return `B\u1ECDt\xECn\xEC a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue3.origin}`;
          case "invalid_union":
            return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
          case "invalid_element":
            return `Iye a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue3.origin}`;
          default:
            return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
        }
      };
    };
    function default_1() {
      return {
        localeError: error73()
      };
    }
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v4/locales/index.cjs
var require_locales = __commonJS({
  "node_modules/zod/v4/locales/index.cjs"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.yo = exports2.zhTW = exports2.zhCN = exports2.vi = exports2.uz = exports2.ur = exports2.uk = exports2.ua = exports2.tr = exports2.th = exports2.ta = exports2.sv = exports2.sl = exports2.ru = exports2.pt = exports2.pl = exports2.ps = exports2.ota = exports2.no = exports2.nl = exports2.ms = exports2.mk = exports2.lt = exports2.ko = exports2.km = exports2.kh = exports2.ka = exports2.ja = exports2.it = exports2.is = exports2.id = exports2.hy = exports2.hu = exports2.he = exports2.frCA = exports2.fr = exports2.fi = exports2.fa = exports2.es = exports2.eo = exports2.en = exports2.de = exports2.da = exports2.cs = exports2.ca = exports2.bg = exports2.be = exports2.az = exports2.ar = void 0;
    var ar_js_1 = require_ar();
    Object.defineProperty(exports2, "ar", { enumerable: true, get: function() {
      return __importDefault(ar_js_1).default;
    } });
    var az_js_1 = require_az();
    Object.defineProperty(exports2, "az", { enumerable: true, get: function() {
      return __importDefault(az_js_1).default;
    } });
    var be_js_1 = require_be();
    Object.defineProperty(exports2, "be", { enumerable: true, get: function() {
      return __importDefault(be_js_1).default;
    } });
    var bg_js_1 = require_bg();
    Object.defineProperty(exports2, "bg", { enumerable: true, get: function() {
      return __importDefault(bg_js_1).default;
    } });
    var ca_js_1 = require_ca();
    Object.defineProperty(exports2, "ca", { enumerable: true, get: function() {
      return __importDefault(ca_js_1).default;
    } });
    var cs_js_1 = require_cs();
    Object.defineProperty(exports2, "cs", { enumerable: true, get: function() {
      return __importDefault(cs_js_1).default;
    } });
    var da_js_1 = require_da();
    Object.defineProperty(exports2, "da", { enumerable: true, get: function() {
      return __importDefault(da_js_1).default;
    } });
    var de_js_1 = require_de();
    Object.defineProperty(exports2, "de", { enumerable: true, get: function() {
      return __importDefault(de_js_1).default;
    } });
    var en_js_1 = require_en();
    Object.defineProperty(exports2, "en", { enumerable: true, get: function() {
      return __importDefault(en_js_1).default;
    } });
    var eo_js_1 = require_eo();
    Object.defineProperty(exports2, "eo", { enumerable: true, get: function() {
      return __importDefault(eo_js_1).default;
    } });
    var es_js_1 = require_es();
    Object.defineProperty(exports2, "es", { enumerable: true, get: function() {
      return __importDefault(es_js_1).default;
    } });
    var fa_js_1 = require_fa();
    Object.defineProperty(exports2, "fa", { enumerable: true, get: function() {
      return __importDefault(fa_js_1).default;
    } });
    var fi_js_1 = require_fi();
    Object.defineProperty(exports2, "fi", { enumerable: true, get: function() {
      return __importDefault(fi_js_1).default;
    } });
    var fr_js_1 = require_fr();
    Object.defineProperty(exports2, "fr", { enumerable: true, get: function() {
      return __importDefault(fr_js_1).default;
    } });
    var fr_CA_js_1 = require_fr_CA();
    Object.defineProperty(exports2, "frCA", { enumerable: true, get: function() {
      return __importDefault(fr_CA_js_1).default;
    } });
    var he_js_1 = require_he();
    Object.defineProperty(exports2, "he", { enumerable: true, get: function() {
      return __importDefault(he_js_1).default;
    } });
    var hu_js_1 = require_hu();
    Object.defineProperty(exports2, "hu", { enumerable: true, get: function() {
      return __importDefault(hu_js_1).default;
    } });
    var hy_js_1 = require_hy();
    Object.defineProperty(exports2, "hy", { enumerable: true, get: function() {
      return __importDefault(hy_js_1).default;
    } });
    var id_js_1 = require_id();
    Object.defineProperty(exports2, "id", { enumerable: true, get: function() {
      return __importDefault(id_js_1).default;
    } });
    var is_js_1 = require_is2();
    Object.defineProperty(exports2, "is", { enumerable: true, get: function() {
      return __importDefault(is_js_1).default;
    } });
    var it_js_1 = require_it();
    Object.defineProperty(exports2, "it", { enumerable: true, get: function() {
      return __importDefault(it_js_1).default;
    } });
    var ja_js_1 = require_ja();
    Object.defineProperty(exports2, "ja", { enumerable: true, get: function() {
      return __importDefault(ja_js_1).default;
    } });
    var ka_js_1 = require_ka();
    Object.defineProperty(exports2, "ka", { enumerable: true, get: function() {
      return __importDefault(ka_js_1).default;
    } });
    var kh_js_1 = require_kh();
    Object.defineProperty(exports2, "kh", { enumerable: true, get: function() {
      return __importDefault(kh_js_1).default;
    } });
    var km_js_1 = require_km();
    Object.defineProperty(exports2, "km", { enumerable: true, get: function() {
      return __importDefault(km_js_1).default;
    } });
    var ko_js_1 = require_ko();
    Object.defineProperty(exports2, "ko", { enumerable: true, get: function() {
      return __importDefault(ko_js_1).default;
    } });
    var lt_js_1 = require_lt();
    Object.defineProperty(exports2, "lt", { enumerable: true, get: function() {
      return __importDefault(lt_js_1).default;
    } });
    var mk_js_1 = require_mk();
    Object.defineProperty(exports2, "mk", { enumerable: true, get: function() {
      return __importDefault(mk_js_1).default;
    } });
    var ms_js_1 = require_ms4();
    Object.defineProperty(exports2, "ms", { enumerable: true, get: function() {
      return __importDefault(ms_js_1).default;
    } });
    var nl_js_1 = require_nl();
    Object.defineProperty(exports2, "nl", { enumerable: true, get: function() {
      return __importDefault(nl_js_1).default;
    } });
    var no_js_1 = require_no();
    Object.defineProperty(exports2, "no", { enumerable: true, get: function() {
      return __importDefault(no_js_1).default;
    } });
    var ota_js_1 = require_ota();
    Object.defineProperty(exports2, "ota", { enumerable: true, get: function() {
      return __importDefault(ota_js_1).default;
    } });
    var ps_js_1 = require_ps();
    Object.defineProperty(exports2, "ps", { enumerable: true, get: function() {
      return __importDefault(ps_js_1).default;
    } });
    var pl_js_1 = require_pl();
    Object.defineProperty(exports2, "pl", { enumerable: true, get: function() {
      return __importDefault(pl_js_1).default;
    } });
    var pt_js_1 = require_pt();
    Object.defineProperty(exports2, "pt", { enumerable: true, get: function() {
      return __importDefault(pt_js_1).default;
    } });
    var ru_js_1 = require_ru();
    Object.defineProperty(exports2, "ru", { enumerable: true, get: function() {
      return __importDefault(ru_js_1).default;
    } });
    var sl_js_1 = require_sl();
    Object.defineProperty(exports2, "sl", { enumerable: true, get: function() {
      return __importDefault(sl_js_1).default;
    } });
    var sv_js_1 = require_sv();
    Object.defineProperty(exports2, "sv", { enumerable: true, get: function() {
      return __importDefault(sv_js_1).default;
    } });
    var ta_js_1 = require_ta();
    Object.defineProperty(exports2, "ta", { enumerable: true, get: function() {
      return __importDefault(ta_js_1).default;
    } });
    var th_js_1 = require_th();
    Object.defineProperty(exports2, "th", { enumerable: true, get: function() {
      return __importDefault(th_js_1).default;
    } });
    var tr_js_1 = require_tr();
    Object.defineProperty(exports2, "tr", { enumerable: true, get: function() {
      return __importDefault(tr_js_1).default;
    } });
    var ua_js_1 = require_ua();
    Object.defineProperty(exports2, "ua", { enumerable: true, get: function() {
      return __importDefault(ua_js_1).default;
    } });
    var uk_js_1 = require_uk();
    Object.defineProperty(exports2, "uk", { enumerable: true, get: function() {
      return __importDefault(uk_js_1).default;
    } });
    var ur_js_1 = require_ur();
    Object.defineProperty(exports2, "ur", { enumerable: true, get: function() {
      return __importDefault(ur_js_1).default;
    } });
    var uz_js_1 = require_uz();
    Object.defineProperty(exports2, "uz", { enumerable: true, get: function() {
      return __importDefault(uz_js_1).default;
    } });
    var vi_js_1 = require_vi();
    Object.defineProperty(exports2, "vi", { enumerable: true, get: function() {
      return __importDefault(vi_js_1).default;
    } });
    var zh_CN_js_1 = require_zh_CN();
    Object.defineProperty(exports2, "zhCN", { enumerable: true, get: function() {
      return __importDefault(zh_CN_js_1).default;
    } });
    var zh_TW_js_1 = require_zh_TW();
    Object.defineProperty(exports2, "zhTW", { enumerable: true, get: function() {
      return __importDefault(zh_TW_js_1).default;
    } });
    var yo_js_1 = require_yo();
    Object.defineProperty(exports2, "yo", { enumerable: true, get: function() {
      return __importDefault(yo_js_1).default;
    } });
  }
});

// node_modules/zod/v4/core/registries.cjs
var require_registries = __commonJS({
  "node_modules/zod/v4/core/registries.cjs"(exports2) {
    "use strict";
    var _a31;
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.globalRegistry = exports2.$ZodRegistry = exports2.$input = exports2.$output = void 0;
    exports2.registry = registry3;
    exports2.$output = /* @__PURE__ */ Symbol("ZodOutput");
    exports2.$input = /* @__PURE__ */ Symbol("ZodInput");
    var $ZodRegistry3 = class {
      constructor() {
        this._map = /* @__PURE__ */ new WeakMap();
        this._idmap = /* @__PURE__ */ new Map();
      }
      add(schema, ..._meta) {
        const meta4 = _meta[0];
        this._map.set(schema, meta4);
        if (meta4 && typeof meta4 === "object" && "id" in meta4) {
          this._idmap.set(meta4.id, schema);
        }
        return this;
      }
      clear() {
        this._map = /* @__PURE__ */ new WeakMap();
        this._idmap = /* @__PURE__ */ new Map();
        return this;
      }
      remove(schema) {
        const meta4 = this._map.get(schema);
        if (meta4 && typeof meta4 === "object" && "id" in meta4) {
          this._idmap.delete(meta4.id);
        }
        this._map.delete(schema);
        return this;
      }
      get(schema) {
        const p3 = schema._zod.parent;
        if (p3) {
          const pm = { ...this.get(p3) ?? {} };
          delete pm.id;
          const f = { ...pm, ...this._map.get(schema) };
          return Object.keys(f).length ? f : void 0;
        }
        return this._map.get(schema);
      }
      has(schema) {
        return this._map.has(schema);
      }
    };
    exports2.$ZodRegistry = $ZodRegistry3;
    function registry3() {
      return new $ZodRegistry3();
    }
    (_a31 = globalThis).__zod_globalRegistry ?? (_a31.__zod_globalRegistry = registry3());
    exports2.globalRegistry = globalThis.__zod_globalRegistry;
  }
});

// node_modules/zod/v4/core/api.cjs
var require_api = __commonJS({
  "node_modules/zod/v4/core/api.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.TimePrecision = void 0;
    exports2._string = _string3;
    exports2._coercedString = _coercedString3;
    exports2._email = _email3;
    exports2._guid = _guid3;
    exports2._uuid = _uuid3;
    exports2._uuidv4 = _uuidv43;
    exports2._uuidv6 = _uuidv63;
    exports2._uuidv7 = _uuidv73;
    exports2._url = _url3;
    exports2._emoji = _emoji4;
    exports2._nanoid = _nanoid3;
    exports2._cuid = _cuid4;
    exports2._cuid2 = _cuid23;
    exports2._ulid = _ulid3;
    exports2._xid = _xid3;
    exports2._ksuid = _ksuid3;
    exports2._ipv4 = _ipv43;
    exports2._ipv6 = _ipv63;
    exports2._mac = _mac3;
    exports2._cidrv4 = _cidrv43;
    exports2._cidrv6 = _cidrv63;
    exports2._base64 = _base643;
    exports2._base64url = _base64url3;
    exports2._e164 = _e1643;
    exports2._jwt = _jwt3;
    exports2._isoDateTime = _isoDateTime3;
    exports2._isoDate = _isoDate3;
    exports2._isoTime = _isoTime3;
    exports2._isoDuration = _isoDuration3;
    exports2._number = _number3;
    exports2._coercedNumber = _coercedNumber3;
    exports2._int = _int3;
    exports2._float32 = _float323;
    exports2._float64 = _float643;
    exports2._int32 = _int323;
    exports2._uint32 = _uint323;
    exports2._boolean = _boolean3;
    exports2._coercedBoolean = _coercedBoolean3;
    exports2._bigint = _bigint3;
    exports2._coercedBigint = _coercedBigint3;
    exports2._int64 = _int643;
    exports2._uint64 = _uint643;
    exports2._symbol = _symbol3;
    exports2._undefined = _undefined5;
    exports2._null = _null5;
    exports2._any = _any3;
    exports2._unknown = _unknown3;
    exports2._never = _never3;
    exports2._void = _void4;
    exports2._date = _date3;
    exports2._coercedDate = _coercedDate3;
    exports2._nan = _nan3;
    exports2._lt = _lt3;
    exports2._lte = _lte3;
    exports2._max = _lte3;
    exports2._lte = _lte3;
    exports2._max = _lte3;
    exports2._gt = _gt3;
    exports2._gte = _gte3;
    exports2._min = _gte3;
    exports2._gte = _gte3;
    exports2._min = _gte3;
    exports2._positive = _positive3;
    exports2._negative = _negative3;
    exports2._nonpositive = _nonpositive3;
    exports2._nonnegative = _nonnegative3;
    exports2._multipleOf = _multipleOf3;
    exports2._maxSize = _maxSize3;
    exports2._minSize = _minSize3;
    exports2._size = _size3;
    exports2._maxLength = _maxLength3;
    exports2._minLength = _minLength3;
    exports2._length = _length3;
    exports2._regex = _regex3;
    exports2._lowercase = _lowercase3;
    exports2._uppercase = _uppercase3;
    exports2._includes = _includes3;
    exports2._startsWith = _startsWith3;
    exports2._endsWith = _endsWith3;
    exports2._property = _property3;
    exports2._mime = _mime3;
    exports2._overwrite = _overwrite3;
    exports2._normalize = _normalize3;
    exports2._trim = _trim3;
    exports2._toLowerCase = _toLowerCase3;
    exports2._toUpperCase = _toUpperCase3;
    exports2._slugify = _slugify3;
    exports2._array = _array3;
    exports2._union = _union3;
    exports2._xor = _xor3;
    exports2._discriminatedUnion = _discriminatedUnion3;
    exports2._intersection = _intersection3;
    exports2._tuple = _tuple3;
    exports2._record = _record3;
    exports2._map = _map3;
    exports2._set = _set3;
    exports2._enum = _enum4;
    exports2._nativeEnum = _nativeEnum3;
    exports2._literal = _literal3;
    exports2._file = _file3;
    exports2._transform = _transform3;
    exports2._optional = _optional3;
    exports2._nullable = _nullable3;
    exports2._default = _default4;
    exports2._nonoptional = _nonoptional3;
    exports2._success = _success3;
    exports2._catch = _catch4;
    exports2._pipe = _pipe3;
    exports2._readonly = _readonly3;
    exports2._templateLiteral = _templateLiteral3;
    exports2._lazy = _lazy3;
    exports2._promise = _promise3;
    exports2._custom = _custom3;
    exports2._refine = _refine3;
    exports2._superRefine = _superRefine3;
    exports2._check = _check3;
    exports2.describe = describe4;
    exports2.meta = meta4;
    exports2._stringbool = _stringbool3;
    exports2._stringFormat = _stringFormat3;
    var checks = __importStar(require_checks());
    var registries = __importStar(require_registries());
    var schemas = __importStar(require_schemas());
    var util4 = __importStar(require_util4());
    // @__NO_SIDE_EFFECTS__
    function _string3(Class3, params) {
      return new Class3({
        type: "string",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _coercedString3(Class3, params) {
      return new Class3({
        type: "string",
        coerce: true,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _email3(Class3, params) {
      return new Class3({
        type: "string",
        format: "email",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _guid3(Class3, params) {
      return new Class3({
        type: "string",
        format: "guid",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _uuid3(Class3, params) {
      return new Class3({
        type: "string",
        format: "uuid",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _uuidv43(Class3, params) {
      return new Class3({
        type: "string",
        format: "uuid",
        check: "string_format",
        abort: false,
        version: "v4",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _uuidv63(Class3, params) {
      return new Class3({
        type: "string",
        format: "uuid",
        check: "string_format",
        abort: false,
        version: "v6",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _uuidv73(Class3, params) {
      return new Class3({
        type: "string",
        format: "uuid",
        check: "string_format",
        abort: false,
        version: "v7",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _url3(Class3, params) {
      return new Class3({
        type: "string",
        format: "url",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _emoji4(Class3, params) {
      return new Class3({
        type: "string",
        format: "emoji",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _nanoid3(Class3, params) {
      return new Class3({
        type: "string",
        format: "nanoid",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _cuid4(Class3, params) {
      return new Class3({
        type: "string",
        format: "cuid",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _cuid23(Class3, params) {
      return new Class3({
        type: "string",
        format: "cuid2",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _ulid3(Class3, params) {
      return new Class3({
        type: "string",
        format: "ulid",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _xid3(Class3, params) {
      return new Class3({
        type: "string",
        format: "xid",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _ksuid3(Class3, params) {
      return new Class3({
        type: "string",
        format: "ksuid",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _ipv43(Class3, params) {
      return new Class3({
        type: "string",
        format: "ipv4",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _ipv63(Class3, params) {
      return new Class3({
        type: "string",
        format: "ipv6",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _mac3(Class3, params) {
      return new Class3({
        type: "string",
        format: "mac",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _cidrv43(Class3, params) {
      return new Class3({
        type: "string",
        format: "cidrv4",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _cidrv63(Class3, params) {
      return new Class3({
        type: "string",
        format: "cidrv6",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _base643(Class3, params) {
      return new Class3({
        type: "string",
        format: "base64",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _base64url3(Class3, params) {
      return new Class3({
        type: "string",
        format: "base64url",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _e1643(Class3, params) {
      return new Class3({
        type: "string",
        format: "e164",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _jwt3(Class3, params) {
      return new Class3({
        type: "string",
        format: "jwt",
        check: "string_format",
        abort: false,
        ...util4.normalizeParams(params)
      });
    }
    exports2.TimePrecision = {
      Any: null,
      Minute: -1,
      Second: 0,
      Millisecond: 3,
      Microsecond: 6
    };
    // @__NO_SIDE_EFFECTS__
    function _isoDateTime3(Class3, params) {
      return new Class3({
        type: "string",
        format: "datetime",
        check: "string_format",
        offset: false,
        local: false,
        precision: null,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _isoDate3(Class3, params) {
      return new Class3({
        type: "string",
        format: "date",
        check: "string_format",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _isoTime3(Class3, params) {
      return new Class3({
        type: "string",
        format: "time",
        check: "string_format",
        precision: null,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _isoDuration3(Class3, params) {
      return new Class3({
        type: "string",
        format: "duration",
        check: "string_format",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _number3(Class3, params) {
      return new Class3({
        type: "number",
        checks: [],
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _coercedNumber3(Class3, params) {
      return new Class3({
        type: "number",
        coerce: true,
        checks: [],
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _int3(Class3, params) {
      return new Class3({
        type: "number",
        check: "number_format",
        abort: false,
        format: "safeint",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _float323(Class3, params) {
      return new Class3({
        type: "number",
        check: "number_format",
        abort: false,
        format: "float32",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _float643(Class3, params) {
      return new Class3({
        type: "number",
        check: "number_format",
        abort: false,
        format: "float64",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _int323(Class3, params) {
      return new Class3({
        type: "number",
        check: "number_format",
        abort: false,
        format: "int32",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _uint323(Class3, params) {
      return new Class3({
        type: "number",
        check: "number_format",
        abort: false,
        format: "uint32",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _boolean3(Class3, params) {
      return new Class3({
        type: "boolean",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _coercedBoolean3(Class3, params) {
      return new Class3({
        type: "boolean",
        coerce: true,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _bigint3(Class3, params) {
      return new Class3({
        type: "bigint",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _coercedBigint3(Class3, params) {
      return new Class3({
        type: "bigint",
        coerce: true,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _int643(Class3, params) {
      return new Class3({
        type: "bigint",
        check: "bigint_format",
        abort: false,
        format: "int64",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _uint643(Class3, params) {
      return new Class3({
        type: "bigint",
        check: "bigint_format",
        abort: false,
        format: "uint64",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _symbol3(Class3, params) {
      return new Class3({
        type: "symbol",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _undefined5(Class3, params) {
      return new Class3({
        type: "undefined",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _null5(Class3, params) {
      return new Class3({
        type: "null",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _any3(Class3) {
      return new Class3({
        type: "any"
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _unknown3(Class3) {
      return new Class3({
        type: "unknown"
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _never3(Class3, params) {
      return new Class3({
        type: "never",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _void4(Class3, params) {
      return new Class3({
        type: "void",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _date3(Class3, params) {
      return new Class3({
        type: "date",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _coercedDate3(Class3, params) {
      return new Class3({
        type: "date",
        coerce: true,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _nan3(Class3, params) {
      return new Class3({
        type: "nan",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _lt3(value, params) {
      return new checks.$ZodCheckLessThan({
        check: "less_than",
        ...util4.normalizeParams(params),
        value,
        inclusive: false
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _lte3(value, params) {
      return new checks.$ZodCheckLessThan({
        check: "less_than",
        ...util4.normalizeParams(params),
        value,
        inclusive: true
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _gt3(value, params) {
      return new checks.$ZodCheckGreaterThan({
        check: "greater_than",
        ...util4.normalizeParams(params),
        value,
        inclusive: false
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _gte3(value, params) {
      return new checks.$ZodCheckGreaterThan({
        check: "greater_than",
        ...util4.normalizeParams(params),
        value,
        inclusive: true
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _positive3(params) {
      return /* @__PURE__ */ _gt3(0, params);
    }
    // @__NO_SIDE_EFFECTS__
    function _negative3(params) {
      return /* @__PURE__ */ _lt3(0, params);
    }
    // @__NO_SIDE_EFFECTS__
    function _nonpositive3(params) {
      return /* @__PURE__ */ _lte3(0, params);
    }
    // @__NO_SIDE_EFFECTS__
    function _nonnegative3(params) {
      return /* @__PURE__ */ _gte3(0, params);
    }
    // @__NO_SIDE_EFFECTS__
    function _multipleOf3(value, params) {
      return new checks.$ZodCheckMultipleOf({
        check: "multiple_of",
        ...util4.normalizeParams(params),
        value
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _maxSize3(maximum, params) {
      return new checks.$ZodCheckMaxSize({
        check: "max_size",
        ...util4.normalizeParams(params),
        maximum
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _minSize3(minimum, params) {
      return new checks.$ZodCheckMinSize({
        check: "min_size",
        ...util4.normalizeParams(params),
        minimum
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _size3(size, params) {
      return new checks.$ZodCheckSizeEquals({
        check: "size_equals",
        ...util4.normalizeParams(params),
        size
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _maxLength3(maximum, params) {
      const ch = new checks.$ZodCheckMaxLength({
        check: "max_length",
        ...util4.normalizeParams(params),
        maximum
      });
      return ch;
    }
    // @__NO_SIDE_EFFECTS__
    function _minLength3(minimum, params) {
      return new checks.$ZodCheckMinLength({
        check: "min_length",
        ...util4.normalizeParams(params),
        minimum
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _length3(length, params) {
      return new checks.$ZodCheckLengthEquals({
        check: "length_equals",
        ...util4.normalizeParams(params),
        length
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _regex3(pattern, params) {
      return new checks.$ZodCheckRegex({
        check: "string_format",
        format: "regex",
        ...util4.normalizeParams(params),
        pattern
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _lowercase3(params) {
      return new checks.$ZodCheckLowerCase({
        check: "string_format",
        format: "lowercase",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _uppercase3(params) {
      return new checks.$ZodCheckUpperCase({
        check: "string_format",
        format: "uppercase",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _includes3(includes, params) {
      return new checks.$ZodCheckIncludes({
        check: "string_format",
        format: "includes",
        ...util4.normalizeParams(params),
        includes
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _startsWith3(prefix, params) {
      return new checks.$ZodCheckStartsWith({
        check: "string_format",
        format: "starts_with",
        ...util4.normalizeParams(params),
        prefix
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _endsWith3(suffix, params) {
      return new checks.$ZodCheckEndsWith({
        check: "string_format",
        format: "ends_with",
        ...util4.normalizeParams(params),
        suffix
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _property3(property2, schema, params) {
      return new checks.$ZodCheckProperty({
        check: "property",
        property: property2,
        schema,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _mime3(types, params) {
      return new checks.$ZodCheckMimeType({
        check: "mime_type",
        mime: types,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _overwrite3(tx) {
      return new checks.$ZodCheckOverwrite({
        check: "overwrite",
        tx
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _normalize3(form) {
      return /* @__PURE__ */ _overwrite3((input) => input.normalize(form));
    }
    // @__NO_SIDE_EFFECTS__
    function _trim3() {
      return /* @__PURE__ */ _overwrite3((input) => input.trim());
    }
    // @__NO_SIDE_EFFECTS__
    function _toLowerCase3() {
      return /* @__PURE__ */ _overwrite3((input) => input.toLowerCase());
    }
    // @__NO_SIDE_EFFECTS__
    function _toUpperCase3() {
      return /* @__PURE__ */ _overwrite3((input) => input.toUpperCase());
    }
    // @__NO_SIDE_EFFECTS__
    function _slugify3() {
      return /* @__PURE__ */ _overwrite3((input) => util4.slugify(input));
    }
    // @__NO_SIDE_EFFECTS__
    function _array3(Class3, element, params) {
      return new Class3({
        type: "array",
        element,
        // get element() {
        //   return element;
        // },
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _union3(Class3, options, params) {
      return new Class3({
        type: "union",
        options,
        ...util4.normalizeParams(params)
      });
    }
    function _xor3(Class3, options, params) {
      return new Class3({
        type: "union",
        options,
        inclusive: false,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _discriminatedUnion3(Class3, discriminator, options, params) {
      return new Class3({
        type: "union",
        options,
        discriminator,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _intersection3(Class3, left, right) {
      return new Class3({
        type: "intersection",
        left,
        right
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _tuple3(Class3, items, _paramsOrRest, _params) {
      const hasRest = _paramsOrRest instanceof schemas.$ZodType;
      const params = hasRest ? _params : _paramsOrRest;
      const rest = hasRest ? _paramsOrRest : null;
      return new Class3({
        type: "tuple",
        items,
        rest,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _record3(Class3, keyType, valueType, params) {
      return new Class3({
        type: "record",
        keyType,
        valueType,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _map3(Class3, keyType, valueType, params) {
      return new Class3({
        type: "map",
        keyType,
        valueType,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _set3(Class3, valueType, params) {
      return new Class3({
        type: "set",
        valueType,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _enum4(Class3, values, params) {
      const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
      return new Class3({
        type: "enum",
        entries,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _nativeEnum3(Class3, entries, params) {
      return new Class3({
        type: "enum",
        entries,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _literal3(Class3, value, params) {
      return new Class3({
        type: "literal",
        values: Array.isArray(value) ? value : [value],
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _file3(Class3, params) {
      return new Class3({
        type: "file",
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _transform3(Class3, fn) {
      return new Class3({
        type: "transform",
        transform: fn
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _optional3(Class3, innerType) {
      return new Class3({
        type: "optional",
        innerType
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _nullable3(Class3, innerType) {
      return new Class3({
        type: "nullable",
        innerType
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _default4(Class3, innerType, defaultValue) {
      return new Class3({
        type: "default",
        innerType,
        get defaultValue() {
          return typeof defaultValue === "function" ? defaultValue() : util4.shallowClone(defaultValue);
        }
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _nonoptional3(Class3, innerType, params) {
      return new Class3({
        type: "nonoptional",
        innerType,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _success3(Class3, innerType) {
      return new Class3({
        type: "success",
        innerType
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _catch4(Class3, innerType, catchValue) {
      return new Class3({
        type: "catch",
        innerType,
        catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _pipe3(Class3, in_, out) {
      return new Class3({
        type: "pipe",
        in: in_,
        out
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _readonly3(Class3, innerType) {
      return new Class3({
        type: "readonly",
        innerType
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _templateLiteral3(Class3, parts, params) {
      return new Class3({
        type: "template_literal",
        parts,
        ...util4.normalizeParams(params)
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _lazy3(Class3, getter) {
      return new Class3({
        type: "lazy",
        getter
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _promise3(Class3, innerType) {
      return new Class3({
        type: "promise",
        innerType
      });
    }
    // @__NO_SIDE_EFFECTS__
    function _custom3(Class3, fn, _params) {
      const norm = util4.normalizeParams(_params);
      norm.abort ?? (norm.abort = true);
      const schema = new Class3({
        type: "custom",
        check: "custom",
        fn,
        ...norm
      });
      return schema;
    }
    // @__NO_SIDE_EFFECTS__
    function _refine3(Class3, fn, _params) {
      const schema = new Class3({
        type: "custom",
        check: "custom",
        fn,
        ...util4.normalizeParams(_params)
      });
      return schema;
    }
    // @__NO_SIDE_EFFECTS__
    function _superRefine3(fn) {
      const ch = /* @__PURE__ */ _check3((payload) => {
        payload.addIssue = (issue3) => {
          if (typeof issue3 === "string") {
            payload.issues.push(util4.issue(issue3, payload.value, ch._zod.def));
          } else {
            const _issue = issue3;
            if (_issue.fatal)
              _issue.continue = false;
            _issue.code ?? (_issue.code = "custom");
            _issue.input ?? (_issue.input = payload.value);
            _issue.inst ?? (_issue.inst = ch);
            _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
            payload.issues.push(util4.issue(_issue));
          }
        };
        return fn(payload.value, payload);
      });
      return ch;
    }
    // @__NO_SIDE_EFFECTS__
    function _check3(fn, params) {
      const ch = new checks.$ZodCheck({
        check: "custom",
        ...util4.normalizeParams(params)
      });
      ch._zod.check = fn;
      return ch;
    }
    // @__NO_SIDE_EFFECTS__
    function describe4(description) {
      const ch = new checks.$ZodCheck({ check: "describe" });
      ch._zod.onattach = [
        (inst) => {
          const existing = registries.globalRegistry.get(inst) ?? {};
          registries.globalRegistry.add(inst, { ...existing, description });
        }
      ];
      ch._zod.check = () => {
      };
      return ch;
    }
    // @__NO_SIDE_EFFECTS__
    function meta4(metadata) {
      const ch = new checks.$ZodCheck({ check: "meta" });
      ch._zod.onattach = [
        (inst) => {
          const existing = registries.globalRegistry.get(inst) ?? {};
          registries.globalRegistry.add(inst, { ...existing, ...metadata });
        }
      ];
      ch._zod.check = () => {
      };
      return ch;
    }
    // @__NO_SIDE_EFFECTS__
    function _stringbool3(Classes, _params) {
      const params = util4.normalizeParams(_params);
      let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
      let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
      if (params.case !== "sensitive") {
        truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
        falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
      }
      const truthySet = new Set(truthyArray);
      const falsySet = new Set(falsyArray);
      const _Codec = Classes.Codec ?? schemas.$ZodCodec;
      const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean;
      const _String = Classes.String ?? schemas.$ZodString;
      const stringSchema = new _String({ type: "string", error: params.error });
      const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
      const codec3 = new _Codec({
        type: "pipe",
        in: stringSchema,
        out: booleanSchema,
        transform: ((input, payload) => {
          let data = input;
          if (params.case !== "sensitive")
            data = data.toLowerCase();
          if (truthySet.has(data)) {
            return true;
          } else if (falsySet.has(data)) {
            return false;
          } else {
            payload.issues.push({
              code: "invalid_value",
              expected: "stringbool",
              values: [...truthySet, ...falsySet],
              input: payload.value,
              inst: codec3,
              continue: false
            });
            return {};
          }
        }),
        reverseTransform: ((input, _payload) => {
          if (input === true) {
            return truthyArray[0] || "true";
          } else {
            return falsyArray[0] || "false";
          }
        }),
        error: params.error
      });
      return codec3;
    }
    // @__NO_SIDE_EFFECTS__
    function _stringFormat3(Class3, format, fnOrRegex, _params = {}) {
      const params = util4.normalizeParams(_params);
      const def = {
        ...util4.normalizeParams(_params),
        check: "string_format",
        type: "string",
        format,
        fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
        ...params
      };
      if (fnOrRegex instanceof RegExp) {
        def.pattern = fnOrRegex;
      }
      const inst = new Class3(def);
      return inst;
    }
  }
});

// node_modules/zod/v4/core/to-json-schema.cjs
var require_to_json_schema = __commonJS({
  "node_modules/zod/v4/core/to-json-schema.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createStandardJSONSchemaMethod = exports2.createToJSONSchemaMethod = void 0;
    exports2.initializeContext = initializeContext3;
    exports2.process = process4;
    exports2.extractDefs = extractDefs3;
    exports2.finalize = finalize3;
    var registries_js_1 = require_registries();
    function initializeContext3(params) {
      let target = params?.target ?? "draft-2020-12";
      if (target === "draft-4")
        target = "draft-04";
      if (target === "draft-7")
        target = "draft-07";
      return {
        processors: params.processors ?? {},
        metadataRegistry: params?.metadata ?? registries_js_1.globalRegistry,
        target,
        unrepresentable: params?.unrepresentable ?? "throw",
        override: params?.override ?? (() => {
        }),
        io: params?.io ?? "output",
        counter: 0,
        seen: /* @__PURE__ */ new Map(),
        cycles: params?.cycles ?? "ref",
        reused: params?.reused ?? "inline",
        external: params?.external ?? void 0
      };
    }
    function process4(schema, ctx, _params = { path: [], schemaPath: [] }) {
      var _a31;
      const def = schema._zod.def;
      const seen = ctx.seen.get(schema);
      if (seen) {
        seen.count++;
        const isCycle = _params.schemaPath.includes(schema);
        if (isCycle) {
          seen.cycle = _params.path;
        }
        return seen.schema;
      }
      const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
      ctx.seen.set(schema, result);
      const overrideSchema = schema._zod.toJSONSchema?.();
      if (overrideSchema) {
        result.schema = overrideSchema;
      } else {
        const params = {
          ..._params,
          schemaPath: [..._params.schemaPath, schema],
          path: _params.path
        };
        if (schema._zod.processJSONSchema) {
          schema._zod.processJSONSchema(ctx, result.schema, params);
        } else {
          const _json = result.schema;
          const processor = ctx.processors[def.type];
          if (!processor) {
            throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
          }
          processor(schema, ctx, _json, params);
        }
        const parent = schema._zod.parent;
        if (parent) {
          if (!result.ref)
            result.ref = parent;
          process4(parent, ctx, params);
          ctx.seen.get(parent).isParent = true;
        }
      }
      const meta4 = ctx.metadataRegistry.get(schema);
      if (meta4)
        Object.assign(result.schema, meta4);
      if (ctx.io === "input" && isTransforming3(schema)) {
        delete result.schema.examples;
        delete result.schema.default;
      }
      if (ctx.io === "input" && result.schema._prefault)
        (_a31 = result.schema).default ?? (_a31.default = result.schema._prefault);
      delete result.schema._prefault;
      const _result = ctx.seen.get(schema);
      return _result.schema;
    }
    function extractDefs3(ctx, schema) {
      const root2 = ctx.seen.get(schema);
      if (!root2)
        throw new Error("Unprocessed schema. This is a bug in Zod.");
      const idToSchema = /* @__PURE__ */ new Map();
      for (const entry of ctx.seen.entries()) {
        const id = ctx.metadataRegistry.get(entry[0])?.id;
        if (id) {
          const existing = idToSchema.get(id);
          if (existing && existing !== entry[0]) {
            throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
          }
          idToSchema.set(id, entry[0]);
        }
      }
      const makeURI = (entry) => {
        const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
        if (ctx.external) {
          const externalId = ctx.external.registry.get(entry[0])?.id;
          const uriGenerator = ctx.external.uri ?? ((id2) => id2);
          if (externalId) {
            return { ref: uriGenerator(externalId) };
          }
          const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
          entry[1].defId = id;
          return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
        }
        if (entry[1] === root2) {
          return { ref: "#" };
        }
        const uriPrefix = `#`;
        const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
        const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
        return { defId, ref: defUriPrefix + defId };
      };
      const extractToDef = (entry) => {
        if (entry[1].schema.$ref) {
          return;
        }
        const seen = entry[1];
        const { ref, defId } = makeURI(entry);
        seen.def = { ...seen.schema };
        if (defId)
          seen.defId = defId;
        const schema2 = seen.schema;
        for (const key in schema2) {
          delete schema2[key];
        }
        schema2.$ref = ref;
      };
      if (ctx.cycles === "throw") {
        for (const entry of ctx.seen.entries()) {
          const seen = entry[1];
          if (seen.cycle) {
            throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>

Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
          }
        }
      }
      for (const entry of ctx.seen.entries()) {
        const seen = entry[1];
        if (schema === entry[0]) {
          extractToDef(entry);
          continue;
        }
        if (ctx.external) {
          const ext = ctx.external.registry.get(entry[0])?.id;
          if (schema !== entry[0] && ext) {
            extractToDef(entry);
            continue;
          }
        }
        const id = ctx.metadataRegistry.get(entry[0])?.id;
        if (id) {
          extractToDef(entry);
          continue;
        }
        if (seen.cycle) {
          extractToDef(entry);
          continue;
        }
        if (seen.count > 1) {
          if (ctx.reused === "ref") {
            extractToDef(entry);
            continue;
          }
        }
      }
    }
    function finalize3(ctx, schema) {
      const root2 = ctx.seen.get(schema);
      if (!root2)
        throw new Error("Unprocessed schema. This is a bug in Zod.");
      const flattenRef = (zodSchema4) => {
        const seen = ctx.seen.get(zodSchema4);
        if (seen.ref === null)
          return;
        const schema2 = seen.def ?? seen.schema;
        const _cached = { ...schema2 };
        const ref = seen.ref;
        seen.ref = null;
        if (ref) {
          flattenRef(ref);
          const refSeen = ctx.seen.get(ref);
          const refSchema = refSeen.schema;
          if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
            schema2.allOf = schema2.allOf ?? [];
            schema2.allOf.push(refSchema);
          } else {
            Object.assign(schema2, refSchema);
          }
          Object.assign(schema2, _cached);
          const isParentRef = zodSchema4._zod.parent === ref;
          if (isParentRef) {
            for (const key in schema2) {
              if (key === "$ref" || key === "allOf")
                continue;
              if (!(key in _cached)) {
                delete schema2[key];
              }
            }
          }
          if (refSchema.$ref && refSeen.def) {
            for (const key in schema2) {
              if (key === "$ref" || key === "allOf")
                continue;
              if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
                delete schema2[key];
              }
            }
          }
        }
        const parent = zodSchema4._zod.parent;
        if (parent && parent !== ref) {
          flattenRef(parent);
          const parentSeen = ctx.seen.get(parent);
          if (parentSeen?.schema.$ref) {
            schema2.$ref = parentSeen.schema.$ref;
            if (parentSeen.def) {
              for (const key in schema2) {
                if (key === "$ref" || key === "allOf")
                  continue;
                if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
                  delete schema2[key];
                }
              }
            }
          }
        }
        ctx.override({
          zodSchema: zodSchema4,
          jsonSchema: schema2,
          path: seen.path ?? []
        });
      };
      for (const entry of [...ctx.seen.entries()].reverse()) {
        flattenRef(entry[0]);
      }
      const result = {};
      if (ctx.target === "draft-2020-12") {
        result.$schema = "https://json-schema.org/draft/2020-12/schema";
      } else if (ctx.target === "draft-07") {
        result.$schema = "http://json-schema.org/draft-07/schema#";
      } else if (ctx.target === "draft-04") {
        result.$schema = "http://json-schema.org/draft-04/schema#";
      } else if (ctx.target === "openapi-3.0") {
      } else {
      }
      if (ctx.external?.uri) {
        const id = ctx.external.registry.get(schema)?.id;
        if (!id)
          throw new Error("Schema is missing an `id` property");
        result.$id = ctx.external.uri(id);
      }
      Object.assign(result, root2.def ?? root2.schema);
      const defs = ctx.external?.defs ?? {};
      for (const entry of ctx.seen.entries()) {
        const seen = entry[1];
        if (seen.def && seen.defId) {
          defs[seen.defId] = seen.def;
        }
      }
      if (ctx.external) {
      } else {
        if (Object.keys(defs).length > 0) {
          if (ctx.target === "draft-2020-12") {
            result.$defs = defs;
          } else {
            result.definitions = defs;
          }
        }
      }
      try {
        const finalized = JSON.parse(JSON.stringify(result));
        Object.defineProperty(finalized, "~standard", {
          value: {
            ...schema["~standard"],
            jsonSchema: {
              input: (0, exports2.createStandardJSONSchemaMethod)(schema, "input", ctx.processors),
              output: (0, exports2.createStandardJSONSchemaMethod)(schema, "output", ctx.processors)
            }
          },
          enumerable: false,
          writable: false
        });
        return finalized;
      } catch (_err) {
        throw new Error("Error converting schema to JSON.");
      }
    }
    function isTransforming3(_schema, _ctx) {
      const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
      if (ctx.seen.has(_schema))
        return false;
      ctx.seen.add(_schema);
      const def = _schema._zod.def;
      if (def.type === "transform")
        return true;
      if (def.type === "array")
        return isTransforming3(def.element, ctx);
      if (def.type === "set")
        return isTransforming3(def.valueType, ctx);
      if (def.type === "lazy")
        return isTransforming3(def.getter(), ctx);
      if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
        return isTransforming3(def.innerType, ctx);
      }
      if (def.type === "intersection") {
        return isTransforming3(def.left, ctx) || isTransforming3(def.right, ctx);
      }
      if (def.type === "record" || def.type === "map") {
        return isTransforming3(def.keyType, ctx) || isTransforming3(def.valueType, ctx);
      }
      if (def.type === "pipe") {
        return isTransforming3(def.in, ctx) || isTransforming3(def.out, ctx);
      }
      if (def.type === "object") {
        for (const key in def.shape) {
          if (isTransforming3(def.shape[key], ctx))
            return true;
        }
        return false;
      }
      if (def.type === "union") {
        for (const option of def.options) {
          if (isTransforming3(option, ctx))
            return true;
        }
        return false;
      }
      if (def.type === "tuple") {
        for (const item of def.items) {
          if (isTransforming3(item, ctx))
            return true;
        }
        if (def.rest && isTransforming3(def.rest, ctx))
          return true;
        return false;
      }
      return false;
    }
    var createToJSONSchemaMethod3 = (schema, processors = {}) => (params) => {
      const ctx = initializeContext3({ ...params, processors });
      process4(schema, ctx);
      extractDefs3(ctx, schema);
      return finalize3(ctx, schema);
    };
    exports2.createToJSONSchemaMethod = createToJSONSchemaMethod3;
    var createStandardJSONSchemaMethod3 = (schema, io2, processors = {}) => (params) => {
      const { libraryOptions, target } = params ?? {};
      const ctx = initializeContext3({ ...libraryOptions ?? {}, target, io: io2, processors });
      process4(schema, ctx);
      extractDefs3(ctx, schema);
      return finalize3(ctx, schema);
    };
    exports2.createStandardJSONSchemaMethod = createStandardJSONSchemaMethod3;
  }
});

// node_modules/zod/v4/core/json-schema-processors.cjs
var require_json_schema_processors = __commonJS({
  "node_modules/zod/v4/core/json-schema-processors.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.allProcessors = exports2.lazyProcessor = exports2.optionalProcessor = exports2.promiseProcessor = exports2.readonlyProcessor = exports2.pipeProcessor = exports2.catchProcessor = exports2.prefaultProcessor = exports2.defaultProcessor = exports2.nonoptionalProcessor = exports2.nullableProcessor = exports2.recordProcessor = exports2.tupleProcessor = exports2.intersectionProcessor = exports2.unionProcessor = exports2.objectProcessor = exports2.arrayProcessor = exports2.setProcessor = exports2.mapProcessor = exports2.transformProcessor = exports2.functionProcessor = exports2.customProcessor = exports2.successProcessor = exports2.fileProcessor = exports2.templateLiteralProcessor = exports2.nanProcessor = exports2.literalProcessor = exports2.enumProcessor = exports2.dateProcessor = exports2.unknownProcessor = exports2.anyProcessor = exports2.neverProcessor = exports2.voidProcessor = exports2.undefinedProcessor = exports2.nullProcessor = exports2.symbolProcessor = exports2.bigintProcessor = exports2.booleanProcessor = exports2.numberProcessor = exports2.stringProcessor = void 0;
    exports2.toJSONSchema = toJSONSchema3;
    var to_json_schema_js_1 = require_to_json_schema();
    var util_js_1 = require_util4();
    var formatMap3 = {
      guid: "uuid",
      url: "uri",
      datetime: "date-time",
      json_string: "json-string",
      regex: ""
      // do not set
    };
    var stringProcessor3 = (schema, ctx, _json, _params) => {
      const json4 = _json;
      json4.type = "string";
      const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
      if (typeof minimum === "number")
        json4.minLength = minimum;
      if (typeof maximum === "number")
        json4.maxLength = maximum;
      if (format) {
        json4.format = formatMap3[format] ?? format;
        if (json4.format === "")
          delete json4.format;
        if (format === "time") {
          delete json4.format;
        }
      }
      if (contentEncoding)
        json4.contentEncoding = contentEncoding;
      if (patterns && patterns.size > 0) {
        const regexes = [...patterns];
        if (regexes.length === 1)
          json4.pattern = regexes[0].source;
        else if (regexes.length > 1) {
          json4.allOf = [
            ...regexes.map((regex) => ({
              ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
              pattern: regex.source
            }))
          ];
        }
      }
    };
    exports2.stringProcessor = stringProcessor3;
    var numberProcessor3 = (schema, ctx, _json, _params) => {
      const json4 = _json;
      const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
      if (typeof format === "string" && format.includes("int"))
        json4.type = "integer";
      else
        json4.type = "number";
      if (typeof exclusiveMinimum === "number") {
        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
          json4.minimum = exclusiveMinimum;
          json4.exclusiveMinimum = true;
        } else {
          json4.exclusiveMinimum = exclusiveMinimum;
        }
      }
      if (typeof minimum === "number") {
        json4.minimum = minimum;
        if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
          if (exclusiveMinimum >= minimum)
            delete json4.minimum;
          else
            delete json4.exclusiveMinimum;
        }
      }
      if (typeof exclusiveMaximum === "number") {
        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
          json4.maximum = exclusiveMaximum;
          json4.exclusiveMaximum = true;
        } else {
          json4.exclusiveMaximum = exclusiveMaximum;
        }
      }
      if (typeof maximum === "number") {
        json4.maximum = maximum;
        if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
          if (exclusiveMaximum <= maximum)
            delete json4.maximum;
          else
            delete json4.exclusiveMaximum;
        }
      }
      if (typeof multipleOf === "number")
        json4.multipleOf = multipleOf;
    };
    exports2.numberProcessor = numberProcessor3;
    var booleanProcessor3 = (_schema, _ctx, json4, _params) => {
      json4.type = "boolean";
    };
    exports2.booleanProcessor = booleanProcessor3;
    var bigintProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("BigInt cannot be represented in JSON Schema");
      }
    };
    exports2.bigintProcessor = bigintProcessor3;
    var symbolProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Symbols cannot be represented in JSON Schema");
      }
    };
    exports2.symbolProcessor = symbolProcessor3;
    var nullProcessor3 = (_schema, ctx, json4, _params) => {
      if (ctx.target === "openapi-3.0") {
        json4.type = "string";
        json4.nullable = true;
        json4.enum = [null];
      } else {
        json4.type = "null";
      }
    };
    exports2.nullProcessor = nullProcessor3;
    var undefinedProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Undefined cannot be represented in JSON Schema");
      }
    };
    exports2.undefinedProcessor = undefinedProcessor3;
    var voidProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Void cannot be represented in JSON Schema");
      }
    };
    exports2.voidProcessor = voidProcessor3;
    var neverProcessor3 = (_schema, _ctx, json4, _params) => {
      json4.not = {};
    };
    exports2.neverProcessor = neverProcessor3;
    var anyProcessor3 = (_schema, _ctx, _json, _params) => {
    };
    exports2.anyProcessor = anyProcessor3;
    var unknownProcessor3 = (_schema, _ctx, _json, _params) => {
    };
    exports2.unknownProcessor = unknownProcessor3;
    var dateProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Date cannot be represented in JSON Schema");
      }
    };
    exports2.dateProcessor = dateProcessor3;
    var enumProcessor3 = (schema, _ctx, json4, _params) => {
      const def = schema._zod.def;
      const values = (0, util_js_1.getEnumValues)(def.entries);
      if (values.every((v) => typeof v === "number"))
        json4.type = "number";
      if (values.every((v) => typeof v === "string"))
        json4.type = "string";
      json4.enum = values;
    };
    exports2.enumProcessor = enumProcessor3;
    var literalProcessor3 = (schema, ctx, json4, _params) => {
      const def = schema._zod.def;
      const vals = [];
      for (const val of def.values) {
        if (val === void 0) {
          if (ctx.unrepresentable === "throw") {
            throw new Error("Literal `undefined` cannot be represented in JSON Schema");
          } else {
          }
        } else if (typeof val === "bigint") {
          if (ctx.unrepresentable === "throw") {
            throw new Error("BigInt literals cannot be represented in JSON Schema");
          } else {
            vals.push(Number(val));
          }
        } else {
          vals.push(val);
        }
      }
      if (vals.length === 0) {
      } else if (vals.length === 1) {
        const val = vals[0];
        json4.type = val === null ? "null" : typeof val;
        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
          json4.enum = [val];
        } else {
          json4.const = val;
        }
      } else {
        if (vals.every((v) => typeof v === "number"))
          json4.type = "number";
        if (vals.every((v) => typeof v === "string"))
          json4.type = "string";
        if (vals.every((v) => typeof v === "boolean"))
          json4.type = "boolean";
        if (vals.every((v) => v === null))
          json4.type = "null";
        json4.enum = vals;
      }
    };
    exports2.literalProcessor = literalProcessor3;
    var nanProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("NaN cannot be represented in JSON Schema");
      }
    };
    exports2.nanProcessor = nanProcessor3;
    var templateLiteralProcessor3 = (schema, _ctx, json4, _params) => {
      const _json = json4;
      const pattern = schema._zod.pattern;
      if (!pattern)
        throw new Error("Pattern not found in template literal");
      _json.type = "string";
      _json.pattern = pattern.source;
    };
    exports2.templateLiteralProcessor = templateLiteralProcessor3;
    var fileProcessor3 = (schema, _ctx, json4, _params) => {
      const _json = json4;
      const file3 = {
        type: "string",
        format: "binary",
        contentEncoding: "binary"
      };
      const { minimum, maximum, mime } = schema._zod.bag;
      if (minimum !== void 0)
        file3.minLength = minimum;
      if (maximum !== void 0)
        file3.maxLength = maximum;
      if (mime) {
        if (mime.length === 1) {
          file3.contentMediaType = mime[0];
          Object.assign(_json, file3);
        } else {
          Object.assign(_json, file3);
          _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
        }
      } else {
        Object.assign(_json, file3);
      }
    };
    exports2.fileProcessor = fileProcessor3;
    var successProcessor3 = (_schema, _ctx, json4, _params) => {
      json4.type = "boolean";
    };
    exports2.successProcessor = successProcessor3;
    var customProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Custom types cannot be represented in JSON Schema");
      }
    };
    exports2.customProcessor = customProcessor3;
    var functionProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Function types cannot be represented in JSON Schema");
      }
    };
    exports2.functionProcessor = functionProcessor3;
    var transformProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Transforms cannot be represented in JSON Schema");
      }
    };
    exports2.transformProcessor = transformProcessor3;
    var mapProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Map cannot be represented in JSON Schema");
      }
    };
    exports2.mapProcessor = mapProcessor3;
    var setProcessor3 = (_schema, ctx, _json, _params) => {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Set cannot be represented in JSON Schema");
      }
    };
    exports2.setProcessor = setProcessor3;
    var arrayProcessor3 = (schema, ctx, _json, params) => {
      const json4 = _json;
      const def = schema._zod.def;
      const { minimum, maximum } = schema._zod.bag;
      if (typeof minimum === "number")
        json4.minItems = minimum;
      if (typeof maximum === "number")
        json4.maxItems = maximum;
      json4.type = "array";
      json4.items = (0, to_json_schema_js_1.process)(def.element, ctx, { ...params, path: [...params.path, "items"] });
    };
    exports2.arrayProcessor = arrayProcessor3;
    var objectProcessor3 = (schema, ctx, _json, params) => {
      const json4 = _json;
      const def = schema._zod.def;
      json4.type = "object";
      json4.properties = {};
      const shape = def.shape;
      for (const key in shape) {
        json4.properties[key] = (0, to_json_schema_js_1.process)(shape[key], ctx, {
          ...params,
          path: [...params.path, "properties", key]
        });
      }
      const allKeys = new Set(Object.keys(shape));
      const requiredKeys = new Set([...allKeys].filter((key) => {
        const v = def.shape[key]._zod;
        if (ctx.io === "input") {
          return v.optin === void 0;
        } else {
          return v.optout === void 0;
        }
      }));
      if (requiredKeys.size > 0) {
        json4.required = Array.from(requiredKeys);
      }
      if (def.catchall?._zod.def.type === "never") {
        json4.additionalProperties = false;
      } else if (!def.catchall) {
        if (ctx.io === "output")
          json4.additionalProperties = false;
      } else if (def.catchall) {
        json4.additionalProperties = (0, to_json_schema_js_1.process)(def.catchall, ctx, {
          ...params,
          path: [...params.path, "additionalProperties"]
        });
      }
    };
    exports2.objectProcessor = objectProcessor3;
    var unionProcessor3 = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      const isExclusive = def.inclusive === false;
      const options = def.options.map((x, i) => (0, to_json_schema_js_1.process)(x, ctx, {
        ...params,
        path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
      }));
      if (isExclusive) {
        json4.oneOf = options;
      } else {
        json4.anyOf = options;
      }
    };
    exports2.unionProcessor = unionProcessor3;
    var intersectionProcessor3 = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      const a = (0, to_json_schema_js_1.process)(def.left, ctx, {
        ...params,
        path: [...params.path, "allOf", 0]
      });
      const b = (0, to_json_schema_js_1.process)(def.right, ctx, {
        ...params,
        path: [...params.path, "allOf", 1]
      });
      const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
      const allOf = [
        ...isSimpleIntersection(a) ? a.allOf : [a],
        ...isSimpleIntersection(b) ? b.allOf : [b]
      ];
      json4.allOf = allOf;
    };
    exports2.intersectionProcessor = intersectionProcessor3;
    var tupleProcessor3 = (schema, ctx, _json, params) => {
      const json4 = _json;
      const def = schema._zod.def;
      json4.type = "array";
      const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
      const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
      const prefixItems = def.items.map((x, i) => (0, to_json_schema_js_1.process)(x, ctx, {
        ...params,
        path: [...params.path, prefixPath, i]
      }));
      const rest = def.rest ? (0, to_json_schema_js_1.process)(def.rest, ctx, {
        ...params,
        path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
      }) : null;
      if (ctx.target === "draft-2020-12") {
        json4.prefixItems = prefixItems;
        if (rest) {
          json4.items = rest;
        }
      } else if (ctx.target === "openapi-3.0") {
        json4.items = {
          anyOf: prefixItems
        };
        if (rest) {
          json4.items.anyOf.push(rest);
        }
        json4.minItems = prefixItems.length;
        if (!rest) {
          json4.maxItems = prefixItems.length;
        }
      } else {
        json4.items = prefixItems;
        if (rest) {
          json4.additionalItems = rest;
        }
      }
      const { minimum, maximum } = schema._zod.bag;
      if (typeof minimum === "number")
        json4.minItems = minimum;
      if (typeof maximum === "number")
        json4.maxItems = maximum;
    };
    exports2.tupleProcessor = tupleProcessor3;
    var recordProcessor3 = (schema, ctx, _json, params) => {
      const json4 = _json;
      const def = schema._zod.def;
      json4.type = "object";
      const keyType = def.keyType;
      const keyBag = keyType._zod.bag;
      const patterns = keyBag?.patterns;
      if (def.mode === "loose" && patterns && patterns.size > 0) {
        const valueSchema = (0, to_json_schema_js_1.process)(def.valueType, ctx, {
          ...params,
          path: [...params.path, "patternProperties", "*"]
        });
        json4.patternProperties = {};
        for (const pattern of patterns) {
          json4.patternProperties[pattern.source] = valueSchema;
        }
      } else {
        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
          json4.propertyNames = (0, to_json_schema_js_1.process)(def.keyType, ctx, {
            ...params,
            path: [...params.path, "propertyNames"]
          });
        }
        json4.additionalProperties = (0, to_json_schema_js_1.process)(def.valueType, ctx, {
          ...params,
          path: [...params.path, "additionalProperties"]
        });
      }
      const keyValues = keyType._zod.values;
      if (keyValues) {
        const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
        if (validKeyValues.length > 0) {
          json4.required = validKeyValues;
        }
      }
    };
    exports2.recordProcessor = recordProcessor3;
    var nullableProcessor3 = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      const inner = (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      if (ctx.target === "openapi-3.0") {
        seen.ref = def.innerType;
        json4.nullable = true;
      } else {
        json4.anyOf = [inner, { type: "null" }];
      }
    };
    exports2.nullableProcessor = nullableProcessor3;
    var nonoptionalProcessor3 = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
    };
    exports2.nonoptionalProcessor = nonoptionalProcessor3;
    var defaultProcessor3 = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      json4.default = JSON.parse(JSON.stringify(def.defaultValue));
    };
    exports2.defaultProcessor = defaultProcessor3;
    var prefaultProcessor3 = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      if (ctx.io === "input")
        json4._prefault = JSON.parse(JSON.stringify(def.defaultValue));
    };
    exports2.prefaultProcessor = prefaultProcessor3;
    var catchProcessor3 = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      let catchValue;
      try {
        catchValue = def.catchValue(void 0);
      } catch {
        throw new Error("Dynamic catch values are not supported in JSON Schema");
      }
      json4.default = catchValue;
    };
    exports2.catchProcessor = catchProcessor3;
    var pipeProcessor3 = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
      (0, to_json_schema_js_1.process)(innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = innerType;
    };
    exports2.pipeProcessor = pipeProcessor3;
    var readonlyProcessor3 = (schema, ctx, json4, params) => {
      const def = schema._zod.def;
      (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
      json4.readOnly = true;
    };
    exports2.readonlyProcessor = readonlyProcessor3;
    var promiseProcessor3 = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
    };
    exports2.promiseProcessor = promiseProcessor3;
    var optionalProcessor3 = (schema, ctx, _json, params) => {
      const def = schema._zod.def;
      (0, to_json_schema_js_1.process)(def.innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = def.innerType;
    };
    exports2.optionalProcessor = optionalProcessor3;
    var lazyProcessor3 = (schema, ctx, _json, params) => {
      const innerType = schema._zod.innerType;
      (0, to_json_schema_js_1.process)(innerType, ctx, params);
      const seen = ctx.seen.get(schema);
      seen.ref = innerType;
    };
    exports2.lazyProcessor = lazyProcessor3;
    exports2.allProcessors = {
      string: exports2.stringProcessor,
      number: exports2.numberProcessor,
      boolean: exports2.booleanProcessor,
      bigint: exports2.bigintProcessor,
      symbol: exports2.symbolProcessor,
      null: exports2.nullProcessor,
      undefined: exports2.undefinedProcessor,
      void: exports2.voidProcessor,
      never: exports2.neverProcessor,
      any: exports2.anyProcessor,
      unknown: exports2.unknownProcessor,
      date: exports2.dateProcessor,
      enum: exports2.enumProcessor,
      literal: exports2.literalProcessor,
      nan: exports2.nanProcessor,
      template_literal: exports2.templateLiteralProcessor,
      file: exports2.fileProcessor,
      success: exports2.successProcessor,
      custom: exports2.customProcessor,
      function: exports2.functionProcessor,
      transform: exports2.transformProcessor,
      map: exports2.mapProcessor,
      set: exports2.setProcessor,
      array: exports2.arrayProcessor,
      object: exports2.objectProcessor,
      union: exports2.unionProcessor,
      intersection: exports2.intersectionProcessor,
      tuple: exports2.tupleProcessor,
      record: exports2.recordProcessor,
      nullable: exports2.nullableProcessor,
      nonoptional: exports2.nonoptionalProcessor,
      default: exports2.defaultProcessor,
      prefault: exports2.prefaultProcessor,
      catch: exports2.catchProcessor,
      pipe: exports2.pipeProcessor,
      readonly: exports2.readonlyProcessor,
      promise: exports2.promiseProcessor,
      optional: exports2.optionalProcessor,
      lazy: exports2.lazyProcessor
    };
    function toJSONSchema3(input, params) {
      if ("_idmap" in input) {
        const registry3 = input;
        const ctx2 = (0, to_json_schema_js_1.initializeContext)({ ...params, processors: exports2.allProcessors });
        const defs = {};
        for (const entry of registry3._idmap.entries()) {
          const [_, schema] = entry;
          (0, to_json_schema_js_1.process)(schema, ctx2);
        }
        const schemas = {};
        const external = {
          registry: registry3,
          uri: params?.uri,
          defs
        };
        ctx2.external = external;
        for (const entry of registry3._idmap.entries()) {
          const [key, schema] = entry;
          (0, to_json_schema_js_1.extractDefs)(ctx2, schema);
          schemas[key] = (0, to_json_schema_js_1.finalize)(ctx2, schema);
        }
        if (Object.keys(defs).length > 0) {
          const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
          schemas.__shared = {
            [defsSegment]: defs
          };
        }
        return { schemas };
      }
      const ctx = (0, to_json_schema_js_1.initializeContext)({ ...params, processors: exports2.allProcessors });
      (0, to_json_schema_js_1.process)(input, ctx);
      (0, to_json_schema_js_1.extractDefs)(ctx, input);
      return (0, to_json_schema_js_1.finalize)(ctx, input);
    }
  }
});

// node_modules/zod/v4/core/json-schema-generator.cjs
var require_json_schema_generator = __commonJS({
  "node_modules/zod/v4/core/json-schema-generator.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.JSONSchemaGenerator = void 0;
    var json_schema_processors_js_1 = require_json_schema_processors();
    var to_json_schema_js_1 = require_to_json_schema();
    var JSONSchemaGenerator3 = class {
      /** @deprecated Access via ctx instead */
      get metadataRegistry() {
        return this.ctx.metadataRegistry;
      }
      /** @deprecated Access via ctx instead */
      get target() {
        return this.ctx.target;
      }
      /** @deprecated Access via ctx instead */
      get unrepresentable() {
        return this.ctx.unrepresentable;
      }
      /** @deprecated Access via ctx instead */
      get override() {
        return this.ctx.override;
      }
      /** @deprecated Access via ctx instead */
      get io() {
        return this.ctx.io;
      }
      /** @deprecated Access via ctx instead */
      get counter() {
        return this.ctx.counter;
      }
      set counter(value) {
        this.ctx.counter = value;
      }
      /** @deprecated Access via ctx instead */
      get seen() {
        return this.ctx.seen;
      }
      constructor(params) {
        let normalizedTarget = params?.target ?? "draft-2020-12";
        if (normalizedTarget === "draft-4")
          normalizedTarget = "draft-04";
        if (normalizedTarget === "draft-7")
          normalizedTarget = "draft-07";
        this.ctx = (0, to_json_schema_js_1.initializeContext)({
          processors: json_schema_processors_js_1.allProcessors,
          target: normalizedTarget,
          ...params?.metadata && { metadata: params.metadata },
          ...params?.unrepresentable && { unrepresentable: params.unrepresentable },
          ...params?.override && { override: params.override },
          ...params?.io && { io: params.io }
        });
      }
      /**
       * Process a schema to prepare it for JSON Schema generation.
       * This must be called before emit().
       */
      process(schema, _params = { path: [], schemaPath: [] }) {
        return (0, to_json_schema_js_1.process)(schema, this.ctx, _params);
      }
      /**
       * Emit the final JSON Schema after processing.
       * Must call process() first.
       */
      emit(schema, _params) {
        if (_params) {
          if (_params.cycles)
            this.ctx.cycles = _params.cycles;
          if (_params.reused)
            this.ctx.reused = _params.reused;
          if (_params.external)
            this.ctx.external = _params.external;
        }
        (0, to_json_schema_js_1.extractDefs)(this.ctx, schema);
        const result = (0, to_json_schema_js_1.finalize)(this.ctx, schema);
        const { "~standard": _, ...plainResult } = result;
        return plainResult;
      }
    };
    exports2.JSONSchemaGenerator = JSONSchemaGenerator3;
  }
});

// node_modules/zod/v4/core/json-schema.cjs
var require_json_schema = __commonJS({
  "node_modules/zod/v4/core/json-schema.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/zod/v4/core/index.cjs
var require_core2 = __commonJS({
  "node_modules/zod/v4/core/index.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p3 in m) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m, p3);
    };
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.JSONSchema = exports2.JSONSchemaGenerator = exports2.toJSONSchema = exports2.locales = exports2.regexes = exports2.util = void 0;
    __exportStar(require_core(), exports2);
    __exportStar(require_parse4(), exports2);
    __exportStar(require_errors(), exports2);
    __exportStar(require_schemas(), exports2);
    __exportStar(require_checks(), exports2);
    __exportStar(require_versions(), exports2);
    exports2.util = __importStar(require_util4());
    exports2.regexes = __importStar(require_regexes());
    exports2.locales = __importStar(require_locales());
    __exportStar(require_registries(), exports2);
    __exportStar(require_doc(), exports2);
    __exportStar(require_api(), exports2);
    __exportStar(require_to_json_schema(), exports2);
    var json_schema_processors_js_1 = require_json_schema_processors();
    Object.defineProperty(exports2, "toJSONSchema", { enumerable: true, get: function() {
      return json_schema_processors_js_1.toJSONSchema;
    } });
    var json_schema_generator_js_1 = require_json_schema_generator();
    Object.defineProperty(exports2, "JSONSchemaGenerator", { enumerable: true, get: function() {
      return json_schema_generator_js_1.JSONSchemaGenerator;
    } });
    exports2.JSONSchema = __importStar(require_json_schema());
  }
});

// node_modules/zod/v4/classic/checks.cjs
var require_checks2 = __commonJS({
  "node_modules/zod/v4/classic/checks.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.slugify = exports2.toUpperCase = exports2.toLowerCase = exports2.trim = exports2.normalize = exports2.overwrite = exports2.mime = exports2.property = exports2.endsWith = exports2.startsWith = exports2.includes = exports2.uppercase = exports2.lowercase = exports2.regex = exports2.length = exports2.minLength = exports2.maxLength = exports2.size = exports2.minSize = exports2.maxSize = exports2.multipleOf = exports2.nonnegative = exports2.nonpositive = exports2.negative = exports2.positive = exports2.gte = exports2.gt = exports2.lte = exports2.lt = void 0;
    var index_js_1 = require_core2();
    Object.defineProperty(exports2, "lt", { enumerable: true, get: function() {
      return index_js_1._lt;
    } });
    Object.defineProperty(exports2, "lte", { enumerable: true, get: function() {
      return index_js_1._lte;
    } });
    Object.defineProperty(exports2, "gt", { enumerable: true, get: function() {
      return index_js_1._gt;
    } });
    Object.defineProperty(exports2, "gte", { enumerable: true, get: function() {
      return index_js_1._gte;
    } });
    Object.defineProperty(exports2, "positive", { enumerable: true, get: function() {
      return index_js_1._positive;
    } });
    Object.defineProperty(exports2, "negative", { enumerable: true, get: function() {
      return index_js_1._negative;
    } });
    Object.defineProperty(exports2, "nonpositive", { enumerable: true, get: function() {
      return index_js_1._nonpositive;
    } });
    Object.defineProperty(exports2, "nonnegative", { enumerable: true, get: function() {
      return index_js_1._nonnegative;
    } });
    Object.defineProperty(exports2, "multipleOf", { enumerable: true, get: function() {
      return index_js_1._multipleOf;
    } });
    Object.defineProperty(exports2, "maxSize", { enumerable: true, get: function() {
      return index_js_1._maxSize;
    } });
    Object.defineProperty(exports2, "minSize", { enumerable: true, get: function() {
      return index_js_1._minSize;
    } });
    Object.defineProperty(exports2, "size", { enumerable: true, get: function() {
      return index_js_1._size;
    } });
    Object.defineProperty(exports2, "maxLength", { enumerable: true, get: function() {
      return index_js_1._maxLength;
    } });
    Object.defineProperty(exports2, "minLength", { enumerable: true, get: function() {
      return index_js_1._minLength;
    } });
    Object.defineProperty(exports2, "length", { enumerable: true, get: function() {
      return index_js_1._length;
    } });
    Object.defineProperty(exports2, "regex", { enumerable: true, get: function() {
      return index_js_1._regex;
    } });
    Object.defineProperty(exports2, "lowercase", { enumerable: true, get: function() {
      return index_js_1._lowercase;
    } });
    Object.defineProperty(exports2, "uppercase", { enumerable: true, get: function() {
      return index_js_1._uppercase;
    } });
    Object.defineProperty(exports2, "includes", { enumerable: true, get: function() {
      return index_js_1._includes;
    } });
    Object.defineProperty(exports2, "startsWith", { enumerable: true, get: function() {
      return index_js_1._startsWith;
    } });
    Object.defineProperty(exports2, "endsWith", { enumerable: true, get: function() {
      return index_js_1._endsWith;
    } });
    Object.defineProperty(exports2, "property", { enumerable: true, get: function() {
      return index_js_1._property;
    } });
    Object.defineProperty(exports2, "mime", { enumerable: true, get: function() {
      return index_js_1._mime;
    } });
    Object.defineProperty(exports2, "overwrite", { enumerable: true, get: function() {
      return index_js_1._overwrite;
    } });
    Object.defineProperty(exports2, "normalize", { enumerable: true, get: function() {
      return index_js_1._normalize;
    } });
    Object.defineProperty(exports2, "trim", { enumerable: true, get: function() {
      return index_js_1._trim;
    } });
    Object.defineProperty(exports2, "toLowerCase", { enumerable: true, get: function() {
      return index_js_1._toLowerCase;
    } });
    Object.defineProperty(exports2, "toUpperCase", { enumerable: true, get: function() {
      return index_js_1._toUpperCase;
    } });
    Object.defineProperty(exports2, "slugify", { enumerable: true, get: function() {
      return index_js_1._slugify;
    } });
  }
});

// node_modules/zod/v4/classic/iso.cjs
var require_iso = __commonJS({
  "node_modules/zod/v4/classic/iso.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ZodISODuration = exports2.ZodISOTime = exports2.ZodISODate = exports2.ZodISODateTime = void 0;
    exports2.datetime = datetime4;
    exports2.date = date6;
    exports2.time = time4;
    exports2.duration = duration4;
    var core = __importStar(require_core2());
    var schemas = __importStar(require_schemas2());
    exports2.ZodISODateTime = core.$constructor("ZodISODateTime", (inst, def) => {
      core.$ZodISODateTime.init(inst, def);
      schemas.ZodStringFormat.init(inst, def);
    });
    function datetime4(params) {
      return core._isoDateTime(exports2.ZodISODateTime, params);
    }
    exports2.ZodISODate = core.$constructor("ZodISODate", (inst, def) => {
      core.$ZodISODate.init(inst, def);
      schemas.ZodStringFormat.init(inst, def);
    });
    function date6(params) {
      return core._isoDate(exports2.ZodISODate, params);
    }
    exports2.ZodISOTime = core.$constructor("ZodISOTime", (inst, def) => {
      core.$ZodISOTime.init(inst, def);
      schemas.ZodStringFormat.init(inst, def);
    });
    function time4(params) {
      return core._isoTime(exports2.ZodISOTime, params);
    }
    exports2.ZodISODuration = core.$constructor("ZodISODuration", (inst, def) => {
      core.$ZodISODuration.init(inst, def);
      schemas.ZodStringFormat.init(inst, def);
    });
    function duration4(params) {
      return core._isoDuration(exports2.ZodISODuration, params);
    }
  }
});

// node_modules/zod/v4/classic/errors.cjs
var require_errors2 = __commonJS({
  "node_modules/zod/v4/classic/errors.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ZodRealError = exports2.ZodError = void 0;
    var core = __importStar(require_core2());
    var index_js_1 = require_core2();
    var util4 = __importStar(require_util4());
    var initializer4 = (inst, issues) => {
      index_js_1.$ZodError.init(inst, issues);
      inst.name = "ZodError";
      Object.defineProperties(inst, {
        format: {
          value: (mapper) => core.formatError(inst, mapper)
          // enumerable: false,
        },
        flatten: {
          value: (mapper) => core.flattenError(inst, mapper)
          // enumerable: false,
        },
        addIssue: {
          value: (issue3) => {
            inst.issues.push(issue3);
            inst.message = JSON.stringify(inst.issues, util4.jsonStringifyReplacer, 2);
          }
          // enumerable: false,
        },
        addIssues: {
          value: (issues2) => {
            inst.issues.push(...issues2);
            inst.message = JSON.stringify(inst.issues, util4.jsonStringifyReplacer, 2);
          }
          // enumerable: false,
        },
        isEmpty: {
          get() {
            return inst.issues.length === 0;
          }
          // enumerable: false,
        }
      });
    };
    exports2.ZodError = core.$constructor("ZodError", initializer4);
    exports2.ZodRealError = core.$constructor("ZodError", initializer4, {
      Parent: Error
    });
  }
});

// node_modules/zod/v4/classic/parse.cjs
var require_parse5 = __commonJS({
  "node_modules/zod/v4/classic/parse.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.safeDecodeAsync = exports2.safeEncodeAsync = exports2.safeDecode = exports2.safeEncode = exports2.decodeAsync = exports2.encodeAsync = exports2.decode = exports2.encode = exports2.safeParseAsync = exports2.safeParse = exports2.parseAsync = exports2.parse = void 0;
    var core = __importStar(require_core2());
    var errors_js_1 = require_errors2();
    exports2.parse = core._parse(errors_js_1.ZodRealError);
    exports2.parseAsync = core._parseAsync(errors_js_1.ZodRealError);
    exports2.safeParse = core._safeParse(errors_js_1.ZodRealError);
    exports2.safeParseAsync = core._safeParseAsync(errors_js_1.ZodRealError);
    exports2.encode = core._encode(errors_js_1.ZodRealError);
    exports2.decode = core._decode(errors_js_1.ZodRealError);
    exports2.encodeAsync = core._encodeAsync(errors_js_1.ZodRealError);
    exports2.decodeAsync = core._decodeAsync(errors_js_1.ZodRealError);
    exports2.safeEncode = core._safeEncode(errors_js_1.ZodRealError);
    exports2.safeDecode = core._safeDecode(errors_js_1.ZodRealError);
    exports2.safeEncodeAsync = core._safeEncodeAsync(errors_js_1.ZodRealError);
    exports2.safeDecodeAsync = core._safeDecodeAsync(errors_js_1.ZodRealError);
  }
});

// node_modules/zod/v4/classic/schemas.cjs
var require_schemas2 = __commonJS({
  "node_modules/zod/v4/classic/schemas.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ZodLiteral = exports2.ZodEnum = exports2.ZodSet = exports2.ZodMap = exports2.ZodRecord = exports2.ZodTuple = exports2.ZodIntersection = exports2.ZodDiscriminatedUnion = exports2.ZodXor = exports2.ZodUnion = exports2.ZodObject = exports2.ZodArray = exports2.ZodDate = exports2.ZodVoid = exports2.ZodNever = exports2.ZodUnknown = exports2.ZodAny = exports2.ZodNull = exports2.ZodUndefined = exports2.ZodSymbol = exports2.ZodBigIntFormat = exports2.ZodBigInt = exports2.ZodBoolean = exports2.ZodNumberFormat = exports2.ZodNumber = exports2.ZodCustomStringFormat = exports2.ZodJWT = exports2.ZodE164 = exports2.ZodBase64URL = exports2.ZodBase64 = exports2.ZodCIDRv6 = exports2.ZodCIDRv4 = exports2.ZodIPv6 = exports2.ZodMAC = exports2.ZodIPv4 = exports2.ZodKSUID = exports2.ZodXID = exports2.ZodULID = exports2.ZodCUID2 = exports2.ZodCUID = exports2.ZodNanoID = exports2.ZodEmoji = exports2.ZodURL = exports2.ZodUUID = exports2.ZodGUID = exports2.ZodEmail = exports2.ZodStringFormat = exports2.ZodString = exports2._ZodString = exports2.ZodType = void 0;
    exports2.stringbool = exports2.meta = exports2.describe = exports2.ZodCustom = exports2.ZodFunction = exports2.ZodPromise = exports2.ZodLazy = exports2.ZodTemplateLiteral = exports2.ZodReadonly = exports2.ZodCodec = exports2.ZodPipe = exports2.ZodNaN = exports2.ZodCatch = exports2.ZodSuccess = exports2.ZodNonOptional = exports2.ZodPrefault = exports2.ZodDefault = exports2.ZodNullable = exports2.ZodExactOptional = exports2.ZodOptional = exports2.ZodTransform = exports2.ZodFile = void 0;
    exports2.string = string5;
    exports2.email = email4;
    exports2.guid = guid4;
    exports2.uuid = uuid5;
    exports2.uuidv4 = uuidv43;
    exports2.uuidv6 = uuidv63;
    exports2.uuidv7 = uuidv73;
    exports2.url = url4;
    exports2.httpUrl = httpUrl3;
    exports2.emoji = emoji4;
    exports2.nanoid = nanoid4;
    exports2.cuid = cuid5;
    exports2.cuid2 = cuid24;
    exports2.ulid = ulid4;
    exports2.xid = xid4;
    exports2.ksuid = ksuid4;
    exports2.ipv4 = ipv44;
    exports2.mac = mac4;
    exports2.ipv6 = ipv64;
    exports2.cidrv4 = cidrv44;
    exports2.cidrv6 = cidrv64;
    exports2.base64 = base644;
    exports2.base64url = base64url4;
    exports2.e164 = e1644;
    exports2.jwt = jwt4;
    exports2.stringFormat = stringFormat3;
    exports2.hostname = hostname4;
    exports2.hex = hex4;
    exports2.hash = hash3;
    exports2.number = number5;
    exports2.int = int3;
    exports2.float32 = float323;
    exports2.float64 = float643;
    exports2.int32 = int323;
    exports2.uint32 = uint323;
    exports2.boolean = boolean5;
    exports2.bigint = bigint5;
    exports2.int64 = int643;
    exports2.uint64 = uint643;
    exports2.symbol = symbol30;
    exports2.undefined = _undefined5;
    exports2.null = _null5;
    exports2.any = any3;
    exports2.unknown = unknown3;
    exports2.never = never3;
    exports2.void = _void4;
    exports2.date = date6;
    exports2.array = array4;
    exports2.keyof = keyof3;
    exports2.object = object4;
    exports2.strictObject = strictObject3;
    exports2.looseObject = looseObject3;
    exports2.union = union3;
    exports2.xor = xor3;
    exports2.discriminatedUnion = discriminatedUnion3;
    exports2.intersection = intersection3;
    exports2.tuple = tuple3;
    exports2.record = record3;
    exports2.partialRecord = partialRecord3;
    exports2.looseRecord = looseRecord3;
    exports2.map = map3;
    exports2.set = set3;
    exports2.enum = _enum4;
    exports2.nativeEnum = nativeEnum3;
    exports2.literal = literal3;
    exports2.file = file3;
    exports2.transform = transform8;
    exports2.optional = optional3;
    exports2.exactOptional = exactOptional3;
    exports2.nullable = nullable3;
    exports2.nullish = nullish4;
    exports2._default = _default4;
    exports2.prefault = prefault3;
    exports2.nonoptional = nonoptional3;
    exports2.success = success5;
    exports2.catch = _catch4;
    exports2.nan = nan3;
    exports2.pipe = pipe3;
    exports2.codec = codec3;
    exports2.readonly = readonly3;
    exports2.templateLiteral = templateLiteral3;
    exports2.lazy = lazy3;
    exports2.promise = promise3;
    exports2._function = _function3;
    exports2.function = _function3;
    exports2._function = _function3;
    exports2.function = _function3;
    exports2.check = check3;
    exports2.custom = custom3;
    exports2.refine = refine3;
    exports2.superRefine = superRefine3;
    exports2.instanceof = _instanceof3;
    exports2.json = json4;
    exports2.preprocess = preprocess3;
    var core = __importStar(require_core2());
    var index_js_1 = require_core2();
    var processors = __importStar(require_json_schema_processors());
    var to_json_schema_js_1 = require_to_json_schema();
    var checks = __importStar(require_checks2());
    var iso = __importStar(require_iso());
    var parse4 = __importStar(require_parse5());
    exports2.ZodType = core.$constructor("ZodType", (inst, def) => {
      core.$ZodType.init(inst, def);
      Object.assign(inst["~standard"], {
        jsonSchema: {
          input: (0, to_json_schema_js_1.createStandardJSONSchemaMethod)(inst, "input"),
          output: (0, to_json_schema_js_1.createStandardJSONSchemaMethod)(inst, "output")
        }
      });
      inst.toJSONSchema = (0, to_json_schema_js_1.createToJSONSchemaMethod)(inst, {});
      inst.def = def;
      inst.type = def.type;
      Object.defineProperty(inst, "_def", { value: def });
      inst.check = (...checks2) => {
        return inst.clone(index_js_1.util.mergeDefs(def, {
          checks: [
            ...def.checks ?? [],
            ...checks2.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
          ]
        }), {
          parent: true
        });
      };
      inst.with = inst.check;
      inst.clone = (def2, params) => core.clone(inst, def2, params);
      inst.brand = () => inst;
      inst.register = ((reg, meta4) => {
        reg.add(inst, meta4);
        return inst;
      });
      inst.parse = (data, params) => parse4.parse(inst, data, params, { callee: inst.parse });
      inst.safeParse = (data, params) => parse4.safeParse(inst, data, params);
      inst.parseAsync = async (data, params) => parse4.parseAsync(inst, data, params, { callee: inst.parseAsync });
      inst.safeParseAsync = async (data, params) => parse4.safeParseAsync(inst, data, params);
      inst.spa = inst.safeParseAsync;
      inst.encode = (data, params) => parse4.encode(inst, data, params);
      inst.decode = (data, params) => parse4.decode(inst, data, params);
      inst.encodeAsync = async (data, params) => parse4.encodeAsync(inst, data, params);
      inst.decodeAsync = async (data, params) => parse4.decodeAsync(inst, data, params);
      inst.safeEncode = (data, params) => parse4.safeEncode(inst, data, params);
      inst.safeDecode = (data, params) => parse4.safeDecode(inst, data, params);
      inst.safeEncodeAsync = async (data, params) => parse4.safeEncodeAsync(inst, data, params);
      inst.safeDecodeAsync = async (data, params) => parse4.safeDecodeAsync(inst, data, params);
      inst.refine = (check4, params) => inst.check(refine3(check4, params));
      inst.superRefine = (refinement) => inst.check(superRefine3(refinement));
      inst.overwrite = (fn) => inst.check(checks.overwrite(fn));
      inst.optional = () => optional3(inst);
      inst.exactOptional = () => exactOptional3(inst);
      inst.nullable = () => nullable3(inst);
      inst.nullish = () => optional3(nullable3(inst));
      inst.nonoptional = (params) => nonoptional3(inst, params);
      inst.array = () => array4(inst);
      inst.or = (arg) => union3([inst, arg]);
      inst.and = (arg) => intersection3(inst, arg);
      inst.transform = (tx) => pipe3(inst, transform8(tx));
      inst.default = (def2) => _default4(inst, def2);
      inst.prefault = (def2) => prefault3(inst, def2);
      inst.catch = (params) => _catch4(inst, params);
      inst.pipe = (target) => pipe3(inst, target);
      inst.readonly = () => readonly3(inst);
      inst.describe = (description) => {
        const cl = inst.clone();
        core.globalRegistry.add(cl, { description });
        return cl;
      };
      Object.defineProperty(inst, "description", {
        get() {
          return core.globalRegistry.get(inst)?.description;
        },
        configurable: true
      });
      inst.meta = (...args) => {
        if (args.length === 0) {
          return core.globalRegistry.get(inst);
        }
        const cl = inst.clone();
        core.globalRegistry.add(cl, args[0]);
        return cl;
      };
      inst.isOptional = () => inst.safeParse(void 0).success;
      inst.isNullable = () => inst.safeParse(null).success;
      inst.apply = (fn) => fn(inst);
      return inst;
    });
    exports2._ZodString = core.$constructor("_ZodString", (inst, def) => {
      core.$ZodString.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.stringProcessor(inst, ctx, json5, params);
      const bag = inst._zod.bag;
      inst.format = bag.format ?? null;
      inst.minLength = bag.minimum ?? null;
      inst.maxLength = bag.maximum ?? null;
      inst.regex = (...args) => inst.check(checks.regex(...args));
      inst.includes = (...args) => inst.check(checks.includes(...args));
      inst.startsWith = (...args) => inst.check(checks.startsWith(...args));
      inst.endsWith = (...args) => inst.check(checks.endsWith(...args));
      inst.min = (...args) => inst.check(checks.minLength(...args));
      inst.max = (...args) => inst.check(checks.maxLength(...args));
      inst.length = (...args) => inst.check(checks.length(...args));
      inst.nonempty = (...args) => inst.check(checks.minLength(1, ...args));
      inst.lowercase = (params) => inst.check(checks.lowercase(params));
      inst.uppercase = (params) => inst.check(checks.uppercase(params));
      inst.trim = () => inst.check(checks.trim());
      inst.normalize = (...args) => inst.check(checks.normalize(...args));
      inst.toLowerCase = () => inst.check(checks.toLowerCase());
      inst.toUpperCase = () => inst.check(checks.toUpperCase());
      inst.slugify = () => inst.check(checks.slugify());
    });
    exports2.ZodString = core.$constructor("ZodString", (inst, def) => {
      core.$ZodString.init(inst, def);
      exports2._ZodString.init(inst, def);
      inst.email = (params) => inst.check(core._email(exports2.ZodEmail, params));
      inst.url = (params) => inst.check(core._url(exports2.ZodURL, params));
      inst.jwt = (params) => inst.check(core._jwt(exports2.ZodJWT, params));
      inst.emoji = (params) => inst.check(core._emoji(exports2.ZodEmoji, params));
      inst.guid = (params) => inst.check(core._guid(exports2.ZodGUID, params));
      inst.uuid = (params) => inst.check(core._uuid(exports2.ZodUUID, params));
      inst.uuidv4 = (params) => inst.check(core._uuidv4(exports2.ZodUUID, params));
      inst.uuidv6 = (params) => inst.check(core._uuidv6(exports2.ZodUUID, params));
      inst.uuidv7 = (params) => inst.check(core._uuidv7(exports2.ZodUUID, params));
      inst.nanoid = (params) => inst.check(core._nanoid(exports2.ZodNanoID, params));
      inst.guid = (params) => inst.check(core._guid(exports2.ZodGUID, params));
      inst.cuid = (params) => inst.check(core._cuid(exports2.ZodCUID, params));
      inst.cuid2 = (params) => inst.check(core._cuid2(exports2.ZodCUID2, params));
      inst.ulid = (params) => inst.check(core._ulid(exports2.ZodULID, params));
      inst.base64 = (params) => inst.check(core._base64(exports2.ZodBase64, params));
      inst.base64url = (params) => inst.check(core._base64url(exports2.ZodBase64URL, params));
      inst.xid = (params) => inst.check(core._xid(exports2.ZodXID, params));
      inst.ksuid = (params) => inst.check(core._ksuid(exports2.ZodKSUID, params));
      inst.ipv4 = (params) => inst.check(core._ipv4(exports2.ZodIPv4, params));
      inst.ipv6 = (params) => inst.check(core._ipv6(exports2.ZodIPv6, params));
      inst.cidrv4 = (params) => inst.check(core._cidrv4(exports2.ZodCIDRv4, params));
      inst.cidrv6 = (params) => inst.check(core._cidrv6(exports2.ZodCIDRv6, params));
      inst.e164 = (params) => inst.check(core._e164(exports2.ZodE164, params));
      inst.datetime = (params) => inst.check(iso.datetime(params));
      inst.date = (params) => inst.check(iso.date(params));
      inst.time = (params) => inst.check(iso.time(params));
      inst.duration = (params) => inst.check(iso.duration(params));
    });
    function string5(params) {
      return core._string(exports2.ZodString, params);
    }
    exports2.ZodStringFormat = core.$constructor("ZodStringFormat", (inst, def) => {
      core.$ZodStringFormat.init(inst, def);
      exports2._ZodString.init(inst, def);
    });
    exports2.ZodEmail = core.$constructor("ZodEmail", (inst, def) => {
      core.$ZodEmail.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function email4(params) {
      return core._email(exports2.ZodEmail, params);
    }
    exports2.ZodGUID = core.$constructor("ZodGUID", (inst, def) => {
      core.$ZodGUID.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function guid4(params) {
      return core._guid(exports2.ZodGUID, params);
    }
    exports2.ZodUUID = core.$constructor("ZodUUID", (inst, def) => {
      core.$ZodUUID.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function uuid5(params) {
      return core._uuid(exports2.ZodUUID, params);
    }
    function uuidv43(params) {
      return core._uuidv4(exports2.ZodUUID, params);
    }
    function uuidv63(params) {
      return core._uuidv6(exports2.ZodUUID, params);
    }
    function uuidv73(params) {
      return core._uuidv7(exports2.ZodUUID, params);
    }
    exports2.ZodURL = core.$constructor("ZodURL", (inst, def) => {
      core.$ZodURL.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function url4(params) {
      return core._url(exports2.ZodURL, params);
    }
    function httpUrl3(params) {
      return core._url(exports2.ZodURL, {
        protocol: /^https?$/,
        hostname: core.regexes.domain,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodEmoji = core.$constructor("ZodEmoji", (inst, def) => {
      core.$ZodEmoji.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function emoji4(params) {
      return core._emoji(exports2.ZodEmoji, params);
    }
    exports2.ZodNanoID = core.$constructor("ZodNanoID", (inst, def) => {
      core.$ZodNanoID.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function nanoid4(params) {
      return core._nanoid(exports2.ZodNanoID, params);
    }
    exports2.ZodCUID = core.$constructor("ZodCUID", (inst, def) => {
      core.$ZodCUID.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function cuid5(params) {
      return core._cuid(exports2.ZodCUID, params);
    }
    exports2.ZodCUID2 = core.$constructor("ZodCUID2", (inst, def) => {
      core.$ZodCUID2.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function cuid24(params) {
      return core._cuid2(exports2.ZodCUID2, params);
    }
    exports2.ZodULID = core.$constructor("ZodULID", (inst, def) => {
      core.$ZodULID.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function ulid4(params) {
      return core._ulid(exports2.ZodULID, params);
    }
    exports2.ZodXID = core.$constructor("ZodXID", (inst, def) => {
      core.$ZodXID.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function xid4(params) {
      return core._xid(exports2.ZodXID, params);
    }
    exports2.ZodKSUID = core.$constructor("ZodKSUID", (inst, def) => {
      core.$ZodKSUID.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function ksuid4(params) {
      return core._ksuid(exports2.ZodKSUID, params);
    }
    exports2.ZodIPv4 = core.$constructor("ZodIPv4", (inst, def) => {
      core.$ZodIPv4.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function ipv44(params) {
      return core._ipv4(exports2.ZodIPv4, params);
    }
    exports2.ZodMAC = core.$constructor("ZodMAC", (inst, def) => {
      core.$ZodMAC.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function mac4(params) {
      return core._mac(exports2.ZodMAC, params);
    }
    exports2.ZodIPv6 = core.$constructor("ZodIPv6", (inst, def) => {
      core.$ZodIPv6.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function ipv64(params) {
      return core._ipv6(exports2.ZodIPv6, params);
    }
    exports2.ZodCIDRv4 = core.$constructor("ZodCIDRv4", (inst, def) => {
      core.$ZodCIDRv4.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function cidrv44(params) {
      return core._cidrv4(exports2.ZodCIDRv4, params);
    }
    exports2.ZodCIDRv6 = core.$constructor("ZodCIDRv6", (inst, def) => {
      core.$ZodCIDRv6.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function cidrv64(params) {
      return core._cidrv6(exports2.ZodCIDRv6, params);
    }
    exports2.ZodBase64 = core.$constructor("ZodBase64", (inst, def) => {
      core.$ZodBase64.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function base644(params) {
      return core._base64(exports2.ZodBase64, params);
    }
    exports2.ZodBase64URL = core.$constructor("ZodBase64URL", (inst, def) => {
      core.$ZodBase64URL.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function base64url4(params) {
      return core._base64url(exports2.ZodBase64URL, params);
    }
    exports2.ZodE164 = core.$constructor("ZodE164", (inst, def) => {
      core.$ZodE164.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function e1644(params) {
      return core._e164(exports2.ZodE164, params);
    }
    exports2.ZodJWT = core.$constructor("ZodJWT", (inst, def) => {
      core.$ZodJWT.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function jwt4(params) {
      return core._jwt(exports2.ZodJWT, params);
    }
    exports2.ZodCustomStringFormat = core.$constructor("ZodCustomStringFormat", (inst, def) => {
      core.$ZodCustomStringFormat.init(inst, def);
      exports2.ZodStringFormat.init(inst, def);
    });
    function stringFormat3(format, fnOrRegex, _params = {}) {
      return core._stringFormat(exports2.ZodCustomStringFormat, format, fnOrRegex, _params);
    }
    function hostname4(_params) {
      return core._stringFormat(exports2.ZodCustomStringFormat, "hostname", core.regexes.hostname, _params);
    }
    function hex4(_params) {
      return core._stringFormat(exports2.ZodCustomStringFormat, "hex", core.regexes.hex, _params);
    }
    function hash3(alg, params) {
      const enc = params?.enc ?? "hex";
      const format = `${alg}_${enc}`;
      const regex = core.regexes[format];
      if (!regex)
        throw new Error(`Unrecognized hash format: ${format}`);
      return core._stringFormat(exports2.ZodCustomStringFormat, format, regex, params);
    }
    exports2.ZodNumber = core.$constructor("ZodNumber", (inst, def) => {
      core.$ZodNumber.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.numberProcessor(inst, ctx, json5, params);
      inst.gt = (value, params) => inst.check(checks.gt(value, params));
      inst.gte = (value, params) => inst.check(checks.gte(value, params));
      inst.min = (value, params) => inst.check(checks.gte(value, params));
      inst.lt = (value, params) => inst.check(checks.lt(value, params));
      inst.lte = (value, params) => inst.check(checks.lte(value, params));
      inst.max = (value, params) => inst.check(checks.lte(value, params));
      inst.int = (params) => inst.check(int3(params));
      inst.safe = (params) => inst.check(int3(params));
      inst.positive = (params) => inst.check(checks.gt(0, params));
      inst.nonnegative = (params) => inst.check(checks.gte(0, params));
      inst.negative = (params) => inst.check(checks.lt(0, params));
      inst.nonpositive = (params) => inst.check(checks.lte(0, params));
      inst.multipleOf = (value, params) => inst.check(checks.multipleOf(value, params));
      inst.step = (value, params) => inst.check(checks.multipleOf(value, params));
      inst.finite = () => inst;
      const bag = inst._zod.bag;
      inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
      inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
      inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
      inst.isFinite = true;
      inst.format = bag.format ?? null;
    });
    function number5(params) {
      return core._number(exports2.ZodNumber, params);
    }
    exports2.ZodNumberFormat = core.$constructor("ZodNumberFormat", (inst, def) => {
      core.$ZodNumberFormat.init(inst, def);
      exports2.ZodNumber.init(inst, def);
    });
    function int3(params) {
      return core._int(exports2.ZodNumberFormat, params);
    }
    function float323(params) {
      return core._float32(exports2.ZodNumberFormat, params);
    }
    function float643(params) {
      return core._float64(exports2.ZodNumberFormat, params);
    }
    function int323(params) {
      return core._int32(exports2.ZodNumberFormat, params);
    }
    function uint323(params) {
      return core._uint32(exports2.ZodNumberFormat, params);
    }
    exports2.ZodBoolean = core.$constructor("ZodBoolean", (inst, def) => {
      core.$ZodBoolean.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.booleanProcessor(inst, ctx, json5, params);
    });
    function boolean5(params) {
      return core._boolean(exports2.ZodBoolean, params);
    }
    exports2.ZodBigInt = core.$constructor("ZodBigInt", (inst, def) => {
      core.$ZodBigInt.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.bigintProcessor(inst, ctx, json5, params);
      inst.gte = (value, params) => inst.check(checks.gte(value, params));
      inst.min = (value, params) => inst.check(checks.gte(value, params));
      inst.gt = (value, params) => inst.check(checks.gt(value, params));
      inst.gte = (value, params) => inst.check(checks.gte(value, params));
      inst.min = (value, params) => inst.check(checks.gte(value, params));
      inst.lt = (value, params) => inst.check(checks.lt(value, params));
      inst.lte = (value, params) => inst.check(checks.lte(value, params));
      inst.max = (value, params) => inst.check(checks.lte(value, params));
      inst.positive = (params) => inst.check(checks.gt(BigInt(0), params));
      inst.negative = (params) => inst.check(checks.lt(BigInt(0), params));
      inst.nonpositive = (params) => inst.check(checks.lte(BigInt(0), params));
      inst.nonnegative = (params) => inst.check(checks.gte(BigInt(0), params));
      inst.multipleOf = (value, params) => inst.check(checks.multipleOf(value, params));
      const bag = inst._zod.bag;
      inst.minValue = bag.minimum ?? null;
      inst.maxValue = bag.maximum ?? null;
      inst.format = bag.format ?? null;
    });
    function bigint5(params) {
      return core._bigint(exports2.ZodBigInt, params);
    }
    exports2.ZodBigIntFormat = core.$constructor("ZodBigIntFormat", (inst, def) => {
      core.$ZodBigIntFormat.init(inst, def);
      exports2.ZodBigInt.init(inst, def);
    });
    function int643(params) {
      return core._int64(exports2.ZodBigIntFormat, params);
    }
    function uint643(params) {
      return core._uint64(exports2.ZodBigIntFormat, params);
    }
    exports2.ZodSymbol = core.$constructor("ZodSymbol", (inst, def) => {
      core.$ZodSymbol.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.symbolProcessor(inst, ctx, json5, params);
    });
    function symbol30(params) {
      return core._symbol(exports2.ZodSymbol, params);
    }
    exports2.ZodUndefined = core.$constructor("ZodUndefined", (inst, def) => {
      core.$ZodUndefined.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.undefinedProcessor(inst, ctx, json5, params);
    });
    function _undefined5(params) {
      return core._undefined(exports2.ZodUndefined, params);
    }
    exports2.ZodNull = core.$constructor("ZodNull", (inst, def) => {
      core.$ZodNull.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.nullProcessor(inst, ctx, json5, params);
    });
    function _null5(params) {
      return core._null(exports2.ZodNull, params);
    }
    exports2.ZodAny = core.$constructor("ZodAny", (inst, def) => {
      core.$ZodAny.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.anyProcessor(inst, ctx, json5, params);
    });
    function any3() {
      return core._any(exports2.ZodAny);
    }
    exports2.ZodUnknown = core.$constructor("ZodUnknown", (inst, def) => {
      core.$ZodUnknown.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.unknownProcessor(inst, ctx, json5, params);
    });
    function unknown3() {
      return core._unknown(exports2.ZodUnknown);
    }
    exports2.ZodNever = core.$constructor("ZodNever", (inst, def) => {
      core.$ZodNever.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.neverProcessor(inst, ctx, json5, params);
    });
    function never3(params) {
      return core._never(exports2.ZodNever, params);
    }
    exports2.ZodVoid = core.$constructor("ZodVoid", (inst, def) => {
      core.$ZodVoid.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.voidProcessor(inst, ctx, json5, params);
    });
    function _void4(params) {
      return core._void(exports2.ZodVoid, params);
    }
    exports2.ZodDate = core.$constructor("ZodDate", (inst, def) => {
      core.$ZodDate.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.dateProcessor(inst, ctx, json5, params);
      inst.min = (value, params) => inst.check(checks.gte(value, params));
      inst.max = (value, params) => inst.check(checks.lte(value, params));
      const c = inst._zod.bag;
      inst.minDate = c.minimum ? new Date(c.minimum) : null;
      inst.maxDate = c.maximum ? new Date(c.maximum) : null;
    });
    function date6(params) {
      return core._date(exports2.ZodDate, params);
    }
    exports2.ZodArray = core.$constructor("ZodArray", (inst, def) => {
      core.$ZodArray.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.arrayProcessor(inst, ctx, json5, params);
      inst.element = def.element;
      inst.min = (minLength, params) => inst.check(checks.minLength(minLength, params));
      inst.nonempty = (params) => inst.check(checks.minLength(1, params));
      inst.max = (maxLength, params) => inst.check(checks.maxLength(maxLength, params));
      inst.length = (len, params) => inst.check(checks.length(len, params));
      inst.unwrap = () => inst.element;
    });
    function array4(element, params) {
      return core._array(exports2.ZodArray, element, params);
    }
    function keyof3(schema) {
      const shape = schema._zod.def.shape;
      return _enum4(Object.keys(shape));
    }
    exports2.ZodObject = core.$constructor("ZodObject", (inst, def) => {
      core.$ZodObjectJIT.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.objectProcessor(inst, ctx, json5, params);
      index_js_1.util.defineLazy(inst, "shape", () => {
        return def.shape;
      });
      inst.keyof = () => _enum4(Object.keys(inst._zod.def.shape));
      inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
      inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown3() });
      inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown3() });
      inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never3() });
      inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
      inst.extend = (incoming) => {
        return index_js_1.util.extend(inst, incoming);
      };
      inst.safeExtend = (incoming) => {
        return index_js_1.util.safeExtend(inst, incoming);
      };
      inst.merge = (other) => index_js_1.util.merge(inst, other);
      inst.pick = (mask) => index_js_1.util.pick(inst, mask);
      inst.omit = (mask) => index_js_1.util.omit(inst, mask);
      inst.partial = (...args) => index_js_1.util.partial(exports2.ZodOptional, inst, args[0]);
      inst.required = (...args) => index_js_1.util.required(exports2.ZodNonOptional, inst, args[0]);
    });
    function object4(shape, params) {
      const def = {
        type: "object",
        shape: shape ?? {},
        ...index_js_1.util.normalizeParams(params)
      };
      return new exports2.ZodObject(def);
    }
    function strictObject3(shape, params) {
      return new exports2.ZodObject({
        type: "object",
        shape,
        catchall: never3(),
        ...index_js_1.util.normalizeParams(params)
      });
    }
    function looseObject3(shape, params) {
      return new exports2.ZodObject({
        type: "object",
        shape,
        catchall: unknown3(),
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodUnion = core.$constructor("ZodUnion", (inst, def) => {
      core.$ZodUnion.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.unionProcessor(inst, ctx, json5, params);
      inst.options = def.options;
    });
    function union3(options, params) {
      return new exports2.ZodUnion({
        type: "union",
        options,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodXor = core.$constructor("ZodXor", (inst, def) => {
      exports2.ZodUnion.init(inst, def);
      core.$ZodXor.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.unionProcessor(inst, ctx, json5, params);
      inst.options = def.options;
    });
    function xor3(options, params) {
      return new exports2.ZodXor({
        type: "union",
        options,
        inclusive: false,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodDiscriminatedUnion = core.$constructor("ZodDiscriminatedUnion", (inst, def) => {
      exports2.ZodUnion.init(inst, def);
      core.$ZodDiscriminatedUnion.init(inst, def);
    });
    function discriminatedUnion3(discriminator, options, params) {
      return new exports2.ZodDiscriminatedUnion({
        type: "union",
        options,
        discriminator,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodIntersection = core.$constructor("ZodIntersection", (inst, def) => {
      core.$ZodIntersection.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.intersectionProcessor(inst, ctx, json5, params);
    });
    function intersection3(left, right) {
      return new exports2.ZodIntersection({
        type: "intersection",
        left,
        right
      });
    }
    exports2.ZodTuple = core.$constructor("ZodTuple", (inst, def) => {
      core.$ZodTuple.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.tupleProcessor(inst, ctx, json5, params);
      inst.rest = (rest) => inst.clone({
        ...inst._zod.def,
        rest
      });
    });
    function tuple3(items, _paramsOrRest, _params) {
      const hasRest = _paramsOrRest instanceof core.$ZodType;
      const params = hasRest ? _params : _paramsOrRest;
      const rest = hasRest ? _paramsOrRest : null;
      return new exports2.ZodTuple({
        type: "tuple",
        items,
        rest,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodRecord = core.$constructor("ZodRecord", (inst, def) => {
      core.$ZodRecord.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.recordProcessor(inst, ctx, json5, params);
      inst.keyType = def.keyType;
      inst.valueType = def.valueType;
    });
    function record3(keyType, valueType, params) {
      return new exports2.ZodRecord({
        type: "record",
        keyType,
        valueType,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    function partialRecord3(keyType, valueType, params) {
      const k = core.clone(keyType);
      k._zod.values = void 0;
      return new exports2.ZodRecord({
        type: "record",
        keyType: k,
        valueType,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    function looseRecord3(keyType, valueType, params) {
      return new exports2.ZodRecord({
        type: "record",
        keyType,
        valueType,
        mode: "loose",
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodMap = core.$constructor("ZodMap", (inst, def) => {
      core.$ZodMap.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.mapProcessor(inst, ctx, json5, params);
      inst.keyType = def.keyType;
      inst.valueType = def.valueType;
      inst.min = (...args) => inst.check(core._minSize(...args));
      inst.nonempty = (params) => inst.check(core._minSize(1, params));
      inst.max = (...args) => inst.check(core._maxSize(...args));
      inst.size = (...args) => inst.check(core._size(...args));
    });
    function map3(keyType, valueType, params) {
      return new exports2.ZodMap({
        type: "map",
        keyType,
        valueType,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodSet = core.$constructor("ZodSet", (inst, def) => {
      core.$ZodSet.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.setProcessor(inst, ctx, json5, params);
      inst.min = (...args) => inst.check(core._minSize(...args));
      inst.nonempty = (params) => inst.check(core._minSize(1, params));
      inst.max = (...args) => inst.check(core._maxSize(...args));
      inst.size = (...args) => inst.check(core._size(...args));
    });
    function set3(valueType, params) {
      return new exports2.ZodSet({
        type: "set",
        valueType,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodEnum = core.$constructor("ZodEnum", (inst, def) => {
      core.$ZodEnum.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.enumProcessor(inst, ctx, json5, params);
      inst.enum = def.entries;
      inst.options = Object.values(def.entries);
      const keys2 = new Set(Object.keys(def.entries));
      inst.extract = (values, params) => {
        const newEntries = {};
        for (const value of values) {
          if (keys2.has(value)) {
            newEntries[value] = def.entries[value];
          } else
            throw new Error(`Key ${value} not found in enum`);
        }
        return new exports2.ZodEnum({
          ...def,
          checks: [],
          ...index_js_1.util.normalizeParams(params),
          entries: newEntries
        });
      };
      inst.exclude = (values, params) => {
        const newEntries = { ...def.entries };
        for (const value of values) {
          if (keys2.has(value)) {
            delete newEntries[value];
          } else
            throw new Error(`Key ${value} not found in enum`);
        }
        return new exports2.ZodEnum({
          ...def,
          checks: [],
          ...index_js_1.util.normalizeParams(params),
          entries: newEntries
        });
      };
    });
    function _enum4(values, params) {
      const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
      return new exports2.ZodEnum({
        type: "enum",
        entries,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    function nativeEnum3(entries, params) {
      return new exports2.ZodEnum({
        type: "enum",
        entries,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodLiteral = core.$constructor("ZodLiteral", (inst, def) => {
      core.$ZodLiteral.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.literalProcessor(inst, ctx, json5, params);
      inst.values = new Set(def.values);
      Object.defineProperty(inst, "value", {
        get() {
          if (def.values.length > 1) {
            throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
          }
          return def.values[0];
        }
      });
    });
    function literal3(value, params) {
      return new exports2.ZodLiteral({
        type: "literal",
        values: Array.isArray(value) ? value : [value],
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodFile = core.$constructor("ZodFile", (inst, def) => {
      core.$ZodFile.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.fileProcessor(inst, ctx, json5, params);
      inst.min = (size, params) => inst.check(core._minSize(size, params));
      inst.max = (size, params) => inst.check(core._maxSize(size, params));
      inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));
    });
    function file3(params) {
      return core._file(exports2.ZodFile, params);
    }
    exports2.ZodTransform = core.$constructor("ZodTransform", (inst, def) => {
      core.$ZodTransform.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.transformProcessor(inst, ctx, json5, params);
      inst._zod.parse = (payload, _ctx) => {
        if (_ctx.direction === "backward") {
          throw new core.$ZodEncodeError(inst.constructor.name);
        }
        payload.addIssue = (issue3) => {
          if (typeof issue3 === "string") {
            payload.issues.push(index_js_1.util.issue(issue3, payload.value, def));
          } else {
            const _issue = issue3;
            if (_issue.fatal)
              _issue.continue = false;
            _issue.code ?? (_issue.code = "custom");
            _issue.input ?? (_issue.input = payload.value);
            _issue.inst ?? (_issue.inst = inst);
            payload.issues.push(index_js_1.util.issue(_issue));
          }
        };
        const output = def.transform(payload.value, payload);
        if (output instanceof Promise) {
          return output.then((output2) => {
            payload.value = output2;
            return payload;
          });
        }
        payload.value = output;
        return payload;
      };
    });
    function transform8(fn) {
      return new exports2.ZodTransform({
        type: "transform",
        transform: fn
      });
    }
    exports2.ZodOptional = core.$constructor("ZodOptional", (inst, def) => {
      core.$ZodOptional.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.optionalProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    function optional3(innerType) {
      return new exports2.ZodOptional({
        type: "optional",
        innerType
      });
    }
    exports2.ZodExactOptional = core.$constructor("ZodExactOptional", (inst, def) => {
      core.$ZodExactOptional.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.optionalProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    function exactOptional3(innerType) {
      return new exports2.ZodExactOptional({
        type: "optional",
        innerType
      });
    }
    exports2.ZodNullable = core.$constructor("ZodNullable", (inst, def) => {
      core.$ZodNullable.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.nullableProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    function nullable3(innerType) {
      return new exports2.ZodNullable({
        type: "nullable",
        innerType
      });
    }
    function nullish4(innerType) {
      return optional3(nullable3(innerType));
    }
    exports2.ZodDefault = core.$constructor("ZodDefault", (inst, def) => {
      core.$ZodDefault.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.defaultProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
      inst.removeDefault = inst.unwrap;
    });
    function _default4(innerType, defaultValue) {
      return new exports2.ZodDefault({
        type: "default",
        innerType,
        get defaultValue() {
          return typeof defaultValue === "function" ? defaultValue() : index_js_1.util.shallowClone(defaultValue);
        }
      });
    }
    exports2.ZodPrefault = core.$constructor("ZodPrefault", (inst, def) => {
      core.$ZodPrefault.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.prefaultProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    function prefault3(innerType, defaultValue) {
      return new exports2.ZodPrefault({
        type: "prefault",
        innerType,
        get defaultValue() {
          return typeof defaultValue === "function" ? defaultValue() : index_js_1.util.shallowClone(defaultValue);
        }
      });
    }
    exports2.ZodNonOptional = core.$constructor("ZodNonOptional", (inst, def) => {
      core.$ZodNonOptional.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.nonoptionalProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    function nonoptional3(innerType, params) {
      return new exports2.ZodNonOptional({
        type: "nonoptional",
        innerType,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodSuccess = core.$constructor("ZodSuccess", (inst, def) => {
      core.$ZodSuccess.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.successProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    function success5(innerType) {
      return new exports2.ZodSuccess({
        type: "success",
        innerType
      });
    }
    exports2.ZodCatch = core.$constructor("ZodCatch", (inst, def) => {
      core.$ZodCatch.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.catchProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
      inst.removeCatch = inst.unwrap;
    });
    function _catch4(innerType, catchValue) {
      return new exports2.ZodCatch({
        type: "catch",
        innerType,
        catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
      });
    }
    exports2.ZodNaN = core.$constructor("ZodNaN", (inst, def) => {
      core.$ZodNaN.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.nanProcessor(inst, ctx, json5, params);
    });
    function nan3(params) {
      return core._nan(exports2.ZodNaN, params);
    }
    exports2.ZodPipe = core.$constructor("ZodPipe", (inst, def) => {
      core.$ZodPipe.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.pipeProcessor(inst, ctx, json5, params);
      inst.in = def.in;
      inst.out = def.out;
    });
    function pipe3(in_, out) {
      return new exports2.ZodPipe({
        type: "pipe",
        in: in_,
        out
        // ...util.normalizeParams(params),
      });
    }
    exports2.ZodCodec = core.$constructor("ZodCodec", (inst, def) => {
      exports2.ZodPipe.init(inst, def);
      core.$ZodCodec.init(inst, def);
    });
    function codec3(in_, out, params) {
      return new exports2.ZodCodec({
        type: "pipe",
        in: in_,
        out,
        transform: params.decode,
        reverseTransform: params.encode
      });
    }
    exports2.ZodReadonly = core.$constructor("ZodReadonly", (inst, def) => {
      core.$ZodReadonly.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.readonlyProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    function readonly3(innerType) {
      return new exports2.ZodReadonly({
        type: "readonly",
        innerType
      });
    }
    exports2.ZodTemplateLiteral = core.$constructor("ZodTemplateLiteral", (inst, def) => {
      core.$ZodTemplateLiteral.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.templateLiteralProcessor(inst, ctx, json5, params);
    });
    function templateLiteral3(parts, params) {
      return new exports2.ZodTemplateLiteral({
        type: "template_literal",
        parts,
        ...index_js_1.util.normalizeParams(params)
      });
    }
    exports2.ZodLazy = core.$constructor("ZodLazy", (inst, def) => {
      core.$ZodLazy.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.lazyProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.getter();
    });
    function lazy3(getter) {
      return new exports2.ZodLazy({
        type: "lazy",
        getter
      });
    }
    exports2.ZodPromise = core.$constructor("ZodPromise", (inst, def) => {
      core.$ZodPromise.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.promiseProcessor(inst, ctx, json5, params);
      inst.unwrap = () => inst._zod.def.innerType;
    });
    function promise3(innerType) {
      return new exports2.ZodPromise({
        type: "promise",
        innerType
      });
    }
    exports2.ZodFunction = core.$constructor("ZodFunction", (inst, def) => {
      core.$ZodFunction.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.functionProcessor(inst, ctx, json5, params);
    });
    function _function3(params) {
      return new exports2.ZodFunction({
        type: "function",
        input: Array.isArray(params?.input) ? tuple3(params?.input) : params?.input ?? array4(unknown3()),
        output: params?.output ?? unknown3()
      });
    }
    exports2.ZodCustom = core.$constructor("ZodCustom", (inst, def) => {
      core.$ZodCustom.init(inst, def);
      exports2.ZodType.init(inst, def);
      inst._zod.processJSONSchema = (ctx, json5, params) => processors.customProcessor(inst, ctx, json5, params);
    });
    function check3(fn) {
      const ch = new core.$ZodCheck({
        check: "custom"
        // ...util.normalizeParams(params),
      });
      ch._zod.check = fn;
      return ch;
    }
    function custom3(fn, _params) {
      return core._custom(exports2.ZodCustom, fn ?? (() => true), _params);
    }
    function refine3(fn, _params = {}) {
      return core._refine(exports2.ZodCustom, fn, _params);
    }
    function superRefine3(fn) {
      return core._superRefine(fn);
    }
    exports2.describe = core.describe;
    exports2.meta = core.meta;
    function _instanceof3(cls, params = {}) {
      const inst = new exports2.ZodCustom({
        type: "custom",
        check: "custom",
        fn: (data) => data instanceof cls,
        abort: true,
        ...index_js_1.util.normalizeParams(params)
      });
      inst._zod.bag.Class = cls;
      inst._zod.check = (payload) => {
        if (!(payload.value instanceof cls)) {
          payload.issues.push({
            code: "invalid_type",
            expected: cls.name,
            input: payload.value,
            inst,
            path: [...inst._zod.def.path ?? []]
          });
        }
      };
      return inst;
    }
    var stringbool3 = (...args) => core._stringbool({
      Codec: exports2.ZodCodec,
      Boolean: exports2.ZodBoolean,
      String: exports2.ZodString
    }, ...args);
    exports2.stringbool = stringbool3;
    function json4(params) {
      const jsonSchema4 = lazy3(() => {
        return union3([string5(params), number5(), boolean5(), _null5(), array4(jsonSchema4), record3(string5(), jsonSchema4)]);
      });
      return jsonSchema4;
    }
    function preprocess3(fn, schema) {
      return pipe3(transform8(fn), schema);
    }
  }
});

// node_modules/zod/v4/classic/compat.cjs
var require_compat = __commonJS({
  "node_modules/zod/v4/classic/compat.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ZodFirstPartyTypeKind = exports2.config = exports2.$brand = exports2.ZodIssueCode = void 0;
    exports2.setErrorMap = setErrorMap3;
    exports2.getErrorMap = getErrorMap4;
    var core = __importStar(require_core2());
    exports2.ZodIssueCode = {
      invalid_type: "invalid_type",
      too_big: "too_big",
      too_small: "too_small",
      invalid_format: "invalid_format",
      not_multiple_of: "not_multiple_of",
      unrecognized_keys: "unrecognized_keys",
      invalid_union: "invalid_union",
      invalid_key: "invalid_key",
      invalid_element: "invalid_element",
      invalid_value: "invalid_value",
      custom: "custom"
    };
    var index_js_1 = require_core2();
    Object.defineProperty(exports2, "$brand", { enumerable: true, get: function() {
      return index_js_1.$brand;
    } });
    Object.defineProperty(exports2, "config", { enumerable: true, get: function() {
      return index_js_1.config;
    } });
    function setErrorMap3(map3) {
      core.config({
        customError: map3
      });
    }
    function getErrorMap4() {
      return core.config().customError;
    }
    var ZodFirstPartyTypeKind4;
    /* @__PURE__ */ (function(ZodFirstPartyTypeKind5) {
    })(ZodFirstPartyTypeKind4 || (exports2.ZodFirstPartyTypeKind = ZodFirstPartyTypeKind4 = {}));
  }
});

// node_modules/zod/v4/classic/from-json-schema.cjs
var require_from_json_schema = __commonJS({
  "node_modules/zod/v4/classic/from-json-schema.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.fromJSONSchema = fromJSONSchema3;
    var registries_js_1 = require_registries();
    var _checks = __importStar(require_checks2());
    var _iso = __importStar(require_iso());
    var _schemas = __importStar(require_schemas2());
    var z3 = {
      ..._schemas,
      ..._checks,
      iso: _iso
    };
    var RECOGNIZED_KEYS3 = /* @__PURE__ */ new Set([
      // Schema identification
      "$schema",
      "$ref",
      "$defs",
      "definitions",
      // Core schema keywords
      "$id",
      "id",
      "$comment",
      "$anchor",
      "$vocabulary",
      "$dynamicRef",
      "$dynamicAnchor",
      // Type
      "type",
      "enum",
      "const",
      // Composition
      "anyOf",
      "oneOf",
      "allOf",
      "not",
      // Object
      "properties",
      "required",
      "additionalProperties",
      "patternProperties",
      "propertyNames",
      "minProperties",
      "maxProperties",
      // Array
      "items",
      "prefixItems",
      "additionalItems",
      "minItems",
      "maxItems",
      "uniqueItems",
      "contains",
      "minContains",
      "maxContains",
      // String
      "minLength",
      "maxLength",
      "pattern",
      "format",
      // Number
      "minimum",
      "maximum",
      "exclusiveMinimum",
      "exclusiveMaximum",
      "multipleOf",
      // Already handled metadata
      "description",
      "default",
      // Content
      "contentEncoding",
      "contentMediaType",
      "contentSchema",
      // Unsupported (error-throwing)
      "unevaluatedItems",
      "unevaluatedProperties",
      "if",
      "then",
      "else",
      "dependentSchemas",
      "dependentRequired",
      // OpenAPI
      "nullable",
      "readOnly"
    ]);
    function detectVersion3(schema, defaultTarget) {
      const $schema = schema.$schema;
      if ($schema === "https://json-schema.org/draft/2020-12/schema") {
        return "draft-2020-12";
      }
      if ($schema === "http://json-schema.org/draft-07/schema#") {
        return "draft-7";
      }
      if ($schema === "http://json-schema.org/draft-04/schema#") {
        return "draft-4";
      }
      return defaultTarget ?? "draft-2020-12";
    }
    function resolveRef3(ref, ctx) {
      if (!ref.startsWith("#")) {
        throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
      }
      const path33 = ref.slice(1).split("/").filter(Boolean);
      if (path33.length === 0) {
        return ctx.rootSchema;
      }
      const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
      if (path33[0] === defsKey) {
        const key = path33[1];
        if (!key || !ctx.defs[key]) {
          throw new Error(`Reference not found: ${ref}`);
        }
        return ctx.defs[key];
      }
      throw new Error(`Reference not found: ${ref}`);
    }
    function convertBaseSchema3(schema, ctx) {
      if (schema.not !== void 0) {
        if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
          return z3.never();
        }
        throw new Error("not is not supported in Zod (except { not: {} } for never)");
      }
      if (schema.unevaluatedItems !== void 0) {
        throw new Error("unevaluatedItems is not supported");
      }
      if (schema.unevaluatedProperties !== void 0) {
        throw new Error("unevaluatedProperties is not supported");
      }
      if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
        throw new Error("Conditional schemas (if/then/else) are not supported");
      }
      if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
        throw new Error("dependentSchemas and dependentRequired are not supported");
      }
      if (schema.$ref) {
        const refPath = schema.$ref;
        if (ctx.refs.has(refPath)) {
          return ctx.refs.get(refPath);
        }
        if (ctx.processing.has(refPath)) {
          return z3.lazy(() => {
            if (!ctx.refs.has(refPath)) {
              throw new Error(`Circular reference not resolved: ${refPath}`);
            }
            return ctx.refs.get(refPath);
          });
        }
        ctx.processing.add(refPath);
        const resolved = resolveRef3(refPath, ctx);
        const zodSchema5 = convertSchema3(resolved, ctx);
        ctx.refs.set(refPath, zodSchema5);
        ctx.processing.delete(refPath);
        return zodSchema5;
      }
      if (schema.enum !== void 0) {
        const enumValues = schema.enum;
        if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
          return z3.null();
        }
        if (enumValues.length === 0) {
          return z3.never();
        }
        if (enumValues.length === 1) {
          return z3.literal(enumValues[0]);
        }
        if (enumValues.every((v) => typeof v === "string")) {
          return z3.enum(enumValues);
        }
        const literalSchemas = enumValues.map((v) => z3.literal(v));
        if (literalSchemas.length < 2) {
          return literalSchemas[0];
        }
        return z3.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
      }
      if (schema.const !== void 0) {
        return z3.literal(schema.const);
      }
      const type = schema.type;
      if (Array.isArray(type)) {
        const typeSchemas = type.map((t) => {
          const typeSchema = { ...schema, type: t };
          return convertBaseSchema3(typeSchema, ctx);
        });
        if (typeSchemas.length === 0) {
          return z3.never();
        }
        if (typeSchemas.length === 1) {
          return typeSchemas[0];
        }
        return z3.union(typeSchemas);
      }
      if (!type) {
        return z3.any();
      }
      let zodSchema4;
      switch (type) {
        case "string": {
          let stringSchema = z3.string();
          if (schema.format) {
            const format = schema.format;
            if (format === "email") {
              stringSchema = stringSchema.check(z3.email());
            } else if (format === "uri" || format === "uri-reference") {
              stringSchema = stringSchema.check(z3.url());
            } else if (format === "uuid" || format === "guid") {
              stringSchema = stringSchema.check(z3.uuid());
            } else if (format === "date-time") {
              stringSchema = stringSchema.check(z3.iso.datetime());
            } else if (format === "date") {
              stringSchema = stringSchema.check(z3.iso.date());
            } else if (format === "time") {
              stringSchema = stringSchema.check(z3.iso.time());
            } else if (format === "duration") {
              stringSchema = stringSchema.check(z3.iso.duration());
            } else if (format === "ipv4") {
              stringSchema = stringSchema.check(z3.ipv4());
            } else if (format === "ipv6") {
              stringSchema = stringSchema.check(z3.ipv6());
            } else if (format === "mac") {
              stringSchema = stringSchema.check(z3.mac());
            } else if (format === "cidr") {
              stringSchema = stringSchema.check(z3.cidrv4());
            } else if (format === "cidr-v6") {
              stringSchema = stringSchema.check(z3.cidrv6());
            } else if (format === "base64") {
              stringSchema = stringSchema.check(z3.base64());
            } else if (format === "base64url") {
              stringSchema = stringSchema.check(z3.base64url());
            } else if (format === "e164") {
              stringSchema = stringSchema.check(z3.e164());
            } else if (format === "jwt") {
              stringSchema = stringSchema.check(z3.jwt());
            } else if (format === "emoji") {
              stringSchema = stringSchema.check(z3.emoji());
            } else if (format === "nanoid") {
              stringSchema = stringSchema.check(z3.nanoid());
            } else if (format === "cuid") {
              stringSchema = stringSchema.check(z3.cuid());
            } else if (format === "cuid2") {
              stringSchema = stringSchema.check(z3.cuid2());
            } else if (format === "ulid") {
              stringSchema = stringSchema.check(z3.ulid());
            } else if (format === "xid") {
              stringSchema = stringSchema.check(z3.xid());
            } else if (format === "ksuid") {
              stringSchema = stringSchema.check(z3.ksuid());
            }
          }
          if (typeof schema.minLength === "number") {
            stringSchema = stringSchema.min(schema.minLength);
          }
          if (typeof schema.maxLength === "number") {
            stringSchema = stringSchema.max(schema.maxLength);
          }
          if (schema.pattern) {
            stringSchema = stringSchema.regex(new RegExp(schema.pattern));
          }
          zodSchema4 = stringSchema;
          break;
        }
        case "number":
        case "integer": {
          let numberSchema = type === "integer" ? z3.number().int() : z3.number();
          if (typeof schema.minimum === "number") {
            numberSchema = numberSchema.min(schema.minimum);
          }
          if (typeof schema.maximum === "number") {
            numberSchema = numberSchema.max(schema.maximum);
          }
          if (typeof schema.exclusiveMinimum === "number") {
            numberSchema = numberSchema.gt(schema.exclusiveMinimum);
          } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
            numberSchema = numberSchema.gt(schema.minimum);
          }
          if (typeof schema.exclusiveMaximum === "number") {
            numberSchema = numberSchema.lt(schema.exclusiveMaximum);
          } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
            numberSchema = numberSchema.lt(schema.maximum);
          }
          if (typeof schema.multipleOf === "number") {
            numberSchema = numberSchema.multipleOf(schema.multipleOf);
          }
          zodSchema4 = numberSchema;
          break;
        }
        case "boolean": {
          zodSchema4 = z3.boolean();
          break;
        }
        case "null": {
          zodSchema4 = z3.null();
          break;
        }
        case "object": {
          const shape = {};
          const properties = schema.properties || {};
          const requiredSet = new Set(schema.required || []);
          for (const [key, propSchema] of Object.entries(properties)) {
            const propZodSchema = convertSchema3(propSchema, ctx);
            shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
          }
          if (schema.propertyNames) {
            const keySchema3 = convertSchema3(schema.propertyNames, ctx);
            const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema3(schema.additionalProperties, ctx) : z3.any();
            if (Object.keys(shape).length === 0) {
              zodSchema4 = z3.record(keySchema3, valueSchema);
              break;
            }
            const objectSchema2 = z3.object(shape).passthrough();
            const recordSchema = z3.looseRecord(keySchema3, valueSchema);
            zodSchema4 = z3.intersection(objectSchema2, recordSchema);
            break;
          }
          if (schema.patternProperties) {
            const patternProps = schema.patternProperties;
            const patternKeys = Object.keys(patternProps);
            const looseRecords = [];
            for (const pattern of patternKeys) {
              const patternValue = convertSchema3(patternProps[pattern], ctx);
              const keySchema3 = z3.string().regex(new RegExp(pattern));
              looseRecords.push(z3.looseRecord(keySchema3, patternValue));
            }
            const schemasToIntersect = [];
            if (Object.keys(shape).length > 0) {
              schemasToIntersect.push(z3.object(shape).passthrough());
            }
            schemasToIntersect.push(...looseRecords);
            if (schemasToIntersect.length === 0) {
              zodSchema4 = z3.object({}).passthrough();
            } else if (schemasToIntersect.length === 1) {
              zodSchema4 = schemasToIntersect[0];
            } else {
              let result = z3.intersection(schemasToIntersect[0], schemasToIntersect[1]);
              for (let i = 2; i < schemasToIntersect.length; i++) {
                result = z3.intersection(result, schemasToIntersect[i]);
              }
              zodSchema4 = result;
            }
            break;
          }
          const objectSchema = z3.object(shape);
          if (schema.additionalProperties === false) {
            zodSchema4 = objectSchema.strict();
          } else if (typeof schema.additionalProperties === "object") {
            zodSchema4 = objectSchema.catchall(convertSchema3(schema.additionalProperties, ctx));
          } else {
            zodSchema4 = objectSchema.passthrough();
          }
          break;
        }
        case "array": {
          const prefixItems = schema.prefixItems;
          const items = schema.items;
          if (prefixItems && Array.isArray(prefixItems)) {
            const tupleItems = prefixItems.map((item) => convertSchema3(item, ctx));
            const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema3(items, ctx) : void 0;
            if (rest) {
              zodSchema4 = z3.tuple(tupleItems).rest(rest);
            } else {
              zodSchema4 = z3.tuple(tupleItems);
            }
            if (typeof schema.minItems === "number") {
              zodSchema4 = zodSchema4.check(z3.minLength(schema.minItems));
            }
            if (typeof schema.maxItems === "number") {
              zodSchema4 = zodSchema4.check(z3.maxLength(schema.maxItems));
            }
          } else if (Array.isArray(items)) {
            const tupleItems = items.map((item) => convertSchema3(item, ctx));
            const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema3(schema.additionalItems, ctx) : void 0;
            if (rest) {
              zodSchema4 = z3.tuple(tupleItems).rest(rest);
            } else {
              zodSchema4 = z3.tuple(tupleItems);
            }
            if (typeof schema.minItems === "number") {
              zodSchema4 = zodSchema4.check(z3.minLength(schema.minItems));
            }
            if (typeof schema.maxItems === "number") {
              zodSchema4 = zodSchema4.check(z3.maxLength(schema.maxItems));
            }
          } else if (items !== void 0) {
            const element = convertSchema3(items, ctx);
            let arraySchema = z3.array(element);
            if (typeof schema.minItems === "number") {
              arraySchema = arraySchema.min(schema.minItems);
            }
            if (typeof schema.maxItems === "number") {
              arraySchema = arraySchema.max(schema.maxItems);
            }
            zodSchema4 = arraySchema;
          } else {
            zodSchema4 = z3.array(z3.any());
          }
          break;
        }
        default:
          throw new Error(`Unsupported type: ${type}`);
      }
      if (schema.description) {
        zodSchema4 = zodSchema4.describe(schema.description);
      }
      if (schema.default !== void 0) {
        zodSchema4 = zodSchema4.default(schema.default);
      }
      return zodSchema4;
    }
    function convertSchema3(schema, ctx) {
      if (typeof schema === "boolean") {
        return schema ? z3.any() : z3.never();
      }
      let baseSchema = convertBaseSchema3(schema, ctx);
      const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
      if (schema.anyOf && Array.isArray(schema.anyOf)) {
        const options = schema.anyOf.map((s) => convertSchema3(s, ctx));
        const anyOfUnion = z3.union(options);
        baseSchema = hasExplicitType ? z3.intersection(baseSchema, anyOfUnion) : anyOfUnion;
      }
      if (schema.oneOf && Array.isArray(schema.oneOf)) {
        const options = schema.oneOf.map((s) => convertSchema3(s, ctx));
        const oneOfUnion = z3.xor(options);
        baseSchema = hasExplicitType ? z3.intersection(baseSchema, oneOfUnion) : oneOfUnion;
      }
      if (schema.allOf && Array.isArray(schema.allOf)) {
        if (schema.allOf.length === 0) {
          baseSchema = hasExplicitType ? baseSchema : z3.any();
        } else {
          let result = hasExplicitType ? baseSchema : convertSchema3(schema.allOf[0], ctx);
          const startIdx = hasExplicitType ? 0 : 1;
          for (let i = startIdx; i < schema.allOf.length; i++) {
            result = z3.intersection(result, convertSchema3(schema.allOf[i], ctx));
          }
          baseSchema = result;
        }
      }
      if (schema.nullable === true && ctx.version === "openapi-3.0") {
        baseSchema = z3.nullable(baseSchema);
      }
      if (schema.readOnly === true) {
        baseSchema = z3.readonly(baseSchema);
      }
      const extraMeta = {};
      const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
      for (const key of coreMetadataKeys) {
        if (key in schema) {
          extraMeta[key] = schema[key];
        }
      }
      const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
      for (const key of contentMetadataKeys) {
        if (key in schema) {
          extraMeta[key] = schema[key];
        }
      }
      for (const key of Object.keys(schema)) {
        if (!RECOGNIZED_KEYS3.has(key)) {
          extraMeta[key] = schema[key];
        }
      }
      if (Object.keys(extraMeta).length > 0) {
        ctx.registry.add(baseSchema, extraMeta);
      }
      return baseSchema;
    }
    function fromJSONSchema3(schema, params) {
      if (typeof schema === "boolean") {
        return schema ? z3.any() : z3.never();
      }
      const version3 = detectVersion3(schema, params?.defaultTarget);
      const defs = schema.$defs || schema.definitions || {};
      const ctx = {
        version: version3,
        defs,
        refs: /* @__PURE__ */ new Map(),
        processing: /* @__PURE__ */ new Set(),
        rootSchema: schema,
        registry: params?.registry ?? registries_js_1.globalRegistry
      };
      return convertSchema3(schema, ctx);
    }
  }
});

// node_modules/zod/v4/classic/coerce.cjs
var require_coerce = __commonJS({
  "node_modules/zod/v4/classic/coerce.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.string = string5;
    exports2.number = number5;
    exports2.boolean = boolean5;
    exports2.bigint = bigint5;
    exports2.date = date6;
    var core = __importStar(require_core2());
    var schemas = __importStar(require_schemas2());
    function string5(params) {
      return core._coercedString(schemas.ZodString, params);
    }
    function number5(params) {
      return core._coercedNumber(schemas.ZodNumber, params);
    }
    function boolean5(params) {
      return core._coercedBoolean(schemas.ZodBoolean, params);
    }
    function bigint5(params) {
      return core._coercedBigint(schemas.ZodBigInt, params);
    }
    function date6(params) {
      return core._coercedDate(schemas.ZodDate, params);
    }
  }
});

// node_modules/zod/v4/classic/external.cjs
var require_external = __commonJS({
  "node_modules/zod/v4/classic/external.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p3 in m) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m, p3);
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.coerce = exports2.iso = exports2.ZodISODuration = exports2.ZodISOTime = exports2.ZodISODate = exports2.ZodISODateTime = exports2.locales = exports2.fromJSONSchema = exports2.toJSONSchema = exports2.NEVER = exports2.util = exports2.TimePrecision = exports2.flattenError = exports2.formatError = exports2.prettifyError = exports2.treeifyError = exports2.regexes = exports2.clone = exports2.$brand = exports2.$input = exports2.$output = exports2.config = exports2.registry = exports2.globalRegistry = exports2.core = void 0;
    exports2.core = __importStar(require_core2());
    __exportStar(require_schemas2(), exports2);
    __exportStar(require_checks2(), exports2);
    __exportStar(require_errors2(), exports2);
    __exportStar(require_parse5(), exports2);
    __exportStar(require_compat(), exports2);
    var index_js_1 = require_core2();
    var en_js_1 = __importDefault(require_en());
    (0, index_js_1.config)((0, en_js_1.default)());
    var index_js_2 = require_core2();
    Object.defineProperty(exports2, "globalRegistry", { enumerable: true, get: function() {
      return index_js_2.globalRegistry;
    } });
    Object.defineProperty(exports2, "registry", { enumerable: true, get: function() {
      return index_js_2.registry;
    } });
    Object.defineProperty(exports2, "config", { enumerable: true, get: function() {
      return index_js_2.config;
    } });
    Object.defineProperty(exports2, "$output", { enumerable: true, get: function() {
      return index_js_2.$output;
    } });
    Object.defineProperty(exports2, "$input", { enumerable: true, get: function() {
      return index_js_2.$input;
    } });
    Object.defineProperty(exports2, "$brand", { enumerable: true, get: function() {
      return index_js_2.$brand;
    } });
    Object.defineProperty(exports2, "clone", { enumerable: true, get: function() {
      return index_js_2.clone;
    } });
    Object.defineProperty(exports2, "regexes", { enumerable: true, get: function() {
      return index_js_2.regexes;
    } });
    Object.defineProperty(exports2, "treeifyError", { enumerable: true, get: function() {
      return index_js_2.treeifyError;
    } });
    Object.defineProperty(exports2, "prettifyError", { enumerable: true, get: function() {
      return index_js_2.prettifyError;
    } });
    Object.defineProperty(exports2, "formatError", { enumerable: true, get: function() {
      return index_js_2.formatError;
    } });
    Object.defineProperty(exports2, "flattenError", { enumerable: true, get: function() {
      return index_js_2.flattenError;
    } });
    Object.defineProperty(exports2, "TimePrecision", { enumerable: true, get: function() {
      return index_js_2.TimePrecision;
    } });
    Object.defineProperty(exports2, "util", { enumerable: true, get: function() {
      return index_js_2.util;
    } });
    Object.defineProperty(exports2, "NEVER", { enumerable: true, get: function() {
      return index_js_2.NEVER;
    } });
    var json_schema_processors_js_1 = require_json_schema_processors();
    Object.defineProperty(exports2, "toJSONSchema", { enumerable: true, get: function() {
      return json_schema_processors_js_1.toJSONSchema;
    } });
    var from_json_schema_js_1 = require_from_json_schema();
    Object.defineProperty(exports2, "fromJSONSchema", { enumerable: true, get: function() {
      return from_json_schema_js_1.fromJSONSchema;
    } });
    exports2.locales = __importStar(require_locales());
    var iso_js_1 = require_iso();
    Object.defineProperty(exports2, "ZodISODateTime", { enumerable: true, get: function() {
      return iso_js_1.ZodISODateTime;
    } });
    Object.defineProperty(exports2, "ZodISODate", { enumerable: true, get: function() {
      return iso_js_1.ZodISODate;
    } });
    Object.defineProperty(exports2, "ZodISOTime", { enumerable: true, get: function() {
      return iso_js_1.ZodISOTime;
    } });
    Object.defineProperty(exports2, "ZodISODuration", { enumerable: true, get: function() {
      return iso_js_1.ZodISODuration;
    } });
    exports2.iso = __importStar(require_iso());
    exports2.coerce = __importStar(require_coerce());
  }
});

// node_modules/zod/v4/classic/index.cjs
var require_classic = __commonJS({
  "node_modules/zod/v4/classic/index.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p3 in m) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m, p3);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.z = void 0;
    var z3 = __importStar(require_external());
    exports2.z = z3;
    __exportStar(require_external(), exports2);
    exports2.default = z3;
  }
});

// node_modules/zod/v4/index.cjs
var require_v4 = __commonJS({
  "node_modules/zod/v4/index.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p3 in m) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m, p3);
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var index_js_1 = __importDefault(require_classic());
    __exportStar(require_classic(), exports2);
    exports2.default = index_js_1.default;
  }
});

// node_modules/zod/v3/helpers/util.cjs
var require_util5 = __commonJS({
  "node_modules/zod/v3/helpers/util.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getParsedType = exports2.ZodParsedType = exports2.objectUtil = exports2.util = void 0;
    var util4;
    (function(util5) {
      util5.assertEqual = (_) => {
      };
      function assertIs3(_arg) {
      }
      util5.assertIs = assertIs3;
      function assertNever3(_x) {
        throw new Error();
      }
      util5.assertNever = assertNever3;
      util5.arrayToEnum = (items) => {
        const obj = {};
        for (const item of items) {
          obj[item] = item;
        }
        return obj;
      };
      util5.getValidEnumValues = (obj) => {
        const validKeys = util5.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
        const filtered = {};
        for (const k of validKeys) {
          filtered[k] = obj[k];
        }
        return util5.objectValues(filtered);
      };
      util5.objectValues = (obj) => {
        return util5.objectKeys(obj).map(function(e) {
          return obj[e];
        });
      };
      util5.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object4) => {
        const keys2 = [];
        for (const key in object4) {
          if (Object.prototype.hasOwnProperty.call(object4, key)) {
            keys2.push(key);
          }
        }
        return keys2;
      };
      util5.find = (arr, checker) => {
        for (const item of arr) {
          if (checker(item))
            return item;
        }
        return void 0;
      };
      util5.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
      function joinValues3(array4, separator = " | ") {
        return array4.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
      }
      util5.joinValues = joinValues3;
      util5.jsonStringifyReplacer = (_, value) => {
        if (typeof value === "bigint") {
          return value.toString();
        }
        return value;
      };
    })(util4 || (exports2.util = util4 = {}));
    var objectUtil2;
    (function(objectUtil3) {
      objectUtil3.mergeShapes = (first, second) => {
        return {
          ...first,
          ...second
          // second overwrites first
        };
      };
    })(objectUtil2 || (exports2.objectUtil = objectUtil2 = {}));
    exports2.ZodParsedType = util4.arrayToEnum([
      "string",
      "nan",
      "number",
      "integer",
      "float",
      "boolean",
      "date",
      "bigint",
      "symbol",
      "function",
      "undefined",
      "null",
      "array",
      "object",
      "unknown",
      "promise",
      "void",
      "never",
      "map",
      "set"
    ]);
    var getParsedType4 = (data) => {
      const t = typeof data;
      switch (t) {
        case "undefined":
          return exports2.ZodParsedType.undefined;
        case "string":
          return exports2.ZodParsedType.string;
        case "number":
          return Number.isNaN(data) ? exports2.ZodParsedType.nan : exports2.ZodParsedType.number;
        case "boolean":
          return exports2.ZodParsedType.boolean;
        case "function":
          return exports2.ZodParsedType.function;
        case "bigint":
          return exports2.ZodParsedType.bigint;
        case "symbol":
          return exports2.ZodParsedType.symbol;
        case "object":
          if (Array.isArray(data)) {
            return exports2.ZodParsedType.array;
          }
          if (data === null) {
            return exports2.ZodParsedType.null;
          }
          if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
            return exports2.ZodParsedType.promise;
          }
          if (typeof Map !== "undefined" && data instanceof Map) {
            return exports2.ZodParsedType.map;
          }
          if (typeof Set !== "undefined" && data instanceof Set) {
            return exports2.ZodParsedType.set;
          }
          if (typeof Date !== "undefined" && data instanceof Date) {
            return exports2.ZodParsedType.date;
          }
          return exports2.ZodParsedType.object;
        default:
          return exports2.ZodParsedType.unknown;
      }
    };
    exports2.getParsedType = getParsedType4;
  }
});

// node_modules/zod/v3/ZodError.cjs
var require_ZodError = __commonJS({
  "node_modules/zod/v3/ZodError.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ZodError = exports2.quotelessJson = exports2.ZodIssueCode = void 0;
    var util_js_1 = require_util5();
    exports2.ZodIssueCode = util_js_1.util.arrayToEnum([
      "invalid_type",
      "invalid_literal",
      "custom",
      "invalid_union",
      "invalid_union_discriminator",
      "invalid_enum_value",
      "unrecognized_keys",
      "invalid_arguments",
      "invalid_return_type",
      "invalid_date",
      "invalid_string",
      "too_small",
      "too_big",
      "invalid_intersection_types",
      "not_multiple_of",
      "not_finite"
    ]);
    var quotelessJson = (obj) => {
      const json4 = JSON.stringify(obj, null, 2);
      return json4.replace(/"([^"]+)":/g, "$1:");
    };
    exports2.quotelessJson = quotelessJson;
    var ZodError4 = class _ZodError extends Error {
      get errors() {
        return this.issues;
      }
      constructor(issues) {
        super();
        this.issues = [];
        this.addIssue = (sub) => {
          this.issues = [...this.issues, sub];
        };
        this.addIssues = (subs = []) => {
          this.issues = [...this.issues, ...subs];
        };
        const actualProto = new.target.prototype;
        if (Object.setPrototypeOf) {
          Object.setPrototypeOf(this, actualProto);
        } else {
          this.__proto__ = actualProto;
        }
        this.name = "ZodError";
        this.issues = issues;
      }
      format(_mapper) {
        const mapper = _mapper || function(issue3) {
          return issue3.message;
        };
        const fieldErrors = { _errors: [] };
        const processError = (error73) => {
          for (const issue3 of error73.issues) {
            if (issue3.code === "invalid_union") {
              issue3.unionErrors.map(processError);
            } else if (issue3.code === "invalid_return_type") {
              processError(issue3.returnTypeError);
            } else if (issue3.code === "invalid_arguments") {
              processError(issue3.argumentsError);
            } else if (issue3.path.length === 0) {
              fieldErrors._errors.push(mapper(issue3));
            } else {
              let curr = fieldErrors;
              let i = 0;
              while (i < issue3.path.length) {
                const el = issue3.path[i];
                const terminal = i === issue3.path.length - 1;
                if (!terminal) {
                  curr[el] = curr[el] || { _errors: [] };
                } else {
                  curr[el] = curr[el] || { _errors: [] };
                  curr[el]._errors.push(mapper(issue3));
                }
                curr = curr[el];
                i++;
              }
            }
          }
        };
        processError(this);
        return fieldErrors;
      }
      static assert(value) {
        if (!(value instanceof _ZodError)) {
          throw new Error(`Not a ZodError: ${value}`);
        }
      }
      toString() {
        return this.message;
      }
      get message() {
        return JSON.stringify(this.issues, util_js_1.util.jsonStringifyReplacer, 2);
      }
      get isEmpty() {
        return this.issues.length === 0;
      }
      flatten(mapper = (issue3) => issue3.message) {
        const fieldErrors = /* @__PURE__ */ Object.create(null);
        const formErrors = [];
        for (const sub of this.issues) {
          if (sub.path.length > 0) {
            const firstEl = sub.path[0];
            fieldErrors[firstEl] = fieldErrors[firstEl] || [];
            fieldErrors[firstEl].push(mapper(sub));
          } else {
            formErrors.push(mapper(sub));
          }
        }
        return { formErrors, fieldErrors };
      }
      get formErrors() {
        return this.flatten();
      }
    };
    exports2.ZodError = ZodError4;
    ZodError4.create = (issues) => {
      const error73 = new ZodError4(issues);
      return error73;
    };
  }
});

// node_modules/zod/v3/locales/en.cjs
var require_en2 = __commonJS({
  "node_modules/zod/v3/locales/en.cjs"(exports2, module2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var ZodError_js_1 = require_ZodError();
    var util_js_1 = require_util5();
    var errorMap2 = (issue3, _ctx) => {
      let message;
      switch (issue3.code) {
        case ZodError_js_1.ZodIssueCode.invalid_type:
          if (issue3.received === util_js_1.ZodParsedType.undefined) {
            message = "Required";
          } else {
            message = `Expected ${issue3.expected}, received ${issue3.received}`;
          }
          break;
        case ZodError_js_1.ZodIssueCode.invalid_literal:
          message = `Invalid literal value, expected ${JSON.stringify(issue3.expected, util_js_1.util.jsonStringifyReplacer)}`;
          break;
        case ZodError_js_1.ZodIssueCode.unrecognized_keys:
          message = `Unrecognized key(s) in object: ${util_js_1.util.joinValues(issue3.keys, ", ")}`;
          break;
        case ZodError_js_1.ZodIssueCode.invalid_union:
          message = `Invalid input`;
          break;
        case ZodError_js_1.ZodIssueCode.invalid_union_discriminator:
          message = `Invalid discriminator value. Expected ${util_js_1.util.joinValues(issue3.options)}`;
          break;
        case ZodError_js_1.ZodIssueCode.invalid_enum_value:
          message = `Invalid enum value. Expected ${util_js_1.util.joinValues(issue3.options)}, received '${issue3.received}'`;
          break;
        case ZodError_js_1.ZodIssueCode.invalid_arguments:
          message = `Invalid function arguments`;
          break;
        case ZodError_js_1.ZodIssueCode.invalid_return_type:
          message = `Invalid function return type`;
          break;
        case ZodError_js_1.ZodIssueCode.invalid_date:
          message = `Invalid date`;
          break;
        case ZodError_js_1.ZodIssueCode.invalid_string:
          if (typeof issue3.validation === "object") {
            if ("includes" in issue3.validation) {
              message = `Invalid input: must include "${issue3.validation.includes}"`;
              if (typeof issue3.validation.position === "number") {
                message = `${message} at one or more positions greater than or equal to ${issue3.validation.position}`;
              }
            } else if ("startsWith" in issue3.validation) {
              message = `Invalid input: must start with "${issue3.validation.startsWith}"`;
            } else if ("endsWith" in issue3.validation) {
              message = `Invalid input: must end with "${issue3.validation.endsWith}"`;
            } else {
              util_js_1.util.assertNever(issue3.validation);
            }
          } else if (issue3.validation !== "regex") {
            message = `Invalid ${issue3.validation}`;
          } else {
            message = "Invalid";
          }
          break;
        case ZodError_js_1.ZodIssueCode.too_small:
          if (issue3.type === "array")
            message = `Array must contain ${issue3.exact ? "exactly" : issue3.inclusive ? `at least` : `more than`} ${issue3.minimum} element(s)`;
          else if (issue3.type === "string")
            message = `String must contain ${issue3.exact ? "exactly" : issue3.inclusive ? `at least` : `over`} ${issue3.minimum} character(s)`;
          else if (issue3.type === "number")
            message = `Number must be ${issue3.exact ? `exactly equal to ` : issue3.inclusive ? `greater than or equal to ` : `greater than `}${issue3.minimum}`;
          else if (issue3.type === "bigint")
            message = `Number must be ${issue3.exact ? `exactly equal to ` : issue3.inclusive ? `greater than or equal to ` : `greater than `}${issue3.minimum}`;
          else if (issue3.type === "date")
            message = `Date must be ${issue3.exact ? `exactly equal to ` : issue3.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue3.minimum))}`;
          else
            message = "Invalid input";
          break;
        case ZodError_js_1.ZodIssueCode.too_big:
          if (issue3.type === "array")
            message = `Array must contain ${issue3.exact ? `exactly` : issue3.inclusive ? `at most` : `less than`} ${issue3.maximum} element(s)`;
          else if (issue3.type === "string")
            message = `String must contain ${issue3.exact ? `exactly` : issue3.inclusive ? `at most` : `under`} ${issue3.maximum} character(s)`;
          else if (issue3.type === "number")
            message = `Number must be ${issue3.exact ? `exactly` : issue3.inclusive ? `less than or equal to` : `less than`} ${issue3.maximum}`;
          else if (issue3.type === "bigint")
            message = `BigInt must be ${issue3.exact ? `exactly` : issue3.inclusive ? `less than or equal to` : `less than`} ${issue3.maximum}`;
          else if (issue3.type === "date")
            message = `Date must be ${issue3.exact ? `exactly` : issue3.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue3.maximum))}`;
          else
            message = "Invalid input";
          break;
        case ZodError_js_1.ZodIssueCode.custom:
          message = `Invalid input`;
          break;
        case ZodError_js_1.ZodIssueCode.invalid_intersection_types:
          message = `Intersection results could not be merged`;
          break;
        case ZodError_js_1.ZodIssueCode.not_multiple_of:
          message = `Number must be a multiple of ${issue3.multipleOf}`;
          break;
        case ZodError_js_1.ZodIssueCode.not_finite:
          message = "Number must be finite";
          break;
        default:
          message = _ctx.defaultError;
          util_js_1.util.assertNever(issue3);
      }
      return { message };
    };
    exports2.default = errorMap2;
    module2.exports = exports2.default;
  }
});

// node_modules/zod/v3/errors.cjs
var require_errors3 = __commonJS({
  "node_modules/zod/v3/errors.cjs"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.defaultErrorMap = void 0;
    exports2.setErrorMap = setErrorMap3;
    exports2.getErrorMap = getErrorMap4;
    var en_js_1 = __importDefault(require_en2());
    exports2.defaultErrorMap = en_js_1.default;
    var overrideErrorMap2 = en_js_1.default;
    function setErrorMap3(map3) {
      overrideErrorMap2 = map3;
    }
    function getErrorMap4() {
      return overrideErrorMap2;
    }
  }
});

// node_modules/zod/v3/helpers/parseUtil.cjs
var require_parseUtil = __commonJS({
  "node_modules/zod/v3/helpers/parseUtil.cjs"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isAsync = exports2.isValid = exports2.isDirty = exports2.isAborted = exports2.OK = exports2.DIRTY = exports2.INVALID = exports2.ParseStatus = exports2.EMPTY_PATH = exports2.makeIssue = void 0;
    exports2.addIssueToContext = addIssueToContext2;
    var errors_js_1 = require_errors3();
    var en_js_1 = __importDefault(require_en2());
    var makeIssue2 = (params) => {
      const { data, path: path33, errorMaps, issueData } = params;
      const fullPath = [...path33, ...issueData.path || []];
      const fullIssue = {
        ...issueData,
        path: fullPath
      };
      if (issueData.message !== void 0) {
        return {
          ...issueData,
          path: fullPath,
          message: issueData.message
        };
      }
      let errorMessage = "";
      const maps = errorMaps.filter((m) => !!m).slice().reverse();
      for (const map3 of maps) {
        errorMessage = map3(fullIssue, { data, defaultError: errorMessage }).message;
      }
      return {
        ...issueData,
        path: fullPath,
        message: errorMessage
      };
    };
    exports2.makeIssue = makeIssue2;
    exports2.EMPTY_PATH = [];
    function addIssueToContext2(ctx, issueData) {
      const overrideMap = (0, errors_js_1.getErrorMap)();
      const issue3 = (0, exports2.makeIssue)({
        issueData,
        data: ctx.data,
        path: ctx.path,
        errorMaps: [
          ctx.common.contextualErrorMap,
          // contextual error map is first priority
          ctx.schemaErrorMap,
          // then schema-bound map if available
          overrideMap,
          // then global override map
          overrideMap === en_js_1.default ? void 0 : en_js_1.default
          // then global default map
        ].filter((x) => !!x)
      });
      ctx.common.issues.push(issue3);
    }
    var ParseStatus2 = class _ParseStatus {
      constructor() {
        this.value = "valid";
      }
      dirty() {
        if (this.value === "valid")
          this.value = "dirty";
      }
      abort() {
        if (this.value !== "aborted")
          this.value = "aborted";
      }
      static mergeArray(status, results) {
        const arrayValue = [];
        for (const s of results) {
          if (s.status === "aborted")
            return exports2.INVALID;
          if (s.status === "dirty")
            status.dirty();
          arrayValue.push(s.value);
        }
        return { status: status.value, value: arrayValue };
      }
      static async mergeObjectAsync(status, pairs) {
        const syncPairs = [];
        for (const pair of pairs) {
          const key = await pair.key;
          const value = await pair.value;
          syncPairs.push({
            key,
            value
          });
        }
        return _ParseStatus.mergeObjectSync(status, syncPairs);
      }
      static mergeObjectSync(status, pairs) {
        const finalObject = {};
        for (const pair of pairs) {
          const { key, value } = pair;
          if (key.status === "aborted")
            return exports2.INVALID;
          if (value.status === "aborted")
            return exports2.INVALID;
          if (key.status === "dirty")
            status.dirty();
          if (value.status === "dirty")
            status.dirty();
          if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
            finalObject[key.value] = value.value;
          }
        }
        return { status: status.value, value: finalObject };
      }
    };
    exports2.ParseStatus = ParseStatus2;
    exports2.INVALID = Object.freeze({
      status: "aborted"
    });
    var DIRTY2 = (value) => ({ status: "dirty", value });
    exports2.DIRTY = DIRTY2;
    var OK2 = (value) => ({ status: "valid", value });
    exports2.OK = OK2;
    var isAborted2 = (x) => x.status === "aborted";
    exports2.isAborted = isAborted2;
    var isDirty2 = (x) => x.status === "dirty";
    exports2.isDirty = isDirty2;
    var isValid2 = (x) => x.status === "valid";
    exports2.isValid = isValid2;
    var isAsync2 = (x) => typeof Promise !== "undefined" && x instanceof Promise;
    exports2.isAsync = isAsync2;
  }
});

// node_modules/zod/v3/helpers/typeAliases.cjs
var require_typeAliases = __commonJS({
  "node_modules/zod/v3/helpers/typeAliases.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/zod/v3/helpers/errorUtil.cjs
var require_errorUtil = __commonJS({
  "node_modules/zod/v3/helpers/errorUtil.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.errorUtil = void 0;
    var errorUtil2;
    (function(errorUtil3) {
      errorUtil3.errToObj = (message) => typeof message === "string" ? { message } : message || {};
      errorUtil3.toString = (message) => typeof message === "string" ? message : message?.message;
    })(errorUtil2 || (exports2.errorUtil = errorUtil2 = {}));
  }
});

// node_modules/zod/v3/types.cjs
var require_types4 = __commonJS({
  "node_modules/zod/v3/types.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.discriminatedUnion = exports2.date = exports2.boolean = exports2.bigint = exports2.array = exports2.any = exports2.coerce = exports2.ZodFirstPartyTypeKind = exports2.late = exports2.ZodSchema = exports2.Schema = exports2.ZodReadonly = exports2.ZodPipeline = exports2.ZodBranded = exports2.BRAND = exports2.ZodNaN = exports2.ZodCatch = exports2.ZodDefault = exports2.ZodNullable = exports2.ZodOptional = exports2.ZodTransformer = exports2.ZodEffects = exports2.ZodPromise = exports2.ZodNativeEnum = exports2.ZodEnum = exports2.ZodLiteral = exports2.ZodLazy = exports2.ZodFunction = exports2.ZodSet = exports2.ZodMap = exports2.ZodRecord = exports2.ZodTuple = exports2.ZodIntersection = exports2.ZodDiscriminatedUnion = exports2.ZodUnion = exports2.ZodObject = exports2.ZodArray = exports2.ZodVoid = exports2.ZodNever = exports2.ZodUnknown = exports2.ZodAny = exports2.ZodNull = exports2.ZodUndefined = exports2.ZodSymbol = exports2.ZodDate = exports2.ZodBoolean = exports2.ZodBigInt = exports2.ZodNumber = exports2.ZodString = exports2.ZodType = void 0;
    exports2.NEVER = exports2.void = exports2.unknown = exports2.union = exports2.undefined = exports2.tuple = exports2.transformer = exports2.symbol = exports2.string = exports2.strictObject = exports2.set = exports2.record = exports2.promise = exports2.preprocess = exports2.pipeline = exports2.ostring = exports2.optional = exports2.onumber = exports2.oboolean = exports2.object = exports2.number = exports2.nullable = exports2.null = exports2.never = exports2.nativeEnum = exports2.nan = exports2.map = exports2.literal = exports2.lazy = exports2.intersection = exports2.instanceof = exports2.function = exports2.enum = exports2.effect = void 0;
    exports2.datetimeRegex = datetimeRegex2;
    exports2.custom = custom3;
    var ZodError_js_1 = require_ZodError();
    var errors_js_1 = require_errors3();
    var errorUtil_js_1 = require_errorUtil();
    var parseUtil_js_1 = require_parseUtil();
    var util_js_1 = require_util5();
    var ParseInputLazyPath2 = class {
      constructor(parent, value, path33, key) {
        this._cachedPath = [];
        this.parent = parent;
        this.data = value;
        this._path = path33;
        this._key = key;
      }
      get path() {
        if (!this._cachedPath.length) {
          if (Array.isArray(this._key)) {
            this._cachedPath.push(...this._path, ...this._key);
          } else {
            this._cachedPath.push(...this._path, this._key);
          }
        }
        return this._cachedPath;
      }
    };
    var handleResult2 = (ctx, result) => {
      if ((0, parseUtil_js_1.isValid)(result)) {
        return { success: true, data: result.value };
      } else {
        if (!ctx.common.issues.length) {
          throw new Error("Validation failed but no issues detected.");
        }
        return {
          success: false,
          get error() {
            if (this._error)
              return this._error;
            const error73 = new ZodError_js_1.ZodError(ctx.common.issues);
            this._error = error73;
            return this._error;
          }
        };
      }
    };
    function processCreateParams2(params) {
      if (!params)
        return {};
      const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
      if (errorMap2 && (invalid_type_error || required_error)) {
        throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
      }
      if (errorMap2)
        return { errorMap: errorMap2, description };
      const customMap = (iss, ctx) => {
        const { message } = params;
        if (iss.code === "invalid_enum_value") {
          return { message: message ?? ctx.defaultError };
        }
        if (typeof ctx.data === "undefined") {
          return { message: message ?? required_error ?? ctx.defaultError };
        }
        if (iss.code !== "invalid_type")
          return { message: ctx.defaultError };
        return { message: message ?? invalid_type_error ?? ctx.defaultError };
      };
      return { errorMap: customMap, description };
    }
    var ZodType4 = class {
      get description() {
        return this._def.description;
      }
      _getType(input) {
        return (0, util_js_1.getParsedType)(input.data);
      }
      _getOrReturnCtx(input, ctx) {
        return ctx || {
          common: input.parent.common,
          data: input.data,
          parsedType: (0, util_js_1.getParsedType)(input.data),
          schemaErrorMap: this._def.errorMap,
          path: input.path,
          parent: input.parent
        };
      }
      _processInputParams(input) {
        return {
          status: new parseUtil_js_1.ParseStatus(),
          ctx: {
            common: input.parent.common,
            data: input.data,
            parsedType: (0, util_js_1.getParsedType)(input.data),
            schemaErrorMap: this._def.errorMap,
            path: input.path,
            parent: input.parent
          }
        };
      }
      _parseSync(input) {
        const result = this._parse(input);
        if ((0, parseUtil_js_1.isAsync)(result)) {
          throw new Error("Synchronous parse encountered promise.");
        }
        return result;
      }
      _parseAsync(input) {
        const result = this._parse(input);
        return Promise.resolve(result);
      }
      parse(data, params) {
        const result = this.safeParse(data, params);
        if (result.success)
          return result.data;
        throw result.error;
      }
      safeParse(data, params) {
        const ctx = {
          common: {
            issues: [],
            async: params?.async ?? false,
            contextualErrorMap: params?.errorMap
          },
          path: params?.path || [],
          schemaErrorMap: this._def.errorMap,
          parent: null,
          data,
          parsedType: (0, util_js_1.getParsedType)(data)
        };
        const result = this._parseSync({ data, path: ctx.path, parent: ctx });
        return handleResult2(ctx, result);
      }
      "~validate"(data) {
        const ctx = {
          common: {
            issues: [],
            async: !!this["~standard"].async
          },
          path: [],
          schemaErrorMap: this._def.errorMap,
          parent: null,
          data,
          parsedType: (0, util_js_1.getParsedType)(data)
        };
        if (!this["~standard"].async) {
          try {
            const result = this._parseSync({ data, path: [], parent: ctx });
            return (0, parseUtil_js_1.isValid)(result) ? {
              value: result.value
            } : {
              issues: ctx.common.issues
            };
          } catch (err) {
            if (err?.message?.toLowerCase()?.includes("encountered")) {
              this["~standard"].async = true;
            }
            ctx.common = {
              issues: [],
              async: true
            };
          }
        }
        return this._parseAsync({ data, path: [], parent: ctx }).then((result) => (0, parseUtil_js_1.isValid)(result) ? {
          value: result.value
        } : {
          issues: ctx.common.issues
        });
      }
      async parseAsync(data, params) {
        const result = await this.safeParseAsync(data, params);
        if (result.success)
          return result.data;
        throw result.error;
      }
      async safeParseAsync(data, params) {
        const ctx = {
          common: {
            issues: [],
            contextualErrorMap: params?.errorMap,
            async: true
          },
          path: params?.path || [],
          schemaErrorMap: this._def.errorMap,
          parent: null,
          data,
          parsedType: (0, util_js_1.getParsedType)(data)
        };
        const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
        const result = await ((0, parseUtil_js_1.isAsync)(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
        return handleResult2(ctx, result);
      }
      refine(check3, message) {
        const getIssueProperties = (val) => {
          if (typeof message === "string" || typeof message === "undefined") {
            return { message };
          } else if (typeof message === "function") {
            return message(val);
          } else {
            return message;
          }
        };
        return this._refinement((val, ctx) => {
          const result = check3(val);
          const setError = () => ctx.addIssue({
            code: ZodError_js_1.ZodIssueCode.custom,
            ...getIssueProperties(val)
          });
          if (typeof Promise !== "undefined" && result instanceof Promise) {
            return result.then((data) => {
              if (!data) {
                setError();
                return false;
              } else {
                return true;
              }
            });
          }
          if (!result) {
            setError();
            return false;
          } else {
            return true;
          }
        });
      }
      refinement(check3, refinementData) {
        return this._refinement((val, ctx) => {
          if (!check3(val)) {
            ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
            return false;
          } else {
            return true;
          }
        });
      }
      _refinement(refinement) {
        return new ZodEffects2({
          schema: this,
          typeName: ZodFirstPartyTypeKind4.ZodEffects,
          effect: { type: "refinement", refinement }
        });
      }
      superRefine(refinement) {
        return this._refinement(refinement);
      }
      constructor(def) {
        this.spa = this.safeParseAsync;
        this._def = def;
        this.parse = this.parse.bind(this);
        this.safeParse = this.safeParse.bind(this);
        this.parseAsync = this.parseAsync.bind(this);
        this.safeParseAsync = this.safeParseAsync.bind(this);
        this.spa = this.spa.bind(this);
        this.refine = this.refine.bind(this);
        this.refinement = this.refinement.bind(this);
        this.superRefine = this.superRefine.bind(this);
        this.optional = this.optional.bind(this);
        this.nullable = this.nullable.bind(this);
        this.nullish = this.nullish.bind(this);
        this.array = this.array.bind(this);
        this.promise = this.promise.bind(this);
        this.or = this.or.bind(this);
        this.and = this.and.bind(this);
        this.transform = this.transform.bind(this);
        this.brand = this.brand.bind(this);
        this.default = this.default.bind(this);
        this.catch = this.catch.bind(this);
        this.describe = this.describe.bind(this);
        this.pipe = this.pipe.bind(this);
        this.readonly = this.readonly.bind(this);
        this.isNullable = this.isNullable.bind(this);
        this.isOptional = this.isOptional.bind(this);
        this["~standard"] = {
          version: 1,
          vendor: "zod",
          validate: (data) => this["~validate"](data)
        };
      }
      optional() {
        return ZodOptional4.create(this, this._def);
      }
      nullable() {
        return ZodNullable4.create(this, this._def);
      }
      nullish() {
        return this.nullable().optional();
      }
      array() {
        return ZodArray4.create(this);
      }
      promise() {
        return ZodPromise4.create(this, this._def);
      }
      or(option) {
        return ZodUnion4.create([this, option], this._def);
      }
      and(incoming) {
        return ZodIntersection4.create(this, incoming, this._def);
      }
      transform(transform8) {
        return new ZodEffects2({
          ...processCreateParams2(this._def),
          schema: this,
          typeName: ZodFirstPartyTypeKind4.ZodEffects,
          effect: { type: "transform", transform: transform8 }
        });
      }
      default(def) {
        const defaultValueFunc = typeof def === "function" ? def : () => def;
        return new ZodDefault4({
          ...processCreateParams2(this._def),
          innerType: this,
          defaultValue: defaultValueFunc,
          typeName: ZodFirstPartyTypeKind4.ZodDefault
        });
      }
      brand() {
        return new ZodBranded2({
          typeName: ZodFirstPartyTypeKind4.ZodBranded,
          type: this,
          ...processCreateParams2(this._def)
        });
      }
      catch(def) {
        const catchValueFunc = typeof def === "function" ? def : () => def;
        return new ZodCatch4({
          ...processCreateParams2(this._def),
          innerType: this,
          catchValue: catchValueFunc,
          typeName: ZodFirstPartyTypeKind4.ZodCatch
        });
      }
      describe(description) {
        const This = this.constructor;
        return new This({
          ...this._def,
          description
        });
      }
      pipe(target) {
        return ZodPipeline2.create(this, target);
      }
      readonly() {
        return ZodReadonly4.create(this);
      }
      isOptional() {
        return this.safeParse(void 0).success;
      }
      isNullable() {
        return this.safeParse(null).success;
      }
    };
    exports2.ZodType = ZodType4;
    exports2.Schema = ZodType4;
    exports2.ZodSchema = ZodType4;
    var cuidRegex2 = /^c[^\s-]{8,}$/i;
    var cuid2Regex2 = /^[0-9a-z]+$/;
    var ulidRegex2 = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
    var uuidRegex2 = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
    var nanoidRegex2 = /^[a-z0-9_-]{21}$/i;
    var jwtRegex2 = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
    var durationRegex2 = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
    var emailRegex2 = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
    var _emojiRegex2 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
    var emojiRegex5;
    var ipv4Regex2 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
    var ipv4CidrRegex2 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/;
    var ipv6Regex2 = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
    var ipv6CidrRegex2 = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
    var base64Regex2 = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
    var base64urlRegex2 = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
    var dateRegexSource2 = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
    var dateRegex2 = new RegExp(`^${dateRegexSource2}$`);
    function timeRegexSource2(args) {
      let secondsRegexSource = `[0-5]\\d`;
      if (args.precision) {
        secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
      } else if (args.precision == null) {
        secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
      }
      const secondsQuantifier = args.precision ? "+" : "?";
      return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
    }
    function timeRegex2(args) {
      return new RegExp(`^${timeRegexSource2(args)}$`);
    }
    function datetimeRegex2(args) {
      let regex = `${dateRegexSource2}T${timeRegexSource2(args)}`;
      const opts = [];
      opts.push(args.local ? `Z?` : `Z`);
      if (args.offset)
        opts.push(`([+-]\\d{2}:?\\d{2})`);
      regex = `${regex}(${opts.join("|")})`;
      return new RegExp(`^${regex}$`);
    }
    function isValidIP2(ip, version3) {
      if ((version3 === "v4" || !version3) && ipv4Regex2.test(ip)) {
        return true;
      }
      if ((version3 === "v6" || !version3) && ipv6Regex2.test(ip)) {
        return true;
      }
      return false;
    }
    function isValidJWT4(jwt4, alg) {
      if (!jwtRegex2.test(jwt4))
        return false;
      try {
        const [header] = jwt4.split(".");
        if (!header)
          return false;
        const base644 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
        const decoded = JSON.parse(atob(base644));
        if (typeof decoded !== "object" || decoded === null)
          return false;
        if ("typ" in decoded && decoded?.typ !== "JWT")
          return false;
        if (!decoded.alg)
          return false;
        if (alg && decoded.alg !== alg)
          return false;
        return true;
      } catch {
        return false;
      }
    }
    function isValidCidr2(ip, version3) {
      if ((version3 === "v4" || !version3) && ipv4CidrRegex2.test(ip)) {
        return true;
      }
      if ((version3 === "v6" || !version3) && ipv6CidrRegex2.test(ip)) {
        return true;
      }
      return false;
    }
    var ZodString4 = class _ZodString3 extends ZodType4 {
      _parse(input) {
        if (this._def.coerce) {
          input.data = String(input.data);
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.string) {
          const ctx2 = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx2, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.string,
            received: ctx2.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        const status = new parseUtil_js_1.ParseStatus();
        let ctx = void 0;
        for (const check3 of this._def.checks) {
          if (check3.kind === "min") {
            if (input.data.length < check3.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.too_small,
                minimum: check3.value,
                type: "string",
                inclusive: true,
                exact: false,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "max") {
            if (input.data.length > check3.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.too_big,
                maximum: check3.value,
                type: "string",
                inclusive: true,
                exact: false,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "length") {
            const tooBig = input.data.length > check3.value;
            const tooSmall = input.data.length < check3.value;
            if (tooBig || tooSmall) {
              ctx = this._getOrReturnCtx(input, ctx);
              if (tooBig) {
                (0, parseUtil_js_1.addIssueToContext)(ctx, {
                  code: ZodError_js_1.ZodIssueCode.too_big,
                  maximum: check3.value,
                  type: "string",
                  inclusive: true,
                  exact: true,
                  message: check3.message
                });
              } else if (tooSmall) {
                (0, parseUtil_js_1.addIssueToContext)(ctx, {
                  code: ZodError_js_1.ZodIssueCode.too_small,
                  minimum: check3.value,
                  type: "string",
                  inclusive: true,
                  exact: true,
                  message: check3.message
                });
              }
              status.dirty();
            }
          } else if (check3.kind === "email") {
            if (!emailRegex2.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "email",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "emoji") {
            if (!emojiRegex5) {
              emojiRegex5 = new RegExp(_emojiRegex2, "u");
            }
            if (!emojiRegex5.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "emoji",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "uuid") {
            if (!uuidRegex2.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "uuid",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "nanoid") {
            if (!nanoidRegex2.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "nanoid",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "cuid") {
            if (!cuidRegex2.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "cuid",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "cuid2") {
            if (!cuid2Regex2.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "cuid2",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "ulid") {
            if (!ulidRegex2.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "ulid",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "url") {
            try {
              new URL(input.data);
            } catch {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "url",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "regex") {
            check3.regex.lastIndex = 0;
            const testResult = check3.regex.test(input.data);
            if (!testResult) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "regex",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "trim") {
            input.data = input.data.trim();
          } else if (check3.kind === "includes") {
            if (!input.data.includes(check3.value, check3.position)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                validation: { includes: check3.value, position: check3.position },
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "toLowerCase") {
            input.data = input.data.toLowerCase();
          } else if (check3.kind === "toUpperCase") {
            input.data = input.data.toUpperCase();
          } else if (check3.kind === "startsWith") {
            if (!input.data.startsWith(check3.value)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                validation: { startsWith: check3.value },
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "endsWith") {
            if (!input.data.endsWith(check3.value)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                validation: { endsWith: check3.value },
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "datetime") {
            const regex = datetimeRegex2(check3);
            if (!regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                validation: "datetime",
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "date") {
            const regex = dateRegex2;
            if (!regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                validation: "date",
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "time") {
            const regex = timeRegex2(check3);
            if (!regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                validation: "time",
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "duration") {
            if (!durationRegex2.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "duration",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "ip") {
            if (!isValidIP2(input.data, check3.version)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "ip",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "jwt") {
            if (!isValidJWT4(input.data, check3.alg)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "jwt",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "cidr") {
            if (!isValidCidr2(input.data, check3.version)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "cidr",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "base64") {
            if (!base64Regex2.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "base64",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "base64url") {
            if (!base64urlRegex2.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                validation: "base64url",
                code: ZodError_js_1.ZodIssueCode.invalid_string,
                message: check3.message
              });
              status.dirty();
            }
          } else {
            util_js_1.util.assertNever(check3);
          }
        }
        return { status: status.value, value: input.data };
      }
      _regex(regex, validation, message) {
        return this.refinement((data) => regex.test(data), {
          validation,
          code: ZodError_js_1.ZodIssueCode.invalid_string,
          ...errorUtil_js_1.errorUtil.errToObj(message)
        });
      }
      _addCheck(check3) {
        return new _ZodString3({
          ...this._def,
          checks: [...this._def.checks, check3]
        });
      }
      email(message) {
        return this._addCheck({ kind: "email", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      url(message) {
        return this._addCheck({ kind: "url", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      emoji(message) {
        return this._addCheck({ kind: "emoji", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      uuid(message) {
        return this._addCheck({ kind: "uuid", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      nanoid(message) {
        return this._addCheck({ kind: "nanoid", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      cuid(message) {
        return this._addCheck({ kind: "cuid", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      cuid2(message) {
        return this._addCheck({ kind: "cuid2", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      ulid(message) {
        return this._addCheck({ kind: "ulid", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      base64(message) {
        return this._addCheck({ kind: "base64", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      base64url(message) {
        return this._addCheck({
          kind: "base64url",
          ...errorUtil_js_1.errorUtil.errToObj(message)
        });
      }
      jwt(options) {
        return this._addCheck({ kind: "jwt", ...errorUtil_js_1.errorUtil.errToObj(options) });
      }
      ip(options) {
        return this._addCheck({ kind: "ip", ...errorUtil_js_1.errorUtil.errToObj(options) });
      }
      cidr(options) {
        return this._addCheck({ kind: "cidr", ...errorUtil_js_1.errorUtil.errToObj(options) });
      }
      datetime(options) {
        if (typeof options === "string") {
          return this._addCheck({
            kind: "datetime",
            precision: null,
            offset: false,
            local: false,
            message: options
          });
        }
        return this._addCheck({
          kind: "datetime",
          precision: typeof options?.precision === "undefined" ? null : options?.precision,
          offset: options?.offset ?? false,
          local: options?.local ?? false,
          ...errorUtil_js_1.errorUtil.errToObj(options?.message)
        });
      }
      date(message) {
        return this._addCheck({ kind: "date", message });
      }
      time(options) {
        if (typeof options === "string") {
          return this._addCheck({
            kind: "time",
            precision: null,
            message: options
          });
        }
        return this._addCheck({
          kind: "time",
          precision: typeof options?.precision === "undefined" ? null : options?.precision,
          ...errorUtil_js_1.errorUtil.errToObj(options?.message)
        });
      }
      duration(message) {
        return this._addCheck({ kind: "duration", ...errorUtil_js_1.errorUtil.errToObj(message) });
      }
      regex(regex, message) {
        return this._addCheck({
          kind: "regex",
          regex,
          ...errorUtil_js_1.errorUtil.errToObj(message)
        });
      }
      includes(value, options) {
        return this._addCheck({
          kind: "includes",
          value,
          position: options?.position,
          ...errorUtil_js_1.errorUtil.errToObj(options?.message)
        });
      }
      startsWith(value, message) {
        return this._addCheck({
          kind: "startsWith",
          value,
          ...errorUtil_js_1.errorUtil.errToObj(message)
        });
      }
      endsWith(value, message) {
        return this._addCheck({
          kind: "endsWith",
          value,
          ...errorUtil_js_1.errorUtil.errToObj(message)
        });
      }
      min(minLength, message) {
        return this._addCheck({
          kind: "min",
          value: minLength,
          ...errorUtil_js_1.errorUtil.errToObj(message)
        });
      }
      max(maxLength, message) {
        return this._addCheck({
          kind: "max",
          value: maxLength,
          ...errorUtil_js_1.errorUtil.errToObj(message)
        });
      }
      length(len, message) {
        return this._addCheck({
          kind: "length",
          value: len,
          ...errorUtil_js_1.errorUtil.errToObj(message)
        });
      }
      /**
       * Equivalent to `.min(1)`
       */
      nonempty(message) {
        return this.min(1, errorUtil_js_1.errorUtil.errToObj(message));
      }
      trim() {
        return new _ZodString3({
          ...this._def,
          checks: [...this._def.checks, { kind: "trim" }]
        });
      }
      toLowerCase() {
        return new _ZodString3({
          ...this._def,
          checks: [...this._def.checks, { kind: "toLowerCase" }]
        });
      }
      toUpperCase() {
        return new _ZodString3({
          ...this._def,
          checks: [...this._def.checks, { kind: "toUpperCase" }]
        });
      }
      get isDatetime() {
        return !!this._def.checks.find((ch) => ch.kind === "datetime");
      }
      get isDate() {
        return !!this._def.checks.find((ch) => ch.kind === "date");
      }
      get isTime() {
        return !!this._def.checks.find((ch) => ch.kind === "time");
      }
      get isDuration() {
        return !!this._def.checks.find((ch) => ch.kind === "duration");
      }
      get isEmail() {
        return !!this._def.checks.find((ch) => ch.kind === "email");
      }
      get isURL() {
        return !!this._def.checks.find((ch) => ch.kind === "url");
      }
      get isEmoji() {
        return !!this._def.checks.find((ch) => ch.kind === "emoji");
      }
      get isUUID() {
        return !!this._def.checks.find((ch) => ch.kind === "uuid");
      }
      get isNANOID() {
        return !!this._def.checks.find((ch) => ch.kind === "nanoid");
      }
      get isCUID() {
        return !!this._def.checks.find((ch) => ch.kind === "cuid");
      }
      get isCUID2() {
        return !!this._def.checks.find((ch) => ch.kind === "cuid2");
      }
      get isULID() {
        return !!this._def.checks.find((ch) => ch.kind === "ulid");
      }
      get isIP() {
        return !!this._def.checks.find((ch) => ch.kind === "ip");
      }
      get isCIDR() {
        return !!this._def.checks.find((ch) => ch.kind === "cidr");
      }
      get isBase64() {
        return !!this._def.checks.find((ch) => ch.kind === "base64");
      }
      get isBase64url() {
        return !!this._def.checks.find((ch) => ch.kind === "base64url");
      }
      get minLength() {
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          }
        }
        return min;
      }
      get maxLength() {
        let max = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return max;
      }
    };
    exports2.ZodString = ZodString4;
    ZodString4.create = (params) => {
      return new ZodString4({
        checks: [],
        typeName: ZodFirstPartyTypeKind4.ZodString,
        coerce: params?.coerce ?? false,
        ...processCreateParams2(params)
      });
    };
    function floatSafeRemainder4(val, step) {
      const valDecCount = (val.toString().split(".")[1] || "").length;
      const stepDecCount = (step.toString().split(".")[1] || "").length;
      const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
      const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
      const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
      return valInt % stepInt / 10 ** decCount;
    }
    var ZodNumber4 = class _ZodNumber extends ZodType4 {
      constructor() {
        super(...arguments);
        this.min = this.gte;
        this.max = this.lte;
        this.step = this.multipleOf;
      }
      _parse(input) {
        if (this._def.coerce) {
          input.data = Number(input.data);
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.number) {
          const ctx2 = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx2, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.number,
            received: ctx2.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        let ctx = void 0;
        const status = new parseUtil_js_1.ParseStatus();
        for (const check3 of this._def.checks) {
          if (check3.kind === "int") {
            if (!util_js_1.util.isInteger(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.invalid_type,
                expected: "integer",
                received: "float",
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "min") {
            const tooSmall = check3.inclusive ? input.data < check3.value : input.data <= check3.value;
            if (tooSmall) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.too_small,
                minimum: check3.value,
                type: "number",
                inclusive: check3.inclusive,
                exact: false,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "max") {
            const tooBig = check3.inclusive ? input.data > check3.value : input.data >= check3.value;
            if (tooBig) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.too_big,
                maximum: check3.value,
                type: "number",
                inclusive: check3.inclusive,
                exact: false,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "multipleOf") {
            if (floatSafeRemainder4(input.data, check3.value) !== 0) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.not_multiple_of,
                multipleOf: check3.value,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "finite") {
            if (!Number.isFinite(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.not_finite,
                message: check3.message
              });
              status.dirty();
            }
          } else {
            util_js_1.util.assertNever(check3);
          }
        }
        return { status: status.value, value: input.data };
      }
      gte(value, message) {
        return this.setLimit("min", value, true, errorUtil_js_1.errorUtil.toString(message));
      }
      gt(value, message) {
        return this.setLimit("min", value, false, errorUtil_js_1.errorUtil.toString(message));
      }
      lte(value, message) {
        return this.setLimit("max", value, true, errorUtil_js_1.errorUtil.toString(message));
      }
      lt(value, message) {
        return this.setLimit("max", value, false, errorUtil_js_1.errorUtil.toString(message));
      }
      setLimit(kind, value, inclusive, message) {
        return new _ZodNumber({
          ...this._def,
          checks: [
            ...this._def.checks,
            {
              kind,
              value,
              inclusive,
              message: errorUtil_js_1.errorUtil.toString(message)
            }
          ]
        });
      }
      _addCheck(check3) {
        return new _ZodNumber({
          ...this._def,
          checks: [...this._def.checks, check3]
        });
      }
      int(message) {
        return this._addCheck({
          kind: "int",
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      positive(message) {
        return this._addCheck({
          kind: "min",
          value: 0,
          inclusive: false,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      negative(message) {
        return this._addCheck({
          kind: "max",
          value: 0,
          inclusive: false,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      nonpositive(message) {
        return this._addCheck({
          kind: "max",
          value: 0,
          inclusive: true,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      nonnegative(message) {
        return this._addCheck({
          kind: "min",
          value: 0,
          inclusive: true,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      multipleOf(value, message) {
        return this._addCheck({
          kind: "multipleOf",
          value,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      finite(message) {
        return this._addCheck({
          kind: "finite",
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      safe(message) {
        return this._addCheck({
          kind: "min",
          inclusive: true,
          value: Number.MIN_SAFE_INTEGER,
          message: errorUtil_js_1.errorUtil.toString(message)
        })._addCheck({
          kind: "max",
          inclusive: true,
          value: Number.MAX_SAFE_INTEGER,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      get minValue() {
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          }
        }
        return min;
      }
      get maxValue() {
        let max = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return max;
      }
      get isInt() {
        return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util_js_1.util.isInteger(ch.value));
      }
      get isFinite() {
        let max = null;
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
            return true;
          } else if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          } else if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return Number.isFinite(min) && Number.isFinite(max);
      }
    };
    exports2.ZodNumber = ZodNumber4;
    ZodNumber4.create = (params) => {
      return new ZodNumber4({
        checks: [],
        typeName: ZodFirstPartyTypeKind4.ZodNumber,
        coerce: params?.coerce || false,
        ...processCreateParams2(params)
      });
    };
    var ZodBigInt4 = class _ZodBigInt extends ZodType4 {
      constructor() {
        super(...arguments);
        this.min = this.gte;
        this.max = this.lte;
      }
      _parse(input) {
        if (this._def.coerce) {
          try {
            input.data = BigInt(input.data);
          } catch {
            return this._getInvalidInput(input);
          }
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.bigint) {
          return this._getInvalidInput(input);
        }
        let ctx = void 0;
        const status = new parseUtil_js_1.ParseStatus();
        for (const check3 of this._def.checks) {
          if (check3.kind === "min") {
            const tooSmall = check3.inclusive ? input.data < check3.value : input.data <= check3.value;
            if (tooSmall) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.too_small,
                type: "bigint",
                minimum: check3.value,
                inclusive: check3.inclusive,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "max") {
            const tooBig = check3.inclusive ? input.data > check3.value : input.data >= check3.value;
            if (tooBig) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.too_big,
                type: "bigint",
                maximum: check3.value,
                inclusive: check3.inclusive,
                message: check3.message
              });
              status.dirty();
            }
          } else if (check3.kind === "multipleOf") {
            if (input.data % check3.value !== BigInt(0)) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.not_multiple_of,
                multipleOf: check3.value,
                message: check3.message
              });
              status.dirty();
            }
          } else {
            util_js_1.util.assertNever(check3);
          }
        }
        return { status: status.value, value: input.data };
      }
      _getInvalidInput(input) {
        const ctx = this._getOrReturnCtx(input);
        (0, parseUtil_js_1.addIssueToContext)(ctx, {
          code: ZodError_js_1.ZodIssueCode.invalid_type,
          expected: util_js_1.ZodParsedType.bigint,
          received: ctx.parsedType
        });
        return parseUtil_js_1.INVALID;
      }
      gte(value, message) {
        return this.setLimit("min", value, true, errorUtil_js_1.errorUtil.toString(message));
      }
      gt(value, message) {
        return this.setLimit("min", value, false, errorUtil_js_1.errorUtil.toString(message));
      }
      lte(value, message) {
        return this.setLimit("max", value, true, errorUtil_js_1.errorUtil.toString(message));
      }
      lt(value, message) {
        return this.setLimit("max", value, false, errorUtil_js_1.errorUtil.toString(message));
      }
      setLimit(kind, value, inclusive, message) {
        return new _ZodBigInt({
          ...this._def,
          checks: [
            ...this._def.checks,
            {
              kind,
              value,
              inclusive,
              message: errorUtil_js_1.errorUtil.toString(message)
            }
          ]
        });
      }
      _addCheck(check3) {
        return new _ZodBigInt({
          ...this._def,
          checks: [...this._def.checks, check3]
        });
      }
      positive(message) {
        return this._addCheck({
          kind: "min",
          value: BigInt(0),
          inclusive: false,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      negative(message) {
        return this._addCheck({
          kind: "max",
          value: BigInt(0),
          inclusive: false,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      nonpositive(message) {
        return this._addCheck({
          kind: "max",
          value: BigInt(0),
          inclusive: true,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      nonnegative(message) {
        return this._addCheck({
          kind: "min",
          value: BigInt(0),
          inclusive: true,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      multipleOf(value, message) {
        return this._addCheck({
          kind: "multipleOf",
          value,
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      get minValue() {
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          }
        }
        return min;
      }
      get maxValue() {
        let max = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return max;
      }
    };
    exports2.ZodBigInt = ZodBigInt4;
    ZodBigInt4.create = (params) => {
      return new ZodBigInt4({
        checks: [],
        typeName: ZodFirstPartyTypeKind4.ZodBigInt,
        coerce: params?.coerce ?? false,
        ...processCreateParams2(params)
      });
    };
    var ZodBoolean4 = class extends ZodType4 {
      _parse(input) {
        if (this._def.coerce) {
          input.data = Boolean(input.data);
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.boolean) {
          const ctx = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.boolean,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        return (0, parseUtil_js_1.OK)(input.data);
      }
    };
    exports2.ZodBoolean = ZodBoolean4;
    ZodBoolean4.create = (params) => {
      return new ZodBoolean4({
        typeName: ZodFirstPartyTypeKind4.ZodBoolean,
        coerce: params?.coerce || false,
        ...processCreateParams2(params)
      });
    };
    var ZodDate4 = class _ZodDate extends ZodType4 {
      _parse(input) {
        if (this._def.coerce) {
          input.data = new Date(input.data);
        }
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.date) {
          const ctx2 = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx2, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.date,
            received: ctx2.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        if (Number.isNaN(input.data.getTime())) {
          const ctx2 = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx2, {
            code: ZodError_js_1.ZodIssueCode.invalid_date
          });
          return parseUtil_js_1.INVALID;
        }
        const status = new parseUtil_js_1.ParseStatus();
        let ctx = void 0;
        for (const check3 of this._def.checks) {
          if (check3.kind === "min") {
            if (input.data.getTime() < check3.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.too_small,
                message: check3.message,
                inclusive: true,
                exact: false,
                minimum: check3.value,
                type: "date"
              });
              status.dirty();
            }
          } else if (check3.kind === "max") {
            if (input.data.getTime() > check3.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.too_big,
                message: check3.message,
                inclusive: true,
                exact: false,
                maximum: check3.value,
                type: "date"
              });
              status.dirty();
            }
          } else {
            util_js_1.util.assertNever(check3);
          }
        }
        return {
          status: status.value,
          value: new Date(input.data.getTime())
        };
      }
      _addCheck(check3) {
        return new _ZodDate({
          ...this._def,
          checks: [...this._def.checks, check3]
        });
      }
      min(minDate, message) {
        return this._addCheck({
          kind: "min",
          value: minDate.getTime(),
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      max(maxDate, message) {
        return this._addCheck({
          kind: "max",
          value: maxDate.getTime(),
          message: errorUtil_js_1.errorUtil.toString(message)
        });
      }
      get minDate() {
        let min = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min === null || ch.value > min)
              min = ch.value;
          }
        }
        return min != null ? new Date(min) : null;
      }
      get maxDate() {
        let max = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max === null || ch.value < max)
              max = ch.value;
          }
        }
        return max != null ? new Date(max) : null;
      }
    };
    exports2.ZodDate = ZodDate4;
    ZodDate4.create = (params) => {
      return new ZodDate4({
        checks: [],
        coerce: params?.coerce || false,
        typeName: ZodFirstPartyTypeKind4.ZodDate,
        ...processCreateParams2(params)
      });
    };
    var ZodSymbol4 = class extends ZodType4 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.symbol) {
          const ctx = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.symbol,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        return (0, parseUtil_js_1.OK)(input.data);
      }
    };
    exports2.ZodSymbol = ZodSymbol4;
    ZodSymbol4.create = (params) => {
      return new ZodSymbol4({
        typeName: ZodFirstPartyTypeKind4.ZodSymbol,
        ...processCreateParams2(params)
      });
    };
    var ZodUndefined4 = class extends ZodType4 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.undefined) {
          const ctx = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.undefined,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        return (0, parseUtil_js_1.OK)(input.data);
      }
    };
    exports2.ZodUndefined = ZodUndefined4;
    ZodUndefined4.create = (params) => {
      return new ZodUndefined4({
        typeName: ZodFirstPartyTypeKind4.ZodUndefined,
        ...processCreateParams2(params)
      });
    };
    var ZodNull4 = class extends ZodType4 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.null) {
          const ctx = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.null,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        return (0, parseUtil_js_1.OK)(input.data);
      }
    };
    exports2.ZodNull = ZodNull4;
    ZodNull4.create = (params) => {
      return new ZodNull4({
        typeName: ZodFirstPartyTypeKind4.ZodNull,
        ...processCreateParams2(params)
      });
    };
    var ZodAny4 = class extends ZodType4 {
      constructor() {
        super(...arguments);
        this._any = true;
      }
      _parse(input) {
        return (0, parseUtil_js_1.OK)(input.data);
      }
    };
    exports2.ZodAny = ZodAny4;
    ZodAny4.create = (params) => {
      return new ZodAny4({
        typeName: ZodFirstPartyTypeKind4.ZodAny,
        ...processCreateParams2(params)
      });
    };
    var ZodUnknown4 = class extends ZodType4 {
      constructor() {
        super(...arguments);
        this._unknown = true;
      }
      _parse(input) {
        return (0, parseUtil_js_1.OK)(input.data);
      }
    };
    exports2.ZodUnknown = ZodUnknown4;
    ZodUnknown4.create = (params) => {
      return new ZodUnknown4({
        typeName: ZodFirstPartyTypeKind4.ZodUnknown,
        ...processCreateParams2(params)
      });
    };
    var ZodNever4 = class extends ZodType4 {
      _parse(input) {
        const ctx = this._getOrReturnCtx(input);
        (0, parseUtil_js_1.addIssueToContext)(ctx, {
          code: ZodError_js_1.ZodIssueCode.invalid_type,
          expected: util_js_1.ZodParsedType.never,
          received: ctx.parsedType
        });
        return parseUtil_js_1.INVALID;
      }
    };
    exports2.ZodNever = ZodNever4;
    ZodNever4.create = (params) => {
      return new ZodNever4({
        typeName: ZodFirstPartyTypeKind4.ZodNever,
        ...processCreateParams2(params)
      });
    };
    var ZodVoid4 = class extends ZodType4 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.undefined) {
          const ctx = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.void,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        return (0, parseUtil_js_1.OK)(input.data);
      }
    };
    exports2.ZodVoid = ZodVoid4;
    ZodVoid4.create = (params) => {
      return new ZodVoid4({
        typeName: ZodFirstPartyTypeKind4.ZodVoid,
        ...processCreateParams2(params)
      });
    };
    var ZodArray4 = class _ZodArray extends ZodType4 {
      _parse(input) {
        const { ctx, status } = this._processInputParams(input);
        const def = this._def;
        if (ctx.parsedType !== util_js_1.ZodParsedType.array) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.array,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        if (def.exactLength !== null) {
          const tooBig = ctx.data.length > def.exactLength.value;
          const tooSmall = ctx.data.length < def.exactLength.value;
          if (tooBig || tooSmall) {
            (0, parseUtil_js_1.addIssueToContext)(ctx, {
              code: tooBig ? ZodError_js_1.ZodIssueCode.too_big : ZodError_js_1.ZodIssueCode.too_small,
              minimum: tooSmall ? def.exactLength.value : void 0,
              maximum: tooBig ? def.exactLength.value : void 0,
              type: "array",
              inclusive: true,
              exact: true,
              message: def.exactLength.message
            });
            status.dirty();
          }
        }
        if (def.minLength !== null) {
          if (ctx.data.length < def.minLength.value) {
            (0, parseUtil_js_1.addIssueToContext)(ctx, {
              code: ZodError_js_1.ZodIssueCode.too_small,
              minimum: def.minLength.value,
              type: "array",
              inclusive: true,
              exact: false,
              message: def.minLength.message
            });
            status.dirty();
          }
        }
        if (def.maxLength !== null) {
          if (ctx.data.length > def.maxLength.value) {
            (0, parseUtil_js_1.addIssueToContext)(ctx, {
              code: ZodError_js_1.ZodIssueCode.too_big,
              maximum: def.maxLength.value,
              type: "array",
              inclusive: true,
              exact: false,
              message: def.maxLength.message
            });
            status.dirty();
          }
        }
        if (ctx.common.async) {
          return Promise.all([...ctx.data].map((item, i) => {
            return def.type._parseAsync(new ParseInputLazyPath2(ctx, item, ctx.path, i));
          })).then((result2) => {
            return parseUtil_js_1.ParseStatus.mergeArray(status, result2);
          });
        }
        const result = [...ctx.data].map((item, i) => {
          return def.type._parseSync(new ParseInputLazyPath2(ctx, item, ctx.path, i));
        });
        return parseUtil_js_1.ParseStatus.mergeArray(status, result);
      }
      get element() {
        return this._def.type;
      }
      min(minLength, message) {
        return new _ZodArray({
          ...this._def,
          minLength: { value: minLength, message: errorUtil_js_1.errorUtil.toString(message) }
        });
      }
      max(maxLength, message) {
        return new _ZodArray({
          ...this._def,
          maxLength: { value: maxLength, message: errorUtil_js_1.errorUtil.toString(message) }
        });
      }
      length(len, message) {
        return new _ZodArray({
          ...this._def,
          exactLength: { value: len, message: errorUtil_js_1.errorUtil.toString(message) }
        });
      }
      nonempty(message) {
        return this.min(1, message);
      }
    };
    exports2.ZodArray = ZodArray4;
    ZodArray4.create = (schema, params) => {
      return new ZodArray4({
        type: schema,
        minLength: null,
        maxLength: null,
        exactLength: null,
        typeName: ZodFirstPartyTypeKind4.ZodArray,
        ...processCreateParams2(params)
      });
    };
    function deepPartialify2(schema) {
      if (schema instanceof ZodObject4) {
        const newShape = {};
        for (const key in schema.shape) {
          const fieldSchema = schema.shape[key];
          newShape[key] = ZodOptional4.create(deepPartialify2(fieldSchema));
        }
        return new ZodObject4({
          ...schema._def,
          shape: () => newShape
        });
      } else if (schema instanceof ZodArray4) {
        return new ZodArray4({
          ...schema._def,
          type: deepPartialify2(schema.element)
        });
      } else if (schema instanceof ZodOptional4) {
        return ZodOptional4.create(deepPartialify2(schema.unwrap()));
      } else if (schema instanceof ZodNullable4) {
        return ZodNullable4.create(deepPartialify2(schema.unwrap()));
      } else if (schema instanceof ZodTuple4) {
        return ZodTuple4.create(schema.items.map((item) => deepPartialify2(item)));
      } else {
        return schema;
      }
    }
    var ZodObject4 = class _ZodObject extends ZodType4 {
      constructor() {
        super(...arguments);
        this._cached = null;
        this.nonstrict = this.passthrough;
        this.augment = this.extend;
      }
      _getCached() {
        if (this._cached !== null)
          return this._cached;
        const shape = this._def.shape();
        const keys2 = util_js_1.util.objectKeys(shape);
        this._cached = { shape, keys: keys2 };
        return this._cached;
      }
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.object) {
          const ctx2 = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx2, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.object,
            received: ctx2.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        const { status, ctx } = this._processInputParams(input);
        const { shape, keys: shapeKeys } = this._getCached();
        const extraKeys = [];
        if (!(this._def.catchall instanceof ZodNever4 && this._def.unknownKeys === "strip")) {
          for (const key in ctx.data) {
            if (!shapeKeys.includes(key)) {
              extraKeys.push(key);
            }
          }
        }
        const pairs = [];
        for (const key of shapeKeys) {
          const keyValidator = shape[key];
          const value = ctx.data[key];
          pairs.push({
            key: { status: "valid", value: key },
            value: keyValidator._parse(new ParseInputLazyPath2(ctx, value, ctx.path, key)),
            alwaysSet: key in ctx.data
          });
        }
        if (this._def.catchall instanceof ZodNever4) {
          const unknownKeys = this._def.unknownKeys;
          if (unknownKeys === "passthrough") {
            for (const key of extraKeys) {
              pairs.push({
                key: { status: "valid", value: key },
                value: { status: "valid", value: ctx.data[key] }
              });
            }
          } else if (unknownKeys === "strict") {
            if (extraKeys.length > 0) {
              (0, parseUtil_js_1.addIssueToContext)(ctx, {
                code: ZodError_js_1.ZodIssueCode.unrecognized_keys,
                keys: extraKeys
              });
              status.dirty();
            }
          } else if (unknownKeys === "strip") {
          } else {
            throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
          }
        } else {
          const catchall = this._def.catchall;
          for (const key of extraKeys) {
            const value = ctx.data[key];
            pairs.push({
              key: { status: "valid", value: key },
              value: catchall._parse(
                new ParseInputLazyPath2(ctx, value, ctx.path, key)
                //, ctx.child(key), value, getParsedType(value)
              ),
              alwaysSet: key in ctx.data
            });
          }
        }
        if (ctx.common.async) {
          return Promise.resolve().then(async () => {
            const syncPairs = [];
            for (const pair of pairs) {
              const key = await pair.key;
              const value = await pair.value;
              syncPairs.push({
                key,
                value,
                alwaysSet: pair.alwaysSet
              });
            }
            return syncPairs;
          }).then((syncPairs) => {
            return parseUtil_js_1.ParseStatus.mergeObjectSync(status, syncPairs);
          });
        } else {
          return parseUtil_js_1.ParseStatus.mergeObjectSync(status, pairs);
        }
      }
      get shape() {
        return this._def.shape();
      }
      strict(message) {
        errorUtil_js_1.errorUtil.errToObj;
        return new _ZodObject({
          ...this._def,
          unknownKeys: "strict",
          ...message !== void 0 ? {
            errorMap: (issue3, ctx) => {
              const defaultError = this._def.errorMap?.(issue3, ctx).message ?? ctx.defaultError;
              if (issue3.code === "unrecognized_keys")
                return {
                  message: errorUtil_js_1.errorUtil.errToObj(message).message ?? defaultError
                };
              return {
                message: defaultError
              };
            }
          } : {}
        });
      }
      strip() {
        return new _ZodObject({
          ...this._def,
          unknownKeys: "strip"
        });
      }
      passthrough() {
        return new _ZodObject({
          ...this._def,
          unknownKeys: "passthrough"
        });
      }
      // const AugmentFactory =
      //   <Def extends ZodObjectDef>(def: Def) =>
      //   <Augmentation extends ZodRawShape>(
      //     augmentation: Augmentation
      //   ): ZodObject<
      //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
      //     Def["unknownKeys"],
      //     Def["catchall"]
      //   > => {
      //     return new ZodObject({
      //       ...def,
      //       shape: () => ({
      //         ...def.shape(),
      //         ...augmentation,
      //       }),
      //     }) as any;
      //   };
      extend(augmentation) {
        return new _ZodObject({
          ...this._def,
          shape: () => ({
            ...this._def.shape(),
            ...augmentation
          })
        });
      }
      /**
       * Prior to zod@1.0.12 there was a bug in the
       * inferred type of merged objects. Please
       * upgrade if you are experiencing issues.
       */
      merge(merging) {
        const merged = new _ZodObject({
          unknownKeys: merging._def.unknownKeys,
          catchall: merging._def.catchall,
          shape: () => ({
            ...this._def.shape(),
            ...merging._def.shape()
          }),
          typeName: ZodFirstPartyTypeKind4.ZodObject
        });
        return merged;
      }
      // merge<
      //   Incoming extends AnyZodObject,
      //   Augmentation extends Incoming["shape"],
      //   NewOutput extends {
      //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
      //       ? Augmentation[k]["_output"]
      //       : k extends keyof Output
      //       ? Output[k]
      //       : never;
      //   },
      //   NewInput extends {
      //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
      //       ? Augmentation[k]["_input"]
      //       : k extends keyof Input
      //       ? Input[k]
      //       : never;
      //   }
      // >(
      //   merging: Incoming
      // ): ZodObject<
      //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
      //   Incoming["_def"]["unknownKeys"],
      //   Incoming["_def"]["catchall"],
      //   NewOutput,
      //   NewInput
      // > {
      //   const merged: any = new ZodObject({
      //     unknownKeys: merging._def.unknownKeys,
      //     catchall: merging._def.catchall,
      //     shape: () =>
      //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
      //     typeName: ZodFirstPartyTypeKind.ZodObject,
      //   }) as any;
      //   return merged;
      // }
      setKey(key, schema) {
        return this.augment({ [key]: schema });
      }
      // merge<Incoming extends AnyZodObject>(
      //   merging: Incoming
      // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
      // ZodObject<
      //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
      //   Incoming["_def"]["unknownKeys"],
      //   Incoming["_def"]["catchall"]
      // > {
      //   // const mergedShape = objectUtil.mergeShapes(
      //   //   this._def.shape(),
      //   //   merging._def.shape()
      //   // );
      //   const merged: any = new ZodObject({
      //     unknownKeys: merging._def.unknownKeys,
      //     catchall: merging._def.catchall,
      //     shape: () =>
      //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
      //     typeName: ZodFirstPartyTypeKind.ZodObject,
      //   }) as any;
      //   return merged;
      // }
      catchall(index) {
        return new _ZodObject({
          ...this._def,
          catchall: index
        });
      }
      pick(mask) {
        const shape = {};
        for (const key of util_js_1.util.objectKeys(mask)) {
          if (mask[key] && this.shape[key]) {
            shape[key] = this.shape[key];
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => shape
        });
      }
      omit(mask) {
        const shape = {};
        for (const key of util_js_1.util.objectKeys(this.shape)) {
          if (!mask[key]) {
            shape[key] = this.shape[key];
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => shape
        });
      }
      /**
       * @deprecated
       */
      deepPartial() {
        return deepPartialify2(this);
      }
      partial(mask) {
        const newShape = {};
        for (const key of util_js_1.util.objectKeys(this.shape)) {
          const fieldSchema = this.shape[key];
          if (mask && !mask[key]) {
            newShape[key] = fieldSchema;
          } else {
            newShape[key] = fieldSchema.optional();
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => newShape
        });
      }
      required(mask) {
        const newShape = {};
        for (const key of util_js_1.util.objectKeys(this.shape)) {
          if (mask && !mask[key]) {
            newShape[key] = this.shape[key];
          } else {
            const fieldSchema = this.shape[key];
            let newField = fieldSchema;
            while (newField instanceof ZodOptional4) {
              newField = newField._def.innerType;
            }
            newShape[key] = newField;
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => newShape
        });
      }
      keyof() {
        return createZodEnum2(util_js_1.util.objectKeys(this.shape));
      }
    };
    exports2.ZodObject = ZodObject4;
    ZodObject4.create = (shape, params) => {
      return new ZodObject4({
        shape: () => shape,
        unknownKeys: "strip",
        catchall: ZodNever4.create(),
        typeName: ZodFirstPartyTypeKind4.ZodObject,
        ...processCreateParams2(params)
      });
    };
    ZodObject4.strictCreate = (shape, params) => {
      return new ZodObject4({
        shape: () => shape,
        unknownKeys: "strict",
        catchall: ZodNever4.create(),
        typeName: ZodFirstPartyTypeKind4.ZodObject,
        ...processCreateParams2(params)
      });
    };
    ZodObject4.lazycreate = (shape, params) => {
      return new ZodObject4({
        shape,
        unknownKeys: "strip",
        catchall: ZodNever4.create(),
        typeName: ZodFirstPartyTypeKind4.ZodObject,
        ...processCreateParams2(params)
      });
    };
    var ZodUnion4 = class extends ZodType4 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const options = this._def.options;
        function handleResults(results) {
          for (const result of results) {
            if (result.result.status === "valid") {
              return result.result;
            }
          }
          for (const result of results) {
            if (result.result.status === "dirty") {
              ctx.common.issues.push(...result.ctx.common.issues);
              return result.result;
            }
          }
          const unionErrors = results.map((result) => new ZodError_js_1.ZodError(result.ctx.common.issues));
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_union,
            unionErrors
          });
          return parseUtil_js_1.INVALID;
        }
        if (ctx.common.async) {
          return Promise.all(options.map(async (option) => {
            const childCtx = {
              ...ctx,
              common: {
                ...ctx.common,
                issues: []
              },
              parent: null
            };
            return {
              result: await option._parseAsync({
                data: ctx.data,
                path: ctx.path,
                parent: childCtx
              }),
              ctx: childCtx
            };
          })).then(handleResults);
        } else {
          let dirty = void 0;
          const issues = [];
          for (const option of options) {
            const childCtx = {
              ...ctx,
              common: {
                ...ctx.common,
                issues: []
              },
              parent: null
            };
            const result = option._parseSync({
              data: ctx.data,
              path: ctx.path,
              parent: childCtx
            });
            if (result.status === "valid") {
              return result;
            } else if (result.status === "dirty" && !dirty) {
              dirty = { result, ctx: childCtx };
            }
            if (childCtx.common.issues.length) {
              issues.push(childCtx.common.issues);
            }
          }
          if (dirty) {
            ctx.common.issues.push(...dirty.ctx.common.issues);
            return dirty.result;
          }
          const unionErrors = issues.map((issues2) => new ZodError_js_1.ZodError(issues2));
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_union,
            unionErrors
          });
          return parseUtil_js_1.INVALID;
        }
      }
      get options() {
        return this._def.options;
      }
    };
    exports2.ZodUnion = ZodUnion4;
    ZodUnion4.create = (types, params) => {
      return new ZodUnion4({
        options: types,
        typeName: ZodFirstPartyTypeKind4.ZodUnion,
        ...processCreateParams2(params)
      });
    };
    var getDiscriminator2 = (type) => {
      if (type instanceof ZodLazy4) {
        return getDiscriminator2(type.schema);
      } else if (type instanceof ZodEffects2) {
        return getDiscriminator2(type.innerType());
      } else if (type instanceof ZodLiteral4) {
        return [type.value];
      } else if (type instanceof ZodEnum4) {
        return type.options;
      } else if (type instanceof ZodNativeEnum2) {
        return util_js_1.util.objectValues(type.enum);
      } else if (type instanceof ZodDefault4) {
        return getDiscriminator2(type._def.innerType);
      } else if (type instanceof ZodUndefined4) {
        return [void 0];
      } else if (type instanceof ZodNull4) {
        return [null];
      } else if (type instanceof ZodOptional4) {
        return [void 0, ...getDiscriminator2(type.unwrap())];
      } else if (type instanceof ZodNullable4) {
        return [null, ...getDiscriminator2(type.unwrap())];
      } else if (type instanceof ZodBranded2) {
        return getDiscriminator2(type.unwrap());
      } else if (type instanceof ZodReadonly4) {
        return getDiscriminator2(type.unwrap());
      } else if (type instanceof ZodCatch4) {
        return getDiscriminator2(type._def.innerType);
      } else {
        return [];
      }
    };
    var ZodDiscriminatedUnion4 = class _ZodDiscriminatedUnion extends ZodType4 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        if (ctx.parsedType !== util_js_1.ZodParsedType.object) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.object,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        const discriminator = this.discriminator;
        const discriminatorValue = ctx.data[discriminator];
        const option = this.optionsMap.get(discriminatorValue);
        if (!option) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_union_discriminator,
            options: Array.from(this.optionsMap.keys()),
            path: [discriminator]
          });
          return parseUtil_js_1.INVALID;
        }
        if (ctx.common.async) {
          return option._parseAsync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          });
        } else {
          return option._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          });
        }
      }
      get discriminator() {
        return this._def.discriminator;
      }
      get options() {
        return this._def.options;
      }
      get optionsMap() {
        return this._def.optionsMap;
      }
      /**
       * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
       * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
       * have a different value for each object in the union.
       * @param discriminator the name of the discriminator property
       * @param types an array of object schemas
       * @param params
       */
      static create(discriminator, options, params) {
        const optionsMap = /* @__PURE__ */ new Map();
        for (const type of options) {
          const discriminatorValues = getDiscriminator2(type.shape[discriminator]);
          if (!discriminatorValues.length) {
            throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
          }
          for (const value of discriminatorValues) {
            if (optionsMap.has(value)) {
              throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
            }
            optionsMap.set(value, type);
          }
        }
        return new _ZodDiscriminatedUnion({
          typeName: ZodFirstPartyTypeKind4.ZodDiscriminatedUnion,
          discriminator,
          options,
          optionsMap,
          ...processCreateParams2(params)
        });
      }
    };
    exports2.ZodDiscriminatedUnion = ZodDiscriminatedUnion4;
    function mergeValues4(a, b) {
      const aType = (0, util_js_1.getParsedType)(a);
      const bType = (0, util_js_1.getParsedType)(b);
      if (a === b) {
        return { valid: true, data: a };
      } else if (aType === util_js_1.ZodParsedType.object && bType === util_js_1.ZodParsedType.object) {
        const bKeys = util_js_1.util.objectKeys(b);
        const sharedKeys = util_js_1.util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
        const newObj = { ...a, ...b };
        for (const key of sharedKeys) {
          const sharedValue = mergeValues4(a[key], b[key]);
          if (!sharedValue.valid) {
            return { valid: false };
          }
          newObj[key] = sharedValue.data;
        }
        return { valid: true, data: newObj };
      } else if (aType === util_js_1.ZodParsedType.array && bType === util_js_1.ZodParsedType.array) {
        if (a.length !== b.length) {
          return { valid: false };
        }
        const newArray = [];
        for (let index = 0; index < a.length; index++) {
          const itemA = a[index];
          const itemB = b[index];
          const sharedValue = mergeValues4(itemA, itemB);
          if (!sharedValue.valid) {
            return { valid: false };
          }
          newArray.push(sharedValue.data);
        }
        return { valid: true, data: newArray };
      } else if (aType === util_js_1.ZodParsedType.date && bType === util_js_1.ZodParsedType.date && +a === +b) {
        return { valid: true, data: a };
      } else {
        return { valid: false };
      }
    }
    var ZodIntersection4 = class extends ZodType4 {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        const handleParsed = (parsedLeft, parsedRight) => {
          if ((0, parseUtil_js_1.isAborted)(parsedLeft) || (0, parseUtil_js_1.isAborted)(parsedRight)) {
            return parseUtil_js_1.INVALID;
          }
          const merged = mergeValues4(parsedLeft.value, parsedRight.value);
          if (!merged.valid) {
            (0, parseUtil_js_1.addIssueToContext)(ctx, {
              code: ZodError_js_1.ZodIssueCode.invalid_intersection_types
            });
            return parseUtil_js_1.INVALID;
          }
          if ((0, parseUtil_js_1.isDirty)(parsedLeft) || (0, parseUtil_js_1.isDirty)(parsedRight)) {
            status.dirty();
          }
          return { status: status.value, value: merged.data };
        };
        if (ctx.common.async) {
          return Promise.all([
            this._def.left._parseAsync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            }),
            this._def.right._parseAsync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            })
          ]).then(([left, right]) => handleParsed(left, right));
        } else {
          return handleParsed(this._def.left._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          }), this._def.right._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          }));
        }
      }
    };
    exports2.ZodIntersection = ZodIntersection4;
    ZodIntersection4.create = (left, right, params) => {
      return new ZodIntersection4({
        left,
        right,
        typeName: ZodFirstPartyTypeKind4.ZodIntersection,
        ...processCreateParams2(params)
      });
    };
    var ZodTuple4 = class _ZodTuple extends ZodType4 {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== util_js_1.ZodParsedType.array) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.array,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        if (ctx.data.length < this._def.items.length) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.too_small,
            minimum: this._def.items.length,
            inclusive: true,
            exact: false,
            type: "array"
          });
          return parseUtil_js_1.INVALID;
        }
        const rest = this._def.rest;
        if (!rest && ctx.data.length > this._def.items.length) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.too_big,
            maximum: this._def.items.length,
            inclusive: true,
            exact: false,
            type: "array"
          });
          status.dirty();
        }
        const items = [...ctx.data].map((item, itemIndex) => {
          const schema = this._def.items[itemIndex] || this._def.rest;
          if (!schema)
            return null;
          return schema._parse(new ParseInputLazyPath2(ctx, item, ctx.path, itemIndex));
        }).filter((x) => !!x);
        if (ctx.common.async) {
          return Promise.all(items).then((results) => {
            return parseUtil_js_1.ParseStatus.mergeArray(status, results);
          });
        } else {
          return parseUtil_js_1.ParseStatus.mergeArray(status, items);
        }
      }
      get items() {
        return this._def.items;
      }
      rest(rest) {
        return new _ZodTuple({
          ...this._def,
          rest
        });
      }
    };
    exports2.ZodTuple = ZodTuple4;
    ZodTuple4.create = (schemas, params) => {
      if (!Array.isArray(schemas)) {
        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
      }
      return new ZodTuple4({
        items: schemas,
        typeName: ZodFirstPartyTypeKind4.ZodTuple,
        rest: null,
        ...processCreateParams2(params)
      });
    };
    var ZodRecord4 = class _ZodRecord extends ZodType4 {
      get keySchema() {
        return this._def.keyType;
      }
      get valueSchema() {
        return this._def.valueType;
      }
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== util_js_1.ZodParsedType.object) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.object,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        const pairs = [];
        const keyType = this._def.keyType;
        const valueType = this._def.valueType;
        for (const key in ctx.data) {
          pairs.push({
            key: keyType._parse(new ParseInputLazyPath2(ctx, key, ctx.path, key)),
            value: valueType._parse(new ParseInputLazyPath2(ctx, ctx.data[key], ctx.path, key)),
            alwaysSet: key in ctx.data
          });
        }
        if (ctx.common.async) {
          return parseUtil_js_1.ParseStatus.mergeObjectAsync(status, pairs);
        } else {
          return parseUtil_js_1.ParseStatus.mergeObjectSync(status, pairs);
        }
      }
      get element() {
        return this._def.valueType;
      }
      static create(first, second, third) {
        if (second instanceof ZodType4) {
          return new _ZodRecord({
            keyType: first,
            valueType: second,
            typeName: ZodFirstPartyTypeKind4.ZodRecord,
            ...processCreateParams2(third)
          });
        }
        return new _ZodRecord({
          keyType: ZodString4.create(),
          valueType: first,
          typeName: ZodFirstPartyTypeKind4.ZodRecord,
          ...processCreateParams2(second)
        });
      }
    };
    exports2.ZodRecord = ZodRecord4;
    var ZodMap4 = class extends ZodType4 {
      get keySchema() {
        return this._def.keyType;
      }
      get valueSchema() {
        return this._def.valueType;
      }
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== util_js_1.ZodParsedType.map) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.map,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        const keyType = this._def.keyType;
        const valueType = this._def.valueType;
        const pairs = [...ctx.data.entries()].map(([key, value], index) => {
          return {
            key: keyType._parse(new ParseInputLazyPath2(ctx, key, ctx.path, [index, "key"])),
            value: valueType._parse(new ParseInputLazyPath2(ctx, value, ctx.path, [index, "value"]))
          };
        });
        if (ctx.common.async) {
          const finalMap = /* @__PURE__ */ new Map();
          return Promise.resolve().then(async () => {
            for (const pair of pairs) {
              const key = await pair.key;
              const value = await pair.value;
              if (key.status === "aborted" || value.status === "aborted") {
                return parseUtil_js_1.INVALID;
              }
              if (key.status === "dirty" || value.status === "dirty") {
                status.dirty();
              }
              finalMap.set(key.value, value.value);
            }
            return { status: status.value, value: finalMap };
          });
        } else {
          const finalMap = /* @__PURE__ */ new Map();
          for (const pair of pairs) {
            const key = pair.key;
            const value = pair.value;
            if (key.status === "aborted" || value.status === "aborted") {
              return parseUtil_js_1.INVALID;
            }
            if (key.status === "dirty" || value.status === "dirty") {
              status.dirty();
            }
            finalMap.set(key.value, value.value);
          }
          return { status: status.value, value: finalMap };
        }
      }
    };
    exports2.ZodMap = ZodMap4;
    ZodMap4.create = (keyType, valueType, params) => {
      return new ZodMap4({
        valueType,
        keyType,
        typeName: ZodFirstPartyTypeKind4.ZodMap,
        ...processCreateParams2(params)
      });
    };
    var ZodSet4 = class _ZodSet extends ZodType4 {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== util_js_1.ZodParsedType.set) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.set,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        const def = this._def;
        if (def.minSize !== null) {
          if (ctx.data.size < def.minSize.value) {
            (0, parseUtil_js_1.addIssueToContext)(ctx, {
              code: ZodError_js_1.ZodIssueCode.too_small,
              minimum: def.minSize.value,
              type: "set",
              inclusive: true,
              exact: false,
              message: def.minSize.message
            });
            status.dirty();
          }
        }
        if (def.maxSize !== null) {
          if (ctx.data.size > def.maxSize.value) {
            (0, parseUtil_js_1.addIssueToContext)(ctx, {
              code: ZodError_js_1.ZodIssueCode.too_big,
              maximum: def.maxSize.value,
              type: "set",
              inclusive: true,
              exact: false,
              message: def.maxSize.message
            });
            status.dirty();
          }
        }
        const valueType = this._def.valueType;
        function finalizeSet(elements2) {
          const parsedSet = /* @__PURE__ */ new Set();
          for (const element of elements2) {
            if (element.status === "aborted")
              return parseUtil_js_1.INVALID;
            if (element.status === "dirty")
              status.dirty();
            parsedSet.add(element.value);
          }
          return { status: status.value, value: parsedSet };
        }
        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath2(ctx, item, ctx.path, i)));
        if (ctx.common.async) {
          return Promise.all(elements).then((elements2) => finalizeSet(elements2));
        } else {
          return finalizeSet(elements);
        }
      }
      min(minSize, message) {
        return new _ZodSet({
          ...this._def,
          minSize: { value: minSize, message: errorUtil_js_1.errorUtil.toString(message) }
        });
      }
      max(maxSize, message) {
        return new _ZodSet({
          ...this._def,
          maxSize: { value: maxSize, message: errorUtil_js_1.errorUtil.toString(message) }
        });
      }
      size(size, message) {
        return this.min(size, message).max(size, message);
      }
      nonempty(message) {
        return this.min(1, message);
      }
    };
    exports2.ZodSet = ZodSet4;
    ZodSet4.create = (valueType, params) => {
      return new ZodSet4({
        valueType,
        minSize: null,
        maxSize: null,
        typeName: ZodFirstPartyTypeKind4.ZodSet,
        ...processCreateParams2(params)
      });
    };
    var ZodFunction4 = class _ZodFunction extends ZodType4 {
      constructor() {
        super(...arguments);
        this.validate = this.implement;
      }
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        if (ctx.parsedType !== util_js_1.ZodParsedType.function) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.function,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        function makeArgsIssue(args, error73) {
          return (0, parseUtil_js_1.makeIssue)({
            data: args,
            path: ctx.path,
            errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, (0, errors_js_1.getErrorMap)(), errors_js_1.defaultErrorMap].filter((x) => !!x),
            issueData: {
              code: ZodError_js_1.ZodIssueCode.invalid_arguments,
              argumentsError: error73
            }
          });
        }
        function makeReturnsIssue(returns, error73) {
          return (0, parseUtil_js_1.makeIssue)({
            data: returns,
            path: ctx.path,
            errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, (0, errors_js_1.getErrorMap)(), errors_js_1.defaultErrorMap].filter((x) => !!x),
            issueData: {
              code: ZodError_js_1.ZodIssueCode.invalid_return_type,
              returnTypeError: error73
            }
          });
        }
        const params = { errorMap: ctx.common.contextualErrorMap };
        const fn = ctx.data;
        if (this._def.returns instanceof ZodPromise4) {
          const me = this;
          return (0, parseUtil_js_1.OK)(async function(...args) {
            const error73 = new ZodError_js_1.ZodError([]);
            const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
              error73.addIssue(makeArgsIssue(args, e));
              throw error73;
            });
            const result = await Reflect.apply(fn, this, parsedArgs);
            const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
              error73.addIssue(makeReturnsIssue(result, e));
              throw error73;
            });
            return parsedReturns;
          });
        } else {
          const me = this;
          return (0, parseUtil_js_1.OK)(function(...args) {
            const parsedArgs = me._def.args.safeParse(args, params);
            if (!parsedArgs.success) {
              throw new ZodError_js_1.ZodError([makeArgsIssue(args, parsedArgs.error)]);
            }
            const result = Reflect.apply(fn, this, parsedArgs.data);
            const parsedReturns = me._def.returns.safeParse(result, params);
            if (!parsedReturns.success) {
              throw new ZodError_js_1.ZodError([makeReturnsIssue(result, parsedReturns.error)]);
            }
            return parsedReturns.data;
          });
        }
      }
      parameters() {
        return this._def.args;
      }
      returnType() {
        return this._def.returns;
      }
      args(...items) {
        return new _ZodFunction({
          ...this._def,
          args: ZodTuple4.create(items).rest(ZodUnknown4.create())
        });
      }
      returns(returnType) {
        return new _ZodFunction({
          ...this._def,
          returns: returnType
        });
      }
      implement(func) {
        const validatedFunc = this.parse(func);
        return validatedFunc;
      }
      strictImplement(func) {
        const validatedFunc = this.parse(func);
        return validatedFunc;
      }
      static create(args, returns, params) {
        return new _ZodFunction({
          args: args ? args : ZodTuple4.create([]).rest(ZodUnknown4.create()),
          returns: returns || ZodUnknown4.create(),
          typeName: ZodFirstPartyTypeKind4.ZodFunction,
          ...processCreateParams2(params)
        });
      }
    };
    exports2.ZodFunction = ZodFunction4;
    var ZodLazy4 = class extends ZodType4 {
      get schema() {
        return this._def.getter();
      }
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const lazySchema3 = this._def.getter();
        return lazySchema3._parse({ data: ctx.data, path: ctx.path, parent: ctx });
      }
    };
    exports2.ZodLazy = ZodLazy4;
    ZodLazy4.create = (getter, params) => {
      return new ZodLazy4({
        getter,
        typeName: ZodFirstPartyTypeKind4.ZodLazy,
        ...processCreateParams2(params)
      });
    };
    var ZodLiteral4 = class extends ZodType4 {
      _parse(input) {
        if (input.data !== this._def.value) {
          const ctx = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            received: ctx.data,
            code: ZodError_js_1.ZodIssueCode.invalid_literal,
            expected: this._def.value
          });
          return parseUtil_js_1.INVALID;
        }
        return { status: "valid", value: input.data };
      }
      get value() {
        return this._def.value;
      }
    };
    exports2.ZodLiteral = ZodLiteral4;
    ZodLiteral4.create = (value, params) => {
      return new ZodLiteral4({
        value,
        typeName: ZodFirstPartyTypeKind4.ZodLiteral,
        ...processCreateParams2(params)
      });
    };
    function createZodEnum2(values, params) {
      return new ZodEnum4({
        values,
        typeName: ZodFirstPartyTypeKind4.ZodEnum,
        ...processCreateParams2(params)
      });
    }
    var ZodEnum4 = class _ZodEnum extends ZodType4 {
      _parse(input) {
        if (typeof input.data !== "string") {
          const ctx = this._getOrReturnCtx(input);
          const expectedValues = this._def.values;
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            expected: util_js_1.util.joinValues(expectedValues),
            received: ctx.parsedType,
            code: ZodError_js_1.ZodIssueCode.invalid_type
          });
          return parseUtil_js_1.INVALID;
        }
        if (!this._cache) {
          this._cache = new Set(this._def.values);
        }
        if (!this._cache.has(input.data)) {
          const ctx = this._getOrReturnCtx(input);
          const expectedValues = this._def.values;
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            received: ctx.data,
            code: ZodError_js_1.ZodIssueCode.invalid_enum_value,
            options: expectedValues
          });
          return parseUtil_js_1.INVALID;
        }
        return (0, parseUtil_js_1.OK)(input.data);
      }
      get options() {
        return this._def.values;
      }
      get enum() {
        const enumValues = {};
        for (const val of this._def.values) {
          enumValues[val] = val;
        }
        return enumValues;
      }
      get Values() {
        const enumValues = {};
        for (const val of this._def.values) {
          enumValues[val] = val;
        }
        return enumValues;
      }
      get Enum() {
        const enumValues = {};
        for (const val of this._def.values) {
          enumValues[val] = val;
        }
        return enumValues;
      }
      extract(values, newDef = this._def) {
        return _ZodEnum.create(values, {
          ...this._def,
          ...newDef
        });
      }
      exclude(values, newDef = this._def) {
        return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
          ...this._def,
          ...newDef
        });
      }
    };
    exports2.ZodEnum = ZodEnum4;
    ZodEnum4.create = createZodEnum2;
    var ZodNativeEnum2 = class extends ZodType4 {
      _parse(input) {
        const nativeEnumValues = util_js_1.util.getValidEnumValues(this._def.values);
        const ctx = this._getOrReturnCtx(input);
        if (ctx.parsedType !== util_js_1.ZodParsedType.string && ctx.parsedType !== util_js_1.ZodParsedType.number) {
          const expectedValues = util_js_1.util.objectValues(nativeEnumValues);
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            expected: util_js_1.util.joinValues(expectedValues),
            received: ctx.parsedType,
            code: ZodError_js_1.ZodIssueCode.invalid_type
          });
          return parseUtil_js_1.INVALID;
        }
        if (!this._cache) {
          this._cache = new Set(util_js_1.util.getValidEnumValues(this._def.values));
        }
        if (!this._cache.has(input.data)) {
          const expectedValues = util_js_1.util.objectValues(nativeEnumValues);
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            received: ctx.data,
            code: ZodError_js_1.ZodIssueCode.invalid_enum_value,
            options: expectedValues
          });
          return parseUtil_js_1.INVALID;
        }
        return (0, parseUtil_js_1.OK)(input.data);
      }
      get enum() {
        return this._def.values;
      }
    };
    exports2.ZodNativeEnum = ZodNativeEnum2;
    ZodNativeEnum2.create = (values, params) => {
      return new ZodNativeEnum2({
        values,
        typeName: ZodFirstPartyTypeKind4.ZodNativeEnum,
        ...processCreateParams2(params)
      });
    };
    var ZodPromise4 = class extends ZodType4 {
      unwrap() {
        return this._def.type;
      }
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        if (ctx.parsedType !== util_js_1.ZodParsedType.promise && ctx.common.async === false) {
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.promise,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        const promisified = ctx.parsedType === util_js_1.ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
        return (0, parseUtil_js_1.OK)(promisified.then((data) => {
          return this._def.type.parseAsync(data, {
            path: ctx.path,
            errorMap: ctx.common.contextualErrorMap
          });
        }));
      }
    };
    exports2.ZodPromise = ZodPromise4;
    ZodPromise4.create = (schema, params) => {
      return new ZodPromise4({
        type: schema,
        typeName: ZodFirstPartyTypeKind4.ZodPromise,
        ...processCreateParams2(params)
      });
    };
    var ZodEffects2 = class extends ZodType4 {
      innerType() {
        return this._def.schema;
      }
      sourceType() {
        return this._def.schema._def.typeName === ZodFirstPartyTypeKind4.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
      }
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        const effect = this._def.effect || null;
        const checkCtx = {
          addIssue: (arg) => {
            (0, parseUtil_js_1.addIssueToContext)(ctx, arg);
            if (arg.fatal) {
              status.abort();
            } else {
              status.dirty();
            }
          },
          get path() {
            return ctx.path;
          }
        };
        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
        if (effect.type === "preprocess") {
          const processed = effect.transform(ctx.data, checkCtx);
          if (ctx.common.async) {
            return Promise.resolve(processed).then(async (processed2) => {
              if (status.value === "aborted")
                return parseUtil_js_1.INVALID;
              const result = await this._def.schema._parseAsync({
                data: processed2,
                path: ctx.path,
                parent: ctx
              });
              if (result.status === "aborted")
                return parseUtil_js_1.INVALID;
              if (result.status === "dirty")
                return (0, parseUtil_js_1.DIRTY)(result.value);
              if (status.value === "dirty")
                return (0, parseUtil_js_1.DIRTY)(result.value);
              return result;
            });
          } else {
            if (status.value === "aborted")
              return parseUtil_js_1.INVALID;
            const result = this._def.schema._parseSync({
              data: processed,
              path: ctx.path,
              parent: ctx
            });
            if (result.status === "aborted")
              return parseUtil_js_1.INVALID;
            if (result.status === "dirty")
              return (0, parseUtil_js_1.DIRTY)(result.value);
            if (status.value === "dirty")
              return (0, parseUtil_js_1.DIRTY)(result.value);
            return result;
          }
        }
        if (effect.type === "refinement") {
          const executeRefinement = (acc) => {
            const result = effect.refinement(acc, checkCtx);
            if (ctx.common.async) {
              return Promise.resolve(result);
            }
            if (result instanceof Promise) {
              throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
            }
            return acc;
          };
          if (ctx.common.async === false) {
            const inner = this._def.schema._parseSync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            });
            if (inner.status === "aborted")
              return parseUtil_js_1.INVALID;
            if (inner.status === "dirty")
              status.dirty();
            executeRefinement(inner.value);
            return { status: status.value, value: inner.value };
          } else {
            return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
              if (inner.status === "aborted")
                return parseUtil_js_1.INVALID;
              if (inner.status === "dirty")
                status.dirty();
              return executeRefinement(inner.value).then(() => {
                return { status: status.value, value: inner.value };
              });
            });
          }
        }
        if (effect.type === "transform") {
          if (ctx.common.async === false) {
            const base = this._def.schema._parseSync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            });
            if (!(0, parseUtil_js_1.isValid)(base))
              return parseUtil_js_1.INVALID;
            const result = effect.transform(base.value, checkCtx);
            if (result instanceof Promise) {
              throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
            }
            return { status: status.value, value: result };
          } else {
            return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
              if (!(0, parseUtil_js_1.isValid)(base))
                return parseUtil_js_1.INVALID;
              return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
                status: status.value,
                value: result
              }));
            });
          }
        }
        util_js_1.util.assertNever(effect);
      }
    };
    exports2.ZodEffects = ZodEffects2;
    exports2.ZodTransformer = ZodEffects2;
    ZodEffects2.create = (schema, effect, params) => {
      return new ZodEffects2({
        schema,
        typeName: ZodFirstPartyTypeKind4.ZodEffects,
        effect,
        ...processCreateParams2(params)
      });
    };
    ZodEffects2.createWithPreprocess = (preprocess3, schema, params) => {
      return new ZodEffects2({
        schema,
        effect: { type: "preprocess", transform: preprocess3 },
        typeName: ZodFirstPartyTypeKind4.ZodEffects,
        ...processCreateParams2(params)
      });
    };
    var ZodOptional4 = class extends ZodType4 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 === util_js_1.ZodParsedType.undefined) {
          return (0, parseUtil_js_1.OK)(void 0);
        }
        return this._def.innerType._parse(input);
      }
      unwrap() {
        return this._def.innerType;
      }
    };
    exports2.ZodOptional = ZodOptional4;
    ZodOptional4.create = (type, params) => {
      return new ZodOptional4({
        innerType: type,
        typeName: ZodFirstPartyTypeKind4.ZodOptional,
        ...processCreateParams2(params)
      });
    };
    var ZodNullable4 = class extends ZodType4 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 === util_js_1.ZodParsedType.null) {
          return (0, parseUtil_js_1.OK)(null);
        }
        return this._def.innerType._parse(input);
      }
      unwrap() {
        return this._def.innerType;
      }
    };
    exports2.ZodNullable = ZodNullable4;
    ZodNullable4.create = (type, params) => {
      return new ZodNullable4({
        innerType: type,
        typeName: ZodFirstPartyTypeKind4.ZodNullable,
        ...processCreateParams2(params)
      });
    };
    var ZodDefault4 = class extends ZodType4 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        let data = ctx.data;
        if (ctx.parsedType === util_js_1.ZodParsedType.undefined) {
          data = this._def.defaultValue();
        }
        return this._def.innerType._parse({
          data,
          path: ctx.path,
          parent: ctx
        });
      }
      removeDefault() {
        return this._def.innerType;
      }
    };
    exports2.ZodDefault = ZodDefault4;
    ZodDefault4.create = (type, params) => {
      return new ZodDefault4({
        innerType: type,
        typeName: ZodFirstPartyTypeKind4.ZodDefault,
        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
        ...processCreateParams2(params)
      });
    };
    var ZodCatch4 = class extends ZodType4 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const newCtx = {
          ...ctx,
          common: {
            ...ctx.common,
            issues: []
          }
        };
        const result = this._def.innerType._parse({
          data: newCtx.data,
          path: newCtx.path,
          parent: {
            ...newCtx
          }
        });
        if ((0, parseUtil_js_1.isAsync)(result)) {
          return result.then((result2) => {
            return {
              status: "valid",
              value: result2.status === "valid" ? result2.value : this._def.catchValue({
                get error() {
                  return new ZodError_js_1.ZodError(newCtx.common.issues);
                },
                input: newCtx.data
              })
            };
          });
        } else {
          return {
            status: "valid",
            value: result.status === "valid" ? result.value : this._def.catchValue({
              get error() {
                return new ZodError_js_1.ZodError(newCtx.common.issues);
              },
              input: newCtx.data
            })
          };
        }
      }
      removeCatch() {
        return this._def.innerType;
      }
    };
    exports2.ZodCatch = ZodCatch4;
    ZodCatch4.create = (type, params) => {
      return new ZodCatch4({
        innerType: type,
        typeName: ZodFirstPartyTypeKind4.ZodCatch,
        catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
        ...processCreateParams2(params)
      });
    };
    var ZodNaN4 = class extends ZodType4 {
      _parse(input) {
        const parsedType3 = this._getType(input);
        if (parsedType3 !== util_js_1.ZodParsedType.nan) {
          const ctx = this._getOrReturnCtx(input);
          (0, parseUtil_js_1.addIssueToContext)(ctx, {
            code: ZodError_js_1.ZodIssueCode.invalid_type,
            expected: util_js_1.ZodParsedType.nan,
            received: ctx.parsedType
          });
          return parseUtil_js_1.INVALID;
        }
        return { status: "valid", value: input.data };
      }
    };
    exports2.ZodNaN = ZodNaN4;
    ZodNaN4.create = (params) => {
      return new ZodNaN4({
        typeName: ZodFirstPartyTypeKind4.ZodNaN,
        ...processCreateParams2(params)
      });
    };
    exports2.BRAND = /* @__PURE__ */ Symbol("zod_brand");
    var ZodBranded2 = class extends ZodType4 {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const data = ctx.data;
        return this._def.type._parse({
          data,
          path: ctx.path,
          parent: ctx
        });
      }
      unwrap() {
        return this._def.type;
      }
    };
    exports2.ZodBranded = ZodBranded2;
    var ZodPipeline2 = class _ZodPipeline extends ZodType4 {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.common.async) {
          const handleAsync = async () => {
            const inResult = await this._def.in._parseAsync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            });
            if (inResult.status === "aborted")
              return parseUtil_js_1.INVALID;
            if (inResult.status === "dirty") {
              status.dirty();
              return (0, parseUtil_js_1.DIRTY)(inResult.value);
            } else {
              return this._def.out._parseAsync({
                data: inResult.value,
                path: ctx.path,
                parent: ctx
              });
            }
          };
          return handleAsync();
        } else {
          const inResult = this._def.in._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          });
          if (inResult.status === "aborted")
            return parseUtil_js_1.INVALID;
          if (inResult.status === "dirty") {
            status.dirty();
            return {
              status: "dirty",
              value: inResult.value
            };
          } else {
            return this._def.out._parseSync({
              data: inResult.value,
              path: ctx.path,
              parent: ctx
            });
          }
        }
      }
      static create(a, b) {
        return new _ZodPipeline({
          in: a,
          out: b,
          typeName: ZodFirstPartyTypeKind4.ZodPipeline
        });
      }
    };
    exports2.ZodPipeline = ZodPipeline2;
    var ZodReadonly4 = class extends ZodType4 {
      _parse(input) {
        const result = this._def.innerType._parse(input);
        const freeze = (data) => {
          if ((0, parseUtil_js_1.isValid)(data)) {
            data.value = Object.freeze(data.value);
          }
          return data;
        };
        return (0, parseUtil_js_1.isAsync)(result) ? result.then((data) => freeze(data)) : freeze(result);
      }
      unwrap() {
        return this._def.innerType;
      }
    };
    exports2.ZodReadonly = ZodReadonly4;
    ZodReadonly4.create = (type, params) => {
      return new ZodReadonly4({
        innerType: type,
        typeName: ZodFirstPartyTypeKind4.ZodReadonly,
        ...processCreateParams2(params)
      });
    };
    function cleanParams(params, data) {
      const p3 = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
      const p22 = typeof p3 === "string" ? { message: p3 } : p3;
      return p22;
    }
    function custom3(check3, _params = {}, fatal) {
      if (check3)
        return ZodAny4.create().superRefine((data, ctx) => {
          const r = check3(data);
          if (r instanceof Promise) {
            return r.then((r2) => {
              if (!r2) {
                const params = cleanParams(_params, data);
                const _fatal = params.fatal ?? fatal ?? true;
                ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
              }
            });
          }
          if (!r) {
            const params = cleanParams(_params, data);
            const _fatal = params.fatal ?? fatal ?? true;
            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
          }
          return;
        });
      return ZodAny4.create();
    }
    exports2.late = {
      object: ZodObject4.lazycreate
    };
    var ZodFirstPartyTypeKind4;
    (function(ZodFirstPartyTypeKind5) {
      ZodFirstPartyTypeKind5["ZodString"] = "ZodString";
      ZodFirstPartyTypeKind5["ZodNumber"] = "ZodNumber";
      ZodFirstPartyTypeKind5["ZodNaN"] = "ZodNaN";
      ZodFirstPartyTypeKind5["ZodBigInt"] = "ZodBigInt";
      ZodFirstPartyTypeKind5["ZodBoolean"] = "ZodBoolean";
      ZodFirstPartyTypeKind5["ZodDate"] = "ZodDate";
      ZodFirstPartyTypeKind5["ZodSymbol"] = "ZodSymbol";
      ZodFirstPartyTypeKind5["ZodUndefined"] = "ZodUndefined";
      ZodFirstPartyTypeKind5["ZodNull"] = "ZodNull";
      ZodFirstPartyTypeKind5["ZodAny"] = "ZodAny";
      ZodFirstPartyTypeKind5["ZodUnknown"] = "ZodUnknown";
      ZodFirstPartyTypeKind5["ZodNever"] = "ZodNever";
      ZodFirstPartyTypeKind5["ZodVoid"] = "ZodVoid";
      ZodFirstPartyTypeKind5["ZodArray"] = "ZodArray";
      ZodFirstPartyTypeKind5["ZodObject"] = "ZodObject";
      ZodFirstPartyTypeKind5["ZodUnion"] = "ZodUnion";
      ZodFirstPartyTypeKind5["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
      ZodFirstPartyTypeKind5["ZodIntersection"] = "ZodIntersection";
      ZodFirstPartyTypeKind5["ZodTuple"] = "ZodTuple";
      ZodFirstPartyTypeKind5["ZodRecord"] = "ZodRecord";
      ZodFirstPartyTypeKind5["ZodMap"] = "ZodMap";
      ZodFirstPartyTypeKind5["ZodSet"] = "ZodSet";
      ZodFirstPartyTypeKind5["ZodFunction"] = "ZodFunction";
      ZodFirstPartyTypeKind5["ZodLazy"] = "ZodLazy";
      ZodFirstPartyTypeKind5["ZodLiteral"] = "ZodLiteral";
      ZodFirstPartyTypeKind5["ZodEnum"] = "ZodEnum";
      ZodFirstPartyTypeKind5["ZodEffects"] = "ZodEffects";
      ZodFirstPartyTypeKind5["ZodNativeEnum"] = "ZodNativeEnum";
      ZodFirstPartyTypeKind5["ZodOptional"] = "ZodOptional";
      ZodFirstPartyTypeKind5["ZodNullable"] = "ZodNullable";
      ZodFirstPartyTypeKind5["ZodDefault"] = "ZodDefault";
      ZodFirstPartyTypeKind5["ZodCatch"] = "ZodCatch";
      ZodFirstPartyTypeKind5["ZodPromise"] = "ZodPromise";
      ZodFirstPartyTypeKind5["ZodBranded"] = "ZodBranded";
      ZodFirstPartyTypeKind5["ZodPipeline"] = "ZodPipeline";
      ZodFirstPartyTypeKind5["ZodReadonly"] = "ZodReadonly";
    })(ZodFirstPartyTypeKind4 || (exports2.ZodFirstPartyTypeKind = ZodFirstPartyTypeKind4 = {}));
    var instanceOfType = (cls, params = {
      message: `Input not instance of ${cls.name}`
    }) => custom3((data) => data instanceof cls, params);
    exports2.instanceof = instanceOfType;
    var stringType2 = ZodString4.create;
    exports2.string = stringType2;
    var numberType2 = ZodNumber4.create;
    exports2.number = numberType2;
    var nanType2 = ZodNaN4.create;
    exports2.nan = nanType2;
    var bigIntType2 = ZodBigInt4.create;
    exports2.bigint = bigIntType2;
    var booleanType2 = ZodBoolean4.create;
    exports2.boolean = booleanType2;
    var dateType2 = ZodDate4.create;
    exports2.date = dateType2;
    var symbolType2 = ZodSymbol4.create;
    exports2.symbol = symbolType2;
    var undefinedType2 = ZodUndefined4.create;
    exports2.undefined = undefinedType2;
    var nullType2 = ZodNull4.create;
    exports2.null = nullType2;
    var anyType2 = ZodAny4.create;
    exports2.any = anyType2;
    var unknownType2 = ZodUnknown4.create;
    exports2.unknown = unknownType2;
    var neverType2 = ZodNever4.create;
    exports2.never = neverType2;
    var voidType2 = ZodVoid4.create;
    exports2.void = voidType2;
    var arrayType2 = ZodArray4.create;
    exports2.array = arrayType2;
    var objectType2 = ZodObject4.create;
    exports2.object = objectType2;
    var strictObjectType2 = ZodObject4.strictCreate;
    exports2.strictObject = strictObjectType2;
    var unionType2 = ZodUnion4.create;
    exports2.union = unionType2;
    var discriminatedUnionType2 = ZodDiscriminatedUnion4.create;
    exports2.discriminatedUnion = discriminatedUnionType2;
    var intersectionType2 = ZodIntersection4.create;
    exports2.intersection = intersectionType2;
    var tupleType2 = ZodTuple4.create;
    exports2.tuple = tupleType2;
    var recordType2 = ZodRecord4.create;
    exports2.record = recordType2;
    var mapType2 = ZodMap4.create;
    exports2.map = mapType2;
    var setType2 = ZodSet4.create;
    exports2.set = setType2;
    var functionType2 = ZodFunction4.create;
    exports2.function = functionType2;
    var lazyType2 = ZodLazy4.create;
    exports2.lazy = lazyType2;
    var literalType2 = ZodLiteral4.create;
    exports2.literal = literalType2;
    var enumType2 = ZodEnum4.create;
    exports2.enum = enumType2;
    var nativeEnumType2 = ZodNativeEnum2.create;
    exports2.nativeEnum = nativeEnumType2;
    var promiseType2 = ZodPromise4.create;
    exports2.promise = promiseType2;
    var effectsType2 = ZodEffects2.create;
    exports2.effect = effectsType2;
    exports2.transformer = effectsType2;
    var optionalType2 = ZodOptional4.create;
    exports2.optional = optionalType2;
    var nullableType2 = ZodNullable4.create;
    exports2.nullable = nullableType2;
    var preprocessType2 = ZodEffects2.createWithPreprocess;
    exports2.preprocess = preprocessType2;
    var pipelineType2 = ZodPipeline2.create;
    exports2.pipeline = pipelineType2;
    var ostring = () => stringType2().optional();
    exports2.ostring = ostring;
    var onumber = () => numberType2().optional();
    exports2.onumber = onumber;
    var oboolean = () => booleanType2().optional();
    exports2.oboolean = oboolean;
    exports2.coerce = {
      string: ((arg) => ZodString4.create({ ...arg, coerce: true })),
      number: ((arg) => ZodNumber4.create({ ...arg, coerce: true })),
      boolean: ((arg) => ZodBoolean4.create({
        ...arg,
        coerce: true
      })),
      bigint: ((arg) => ZodBigInt4.create({ ...arg, coerce: true })),
      date: ((arg) => ZodDate4.create({ ...arg, coerce: true }))
    };
    exports2.NEVER = parseUtil_js_1.INVALID;
  }
});

// node_modules/zod/v3/external.cjs
var require_external2 = __commonJS({
  "node_modules/zod/v3/external.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p3 in m) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m, p3);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_errors3(), exports2);
    __exportStar(require_parseUtil(), exports2);
    __exportStar(require_typeAliases(), exports2);
    __exportStar(require_util5(), exports2);
    __exportStar(require_types4(), exports2);
    __exportStar(require_ZodError(), exports2);
  }
});

// node_modules/zod/v3/index.cjs
var require_v3 = __commonJS({
  "node_modules/zod/v3/index.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p3 in m) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m, p3);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.z = void 0;
    var z3 = __importStar(require_external2());
    exports2.z = z3;
    __exportStar(require_external2(), exports2);
    exports2.default = z3;
  }
});

// node_modules/eventsource-parser/dist/index.cjs
var require_dist7 = __commonJS({
  "node_modules/eventsource-parser/dist/index.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var ParseError2 = class extends Error {
      constructor(message, options) {
        super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
      }
    };
    function noop4(_arg) {
    }
    function createParser2(callbacks) {
      if (typeof callbacks == "function")
        throw new TypeError(
          "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
        );
      const { onEvent = noop4, onError = noop4, onRetry = noop4, onComment } = callbacks;
      let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
      function feed(newChunk) {
        const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines2(`${incompleteLine}${chunk}`);
        for (const line of complete)
          parseLine(line);
        incompleteLine = incomplete, isFirstChunk = false;
      }
      function parseLine(line) {
        if (line === "") {
          dispatchEvent();
          return;
        }
        if (line.startsWith(":")) {
          onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
          return;
        }
        const fieldSeparatorIndex = line.indexOf(":");
        if (fieldSeparatorIndex !== -1) {
          const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
          processField(field, value, line);
          return;
        }
        processField(line, "", line);
      }
      function processField(field, value, line) {
        switch (field) {
          case "event":
            eventType = value;
            break;
          case "data":
            data = `${data}${value}
`;
            break;
          case "id":
            id = value.includes("\0") ? void 0 : value;
            break;
          case "retry":
            /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
              new ParseError2(`Invalid \`retry\` value: "${value}"`, {
                type: "invalid-retry",
                value,
                line
              })
            );
            break;
          default:
            onError(
              new ParseError2(
                `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
                { type: "unknown-field", field, value, line }
              )
            );
            break;
        }
      }
      function dispatchEvent() {
        data.length > 0 && onEvent({
          id,
          event: eventType || void 0,
          // If the data buffer's last character is a U+000A LINE FEED (LF) character,
          // then remove the last character from the data buffer.
          data: data.endsWith(`
`) ? data.slice(0, -1) : data
        }), id = void 0, data = "", eventType = "";
      }
      function reset(options = {}) {
        incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
      }
      return { feed, reset };
    }
    function splitLines2(chunk) {
      const lines = [];
      let incompleteLine = "", searchIndex = 0;
      for (; searchIndex < chunk.length; ) {
        const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
`, searchIndex);
        let lineEnd = -1;
        if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
          incompleteLine = chunk.slice(searchIndex);
          break;
        } else {
          const line = chunk.slice(searchIndex, lineEnd);
          lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
` && searchIndex++;
        }
      }
      return [lines, incompleteLine];
    }
    exports2.ParseError = ParseError2;
    exports2.createParser = createParser2;
  }
});

// node_modules/eventsource-parser/dist/stream.cjs
var require_stream7 = __commonJS({
  "node_modules/eventsource-parser/dist/stream.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var index = require_dist7();
    var EventSourceParserStream3 = class extends TransformStream {
      constructor({ onError, onRetry, onComment } = {}) {
        let parser;
        super({
          start(controller) {
            parser = index.createParser({
              onEvent: (event) => {
                controller.enqueue(event);
              },
              onError(error73) {
                onError === "terminate" ? controller.error(error73) : typeof onError == "function" && onError(error73);
              },
              onRetry,
              onComment
            });
          },
          transform(chunk) {
            parser.feed(chunk);
          }
        });
      }
    };
    exports2.ParseError = index.ParseError;
    exports2.EventSourceParserStream = EventSourceParserStream3;
  }
});

// node_modules/@ai-sdk/provider-utils/dist/index.js
var require_dist8 = __commonJS({
  "node_modules/@ai-sdk/provider-utils/dist/index.js"(exports2, module2) {
    "use strict";
    var __create2 = Object.create;
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name29 in all3)
        __defProp4(target, name29, { get: all3[name29], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
      // If the importer is in node compatibility mode or this is not an ESM
      // file that has been converted to a CommonJS file using a Babel-
      // compatible transform (i.e. "__esModule" has not been set), then set
      // "default" to the CommonJS "module.exports" for node compatibility.
      isNodeMode || !mod || !mod.__esModule ? __defProp4(target, "default", { value: mod, enumerable: true }) : target,
      mod
    ));
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var index_exports = {};
    __export4(index_exports, {
      DEFAULT_MAX_DOWNLOAD_SIZE: () => DEFAULT_MAX_DOWNLOAD_SIZE3,
      DelayedPromise: () => DelayedPromise2,
      DownloadError: () => DownloadError5,
      EventSourceParserStream: () => import_stream22.EventSourceParserStream,
      VERSION: () => VERSION16,
      asSchema: () => asSchema4,
      combineHeaders: () => combineHeaders5,
      convertAsyncIteratorToReadableStream: () => convertAsyncIteratorToReadableStream,
      convertBase64ToUint8Array: () => convertBase64ToUint8Array2,
      convertImageModelFileToDataUri: () => convertImageModelFileToDataUri2,
      convertToBase64: () => convertToBase644,
      convertToFormData: () => convertToFormData2,
      convertUint8ArrayToBase64: () => convertUint8ArrayToBase645,
      createBinaryResponseHandler: () => createBinaryResponseHandler2,
      createEventSourceResponseHandler: () => createEventSourceResponseHandler5,
      createIdGenerator: () => createIdGenerator5,
      createJsonErrorResponseHandler: () => createJsonErrorResponseHandler5,
      createJsonResponseHandler: () => createJsonResponseHandler5,
      createProviderToolFactory: () => createProviderToolFactory3,
      createProviderToolFactoryWithOutputSchema: () => createProviderToolFactoryWithOutputSchema3,
      createStatusCodeErrorResponseHandler: () => createStatusCodeErrorResponseHandler2,
      createToolNameMapping: () => createToolNameMapping3,
      delay: () => delay2,
      downloadBlob: () => downloadBlob2,
      dynamicTool: () => dynamicTool2,
      executeTool: () => executeTool2,
      extractResponseHeaders: () => extractResponseHeaders5,
      generateId: () => generateId6,
      getErrorMessage: () => getErrorMessage6,
      getFromApi: () => getFromApi2,
      getRuntimeEnvironmentUserAgent: () => getRuntimeEnvironmentUserAgent5,
      injectJsonInstructionIntoMessages: () => injectJsonInstructionIntoMessages,
      isAbortError: () => isAbortError5,
      isNonNullable: () => isNonNullable3,
      isParsableJson: () => isParsableJson4,
      isUrlSupported: () => isUrlSupported2,
      jsonSchema: () => jsonSchema4,
      lazySchema: () => lazySchema3,
      loadApiKey: () => loadApiKey4,
      loadOptionalSetting: () => loadOptionalSetting2,
      loadSetting: () => loadSetting,
      mediaTypeToExtension: () => mediaTypeToExtension2,
      normalizeHeaders: () => normalizeHeaders5,
      parseJSON: () => parseJSON5,
      parseJsonEventStream: () => parseJsonEventStream5,
      parseProviderOptions: () => parseProviderOptions4,
      postFormDataToApi: () => postFormDataToApi2,
      postJsonToApi: () => postJsonToApi5,
      postToApi: () => postToApi5,
      readResponseWithSizeLimit: () => readResponseWithSizeLimit2,
      removeUndefinedEntries: () => removeUndefinedEntries,
      resolve: () => resolve3,
      safeParseJSON: () => safeParseJSON5,
      safeValidateTypes: () => safeValidateTypes5,
      stripFileExtension: () => stripFileExtension,
      tool: () => tool3,
      validateDownloadUrl: () => validateDownloadUrl2,
      validateTypes: () => validateTypes5,
      withUserAgentSuffix: () => withUserAgentSuffix5,
      withoutTrailingSlash: () => withoutTrailingSlash4,
      zodSchema: () => zodSchema4
    });
    module2.exports = __toCommonJS2(index_exports);
    function combineHeaders5(...headers) {
      return headers.reduce(
        (combinedHeaders, currentHeaders) => ({
          ...combinedHeaders,
          ...currentHeaders != null ? currentHeaders : {}
        }),
        {}
      );
    }
    function convertAsyncIteratorToReadableStream(iterator2) {
      let cancelled = false;
      return new ReadableStream({
        /**
         * Called when the consumer wants to pull more data from the stream.
         *
         * @param {ReadableStreamDefaultController<T>} controller - The controller to enqueue data into the stream.
         * @returns {Promise<void>}
         */
        async pull(controller) {
          if (cancelled) return;
          try {
            const { value, done } = await iterator2.next();
            if (done) {
              controller.close();
            } else {
              controller.enqueue(value);
            }
          } catch (error73) {
            controller.error(error73);
          }
        },
        /**
         * Called when the consumer cancels the stream.
         */
        async cancel(reason) {
          cancelled = true;
          if (iterator2.return) {
            try {
              await iterator2.return(reason);
            } catch (e) {
            }
          }
        }
      });
    }
    function createToolNameMapping3({
      tools = [],
      providerToolNames,
      resolveProviderToolName
    }) {
      var _a211;
      const customToolNameToProviderToolName = {};
      const providerToolNameToCustomToolName = {};
      for (const tool22 of tools) {
        if (tool22.type === "provider") {
          const providerToolName = (_a211 = resolveProviderToolName == null ? void 0 : resolveProviderToolName(tool22)) != null ? _a211 : tool22.id in providerToolNames ? providerToolNames[tool22.id] : void 0;
          if (providerToolName == null) {
            continue;
          }
          customToolNameToProviderToolName[tool22.name] = providerToolName;
          providerToolNameToCustomToolName[providerToolName] = tool22.name;
        }
      }
      return {
        toProviderToolName: (customToolName) => {
          var _a37;
          return (_a37 = customToolNameToProviderToolName[customToolName]) != null ? _a37 : customToolName;
        },
        toCustomToolName: (providerToolName) => {
          var _a37;
          return (_a37 = providerToolNameToCustomToolName[providerToolName]) != null ? _a37 : providerToolName;
        }
      };
    }
    async function delay2(delayInMs, options) {
      if (delayInMs == null) {
        return Promise.resolve();
      }
      const signal = options == null ? void 0 : options.abortSignal;
      return new Promise((resolve22, reject) => {
        if (signal == null ? void 0 : signal.aborted) {
          reject(createAbortError2());
          return;
        }
        const timeoutId = setTimeout(() => {
          cleanup();
          resolve22();
        }, delayInMs);
        const cleanup = () => {
          clearTimeout(timeoutId);
          signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
        };
        const onAbort = () => {
          cleanup();
          reject(createAbortError2());
        };
        signal == null ? void 0 : signal.addEventListener("abort", onAbort);
      });
    }
    function createAbortError2() {
      return new DOMException("Delay was aborted", "AbortError");
    }
    var DelayedPromise2 = class {
      constructor() {
        this.status = { type: "pending" };
        this._resolve = void 0;
        this._reject = void 0;
      }
      get promise() {
        if (this._promise) {
          return this._promise;
        }
        this._promise = new Promise((resolve22, reject) => {
          if (this.status.type === "resolved") {
            resolve22(this.status.value);
          } else if (this.status.type === "rejected") {
            reject(this.status.error);
          }
          this._resolve = resolve22;
          this._reject = reject;
        });
        return this._promise;
      }
      resolve(value) {
        var _a211;
        this.status = { type: "resolved", value };
        if (this._promise) {
          (_a211 = this._resolve) == null ? void 0 : _a211.call(this, value);
        }
      }
      reject(error73) {
        var _a211;
        this.status = { type: "rejected", error: error73 };
        if (this._promise) {
          (_a211 = this._reject) == null ? void 0 : _a211.call(this, error73);
        }
      }
      isResolved() {
        return this.status.type === "resolved";
      }
      isRejected() {
        return this.status.type === "rejected";
      }
      isPending() {
        return this.status.type === "pending";
      }
    };
    function extractResponseHeaders5(response) {
      return Object.fromEntries([...response.headers]);
    }
    var { btoa: btoa6, atob: atob6 } = globalThis;
    function convertBase64ToUint8Array2(base64String) {
      const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
      const latin1string = atob6(base64Url);
      return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
    }
    function convertUint8ArrayToBase645(array4) {
      let latin1string = "";
      for (let i = 0; i < array4.length; i++) {
        latin1string += String.fromCodePoint(array4[i]);
      }
      return btoa6(latin1string);
    }
    function convertToBase644(value) {
      return value instanceof Uint8Array ? convertUint8ArrayToBase645(value) : value;
    }
    function convertImageModelFileToDataUri2(file3) {
      if (file3.type === "url") return file3.url;
      return `data:${file3.mediaType};base64,${typeof file3.data === "string" ? file3.data : convertUint8ArrayToBase645(file3.data)}`;
    }
    function convertToFormData2(input, options = {}) {
      const { useArrayBrackets = true } = options;
      const formData = new FormData();
      for (const [key, value] of Object.entries(input)) {
        if (value == null) {
          continue;
        }
        if (Array.isArray(value)) {
          if (value.length === 1) {
            formData.append(key, value[0]);
            continue;
          }
          const arrayKey = useArrayBrackets ? `${key}[]` : key;
          for (const item of value) {
            formData.append(arrayKey, item);
          }
          continue;
        }
        formData.append(key, value);
      }
      return formData;
    }
    var import_provider103 = require_dist6();
    var name28 = "AI_DownloadError";
    var marker29 = `vercel.ai.error.${name28}`;
    var symbol30 = Symbol.for(marker29);
    var _a31;
    var _b27;
    var DownloadError5 = class extends (_b27 = import_provider103.AISDKError, _a31 = symbol30, _b27) {
      constructor({
        url: url4,
        statusCode,
        statusText,
        cause,
        message = cause == null ? `Failed to download ${url4}: ${statusCode} ${statusText}` : `Failed to download ${url4}: ${cause}`
      }) {
        super({ name: name28, message, cause });
        this[_a31] = true;
        this.url = url4;
        this.statusCode = statusCode;
        this.statusText = statusText;
      }
      static isInstance(error73) {
        return import_provider103.AISDKError.hasMarker(error73, marker29);
      }
    };
    var DEFAULT_MAX_DOWNLOAD_SIZE3 = 2 * 1024 * 1024 * 1024;
    async function readResponseWithSizeLimit2({
      response,
      url: url4,
      maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE3
    }) {
      const contentLength = response.headers.get("content-length");
      if (contentLength != null) {
        const length = parseInt(contentLength, 10);
        if (!isNaN(length) && length > maxBytes) {
          throw new DownloadError5({
            url: url4,
            message: `Download of ${url4} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
          });
        }
      }
      const body = response.body;
      if (body == null) {
        return new Uint8Array(0);
      }
      const reader = body.getReader();
      const chunks = [];
      let totalBytes = 0;
      try {
        while (true) {
          const { done, value } = await reader.read();
          if (done) {
            break;
          }
          totalBytes += value.length;
          if (totalBytes > maxBytes) {
            throw new DownloadError5({
              url: url4,
              message: `Download of ${url4} exceeded maximum size of ${maxBytes} bytes.`
            });
          }
          chunks.push(value);
        }
      } finally {
        try {
          await reader.cancel();
        } finally {
          reader.releaseLock();
        }
      }
      const result = new Uint8Array(totalBytes);
      let offset = 0;
      for (const chunk of chunks) {
        result.set(chunk, offset);
        offset += chunk.length;
      }
      return result;
    }
    function validateDownloadUrl2(url4) {
      let parsed;
      try {
        parsed = new URL(url4);
      } catch (e) {
        throw new DownloadError5({
          url: url4,
          message: `Invalid URL: ${url4}`
        });
      }
      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
        throw new DownloadError5({
          url: url4,
          message: `URL scheme must be http or https, got ${parsed.protocol}`
        });
      }
      const hostname4 = parsed.hostname;
      if (!hostname4) {
        throw new DownloadError5({
          url: url4,
          message: `URL must have a hostname`
        });
      }
      if (hostname4 === "localhost" || hostname4.endsWith(".local") || hostname4.endsWith(".localhost")) {
        throw new DownloadError5({
          url: url4,
          message: `URL with hostname ${hostname4} is not allowed`
        });
      }
      if (hostname4.startsWith("[") && hostname4.endsWith("]")) {
        const ipv64 = hostname4.slice(1, -1);
        if (isPrivateIPv62(ipv64)) {
          throw new DownloadError5({
            url: url4,
            message: `URL with IPv6 address ${hostname4} is not allowed`
          });
        }
        return;
      }
      if (isIPv42(hostname4)) {
        if (isPrivateIPv42(hostname4)) {
          throw new DownloadError5({
            url: url4,
            message: `URL with IP address ${hostname4} is not allowed`
          });
        }
        return;
      }
    }
    function isIPv42(hostname4) {
      const parts = hostname4.split(".");
      if (parts.length !== 4) return false;
      return parts.every((part) => {
        const num = Number(part);
        return Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part;
      });
    }
    function isPrivateIPv42(ip) {
      const parts = ip.split(".").map(Number);
      const [a, b] = parts;
      if (a === 0) return true;
      if (a === 10) return true;
      if (a === 127) return true;
      if (a === 169 && b === 254) return true;
      if (a === 172 && b >= 16 && b <= 31) return true;
      if (a === 192 && b === 168) return true;
      return false;
    }
    function isPrivateIPv62(ip) {
      const normalized = ip.toLowerCase();
      if (normalized === "::1") return true;
      if (normalized === "::") return true;
      if (normalized.startsWith("::ffff:")) {
        const mappedPart = normalized.slice(7);
        if (isIPv42(mappedPart)) {
          return isPrivateIPv42(mappedPart);
        }
        const hexParts = mappedPart.split(":");
        if (hexParts.length === 2) {
          const high = parseInt(hexParts[0], 16);
          const low = parseInt(hexParts[1], 16);
          if (!isNaN(high) && !isNaN(low)) {
            const a = high >> 8 & 255;
            const b = high & 255;
            const c = low >> 8 & 255;
            const d = low & 255;
            return isPrivateIPv42(`${a}.${b}.${c}.${d}`);
          }
        }
      }
      if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
      if (normalized.startsWith("fe80")) return true;
      return false;
    }
    async function downloadBlob2(url4, options) {
      var _a211, _b28;
      validateDownloadUrl2(url4);
      try {
        const response = await fetch(url4, {
          signal: options == null ? void 0 : options.abortSignal
        });
        if (response.redirected) {
          validateDownloadUrl2(response.url);
        }
        if (!response.ok) {
          throw new DownloadError5({
            url: url4,
            statusCode: response.status,
            statusText: response.statusText
          });
        }
        const data = await readResponseWithSizeLimit2({
          response,
          url: url4,
          maxBytes: (_a211 = options == null ? void 0 : options.maxBytes) != null ? _a211 : DEFAULT_MAX_DOWNLOAD_SIZE3
        });
        const contentType = (_b28 = response.headers.get("content-type")) != null ? _b28 : void 0;
        return new Blob([data], contentType ? { type: contentType } : void 0);
      } catch (error73) {
        if (DownloadError5.isInstance(error73)) {
          throw error73;
        }
        throw new DownloadError5({ url: url4, cause: error73 });
      }
    }
    var import_provider210 = require_dist6();
    var createIdGenerator5 = ({
      prefix,
      size = 16,
      alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
      separator = "-"
    } = {}) => {
      const generator = () => {
        const alphabetLength = alphabet.length;
        const chars = new Array(size);
        for (let i = 0; i < size; i++) {
          chars[i] = alphabet[Math.random() * alphabetLength | 0];
        }
        return chars.join("");
      };
      if (prefix == null) {
        return generator;
      }
      if (alphabet.includes(separator)) {
        throw new import_provider210.InvalidArgumentError({
          argument: "separator",
          message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
        });
      }
      return () => `${prefix}${separator}${generator()}`;
    };
    var generateId6 = createIdGenerator5();
    function getErrorMessage6(error73) {
      if (error73 == null) {
        return "unknown error";
      }
      if (typeof error73 === "string") {
        return error73;
      }
      if (error73 instanceof Error) {
        return error73.message;
      }
      return JSON.stringify(error73);
    }
    var import_provider410 = require_dist6();
    var import_provider310 = require_dist6();
    function isAbortError5(error73) {
      return (error73 instanceof Error || error73 instanceof DOMException) && (error73.name === "AbortError" || error73.name === "ResponseAborted" || // Next.js
      error73.name === "TimeoutError");
    }
    var FETCH_FAILED_ERROR_MESSAGES5 = ["fetch failed", "failed to fetch"];
    var BUN_ERROR_CODES2 = [
      "ConnectionRefused",
      "ConnectionClosed",
      "FailedToOpenSocket",
      "ECONNRESET",
      "ECONNREFUSED",
      "ETIMEDOUT",
      "EPIPE"
    ];
    function isBunNetworkError2(error73) {
      if (!(error73 instanceof Error)) {
        return false;
      }
      const code = error73.code;
      if (typeof code === "string" && BUN_ERROR_CODES2.includes(code)) {
        return true;
      }
      return false;
    }
    function handleFetchError5({
      error: error73,
      url: url4,
      requestBodyValues
    }) {
      if (isAbortError5(error73)) {
        return error73;
      }
      if (error73 instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES5.includes(error73.message.toLowerCase())) {
        const cause = error73.cause;
        if (cause != null) {
          return new import_provider310.APICallError({
            message: `Cannot connect to API: ${cause.message}`,
            cause,
            url: url4,
            requestBodyValues,
            isRetryable: true
            // retry when network error
          });
        }
      }
      if (isBunNetworkError2(error73)) {
        return new import_provider310.APICallError({
          message: `Cannot connect to API: ${error73.message}`,
          cause: error73,
          url: url4,
          requestBodyValues,
          isRetryable: true
        });
      }
      return error73;
    }
    function getRuntimeEnvironmentUserAgent5(globalThisAny = globalThis) {
      var _a211, _b28, _c;
      if (globalThisAny.window) {
        return `runtime/browser`;
      }
      if ((_a211 = globalThisAny.navigator) == null ? void 0 : _a211.userAgent) {
        return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
      }
      if ((_c = (_b28 = globalThisAny.process) == null ? void 0 : _b28.versions) == null ? void 0 : _c.node) {
        return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
      }
      if (globalThisAny.EdgeRuntime) {
        return `runtime/vercel-edge`;
      }
      return "runtime/unknown";
    }
    function normalizeHeaders5(headers) {
      if (headers == null) {
        return {};
      }
      const normalized = {};
      if (headers instanceof Headers) {
        headers.forEach((value, key) => {
          normalized[key.toLowerCase()] = value;
        });
      } else {
        if (!Array.isArray(headers)) {
          headers = Object.entries(headers);
        }
        for (const [key, value] of headers) {
          if (value != null) {
            normalized[key.toLowerCase()] = value;
          }
        }
      }
      return normalized;
    }
    function withUserAgentSuffix5(headers, ...userAgentSuffixParts) {
      const normalizedHeaders = new Headers(normalizeHeaders5(headers));
      const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
      normalizedHeaders.set(
        "user-agent",
        [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
      );
      return Object.fromEntries(normalizedHeaders.entries());
    }
    var VERSION16 = true ? "4.0.21" : "0.0.0-test";
    var getOriginalFetch3 = () => globalThis.fetch;
    var getFromApi2 = async ({
      url: url4,
      headers = {},
      successfulResponseHandler,
      failedResponseHandler,
      abortSignal,
      fetch: fetch2 = getOriginalFetch3()
    }) => {
      try {
        const response = await fetch2(url4, {
          method: "GET",
          headers: withUserAgentSuffix5(
            headers,
            `ai-sdk/provider-utils/${VERSION16}`,
            getRuntimeEnvironmentUserAgent5()
          ),
          signal: abortSignal
        });
        const responseHeaders = extractResponseHeaders5(response);
        if (!response.ok) {
          let errorInformation;
          try {
            errorInformation = await failedResponseHandler({
              response,
              url: url4,
              requestBodyValues: {}
            });
          } catch (error73) {
            if (isAbortError5(error73) || import_provider410.APICallError.isInstance(error73)) {
              throw error73;
            }
            throw new import_provider410.APICallError({
              message: "Failed to process error response",
              cause: error73,
              statusCode: response.status,
              url: url4,
              responseHeaders,
              requestBodyValues: {}
            });
          }
          throw errorInformation.value;
        }
        try {
          return await successfulResponseHandler({
            response,
            url: url4,
            requestBodyValues: {}
          });
        } catch (error73) {
          if (error73 instanceof Error) {
            if (isAbortError5(error73) || import_provider410.APICallError.isInstance(error73)) {
              throw error73;
            }
          }
          throw new import_provider410.APICallError({
            message: "Failed to process successful response",
            cause: error73,
            statusCode: response.status,
            url: url4,
            responseHeaders,
            requestBodyValues: {}
          });
        }
      } catch (error73) {
        throw handleFetchError5({ error: error73, url: url4, requestBodyValues: {} });
      }
    };
    var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
    var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
    var DEFAULT_GENERIC_SUFFIX = "You MUST answer with JSON.";
    function injectJsonInstruction({
      prompt,
      schema,
      schemaPrefix = schema != null ? DEFAULT_SCHEMA_PREFIX : void 0,
      schemaSuffix = schema != null ? DEFAULT_SCHEMA_SUFFIX : DEFAULT_GENERIC_SUFFIX
    }) {
      return [
        prompt != null && prompt.length > 0 ? prompt : void 0,
        prompt != null && prompt.length > 0 ? "" : void 0,
        // add a newline if prompt is not null
        schemaPrefix,
        schema != null ? JSON.stringify(schema) : void 0,
        schemaSuffix
      ].filter((line) => line != null).join("\n");
    }
    function injectJsonInstructionIntoMessages({
      messages,
      schema,
      schemaPrefix,
      schemaSuffix
    }) {
      var _a211, _b28;
      const systemMessage = ((_a211 = messages[0]) == null ? void 0 : _a211.role) === "system" ? { ...messages[0] } : { role: "system", content: "" };
      systemMessage.content = injectJsonInstruction({
        prompt: systemMessage.content,
        schema,
        schemaPrefix,
        schemaSuffix
      });
      return [
        systemMessage,
        ...((_b28 = messages[0]) == null ? void 0 : _b28.role) === "system" ? messages.slice(1) : messages
      ];
    }
    function isNonNullable3(value) {
      return value != null;
    }
    function isUrlSupported2({
      mediaType,
      url: url4,
      supportedUrls
    }) {
      url4 = url4.toLowerCase();
      mediaType = mediaType.toLowerCase();
      return Object.entries(supportedUrls).map(([key, value]) => {
        const mediaType2 = key.toLowerCase();
        return mediaType2 === "*" || mediaType2 === "*/*" ? { mediaTypePrefix: "", regexes: value } : { mediaTypePrefix: mediaType2.replace(/\*/, ""), regexes: value };
      }).filter(({ mediaTypePrefix }) => mediaType.startsWith(mediaTypePrefix)).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url4));
    }
    var import_provider510 = require_dist6();
    function loadApiKey4({
      apiKey,
      environmentVariableName,
      apiKeyParameterName = "apiKey",
      description
    }) {
      if (typeof apiKey === "string") {
        return apiKey;
      }
      if (apiKey != null) {
        throw new import_provider510.LoadAPIKeyError({
          message: `${description} API key must be a string.`
        });
      }
      if (typeof process === "undefined") {
        throw new import_provider510.LoadAPIKeyError({
          message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
        });
      }
      apiKey = process.env[environmentVariableName];
      if (apiKey == null) {
        throw new import_provider510.LoadAPIKeyError({
          message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
        });
      }
      if (typeof apiKey !== "string") {
        throw new import_provider510.LoadAPIKeyError({
          message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
        });
      }
      return apiKey;
    }
    function loadOptionalSetting2({
      settingValue,
      environmentVariableName
    }) {
      if (typeof settingValue === "string") {
        return settingValue;
      }
      if (settingValue != null || typeof process === "undefined") {
        return void 0;
      }
      settingValue = process.env[environmentVariableName];
      if (settingValue == null || typeof settingValue !== "string") {
        return void 0;
      }
      return settingValue;
    }
    var import_provider610 = require_dist6();
    function loadSetting({
      settingValue,
      environmentVariableName,
      settingName,
      description
    }) {
      if (typeof settingValue === "string") {
        return settingValue;
      }
      if (settingValue != null) {
        throw new import_provider610.LoadSettingError({
          message: `${description} setting must be a string.`
        });
      }
      if (typeof process === "undefined") {
        throw new import_provider610.LoadSettingError({
          message: `${description} setting is missing. Pass it using the '${settingName}' parameter. Environment variables is not supported in this environment.`
        });
      }
      settingValue = process.env[environmentVariableName];
      if (settingValue == null) {
        throw new import_provider610.LoadSettingError({
          message: `${description} setting is missing. Pass it using the '${settingName}' parameter or the ${environmentVariableName} environment variable.`
        });
      }
      if (typeof settingValue !== "string") {
        throw new import_provider610.LoadSettingError({
          message: `${description} setting must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
        });
      }
      return settingValue;
    }
    function mediaTypeToExtension2(mediaType) {
      var _a211;
      const [_type, subtype = ""] = mediaType.toLowerCase().split("/");
      return (_a211 = {
        mpeg: "mp3",
        "x-wav": "wav",
        opus: "ogg",
        mp4: "m4a",
        "x-m4a": "m4a"
      }[subtype]) != null ? _a211 : subtype;
    }
    var import_provider910 = require_dist6();
    var suspectProtoRx5 = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
    var suspectConstructorRx5 = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
    function _parse7(text2) {
      const obj = JSON.parse(text2);
      if (obj === null || typeof obj !== "object") {
        return obj;
      }
      if (suspectProtoRx5.test(text2) === false && suspectConstructorRx5.test(text2) === false) {
        return obj;
      }
      return filter6(obj);
    }
    function filter6(obj) {
      let next = [obj];
      while (next.length) {
        const nodes = next;
        next = [];
        for (const node of nodes) {
          if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
            throw new SyntaxError("Object contains forbidden prototype property");
          }
          if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
            throw new SyntaxError("Object contains forbidden prototype property");
          }
          for (const key in node) {
            const value = node[key];
            if (value && typeof value === "object") {
              next.push(value);
            }
          }
        }
      }
      return obj;
    }
    function secureJsonParse5(text2) {
      const { stackTraceLimit } = Error;
      try {
        Error.stackTraceLimit = 0;
      } catch (e) {
        return _parse7(text2);
      }
      try {
        return _parse7(text2);
      } finally {
        Error.stackTraceLimit = stackTraceLimit;
      }
    }
    var import_provider810 = require_dist6();
    var import_provider710 = require_dist6();
    var z4 = __toESM2(require_v4());
    function addAdditionalPropertiesToJsonSchema4(jsonSchema22) {
      if (jsonSchema22.type === "object" || Array.isArray(jsonSchema22.type) && jsonSchema22.type.includes("object")) {
        jsonSchema22.additionalProperties = false;
        const { properties } = jsonSchema22;
        if (properties != null) {
          for (const key of Object.keys(properties)) {
            properties[key] = visit4(properties[key]);
          }
        }
      }
      if (jsonSchema22.items != null) {
        jsonSchema22.items = Array.isArray(jsonSchema22.items) ? jsonSchema22.items.map(visit4) : visit4(jsonSchema22.items);
      }
      if (jsonSchema22.anyOf != null) {
        jsonSchema22.anyOf = jsonSchema22.anyOf.map(visit4);
      }
      if (jsonSchema22.allOf != null) {
        jsonSchema22.allOf = jsonSchema22.allOf.map(visit4);
      }
      if (jsonSchema22.oneOf != null) {
        jsonSchema22.oneOf = jsonSchema22.oneOf.map(visit4);
      }
      const { definitions } = jsonSchema22;
      if (definitions != null) {
        for (const key of Object.keys(definitions)) {
          definitions[key] = visit4(definitions[key]);
        }
      }
      return jsonSchema22;
    }
    function visit4(def) {
      if (typeof def === "boolean") return def;
      return addAdditionalPropertiesToJsonSchema4(def);
    }
    var ignoreOverride4 = /* @__PURE__ */ Symbol(
      "Let zodToJsonSchema decide on which parser to use"
    );
    var defaultOptions4 = {
      name: void 0,
      $refStrategy: "root",
      basePath: ["#"],
      effectStrategy: "input",
      pipeStrategy: "all",
      dateStrategy: "format:date-time",
      mapStrategy: "entries",
      removeAdditionalStrategy: "passthrough",
      allowedAdditionalProperties: true,
      rejectedAdditionalProperties: false,
      definitionPath: "definitions",
      strictUnions: false,
      definitions: {},
      errorMessages: false,
      patternStrategy: "escape",
      applyRegexFlags: false,
      emailStrategy: "format:email",
      base64Strategy: "contentEncoding:base64",
      nameStrategy: "ref"
    };
    var getDefaultOptions4 = (options) => typeof options === "string" ? {
      ...defaultOptions4,
      name: options
    } : {
      ...defaultOptions4,
      ...options
    };
    var import_v332 = require_v3();
    function parseAnyDef4() {
      return {};
    }
    var import_v313 = require_v3();
    function parseArrayDef4(def, refs) {
      var _a211, _b28, _c;
      const res = {
        type: "array"
      };
      if (((_a211 = def.type) == null ? void 0 : _a211._def) && ((_c = (_b28 = def.type) == null ? void 0 : _b28._def) == null ? void 0 : _c.typeName) !== import_v313.ZodFirstPartyTypeKind.ZodAny) {
        res.items = parseDef4(def.type._def, {
          ...refs,
          currentPath: [...refs.currentPath, "items"]
        });
      }
      if (def.minLength) {
        res.minItems = def.minLength.value;
      }
      if (def.maxLength) {
        res.maxItems = def.maxLength.value;
      }
      if (def.exactLength) {
        res.minItems = def.exactLength.value;
        res.maxItems = def.exactLength.value;
      }
      return res;
    }
    function parseBigintDef4(def) {
      const res = {
        type: "integer",
        format: "int64"
      };
      if (!def.checks) return res;
      for (const check3 of def.checks) {
        switch (check3.kind) {
          case "min":
            if (check3.inclusive) {
              res.minimum = check3.value;
            } else {
              res.exclusiveMinimum = check3.value;
            }
            break;
          case "max":
            if (check3.inclusive) {
              res.maximum = check3.value;
            } else {
              res.exclusiveMaximum = check3.value;
            }
            break;
          case "multipleOf":
            res.multipleOf = check3.value;
            break;
        }
      }
      return res;
    }
    function parseBooleanDef4() {
      return { type: "boolean" };
    }
    function parseBrandedDef4(_def, refs) {
      return parseDef4(_def.type._def, refs);
    }
    var parseCatchDef4 = (def, refs) => {
      return parseDef4(def.innerType._def, refs);
    };
    function parseDateDef4(def, refs, overrideDateStrategy) {
      const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
      if (Array.isArray(strategy)) {
        return {
          anyOf: strategy.map((item, i) => parseDateDef4(def, refs, item))
        };
      }
      switch (strategy) {
        case "string":
        case "format:date-time":
          return {
            type: "string",
            format: "date-time"
          };
        case "format:date":
          return {
            type: "string",
            format: "date"
          };
        case "integer":
          return integerDateParser4(def);
      }
    }
    var integerDateParser4 = (def) => {
      const res = {
        type: "integer",
        format: "unix-time"
      };
      for (const check3 of def.checks) {
        switch (check3.kind) {
          case "min":
            res.minimum = check3.value;
            break;
          case "max":
            res.maximum = check3.value;
            break;
        }
      }
      return res;
    };
    function parseDefaultDef4(_def, refs) {
      return {
        ...parseDef4(_def.innerType._def, refs),
        default: _def.defaultValue()
      };
    }
    function parseEffectsDef4(_def, refs) {
      return refs.effectStrategy === "input" ? parseDef4(_def.schema._def, refs) : parseAnyDef4();
    }
    function parseEnumDef4(def) {
      return {
        type: "string",
        enum: Array.from(def.values)
      };
    }
    var isJsonSchema7AllOfType4 = (type) => {
      if ("type" in type && type.type === "string") return false;
      return "allOf" in type;
    };
    function parseIntersectionDef4(def, refs) {
      const allOf = [
        parseDef4(def.left._def, {
          ...refs,
          currentPath: [...refs.currentPath, "allOf", "0"]
        }),
        parseDef4(def.right._def, {
          ...refs,
          currentPath: [...refs.currentPath, "allOf", "1"]
        })
      ].filter((x) => !!x);
      const mergedAllOf = [];
      allOf.forEach((schema) => {
        if (isJsonSchema7AllOfType4(schema)) {
          mergedAllOf.push(...schema.allOf);
        } else {
          let nestedSchema = schema;
          if ("additionalProperties" in schema && schema.additionalProperties === false) {
            const { additionalProperties, ...rest } = schema;
            nestedSchema = rest;
          }
          mergedAllOf.push(nestedSchema);
        }
      });
      return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
    }
    function parseLiteralDef4(def) {
      const parsedType3 = typeof def.value;
      if (parsedType3 !== "bigint" && parsedType3 !== "number" && parsedType3 !== "boolean" && parsedType3 !== "string") {
        return {
          type: Array.isArray(def.value) ? "array" : "object"
        };
      }
      return {
        type: parsedType3 === "bigint" ? "integer" : parsedType3,
        const: def.value
      };
    }
    var import_v322 = require_v3();
    var emojiRegex5 = void 0;
    var zodPatterns4 = {
      /**
       * `c` was changed to `[cC]` to replicate /i flag
       */
      cuid: /^[cC][^\s-]{8,}$/,
      cuid2: /^[0-9a-z]+$/,
      ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
      /**
       * `a-z` was added to replicate /i flag
       */
      email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
      /**
       * Constructed a valid Unicode RegExp
       *
       * Lazily instantiate since this type of regex isn't supported
       * in all envs (e.g. React Native).
       *
       * See:
       * https://github.com/colinhacks/zod/issues/2433
       * Fix in Zod:
       * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
       */
      emoji: () => {
        if (emojiRegex5 === void 0) {
          emojiRegex5 = RegExp(
            "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
            "u"
          );
        }
        return emojiRegex5;
      },
      /**
       * Unused
       */
      uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
      /**
       * Unused
       */
      ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
      ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
      /**
       * Unused
       */
      ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
      ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
      base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
      base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
      nanoid: /^[a-zA-Z0-9_-]{21}$/,
      jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
    };
    function parseStringDef4(def, refs) {
      const res = {
        type: "string"
      };
      if (def.checks) {
        for (const check3 of def.checks) {
          switch (check3.kind) {
            case "min":
              res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value;
              break;
            case "max":
              res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value;
              break;
            case "email":
              switch (refs.emailStrategy) {
                case "format:email":
                  addFormat4(res, "email", check3.message, refs);
                  break;
                case "format:idn-email":
                  addFormat4(res, "idn-email", check3.message, refs);
                  break;
                case "pattern:zod":
                  addPattern4(res, zodPatterns4.email, check3.message, refs);
                  break;
              }
              break;
            case "url":
              addFormat4(res, "uri", check3.message, refs);
              break;
            case "uuid":
              addFormat4(res, "uuid", check3.message, refs);
              break;
            case "regex":
              addPattern4(res, check3.regex, check3.message, refs);
              break;
            case "cuid":
              addPattern4(res, zodPatterns4.cuid, check3.message, refs);
              break;
            case "cuid2":
              addPattern4(res, zodPatterns4.cuid2, check3.message, refs);
              break;
            case "startsWith":
              addPattern4(
                res,
                RegExp(`^${escapeLiteralCheckValue4(check3.value, refs)}`),
                check3.message,
                refs
              );
              break;
            case "endsWith":
              addPattern4(
                res,
                RegExp(`${escapeLiteralCheckValue4(check3.value, refs)}$`),
                check3.message,
                refs
              );
              break;
            case "datetime":
              addFormat4(res, "date-time", check3.message, refs);
              break;
            case "date":
              addFormat4(res, "date", check3.message, refs);
              break;
            case "time":
              addFormat4(res, "time", check3.message, refs);
              break;
            case "duration":
              addFormat4(res, "duration", check3.message, refs);
              break;
            case "length":
              res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value;
              res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value;
              break;
            case "includes": {
              addPattern4(
                res,
                RegExp(escapeLiteralCheckValue4(check3.value, refs)),
                check3.message,
                refs
              );
              break;
            }
            case "ip": {
              if (check3.version !== "v6") {
                addFormat4(res, "ipv4", check3.message, refs);
              }
              if (check3.version !== "v4") {
                addFormat4(res, "ipv6", check3.message, refs);
              }
              break;
            }
            case "base64url":
              addPattern4(res, zodPatterns4.base64url, check3.message, refs);
              break;
            case "jwt":
              addPattern4(res, zodPatterns4.jwt, check3.message, refs);
              break;
            case "cidr": {
              if (check3.version !== "v6") {
                addPattern4(res, zodPatterns4.ipv4Cidr, check3.message, refs);
              }
              if (check3.version !== "v4") {
                addPattern4(res, zodPatterns4.ipv6Cidr, check3.message, refs);
              }
              break;
            }
            case "emoji":
              addPattern4(res, zodPatterns4.emoji(), check3.message, refs);
              break;
            case "ulid": {
              addPattern4(res, zodPatterns4.ulid, check3.message, refs);
              break;
            }
            case "base64": {
              switch (refs.base64Strategy) {
                case "format:binary": {
                  addFormat4(res, "binary", check3.message, refs);
                  break;
                }
                case "contentEncoding:base64": {
                  res.contentEncoding = "base64";
                  break;
                }
                case "pattern:zod": {
                  addPattern4(res, zodPatterns4.base64, check3.message, refs);
                  break;
                }
              }
              break;
            }
            case "nanoid": {
              addPattern4(res, zodPatterns4.nanoid, check3.message, refs);
            }
            case "toLowerCase":
            case "toUpperCase":
            case "trim":
              break;
            default:
              /* @__PURE__ */ ((_) => {
              })(check3);
          }
        }
      }
      return res;
    }
    function escapeLiteralCheckValue4(literal3, refs) {
      return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric4(literal3) : literal3;
    }
    var ALPHA_NUMERIC5 = new Set(
      "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
    );
    function escapeNonAlphaNumeric4(source) {
      let result = "";
      for (let i = 0; i < source.length; i++) {
        if (!ALPHA_NUMERIC5.has(source[i])) {
          result += "\\";
        }
        result += source[i];
      }
      return result;
    }
    function addFormat4(schema, value, message, refs) {
      var _a211;
      if (schema.format || ((_a211 = schema.anyOf) == null ? void 0 : _a211.some((x) => x.format))) {
        if (!schema.anyOf) {
          schema.anyOf = [];
        }
        if (schema.format) {
          schema.anyOf.push({
            format: schema.format
          });
          delete schema.format;
        }
        schema.anyOf.push({
          format: value,
          ...message && refs.errorMessages && { errorMessage: { format: message } }
        });
      } else {
        schema.format = value;
      }
    }
    function addPattern4(schema, regex, message, refs) {
      var _a211;
      if (schema.pattern || ((_a211 = schema.allOf) == null ? void 0 : _a211.some((x) => x.pattern))) {
        if (!schema.allOf) {
          schema.allOf = [];
        }
        if (schema.pattern) {
          schema.allOf.push({
            pattern: schema.pattern
          });
          delete schema.pattern;
        }
        schema.allOf.push({
          pattern: stringifyRegExpWithFlags4(regex, refs),
          ...message && refs.errorMessages && { errorMessage: { pattern: message } }
        });
      } else {
        schema.pattern = stringifyRegExpWithFlags4(regex, refs);
      }
    }
    function stringifyRegExpWithFlags4(regex, refs) {
      var _a211;
      if (!refs.applyRegexFlags || !regex.flags) {
        return regex.source;
      }
      const flags = {
        i: regex.flags.includes("i"),
        // Case-insensitive
        m: regex.flags.includes("m"),
        // `^` and `$` matches adjacent to newline characters
        s: regex.flags.includes("s")
        // `.` matches newlines
      };
      const source = flags.i ? regex.source.toLowerCase() : regex.source;
      let pattern = "";
      let isEscaped = false;
      let inCharGroup = false;
      let inCharRange = false;
      for (let i = 0; i < source.length; i++) {
        if (isEscaped) {
          pattern += source[i];
          isEscaped = false;
          continue;
        }
        if (flags.i) {
          if (inCharGroup) {
            if (source[i].match(/[a-z]/)) {
              if (inCharRange) {
                pattern += source[i];
                pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
                inCharRange = false;
              } else if (source[i + 1] === "-" && ((_a211 = source[i + 2]) == null ? void 0 : _a211.match(/[a-z]/))) {
                pattern += source[i];
                inCharRange = true;
              } else {
                pattern += `${source[i]}${source[i].toUpperCase()}`;
              }
              continue;
            }
          } else if (source[i].match(/[a-z]/)) {
            pattern += `[${source[i]}${source[i].toUpperCase()}]`;
            continue;
          }
        }
        if (flags.m) {
          if (source[i] === "^") {
            pattern += `(^|(?<=[\r
]))`;
            continue;
          } else if (source[i] === "$") {
            pattern += `($|(?=[\r
]))`;
            continue;
          }
        }
        if (flags.s && source[i] === ".") {
          pattern += inCharGroup ? `${source[i]}\r
` : `[${source[i]}\r
]`;
          continue;
        }
        pattern += source[i];
        if (source[i] === "\\") {
          isEscaped = true;
        } else if (inCharGroup && source[i] === "]") {
          inCharGroup = false;
        } else if (!inCharGroup && source[i] === "[") {
          inCharGroup = true;
        }
      }
      try {
        new RegExp(pattern);
      } catch (e) {
        console.warn(
          `Could not convert regex pattern at ${refs.currentPath.join(
            "/"
          )} to a flag-independent form! Falling back to the flag-ignorant source`
        );
        return regex.source;
      }
      return pattern;
    }
    function parseRecordDef4(def, refs) {
      var _a211, _b28, _c, _d, _e, _f;
      const schema = {
        type: "object",
        additionalProperties: (_a211 = parseDef4(def.valueType._def, {
          ...refs,
          currentPath: [...refs.currentPath, "additionalProperties"]
        })) != null ? _a211 : refs.allowedAdditionalProperties
      };
      if (((_b28 = def.keyType) == null ? void 0 : _b28._def.typeName) === import_v322.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
        const { type, ...keyType } = parseStringDef4(def.keyType._def, refs);
        return {
          ...schema,
          propertyNames: keyType
        };
      } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v322.ZodFirstPartyTypeKind.ZodEnum) {
        return {
          ...schema,
          propertyNames: {
            enum: def.keyType._def.values
          }
        };
      } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === import_v322.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v322.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
        const { type, ...keyType } = parseBrandedDef4(
          def.keyType._def,
          refs
        );
        return {
          ...schema,
          propertyNames: keyType
        };
      }
      return schema;
    }
    function parseMapDef4(def, refs) {
      if (refs.mapStrategy === "record") {
        return parseRecordDef4(def, refs);
      }
      const keys2 = parseDef4(def.keyType._def, {
        ...refs,
        currentPath: [...refs.currentPath, "items", "items", "0"]
      }) || parseAnyDef4();
      const values = parseDef4(def.valueType._def, {
        ...refs,
        currentPath: [...refs.currentPath, "items", "items", "1"]
      }) || parseAnyDef4();
      return {
        type: "array",
        maxItems: 125,
        items: {
          type: "array",
          items: [keys2, values],
          minItems: 2,
          maxItems: 2
        }
      };
    }
    function parseNativeEnumDef4(def) {
      const object4 = def.values;
      const actualKeys = Object.keys(def.values).filter((key) => {
        return typeof object4[object4[key]] !== "number";
      });
      const actualValues = actualKeys.map((key) => object4[key]);
      const parsedTypes = Array.from(
        new Set(actualValues.map((values) => typeof values))
      );
      return {
        type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
        enum: actualValues
      };
    }
    function parseNeverDef4() {
      return { not: parseAnyDef4() };
    }
    function parseNullDef4() {
      return {
        type: "null"
      };
    }
    var primitiveMappings4 = {
      ZodString: "string",
      ZodNumber: "number",
      ZodBigInt: "integer",
      ZodBoolean: "boolean",
      ZodNull: "null"
    };
    function parseUnionDef4(def, refs) {
      const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
      if (options.every(
        (x) => x._def.typeName in primitiveMappings4 && (!x._def.checks || !x._def.checks.length)
      )) {
        const types = options.reduce((types2, x) => {
          const type = primitiveMappings4[x._def.typeName];
          return type && !types2.includes(type) ? [...types2, type] : types2;
        }, []);
        return {
          type: types.length > 1 ? types : types[0]
        };
      } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
        const types = options.reduce(
          (acc, x) => {
            const type = typeof x._def.value;
            switch (type) {
              case "string":
              case "number":
              case "boolean":
                return [...acc, type];
              case "bigint":
                return [...acc, "integer"];
              case "object":
                if (x._def.value === null) return [...acc, "null"];
              case "symbol":
              case "undefined":
              case "function":
              default:
                return acc;
            }
          },
          []
        );
        if (types.length === options.length) {
          const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
          return {
            type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
            enum: options.reduce(
              (acc, x) => {
                return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
              },
              []
            )
          };
        }
      } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
        return {
          type: "string",
          enum: options.reduce(
            (acc, x) => [
              ...acc,
              ...x._def.values.filter((x2) => !acc.includes(x2))
            ],
            []
          )
        };
      }
      return asAnyOf4(def, refs);
    }
    var asAnyOf4 = (def, refs) => {
      const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
        (x, i) => parseDef4(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "anyOf", `${i}`]
        })
      ).filter(
        (x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
      );
      return anyOf.length ? { anyOf } : void 0;
    };
    function parseNullableDef4(def, refs) {
      if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
        def.innerType._def.typeName
      ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
        return {
          type: [
            primitiveMappings4[def.innerType._def.typeName],
            "null"
          ]
        };
      }
      const base = parseDef4(def.innerType._def, {
        ...refs,
        currentPath: [...refs.currentPath, "anyOf", "0"]
      });
      return base && { anyOf: [base, { type: "null" }] };
    }
    function parseNumberDef4(def) {
      const res = {
        type: "number"
      };
      if (!def.checks) return res;
      for (const check3 of def.checks) {
        switch (check3.kind) {
          case "int":
            res.type = "integer";
            break;
          case "min":
            if (check3.inclusive) {
              res.minimum = check3.value;
            } else {
              res.exclusiveMinimum = check3.value;
            }
            break;
          case "max":
            if (check3.inclusive) {
              res.maximum = check3.value;
            } else {
              res.exclusiveMaximum = check3.value;
            }
            break;
          case "multipleOf":
            res.multipleOf = check3.value;
            break;
        }
      }
      return res;
    }
    function parseObjectDef4(def, refs) {
      const result = {
        type: "object",
        properties: {}
      };
      const required3 = [];
      const shape = def.shape();
      for (const propName in shape) {
        let propDef = shape[propName];
        if (propDef === void 0 || propDef._def === void 0) {
          continue;
        }
        const propOptional = safeIsOptional4(propDef);
        const parsedDef = parseDef4(propDef._def, {
          ...refs,
          currentPath: [...refs.currentPath, "properties", propName],
          propertyPath: [...refs.currentPath, "properties", propName]
        });
        if (parsedDef === void 0) {
          continue;
        }
        result.properties[propName] = parsedDef;
        if (!propOptional) {
          required3.push(propName);
        }
      }
      if (required3.length) {
        result.required = required3;
      }
      const additionalProperties = decideAdditionalProperties4(def, refs);
      if (additionalProperties !== void 0) {
        result.additionalProperties = additionalProperties;
      }
      return result;
    }
    function decideAdditionalProperties4(def, refs) {
      if (def.catchall._def.typeName !== "ZodNever") {
        return parseDef4(def.catchall._def, {
          ...refs,
          currentPath: [...refs.currentPath, "additionalProperties"]
        });
      }
      switch (def.unknownKeys) {
        case "passthrough":
          return refs.allowedAdditionalProperties;
        case "strict":
          return refs.rejectedAdditionalProperties;
        case "strip":
          return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
      }
    }
    function safeIsOptional4(schema) {
      try {
        return schema.isOptional();
      } catch (e) {
        return true;
      }
    }
    var parseOptionalDef4 = (def, refs) => {
      var _a211;
      if (refs.currentPath.toString() === ((_a211 = refs.propertyPath) == null ? void 0 : _a211.toString())) {
        return parseDef4(def.innerType._def, refs);
      }
      const innerSchema = parseDef4(def.innerType._def, {
        ...refs,
        currentPath: [...refs.currentPath, "anyOf", "1"]
      });
      return innerSchema ? { anyOf: [{ not: parseAnyDef4() }, innerSchema] } : parseAnyDef4();
    };
    var parsePipelineDef4 = (def, refs) => {
      if (refs.pipeStrategy === "input") {
        return parseDef4(def.in._def, refs);
      } else if (refs.pipeStrategy === "output") {
        return parseDef4(def.out._def, refs);
      }
      const a = parseDef4(def.in._def, {
        ...refs,
        currentPath: [...refs.currentPath, "allOf", "0"]
      });
      const b = parseDef4(def.out._def, {
        ...refs,
        currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
      });
      return {
        allOf: [a, b].filter((x) => x !== void 0)
      };
    };
    function parsePromiseDef4(def, refs) {
      return parseDef4(def.type._def, refs);
    }
    function parseSetDef4(def, refs) {
      const items = parseDef4(def.valueType._def, {
        ...refs,
        currentPath: [...refs.currentPath, "items"]
      });
      const schema = {
        type: "array",
        uniqueItems: true,
        items
      };
      if (def.minSize) {
        schema.minItems = def.minSize.value;
      }
      if (def.maxSize) {
        schema.maxItems = def.maxSize.value;
      }
      return schema;
    }
    function parseTupleDef4(def, refs) {
      if (def.rest) {
        return {
          type: "array",
          minItems: def.items.length,
          items: def.items.map(
            (x, i) => parseDef4(x._def, {
              ...refs,
              currentPath: [...refs.currentPath, "items", `${i}`]
            })
          ).reduce(
            (acc, x) => x === void 0 ? acc : [...acc, x],
            []
          ),
          additionalItems: parseDef4(def.rest._def, {
            ...refs,
            currentPath: [...refs.currentPath, "additionalItems"]
          })
        };
      } else {
        return {
          type: "array",
          minItems: def.items.length,
          maxItems: def.items.length,
          items: def.items.map(
            (x, i) => parseDef4(x._def, {
              ...refs,
              currentPath: [...refs.currentPath, "items", `${i}`]
            })
          ).reduce(
            (acc, x) => x === void 0 ? acc : [...acc, x],
            []
          )
        };
      }
    }
    function parseUndefinedDef4() {
      return {
        not: parseAnyDef4()
      };
    }
    function parseUnknownDef4() {
      return parseAnyDef4();
    }
    var parseReadonlyDef4 = (def, refs) => {
      return parseDef4(def.innerType._def, refs);
    };
    var selectParser4 = (def, typeName, refs) => {
      switch (typeName) {
        case import_v332.ZodFirstPartyTypeKind.ZodString:
          return parseStringDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodNumber:
          return parseNumberDef4(def);
        case import_v332.ZodFirstPartyTypeKind.ZodObject:
          return parseObjectDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodBigInt:
          return parseBigintDef4(def);
        case import_v332.ZodFirstPartyTypeKind.ZodBoolean:
          return parseBooleanDef4();
        case import_v332.ZodFirstPartyTypeKind.ZodDate:
          return parseDateDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodUndefined:
          return parseUndefinedDef4();
        case import_v332.ZodFirstPartyTypeKind.ZodNull:
          return parseNullDef4();
        case import_v332.ZodFirstPartyTypeKind.ZodArray:
          return parseArrayDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodUnion:
        case import_v332.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
          return parseUnionDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodIntersection:
          return parseIntersectionDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodTuple:
          return parseTupleDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodRecord:
          return parseRecordDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodLiteral:
          return parseLiteralDef4(def);
        case import_v332.ZodFirstPartyTypeKind.ZodEnum:
          return parseEnumDef4(def);
        case import_v332.ZodFirstPartyTypeKind.ZodNativeEnum:
          return parseNativeEnumDef4(def);
        case import_v332.ZodFirstPartyTypeKind.ZodNullable:
          return parseNullableDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodOptional:
          return parseOptionalDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodMap:
          return parseMapDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodSet:
          return parseSetDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodLazy:
          return () => def.getter()._def;
        case import_v332.ZodFirstPartyTypeKind.ZodPromise:
          return parsePromiseDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodNaN:
        case import_v332.ZodFirstPartyTypeKind.ZodNever:
          return parseNeverDef4();
        case import_v332.ZodFirstPartyTypeKind.ZodEffects:
          return parseEffectsDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodAny:
          return parseAnyDef4();
        case import_v332.ZodFirstPartyTypeKind.ZodUnknown:
          return parseUnknownDef4();
        case import_v332.ZodFirstPartyTypeKind.ZodDefault:
          return parseDefaultDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodBranded:
          return parseBrandedDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodReadonly:
          return parseReadonlyDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodCatch:
          return parseCatchDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodPipeline:
          return parsePipelineDef4(def, refs);
        case import_v332.ZodFirstPartyTypeKind.ZodFunction:
        case import_v332.ZodFirstPartyTypeKind.ZodVoid:
        case import_v332.ZodFirstPartyTypeKind.ZodSymbol:
          return void 0;
        default:
          return /* @__PURE__ */ ((_) => void 0)(typeName);
      }
    };
    var getRelativePath4 = (pathA, pathB) => {
      let i = 0;
      for (; i < pathA.length && i < pathB.length; i++) {
        if (pathA[i] !== pathB[i]) break;
      }
      return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
    };
    function parseDef4(def, refs, forceResolution = false) {
      var _a211;
      const seenItem = refs.seen.get(def);
      if (refs.override) {
        const overrideResult = (_a211 = refs.override) == null ? void 0 : _a211.call(
          refs,
          def,
          refs,
          seenItem,
          forceResolution
        );
        if (overrideResult !== ignoreOverride4) {
          return overrideResult;
        }
      }
      if (seenItem && !forceResolution) {
        const seenSchema = get$ref4(seenItem, refs);
        if (seenSchema !== void 0) {
          return seenSchema;
        }
      }
      const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
      refs.seen.set(def, newItem);
      const jsonSchemaOrGetter = selectParser4(def, def.typeName, refs);
      const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef4(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
      if (jsonSchema22) {
        addMeta4(def, refs, jsonSchema22);
      }
      if (refs.postProcess) {
        const postProcessResult = refs.postProcess(jsonSchema22, def, refs);
        newItem.jsonSchema = jsonSchema22;
        return postProcessResult;
      }
      newItem.jsonSchema = jsonSchema22;
      return jsonSchema22;
    }
    var get$ref4 = (item, refs) => {
      switch (refs.$refStrategy) {
        case "root":
          return { $ref: item.path.join("/") };
        case "relative":
          return { $ref: getRelativePath4(refs.currentPath, item.path) };
        case "none":
        case "seen": {
          if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
            console.warn(
              `Recursive reference detected at ${refs.currentPath.join(
                "/"
              )}! Defaulting to any`
            );
            return parseAnyDef4();
          }
          return refs.$refStrategy === "seen" ? parseAnyDef4() : void 0;
        }
      }
    };
    var addMeta4 = (def, refs, jsonSchema22) => {
      if (def.description) {
        jsonSchema22.description = def.description;
      }
      return jsonSchema22;
    };
    var getRefs4 = (options) => {
      const _options = getDefaultOptions4(options);
      const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
      return {
        ..._options,
        currentPath,
        propertyPath: void 0,
        seen: new Map(
          Object.entries(_options.definitions).map(([name29, def]) => [
            def._def,
            {
              def: def._def,
              path: [..._options.basePath, _options.definitionPath, name29],
              // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
              jsonSchema: void 0
            }
          ])
        )
      };
    };
    var zod3ToJsonSchema4 = (schema, options) => {
      var _a211;
      const refs = getRefs4(options);
      let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
        (acc, [name37, schema2]) => {
          var _a37;
          return {
            ...acc,
            [name37]: (_a37 = parseDef4(
              schema2._def,
              {
                ...refs,
                currentPath: [...refs.basePath, refs.definitionPath, name37]
              },
              true
            )) != null ? _a37 : parseAnyDef4()
          };
        },
        {}
      ) : void 0;
      const name29 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
      const main = (_a211 = parseDef4(
        schema._def,
        name29 === void 0 ? refs : {
          ...refs,
          currentPath: [...refs.basePath, refs.definitionPath, name29]
        },
        false
      )) != null ? _a211 : parseAnyDef4();
      const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
      if (title !== void 0) {
        main.title = title;
      }
      const combined = name29 === void 0 ? definitions ? {
        ...main,
        [refs.definitionPath]: definitions
      } : main : {
        $ref: [
          ...refs.$refStrategy === "relative" ? [] : refs.basePath,
          refs.definitionPath,
          name29
        ].join("/"),
        [refs.definitionPath]: {
          ...definitions,
          [name29]: main
        }
      };
      combined.$schema = "http://json-schema.org/draft-07/schema#";
      return combined;
    };
    var schemaSymbol4 = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
    function lazySchema3(createSchema) {
      let schema;
      return () => {
        if (schema == null) {
          schema = createSchema();
        }
        return schema;
      };
    }
    function jsonSchema4(jsonSchema22, {
      validate
    } = {}) {
      return {
        [schemaSymbol4]: true,
        _type: void 0,
        // should never be used directly
        get jsonSchema() {
          if (typeof jsonSchema22 === "function") {
            jsonSchema22 = jsonSchema22();
          }
          return jsonSchema22;
        },
        validate
      };
    }
    function isSchema4(value) {
      return typeof value === "object" && value !== null && schemaSymbol4 in value && value[schemaSymbol4] === true && "jsonSchema" in value && "validate" in value;
    }
    function asSchema4(schema) {
      return schema == null ? jsonSchema4({ properties: {}, additionalProperties: false }) : isSchema4(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema4(schema) : standardSchema4(schema) : schema();
    }
    function standardSchema4(standardSchema22) {
      return jsonSchema4(
        () => addAdditionalPropertiesToJsonSchema4(
          standardSchema22["~standard"].jsonSchema.input({
            target: "draft-07"
          })
        ),
        {
          validate: async (value) => {
            const result = await standardSchema22["~standard"].validate(value);
            return "value" in result ? { success: true, value: result.value } : {
              success: false,
              error: new import_provider710.TypeValidationError({
                value,
                cause: result.issues
              })
            };
          }
        }
      );
    }
    function zod3Schema4(zodSchema22, options) {
      var _a211;
      const useReferences = (_a211 = options == null ? void 0 : options.useReferences) != null ? _a211 : false;
      return jsonSchema4(
        // defer json schema creation to avoid unnecessary computation when only validation is needed
        () => zod3ToJsonSchema4(zodSchema22, {
          $refStrategy: useReferences ? "root" : "none"
        }),
        {
          validate: async (value) => {
            const result = await zodSchema22.safeParseAsync(value);
            return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
          }
        }
      );
    }
    function zod4Schema4(zodSchema22, options) {
      var _a211;
      const useReferences = (_a211 = options == null ? void 0 : options.useReferences) != null ? _a211 : false;
      return jsonSchema4(
        // defer json schema creation to avoid unnecessary computation when only validation is needed
        () => addAdditionalPropertiesToJsonSchema4(
          z4.toJSONSchema(zodSchema22, {
            target: "draft-7",
            io: "input",
            reused: useReferences ? "ref" : "inline"
          })
        ),
        {
          validate: async (value) => {
            const result = await z4.safeParseAsync(zodSchema22, value);
            return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
          }
        }
      );
    }
    function isZod4Schema4(zodSchema22) {
      return "_zod" in zodSchema22;
    }
    function zodSchema4(zodSchema22, options) {
      if (isZod4Schema4(zodSchema22)) {
        return zod4Schema4(zodSchema22, options);
      } else {
        return zod3Schema4(zodSchema22, options);
      }
    }
    async function validateTypes5({
      value,
      schema,
      context: context2
    }) {
      const result = await safeValidateTypes5({ value, schema, context: context2 });
      if (!result.success) {
        throw import_provider810.TypeValidationError.wrap({ value, cause: result.error, context: context2 });
      }
      return result.value;
    }
    async function safeValidateTypes5({
      value,
      schema,
      context: context2
    }) {
      const actualSchema = asSchema4(schema);
      try {
        if (actualSchema.validate == null) {
          return { success: true, value, rawValue: value };
        }
        const result = await actualSchema.validate(value);
        if (result.success) {
          return { success: true, value: result.value, rawValue: value };
        }
        return {
          success: false,
          error: import_provider810.TypeValidationError.wrap({ value, cause: result.error, context: context2 }),
          rawValue: value
        };
      } catch (error73) {
        return {
          success: false,
          error: import_provider810.TypeValidationError.wrap({ value, cause: error73, context: context2 }),
          rawValue: value
        };
      }
    }
    async function parseJSON5({
      text: text2,
      schema
    }) {
      try {
        const value = secureJsonParse5(text2);
        if (schema == null) {
          return value;
        }
        return validateTypes5({ value, schema });
      } catch (error73) {
        if (import_provider910.JSONParseError.isInstance(error73) || import_provider910.TypeValidationError.isInstance(error73)) {
          throw error73;
        }
        throw new import_provider910.JSONParseError({ text: text2, cause: error73 });
      }
    }
    async function safeParseJSON5({
      text: text2,
      schema
    }) {
      try {
        const value = secureJsonParse5(text2);
        if (schema == null) {
          return { success: true, value, rawValue: value };
        }
        return await safeValidateTypes5({ value, schema });
      } catch (error73) {
        return {
          success: false,
          error: import_provider910.JSONParseError.isInstance(error73) ? error73 : new import_provider910.JSONParseError({ text: text2, cause: error73 }),
          rawValue: void 0
        };
      }
    }
    function isParsableJson4(input) {
      try {
        secureJsonParse5(input);
        return true;
      } catch (e) {
        return false;
      }
    }
    var import_stream9 = require_stream7();
    function parseJsonEventStream5({
      stream: stream4,
      schema
    }) {
      return stream4.pipeThrough(new TextDecoderStream()).pipeThrough(new import_stream9.EventSourceParserStream()).pipeThrough(
        new TransformStream({
          async transform({ data }, controller) {
            if (data === "[DONE]") {
              return;
            }
            controller.enqueue(await safeParseJSON5({ text: data, schema }));
          }
        })
      );
    }
    var import_provider104 = require_dist6();
    async function parseProviderOptions4({
      provider,
      providerOptions,
      schema
    }) {
      if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
        return void 0;
      }
      const parsedProviderOptions = await safeValidateTypes5({
        value: providerOptions[provider],
        schema
      });
      if (!parsedProviderOptions.success) {
        throw new import_provider104.InvalidArgumentError({
          argument: "providerOptions",
          message: `invalid ${provider} provider options`,
          cause: parsedProviderOptions.error
        });
      }
      return parsedProviderOptions.value;
    }
    var import_provider112 = require_dist6();
    var getOriginalFetch25 = () => globalThis.fetch;
    var postJsonToApi5 = async ({
      url: url4,
      headers,
      body,
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    }) => postToApi5({
      url: url4,
      headers: {
        "Content-Type": "application/json",
        ...headers
      },
      body: {
        content: JSON.stringify(body),
        values: body
      },
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    });
    var postFormDataToApi2 = async ({
      url: url4,
      headers,
      formData,
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    }) => postToApi5({
      url: url4,
      headers,
      body: {
        content: formData,
        values: Object.fromEntries(formData.entries())
      },
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    });
    var postToApi5 = async ({
      url: url4,
      headers = {},
      body,
      successfulResponseHandler,
      failedResponseHandler,
      abortSignal,
      fetch: fetch2 = getOriginalFetch25()
    }) => {
      try {
        const response = await fetch2(url4, {
          method: "POST",
          headers: withUserAgentSuffix5(
            headers,
            `ai-sdk/provider-utils/${VERSION16}`,
            getRuntimeEnvironmentUserAgent5()
          ),
          body: body.content,
          signal: abortSignal
        });
        const responseHeaders = extractResponseHeaders5(response);
        if (!response.ok) {
          let errorInformation;
          try {
            errorInformation = await failedResponseHandler({
              response,
              url: url4,
              requestBodyValues: body.values
            });
          } catch (error73) {
            if (isAbortError5(error73) || import_provider112.APICallError.isInstance(error73)) {
              throw error73;
            }
            throw new import_provider112.APICallError({
              message: "Failed to process error response",
              cause: error73,
              statusCode: response.status,
              url: url4,
              responseHeaders,
              requestBodyValues: body.values
            });
          }
          throw errorInformation.value;
        }
        try {
          return await successfulResponseHandler({
            response,
            url: url4,
            requestBodyValues: body.values
          });
        } catch (error73) {
          if (error73 instanceof Error) {
            if (isAbortError5(error73) || import_provider112.APICallError.isInstance(error73)) {
              throw error73;
            }
          }
          throw new import_provider112.APICallError({
            message: "Failed to process successful response",
            cause: error73,
            statusCode: response.status,
            url: url4,
            responseHeaders,
            requestBodyValues: body.values
          });
        }
      } catch (error73) {
        throw handleFetchError5({ error: error73, url: url4, requestBodyValues: body.values });
      }
    };
    function tool3(tool22) {
      return tool22;
    }
    function dynamicTool2(tool22) {
      return { ...tool22, type: "dynamic" };
    }
    function createProviderToolFactory3({
      id,
      inputSchema
    }) {
      return ({
        execute,
        outputSchema: outputSchema2,
        needsApproval,
        toModelOutput,
        onInputStart,
        onInputDelta,
        onInputAvailable,
        ...args
      }) => tool3({
        type: "provider",
        id,
        args,
        inputSchema,
        outputSchema: outputSchema2,
        execute,
        needsApproval,
        toModelOutput,
        onInputStart,
        onInputDelta,
        onInputAvailable
      });
    }
    function createProviderToolFactoryWithOutputSchema3({
      id,
      inputSchema,
      outputSchema: outputSchema2,
      supportsDeferredResults
    }) {
      return ({
        execute,
        needsApproval,
        toModelOutput,
        onInputStart,
        onInputDelta,
        onInputAvailable,
        ...args
      }) => tool3({
        type: "provider",
        id,
        args,
        inputSchema,
        outputSchema: outputSchema2,
        execute,
        needsApproval,
        toModelOutput,
        onInputStart,
        onInputDelta,
        onInputAvailable,
        supportsDeferredResults
      });
    }
    function removeUndefinedEntries(record3) {
      return Object.fromEntries(
        Object.entries(record3).filter(([_key, value]) => value != null)
      );
    }
    async function resolve3(value) {
      if (typeof value === "function") {
        value = value();
      }
      return Promise.resolve(value);
    }
    var import_provider122 = require_dist6();
    var createJsonErrorResponseHandler5 = ({
      errorSchema,
      errorToMessage,
      isRetryable
    }) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const responseHeaders = extractResponseHeaders5(response);
      if (responseBody.trim() === "") {
        return {
          responseHeaders,
          value: new import_provider122.APICallError({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
      try {
        const parsedError = await parseJSON5({
          text: responseBody,
          schema: errorSchema
        });
        return {
          responseHeaders,
          value: new import_provider122.APICallError({
            message: errorToMessage(parsedError),
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            data: parsedError,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
          })
        };
      } catch (parseError) {
        return {
          responseHeaders,
          value: new import_provider122.APICallError({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
    };
    var createEventSourceResponseHandler5 = (chunkSchema2) => async ({ response }) => {
      const responseHeaders = extractResponseHeaders5(response);
      if (response.body == null) {
        throw new import_provider122.EmptyResponseBodyError({});
      }
      return {
        responseHeaders,
        value: parseJsonEventStream5({
          stream: response.body,
          schema: chunkSchema2
        })
      };
    };
    var createJsonResponseHandler5 = (responseSchema2) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const parsedResult = await safeParseJSON5({
        text: responseBody,
        schema: responseSchema2
      });
      const responseHeaders = extractResponseHeaders5(response);
      if (!parsedResult.success) {
        throw new import_provider122.APICallError({
          message: "Invalid JSON response",
          cause: parsedResult.error,
          statusCode: response.status,
          responseHeaders,
          responseBody,
          url: url4,
          requestBodyValues
        });
      }
      return {
        responseHeaders,
        value: parsedResult.value,
        rawValue: parsedResult.rawValue
      };
    };
    var createBinaryResponseHandler2 = () => async ({ response, url: url4, requestBodyValues }) => {
      const responseHeaders = extractResponseHeaders5(response);
      if (!response.body) {
        throw new import_provider122.APICallError({
          message: "Response body is empty",
          url: url4,
          requestBodyValues,
          statusCode: response.status,
          responseHeaders,
          responseBody: void 0
        });
      }
      try {
        const buffer = await response.arrayBuffer();
        return {
          responseHeaders,
          value: new Uint8Array(buffer)
        };
      } catch (error73) {
        throw new import_provider122.APICallError({
          message: "Failed to read response as array buffer",
          url: url4,
          requestBodyValues,
          statusCode: response.status,
          responseHeaders,
          responseBody: void 0,
          cause: error73
        });
      }
    };
    var createStatusCodeErrorResponseHandler2 = () => async ({ response, url: url4, requestBodyValues }) => {
      const responseHeaders = extractResponseHeaders5(response);
      const responseBody = await response.text();
      return {
        responseHeaders,
        value: new import_provider122.APICallError({
          message: response.statusText,
          url: url4,
          requestBodyValues,
          statusCode: response.status,
          responseHeaders,
          responseBody
        })
      };
    };
    function stripFileExtension(filename) {
      const firstDotIndex = filename.indexOf(".");
      return firstDotIndex === -1 ? filename : filename.slice(0, firstDotIndex);
    }
    function withoutTrailingSlash4(url4) {
      return url4 == null ? void 0 : url4.replace(/\/$/, "");
    }
    function isAsyncIterable2(obj) {
      return obj != null && typeof obj[Symbol.asyncIterator] === "function";
    }
    async function* executeTool2({
      execute,
      input,
      options
    }) {
      const result = execute(input, options);
      if (isAsyncIterable2(result)) {
        let lastOutput;
        for await (const output of result) {
          lastOutput = output;
          yield { type: "preliminary", output };
        }
        yield { type: "final", output: lastOutput };
      } else {
        yield { type: "final", output: await result };
      }
    }
    var import_stream22 = require_stream7();
  }
});

// node_modules/zod/index.cjs
var require_zod = __commonJS({
  "node_modules/zod/index.cjs"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p3 in m) if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p3)) __createBinding(exports3, m, p3);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.z = void 0;
    var z3 = __importStar(require_external());
    exports2.z = z3;
    __exportStar(require_external(), exports2);
    exports2.default = z3;
  }
});

// node_modules/qwen-ai-provider-v5/dist/index.js
var require_dist9 = __commonJS({
  "node_modules/qwen-ai-provider-v5/dist/index.js"(exports2, module2) {
    "use strict";
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var index_exports = {};
    __export4(index_exports, {
      createQwen: () => createQwen2,
      qwen: () => qwen
    });
    module2.exports = __toCommonJS2(index_exports);
    var import_provider_utils710 = require_dist8();
    var import_provider210 = require_dist6();
    var import_provider_utils310 = require_dist8();
    var import_zod210 = require_zod();
    function buildUsage(inputTokens, outputTokens) {
      return {
        inputTokens: {
          total: inputTokens,
          noCache: void 0,
          cacheRead: void 0,
          cacheWrite: void 0
        },
        outputTokens: {
          total: outputTokens,
          text: void 0,
          reasoning: void 0
        }
      };
    }
    var import_provider103 = require_dist6();
    var import_provider_utils171 = require_dist8();
    function getQwenOptions(message) {
      var _a31, _b27;
      return (_b27 = (_a31 = message == null ? void 0 : message.providerOptions) == null ? void 0 : _a31.qwen) != null ? _b27 : {};
    }
    function convertToQwenChatMessages(prompt) {
      const messages = [];
      for (const { role, content, ...message } of prompt) {
        const options = getQwenOptions({ ...message });
        switch (role) {
          case "system": {
            messages.push({ role: "system", content, ...options });
            break;
          }
          case "user": {
            if (content.length === 1 && content[0].type === "text") {
              messages.push({
                role: "user",
                content: content[0].text,
                ...getQwenOptions(content[0])
              });
              break;
            }
            messages.push({
              role: "user",
              content: content.map((part) => {
                const partOptions = getQwenOptions(part);
                switch (part.type) {
                  case "text": {
                    return { type: "text", text: part.text, ...partOptions };
                  }
                  case "file": {
                    if (part.mediaType && part.mediaType.startsWith("image/")) {
                      const data = part.data;
                      let url4;
                      if (typeof data === "string") {
                        if (data.startsWith("http") || data.startsWith("data:")) {
                          url4 = data;
                        } else {
                          url4 = `data:${part.mediaType};base64,${data}`;
                        }
                      } else if (data instanceof URL) {
                        url4 = data.toString();
                      } else {
                        url4 = `data:${part.mediaType};base64,${(0, import_provider_utils171.convertUint8ArrayToBase64)(data)}`;
                      }
                      return {
                        type: "image_url",
                        image_url: { url: url4 },
                        ...partOptions
                      };
                    }
                    throw new import_provider103.UnsupportedFunctionalityError({
                      functionality: "Non-image file content parts in user messages"
                    });
                  }
                  default: {
                    const _exhaustiveCheck = part;
                    throw new import_provider103.UnsupportedFunctionalityError({
                      functionality: `Unsupported content part type: ${_exhaustiveCheck}`
                    });
                  }
                }
              }),
              ...options
            });
            break;
          }
          case "assistant": {
            let text2 = "";
            const toolCalls = [];
            for (const part of content) {
              const partOptions = getQwenOptions(part);
              switch (part.type) {
                case "text": {
                  text2 += part.text;
                  break;
                }
                case "tool-call": {
                  toolCalls.push({
                    id: part.toolCallId,
                    type: "function",
                    function: {
                      name: part.toolName,
                      arguments: JSON.stringify(part.input)
                    },
                    ...partOptions
                  });
                  break;
                }
                case "file":
                case "reasoning": {
                  break;
                }
                case "tool-result": {
                  throw new import_provider103.UnsupportedFunctionalityError({
                    functionality: "tool-result content parts in assistant messages"
                  });
                }
                default: {
                  const _exhaustiveCheck = part;
                  throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
                }
              }
            }
            messages.push({
              role: "assistant",
              content: text2,
              tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
              ...options
            });
            break;
          }
          case "tool": {
            for (const toolResponse of content) {
              if (toolResponse.type === "tool-approval-response") {
                continue;
              }
              const toolResponseOptions = getQwenOptions(toolResponse);
              const output = toolResponse.output;
              let toolContent;
              if (output.type === "text" || output.type === "error-text") {
                toolContent = output.value;
              } else if (output.type === "json" || output.type === "error-json") {
                toolContent = JSON.stringify(output.value);
              } else {
                toolContent = JSON.stringify({ type: output.type, reason: output.reason });
              }
              messages.push({
                role: "tool",
                tool_call_id: toolResponse.toolCallId,
                content: toolContent,
                ...toolResponseOptions
              });
            }
            break;
          }
          default: {
            const _exhaustiveCheck = role;
            throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
          }
        }
      }
      return messages;
    }
    function getResponseMetadata8({
      id,
      model,
      created
    }) {
      return {
        // Assign 'id' if provided; otherwise, leave as undefined.
        id: id != null ? id : void 0,
        // Map 'model' to 'modelId' for improved clarity; assign if provided.
        modelId: model != null ? model : void 0,
        // If 'created' is provided, convert the Unix timestamp (seconds) to a JavaScript Date object.
        timestamp: created != null ? new Date(created * 1e3) : void 0
      };
    }
    function mapQwenFinishReason(finishReason) {
      let unified;
      switch (finishReason) {
        case "stop":
          unified = "stop";
          break;
        case "length":
          unified = "length";
          break;
        case "tool_calls":
          unified = "tool-calls";
          break;
        case "content_filter":
          unified = "content-filter";
          break;
        default:
          unified = "other";
      }
      return {
        unified,
        raw: finishReason != null ? finishReason : void 0
      };
    }
    var import_provider_utils210 = require_dist8();
    var import_zod153 = require_zod();
    var qwenErrorDataSchema = import_zod153.z.object({
      object: import_zod153.z.literal("error"),
      message: import_zod153.z.string(),
      type: import_zod153.z.string(),
      param: import_zod153.z.string().nullable(),
      code: import_zod153.z.string().nullable()
    });
    var qwenFailedResponseHandler = (0, import_provider_utils210.createJsonErrorResponseHandler)({
      errorSchema: qwenErrorDataSchema,
      errorToMessage: (error73) => error73.message
    });
    var defaultQwenErrorStructure = {
      errorSchema: qwenErrorDataSchema,
      errorToMessage: (data) => data.message
    };
    var QwenChatResponseSchema = import_zod210.z.object({
      id: import_zod210.z.string().nullish(),
      created: import_zod210.z.number().nullish(),
      model: import_zod210.z.string().nullish(),
      choices: import_zod210.z.array(
        import_zod210.z.object({
          message: import_zod210.z.object({
            role: import_zod210.z.literal("assistant").nullish(),
            content: import_zod210.z.string().nullish(),
            reasoning_content: import_zod210.z.string().nullish(),
            reasoning: import_zod210.z.string().nullish(),
            tool_calls: import_zod210.z.array(
              import_zod210.z.object({
                id: import_zod210.z.string().nullish(),
                type: import_zod210.z.literal("function"),
                function: import_zod210.z.object({
                  name: import_zod210.z.string(),
                  arguments: import_zod210.z.string()
                })
              })
            ).nullish()
          }),
          finish_reason: import_zod210.z.string().nullish()
        })
      ),
      usage: import_zod210.z.object({
        prompt_tokens: import_zod210.z.number().nullish(),
        completion_tokens: import_zod210.z.number().nullish()
      }).nullish()
    });
    var QwenChatLanguageModel = class {
      // type inferred via constructor
      /**
       * Constructs a new QwenChatLanguageModel.
       * @param modelId - The model identifier.
       * @param settings - Settings for the chat.
       * @param config - Model configuration.
       */
      constructor(modelId, settings, config3) {
        this.specificationVersion = "v3";
        this.supportedUrls = {};
        var _a31, _b27;
        this.modelId = modelId;
        this.settings = settings;
        this.config = config3;
        const errorStructure = (_a31 = config3.errorStructure) != null ? _a31 : defaultQwenErrorStructure;
        this.chunkSchema = createQwenChatChunkSchema(errorStructure.errorSchema);
        this.failedResponseHandler = (0, import_provider_utils310.createJsonErrorResponseHandler)(errorStructure);
        this.supportsStructuredOutputs = (_b27 = config3.supportsStructuredOutputs) != null ? _b27 : false;
      }
      /**
       * Getter for the provider name.
       */
      get provider() {
        return this.config.provider;
      }
      /**
       * Internal getter that extracts the provider options name.
       * @private
       */
      get providerOptionsName() {
        return this.config.provider.split(".")[0].trim();
      }
      /**
       * Generates the arguments and warnings required for a language model generation call (V3).
       *
       * @param options - V3 call options
       * @param options.prompt - The prompt messages for the model
       * @param options.maxOutputTokens - Maximum number of tokens to generate
       * @param options.temperature - Sampling temperature
       * @param options.topP - Top-p sampling parameter
       * @param options.topK - Top-k sampling parameter
       * @param options.frequencyPenalty - Frequency penalty parameter
       * @param options.presencePenalty - Presence penalty parameter
       * @param options.providerOptions - Provider-specific options
       * @param options.stopSequences - Sequences where the model will stop generating
       * @param options.responseFormat - Expected format of the response
       * @param options.seed - Random seed for reproducibility
       * @param options.tools - Available tools for the model to use
       * @param options.toolChoice - Tool choice configuration
       * @returns An object containing the arguments and warnings
       */
      getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        providerOptions,
        stopSequences,
        responseFormat,
        seed,
        tools,
        toolChoice
      }) {
        var _a31;
        const warnings = [];
        if (topK != null) {
          warnings.push({
            type: "unsupported",
            feature: "topK"
          });
        }
        if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
          warnings.push({
            type: "unsupported",
            feature: "responseFormat",
            details: "JSON response format schema is only supported with structuredOutputs"
          });
        }
        const openaiTools2 = tools == null ? void 0 : tools.map((tool3) => {
          if (tool3.type === "function") {
            return {
              type: "function",
              function: {
                name: tool3.name,
                description: tool3.description,
                parameters: tool3.inputSchema
              }
            };
          }
          warnings.push({
            type: "unsupported",
            feature: `tool type: ${tool3.type}`
          });
          return null;
        }).filter((t) => t !== null);
        let openaiToolChoice;
        if (toolChoice) {
          if (toolChoice.type === "auto") {
            openaiToolChoice = "auto";
          } else if (toolChoice.type === "none") {
            openaiToolChoice = "none";
          } else if (toolChoice.type === "required") {
            openaiToolChoice = "required";
          } else if (toolChoice.type === "tool") {
            openaiToolChoice = {
              type: "function",
              function: { name: toolChoice.toolName }
            };
          }
        }
        const args = {
          // model id:
          model: this.modelId,
          // model specific settings:
          user: this.settings.user,
          // standardized settings:
          max_tokens: maxOutputTokens,
          temperature,
          top_p: topP,
          frequency_penalty: frequencyPenalty,
          presence_penalty: presencePenalty,
          response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
            type: "json_schema",
            json_schema: {
              schema: responseFormat.schema,
              name: (_a31 = responseFormat.name) != null ? _a31 : "response",
              description: responseFormat.description
            }
          } : { type: "json_object" } : void 0,
          stop: stopSequences,
          seed,
          ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
          // messages:
          messages: convertToQwenChatMessages(prompt),
          // tools:
          tools: openaiTools2 && openaiTools2.length > 0 ? openaiTools2 : void 0,
          tool_choice: openaiToolChoice
        };
        return { args, warnings };
      }
      /**
       * Generates a text response from the model (V3).
       * @param options - Generation options.
       * @returns A promise resolving with the generation result.
       */
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h;
        const { args, warnings } = this.getArgs(options);
        const body = JSON.stringify(args);
        const {
          responseHeaders,
          value: responseBody,
          rawValue: parsedBody
        } = await (0, import_provider_utils310.postJsonToApi)({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: (0, import_provider_utils310.combineHeaders)(this.config.headers(), options.headers),
          body: args,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: (0, import_provider_utils310.createJsonResponseHandler)(
            QwenChatResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const choice2 = responseBody.choices[0];
        const providerMetadata = (_b27 = (_a31 = this.config.metadataExtractor) == null ? void 0 : _a31.extractMetadata) == null ? void 0 : _b27.call(_a31, {
          parsedBody
        });
        const content = [];
        const reasoningText = (_c = choice2.message.reasoning_content) != null ? _c : choice2.message.reasoning;
        if (reasoningText) {
          content.push({
            type: "reasoning",
            text: reasoningText
          });
        }
        if (choice2.message.content) {
          content.push({
            type: "text",
            text: choice2.message.content
          });
        }
        if (choice2.message.tool_calls) {
          for (const toolCall of choice2.message.tool_calls) {
            content.push({
              type: "tool-call",
              toolCallId: (_d = toolCall.id) != null ? _d : (0, import_provider_utils310.generateId)(),
              toolName: toolCall.function.name,
              input: toolCall.function.arguments
            });
          }
        }
        return {
          content,
          finishReason: mapQwenFinishReason(choice2.finish_reason),
          usage: buildUsage(
            (_f = (_e = responseBody.usage) == null ? void 0 : _e.prompt_tokens) != null ? _f : void 0,
            (_h = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens) != null ? _h : void 0
          ),
          ...providerMetadata && { providerMetadata },
          request: { body },
          response: {
            ...getResponseMetadata8(responseBody),
            headers: responseHeaders,
            body: parsedBody
          },
          warnings
        };
      }
      /**
       * Returns a stream of model responses (V3).
       * @param options - Stream generation options.
       * @returns A promise resolving with the stream and additional metadata.
       */
      async doStream(options) {
        var _a31;
        if (this.settings.simulateStreaming) {
          const result = await this.doGenerate(options);
          const simulatedStream = new ReadableStream({
            start(controller) {
              controller.enqueue({
                type: "stream-start",
                warnings: result.warnings
              });
              if (result.response) {
                controller.enqueue({
                  type: "response-metadata",
                  id: result.response.id,
                  timestamp: result.response.timestamp,
                  modelId: result.response.modelId
                });
              }
              for (const part of result.content) {
                if (part.type === "reasoning") {
                  const id = (0, import_provider_utils310.generateId)();
                  controller.enqueue({ type: "reasoning-start", id });
                  controller.enqueue({
                    type: "reasoning-delta",
                    id,
                    delta: part.text
                  });
                  controller.enqueue({ type: "reasoning-end", id });
                } else if (part.type === "text") {
                  const id = (0, import_provider_utils310.generateId)();
                  controller.enqueue({ type: "text-start", id });
                  controller.enqueue({ type: "text-delta", id, delta: part.text });
                  controller.enqueue({ type: "text-end", id });
                } else if (part.type === "tool-call") {
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: part.toolCallId,
                    toolName: part.toolName,
                    input: part.input
                  });
                }
              }
              controller.enqueue({
                type: "finish",
                finishReason: result.finishReason,
                usage: result.usage,
                providerMetadata: result.providerMetadata
              });
              controller.close();
            }
          });
          return {
            stream: simulatedStream,
            request: result.request,
            response: result.response ? { headers: result.response.headers } : void 0
          };
        }
        const { args, warnings } = this.getArgs(options);
        const requestBody = {
          ...args,
          stream: true,
          stream_options: {
            include_usage: true
          }
        };
        const body = JSON.stringify(requestBody);
        const metadataExtractor = (_a31 = this.config.metadataExtractor) == null ? void 0 : _a31.createStreamExtractor();
        const sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
        const shouldRetryQwenStreamRequest = (error73) => {
          var _a211;
          if (!import_provider210.APICallError.isInstance(error73))
            return false;
          if (error73.statusCode !== 500)
            return false;
          const message = String((_a211 = error73.message) != null ? _a211 : "");
          return message.includes("list index out of range") && (message.includes("InternalServerError") || message.toLowerCase().includes("internal server error"));
        };
        const request = () => (0, import_provider_utils310.postJsonToApi)({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: (0, import_provider_utils310.combineHeaders)(this.config.headers(), options.headers),
          body: requestBody,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: (0, import_provider_utils310.createEventSourceResponseHandler)(
            this.chunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const maxRetries = 3;
        let responseHeaders;
        let response;
        for (let attempt = 0; attempt <= maxRetries; attempt++) {
          try {
            const result = await request();
            responseHeaders = result.responseHeaders;
            response = result.value;
            break;
          } catch (error73) {
            if (attempt === maxRetries || !shouldRetryQwenStreamRequest(error73)) {
              throw error73;
            }
            await sleep(100 * (attempt + 1));
          }
        }
        const toolCalls = [];
        let finishReason = { unified: "other", raw: void 0 };
        let usage = buildUsage(void 0, void 0);
        let isFirstChunk = true;
        let hasStreamStarted = false;
        let textId;
        let reasoningId;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              transform(chunk, controller) {
                var _a211, _b27, _c, _d, _e, _f;
                if (!chunk.success) {
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                metadataExtractor == null ? void 0 : metadataExtractor.processChunk(chunk.rawValue);
                if ((value == null ? void 0 : value.object) === "error") {
                  const message = value == null ? void 0 : value.message;
                  const isQwenListIndexOutOfRange = typeof message === "string" && message.includes("list index out of range") && (message.includes("InternalServerError") || message.toLowerCase().includes("internal server error") || message.includes("500"));
                  if (isQwenListIndexOutOfRange) {
                    let recoveredAny = false;
                    for (let i = 0; i < toolCalls.length; i++) {
                      const toolCall = toolCalls[i];
                      if (toolCall == null || toolCall.hasFinished)
                        continue;
                      const recovered = recoverToolCallArguments(toolCall.arguments);
                      if (recovered == null)
                        continue;
                      toolCall.arguments = recovered;
                      const parsed = parseToolCallArguments(recovered);
                      if (parsed == null)
                        continue;
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: toolCall.id,
                        toolName: toolCall.name,
                        input: toolCall.arguments
                      });
                      toolCall.hasFinished = true;
                      recoveredAny = true;
                    }
                    if (recoveredAny) {
                      finishReason = { unified: "tool-calls", raw: "tool_calls" };
                      return;
                    }
                  }
                  controller.enqueue({ type: "error", error: value.message });
                  return;
                }
                if (!hasStreamStarted) {
                  hasStreamStarted = true;
                  controller.enqueue({
                    type: "stream-start",
                    warnings
                  });
                }
                if (isFirstChunk) {
                  isFirstChunk = false;
                  const metadata = getResponseMetadata8(value);
                  controller.enqueue({
                    type: "response-metadata",
                    id: metadata.id,
                    timestamp: metadata.timestamp,
                    modelId: metadata.modelId
                  });
                }
                if (value.usage != null) {
                  usage = buildUsage(
                    value.usage.prompt_tokens,
                    value.usage.completion_tokens
                  );
                }
                const choice2 = value.choices[0];
                if ((choice2 == null ? void 0 : choice2.finish_reason) != null) {
                  finishReason = mapQwenFinishReason(choice2.finish_reason);
                }
                const delta = choice2 == null ? void 0 : choice2.delta;
                if (delta == null)
                  return;
                const reasoningText = (_a211 = delta.reasoning_content) != null ? _a211 : delta.reasoning;
                if (reasoningText != null) {
                  if (!reasoningId) {
                    reasoningId = (0, import_provider_utils310.generateId)();
                    controller.enqueue({
                      type: "reasoning-start",
                      id: reasoningId
                    });
                  }
                  controller.enqueue({
                    type: "reasoning-delta",
                    id: reasoningId,
                    delta: reasoningText
                  });
                }
                if (delta.content != null) {
                  if (!textId) {
                    textId = (0, import_provider_utils310.generateId)();
                    controller.enqueue({ type: "text-start", id: textId });
                  }
                  controller.enqueue({
                    type: "text-delta",
                    id: textId,
                    delta: delta.content
                  });
                }
                if (delta.tool_calls != null) {
                  for (const toolCallDelta of delta.tool_calls) {
                    const index = toolCallDelta.index;
                    if (toolCalls[index] == null) {
                      if (toolCallDelta.type !== "function") {
                        throw new import_provider210.InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'function' type.`
                        });
                      }
                      if (toolCallDelta.id == null) {
                        throw new import_provider210.InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'id' to be a string.`
                        });
                      }
                      if (((_b27 = toolCallDelta.function) == null ? void 0 : _b27.name) == null) {
                        throw new import_provider210.InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'function.name' to be a string.`
                        });
                      }
                      toolCalls[index] = {
                        id: toolCallDelta.id,
                        name: toolCallDelta.function.name,
                        arguments: (_c = toolCallDelta.function.arguments) != null ? _c : "",
                        hasFinished: false
                      };
                      const toolCall2 = toolCalls[index];
                      controller.enqueue({
                        type: "tool-input-start",
                        id: toolCall2.id,
                        toolName: toolCall2.name
                      });
                      if (toolCall2.arguments.length > 0) {
                        controller.enqueue({
                          type: "tool-input-delta",
                          id: toolCall2.id,
                          delta: toolCall2.arguments
                        });
                      }
                      const parsed2 = parseToolCallArguments(toolCall2.arguments);
                      if (parsed2 != null) {
                        controller.enqueue({
                          type: "tool-input-end",
                          id: toolCall2.id
                        });
                        controller.enqueue({
                          type: "tool-call",
                          toolCallId: toolCall2.id,
                          toolName: toolCall2.name,
                          input: toolCall2.arguments
                        });
                        toolCall2.hasFinished = true;
                      }
                      continue;
                    }
                    const toolCall = toolCalls[index];
                    if (toolCall.hasFinished) {
                      continue;
                    }
                    if (((_d = toolCallDelta.function) == null ? void 0 : _d.arguments) != null) {
                      toolCall.arguments += toolCallDelta.function.arguments;
                    }
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.id,
                      delta: (_f = (_e = toolCallDelta.function) == null ? void 0 : _e.arguments) != null ? _f : ""
                    });
                    const parsed = parseToolCallArguments(toolCall.arguments);
                    if (parsed != null) {
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: toolCall.id,
                        toolName: toolCall.name,
                        input: toolCall.arguments
                      });
                      toolCall.hasFinished = true;
                    }
                  }
                }
              },
              flush(controller) {
                if (textId) {
                  controller.enqueue({ type: "text-end", id: textId });
                }
                if (reasoningId) {
                  controller.enqueue({ type: "reasoning-end", id: reasoningId });
                }
                for (let i = 0; i < toolCalls.length; i++) {
                  const toolCall = toolCalls[i];
                  if (toolCall == null || toolCall.hasFinished)
                    continue;
                  if (parseToolCallArguments(toolCall.arguments) == null)
                    continue;
                  controller.enqueue({
                    type: "tool-input-end",
                    id: toolCall.id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: toolCall.id,
                    toolName: toolCall.name,
                    input: toolCall.arguments
                  });
                  toolCall.hasFinished = true;
                }
                const metadata = metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata();
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage,
                  ...metadata && { providerMetadata: metadata }
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    function createQwenChatChunkSchema(errorSchema) {
      return import_zod210.z.union([
        import_zod210.z.object({
          id: import_zod210.z.string().nullish(),
          created: import_zod210.z.number().nullish(),
          model: import_zod210.z.string().nullish(),
          choices: import_zod210.z.array(
            import_zod210.z.object({
              delta: import_zod210.z.object({
                role: import_zod210.z.enum(["assistant"]).nullish(),
                content: import_zod210.z.string().nullish(),
                reasoning_content: import_zod210.z.string().nullish(),
                reasoning: import_zod210.z.string().nullish(),
                tool_calls: import_zod210.z.array(
                  import_zod210.z.object({
                    index: import_zod210.z.number(),
                    id: import_zod210.z.string().nullish(),
                    type: import_zod210.z.literal("function").nullish(),
                    function: import_zod210.z.object({
                      name: import_zod210.z.string().nullish(),
                      arguments: import_zod210.z.string().nullish()
                    })
                  })
                ).nullish()
              }).nullish(),
              finish_reason: import_zod210.z.string().nullish()
            })
          ),
          usage: import_zod210.z.object({
            prompt_tokens: import_zod210.z.number().nullish(),
            completion_tokens: import_zod210.z.number().nullish()
          }).nullish()
        }),
        errorSchema
      ]);
    }
    function parseToolCallArguments(rawArguments) {
      const trimmed = rawArguments.trim();
      if (trimmed.length === 0)
        return null;
      const isObjectLike2 = trimmed.startsWith("{") || trimmed.startsWith("[");
      const hasClosing = trimmed.endsWith("}") || trimmed.endsWith("]");
      if (!isObjectLike2 || !hasClosing)
        return null;
      if (!(0, import_provider_utils310.isParsableJson)(trimmed))
        return null;
      try {
        return JSON.parse(trimmed);
      } catch (e) {
        return null;
      }
    }
    function recoverToolCallArguments(rawArguments) {
      const trimmedEnd = rawArguments.trimEnd();
      if (trimmedEnd.length === 0)
        return null;
      if (trimmedEnd.endsWith("}"))
        return rawArguments;
      const recovered = `${trimmedEnd}}`;
      return recovered;
    }
    var import_provider410 = require_dist6();
    var import_provider_utils410 = require_dist8();
    var import_zod310 = require_zod();
    var import_provider310 = require_dist6();
    function convertToQwenCompletionPrompt({
      prompt,
      inputFormat,
      user = "user",
      assistant = "assistant"
    }) {
      if (inputFormat === "prompt" && prompt.length === 1 && prompt[0].role === "user" && prompt[0].content.length === 1 && prompt[0].content[0].type === "text") {
        return { prompt: prompt[0].content[0].text };
      }
      let text2 = "";
      if (prompt[0].role === "system") {
        const systemContent = prompt[0].content;
        if (typeof systemContent === "string") {
          text2 += `${systemContent}

`;
        } else if (Array.isArray(systemContent)) {
          const systemText = systemContent.map((part) => {
            var _a31;
            if ((part == null ? void 0 : part.type) === "text") {
              return part.text;
            }
            throw new import_provider310.UnsupportedFunctionalityError({
              functionality: `system message ${(_a31 = part == null ? void 0 : part.type) != null ? _a31 : "unknown"} content parts`
            });
          }).join("");
          text2 += `${systemText}

`;
        } else {
          text2 += `${String(systemContent)}

`;
        }
        prompt = prompt.slice(1);
      }
      for (const { role, content } of prompt) {
        switch (role) {
          case "system": {
            throw new import_provider310.InvalidPromptError({
              message: `Unexpected system message in prompt: ${content}`,
              prompt
            });
          }
          case "user": {
            const userMessage = content.map((part) => {
              switch (part.type) {
                case "text": {
                  return part.text;
                }
                case "file": {
                  throw new import_provider310.UnsupportedFunctionalityError({
                    functionality: "file content parts"
                  });
                }
                default: {
                  const _exhaustiveCheck = part;
                  throw new Error(
                    `Unsupported content part type: ${_exhaustiveCheck}`
                  );
                }
              }
            }).join("");
            text2 += `${user}:
${userMessage}

`;
            break;
          }
          case "assistant": {
            const assistantMessage = content.map((part) => {
              switch (part.type) {
                case "text": {
                  return part.text;
                }
                case "tool-call": {
                  throw new import_provider310.UnsupportedFunctionalityError({
                    functionality: "tool-call messages"
                  });
                }
                case "reasoning": {
                  return "";
                }
                case "file":
                case "tool-result": {
                  throw new import_provider310.UnsupportedFunctionalityError({
                    functionality: `${part.type} messages`
                  });
                }
                default: {
                  const _exhaustiveCheck = part;
                  throw new Error(
                    `Unsupported content part type: ${_exhaustiveCheck}`
                  );
                }
              }
            }).join("");
            text2 += `${assistant}:
${assistantMessage}

`;
            break;
          }
          case "tool": {
            throw new import_provider310.UnsupportedFunctionalityError({
              functionality: "tool messages"
            });
          }
          default: {
            const _exhaustiveCheck = role;
            throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
          }
        }
      }
      text2 += `${assistant}:
`;
      return {
        prompt: text2,
        stopSequences: [`
${user}:`]
      };
    }
    var QwenCompletionResponseSchema = import_zod310.z.object({
      id: import_zod310.z.string().nullish(),
      created: import_zod310.z.number().nullish(),
      model: import_zod310.z.string().nullish(),
      choices: import_zod310.z.array(
        import_zod310.z.object({
          text: import_zod310.z.string(),
          finish_reason: import_zod310.z.string()
        })
      ),
      usage: import_zod310.z.object({
        prompt_tokens: import_zod310.z.number(),
        completion_tokens: import_zod310.z.number()
      }).nullish()
    });
    var QwenCompletionLanguageModel = class {
      // type inferred via constructor
      /**
       * Creates an instance of QwenCompletionLanguageModel.
       *
       * @param modelId - The model identifier.
       * @param settings - The settings specific for Qwen completions.
       * @param config - The configuration object which includes provider options and error handling.
       */
      constructor(modelId, settings, config3) {
        this.specificationVersion = "v3";
        this.supportedUrls = {};
        var _a31;
        this.modelId = modelId;
        this.settings = settings;
        this.config = config3;
        const errorStructure = (_a31 = config3.errorStructure) != null ? _a31 : defaultQwenErrorStructure;
        this.chunkSchema = createQwenCompletionChunkSchema(
          errorStructure.errorSchema
        );
        this.failedResponseHandler = (0, import_provider_utils410.createJsonErrorResponseHandler)(errorStructure);
      }
      get provider() {
        return this.config.provider;
      }
      get providerOptionsName() {
        return this.config.provider.split(".")[0].trim();
      }
      /**
       * Generates the arguments for invoking the LanguageModelV3 doGenerate method.
       */
      getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        stopSequences: userStopSequences,
        responseFormat,
        seed,
        providerOptions,
        tools,
        toolChoice
      }) {
        const warnings = [];
        if (topK != null) {
          warnings.push({
            type: "unsupported",
            feature: "topK"
          });
        }
        if (responseFormat != null && responseFormat.type !== "text") {
          warnings.push({
            type: "unsupported",
            feature: "responseFormat",
            details: "JSON response format is not supported."
          });
        }
        if (tools && tools.length > 0) {
          throw new import_provider410.UnsupportedFunctionalityError({
            functionality: "tools"
          });
        }
        if (toolChoice) {
          throw new import_provider410.UnsupportedFunctionalityError({
            functionality: "toolChoice"
          });
        }
        const { prompt: completionPrompt, stopSequences } = convertToQwenCompletionPrompt({ prompt, inputFormat: "prompt" });
        const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
        const args = {
          // Model id and settings:
          model: this.modelId,
          echo: this.settings.echo,
          logit_bias: this.settings.logitBias,
          suffix: this.settings.suffix,
          user: this.settings.user,
          // Standardized settings:
          max_tokens: maxOutputTokens,
          temperature,
          top_p: topP,
          frequency_penalty: frequencyPenalty,
          presence_penalty: presencePenalty,
          seed,
          ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
          // Prompt and stop sequences:
          prompt: completionPrompt,
          stop: stop.length > 0 ? stop : void 0
        };
        return { args, warnings };
      }
      /**
       * Generates a completion response (V3).
       *
       * @param options - Generation options including prompt and parameters.
       * @returns A promise resolving the generated content, usage, finish status, and metadata.
       */
      async doGenerate(options) {
        var _a31, _b27;
        const { args, warnings } = this.getArgs(options);
        const {
          responseHeaders,
          value: response,
          rawValue: parsedBody
        } = await (0, import_provider_utils410.postJsonToApi)({
          url: this.config.url({
            path: "/completions",
            modelId: this.modelId
          }),
          headers: (0, import_provider_utils410.combineHeaders)(this.config.headers(), options.headers),
          body: args,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: (0, import_provider_utils410.createJsonResponseHandler)(
            QwenCompletionResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const choice2 = response.choices[0];
        const content = [];
        if (choice2.text) {
          content.push({
            type: "text",
            text: choice2.text
          });
        }
        return {
          content,
          finishReason: mapQwenFinishReason(choice2.finish_reason),
          usage: buildUsage(
            (_a31 = response.usage) == null ? void 0 : _a31.prompt_tokens,
            (_b27 = response.usage) == null ? void 0 : _b27.completion_tokens
          ),
          response: {
            ...getResponseMetadata8(response),
            headers: responseHeaders,
            body: parsedBody
          },
          warnings,
          request: { body: JSON.stringify(args) }
        };
      }
      /**
       * Streams a completion response (V3).
       *
       * @param options - Generation options including prompt and parameters.
       * @returns A promise resolving a stream of response parts and metadata.
       */
      async doStream(options) {
        const { args, warnings } = this.getArgs(options);
        const body = {
          ...args,
          stream: true
        };
        const { responseHeaders, value: response } = await (0, import_provider_utils410.postJsonToApi)({
          url: this.config.url({
            path: "/completions",
            modelId: this.modelId
          }),
          headers: (0, import_provider_utils410.combineHeaders)(this.config.headers(), options.headers),
          body,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: (0, import_provider_utils410.createEventSourceResponseHandler)(
            this.chunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        let finishReason = { unified: "other", raw: void 0 };
        let usage = buildUsage(void 0, void 0);
        let isFirstChunk = true;
        let hasStreamStarted = false;
        let textId;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              transform(chunk, controller) {
                if (!chunk.success) {
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                if ((value == null ? void 0 : value.object) === "error") {
                  controller.enqueue({ type: "error", error: value.message });
                  return;
                }
                if (!hasStreamStarted) {
                  hasStreamStarted = true;
                  controller.enqueue({
                    type: "stream-start",
                    warnings
                  });
                }
                if (isFirstChunk) {
                  isFirstChunk = false;
                  const metadata = getResponseMetadata8(value);
                  controller.enqueue({
                    type: "response-metadata",
                    id: metadata.id,
                    timestamp: metadata.timestamp,
                    modelId: metadata.modelId
                  });
                }
                if (value.usage != null) {
                  usage = buildUsage(
                    value.usage.prompt_tokens,
                    value.usage.completion_tokens
                  );
                }
                const choice2 = value.choices[0];
                if ((choice2 == null ? void 0 : choice2.finish_reason) != null) {
                  finishReason = mapQwenFinishReason(choice2.finish_reason);
                }
                if ((choice2 == null ? void 0 : choice2.text) != null) {
                  if (!textId) {
                    textId = (0, import_provider_utils410.generateId)();
                    controller.enqueue({ type: "text-start", id: textId });
                  }
                  controller.enqueue({
                    type: "text-delta",
                    id: textId,
                    delta: choice2.text
                  });
                }
              },
              flush(controller) {
                if (textId) {
                  controller.enqueue({ type: "text-end", id: textId });
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage
                });
              }
            })
          ),
          request: { body: JSON.stringify(body) },
          response: { headers: responseHeaders }
        };
      }
    };
    function createQwenCompletionChunkSchema(errorSchema) {
      return import_zod310.z.union([
        import_zod310.z.object({
          id: import_zod310.z.string().nullish(),
          created: import_zod310.z.number().nullish(),
          model: import_zod310.z.string().nullish(),
          choices: import_zod310.z.array(
            import_zod310.z.object({
              text: import_zod310.z.string(),
              finish_reason: import_zod310.z.string().nullish(),
              index: import_zod310.z.number()
            })
          ),
          usage: import_zod310.z.object({
            prompt_tokens: import_zod310.z.number(),
            completion_tokens: import_zod310.z.number()
          }).nullish()
        }),
        errorSchema
      ]);
    }
    var import_provider510 = require_dist6();
    var import_provider_utils510 = require_dist8();
    var import_zod410 = require_zod();
    var qwenTextEmbeddingResponseSchema = import_zod410.z.object({
      data: import_zod410.z.array(import_zod410.z.object({ embedding: import_zod410.z.array(import_zod410.z.number()) })),
      usage: import_zod410.z.object({ prompt_tokens: import_zod410.z.number() }).nullish()
    });
    var QwenEmbeddingModel = class {
      constructor(modelId, settings, config3) {
        this.specificationVersion = "v3";
        this.modelId = modelId;
        this.settings = settings;
        this.config = config3;
      }
      get provider() {
        return this.config.provider;
      }
      get maxEmbeddingsPerCall() {
        var _a31;
        return (_a31 = this.config.maxEmbeddingsPerCall) != null ? _a31 : 2048;
      }
      get supportsParallelCalls() {
        var _a31;
        return (_a31 = this.config.supportsParallelCalls) != null ? _a31 : true;
      }
      /**
       * Sends a request to the Qwen API to generate embeddings for the provided text inputs (V3).
       *
       * @param param0 - The parameters object.
       * @param param0.values - An array of strings to be embedded.
       * @param param0.headers - Optional HTTP headers for the API request.
       * @param param0.abortSignal - Optional signal to abort the API request.
       * @param param0.providerOptions - Additional provider-specific options.
       * @returns A promise that resolves with an object containing embeddings, usage, and response metadata.
       *
       * @throws TooManyEmbeddingValuesForCallError if the number of input values exceeds the maximum allowed.
       */
      async doEmbed({
        values,
        headers,
        abortSignal,
        providerOptions
      }) {
        var _a31, _b27;
        const maxEmbeddings = (_a31 = this.maxEmbeddingsPerCall) != null ? _a31 : Number.POSITIVE_INFINITY;
        if (values.length > maxEmbeddings) {
          throw new import_provider510.TooManyEmbeddingValuesForCallError({
            provider: this.provider,
            modelId: this.modelId,
            maxEmbeddingsPerCall: maxEmbeddings,
            values
          });
        }
        const providerOptionsName = this.config.provider.split(".")[0].trim();
        const specificProviderOptions = providerOptions == null ? void 0 : providerOptions[providerOptionsName];
        const { responseHeaders, value: response } = await (0, import_provider_utils510.postJsonToApi)({
          url: this.config.url({
            path: "/embeddings",
            modelId: this.modelId
          }),
          headers: (0, import_provider_utils510.combineHeaders)(this.config.headers(), headers),
          body: {
            model: this.modelId,
            input: values,
            encoding_format: "float",
            dimensions: this.settings.dimensions,
            user: this.settings.user,
            ...specificProviderOptions
          },
          // Handle response errors using the provided error structure.
          failedResponseHandler: (0, import_provider_utils510.createJsonErrorResponseHandler)(
            (_b27 = this.config.errorStructure) != null ? _b27 : defaultQwenErrorStructure
          ),
          // Process successful responses based on a minimal schema.
          successfulResponseHandler: (0, import_provider_utils510.createJsonResponseHandler)(
            qwenTextEmbeddingResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        return {
          embeddings: response.data.map((item) => item.embedding),
          usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
          response: { headers: responseHeaders },
          warnings: []
        };
      }
    };
    var import_provider_utils610 = require_dist8();
    var import_zod510 = require_zod();
    var dashscopeRerankingResponseSchema = import_zod510.z.object({
      output: import_zod510.z.object({
        results: import_zod510.z.array(
          import_zod510.z.object({
            index: import_zod510.z.number(),
            relevance_score: import_zod510.z.number(),
            document: import_zod510.z.object({
              text: import_zod510.z.string()
            }).nullish()
          })
        )
      }),
      usage: import_zod510.z.object({
        total_tokens: import_zod510.z.number().optional()
      }).optional(),
      request_id: import_zod510.z.string().optional()
    });
    var openaiCompatibleRerankingResponseSchema = import_zod510.z.object({
      results: import_zod510.z.array(
        import_zod510.z.object({
          index: import_zod510.z.number(),
          relevance_score: import_zod510.z.number(),
          document: import_zod510.z.object({
            text: import_zod510.z.string()
          }).nullish()
        })
      ),
      usage: import_zod510.z.object({
        total_tokens: import_zod510.z.number().optional()
      }).optional(),
      id: import_zod510.z.string().optional()
    });
    function usesOpenAICompatibleAPI(modelId) {
      return modelId.startsWith("qwen3-rerank");
    }
    var QwenRerankingModel = class {
      constructor(modelId, settings, config3) {
        this.specificationVersion = "v3";
        this.modelId = modelId;
        this.settings = settings;
        this.config = config3;
      }
      get provider() {
        return this.config.provider;
      }
      /**
       * Reranks documents based on their relevance to the query.
       *
       * @param options - The reranking options.
       * @param options.documents - Documents to rerank (text or objects).
       * @param options.query - The query to rank documents against.
       * @param options.topN - Optional limit on number of results.
       * @param options.headers - Optional HTTP headers.
       * @param options.abortSignal - Optional abort signal.
       * @param options.providerOptions - Additional provider-specific options.
       * @returns Promise with ranking results sorted by relevance.
       */
      async doRerank(options) {
        const { documents, query, topN, headers, abortSignal, providerOptions } = options;
        const documentTexts = documents.type === "text" ? documents.values : documents.values.map((doc) => JSON.stringify(doc));
        const providerOptionsName = this.config.provider.split(".")[0].trim();
        const specificProviderOptions = providerOptions == null ? void 0 : providerOptions[providerOptionsName];
        const isOpenAICompatible = usesOpenAICompatibleAPI(this.modelId);
        if (isOpenAICompatible) {
          return this.doRerankOpenAICompatible({
            documentTexts,
            query,
            topN,
            headers,
            abortSignal,
            specificProviderOptions
          });
        } else {
          return this.doRerankDashScope({
            documentTexts,
            query,
            topN,
            headers,
            abortSignal,
            specificProviderOptions
          });
        }
      }
      /**
       * Rerank using OpenAI-compatible API format (for qwen3-rerank).
       * Endpoint: /compatible-mode/v1/rerank
       */
      async doRerankOpenAICompatible(options) {
        var _a31;
        const {
          documentTexts,
          query,
          topN,
          headers,
          abortSignal,
          specificProviderOptions
        } = options;
        const body = {
          model: this.modelId,
          documents: documentTexts,
          query,
          ...specificProviderOptions
        };
        if (topN != null) {
          body.top_n = topN;
        }
        if (this.settings.instruct != null) {
          body.instruct = this.settings.instruct;
        }
        const url4 = `${this.config.baseURL}/compatible-api/v1/reranks`;
        const { responseHeaders, value: response } = await (0, import_provider_utils610.postJsonToApi)({
          url: url4,
          headers: (0, import_provider_utils610.combineHeaders)(this.config.headers(), headers),
          body,
          failedResponseHandler: (0, import_provider_utils610.createJsonErrorResponseHandler)(
            (_a31 = this.config.errorStructure) != null ? _a31 : defaultQwenErrorStructure
          ),
          successfulResponseHandler: (0, import_provider_utils610.createJsonResponseHandler)(
            openaiCompatibleRerankingResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        return {
          ranking: response.results.map((result) => ({
            index: result.index,
            relevanceScore: result.relevance_score
          })),
          response: {
            id: response.id,
            headers: responseHeaders
          },
          warnings: []
        };
      }
      /**
       * Rerank using DashScope native API format (for gte-rerank models).
       * Endpoint: /api/v1/services/rerank/text-rerank/text-rerank
       */
      async doRerankDashScope(options) {
        var _a31;
        const {
          documentTexts,
          query,
          topN,
          headers,
          abortSignal,
          specificProviderOptions
        } = options;
        const parameters = {};
        if (topN != null) {
          parameters.top_n = topN;
        }
        if (this.settings.returnDocuments != null) {
          parameters.return_documents = this.settings.returnDocuments;
        }
        const body = {
          model: this.modelId,
          input: {
            query,
            documents: documentTexts
          },
          parameters,
          ...specificProviderOptions
        };
        const url4 = `${this.config.baseURL}/api/v1/services/rerank/text-rerank/text-rerank`;
        const { responseHeaders, value: response } = await (0, import_provider_utils610.postJsonToApi)({
          url: url4,
          headers: (0, import_provider_utils610.combineHeaders)(this.config.headers(), headers),
          body,
          failedResponseHandler: (0, import_provider_utils610.createJsonErrorResponseHandler)(
            (_a31 = this.config.errorStructure) != null ? _a31 : defaultQwenErrorStructure
          ),
          successfulResponseHandler: (0, import_provider_utils610.createJsonResponseHandler)(
            dashscopeRerankingResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        return {
          ranking: response.output.results.map((result) => ({
            index: result.index,
            relevanceScore: result.relevance_score
          })),
          response: {
            id: response.request_id,
            headers: responseHeaders
          },
          warnings: []
        };
      }
    };
    function createQwen2(options = {}) {
      var _a31;
      const baseURL = (0, import_provider_utils710.withoutTrailingSlash)(
        (_a31 = options.baseURL) != null ? _a31 : "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
      );
      const getHeaders = () => ({
        Authorization: `Bearer ${(0, import_provider_utils710.loadApiKey)({
          apiKey: options.apiKey,
          environmentVariableName: "DASHSCOPE_API_KEY",
          description: "Qwen API key"
        })}`,
        ...options.headers
      });
      const getCommonModelConfig = (modelType) => ({
        provider: `qwen.${modelType}`,
        url: ({ path: path33 }) => {
          const url4 = new URL(`${baseURL}${path33}`);
          if (options.queryParams) {
            url4.search = new URLSearchParams(options.queryParams).toString();
          }
          return url4.toString();
        },
        headers: getHeaders,
        fetch: options.fetch
      });
      const createChatModel = (modelId, settings = {}) => new QwenChatLanguageModel(modelId, settings, getCommonModelConfig("chat"));
      const createCompletionModel = (modelId, settings = {}) => new QwenCompletionLanguageModel(
        modelId,
        settings,
        getCommonModelConfig("completion")
      );
      const createTextEmbeddingModel = (modelId, settings = {}) => new QwenEmbeddingModel(
        modelId,
        settings,
        getCommonModelConfig("embedding")
      );
      const createRerankingModel = (modelId, settings = {}) => {
        const rerankBaseURL = (baseURL != null ? baseURL : "https://dashscope-intl.aliyuncs.com/compatible-mode/v1").replace(/\/compatible-mode\/v1$/, "");
        return new QwenRerankingModel(modelId, settings, {
          provider: "qwen.reranking",
          baseURL: rerankBaseURL,
          headers: getHeaders,
          fetch: options.fetch
        });
      };
      const provider = (modelId, settings) => createChatModel(modelId, settings);
      provider.chatModel = createChatModel;
      provider.completion = createCompletionModel;
      provider.embeddingModel = createTextEmbeddingModel;
      provider.textEmbeddingModel = createTextEmbeddingModel;
      provider.rerankingModel = createRerankingModel;
      provider.languageModel = createChatModel;
      return provider;
    }
    var qwen = createQwen2();
  }
});

// node_modules/@ai-sdk/google/dist/index.mjs
function convertGoogleGenerativeAIUsage(usage) {
  var _a31, _b27, _c, _d;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = (_a31 = usage.promptTokenCount) != null ? _a31 : 0;
  const candidatesTokens = (_b27 = usage.candidatesTokenCount) != null ? _b27 : 0;
  const cachedContentTokens = (_c = usage.cachedContentTokenCount) != null ? _c : 0;
  const thoughtsTokens = (_d = usage.thoughtsTokenCount) != null ? _d : 0;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens - cachedContentTokens,
      cacheRead: cachedContentTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: candidatesTokens + thoughtsTokens,
      text: candidatesTokens,
      reasoning: thoughtsTokens
    },
    raw: usage
  };
}
function convertJSONSchemaToOpenAPISchema(jsonSchema4, isRoot = true) {
  if (jsonSchema4 == null) {
    return void 0;
  }
  if (isEmptyObjectSchema(jsonSchema4)) {
    if (isRoot) {
      return void 0;
    }
    if (typeof jsonSchema4 === "object" && jsonSchema4.description) {
      return { type: "object", description: jsonSchema4.description };
    }
    return { type: "object" };
  }
  if (typeof jsonSchema4 === "boolean") {
    return { type: "boolean", properties: {} };
  }
  const {
    type,
    description,
    required: required3,
    properties,
    items,
    allOf,
    anyOf,
    oneOf,
    format,
    const: constValue,
    minLength,
    enum: enumValues
  } = jsonSchema4;
  const result = {};
  if (description) result.description = description;
  if (required3) result.required = required3;
  if (format) result.format = format;
  if (constValue !== void 0) {
    result.enum = [constValue];
  }
  if (type) {
    if (Array.isArray(type)) {
      const hasNull = type.includes("null");
      const nonNullTypes = type.filter((t) => t !== "null");
      if (nonNullTypes.length === 0) {
        result.type = "null";
      } else {
        result.anyOf = nonNullTypes.map((t) => ({ type: t }));
        if (hasNull) {
          result.nullable = true;
        }
      }
    } else {
      result.type = type;
    }
  }
  if (enumValues !== void 0) {
    result.enum = enumValues;
  }
  if (properties != null) {
    result.properties = Object.entries(properties).reduce(
      (acc, [key, value]) => {
        acc[key] = convertJSONSchemaToOpenAPISchema(value, false);
        return acc;
      },
      {}
    );
  }
  if (items) {
    result.items = Array.isArray(items) ? items.map((item) => convertJSONSchemaToOpenAPISchema(item, false)) : convertJSONSchemaToOpenAPISchema(items, false);
  }
  if (allOf) {
    result.allOf = allOf.map(
      (item) => convertJSONSchemaToOpenAPISchema(item, false)
    );
  }
  if (anyOf) {
    if (anyOf.some(
      (schema) => typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null"
    )) {
      const nonNullSchemas = anyOf.filter(
        (schema) => !(typeof schema === "object" && (schema == null ? void 0 : schema.type) === "null")
      );
      if (nonNullSchemas.length === 1) {
        const converted = convertJSONSchemaToOpenAPISchema(
          nonNullSchemas[0],
          false
        );
        if (typeof converted === "object") {
          result.nullable = true;
          Object.assign(result, converted);
        }
      } else {
        result.anyOf = nonNullSchemas.map(
          (item) => convertJSONSchemaToOpenAPISchema(item, false)
        );
        result.nullable = true;
      }
    } else {
      result.anyOf = anyOf.map(
        (item) => convertJSONSchemaToOpenAPISchema(item, false)
      );
    }
  }
  if (oneOf) {
    result.oneOf = oneOf.map(
      (item) => convertJSONSchemaToOpenAPISchema(item, false)
    );
  }
  if (minLength !== void 0) {
    result.minLength = minLength;
  }
  return result;
}
function isEmptyObjectSchema(jsonSchema4) {
  return jsonSchema4 != null && typeof jsonSchema4 === "object" && jsonSchema4.type === "object" && (jsonSchema4.properties == null || Object.keys(jsonSchema4.properties).length === 0) && !jsonSchema4.additionalProperties;
}
function parseBase64DataUrl(value) {
  const match = dataUrlRegex.exec(value);
  if (match == null) {
    return void 0;
  }
  return {
    mediaType: match[1],
    data: match[2]
  };
}
function convertUrlToolResultPart(url4) {
  const parsedDataUrl = parseBase64DataUrl(url4);
  if (parsedDataUrl == null) {
    return void 0;
  }
  return {
    inlineData: {
      mimeType: parsedDataUrl.mediaType,
      data: parsedDataUrl.data
    }
  };
}
function appendToolResultParts(parts, toolName, outputValue) {
  const functionResponseParts = [];
  const responseTextParts = [];
  for (const contentPart of outputValue) {
    switch (contentPart.type) {
      case "text": {
        responseTextParts.push(contentPart.text);
        break;
      }
      case "image-data":
      case "file-data": {
        functionResponseParts.push({
          inlineData: {
            mimeType: contentPart.mediaType,
            data: contentPart.data
          }
        });
        break;
      }
      case "image-url":
      case "file-url": {
        const functionResponsePart = convertUrlToolResultPart(
          contentPart.url
        );
        if (functionResponsePart != null) {
          functionResponseParts.push(functionResponsePart);
        } else {
          responseTextParts.push(JSON.stringify(contentPart));
        }
        break;
      }
      default: {
        responseTextParts.push(JSON.stringify(contentPart));
        break;
      }
    }
  }
  parts.push({
    functionResponse: {
      name: toolName,
      response: {
        name: toolName,
        content: responseTextParts.length > 0 ? responseTextParts.join("\n") : "Tool executed successfully."
      },
      ...functionResponseParts.length > 0 ? { parts: functionResponseParts } : {}
    }
  });
}
function appendLegacyToolResultParts(parts, toolName, outputValue) {
  for (const contentPart of outputValue) {
    switch (contentPart.type) {
      case "text":
        parts.push({
          functionResponse: {
            name: toolName,
            response: {
              name: toolName,
              content: contentPart.text
            }
          }
        });
        break;
      case "image-data":
        parts.push(
          {
            inlineData: {
              mimeType: String(contentPart.mediaType),
              data: String(contentPart.data)
            }
          },
          {
            text: "Tool executed successfully and returned this image as a response"
          }
        );
        break;
      default:
        parts.push({ text: JSON.stringify(contentPart) });
        break;
    }
  }
}
function convertToGoogleGenerativeAIMessages(prompt, options) {
  var _a31, _b27, _c, _d;
  const systemInstructionParts = [];
  const contents = [];
  let systemMessagesAllowed = true;
  const isGemmaModel = (_a31 = options == null ? void 0 : options.isGemmaModel) != null ? _a31 : false;
  const providerOptionsName = (_b27 = options == null ? void 0 : options.providerOptionsName) != null ? _b27 : "google";
  const supportsFunctionResponseParts = (_c = options == null ? void 0 : options.supportsFunctionResponseParts) != null ? _c : true;
  for (const { role, content } of prompt) {
    switch (role) {
      case "system": {
        if (!systemMessagesAllowed) {
          throw new UnsupportedFunctionalityError({
            functionality: "system messages are only supported at the beginning of the conversation"
          });
        }
        systemInstructionParts.push({ text: content });
        break;
      }
      case "user": {
        systemMessagesAllowed = false;
        const parts = [];
        for (const part of content) {
          switch (part.type) {
            case "text": {
              parts.push({ text: part.text });
              break;
            }
            case "file": {
              const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
              parts.push(
                part.data instanceof URL ? {
                  fileData: {
                    mimeType: mediaType,
                    fileUri: part.data.toString()
                  }
                } : {
                  inlineData: {
                    mimeType: mediaType,
                    data: convertToBase64(part.data)
                  }
                }
              );
              break;
            }
          }
        }
        contents.push({ role: "user", parts });
        break;
      }
      case "assistant": {
        systemMessagesAllowed = false;
        contents.push({
          role: "model",
          parts: content.map((part) => {
            var _a211, _b28, _c2, _d2;
            const providerOpts = (_d2 = (_a211 = part.providerOptions) == null ? void 0 : _a211[providerOptionsName]) != null ? _d2 : providerOptionsName !== "google" ? (_b28 = part.providerOptions) == null ? void 0 : _b28.google : (_c2 = part.providerOptions) == null ? void 0 : _c2.vertex;
            const thoughtSignature = (providerOpts == null ? void 0 : providerOpts.thoughtSignature) != null ? String(providerOpts.thoughtSignature) : void 0;
            switch (part.type) {
              case "text": {
                return part.text.length === 0 ? void 0 : {
                  text: part.text,
                  thoughtSignature
                };
              }
              case "reasoning": {
                return part.text.length === 0 ? void 0 : {
                  text: part.text,
                  thought: true,
                  thoughtSignature
                };
              }
              case "file": {
                if (part.data instanceof URL) {
                  throw new UnsupportedFunctionalityError({
                    functionality: "File data URLs in assistant messages are not supported"
                  });
                }
                return {
                  inlineData: {
                    mimeType: part.mediaType,
                    data: convertToBase64(part.data)
                  },
                  ...(providerOpts == null ? void 0 : providerOpts.thought) === true ? { thought: true } : {},
                  thoughtSignature
                };
              }
              case "tool-call": {
                return {
                  functionCall: {
                    name: part.toolName,
                    args: part.input
                  },
                  thoughtSignature
                };
              }
            }
          }).filter((part) => part !== void 0)
        });
        break;
      }
      case "tool": {
        systemMessagesAllowed = false;
        const parts = [];
        for (const part of content) {
          if (part.type === "tool-approval-response") {
            continue;
          }
          const output = part.output;
          if (output.type === "content") {
            if (supportsFunctionResponseParts) {
              appendToolResultParts(parts, part.toolName, output.value);
            } else {
              appendLegacyToolResultParts(parts, part.toolName, output.value);
            }
          } else {
            parts.push({
              functionResponse: {
                name: part.toolName,
                response: {
                  name: part.toolName,
                  content: output.type === "execution-denied" ? (_d = output.reason) != null ? _d : "Tool execution denied." : output.value
                }
              }
            });
          }
        }
        contents.push({
          role: "user",
          parts
        });
        break;
      }
    }
  }
  if (isGemmaModel && systemInstructionParts.length > 0 && contents.length > 0 && contents[0].role === "user") {
    const systemText = systemInstructionParts.map((part) => part.text).join("\n\n");
    contents[0].parts.unshift({ text: systemText + "\n\n" });
  }
  return {
    systemInstruction: systemInstructionParts.length > 0 && !isGemmaModel ? { parts: systemInstructionParts } : void 0,
    contents
  };
}
function getModelPath(modelId) {
  return modelId.includes("/") ? modelId : `models/${modelId}`;
}
function prepareTools2({
  tools,
  toolChoice,
  modelId
}) {
  var _a31;
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  const isLatest = [
    "gemini-flash-latest",
    "gemini-flash-lite-latest",
    "gemini-pro-latest"
  ].some((id) => id === modelId);
  const isGemini2orNewer = modelId.includes("gemini-2") || modelId.includes("gemini-3") || modelId.includes("nano-banana") || isLatest;
  const supportsFileSearch = modelId.includes("gemini-2.5") || modelId.includes("gemini-3");
  if (tools == null) {
    return { tools: void 0, toolConfig: void 0, toolWarnings };
  }
  const hasFunctionTools = tools.some((tool3) => tool3.type === "function");
  const hasProviderTools = tools.some((tool3) => tool3.type === "provider");
  if (hasFunctionTools && hasProviderTools) {
    toolWarnings.push({
      type: "unsupported",
      feature: `combination of function and provider-defined tools`
    });
  }
  if (hasProviderTools) {
    const googleTools2 = [];
    const ProviderTools = tools.filter((tool3) => tool3.type === "provider");
    ProviderTools.forEach((tool3) => {
      switch (tool3.id) {
        case "google.google_search":
          if (isGemini2orNewer) {
            googleTools2.push({ googleSearch: { ...tool3.args } });
          } else {
            toolWarnings.push({
              type: "unsupported",
              feature: `provider-defined tool ${tool3.id}`,
              details: "Google Search requires Gemini 2.0 or newer."
            });
          }
          break;
        case "google.enterprise_web_search":
          if (isGemini2orNewer) {
            googleTools2.push({ enterpriseWebSearch: {} });
          } else {
            toolWarnings.push({
              type: "unsupported",
              feature: `provider-defined tool ${tool3.id}`,
              details: "Enterprise Web Search requires Gemini 2.0 or newer."
            });
          }
          break;
        case "google.url_context":
          if (isGemini2orNewer) {
            googleTools2.push({ urlContext: {} });
          } else {
            toolWarnings.push({
              type: "unsupported",
              feature: `provider-defined tool ${tool3.id}`,
              details: "The URL context tool is not supported with other Gemini models than Gemini 2."
            });
          }
          break;
        case "google.code_execution":
          if (isGemini2orNewer) {
            googleTools2.push({ codeExecution: {} });
          } else {
            toolWarnings.push({
              type: "unsupported",
              feature: `provider-defined tool ${tool3.id}`,
              details: "The code execution tools is not supported with other Gemini models than Gemini 2."
            });
          }
          break;
        case "google.file_search":
          if (supportsFileSearch) {
            googleTools2.push({ fileSearch: { ...tool3.args } });
          } else {
            toolWarnings.push({
              type: "unsupported",
              feature: `provider-defined tool ${tool3.id}`,
              details: "The file search tool is only supported with Gemini 2.5 models and Gemini 3 models."
            });
          }
          break;
        case "google.vertex_rag_store":
          if (isGemini2orNewer) {
            googleTools2.push({
              retrieval: {
                vertex_rag_store: {
                  rag_resources: {
                    rag_corpus: tool3.args.ragCorpus
                  },
                  similarity_top_k: tool3.args.topK
                }
              }
            });
          } else {
            toolWarnings.push({
              type: "unsupported",
              feature: `provider-defined tool ${tool3.id}`,
              details: "The RAG store tool is not supported with other Gemini models than Gemini 2."
            });
          }
          break;
        case "google.google_maps":
          if (isGemini2orNewer) {
            googleTools2.push({ googleMaps: {} });
          } else {
            toolWarnings.push({
              type: "unsupported",
              feature: `provider-defined tool ${tool3.id}`,
              details: "The Google Maps grounding tool is not supported with Gemini models other than Gemini 2 or newer."
            });
          }
          break;
        default:
          toolWarnings.push({
            type: "unsupported",
            feature: `provider-defined tool ${tool3.id}`
          });
          break;
      }
    });
    return {
      tools: googleTools2.length > 0 ? googleTools2 : void 0,
      toolConfig: void 0,
      toolWarnings
    };
  }
  const functionDeclarations = [];
  let hasStrictTools = false;
  for (const tool3 of tools) {
    switch (tool3.type) {
      case "function":
        functionDeclarations.push({
          name: tool3.name,
          description: (_a31 = tool3.description) != null ? _a31 : "",
          parameters: convertJSONSchemaToOpenAPISchema(tool3.inputSchema)
        });
        if (tool3.strict === true) {
          hasStrictTools = true;
        }
        break;
      default:
        toolWarnings.push({
          type: "unsupported",
          feature: `function tool ${tool3.name}`
        });
        break;
    }
  }
  if (toolChoice == null) {
    return {
      tools: [{ functionDeclarations }],
      toolConfig: hasStrictTools ? { functionCallingConfig: { mode: "VALIDATED" } } : void 0,
      toolWarnings
    };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
      return {
        tools: [{ functionDeclarations }],
        toolConfig: {
          functionCallingConfig: {
            mode: hasStrictTools ? "VALIDATED" : "AUTO"
          }
        },
        toolWarnings
      };
    case "none":
      return {
        tools: [{ functionDeclarations }],
        toolConfig: { functionCallingConfig: { mode: "NONE" } },
        toolWarnings
      };
    case "required":
      return {
        tools: [{ functionDeclarations }],
        toolConfig: {
          functionCallingConfig: {
            mode: hasStrictTools ? "VALIDATED" : "ANY"
          }
        },
        toolWarnings
      };
    case "tool":
      return {
        tools: [{ functionDeclarations }],
        toolConfig: {
          functionCallingConfig: {
            mode: hasStrictTools ? "VALIDATED" : "ANY",
            allowedFunctionNames: [toolChoice.toolName]
          }
        },
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new UnsupportedFunctionalityError({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
function mapGoogleGenerativeAIFinishReason({
  finishReason,
  hasToolCalls
}) {
  switch (finishReason) {
    case "STOP":
      return hasToolCalls ? "tool-calls" : "stop";
    case "MAX_TOKENS":
      return "length";
    case "IMAGE_SAFETY":
    case "RECITATION":
    case "SAFETY":
    case "BLOCKLIST":
    case "PROHIBITED_CONTENT":
    case "SPII":
      return "content-filter";
    case "MALFORMED_FUNCTION_CALL":
      return "error";
    case "FINISH_REASON_UNSPECIFIED":
    case "OTHER":
    default:
      return "other";
  }
}
function getToolCallsFromParts({
  parts,
  generateId: generateId32,
  providerOptionsName
}) {
  const functionCallParts = parts == null ? void 0 : parts.filter(
    (part) => "functionCall" in part
  );
  return functionCallParts == null || functionCallParts.length === 0 ? void 0 : functionCallParts.map((part) => ({
    type: "tool-call",
    toolCallId: generateId32(),
    toolName: part.functionCall.name,
    args: JSON.stringify(part.functionCall.args),
    providerMetadata: part.thoughtSignature ? {
      [providerOptionsName]: {
        thoughtSignature: part.thoughtSignature
      }
    } : void 0
  }));
}
function extractSources({
  groundingMetadata,
  generateId: generateId32
}) {
  var _a31, _b27, _c, _d, _e, _f;
  if (!(groundingMetadata == null ? void 0 : groundingMetadata.groundingChunks)) {
    return void 0;
  }
  const sources = [];
  for (const chunk of groundingMetadata.groundingChunks) {
    if (chunk.web != null) {
      sources.push({
        type: "source",
        sourceType: "url",
        id: generateId32(),
        url: chunk.web.uri,
        title: (_a31 = chunk.web.title) != null ? _a31 : void 0
      });
    } else if (chunk.image != null) {
      sources.push({
        type: "source",
        sourceType: "url",
        id: generateId32(),
        // Google requires attribution to the source URI, not the actual image URI.
        // TODO: add another type in v7 to allow both the image and source URL to be included separately
        url: chunk.image.sourceUri,
        title: (_b27 = chunk.image.title) != null ? _b27 : void 0
      });
    } else if (chunk.retrievedContext != null) {
      const uri = chunk.retrievedContext.uri;
      const fileSearchStore = chunk.retrievedContext.fileSearchStore;
      if (uri && (uri.startsWith("http://") || uri.startsWith("https://"))) {
        sources.push({
          type: "source",
          sourceType: "url",
          id: generateId32(),
          url: uri,
          title: (_c = chunk.retrievedContext.title) != null ? _c : void 0
        });
      } else if (uri) {
        const title = (_d = chunk.retrievedContext.title) != null ? _d : "Unknown Document";
        let mediaType = "application/octet-stream";
        let filename = void 0;
        if (uri.endsWith(".pdf")) {
          mediaType = "application/pdf";
          filename = uri.split("/").pop();
        } else if (uri.endsWith(".txt")) {
          mediaType = "text/plain";
          filename = uri.split("/").pop();
        } else if (uri.endsWith(".docx")) {
          mediaType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
          filename = uri.split("/").pop();
        } else if (uri.endsWith(".doc")) {
          mediaType = "application/msword";
          filename = uri.split("/").pop();
        } else if (uri.match(/\.(md|markdown)$/)) {
          mediaType = "text/markdown";
          filename = uri.split("/").pop();
        } else {
          filename = uri.split("/").pop();
        }
        sources.push({
          type: "source",
          sourceType: "document",
          id: generateId32(),
          mediaType,
          title,
          filename
        });
      } else if (fileSearchStore) {
        const title = (_e = chunk.retrievedContext.title) != null ? _e : "Unknown Document";
        sources.push({
          type: "source",
          sourceType: "document",
          id: generateId32(),
          mediaType: "application/octet-stream",
          title,
          filename: fileSearchStore.split("/").pop()
        });
      }
    } else if (chunk.maps != null) {
      if (chunk.maps.uri) {
        sources.push({
          type: "source",
          sourceType: "url",
          id: generateId32(),
          url: chunk.maps.uri,
          title: (_f = chunk.maps.title) != null ? _f : void 0
        });
      }
    }
  }
  return sources.length > 0 ? sources : void 0;
}
function isGeminiModel(modelId) {
  return modelId.startsWith("gemini-");
}
function createGoogleGenerativeAI(options = {}) {
  var _a31, _b27;
  const baseURL = (_a31 = withoutTrailingSlash(options.baseURL)) != null ? _a31 : "https://generativelanguage.googleapis.com/v1beta";
  const providerName = (_b27 = options.name) != null ? _b27 : "google.generative-ai";
  const getHeaders = () => withUserAgentSuffix(
    {
      "x-goog-api-key": loadApiKey({
        apiKey: options.apiKey,
        environmentVariableName: "GOOGLE_GENERATIVE_AI_API_KEY",
        description: "Google Generative AI"
      }),
      ...options.headers
    },
    `ai-sdk/google/${VERSION7}`
  );
  const createChatModel = (modelId) => {
    var _a211;
    return new GoogleGenerativeAILanguageModel(modelId, {
      provider: providerName,
      baseURL,
      headers: getHeaders,
      generateId: (_a211 = options.generateId) != null ? _a211 : generateId,
      supportedUrls: () => ({
        "*": [
          // Google Generative Language "files" endpoint
          // e.g. https://generativelanguage.googleapis.com/v1beta/files/...
          new RegExp(`^${baseURL}/files/.*$`),
          // YouTube URLs (public or unlisted videos)
          new RegExp(
            `^https://(?:www\\.)?youtube\\.com/watch\\?v=[\\w-]+(?:&[\\w=&.-]*)?$`
          ),
          new RegExp(`^https://youtu\\.be/[\\w-]+(?:\\?[\\w=&.-]*)?$`)
        ]
      }),
      fetch: options.fetch
    });
  };
  const createEmbeddingModel = (modelId) => new GoogleGenerativeAIEmbeddingModel(modelId, {
    provider: providerName,
    baseURL,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createImageModel = (modelId, settings = {}) => new GoogleGenerativeAIImageModel(modelId, settings, {
    provider: providerName,
    baseURL,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createVideoModel = (modelId) => {
    var _a211;
    return new GoogleGenerativeAIVideoModel(modelId, {
      provider: providerName,
      baseURL,
      headers: getHeaders,
      fetch: options.fetch,
      generateId: (_a211 = options.generateId) != null ? _a211 : generateId
    });
  };
  const provider = function(modelId) {
    if (new.target) {
      throw new Error(
        "The Google Generative AI model function cannot be called with the new keyword."
      );
    }
    return createChatModel(modelId);
  };
  provider.specificationVersion = "v3";
  provider.languageModel = createChatModel;
  provider.chat = createChatModel;
  provider.generativeAI = createChatModel;
  provider.embedding = createEmbeddingModel;
  provider.embeddingModel = createEmbeddingModel;
  provider.textEmbedding = createEmbeddingModel;
  provider.textEmbeddingModel = createEmbeddingModel;
  provider.image = createImageModel;
  provider.imageModel = createImageModel;
  provider.video = createVideoModel;
  provider.videoModel = createVideoModel;
  provider.tools = googleTools;
  return provider;
}
var VERSION7, googleErrorDataSchema, googleFailedResponseHandler, googleEmbeddingContentPartSchema, googleEmbeddingModelOptions, GoogleGenerativeAIEmbeddingModel, googleGenerativeAITextEmbeddingResponseSchema, googleGenerativeAISingleEmbeddingResponseSchema, dataUrlRegex, googleLanguageModelOptions, GoogleGenerativeAILanguageModel, getGroundingMetadataSchema, getContentSchema, getSafetyRatingSchema, usageSchema, getUrlContextMetadataSchema, responseSchema, chunkSchema, codeExecution, enterpriseWebSearch, fileSearchArgsBaseSchema, fileSearchArgsSchema2, fileSearch2, googleMaps, googleSearchToolArgsBaseSchema, googleSearchToolArgsSchema, googleSearch, urlContext, vertexRagStore, googleTools, GoogleGenerativeAIImageModel, googleImageResponseSchema, googleImageModelOptionsSchema, GoogleGenerativeAIVideoModel, googleOperationSchema, googleVideoModelOptionsSchema, google;
var init_dist12 = __esm({
  "node_modules/@ai-sdk/google/dist/index.mjs"() {
    "use strict";
    init_dist5();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    VERSION7 = true ? "3.0.54" : "0.0.0-test";
    googleErrorDataSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          error: external_exports.object({
            code: external_exports.number().nullable(),
            message: external_exports.string(),
            status: external_exports.string()
          })
        })
      )
    );
    googleFailedResponseHandler = createJsonErrorResponseHandler({
      errorSchema: googleErrorDataSchema,
      errorToMessage: (data) => data.error.message
    });
    googleEmbeddingContentPartSchema = external_exports.union([
      external_exports.object({ text: external_exports.string() }),
      external_exports.object({
        inlineData: external_exports.object({
          mimeType: external_exports.string(),
          data: external_exports.string()
        })
      })
    ]);
    googleEmbeddingModelOptions = lazySchema(
      () => zodSchema(
        external_exports.object({
          /**
           * Optional. Optional reduced dimension for the output embedding.
           * If set, excessive values in the output embedding are truncated from the end.
           */
          outputDimensionality: external_exports.number().optional(),
          /**
           * Optional. Specifies the task type for generating embeddings.
           * Supported task types:
           * - SEMANTIC_SIMILARITY: Optimized for text similarity.
           * - CLASSIFICATION: Optimized for text classification.
           * - CLUSTERING: Optimized for clustering texts based on similarity.
           * - RETRIEVAL_DOCUMENT: Optimized for document retrieval.
           * - RETRIEVAL_QUERY: Optimized for query-based retrieval.
           * - QUESTION_ANSWERING: Optimized for answering questions.
           * - FACT_VERIFICATION: Optimized for verifying factual information.
           * - CODE_RETRIEVAL_QUERY: Optimized for retrieving code blocks based on natural language queries.
           */
          taskType: external_exports.enum([
            "SEMANTIC_SIMILARITY",
            "CLASSIFICATION",
            "CLUSTERING",
            "RETRIEVAL_DOCUMENT",
            "RETRIEVAL_QUERY",
            "QUESTION_ANSWERING",
            "FACT_VERIFICATION",
            "CODE_RETRIEVAL_QUERY"
          ]).optional(),
          /**
           * Optional. Per-value multimodal content parts for embedding non-text
           * content (images, video, PDF, audio). Each entry corresponds to the
           * embedding value at the same index and its parts are merged with the
           * text value in the request. Use `null` for entries that are text-only.
           *
           * The array length must match the number of values being embedded. In
           * the case of a single embedding, the array length must be 1.
           */
          content: external_exports.array(external_exports.array(googleEmbeddingContentPartSchema).min(1).nullable()).optional()
        })
      )
    );
    GoogleGenerativeAIEmbeddingModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.maxEmbeddingsPerCall = 2048;
        this.supportsParallelCalls = true;
        this.modelId = modelId;
        this.config = config3;
      }
      get provider() {
        return this.config.provider;
      }
      async doEmbed({
        values,
        headers,
        abortSignal,
        providerOptions
      }) {
        const googleOptions = await parseProviderOptions({
          provider: "google",
          providerOptions,
          schema: googleEmbeddingModelOptions
        });
        if (values.length > this.maxEmbeddingsPerCall) {
          throw new TooManyEmbeddingValuesForCallError({
            provider: this.provider,
            modelId: this.modelId,
            maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
            values
          });
        }
        const mergedHeaders = combineHeaders(
          await resolve(this.config.headers),
          headers
        );
        const multimodalContent = googleOptions == null ? void 0 : googleOptions.content;
        if (multimodalContent != null && multimodalContent.length !== values.length) {
          throw new Error(
            `The number of multimodal content entries (${multimodalContent.length}) must match the number of values (${values.length}).`
          );
        }
        if (values.length === 1) {
          const valueParts = multimodalContent == null ? void 0 : multimodalContent[0];
          const textPart = values[0] ? [{ text: values[0] }] : [];
          const parts = valueParts != null ? [...textPart, ...valueParts] : [{ text: values[0] }];
          const {
            responseHeaders: responseHeaders2,
            value: response2,
            rawValue: rawValue2
          } = await postJsonToApi({
            url: `${this.config.baseURL}/models/${this.modelId}:embedContent`,
            headers: mergedHeaders,
            body: {
              model: `models/${this.modelId}`,
              content: {
                parts
              },
              outputDimensionality: googleOptions == null ? void 0 : googleOptions.outputDimensionality,
              taskType: googleOptions == null ? void 0 : googleOptions.taskType
            },
            failedResponseHandler: googleFailedResponseHandler,
            successfulResponseHandler: createJsonResponseHandler(
              googleGenerativeAISingleEmbeddingResponseSchema
            ),
            abortSignal,
            fetch: this.config.fetch
          });
          return {
            warnings: [],
            embeddings: [response2.embedding.values],
            usage: void 0,
            response: { headers: responseHeaders2, body: rawValue2 }
          };
        }
        const {
          responseHeaders,
          value: response,
          rawValue
        } = await postJsonToApi({
          url: `${this.config.baseURL}/models/${this.modelId}:batchEmbedContents`,
          headers: mergedHeaders,
          body: {
            requests: values.map((value, index) => {
              const valueParts = multimodalContent == null ? void 0 : multimodalContent[index];
              const textPart = value ? [{ text: value }] : [];
              return {
                model: `models/${this.modelId}`,
                content: {
                  role: "user",
                  parts: valueParts != null ? [...textPart, ...valueParts] : [{ text: value }]
                },
                outputDimensionality: googleOptions == null ? void 0 : googleOptions.outputDimensionality,
                taskType: googleOptions == null ? void 0 : googleOptions.taskType
              };
            })
          },
          failedResponseHandler: googleFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            googleGenerativeAITextEmbeddingResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        return {
          warnings: [],
          embeddings: response.embeddings.map((item) => item.values),
          usage: void 0,
          response: { headers: responseHeaders, body: rawValue }
        };
      }
    };
    googleGenerativeAITextEmbeddingResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          embeddings: external_exports.array(external_exports.object({ values: external_exports.array(external_exports.number()) }))
        })
      )
    );
    googleGenerativeAISingleEmbeddingResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          embedding: external_exports.object({ values: external_exports.array(external_exports.number()) })
        })
      )
    );
    dataUrlRegex = /^data:([^;,]+);base64,(.+)$/s;
    googleLanguageModelOptions = lazySchema(
      () => zodSchema(
        external_exports.object({
          responseModalities: external_exports.array(external_exports.enum(["TEXT", "IMAGE"])).optional(),
          thinkingConfig: external_exports.object({
            thinkingBudget: external_exports.number().optional(),
            includeThoughts: external_exports.boolean().optional(),
            // https://ai.google.dev/gemini-api/docs/gemini-3?thinking=high#thinking_level
            thinkingLevel: external_exports.enum(["minimal", "low", "medium", "high"]).optional()
          }).optional(),
          /**
           * Optional.
           * The name of the cached content used as context to serve the prediction.
           * Format: cachedContents/{cachedContent}
           */
          cachedContent: external_exports.string().optional(),
          /**
           * Optional. Enable structured output. Default is true.
           *
           * This is useful when the JSON Schema contains elements that are
           * not supported by the OpenAPI schema version that
           * Google Generative AI uses. You can use this to disable
           * structured outputs if you need to.
           */
          structuredOutputs: external_exports.boolean().optional(),
          /**
           * Optional. A list of unique safety settings for blocking unsafe content.
           */
          safetySettings: external_exports.array(
            external_exports.object({
              category: external_exports.enum([
                "HARM_CATEGORY_UNSPECIFIED",
                "HARM_CATEGORY_HATE_SPEECH",
                "HARM_CATEGORY_DANGEROUS_CONTENT",
                "HARM_CATEGORY_HARASSMENT",
                "HARM_CATEGORY_SEXUALLY_EXPLICIT",
                "HARM_CATEGORY_CIVIC_INTEGRITY"
              ]),
              threshold: external_exports.enum([
                "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
                "BLOCK_LOW_AND_ABOVE",
                "BLOCK_MEDIUM_AND_ABOVE",
                "BLOCK_ONLY_HIGH",
                "BLOCK_NONE",
                "OFF"
              ])
            })
          ).optional(),
          threshold: external_exports.enum([
            "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
            "BLOCK_LOW_AND_ABOVE",
            "BLOCK_MEDIUM_AND_ABOVE",
            "BLOCK_ONLY_HIGH",
            "BLOCK_NONE",
            "OFF"
          ]).optional(),
          /**
           * Optional. Enables timestamp understanding for audio-only files.
           *
           * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
           */
          audioTimestamp: external_exports.boolean().optional(),
          /**
           * Optional. Defines labels used in billing reports. Available on Vertex AI only.
           *
           * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/add-labels-to-api-calls
           */
          labels: external_exports.record(external_exports.string(), external_exports.string()).optional(),
          /**
           * Optional. If specified, the media resolution specified will be used.
           *
           * https://ai.google.dev/api/generate-content#MediaResolution
           */
          mediaResolution: external_exports.enum([
            "MEDIA_RESOLUTION_UNSPECIFIED",
            "MEDIA_RESOLUTION_LOW",
            "MEDIA_RESOLUTION_MEDIUM",
            "MEDIA_RESOLUTION_HIGH"
          ]).optional(),
          /**
           * Optional. Configures the image generation aspect ratio for Gemini models.
           *
           * https://ai.google.dev/gemini-api/docs/image-generation#aspect_ratios
           */
          imageConfig: external_exports.object({
            aspectRatio: external_exports.enum([
              "1:1",
              "2:3",
              "3:2",
              "3:4",
              "4:3",
              "4:5",
              "5:4",
              "9:16",
              "16:9",
              "21:9",
              "1:8",
              "8:1",
              "1:4",
              "4:1"
            ]).optional(),
            imageSize: external_exports.enum(["1K", "2K", "4K", "512"]).optional()
          }).optional(),
          /**
           * Optional. Configuration for grounding retrieval.
           * Used to provide location context for Google Maps and Google Search grounding.
           *
           * https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-maps
           */
          retrievalConfig: external_exports.object({
            latLng: external_exports.object({
              latitude: external_exports.number(),
              longitude: external_exports.number()
            }).optional()
          }).optional(),
          /**
           * Optional. The service tier to use for the request.
           */
          serviceTier: external_exports.enum([
            "SERVICE_TIER_STANDARD",
            "SERVICE_TIER_FLEX",
            "SERVICE_TIER_PRIORITY"
          ]).optional()
        })
      )
    );
    GoogleGenerativeAILanguageModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        var _a31;
        this.modelId = modelId;
        this.config = config3;
        this.generateId = (_a31 = config3.generateId) != null ? _a31 : generateId;
      }
      get provider() {
        return this.config.provider;
      }
      get supportedUrls() {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).supportedUrls) == null ? void 0 : _b27.call(_a31)) != null ? _c : {};
      }
      async getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        stopSequences,
        responseFormat,
        seed,
        tools,
        toolChoice,
        providerOptions
      }) {
        var _a31;
        const warnings = [];
        const providerOptionsName = this.config.provider.includes("vertex") ? "vertex" : "google";
        let googleOptions = await parseProviderOptions({
          provider: providerOptionsName,
          providerOptions,
          schema: googleLanguageModelOptions
        });
        if (googleOptions == null && providerOptionsName !== "google") {
          googleOptions = await parseProviderOptions({
            provider: "google",
            providerOptions,
            schema: googleLanguageModelOptions
          });
        }
        if ((tools == null ? void 0 : tools.some(
          (tool3) => tool3.type === "provider" && tool3.id === "google.vertex_rag_store"
        )) && !this.config.provider.startsWith("google.vertex.")) {
          warnings.push({
            type: "other",
            message: `The 'vertex_rag_store' tool is only supported with the Google Vertex provider and might not be supported or could behave unexpectedly with the current Google provider (${this.config.provider}).`
          });
        }
        const isGemmaModel = this.modelId.toLowerCase().startsWith("gemma-");
        const supportsFunctionResponseParts = this.modelId.startsWith("gemini-3");
        const { contents, systemInstruction } = convertToGoogleGenerativeAIMessages(
          prompt,
          {
            isGemmaModel,
            providerOptionsName,
            supportsFunctionResponseParts
          }
        );
        const {
          tools: googleTools2,
          toolConfig: googleToolConfig,
          toolWarnings
        } = prepareTools2({
          tools,
          toolChoice,
          modelId: this.modelId
        });
        return {
          args: {
            generationConfig: {
              // standardized settings:
              maxOutputTokens,
              temperature,
              topK,
              topP,
              frequencyPenalty,
              presencePenalty,
              stopSequences,
              seed,
              // response format:
              responseMimeType: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? "application/json" : void 0,
              responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
              // so this is needed as an escape hatch:
              // TODO convert into provider option
              ((_a31 = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _a31 : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
              ...(googleOptions == null ? void 0 : googleOptions.audioTimestamp) && {
                audioTimestamp: googleOptions.audioTimestamp
              },
              // provider options:
              responseModalities: googleOptions == null ? void 0 : googleOptions.responseModalities,
              thinkingConfig: googleOptions == null ? void 0 : googleOptions.thinkingConfig,
              ...(googleOptions == null ? void 0 : googleOptions.mediaResolution) && {
                mediaResolution: googleOptions.mediaResolution
              },
              ...(googleOptions == null ? void 0 : googleOptions.imageConfig) && {
                imageConfig: googleOptions.imageConfig
              }
            },
            contents,
            systemInstruction: isGemmaModel ? void 0 : systemInstruction,
            safetySettings: googleOptions == null ? void 0 : googleOptions.safetySettings,
            tools: googleTools2,
            toolConfig: (googleOptions == null ? void 0 : googleOptions.retrievalConfig) ? {
              ...googleToolConfig,
              retrievalConfig: googleOptions.retrievalConfig
            } : googleToolConfig,
            cachedContent: googleOptions == null ? void 0 : googleOptions.cachedContent,
            labels: googleOptions == null ? void 0 : googleOptions.labels,
            serviceTier: googleOptions == null ? void 0 : googleOptions.serviceTier
          },
          warnings: [...warnings, ...toolWarnings],
          providerOptionsName
        };
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
        const { args, warnings, providerOptionsName } = await this.getArgs(options);
        const mergedHeaders = combineHeaders(
          await resolve(this.config.headers),
          options.headers
        );
        const {
          responseHeaders,
          value: response,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: `${this.config.baseURL}/${getModelPath(
            this.modelId
          )}:generateContent`,
          headers: mergedHeaders,
          body: args,
          failedResponseHandler: googleFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(responseSchema),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const candidate = response.candidates[0];
        const content = [];
        const parts = (_b27 = (_a31 = candidate.content) == null ? void 0 : _a31.parts) != null ? _b27 : [];
        const usageMetadata = response.usageMetadata;
        let lastCodeExecutionToolCallId;
        for (const part of parts) {
          if ("executableCode" in part && ((_c = part.executableCode) == null ? void 0 : _c.code)) {
            const toolCallId = this.config.generateId();
            lastCodeExecutionToolCallId = toolCallId;
            content.push({
              type: "tool-call",
              toolCallId,
              toolName: "code_execution",
              input: JSON.stringify(part.executableCode),
              providerExecuted: true
            });
          } else if ("codeExecutionResult" in part && part.codeExecutionResult) {
            content.push({
              type: "tool-result",
              // Assumes a result directly follows its corresponding call part.
              toolCallId: lastCodeExecutionToolCallId,
              toolName: "code_execution",
              result: {
                outcome: part.codeExecutionResult.outcome,
                output: (_d = part.codeExecutionResult.output) != null ? _d : ""
              }
            });
            lastCodeExecutionToolCallId = void 0;
          } else if ("text" in part && part.text != null) {
            const thoughtSignatureMetadata = part.thoughtSignature ? {
              [providerOptionsName]: {
                thoughtSignature: part.thoughtSignature
              }
            } : void 0;
            if (part.text.length === 0) {
              if (thoughtSignatureMetadata != null && content.length > 0) {
                const lastContent = content[content.length - 1];
                lastContent.providerMetadata = thoughtSignatureMetadata;
              }
            } else {
              content.push({
                type: part.thought === true ? "reasoning" : "text",
                text: part.text,
                providerMetadata: thoughtSignatureMetadata
              });
            }
          } else if ("functionCall" in part) {
            content.push({
              type: "tool-call",
              toolCallId: this.config.generateId(),
              toolName: part.functionCall.name,
              input: JSON.stringify(part.functionCall.args),
              providerMetadata: part.thoughtSignature ? {
                [providerOptionsName]: {
                  thoughtSignature: part.thoughtSignature
                }
              } : void 0
            });
          } else if ("inlineData" in part) {
            const hasThought = part.thought === true;
            const hasThoughtSignature = !!part.thoughtSignature;
            content.push({
              type: "file",
              data: part.inlineData.data,
              mediaType: part.inlineData.mimeType,
              providerMetadata: hasThought || hasThoughtSignature ? {
                [providerOptionsName]: {
                  ...hasThought ? { thought: true } : {},
                  ...hasThoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
                }
              } : void 0
            });
          }
        }
        const sources = (_e = extractSources({
          groundingMetadata: candidate.groundingMetadata,
          generateId: this.config.generateId
        })) != null ? _e : [];
        for (const source of sources) {
          content.push(source);
        }
        return {
          content,
          finishReason: {
            unified: mapGoogleGenerativeAIFinishReason({
              finishReason: candidate.finishReason,
              // Only count client-executed tool calls for finish reason determination.
              hasToolCalls: content.some(
                (part) => part.type === "tool-call" && !part.providerExecuted
              )
            }),
            raw: (_f = candidate.finishReason) != null ? _f : void 0
          },
          usage: convertGoogleGenerativeAIUsage(usageMetadata),
          warnings,
          providerMetadata: {
            [providerOptionsName]: {
              promptFeedback: (_g = response.promptFeedback) != null ? _g : null,
              groundingMetadata: (_h = candidate.groundingMetadata) != null ? _h : null,
              urlContextMetadata: (_i = candidate.urlContextMetadata) != null ? _i : null,
              safetyRatings: (_j = candidate.safetyRatings) != null ? _j : null,
              usageMetadata: usageMetadata != null ? usageMetadata : null,
              finishMessage: (_k = candidate.finishMessage) != null ? _k : null,
              serviceTier: (_l = response.serviceTier) != null ? _l : null
            }
          },
          request: { body: args },
          response: {
            // TODO timestamp, model id, id
            headers: responseHeaders,
            body: rawResponse
          }
        };
      }
      async doStream(options) {
        const { args, warnings, providerOptionsName } = await this.getArgs(options);
        const headers = combineHeaders(
          await resolve(this.config.headers),
          options.headers
        );
        const { responseHeaders, value: response } = await postJsonToApi({
          url: `${this.config.baseURL}/${getModelPath(
            this.modelId
          )}:streamGenerateContent?alt=sse`,
          headers,
          body: args,
          failedResponseHandler: googleFailedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler(chunkSchema),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        let usage = void 0;
        let providerMetadata = void 0;
        let lastGroundingMetadata = null;
        let lastUrlContextMetadata = null;
        let serviceTier = null;
        const generateId32 = this.config.generateId;
        let hasToolCalls = false;
        let currentTextBlockId = null;
        let currentReasoningBlockId = null;
        let blockCounter = 0;
        const emittedSourceUrls = /* @__PURE__ */ new Set();
        let lastCodeExecutionToolCallId;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                var _a31, _b27, _c, _d, _e, _f, _g;
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                const usageMetadata = value.usageMetadata;
                if (usageMetadata != null) {
                  usage = usageMetadata;
                }
                if (value.serviceTier != null) {
                  serviceTier = value.serviceTier;
                }
                const candidate = (_a31 = value.candidates) == null ? void 0 : _a31[0];
                if (candidate == null) {
                  return;
                }
                const content = candidate.content;
                if (candidate.groundingMetadata != null) {
                  lastGroundingMetadata = candidate.groundingMetadata;
                }
                if (candidate.urlContextMetadata != null) {
                  lastUrlContextMetadata = candidate.urlContextMetadata;
                }
                const sources = extractSources({
                  groundingMetadata: candidate.groundingMetadata,
                  generateId: generateId32
                });
                if (sources != null) {
                  for (const source of sources) {
                    if (source.sourceType === "url" && !emittedSourceUrls.has(source.url)) {
                      emittedSourceUrls.add(source.url);
                      controller.enqueue(source);
                    }
                  }
                }
                if (content != null) {
                  const parts = (_b27 = content.parts) != null ? _b27 : [];
                  for (const part of parts) {
                    if ("executableCode" in part && ((_c = part.executableCode) == null ? void 0 : _c.code)) {
                      const toolCallId = generateId32();
                      lastCodeExecutionToolCallId = toolCallId;
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId,
                        toolName: "code_execution",
                        input: JSON.stringify(part.executableCode),
                        providerExecuted: true
                      });
                    } else if ("codeExecutionResult" in part && part.codeExecutionResult) {
                      const toolCallId = lastCodeExecutionToolCallId;
                      if (toolCallId) {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId,
                          toolName: "code_execution",
                          result: {
                            outcome: part.codeExecutionResult.outcome,
                            output: (_d = part.codeExecutionResult.output) != null ? _d : ""
                          }
                        });
                        lastCodeExecutionToolCallId = void 0;
                      }
                    } else if ("text" in part && part.text != null) {
                      const thoughtSignatureMetadata = part.thoughtSignature ? {
                        [providerOptionsName]: {
                          thoughtSignature: part.thoughtSignature
                        }
                      } : void 0;
                      if (part.text.length === 0) {
                        if (thoughtSignatureMetadata != null && currentTextBlockId !== null) {
                          controller.enqueue({
                            type: "text-delta",
                            id: currentTextBlockId,
                            delta: "",
                            providerMetadata: thoughtSignatureMetadata
                          });
                        }
                      } else if (part.thought === true) {
                        if (currentTextBlockId !== null) {
                          controller.enqueue({
                            type: "text-end",
                            id: currentTextBlockId
                          });
                          currentTextBlockId = null;
                        }
                        if (currentReasoningBlockId === null) {
                          currentReasoningBlockId = String(blockCounter++);
                          controller.enqueue({
                            type: "reasoning-start",
                            id: currentReasoningBlockId,
                            providerMetadata: thoughtSignatureMetadata
                          });
                        }
                        controller.enqueue({
                          type: "reasoning-delta",
                          id: currentReasoningBlockId,
                          delta: part.text,
                          providerMetadata: thoughtSignatureMetadata
                        });
                      } else {
                        if (currentReasoningBlockId !== null) {
                          controller.enqueue({
                            type: "reasoning-end",
                            id: currentReasoningBlockId
                          });
                          currentReasoningBlockId = null;
                        }
                        if (currentTextBlockId === null) {
                          currentTextBlockId = String(blockCounter++);
                          controller.enqueue({
                            type: "text-start",
                            id: currentTextBlockId,
                            providerMetadata: thoughtSignatureMetadata
                          });
                        }
                        controller.enqueue({
                          type: "text-delta",
                          id: currentTextBlockId,
                          delta: part.text,
                          providerMetadata: thoughtSignatureMetadata
                        });
                      }
                    } else if ("inlineData" in part) {
                      if (currentTextBlockId !== null) {
                        controller.enqueue({
                          type: "text-end",
                          id: currentTextBlockId
                        });
                        currentTextBlockId = null;
                      }
                      if (currentReasoningBlockId !== null) {
                        controller.enqueue({
                          type: "reasoning-end",
                          id: currentReasoningBlockId
                        });
                        currentReasoningBlockId = null;
                      }
                      const hasThought = part.thought === true;
                      const hasThoughtSignature = !!part.thoughtSignature;
                      const fileMeta = hasThought || hasThoughtSignature ? {
                        [providerOptionsName]: {
                          ...hasThought ? { thought: true } : {},
                          ...hasThoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
                        }
                      } : void 0;
                      controller.enqueue({
                        type: "file",
                        mediaType: part.inlineData.mimeType,
                        data: part.inlineData.data,
                        providerMetadata: fileMeta
                      });
                    }
                  }
                  const toolCallDeltas = getToolCallsFromParts({
                    parts: content.parts,
                    generateId: generateId32,
                    providerOptionsName
                  });
                  if (toolCallDeltas != null) {
                    for (const toolCall of toolCallDeltas) {
                      controller.enqueue({
                        type: "tool-input-start",
                        id: toolCall.toolCallId,
                        toolName: toolCall.toolName,
                        providerMetadata: toolCall.providerMetadata
                      });
                      controller.enqueue({
                        type: "tool-input-delta",
                        id: toolCall.toolCallId,
                        delta: toolCall.args,
                        providerMetadata: toolCall.providerMetadata
                      });
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall.toolCallId,
                        providerMetadata: toolCall.providerMetadata
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: toolCall.toolCallId,
                        toolName: toolCall.toolName,
                        input: toolCall.args,
                        providerMetadata: toolCall.providerMetadata
                      });
                      hasToolCalls = true;
                    }
                  }
                }
                if (candidate.finishReason != null) {
                  finishReason = {
                    unified: mapGoogleGenerativeAIFinishReason({
                      finishReason: candidate.finishReason,
                      hasToolCalls
                    }),
                    raw: candidate.finishReason
                  };
                  providerMetadata = {
                    [providerOptionsName]: {
                      promptFeedback: (_e = value.promptFeedback) != null ? _e : null,
                      groundingMetadata: lastGroundingMetadata,
                      urlContextMetadata: lastUrlContextMetadata,
                      safetyRatings: (_f = candidate.safetyRatings) != null ? _f : null,
                      usageMetadata: usageMetadata != null ? usageMetadata : null,
                      finishMessage: (_g = candidate.finishMessage) != null ? _g : null,
                      serviceTier
                    }
                  };
                }
              },
              flush(controller) {
                if (currentTextBlockId !== null) {
                  controller.enqueue({
                    type: "text-end",
                    id: currentTextBlockId
                  });
                }
                if (currentReasoningBlockId !== null) {
                  controller.enqueue({
                    type: "reasoning-end",
                    id: currentReasoningBlockId
                  });
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage: convertGoogleGenerativeAIUsage(usage),
                  providerMetadata
                });
              }
            })
          ),
          response: { headers: responseHeaders },
          request: { body: args }
        };
      }
    };
    getGroundingMetadataSchema = () => external_exports.object({
      webSearchQueries: external_exports.array(external_exports.string()).nullish(),
      imageSearchQueries: external_exports.array(external_exports.string()).nullish(),
      retrievalQueries: external_exports.array(external_exports.string()).nullish(),
      searchEntryPoint: external_exports.object({ renderedContent: external_exports.string() }).nullish(),
      groundingChunks: external_exports.array(
        external_exports.object({
          web: external_exports.object({ uri: external_exports.string(), title: external_exports.string().nullish() }).nullish(),
          image: external_exports.object({
            sourceUri: external_exports.string(),
            imageUri: external_exports.string(),
            title: external_exports.string().nullish(),
            domain: external_exports.string().nullish()
          }).nullish(),
          retrievedContext: external_exports.object({
            uri: external_exports.string().nullish(),
            title: external_exports.string().nullish(),
            text: external_exports.string().nullish(),
            fileSearchStore: external_exports.string().nullish()
          }).nullish(),
          maps: external_exports.object({
            uri: external_exports.string().nullish(),
            title: external_exports.string().nullish(),
            text: external_exports.string().nullish(),
            placeId: external_exports.string().nullish()
          }).nullish()
        })
      ).nullish(),
      groundingSupports: external_exports.array(
        external_exports.object({
          segment: external_exports.object({
            startIndex: external_exports.number().nullish(),
            endIndex: external_exports.number().nullish(),
            text: external_exports.string().nullish()
          }).nullish(),
          segment_text: external_exports.string().nullish(),
          groundingChunkIndices: external_exports.array(external_exports.number()).nullish(),
          supportChunkIndices: external_exports.array(external_exports.number()).nullish(),
          confidenceScores: external_exports.array(external_exports.number()).nullish(),
          confidenceScore: external_exports.array(external_exports.number()).nullish()
        })
      ).nullish(),
      retrievalMetadata: external_exports.union([
        external_exports.object({
          webDynamicRetrievalScore: external_exports.number()
        }),
        external_exports.object({})
      ]).nullish()
    });
    getContentSchema = () => external_exports.object({
      parts: external_exports.array(
        external_exports.union([
          // note: order matters since text can be fully empty
          external_exports.object({
            functionCall: external_exports.object({
              name: external_exports.string(),
              args: external_exports.unknown()
            }),
            thoughtSignature: external_exports.string().nullish()
          }),
          external_exports.object({
            inlineData: external_exports.object({
              mimeType: external_exports.string(),
              data: external_exports.string()
            }),
            thought: external_exports.boolean().nullish(),
            thoughtSignature: external_exports.string().nullish()
          }),
          external_exports.object({
            executableCode: external_exports.object({
              language: external_exports.string(),
              code: external_exports.string()
            }).nullish(),
            codeExecutionResult: external_exports.object({
              outcome: external_exports.string(),
              output: external_exports.string().nullish()
            }).nullish(),
            text: external_exports.string().nullish(),
            thought: external_exports.boolean().nullish(),
            thoughtSignature: external_exports.string().nullish()
          })
        ])
      ).nullish()
    });
    getSafetyRatingSchema = () => external_exports.object({
      category: external_exports.string().nullish(),
      probability: external_exports.string().nullish(),
      probabilityScore: external_exports.number().nullish(),
      severity: external_exports.string().nullish(),
      severityScore: external_exports.number().nullish(),
      blocked: external_exports.boolean().nullish()
    });
    usageSchema = external_exports.object({
      cachedContentTokenCount: external_exports.number().nullish(),
      thoughtsTokenCount: external_exports.number().nullish(),
      promptTokenCount: external_exports.number().nullish(),
      candidatesTokenCount: external_exports.number().nullish(),
      totalTokenCount: external_exports.number().nullish(),
      // https://cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/v1/GenerateContentResponse#TrafficType
      trafficType: external_exports.string().nullish()
    });
    getUrlContextMetadataSchema = () => external_exports.object({
      urlMetadata: external_exports.array(
        external_exports.object({
          retrievedUrl: external_exports.string(),
          urlRetrievalStatus: external_exports.string()
        })
      ).nullish()
    });
    responseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          candidates: external_exports.array(
            external_exports.object({
              content: getContentSchema().nullish().or(external_exports.object({}).strict()),
              finishReason: external_exports.string().nullish(),
              finishMessage: external_exports.string().nullish(),
              safetyRatings: external_exports.array(getSafetyRatingSchema()).nullish(),
              groundingMetadata: getGroundingMetadataSchema().nullish(),
              urlContextMetadata: getUrlContextMetadataSchema().nullish()
            })
          ),
          usageMetadata: usageSchema.nullish(),
          promptFeedback: external_exports.object({
            blockReason: external_exports.string().nullish(),
            safetyRatings: external_exports.array(getSafetyRatingSchema()).nullish()
          }).nullish(),
          serviceTier: external_exports.string().nullish()
        })
      )
    );
    chunkSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          candidates: external_exports.array(
            external_exports.object({
              content: getContentSchema().nullish(),
              finishReason: external_exports.string().nullish(),
              finishMessage: external_exports.string().nullish(),
              safetyRatings: external_exports.array(getSafetyRatingSchema()).nullish(),
              groundingMetadata: getGroundingMetadataSchema().nullish(),
              urlContextMetadata: getUrlContextMetadataSchema().nullish()
            })
          ).nullish(),
          usageMetadata: usageSchema.nullish(),
          promptFeedback: external_exports.object({
            blockReason: external_exports.string().nullish(),
            safetyRatings: external_exports.array(getSafetyRatingSchema()).nullish()
          }).nullish(),
          serviceTier: external_exports.string().nullish()
        })
      )
    );
    codeExecution = createProviderToolFactoryWithOutputSchema({
      id: "google.code_execution",
      inputSchema: external_exports.object({
        language: external_exports.string().describe("The programming language of the code."),
        code: external_exports.string().describe("The code to be executed.")
      }),
      outputSchema: external_exports.object({
        outcome: external_exports.string().describe('The outcome of the execution (e.g., "OUTCOME_OK").'),
        output: external_exports.string().describe("The output from the code execution.")
      })
    });
    enterpriseWebSearch = createProviderToolFactory({
      id: "google.enterprise_web_search",
      inputSchema: lazySchema(() => zodSchema(external_exports.object({})))
    });
    fileSearchArgsBaseSchema = external_exports.object({
      /** The names of the file_search_stores to retrieve from.
       *  Example: `fileSearchStores/my-file-search-store-123`
       */
      fileSearchStoreNames: external_exports.array(external_exports.string()).describe(
        "The names of the file_search_stores to retrieve from. Example: `fileSearchStores/my-file-search-store-123`"
      ),
      /** The number of file search retrieval chunks to retrieve. */
      topK: external_exports.number().int().positive().describe("The number of file search retrieval chunks to retrieve.").optional(),
      /** Metadata filter to apply to the file search retrieval documents.
       *  See https://google.aip.dev/160 for the syntax of the filter expression.
       */
      metadataFilter: external_exports.string().describe(
        "Metadata filter to apply to the file search retrieval documents. See https://google.aip.dev/160 for the syntax of the filter expression."
      ).optional()
    }).passthrough();
    fileSearchArgsSchema2 = lazySchema(
      () => zodSchema(fileSearchArgsBaseSchema)
    );
    fileSearch2 = createProviderToolFactory({
      id: "google.file_search",
      inputSchema: fileSearchArgsSchema2
    });
    googleMaps = createProviderToolFactory({
      id: "google.google_maps",
      inputSchema: lazySchema(() => zodSchema(external_exports.object({})))
    });
    googleSearchToolArgsBaseSchema = external_exports.object({
      searchTypes: external_exports.object({
        webSearch: external_exports.object({}).optional(),
        imageSearch: external_exports.object({}).optional()
      }).optional(),
      timeRangeFilter: external_exports.object({
        startTime: external_exports.string(),
        endTime: external_exports.string()
      }).optional()
    }).passthrough();
    googleSearchToolArgsSchema = lazySchema(
      () => zodSchema(googleSearchToolArgsBaseSchema)
    );
    googleSearch = createProviderToolFactory(
      {
        id: "google.google_search",
        inputSchema: googleSearchToolArgsSchema
      }
    );
    urlContext = createProviderToolFactory({
      id: "google.url_context",
      inputSchema: lazySchema(() => zodSchema(external_exports.object({})))
    });
    vertexRagStore = createProviderToolFactory({
      id: "google.vertex_rag_store",
      inputSchema: external_exports.object({
        ragCorpus: external_exports.string(),
        topK: external_exports.number().optional()
      })
    });
    googleTools = {
      /**
       * Creates a Google search tool that gives Google direct access to real-time web content.
       * Must have name "google_search".
       */
      googleSearch,
      /**
       * Creates an Enterprise Web Search tool for grounding responses using a compliance-focused web index.
       * Designed for highly-regulated industries (finance, healthcare, public sector).
       * Does not log customer data and supports VPC service controls.
       * Must have name "enterprise_web_search".
       *
       * @note Only available on Vertex AI. Requires Gemini 2.0 or newer.
       *
       * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/web-grounding-enterprise
       */
      enterpriseWebSearch,
      /**
       * Creates a Google Maps grounding tool that gives the model access to Google Maps data.
       * Must have name "google_maps".
       *
       * @see https://ai.google.dev/gemini-api/docs/maps-grounding
       * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-maps
       */
      googleMaps,
      /**
       * Creates a URL context tool that gives Google direct access to real-time web content.
       * Must have name "url_context".
       */
      urlContext,
      /**
       * Enables Retrieval Augmented Generation (RAG) via the Gemini File Search tool.
       * Must have name "file_search".
       *
       * @param fileSearchStoreNames - Fully-qualified File Search store resource names.
       * @param metadataFilter - Optional filter expression to restrict the files that can be retrieved.
       * @param topK - Optional result limit for the number of chunks returned from File Search.
       *
       * @see https://ai.google.dev/gemini-api/docs/file-search
       */
      fileSearch: fileSearch2,
      /**
       * A tool that enables the model to generate and run Python code.
       * Must have name "code_execution".
       *
       * @note Ensure the selected model supports Code Execution.
       * Multi-tool usage with the code execution tool is typically compatible with Gemini >=2 models.
       *
       * @see https://ai.google.dev/gemini-api/docs/code-execution (Google AI)
       * @see https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/code-execution-api (Vertex AI)
       */
      codeExecution,
      /**
       * Creates a Vertex RAG Store tool that enables the model to perform RAG searches against a Vertex RAG Store.
       * Must have name "vertex_rag_store".
       */
      vertexRagStore
    };
    GoogleGenerativeAIImageModel = class {
      constructor(modelId, settings, config3) {
        this.modelId = modelId;
        this.settings = settings;
        this.config = config3;
        this.specificationVersion = "v3";
      }
      get maxImagesPerCall() {
        if (this.settings.maxImagesPerCall != null) {
          return this.settings.maxImagesPerCall;
        }
        if (isGeminiModel(this.modelId)) {
          return 10;
        }
        return 4;
      }
      get provider() {
        return this.config.provider;
      }
      async doGenerate(options) {
        if (isGeminiModel(this.modelId)) {
          return this.doGenerateGemini(options);
        }
        return this.doGenerateImagen(options);
      }
      async doGenerateImagen(options) {
        var _a31, _b27, _c;
        const {
          prompt,
          n = 1,
          size,
          aspectRatio = "1:1",
          seed,
          providerOptions,
          headers,
          abortSignal,
          files,
          mask
        } = options;
        const warnings = [];
        if (files != null && files.length > 0) {
          throw new Error(
            "Google Generative AI does not support image editing with Imagen models. Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities."
          );
        }
        if (mask != null) {
          throw new Error(
            "Google Generative AI does not support image editing with masks. Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities."
          );
        }
        if (size != null) {
          warnings.push({
            type: "unsupported",
            feature: "size",
            details: "This model does not support the `size` option. Use `aspectRatio` instead."
          });
        }
        if (seed != null) {
          warnings.push({
            type: "unsupported",
            feature: "seed",
            details: "This model does not support the `seed` option through this provider."
          });
        }
        const googleOptions = await parseProviderOptions({
          provider: "google",
          providerOptions,
          schema: googleImageModelOptionsSchema
        });
        const currentDate = (_c = (_b27 = (_a31 = this.config._internal) == null ? void 0 : _a31.currentDate) == null ? void 0 : _b27.call(_a31)) != null ? _c : /* @__PURE__ */ new Date();
        const parameters = {
          sampleCount: n
        };
        if (aspectRatio != null) {
          parameters.aspectRatio = aspectRatio;
        }
        if (googleOptions) {
          Object.assign(parameters, googleOptions);
        }
        const body = {
          instances: [{ prompt }],
          parameters
        };
        const { responseHeaders, value: response } = await postJsonToApi({
          url: `${this.config.baseURL}/models/${this.modelId}:predict`,
          headers: combineHeaders(await resolve(this.config.headers), headers),
          body,
          failedResponseHandler: googleFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            googleImageResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        return {
          images: response.predictions.map(
            (p3) => p3.bytesBase64Encoded
          ),
          warnings,
          providerMetadata: {
            google: {
              images: response.predictions.map(() => ({
                // Add any prediction-specific metadata here
              }))
            }
          },
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: responseHeaders
          }
        };
      }
      async doGenerateGemini(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h, _i;
        const {
          prompt,
          n,
          size,
          aspectRatio,
          seed,
          providerOptions,
          headers,
          abortSignal,
          files,
          mask
        } = options;
        const warnings = [];
        if (mask != null) {
          throw new Error(
            "Gemini image models do not support mask-based image editing."
          );
        }
        if (n != null && n > 1) {
          throw new Error(
            "Gemini image models do not support generating a set number of images per call. Use n=1 or omit the n parameter."
          );
        }
        if (size != null) {
          warnings.push({
            type: "unsupported",
            feature: "size",
            details: "This model does not support the `size` option. Use `aspectRatio` instead."
          });
        }
        const userContent = [];
        if (prompt != null) {
          userContent.push({ type: "text", text: prompt });
        }
        if (files != null && files.length > 0) {
          for (const file3 of files) {
            if (file3.type === "url") {
              userContent.push({
                type: "file",
                data: new URL(file3.url),
                mediaType: "image/*"
              });
            } else {
              userContent.push({
                type: "file",
                data: typeof file3.data === "string" ? file3.data : new Uint8Array(file3.data),
                mediaType: file3.mediaType
              });
            }
          }
        }
        const languageModelPrompt = [
          { role: "user", content: userContent }
        ];
        const languageModel = new GoogleGenerativeAILanguageModel(this.modelId, {
          provider: this.config.provider,
          baseURL: this.config.baseURL,
          headers: (_a31 = this.config.headers) != null ? _a31 : {},
          fetch: this.config.fetch,
          generateId: (_b27 = this.config.generateId) != null ? _b27 : generateId
        });
        const result = await languageModel.doGenerate({
          prompt: languageModelPrompt,
          seed,
          providerOptions: {
            google: {
              responseModalities: ["IMAGE"],
              imageConfig: aspectRatio ? {
                aspectRatio
              } : void 0,
              ...(_c = providerOptions == null ? void 0 : providerOptions.google) != null ? _c : {}
            }
          },
          headers,
          abortSignal
        });
        const currentDate = (_f = (_e = (_d = this.config._internal) == null ? void 0 : _d.currentDate) == null ? void 0 : _e.call(_d)) != null ? _f : /* @__PURE__ */ new Date();
        const images = [];
        for (const part of result.content) {
          if (part.type === "file" && part.mediaType.startsWith("image/")) {
            images.push(convertToBase64(part.data));
          }
        }
        return {
          images,
          warnings,
          providerMetadata: {
            google: {
              images: images.map(() => ({}))
            }
          },
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: (_g = result.response) == null ? void 0 : _g.headers
          },
          usage: result.usage ? {
            inputTokens: result.usage.inputTokens.total,
            outputTokens: result.usage.outputTokens.total,
            totalTokens: ((_h = result.usage.inputTokens.total) != null ? _h : 0) + ((_i = result.usage.outputTokens.total) != null ? _i : 0)
          } : void 0
        };
      }
    };
    googleImageResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          predictions: external_exports.array(external_exports.object({ bytesBase64Encoded: external_exports.string() })).default([])
        })
      )
    );
    googleImageModelOptionsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          personGeneration: external_exports.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
          aspectRatio: external_exports.enum(["1:1", "3:4", "4:3", "9:16", "16:9"]).nullish()
        })
      )
    );
    GoogleGenerativeAIVideoModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
      }
      get provider() {
        return this.config.provider;
      }
      get maxVideosPerCall() {
        return 4;
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h;
        const currentDate = (_c = (_b27 = (_a31 = this.config._internal) == null ? void 0 : _a31.currentDate) == null ? void 0 : _b27.call(_a31)) != null ? _c : /* @__PURE__ */ new Date();
        const warnings = [];
        const googleOptions = await parseProviderOptions({
          provider: "google",
          providerOptions: options.providerOptions,
          schema: googleVideoModelOptionsSchema
        });
        const instances = [{}];
        const instance = instances[0];
        if (options.prompt != null) {
          instance.prompt = options.prompt;
        }
        if (options.image != null) {
          if (options.image.type === "url") {
            warnings.push({
              type: "unsupported",
              feature: "URL-based image input",
              details: "Google Generative AI video models require base64-encoded images. URL will be ignored."
            });
          } else {
            const base64Data = typeof options.image.data === "string" ? options.image.data : convertUint8ArrayToBase64(options.image.data);
            instance.image = {
              inlineData: {
                mimeType: options.image.mediaType || "image/png",
                data: base64Data
              }
            };
          }
        }
        if ((googleOptions == null ? void 0 : googleOptions.referenceImages) != null) {
          instance.referenceImages = googleOptions.referenceImages.map((refImg) => {
            if (refImg.bytesBase64Encoded) {
              return {
                inlineData: {
                  mimeType: "image/png",
                  data: refImg.bytesBase64Encoded
                }
              };
            } else if (refImg.gcsUri) {
              return {
                gcsUri: refImg.gcsUri
              };
            }
            return refImg;
          });
        }
        const parameters = {
          sampleCount: options.n
        };
        if (options.aspectRatio) {
          parameters.aspectRatio = options.aspectRatio;
        }
        if (options.resolution) {
          const resolutionMap = {
            "1280x720": "720p",
            "1920x1080": "1080p",
            "3840x2160": "4k"
          };
          parameters.resolution = resolutionMap[options.resolution] || options.resolution;
        }
        if (options.duration) {
          parameters.durationSeconds = options.duration;
        }
        if (options.seed) {
          parameters.seed = options.seed;
        }
        if (googleOptions != null) {
          const opts = googleOptions;
          if (opts.personGeneration !== void 0 && opts.personGeneration !== null) {
            parameters.personGeneration = opts.personGeneration;
          }
          if (opts.negativePrompt !== void 0 && opts.negativePrompt !== null) {
            parameters.negativePrompt = opts.negativePrompt;
          }
          for (const [key, value] of Object.entries(opts)) {
            if (![
              "pollIntervalMs",
              "pollTimeoutMs",
              "personGeneration",
              "negativePrompt",
              "referenceImages"
            ].includes(key)) {
              parameters[key] = value;
            }
          }
        }
        const { value: operation } = await postJsonToApi({
          url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
          headers: combineHeaders(
            await resolve(this.config.headers),
            options.headers
          ),
          body: {
            instances,
            parameters
          },
          successfulResponseHandler: createJsonResponseHandler(
            googleOperationSchema
          ),
          failedResponseHandler: googleFailedResponseHandler,
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const operationName = operation.name;
        if (!operationName) {
          throw new AISDKError({
            name: "GOOGLE_VIDEO_GENERATION_ERROR",
            message: "No operation name returned from API"
          });
        }
        const pollIntervalMs = (_d = googleOptions == null ? void 0 : googleOptions.pollIntervalMs) != null ? _d : 1e4;
        const pollTimeoutMs = (_e = googleOptions == null ? void 0 : googleOptions.pollTimeoutMs) != null ? _e : 6e5;
        const startTime = Date.now();
        let finalOperation = operation;
        let responseHeaders;
        while (!finalOperation.done) {
          if (Date.now() - startTime > pollTimeoutMs) {
            throw new AISDKError({
              name: "GOOGLE_VIDEO_GENERATION_TIMEOUT",
              message: `Video generation timed out after ${pollTimeoutMs}ms`
            });
          }
          await delay(pollIntervalMs);
          if ((_f = options.abortSignal) == null ? void 0 : _f.aborted) {
            throw new AISDKError({
              name: "GOOGLE_VIDEO_GENERATION_ABORTED",
              message: "Video generation request was aborted"
            });
          }
          const { value: statusOperation, responseHeaders: pollHeaders } = await getFromApi({
            url: `${this.config.baseURL}/${operationName}`,
            headers: combineHeaders(
              await resolve(this.config.headers),
              options.headers
            ),
            successfulResponseHandler: createJsonResponseHandler(
              googleOperationSchema
            ),
            failedResponseHandler: googleFailedResponseHandler,
            abortSignal: options.abortSignal,
            fetch: this.config.fetch
          });
          finalOperation = statusOperation;
          responseHeaders = pollHeaders;
        }
        if (finalOperation.error) {
          throw new AISDKError({
            name: "GOOGLE_VIDEO_GENERATION_FAILED",
            message: `Video generation failed: ${finalOperation.error.message}`
          });
        }
        const response = finalOperation.response;
        if (!((_g = response == null ? void 0 : response.generateVideoResponse) == null ? void 0 : _g.generatedSamples) || response.generateVideoResponse.generatedSamples.length === 0) {
          throw new AISDKError({
            name: "GOOGLE_VIDEO_GENERATION_ERROR",
            message: `No videos in response. Response: ${JSON.stringify(finalOperation)}`
          });
        }
        const videos = [];
        const videoMetadata = [];
        const resolvedHeaders = await resolve(this.config.headers);
        const apiKey = resolvedHeaders == null ? void 0 : resolvedHeaders["x-goog-api-key"];
        for (const generatedSample of response.generateVideoResponse.generatedSamples) {
          if ((_h = generatedSample.video) == null ? void 0 : _h.uri) {
            const urlWithAuth = apiKey ? `${generatedSample.video.uri}${generatedSample.video.uri.includes("?") ? "&" : "?"}key=${apiKey}` : generatedSample.video.uri;
            videos.push({
              type: "url",
              url: urlWithAuth,
              mediaType: "video/mp4"
            });
            videoMetadata.push({
              uri: generatedSample.video.uri
            });
          }
        }
        if (videos.length === 0) {
          throw new AISDKError({
            name: "GOOGLE_VIDEO_GENERATION_ERROR",
            message: "No valid videos in response"
          });
        }
        return {
          videos,
          warnings,
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: responseHeaders
          },
          providerMetadata: {
            google: {
              videos: videoMetadata
            }
          }
        };
      }
    };
    googleOperationSchema = external_exports.object({
      name: external_exports.string().nullish(),
      done: external_exports.boolean().nullish(),
      error: external_exports.object({
        code: external_exports.number().nullish(),
        message: external_exports.string(),
        status: external_exports.string().nullish()
      }).nullish(),
      response: external_exports.object({
        generateVideoResponse: external_exports.object({
          generatedSamples: external_exports.array(
            external_exports.object({
              video: external_exports.object({
                uri: external_exports.string().nullish()
              }).nullish()
            })
          ).nullish()
        }).nullish()
      }).nullish()
    });
    googleVideoModelOptionsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          pollIntervalMs: external_exports.number().positive().nullish(),
          pollTimeoutMs: external_exports.number().positive().nullish(),
          personGeneration: external_exports.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
          negativePrompt: external_exports.string().nullish(),
          referenceImages: external_exports.array(
            external_exports.object({
              bytesBase64Encoded: external_exports.string().nullish(),
              gcsUri: external_exports.string().nullish()
            })
          ).nullish()
        }).passthrough()
      )
    );
    google = createGoogleGenerativeAI();
  }
});

// node_modules/@ai-sdk/anthropic/dist/index.mjs
function getCacheControl(providerMetadata) {
  var _a31;
  const anthropic2 = providerMetadata == null ? void 0 : providerMetadata.anthropic;
  const cacheControlValue = (_a31 = anthropic2 == null ? void 0 : anthropic2.cacheControl) != null ? _a31 : anthropic2 == null ? void 0 : anthropic2.cache_control;
  return cacheControlValue;
}
async function prepareTools3({
  tools,
  toolChoice,
  disableParallelToolUse,
  cacheControlValidator,
  supportsStructuredOutput,
  supportsStrictTools
}) {
  var _a31;
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  const betas = /* @__PURE__ */ new Set();
  const validator2 = cacheControlValidator || new CacheControlValidator();
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings, betas };
  }
  const anthropicTools2 = [];
  for (const tool3 of tools) {
    switch (tool3.type) {
      case "function": {
        const cacheControl = validator2.getCacheControl(tool3.providerOptions, {
          type: "tool definition",
          canCache: true
        });
        const anthropicOptions = (_a31 = tool3.providerOptions) == null ? void 0 : _a31.anthropic;
        const eagerInputStreaming = anthropicOptions == null ? void 0 : anthropicOptions.eagerInputStreaming;
        const deferLoading = anthropicOptions == null ? void 0 : anthropicOptions.deferLoading;
        const allowedCallers = anthropicOptions == null ? void 0 : anthropicOptions.allowedCallers;
        if (!supportsStrictTools && tool3.strict != null) {
          toolWarnings.push({
            type: "unsupported",
            feature: "strict",
            details: `Tool '${tool3.name}' has strict: ${tool3.strict}, but strict mode is not supported by this provider. The strict property will be ignored.`
          });
        }
        anthropicTools2.push({
          name: tool3.name,
          description: tool3.description,
          input_schema: tool3.inputSchema,
          cache_control: cacheControl,
          ...eagerInputStreaming ? { eager_input_streaming: true } : {},
          ...supportsStrictTools === true && tool3.strict != null ? { strict: tool3.strict } : {},
          ...deferLoading != null ? { defer_loading: deferLoading } : {},
          ...allowedCallers != null ? { allowed_callers: allowedCallers } : {},
          ...tool3.inputExamples != null ? {
            input_examples: tool3.inputExamples.map(
              (example) => example.input
            )
          } : {}
        });
        if (supportsStructuredOutput === true) {
          betas.add("structured-outputs-2025-11-13");
        }
        if (tool3.inputExamples != null || allowedCallers != null) {
          betas.add("advanced-tool-use-2025-11-20");
        }
        break;
      }
      case "provider": {
        switch (tool3.id) {
          case "anthropic.code_execution_20250522": {
            betas.add("code-execution-2025-05-22");
            anthropicTools2.push({
              type: "code_execution_20250522",
              name: "code_execution",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.code_execution_20250825": {
            betas.add("code-execution-2025-08-25");
            anthropicTools2.push({
              type: "code_execution_20250825",
              name: "code_execution"
            });
            break;
          }
          case "anthropic.code_execution_20260120": {
            anthropicTools2.push({
              type: "code_execution_20260120",
              name: "code_execution"
            });
            break;
          }
          case "anthropic.computer_20250124": {
            betas.add("computer-use-2025-01-24");
            anthropicTools2.push({
              name: "computer",
              type: "computer_20250124",
              display_width_px: tool3.args.displayWidthPx,
              display_height_px: tool3.args.displayHeightPx,
              display_number: tool3.args.displayNumber,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.computer_20251124": {
            betas.add("computer-use-2025-11-24");
            anthropicTools2.push({
              name: "computer",
              type: "computer_20251124",
              display_width_px: tool3.args.displayWidthPx,
              display_height_px: tool3.args.displayHeightPx,
              display_number: tool3.args.displayNumber,
              enable_zoom: tool3.args.enableZoom,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.computer_20241022": {
            betas.add("computer-use-2024-10-22");
            anthropicTools2.push({
              name: "computer",
              type: "computer_20241022",
              display_width_px: tool3.args.displayWidthPx,
              display_height_px: tool3.args.displayHeightPx,
              display_number: tool3.args.displayNumber,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.text_editor_20250124": {
            betas.add("computer-use-2025-01-24");
            anthropicTools2.push({
              name: "str_replace_editor",
              type: "text_editor_20250124",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.text_editor_20241022": {
            betas.add("computer-use-2024-10-22");
            anthropicTools2.push({
              name: "str_replace_editor",
              type: "text_editor_20241022",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.text_editor_20250429": {
            betas.add("computer-use-2025-01-24");
            anthropicTools2.push({
              name: "str_replace_based_edit_tool",
              type: "text_editor_20250429",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.text_editor_20250728": {
            const args = await validateTypes({
              value: tool3.args,
              schema: textEditor_20250728ArgsSchema
            });
            anthropicTools2.push({
              name: "str_replace_based_edit_tool",
              type: "text_editor_20250728",
              max_characters: args.maxCharacters,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.bash_20250124": {
            betas.add("computer-use-2025-01-24");
            anthropicTools2.push({
              name: "bash",
              type: "bash_20250124",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.bash_20241022": {
            betas.add("computer-use-2024-10-22");
            anthropicTools2.push({
              name: "bash",
              type: "bash_20241022",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.memory_20250818": {
            betas.add("context-management-2025-06-27");
            anthropicTools2.push({
              name: "memory",
              type: "memory_20250818"
            });
            break;
          }
          case "anthropic.web_fetch_20250910": {
            betas.add("web-fetch-2025-09-10");
            const args = await validateTypes({
              value: tool3.args,
              schema: webFetch_20250910ArgsSchema
            });
            anthropicTools2.push({
              type: "web_fetch_20250910",
              name: "web_fetch",
              max_uses: args.maxUses,
              allowed_domains: args.allowedDomains,
              blocked_domains: args.blockedDomains,
              citations: args.citations,
              max_content_tokens: args.maxContentTokens,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.web_fetch_20260209": {
            betas.add("code-execution-web-tools-2026-02-09");
            const args = await validateTypes({
              value: tool3.args,
              schema: webFetch_20260209ArgsSchema
            });
            anthropicTools2.push({
              type: "web_fetch_20260209",
              name: "web_fetch",
              max_uses: args.maxUses,
              allowed_domains: args.allowedDomains,
              blocked_domains: args.blockedDomains,
              citations: args.citations,
              max_content_tokens: args.maxContentTokens,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.web_search_20250305": {
            const args = await validateTypes({
              value: tool3.args,
              schema: webSearch_20250305ArgsSchema
            });
            anthropicTools2.push({
              type: "web_search_20250305",
              name: "web_search",
              max_uses: args.maxUses,
              allowed_domains: args.allowedDomains,
              blocked_domains: args.blockedDomains,
              user_location: args.userLocation,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.web_search_20260209": {
            betas.add("code-execution-web-tools-2026-02-09");
            const args = await validateTypes({
              value: tool3.args,
              schema: webSearch_20260209ArgsSchema
            });
            anthropicTools2.push({
              type: "web_search_20260209",
              name: "web_search",
              max_uses: args.maxUses,
              allowed_domains: args.allowedDomains,
              blocked_domains: args.blockedDomains,
              user_location: args.userLocation,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.tool_search_regex_20251119": {
            anthropicTools2.push({
              type: "tool_search_tool_regex_20251119",
              name: "tool_search_tool_regex"
            });
            break;
          }
          case "anthropic.tool_search_bm25_20251119": {
            anthropicTools2.push({
              type: "tool_search_tool_bm25_20251119",
              name: "tool_search_tool_bm25"
            });
            break;
          }
          default: {
            toolWarnings.push({
              type: "unsupported",
              feature: `provider-defined tool ${tool3.id}`
            });
            break;
          }
        }
        break;
      }
      default: {
        toolWarnings.push({
          type: "unsupported",
          feature: `tool ${tool3}`
        });
        break;
      }
    }
  }
  if (toolChoice == null) {
    return {
      tools: anthropicTools2,
      toolChoice: disableParallelToolUse ? { type: "auto", disable_parallel_tool_use: disableParallelToolUse } : void 0,
      toolWarnings,
      betas
    };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
      return {
        tools: anthropicTools2,
        toolChoice: {
          type: "auto",
          disable_parallel_tool_use: disableParallelToolUse
        },
        toolWarnings,
        betas
      };
    case "required":
      return {
        tools: anthropicTools2,
        toolChoice: {
          type: "any",
          disable_parallel_tool_use: disableParallelToolUse
        },
        toolWarnings,
        betas
      };
    case "none":
      return { tools: void 0, toolChoice: void 0, toolWarnings, betas };
    case "tool":
      return {
        tools: anthropicTools2,
        toolChoice: {
          type: "tool",
          name: toolChoice.toolName,
          disable_parallel_tool_use: disableParallelToolUse
        },
        toolWarnings,
        betas
      };
    default: {
      const _exhaustiveCheck = type;
      throw new UnsupportedFunctionalityError({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
function convertAnthropicMessagesUsage({
  usage,
  rawUsage
}) {
  var _a31, _b27;
  const cacheCreationTokens = (_a31 = usage.cache_creation_input_tokens) != null ? _a31 : 0;
  const cacheReadTokens = (_b27 = usage.cache_read_input_tokens) != null ? _b27 : 0;
  let inputTokens;
  let outputTokens;
  if (usage.iterations && usage.iterations.length > 0) {
    const totals = usage.iterations.reduce(
      (acc, iter) => ({
        input: acc.input + iter.input_tokens,
        output: acc.output + iter.output_tokens
      }),
      { input: 0, output: 0 }
    );
    inputTokens = totals.input;
    outputTokens = totals.output;
  } else {
    inputTokens = usage.input_tokens;
    outputTokens = usage.output_tokens;
  }
  return {
    inputTokens: {
      total: inputTokens + cacheCreationTokens + cacheReadTokens,
      noCache: inputTokens,
      cacheRead: cacheReadTokens,
      cacheWrite: cacheCreationTokens
    },
    outputTokens: {
      total: outputTokens,
      text: void 0,
      reasoning: void 0
    },
    raw: rawUsage != null ? rawUsage : usage
  };
}
function convertToString(data) {
  if (typeof data === "string") {
    return new TextDecoder().decode(convertBase64ToUint8Array(data));
  }
  if (data instanceof Uint8Array) {
    return new TextDecoder().decode(data);
  }
  if (data instanceof URL) {
    throw new UnsupportedFunctionalityError({
      functionality: "URL-based text documents are not supported for citations"
    });
  }
  throw new UnsupportedFunctionalityError({
    functionality: `unsupported data type for text documents: ${typeof data}`
  });
}
function isUrlData(data) {
  return data instanceof URL || isUrlString(data);
}
function isUrlString(data) {
  return typeof data === "string" && /^https?:\/\//i.test(data);
}
function getUrlString(data) {
  return data instanceof URL ? data.toString() : data;
}
async function convertToAnthropicMessagesPrompt({
  prompt,
  sendReasoning,
  warnings,
  cacheControlValidator,
  toolNameMapping
}) {
  var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
  const betas = /* @__PURE__ */ new Set();
  const blocks = groupIntoBlocks(prompt);
  const validator2 = cacheControlValidator || new CacheControlValidator();
  let system = void 0;
  const messages = [];
  async function shouldEnableCitations(providerMetadata) {
    var _a211, _b28;
    const anthropicOptions = await parseProviderOptions({
      provider: "anthropic",
      providerOptions: providerMetadata,
      schema: anthropicFilePartProviderOptions
    });
    return (_b28 = (_a211 = anthropicOptions == null ? void 0 : anthropicOptions.citations) == null ? void 0 : _a211.enabled) != null ? _b28 : false;
  }
  async function getDocumentMetadata(providerMetadata) {
    const anthropicOptions = await parseProviderOptions({
      provider: "anthropic",
      providerOptions: providerMetadata,
      schema: anthropicFilePartProviderOptions
    });
    return {
      title: anthropicOptions == null ? void 0 : anthropicOptions.title,
      context: anthropicOptions == null ? void 0 : anthropicOptions.context
    };
  }
  for (let i = 0; i < blocks.length; i++) {
    const block = blocks[i];
    const isLastBlock = i === blocks.length - 1;
    const type = block.type;
    switch (type) {
      case "system": {
        if (system != null) {
          throw new UnsupportedFunctionalityError({
            functionality: "Multiple system messages that are separated by user/assistant messages"
          });
        }
        system = block.messages.map(({ content, providerOptions }) => ({
          type: "text",
          text: content,
          cache_control: validator2.getCacheControl(providerOptions, {
            type: "system message",
            canCache: true
          })
        }));
        break;
      }
      case "user": {
        const anthropicContent = [];
        for (const message of block.messages) {
          const { role, content } = message;
          switch (role) {
            case "user": {
              for (let j = 0; j < content.length; j++) {
                const part = content[j];
                const isLastPart = j === content.length - 1;
                const cacheControl = (_a31 = validator2.getCacheControl(part.providerOptions, {
                  type: "user message part",
                  canCache: true
                })) != null ? _a31 : isLastPart ? validator2.getCacheControl(message.providerOptions, {
                  type: "user message",
                  canCache: true
                }) : void 0;
                switch (part.type) {
                  case "text": {
                    anthropicContent.push({
                      type: "text",
                      text: part.text,
                      cache_control: cacheControl
                    });
                    break;
                  }
                  case "file": {
                    if (part.mediaType.startsWith("image/")) {
                      anthropicContent.push({
                        type: "image",
                        source: isUrlData(part.data) ? {
                          type: "url",
                          url: getUrlString(part.data)
                        } : {
                          type: "base64",
                          media_type: part.mediaType === "image/*" ? "image/jpeg" : part.mediaType,
                          data: convertToBase64(part.data)
                        },
                        cache_control: cacheControl
                      });
                    } else if (part.mediaType === "application/pdf") {
                      betas.add("pdfs-2024-09-25");
                      const enableCitations = await shouldEnableCitations(
                        part.providerOptions
                      );
                      const metadata = await getDocumentMetadata(
                        part.providerOptions
                      );
                      anthropicContent.push({
                        type: "document",
                        source: isUrlData(part.data) ? {
                          type: "url",
                          url: getUrlString(part.data)
                        } : {
                          type: "base64",
                          media_type: "application/pdf",
                          data: convertToBase64(part.data)
                        },
                        title: (_b27 = metadata.title) != null ? _b27 : part.filename,
                        ...metadata.context && { context: metadata.context },
                        ...enableCitations && {
                          citations: { enabled: true }
                        },
                        cache_control: cacheControl
                      });
                    } else if (part.mediaType === "text/plain") {
                      const enableCitations = await shouldEnableCitations(
                        part.providerOptions
                      );
                      const metadata = await getDocumentMetadata(
                        part.providerOptions
                      );
                      anthropicContent.push({
                        type: "document",
                        source: isUrlData(part.data) ? {
                          type: "url",
                          url: getUrlString(part.data)
                        } : {
                          type: "text",
                          media_type: "text/plain",
                          data: convertToString(part.data)
                        },
                        title: (_c = metadata.title) != null ? _c : part.filename,
                        ...metadata.context && { context: metadata.context },
                        ...enableCitations && {
                          citations: { enabled: true }
                        },
                        cache_control: cacheControl
                      });
                    } else {
                      throw new UnsupportedFunctionalityError({
                        functionality: `media type: ${part.mediaType}`
                      });
                    }
                    break;
                  }
                }
              }
              break;
            }
            case "tool": {
              for (let i2 = 0; i2 < content.length; i2++) {
                const part = content[i2];
                if (part.type === "tool-approval-response") {
                  continue;
                }
                const isLastPart = i2 === content.length - 1;
                const cacheControl = (_d = validator2.getCacheControl(part.providerOptions, {
                  type: "tool result part",
                  canCache: true
                })) != null ? _d : isLastPart ? validator2.getCacheControl(message.providerOptions, {
                  type: "tool result message",
                  canCache: true
                }) : void 0;
                const output = part.output;
                let contentValue;
                switch (output.type) {
                  case "content":
                    contentValue = output.value.map((contentPart) => {
                      var _a211;
                      switch (contentPart.type) {
                        case "text":
                          return {
                            type: "text",
                            text: contentPart.text
                          };
                        case "image-data": {
                          return {
                            type: "image",
                            source: {
                              type: "base64",
                              media_type: contentPart.mediaType,
                              data: contentPart.data
                            }
                          };
                        }
                        case "image-url": {
                          return {
                            type: "image",
                            source: {
                              type: "url",
                              url: contentPart.url
                            }
                          };
                        }
                        case "file-url": {
                          return {
                            type: "document",
                            source: {
                              type: "url",
                              url: contentPart.url
                            }
                          };
                        }
                        case "file-data": {
                          if (contentPart.mediaType === "application/pdf") {
                            betas.add("pdfs-2024-09-25");
                            return {
                              type: "document",
                              source: {
                                type: "base64",
                                media_type: contentPart.mediaType,
                                data: contentPart.data
                              }
                            };
                          }
                          warnings.push({
                            type: "other",
                            message: `unsupported tool content part type: ${contentPart.type} with media type: ${contentPart.mediaType}`
                          });
                          return void 0;
                        }
                        case "custom": {
                          const anthropicOptions = (_a211 = contentPart.providerOptions) == null ? void 0 : _a211.anthropic;
                          if ((anthropicOptions == null ? void 0 : anthropicOptions.type) === "tool-reference") {
                            return {
                              type: "tool_reference",
                              tool_name: anthropicOptions.toolName
                            };
                          }
                          warnings.push({
                            type: "other",
                            message: `unsupported custom tool content part`
                          });
                          return void 0;
                        }
                        default: {
                          warnings.push({
                            type: "other",
                            message: `unsupported tool content part type: ${contentPart.type}`
                          });
                          return void 0;
                        }
                      }
                    }).filter(isNonNullable);
                    break;
                  case "text":
                  case "error-text":
                    contentValue = output.value;
                    break;
                  case "execution-denied":
                    contentValue = (_e = output.reason) != null ? _e : "Tool execution denied.";
                    break;
                  case "json":
                  case "error-json":
                  default:
                    contentValue = JSON.stringify(output.value);
                    break;
                }
                anthropicContent.push({
                  type: "tool_result",
                  tool_use_id: part.toolCallId,
                  content: contentValue,
                  is_error: output.type === "error-text" || output.type === "error-json" ? true : void 0,
                  cache_control: cacheControl
                });
              }
              break;
            }
            default: {
              const _exhaustiveCheck = role;
              throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
            }
          }
        }
        messages.push({ role: "user", content: anthropicContent });
        break;
      }
      case "assistant": {
        const anthropicContent = [];
        const mcpToolUseIds = /* @__PURE__ */ new Set();
        for (let j = 0; j < block.messages.length; j++) {
          const message = block.messages[j];
          const isLastMessage = j === block.messages.length - 1;
          const { content } = message;
          for (let k = 0; k < content.length; k++) {
            const part = content[k];
            const isLastContentPart = k === content.length - 1;
            const cacheControl = (_f = validator2.getCacheControl(part.providerOptions, {
              type: "assistant message part",
              canCache: true
            })) != null ? _f : isLastContentPart ? validator2.getCacheControl(message.providerOptions, {
              type: "assistant message",
              canCache: true
            }) : void 0;
            switch (part.type) {
              case "text": {
                const textMetadata = (_g = part.providerOptions) == null ? void 0 : _g.anthropic;
                if ((textMetadata == null ? void 0 : textMetadata.type) === "compaction") {
                  anthropicContent.push({
                    type: "compaction",
                    content: part.text,
                    cache_control: cacheControl
                  });
                } else {
                  anthropicContent.push({
                    type: "text",
                    text: (
                      // trim the last text part if it's the last message in the block
                      // because Anthropic does not allow trailing whitespace
                      // in pre-filled assistant responses
                      isLastBlock && isLastMessage && isLastContentPart ? part.text.trim() : part.text
                    ),
                    cache_control: cacheControl
                  });
                }
                break;
              }
              case "reasoning": {
                if (sendReasoning) {
                  const reasoningMetadata = await parseProviderOptions({
                    provider: "anthropic",
                    providerOptions: part.providerOptions,
                    schema: anthropicReasoningMetadataSchema
                  });
                  if (reasoningMetadata != null) {
                    if (reasoningMetadata.signature != null) {
                      validator2.getCacheControl(part.providerOptions, {
                        type: "thinking block",
                        canCache: false
                      });
                      anthropicContent.push({
                        type: "thinking",
                        thinking: part.text,
                        signature: reasoningMetadata.signature
                      });
                    } else if (reasoningMetadata.redactedData != null) {
                      validator2.getCacheControl(part.providerOptions, {
                        type: "redacted thinking block",
                        canCache: false
                      });
                      anthropicContent.push({
                        type: "redacted_thinking",
                        data: reasoningMetadata.redactedData
                      });
                    } else {
                      warnings.push({
                        type: "other",
                        message: "unsupported reasoning metadata"
                      });
                    }
                  } else {
                    warnings.push({
                      type: "other",
                      message: "unsupported reasoning metadata"
                    });
                  }
                } else {
                  warnings.push({
                    type: "other",
                    message: "sending reasoning content is disabled for this model"
                  });
                }
                break;
              }
              case "tool-call": {
                if (part.providerExecuted) {
                  const providerToolName = toolNameMapping.toProviderToolName(
                    part.toolName
                  );
                  const isMcpToolUse = ((_i = (_h = part.providerOptions) == null ? void 0 : _h.anthropic) == null ? void 0 : _i.type) === "mcp-tool-use";
                  if (isMcpToolUse) {
                    mcpToolUseIds.add(part.toolCallId);
                    const serverName = (_k = (_j = part.providerOptions) == null ? void 0 : _j.anthropic) == null ? void 0 : _k.serverName;
                    if (serverName == null || typeof serverName !== "string") {
                      warnings.push({
                        type: "other",
                        message: "mcp tool use server name is required and must be a string"
                      });
                      break;
                    }
                    anthropicContent.push({
                      type: "mcp_tool_use",
                      id: part.toolCallId,
                      name: part.toolName,
                      input: part.input,
                      server_name: serverName,
                      cache_control: cacheControl
                    });
                  } else if (
                    // code execution 20250825:
                    providerToolName === "code_execution" && part.input != null && typeof part.input === "object" && "type" in part.input && typeof part.input.type === "string" && (part.input.type === "bash_code_execution" || part.input.type === "text_editor_code_execution")
                  ) {
                    anthropicContent.push({
                      type: "server_tool_use",
                      id: part.toolCallId,
                      name: part.input.type,
                      // map back to subtool name
                      input: part.input,
                      cache_control: cacheControl
                    });
                  } else if (
                    // code execution 20250825 programmatic tool calling:
                    // Strip the fake 'programmatic-tool-call' type before sending to Anthropic
                    providerToolName === "code_execution" && part.input != null && typeof part.input === "object" && "type" in part.input && part.input.type === "programmatic-tool-call"
                  ) {
                    const { type: _, ...inputWithoutType } = part.input;
                    anthropicContent.push({
                      type: "server_tool_use",
                      id: part.toolCallId,
                      name: "code_execution",
                      input: inputWithoutType,
                      cache_control: cacheControl
                    });
                  } else {
                    if (providerToolName === "code_execution" || // code execution 20250522
                    providerToolName === "web_fetch" || providerToolName === "web_search") {
                      anthropicContent.push({
                        type: "server_tool_use",
                        id: part.toolCallId,
                        name: providerToolName,
                        input: part.input,
                        cache_control: cacheControl
                      });
                    } else if (providerToolName === "tool_search_tool_regex" || providerToolName === "tool_search_tool_bm25") {
                      anthropicContent.push({
                        type: "server_tool_use",
                        id: part.toolCallId,
                        name: providerToolName,
                        input: part.input,
                        cache_control: cacheControl
                      });
                    } else {
                      warnings.push({
                        type: "other",
                        message: `provider executed tool call for tool ${part.toolName} is not supported`
                      });
                    }
                  }
                  break;
                }
                const callerOptions = (_l = part.providerOptions) == null ? void 0 : _l.anthropic;
                const caller = (callerOptions == null ? void 0 : callerOptions.caller) ? (callerOptions.caller.type === "code_execution_20250825" || callerOptions.caller.type === "code_execution_20260120") && callerOptions.caller.toolId ? {
                  type: callerOptions.caller.type,
                  tool_id: callerOptions.caller.toolId
                } : callerOptions.caller.type === "direct" ? { type: "direct" } : void 0 : void 0;
                anthropicContent.push({
                  type: "tool_use",
                  id: part.toolCallId,
                  name: part.toolName,
                  input: part.input,
                  ...caller && { caller },
                  cache_control: cacheControl
                });
                break;
              }
              case "tool-result": {
                const providerToolName = toolNameMapping.toProviderToolName(
                  part.toolName
                );
                if (mcpToolUseIds.has(part.toolCallId)) {
                  const output = part.output;
                  if (output.type !== "json" && output.type !== "error-json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  anthropicContent.push({
                    type: "mcp_tool_result",
                    tool_use_id: part.toolCallId,
                    is_error: output.type === "error-json",
                    content: output.value,
                    cache_control: cacheControl
                  });
                } else if (providerToolName === "code_execution") {
                  const output = part.output;
                  if (output.type === "error-text" || output.type === "error-json") {
                    let errorInfo = {};
                    try {
                      if (typeof output.value === "string") {
                        errorInfo = JSON.parse(output.value);
                      } else if (typeof output.value === "object" && output.value !== null) {
                        errorInfo = output.value;
                      }
                    } catch (e) {
                    }
                    if (errorInfo.type === "code_execution_tool_result_error") {
                      anthropicContent.push({
                        type: "code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        content: {
                          type: "code_execution_tool_result_error",
                          error_code: (_m = errorInfo.errorCode) != null ? _m : "unknown"
                        },
                        cache_control: cacheControl
                      });
                    } else {
                      anthropicContent.push({
                        type: "bash_code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        cache_control: cacheControl,
                        content: {
                          type: "bash_code_execution_tool_result_error",
                          error_code: (_n = errorInfo.errorCode) != null ? _n : "unknown"
                        }
                      });
                    }
                    break;
                  }
                  if (output.type !== "json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  if (output.value == null || typeof output.value !== "object" || !("type" in output.value) || typeof output.value.type !== "string") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output value is not a valid code execution result for tool ${part.toolName}`
                    });
                    break;
                  }
                  if (output.value.type === "code_execution_result") {
                    const codeExecutionOutput = await validateTypes({
                      value: output.value,
                      schema: codeExecution_20250522OutputSchema
                    });
                    anthropicContent.push({
                      type: "code_execution_tool_result",
                      tool_use_id: part.toolCallId,
                      content: {
                        type: codeExecutionOutput.type,
                        stdout: codeExecutionOutput.stdout,
                        stderr: codeExecutionOutput.stderr,
                        return_code: codeExecutionOutput.return_code,
                        content: (_o = codeExecutionOutput.content) != null ? _o : []
                      },
                      cache_control: cacheControl
                    });
                  } else if (output.value.type === "encrypted_code_execution_result") {
                    const codeExecutionOutput = await validateTypes({
                      value: output.value,
                      schema: codeExecution_20260120OutputSchema
                    });
                    if (codeExecutionOutput.type === "encrypted_code_execution_result") {
                      anthropicContent.push({
                        type: "code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        content: {
                          type: codeExecutionOutput.type,
                          encrypted_stdout: codeExecutionOutput.encrypted_stdout,
                          stderr: codeExecutionOutput.stderr,
                          return_code: codeExecutionOutput.return_code,
                          content: (_p = codeExecutionOutput.content) != null ? _p : []
                        },
                        cache_control: cacheControl
                      });
                    }
                  } else {
                    const codeExecutionOutput = await validateTypes({
                      value: output.value,
                      schema: codeExecution_20250825OutputSchema
                    });
                    if (codeExecutionOutput.type === "code_execution_result") {
                      anthropicContent.push({
                        type: "code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        content: {
                          type: codeExecutionOutput.type,
                          stdout: codeExecutionOutput.stdout,
                          stderr: codeExecutionOutput.stderr,
                          return_code: codeExecutionOutput.return_code,
                          content: (_q = codeExecutionOutput.content) != null ? _q : []
                        },
                        cache_control: cacheControl
                      });
                    } else if (codeExecutionOutput.type === "bash_code_execution_result" || codeExecutionOutput.type === "bash_code_execution_tool_result_error") {
                      anthropicContent.push({
                        type: "bash_code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        cache_control: cacheControl,
                        content: codeExecutionOutput
                      });
                    } else {
                      anthropicContent.push({
                        type: "text_editor_code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        cache_control: cacheControl,
                        content: codeExecutionOutput
                      });
                    }
                  }
                  break;
                }
                if (providerToolName === "web_fetch") {
                  const output = part.output;
                  if (output.type === "error-json") {
                    let errorValue = {};
                    try {
                      if (typeof output.value === "string") {
                        errorValue = JSON.parse(output.value);
                      } else if (typeof output.value === "object" && output.value !== null) {
                        errorValue = output.value;
                      }
                    } catch (e) {
                      const extractedErrorCode = (_r = output.value) == null ? void 0 : _r.errorCode;
                      errorValue = {
                        errorCode: typeof extractedErrorCode === "string" ? extractedErrorCode : "unavailable"
                      };
                    }
                    anthropicContent.push({
                      type: "web_fetch_tool_result",
                      tool_use_id: part.toolCallId,
                      content: {
                        type: "web_fetch_tool_result_error",
                        error_code: (_s = errorValue.errorCode) != null ? _s : "unavailable"
                      },
                      cache_control: cacheControl
                    });
                    break;
                  }
                  if (output.type !== "json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  const webFetchOutput = await validateTypes({
                    value: output.value,
                    schema: webFetch_20250910OutputSchema
                  });
                  anthropicContent.push({
                    type: "web_fetch_tool_result",
                    tool_use_id: part.toolCallId,
                    content: {
                      type: "web_fetch_result",
                      url: webFetchOutput.url,
                      retrieved_at: webFetchOutput.retrievedAt,
                      content: {
                        type: "document",
                        title: webFetchOutput.content.title,
                        citations: webFetchOutput.content.citations,
                        source: {
                          type: webFetchOutput.content.source.type,
                          media_type: webFetchOutput.content.source.mediaType,
                          data: webFetchOutput.content.source.data
                        }
                      }
                    },
                    cache_control: cacheControl
                  });
                  break;
                }
                if (providerToolName === "web_search") {
                  const output = part.output;
                  if (output.type !== "json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  const webSearchOutput = await validateTypes({
                    value: output.value,
                    schema: webSearch_20250305OutputSchema
                  });
                  anthropicContent.push({
                    type: "web_search_tool_result",
                    tool_use_id: part.toolCallId,
                    content: webSearchOutput.map((result) => ({
                      url: result.url,
                      title: result.title,
                      page_age: result.pageAge,
                      encrypted_content: result.encryptedContent,
                      type: result.type
                    })),
                    cache_control: cacheControl
                  });
                  break;
                }
                if (providerToolName === "tool_search_tool_regex" || providerToolName === "tool_search_tool_bm25") {
                  const output = part.output;
                  if (output.type !== "json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  const toolSearchOutput = await validateTypes({
                    value: output.value,
                    schema: toolSearchRegex_20251119OutputSchema
                  });
                  const toolReferences = toolSearchOutput.map((ref) => ({
                    type: "tool_reference",
                    tool_name: ref.toolName
                  }));
                  anthropicContent.push({
                    type: "tool_search_tool_result",
                    tool_use_id: part.toolCallId,
                    content: {
                      type: "tool_search_tool_search_result",
                      tool_references: toolReferences
                    },
                    cache_control: cacheControl
                  });
                  break;
                }
                warnings.push({
                  type: "other",
                  message: `provider executed tool result for tool ${part.toolName} is not supported`
                });
                break;
              }
            }
          }
        }
        messages.push({ role: "assistant", content: anthropicContent });
        break;
      }
      default: {
        const _exhaustiveCheck = type;
        throw new Error(`content type: ${_exhaustiveCheck}`);
      }
    }
  }
  return {
    prompt: { system, messages },
    betas
  };
}
function groupIntoBlocks(prompt) {
  const blocks = [];
  let currentBlock = void 0;
  for (const message of prompt) {
    const { role } = message;
    switch (role) {
      case "system": {
        if ((currentBlock == null ? void 0 : currentBlock.type) !== "system") {
          currentBlock = { type: "system", messages: [] };
          blocks.push(currentBlock);
        }
        currentBlock.messages.push(message);
        break;
      }
      case "assistant": {
        if ((currentBlock == null ? void 0 : currentBlock.type) !== "assistant") {
          currentBlock = { type: "assistant", messages: [] };
          blocks.push(currentBlock);
        }
        currentBlock.messages.push(message);
        break;
      }
      case "user": {
        if ((currentBlock == null ? void 0 : currentBlock.type) !== "user") {
          currentBlock = { type: "user", messages: [] };
          blocks.push(currentBlock);
        }
        currentBlock.messages.push(message);
        break;
      }
      case "tool": {
        if ((currentBlock == null ? void 0 : currentBlock.type) !== "user") {
          currentBlock = { type: "user", messages: [] };
          blocks.push(currentBlock);
        }
        currentBlock.messages.push(message);
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return blocks;
}
function mapAnthropicStopReason({
  finishReason,
  isJsonResponseFromTool
}) {
  switch (finishReason) {
    case "pause_turn":
    case "end_turn":
    case "stop_sequence":
      return "stop";
    case "refusal":
      return "content-filter";
    case "tool_use":
      return isJsonResponseFromTool ? "stop" : "tool-calls";
    case "max_tokens":
    case "model_context_window_exceeded":
      return "length";
    case "compaction":
      return "other";
    default:
      return "other";
  }
}
function createCitationSource(citation, citationDocuments, generateId32) {
  var _a31;
  if (citation.type === "web_search_result_location") {
    return {
      type: "source",
      sourceType: "url",
      id: generateId32(),
      url: citation.url,
      title: citation.title,
      providerMetadata: {
        anthropic: {
          citedText: citation.cited_text,
          encryptedIndex: citation.encrypted_index
        }
      }
    };
  }
  if (citation.type !== "page_location" && citation.type !== "char_location") {
    return;
  }
  const documentInfo = citationDocuments[citation.document_index];
  if (!documentInfo) {
    return;
  }
  return {
    type: "source",
    sourceType: "document",
    id: generateId32(),
    mediaType: documentInfo.mediaType,
    title: (_a31 = citation.document_title) != null ? _a31 : documentInfo.title,
    filename: documentInfo.filename,
    providerMetadata: {
      anthropic: citation.type === "page_location" ? {
        citedText: citation.cited_text,
        startPageNumber: citation.start_page_number,
        endPageNumber: citation.end_page_number
      } : {
        citedText: citation.cited_text,
        startCharIndex: citation.start_char_index,
        endCharIndex: citation.end_char_index
      }
    }
  };
}
function getModelCapabilities(modelId) {
  if (modelId.includes("claude-sonnet-4-6") || modelId.includes("claude-opus-4-6")) {
    return {
      maxOutputTokens: 128e3,
      supportsStructuredOutput: true,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-sonnet-4-5") || modelId.includes("claude-opus-4-5") || modelId.includes("claude-haiku-4-5")) {
    return {
      maxOutputTokens: 64e3,
      supportsStructuredOutput: true,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-opus-4-1")) {
    return {
      maxOutputTokens: 32e3,
      supportsStructuredOutput: true,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-sonnet-4-")) {
    return {
      maxOutputTokens: 64e3,
      supportsStructuredOutput: false,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-opus-4-")) {
    return {
      maxOutputTokens: 32e3,
      supportsStructuredOutput: false,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-3-haiku")) {
    return {
      maxOutputTokens: 4096,
      supportsStructuredOutput: false,
      isKnownModel: true
    };
  } else {
    return {
      maxOutputTokens: 4096,
      supportsStructuredOutput: false,
      isKnownModel: false
    };
  }
}
function hasWebTool20260209WithoutCodeExecution(tools) {
  if (!tools) {
    return false;
  }
  let hasWebTool20260209 = false;
  let hasCodeExecutionTool = false;
  for (const tool3 of tools) {
    if ("type" in tool3 && (tool3.type === "web_fetch_20260209" || tool3.type === "web_search_20260209")) {
      hasWebTool20260209 = true;
      continue;
    }
    if (tool3.name === "code_execution") {
      hasCodeExecutionTool = true;
      break;
    }
  }
  return hasWebTool20260209 && !hasCodeExecutionTool;
}
function mapAnthropicResponseContextManagement(contextManagement) {
  return contextManagement ? {
    appliedEdits: contextManagement.applied_edits.map((edit) => {
      const strategy = edit.type;
      switch (strategy) {
        case "clear_tool_uses_20250919":
          return {
            type: edit.type,
            clearedToolUses: edit.cleared_tool_uses,
            clearedInputTokens: edit.cleared_input_tokens
          };
        case "clear_thinking_20251015":
          return {
            type: edit.type,
            clearedThinkingTurns: edit.cleared_thinking_turns,
            clearedInputTokens: edit.cleared_input_tokens
          };
        case "compact_20260112":
          return {
            type: edit.type
          };
      }
    }).filter((edit) => edit !== void 0)
  } : null;
}
function createAnthropic(options = {}) {
  var _a31, _b27;
  const baseURL = (_a31 = withoutTrailingSlash(
    loadOptionalSetting({
      settingValue: options.baseURL,
      environmentVariableName: "ANTHROPIC_BASE_URL"
    })
  )) != null ? _a31 : "https://api.anthropic.com/v1";
  const providerName = (_b27 = options.name) != null ? _b27 : "anthropic.messages";
  if (options.apiKey && options.authToken) {
    throw new InvalidArgumentError({
      argument: "apiKey/authToken",
      message: "Both apiKey and authToken were provided. Please use only one authentication method."
    });
  }
  const getHeaders = () => {
    const authHeaders = options.authToken ? { Authorization: `Bearer ${options.authToken}` } : {
      "x-api-key": loadApiKey({
        apiKey: options.apiKey,
        environmentVariableName: "ANTHROPIC_API_KEY",
        description: "Anthropic"
      })
    };
    return withUserAgentSuffix(
      {
        "anthropic-version": "2023-06-01",
        ...authHeaders,
        ...options.headers
      },
      `ai-sdk/anthropic/${VERSION8}`
    );
  };
  const createChatModel = (modelId) => {
    var _a211;
    return new AnthropicMessagesLanguageModel(modelId, {
      provider: providerName,
      baseURL,
      headers: getHeaders,
      fetch: options.fetch,
      generateId: (_a211 = options.generateId) != null ? _a211 : generateId,
      supportedUrls: () => ({
        "image/*": [/^https?:\/\/.*$/],
        "application/pdf": [/^https?:\/\/.*$/]
      })
    });
  };
  const provider = function(modelId) {
    if (new.target) {
      throw new Error(
        "The Anthropic model function cannot be called with the new keyword."
      );
    }
    return createChatModel(modelId);
  };
  provider.specificationVersion = "v3";
  provider.languageModel = createChatModel;
  provider.chat = createChatModel;
  provider.messages = createChatModel;
  provider.embeddingModel = (modelId) => {
    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
  };
  provider.textEmbeddingModel = provider.embeddingModel;
  provider.imageModel = (modelId) => {
    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
  };
  provider.tools = anthropicTools;
  return provider;
}
var VERSION8, anthropicErrorDataSchema, anthropicFailedResponseHandler, anthropicMessagesResponseSchema, anthropicMessagesChunkSchema, anthropicReasoningMetadataSchema, anthropicFilePartProviderOptions, anthropicLanguageModelOptions, MAX_CACHE_BREAKPOINTS, CacheControlValidator, textEditor_20250728ArgsSchema, textEditor_20250728InputSchema, factory2, textEditor_20250728, webSearch_20260209ArgsSchema, webSearch_20260209OutputSchema, webSearch_20260209InputSchema, factory22, webSearch_20260209, webSearch_20250305ArgsSchema, webSearch_20250305OutputSchema, webSearch_20250305InputSchema, factory3, webSearch_20250305, webFetch_20260209ArgsSchema, webFetch_20260209OutputSchema, webFetch_20260209InputSchema, factory4, webFetch_20260209, webFetch_20250910ArgsSchema, webFetch_20250910OutputSchema, webFetch_20250910InputSchema, factory5, webFetch_20250910, codeExecution_20250522OutputSchema, codeExecution_20250522InputSchema, factory6, codeExecution_20250522, codeExecution_20250825OutputSchema, codeExecution_20250825InputSchema, factory7, codeExecution_20250825, codeExecution_20260120OutputSchema, codeExecution_20260120InputSchema, factory8, codeExecution_20260120, toolSearchRegex_20251119OutputSchema, toolSearchRegex_20251119InputSchema, factory9, toolSearchRegex_20251119, AnthropicMessagesLanguageModel, bash_20241022InputSchema, bash_20241022, bash_20250124InputSchema, bash_20250124, computer_20241022InputSchema, computer_20241022, computer_20250124InputSchema, computer_20250124, computer_20251124InputSchema, computer_20251124, memory_20250818InputSchema, memory_20250818, textEditor_20241022InputSchema, textEditor_20241022, textEditor_20250124InputSchema, textEditor_20250124, textEditor_20250429InputSchema, textEditor_20250429, toolSearchBm25_20251119OutputSchema, toolSearchBm25_20251119InputSchema, factory10, toolSearchBm25_20251119, anthropicTools, anthropic;
var init_dist13 = __esm({
  "node_modules/@ai-sdk/anthropic/dist/index.mjs"() {
    "use strict";
    init_dist3();
    init_dist5();
    init_dist3();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_dist3();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    VERSION8 = true ? "3.0.64" : "0.0.0-test";
    anthropicErrorDataSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          type: external_exports.literal("error"),
          error: external_exports.object({
            type: external_exports.string(),
            message: external_exports.string()
          })
        })
      )
    );
    anthropicFailedResponseHandler = createJsonErrorResponseHandler({
      errorSchema: anthropicErrorDataSchema,
      errorToMessage: (data) => data.error.message
    });
    anthropicMessagesResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          type: external_exports.literal("message"),
          id: external_exports.string().nullish(),
          model: external_exports.string().nullish(),
          content: external_exports.array(
            external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("text"),
                text: external_exports.string(),
                citations: external_exports.array(
                  external_exports.discriminatedUnion("type", [
                    external_exports.object({
                      type: external_exports.literal("web_search_result_location"),
                      cited_text: external_exports.string(),
                      url: external_exports.string(),
                      title: external_exports.string(),
                      encrypted_index: external_exports.string()
                    }),
                    external_exports.object({
                      type: external_exports.literal("page_location"),
                      cited_text: external_exports.string(),
                      document_index: external_exports.number(),
                      document_title: external_exports.string().nullable(),
                      start_page_number: external_exports.number(),
                      end_page_number: external_exports.number()
                    }),
                    external_exports.object({
                      type: external_exports.literal("char_location"),
                      cited_text: external_exports.string(),
                      document_index: external_exports.number(),
                      document_title: external_exports.string().nullable(),
                      start_char_index: external_exports.number(),
                      end_char_index: external_exports.number()
                    })
                  ])
                ).optional()
              }),
              external_exports.object({
                type: external_exports.literal("thinking"),
                thinking: external_exports.string(),
                signature: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("redacted_thinking"),
                data: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("compaction"),
                content: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.unknown(),
                // Programmatic tool calling: caller info when triggered from code execution
                caller: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_20250825"),
                    tool_id: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("code_execution_20260120"),
                    tool_id: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("direct")
                  })
                ]).optional()
              }),
              external_exports.object({
                type: external_exports.literal("server_tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
                caller: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_20260120"),
                    tool_id: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("direct")
                  })
                ]).optional()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.unknown(),
                server_name: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_tool_result"),
                tool_use_id: external_exports.string(),
                is_error: external_exports.boolean(),
                content: external_exports.array(
                  external_exports.union([
                    external_exports.string(),
                    external_exports.object({ type: external_exports.literal("text"), text: external_exports.string() })
                  ])
                )
              }),
              external_exports.object({
                type: external_exports.literal("web_fetch_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("web_fetch_result"),
                    url: external_exports.string(),
                    retrieved_at: external_exports.string(),
                    content: external_exports.object({
                      type: external_exports.literal("document"),
                      title: external_exports.string().nullable(),
                      citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
                      source: external_exports.union([
                        external_exports.object({
                          type: external_exports.literal("base64"),
                          media_type: external_exports.literal("application/pdf"),
                          data: external_exports.string()
                        }),
                        external_exports.object({
                          type: external_exports.literal("text"),
                          media_type: external_exports.literal("text/plain"),
                          data: external_exports.string()
                        })
                      ])
                    })
                  }),
                  external_exports.object({
                    type: external_exports.literal("web_fetch_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              external_exports.object({
                type: external_exports.literal("web_search_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.array(
                    external_exports.object({
                      type: external_exports.literal("web_search_result"),
                      url: external_exports.string(),
                      title: external_exports.string(),
                      encrypted_content: external_exports.string(),
                      page_age: external_exports.string().nullish()
                    })
                  ),
                  external_exports.object({
                    type: external_exports.literal("web_search_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // code execution results for code_execution_20250522 tool:
              external_exports.object({
                type: external_exports.literal("code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_result"),
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number(),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ).optional().default([])
                  }),
                  external_exports.object({
                    type: external_exports.literal("encrypted_code_execution_result"),
                    encrypted_stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number(),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ).optional().default([])
                  }),
                  external_exports.object({
                    type: external_exports.literal("code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // bash code execution results for code_execution_20250825 tool:
              external_exports.object({
                type: external_exports.literal("bash_code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("bash_code_execution_result"),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("bash_code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ),
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number()
                  }),
                  external_exports.object({
                    type: external_exports.literal("bash_code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // text editor code execution results for code_execution_20250825 tool:
              external_exports.object({
                type: external_exports.literal("text_editor_code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_view_result"),
                    content: external_exports.string(),
                    file_type: external_exports.string(),
                    num_lines: external_exports.number().nullable(),
                    start_line: external_exports.number().nullable(),
                    total_lines: external_exports.number().nullable()
                  }),
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_create_result"),
                    is_file_update: external_exports.boolean()
                  }),
                  external_exports.object({
                    type: external_exports.literal(
                      "text_editor_code_execution_str_replace_result"
                    ),
                    lines: external_exports.array(external_exports.string()).nullable(),
                    new_lines: external_exports.number().nullable(),
                    new_start: external_exports.number().nullable(),
                    old_lines: external_exports.number().nullable(),
                    old_start: external_exports.number().nullable()
                  })
                ])
              }),
              // tool search tool results for tool_search_tool_regex_20251119 and tool_search_tool_bm25_20251119:
              external_exports.object({
                type: external_exports.literal("tool_search_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("tool_search_tool_search_result"),
                    tool_references: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("tool_reference"),
                        tool_name: external_exports.string()
                      })
                    )
                  }),
                  external_exports.object({
                    type: external_exports.literal("tool_search_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              })
            ])
          ),
          stop_reason: external_exports.string().nullish(),
          stop_sequence: external_exports.string().nullish(),
          usage: external_exports.looseObject({
            input_tokens: external_exports.number(),
            output_tokens: external_exports.number(),
            cache_creation_input_tokens: external_exports.number().nullish(),
            cache_read_input_tokens: external_exports.number().nullish(),
            iterations: external_exports.array(
              external_exports.object({
                type: external_exports.union([external_exports.literal("compaction"), external_exports.literal("message")]),
                input_tokens: external_exports.number(),
                output_tokens: external_exports.number()
              })
            ).nullish()
          }),
          container: external_exports.object({
            expires_at: external_exports.string(),
            id: external_exports.string(),
            skills: external_exports.array(
              external_exports.object({
                type: external_exports.union([external_exports.literal("anthropic"), external_exports.literal("custom")]),
                skill_id: external_exports.string(),
                version: external_exports.string()
              })
            ).nullish()
          }).nullish(),
          context_management: external_exports.object({
            applied_edits: external_exports.array(
              external_exports.union([
                external_exports.object({
                  type: external_exports.literal("clear_tool_uses_20250919"),
                  cleared_tool_uses: external_exports.number(),
                  cleared_input_tokens: external_exports.number()
                }),
                external_exports.object({
                  type: external_exports.literal("clear_thinking_20251015"),
                  cleared_thinking_turns: external_exports.number(),
                  cleared_input_tokens: external_exports.number()
                }),
                external_exports.object({
                  type: external_exports.literal("compact_20260112")
                })
              ])
            )
          }).nullish()
        })
      )
    );
    anthropicMessagesChunkSchema = lazySchema(
      () => zodSchema(
        external_exports.discriminatedUnion("type", [
          external_exports.object({
            type: external_exports.literal("message_start"),
            message: external_exports.object({
              id: external_exports.string().nullish(),
              model: external_exports.string().nullish(),
              role: external_exports.string().nullish(),
              usage: external_exports.looseObject({
                input_tokens: external_exports.number(),
                cache_creation_input_tokens: external_exports.number().nullish(),
                cache_read_input_tokens: external_exports.number().nullish()
              }),
              // Programmatic tool calling: content may be pre-populated for deferred tool calls
              content: external_exports.array(
                external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("tool_use"),
                    id: external_exports.string(),
                    name: external_exports.string(),
                    input: external_exports.unknown(),
                    caller: external_exports.union([
                      external_exports.object({
                        type: external_exports.literal("code_execution_20250825"),
                        tool_id: external_exports.string()
                      }),
                      external_exports.object({
                        type: external_exports.literal("code_execution_20260120"),
                        tool_id: external_exports.string()
                      }),
                      external_exports.object({
                        type: external_exports.literal("direct")
                      })
                    ]).optional()
                  })
                ])
              ).nullish(),
              stop_reason: external_exports.string().nullish(),
              container: external_exports.object({
                expires_at: external_exports.string(),
                id: external_exports.string()
              }).nullish()
            })
          }),
          external_exports.object({
            type: external_exports.literal("content_block_start"),
            index: external_exports.number(),
            content_block: external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("text"),
                text: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("thinking"),
                thinking: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                // Programmatic tool calling: input may be present directly for deferred tool calls
                input: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
                // Programmatic tool calling: caller info when triggered from code execution
                caller: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_20250825"),
                    tool_id: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("code_execution_20260120"),
                    tool_id: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("direct")
                  })
                ]).optional()
              }),
              external_exports.object({
                type: external_exports.literal("redacted_thinking"),
                data: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("compaction"),
                content: external_exports.string().nullish()
              }),
              external_exports.object({
                type: external_exports.literal("server_tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.record(external_exports.string(), external_exports.unknown()).nullish(),
                caller: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_20260120"),
                    tool_id: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("direct")
                  })
                ]).optional()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.unknown(),
                server_name: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_tool_result"),
                tool_use_id: external_exports.string(),
                is_error: external_exports.boolean(),
                content: external_exports.array(
                  external_exports.union([
                    external_exports.string(),
                    external_exports.object({ type: external_exports.literal("text"), text: external_exports.string() })
                  ])
                )
              }),
              external_exports.object({
                type: external_exports.literal("web_fetch_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("web_fetch_result"),
                    url: external_exports.string(),
                    retrieved_at: external_exports.string(),
                    content: external_exports.object({
                      type: external_exports.literal("document"),
                      title: external_exports.string().nullable(),
                      citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
                      source: external_exports.union([
                        external_exports.object({
                          type: external_exports.literal("base64"),
                          media_type: external_exports.literal("application/pdf"),
                          data: external_exports.string()
                        }),
                        external_exports.object({
                          type: external_exports.literal("text"),
                          media_type: external_exports.literal("text/plain"),
                          data: external_exports.string()
                        })
                      ])
                    })
                  }),
                  external_exports.object({
                    type: external_exports.literal("web_fetch_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              external_exports.object({
                type: external_exports.literal("web_search_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.array(
                    external_exports.object({
                      type: external_exports.literal("web_search_result"),
                      url: external_exports.string(),
                      title: external_exports.string(),
                      encrypted_content: external_exports.string(),
                      page_age: external_exports.string().nullish()
                    })
                  ),
                  external_exports.object({
                    type: external_exports.literal("web_search_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // code execution results for code_execution_20250522 tool:
              external_exports.object({
                type: external_exports.literal("code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_result"),
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number(),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ).optional().default([])
                  }),
                  external_exports.object({
                    type: external_exports.literal("encrypted_code_execution_result"),
                    encrypted_stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number(),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ).optional().default([])
                  }),
                  external_exports.object({
                    type: external_exports.literal("code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // bash code execution results for code_execution_20250825 tool:
              external_exports.object({
                type: external_exports.literal("bash_code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("bash_code_execution_result"),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("bash_code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ),
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number()
                  }),
                  external_exports.object({
                    type: external_exports.literal("bash_code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // text editor code execution results for code_execution_20250825 tool:
              external_exports.object({
                type: external_exports.literal("text_editor_code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_view_result"),
                    content: external_exports.string(),
                    file_type: external_exports.string(),
                    num_lines: external_exports.number().nullable(),
                    start_line: external_exports.number().nullable(),
                    total_lines: external_exports.number().nullable()
                  }),
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_create_result"),
                    is_file_update: external_exports.boolean()
                  }),
                  external_exports.object({
                    type: external_exports.literal(
                      "text_editor_code_execution_str_replace_result"
                    ),
                    lines: external_exports.array(external_exports.string()).nullable(),
                    new_lines: external_exports.number().nullable(),
                    new_start: external_exports.number().nullable(),
                    old_lines: external_exports.number().nullable(),
                    old_start: external_exports.number().nullable()
                  })
                ])
              }),
              // tool search tool results for tool_search_tool_regex_20251119 and tool_search_tool_bm25_20251119:
              external_exports.object({
                type: external_exports.literal("tool_search_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("tool_search_tool_search_result"),
                    tool_references: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("tool_reference"),
                        tool_name: external_exports.string()
                      })
                    )
                  }),
                  external_exports.object({
                    type: external_exports.literal("tool_search_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              })
            ])
          }),
          external_exports.object({
            type: external_exports.literal("content_block_delta"),
            index: external_exports.number(),
            delta: external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("input_json_delta"),
                partial_json: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("text_delta"),
                text: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("thinking_delta"),
                thinking: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("signature_delta"),
                signature: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("compaction_delta"),
                content: external_exports.string().nullish()
              }),
              external_exports.object({
                type: external_exports.literal("citations_delta"),
                citation: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("web_search_result_location"),
                    cited_text: external_exports.string(),
                    url: external_exports.string(),
                    title: external_exports.string(),
                    encrypted_index: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("page_location"),
                    cited_text: external_exports.string(),
                    document_index: external_exports.number(),
                    document_title: external_exports.string().nullable(),
                    start_page_number: external_exports.number(),
                    end_page_number: external_exports.number()
                  }),
                  external_exports.object({
                    type: external_exports.literal("char_location"),
                    cited_text: external_exports.string(),
                    document_index: external_exports.number(),
                    document_title: external_exports.string().nullable(),
                    start_char_index: external_exports.number(),
                    end_char_index: external_exports.number()
                  })
                ])
              })
            ])
          }),
          external_exports.object({
            type: external_exports.literal("content_block_stop"),
            index: external_exports.number()
          }),
          external_exports.object({
            type: external_exports.literal("error"),
            error: external_exports.object({
              type: external_exports.string(),
              message: external_exports.string()
            })
          }),
          external_exports.object({
            type: external_exports.literal("message_delta"),
            delta: external_exports.object({
              stop_reason: external_exports.string().nullish(),
              stop_sequence: external_exports.string().nullish(),
              container: external_exports.object({
                expires_at: external_exports.string(),
                id: external_exports.string(),
                skills: external_exports.array(
                  external_exports.object({
                    type: external_exports.union([
                      external_exports.literal("anthropic"),
                      external_exports.literal("custom")
                    ]),
                    skill_id: external_exports.string(),
                    version: external_exports.string()
                  })
                ).nullish()
              }).nullish()
            }),
            usage: external_exports.looseObject({
              input_tokens: external_exports.number().nullish(),
              output_tokens: external_exports.number(),
              cache_creation_input_tokens: external_exports.number().nullish(),
              cache_read_input_tokens: external_exports.number().nullish(),
              iterations: external_exports.array(
                external_exports.object({
                  type: external_exports.union([external_exports.literal("compaction"), external_exports.literal("message")]),
                  input_tokens: external_exports.number(),
                  output_tokens: external_exports.number()
                })
              ).nullish()
            }),
            context_management: external_exports.object({
              applied_edits: external_exports.array(
                external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("clear_tool_uses_20250919"),
                    cleared_tool_uses: external_exports.number(),
                    cleared_input_tokens: external_exports.number()
                  }),
                  external_exports.object({
                    type: external_exports.literal("clear_thinking_20251015"),
                    cleared_thinking_turns: external_exports.number(),
                    cleared_input_tokens: external_exports.number()
                  }),
                  external_exports.object({
                    type: external_exports.literal("compact_20260112")
                  })
                ])
              )
            }).nullish()
          }),
          external_exports.object({
            type: external_exports.literal("message_stop")
          }),
          external_exports.object({
            type: external_exports.literal("ping")
          })
        ])
      )
    );
    anthropicReasoningMetadataSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          signature: external_exports.string().optional(),
          redactedData: external_exports.string().optional()
        })
      )
    );
    anthropicFilePartProviderOptions = external_exports.object({
      /**
       * Citation configuration for this document.
       * When enabled, this document will generate citations in the response.
       */
      citations: external_exports.object({
        /**
         * Enable citations for this document
         */
        enabled: external_exports.boolean()
      }).optional(),
      /**
       * Custom title for the document.
       * If not provided, the filename will be used.
       */
      title: external_exports.string().optional(),
      /**
       * Context about the document that will be passed to the model
       * but not used towards cited content.
       * Useful for storing document metadata as text or stringified JSON.
       */
      context: external_exports.string().optional()
    });
    anthropicLanguageModelOptions = external_exports.object({
      /**
       * Whether to send reasoning to the model.
       *
       * This allows you to deactivate reasoning inputs for models that do not support them.
       */
      sendReasoning: external_exports.boolean().optional(),
      /**
       * Determines how structured outputs are generated.
       *
       * - `outputFormat`: Use the `output_config.format` parameter to specify the structured output format.
       * - `jsonTool`: Use a special 'json' tool to specify the structured output format.
       * - `auto`: Use 'outputFormat' when supported, otherwise use 'jsonTool' (default).
       */
      structuredOutputMode: external_exports.enum(["outputFormat", "jsonTool", "auto"]).optional(),
      /**
       * Configuration for enabling Claude's extended thinking.
       *
       * When enabled, responses include thinking content blocks showing Claude's thinking process before the final answer.
       * Requires a minimum budget of 1,024 tokens and counts towards the `max_tokens` limit.
       */
      thinking: external_exports.discriminatedUnion("type", [
        external_exports.object({
          /** for Sonnet 4.6, Opus 4.6, and newer models */
          type: external_exports.literal("adaptive")
        }),
        external_exports.object({
          /** for models before Opus 4.6, except Sonnet 4.6 still supports it */
          type: external_exports.literal("enabled"),
          budgetTokens: external_exports.number().optional()
        }),
        external_exports.object({
          type: external_exports.literal("disabled")
        })
      ]).optional(),
      /**
       * Whether to disable parallel function calling during tool use. Default is false.
       * When set to true, Claude will use at most one tool per response.
       */
      disableParallelToolUse: external_exports.boolean().optional(),
      /**
       * Cache control settings for this message.
       * See https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
       */
      cacheControl: external_exports.object({
        type: external_exports.literal("ephemeral"),
        ttl: external_exports.union([external_exports.literal("5m"), external_exports.literal("1h")]).optional()
      }).optional(),
      /**
       * Metadata to include with the request.
       *
       * See https://platform.claude.com/docs/en/api/messages/create for details.
       */
      metadata: external_exports.object({
        /**
         * An external identifier for the user associated with the request.
         *
         * Should be a UUID, hash value, or other opaque identifier.
         * Must not contain PII (name, email, phone number, etc.).
         */
        userId: external_exports.string().optional()
      }).optional(),
      /**
       * MCP servers to be utilized in this request.
       */
      mcpServers: external_exports.array(
        external_exports.object({
          type: external_exports.literal("url"),
          name: external_exports.string(),
          url: external_exports.string(),
          authorizationToken: external_exports.string().nullish(),
          toolConfiguration: external_exports.object({
            enabled: external_exports.boolean().nullish(),
            allowedTools: external_exports.array(external_exports.string()).nullish()
          }).nullish()
        })
      ).optional(),
      /**
       * Agent Skills configuration. Skills enable Claude to perform specialized tasks
       * like document processing (PPTX, DOCX, PDF, XLSX) and data analysis.
       * Requires code execution tool to be enabled.
       */
      container: external_exports.object({
        id: external_exports.string().optional(),
        skills: external_exports.array(
          external_exports.object({
            type: external_exports.union([external_exports.literal("anthropic"), external_exports.literal("custom")]),
            skillId: external_exports.string(),
            version: external_exports.string().optional()
          })
        ).optional()
      }).optional(),
      /**
       * Whether to enable tool streaming (and structured output streaming).
       *
       * When set to false, the model will return all tool calls and results
       * at once after a delay.
       *
       * @default true
       */
      toolStreaming: external_exports.boolean().optional(),
      /**
       * @default 'high'
       */
      effort: external_exports.enum(["low", "medium", "high", "max"]).optional(),
      /**
       * Enable fast mode for faster inference (2.5x faster output token speeds).
       * Only supported with claude-opus-4-6.
       */
      speed: external_exports.enum(["fast", "standard"]).optional(),
      /**
       * A set of beta features to enable.
       * Allow a provider to receive the full `betas` set if it needs it.
       */
      anthropicBeta: external_exports.array(external_exports.string()).optional(),
      contextManagement: external_exports.object({
        edits: external_exports.array(
          external_exports.discriminatedUnion("type", [
            external_exports.object({
              type: external_exports.literal("clear_tool_uses_20250919"),
              trigger: external_exports.discriminatedUnion("type", [
                external_exports.object({
                  type: external_exports.literal("input_tokens"),
                  value: external_exports.number()
                }),
                external_exports.object({
                  type: external_exports.literal("tool_uses"),
                  value: external_exports.number()
                })
              ]).optional(),
              keep: external_exports.object({
                type: external_exports.literal("tool_uses"),
                value: external_exports.number()
              }).optional(),
              clearAtLeast: external_exports.object({
                type: external_exports.literal("input_tokens"),
                value: external_exports.number()
              }).optional(),
              clearToolInputs: external_exports.boolean().optional(),
              excludeTools: external_exports.array(external_exports.string()).optional()
            }),
            external_exports.object({
              type: external_exports.literal("clear_thinking_20251015"),
              keep: external_exports.union([
                external_exports.literal("all"),
                external_exports.object({
                  type: external_exports.literal("thinking_turns"),
                  value: external_exports.number()
                })
              ]).optional()
            }),
            external_exports.object({
              type: external_exports.literal("compact_20260112"),
              trigger: external_exports.object({
                type: external_exports.literal("input_tokens"),
                value: external_exports.number()
              }).optional(),
              pauseAfterCompaction: external_exports.boolean().optional(),
              instructions: external_exports.string().optional()
            })
          ])
        )
      }).optional()
    });
    MAX_CACHE_BREAKPOINTS = 4;
    CacheControlValidator = class {
      constructor() {
        this.breakpointCount = 0;
        this.warnings = [];
      }
      getCacheControl(providerMetadata, context2) {
        const cacheControlValue = getCacheControl(providerMetadata);
        if (!cacheControlValue) {
          return void 0;
        }
        if (!context2.canCache) {
          this.warnings.push({
            type: "unsupported",
            feature: "cache_control on non-cacheable context",
            details: `cache_control cannot be set on ${context2.type}. It will be ignored.`
          });
          return void 0;
        }
        this.breakpointCount++;
        if (this.breakpointCount > MAX_CACHE_BREAKPOINTS) {
          this.warnings.push({
            type: "unsupported",
            feature: "cacheControl breakpoint limit",
            details: `Maximum ${MAX_CACHE_BREAKPOINTS} cache breakpoints exceeded (found ${this.breakpointCount}). This breakpoint will be ignored.`
          });
          return void 0;
        }
        return cacheControlValue;
      }
      getWarnings() {
        return this.warnings;
      }
    };
    textEditor_20250728ArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          maxCharacters: external_exports.number().optional()
        })
      )
    );
    textEditor_20250728InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          command: external_exports.enum(["view", "create", "str_replace", "insert"]),
          path: external_exports.string(),
          file_text: external_exports.string().optional(),
          insert_line: external_exports.number().int().optional(),
          new_str: external_exports.string().optional(),
          insert_text: external_exports.string().optional(),
          old_str: external_exports.string().optional(),
          view_range: external_exports.array(external_exports.number().int()).optional()
        })
      )
    );
    factory2 = createProviderToolFactory({
      id: "anthropic.text_editor_20250728",
      inputSchema: textEditor_20250728InputSchema
    });
    textEditor_20250728 = (args = {}) => {
      return factory2(args);
    };
    webSearch_20260209ArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          maxUses: external_exports.number().optional(),
          allowedDomains: external_exports.array(external_exports.string()).optional(),
          blockedDomains: external_exports.array(external_exports.string()).optional(),
          userLocation: external_exports.object({
            type: external_exports.literal("approximate"),
            city: external_exports.string().optional(),
            region: external_exports.string().optional(),
            country: external_exports.string().optional(),
            timezone: external_exports.string().optional()
          }).optional()
        })
      )
    );
    webSearch_20260209OutputSchema = lazySchema(
      () => zodSchema(
        external_exports.array(
          external_exports.object({
            url: external_exports.string(),
            title: external_exports.string().nullable(),
            pageAge: external_exports.string().nullable(),
            encryptedContent: external_exports.string(),
            type: external_exports.literal("web_search_result")
          })
        )
      )
    );
    webSearch_20260209InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          query: external_exports.string()
        })
      )
    );
    factory22 = createProviderToolFactoryWithOutputSchema({
      id: "anthropic.web_search_20260209",
      inputSchema: webSearch_20260209InputSchema,
      outputSchema: webSearch_20260209OutputSchema,
      supportsDeferredResults: true
    });
    webSearch_20260209 = (args = {}) => {
      return factory22(args);
    };
    webSearch_20250305ArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          maxUses: external_exports.number().optional(),
          allowedDomains: external_exports.array(external_exports.string()).optional(),
          blockedDomains: external_exports.array(external_exports.string()).optional(),
          userLocation: external_exports.object({
            type: external_exports.literal("approximate"),
            city: external_exports.string().optional(),
            region: external_exports.string().optional(),
            country: external_exports.string().optional(),
            timezone: external_exports.string().optional()
          }).optional()
        })
      )
    );
    webSearch_20250305OutputSchema = lazySchema(
      () => zodSchema(
        external_exports.array(
          external_exports.object({
            url: external_exports.string(),
            title: external_exports.string().nullable(),
            pageAge: external_exports.string().nullable(),
            encryptedContent: external_exports.string(),
            type: external_exports.literal("web_search_result")
          })
        )
      )
    );
    webSearch_20250305InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          query: external_exports.string()
        })
      )
    );
    factory3 = createProviderToolFactoryWithOutputSchema({
      id: "anthropic.web_search_20250305",
      inputSchema: webSearch_20250305InputSchema,
      outputSchema: webSearch_20250305OutputSchema,
      supportsDeferredResults: true
    });
    webSearch_20250305 = (args = {}) => {
      return factory3(args);
    };
    webFetch_20260209ArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          maxUses: external_exports.number().optional(),
          allowedDomains: external_exports.array(external_exports.string()).optional(),
          blockedDomains: external_exports.array(external_exports.string()).optional(),
          citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
          maxContentTokens: external_exports.number().optional()
        })
      )
    );
    webFetch_20260209OutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          type: external_exports.literal("web_fetch_result"),
          url: external_exports.string(),
          content: external_exports.object({
            type: external_exports.literal("document"),
            title: external_exports.string().nullable(),
            citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
            source: external_exports.union([
              external_exports.object({
                type: external_exports.literal("base64"),
                mediaType: external_exports.literal("application/pdf"),
                data: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("text"),
                mediaType: external_exports.literal("text/plain"),
                data: external_exports.string()
              })
            ])
          }),
          retrievedAt: external_exports.string().nullable()
        })
      )
    );
    webFetch_20260209InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          url: external_exports.string()
        })
      )
    );
    factory4 = createProviderToolFactoryWithOutputSchema({
      id: "anthropic.web_fetch_20260209",
      inputSchema: webFetch_20260209InputSchema,
      outputSchema: webFetch_20260209OutputSchema,
      supportsDeferredResults: true
    });
    webFetch_20260209 = (args = {}) => {
      return factory4(args);
    };
    webFetch_20250910ArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          maxUses: external_exports.number().optional(),
          allowedDomains: external_exports.array(external_exports.string()).optional(),
          blockedDomains: external_exports.array(external_exports.string()).optional(),
          citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
          maxContentTokens: external_exports.number().optional()
        })
      )
    );
    webFetch_20250910OutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          type: external_exports.literal("web_fetch_result"),
          url: external_exports.string(),
          content: external_exports.object({
            type: external_exports.literal("document"),
            title: external_exports.string().nullable(),
            citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
            source: external_exports.union([
              external_exports.object({
                type: external_exports.literal("base64"),
                mediaType: external_exports.literal("application/pdf"),
                data: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("text"),
                mediaType: external_exports.literal("text/plain"),
                data: external_exports.string()
              })
            ])
          }),
          retrievedAt: external_exports.string().nullable()
        })
      )
    );
    webFetch_20250910InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          url: external_exports.string()
        })
      )
    );
    factory5 = createProviderToolFactoryWithOutputSchema({
      id: "anthropic.web_fetch_20250910",
      inputSchema: webFetch_20250910InputSchema,
      outputSchema: webFetch_20250910OutputSchema,
      supportsDeferredResults: true
    });
    webFetch_20250910 = (args = {}) => {
      return factory5(args);
    };
    codeExecution_20250522OutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          type: external_exports.literal("code_execution_result"),
          stdout: external_exports.string(),
          stderr: external_exports.string(),
          return_code: external_exports.number(),
          content: external_exports.array(
            external_exports.object({
              type: external_exports.literal("code_execution_output"),
              file_id: external_exports.string()
            })
          ).optional().default([])
        })
      )
    );
    codeExecution_20250522InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          code: external_exports.string()
        })
      )
    );
    factory6 = createProviderToolFactoryWithOutputSchema({
      id: "anthropic.code_execution_20250522",
      inputSchema: codeExecution_20250522InputSchema,
      outputSchema: codeExecution_20250522OutputSchema
    });
    codeExecution_20250522 = (args = {}) => {
      return factory6(args);
    };
    codeExecution_20250825OutputSchema = lazySchema(
      () => zodSchema(
        external_exports.discriminatedUnion("type", [
          external_exports.object({
            type: external_exports.literal("code_execution_result"),
            stdout: external_exports.string(),
            stderr: external_exports.string(),
            return_code: external_exports.number(),
            content: external_exports.array(
              external_exports.object({
                type: external_exports.literal("code_execution_output"),
                file_id: external_exports.string()
              })
            ).optional().default([])
          }),
          external_exports.object({
            type: external_exports.literal("bash_code_execution_result"),
            content: external_exports.array(
              external_exports.object({
                type: external_exports.literal("bash_code_execution_output"),
                file_id: external_exports.string()
              })
            ),
            stdout: external_exports.string(),
            stderr: external_exports.string(),
            return_code: external_exports.number()
          }),
          external_exports.object({
            type: external_exports.literal("bash_code_execution_tool_result_error"),
            error_code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_tool_result_error"),
            error_code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_view_result"),
            content: external_exports.string(),
            file_type: external_exports.string(),
            num_lines: external_exports.number().nullable(),
            start_line: external_exports.number().nullable(),
            total_lines: external_exports.number().nullable()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_create_result"),
            is_file_update: external_exports.boolean()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_str_replace_result"),
            lines: external_exports.array(external_exports.string()).nullable(),
            new_lines: external_exports.number().nullable(),
            new_start: external_exports.number().nullable(),
            old_lines: external_exports.number().nullable(),
            old_start: external_exports.number().nullable()
          })
        ])
      )
    );
    codeExecution_20250825InputSchema = lazySchema(
      () => zodSchema(
        external_exports.discriminatedUnion("type", [
          // Programmatic tool calling format (mapped from { code } by AI SDK)
          external_exports.object({
            type: external_exports.literal("programmatic-tool-call"),
            code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("bash_code_execution"),
            command: external_exports.string()
          }),
          external_exports.discriminatedUnion("command", [
            external_exports.object({
              type: external_exports.literal("text_editor_code_execution"),
              command: external_exports.literal("view"),
              path: external_exports.string()
            }),
            external_exports.object({
              type: external_exports.literal("text_editor_code_execution"),
              command: external_exports.literal("create"),
              path: external_exports.string(),
              file_text: external_exports.string().nullish()
            }),
            external_exports.object({
              type: external_exports.literal("text_editor_code_execution"),
              command: external_exports.literal("str_replace"),
              path: external_exports.string(),
              old_str: external_exports.string(),
              new_str: external_exports.string()
            })
          ])
        ])
      )
    );
    factory7 = createProviderToolFactoryWithOutputSchema({
      id: "anthropic.code_execution_20250825",
      inputSchema: codeExecution_20250825InputSchema,
      outputSchema: codeExecution_20250825OutputSchema,
      // Programmatic tool calling: tool results may be deferred to a later turn
      // when code execution triggers a client-executed tool that needs to be
      // resolved before the code execution result can be returned.
      supportsDeferredResults: true
    });
    codeExecution_20250825 = (args = {}) => {
      return factory7(args);
    };
    codeExecution_20260120OutputSchema = lazySchema(
      () => zodSchema(
        external_exports.discriminatedUnion("type", [
          external_exports.object({
            type: external_exports.literal("code_execution_result"),
            stdout: external_exports.string(),
            stderr: external_exports.string(),
            return_code: external_exports.number(),
            content: external_exports.array(
              external_exports.object({
                type: external_exports.literal("code_execution_output"),
                file_id: external_exports.string()
              })
            ).optional().default([])
          }),
          external_exports.object({
            type: external_exports.literal("encrypted_code_execution_result"),
            encrypted_stdout: external_exports.string(),
            stderr: external_exports.string(),
            return_code: external_exports.number(),
            content: external_exports.array(
              external_exports.object({
                type: external_exports.literal("code_execution_output"),
                file_id: external_exports.string()
              })
            ).optional().default([])
          }),
          external_exports.object({
            type: external_exports.literal("bash_code_execution_result"),
            content: external_exports.array(
              external_exports.object({
                type: external_exports.literal("bash_code_execution_output"),
                file_id: external_exports.string()
              })
            ),
            stdout: external_exports.string(),
            stderr: external_exports.string(),
            return_code: external_exports.number()
          }),
          external_exports.object({
            type: external_exports.literal("bash_code_execution_tool_result_error"),
            error_code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_tool_result_error"),
            error_code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_view_result"),
            content: external_exports.string(),
            file_type: external_exports.string(),
            num_lines: external_exports.number().nullable(),
            start_line: external_exports.number().nullable(),
            total_lines: external_exports.number().nullable()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_create_result"),
            is_file_update: external_exports.boolean()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_str_replace_result"),
            lines: external_exports.array(external_exports.string()).nullable(),
            new_lines: external_exports.number().nullable(),
            new_start: external_exports.number().nullable(),
            old_lines: external_exports.number().nullable(),
            old_start: external_exports.number().nullable()
          })
        ])
      )
    );
    codeExecution_20260120InputSchema = lazySchema(
      () => zodSchema(
        external_exports.discriminatedUnion("type", [
          external_exports.object({
            type: external_exports.literal("programmatic-tool-call"),
            code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("bash_code_execution"),
            command: external_exports.string()
          }),
          external_exports.discriminatedUnion("command", [
            external_exports.object({
              type: external_exports.literal("text_editor_code_execution"),
              command: external_exports.literal("view"),
              path: external_exports.string()
            }),
            external_exports.object({
              type: external_exports.literal("text_editor_code_execution"),
              command: external_exports.literal("create"),
              path: external_exports.string(),
              file_text: external_exports.string().nullish()
            }),
            external_exports.object({
              type: external_exports.literal("text_editor_code_execution"),
              command: external_exports.literal("str_replace"),
              path: external_exports.string(),
              old_str: external_exports.string(),
              new_str: external_exports.string()
            })
          ])
        ])
      )
    );
    factory8 = createProviderToolFactoryWithOutputSchema({
      id: "anthropic.code_execution_20260120",
      inputSchema: codeExecution_20260120InputSchema,
      outputSchema: codeExecution_20260120OutputSchema,
      supportsDeferredResults: true
    });
    codeExecution_20260120 = (args = {}) => {
      return factory8(args);
    };
    toolSearchRegex_20251119OutputSchema = lazySchema(
      () => zodSchema(
        external_exports.array(
          external_exports.object({
            type: external_exports.literal("tool_reference"),
            toolName: external_exports.string()
          })
        )
      )
    );
    toolSearchRegex_20251119InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          /**
           * A regex pattern to search for tools.
           * Uses Python re.search() syntax. Maximum 200 characters.
           *
           * Examples:
           * - "weather" - matches tool names/descriptions containing "weather"
           * - "get_.*_data" - matches tools like get_user_data, get_weather_data
           * - "database.*query|query.*database" - OR patterns for flexibility
           * - "(?i)slack" - case-insensitive search
           */
          pattern: external_exports.string(),
          /**
           * Maximum number of tools to return. Optional.
           */
          limit: external_exports.number().optional()
        })
      )
    );
    factory9 = createProviderToolFactoryWithOutputSchema({
      id: "anthropic.tool_search_regex_20251119",
      inputSchema: toolSearchRegex_20251119InputSchema,
      outputSchema: toolSearchRegex_20251119OutputSchema,
      supportsDeferredResults: true
    });
    toolSearchRegex_20251119 = (args = {}) => {
      return factory9(args);
    };
    AnthropicMessagesLanguageModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        var _a31;
        this.modelId = modelId;
        this.config = config3;
        this.generateId = (_a31 = config3.generateId) != null ? _a31 : generateId;
      }
      supportsUrl(url4) {
        return url4.protocol === "https:";
      }
      get provider() {
        return this.config.provider;
      }
      /**
       * Extracts the dynamic provider name from the config.provider string.
       * e.g., 'my-custom-anthropic.messages' -> 'my-custom-anthropic'
       */
      get providerOptionsName() {
        const provider = this.config.provider;
        const dotIndex = provider.indexOf(".");
        return dotIndex === -1 ? provider : provider.substring(0, dotIndex);
      }
      get supportedUrls() {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).supportedUrls) == null ? void 0 : _b27.call(_a31)) != null ? _c : {};
      }
      async getArgs({
        userSuppliedBetas,
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        stopSequences,
        responseFormat,
        seed,
        tools,
        toolChoice,
        providerOptions,
        stream: stream4
      }) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h, _i;
        const warnings = [];
        if (frequencyPenalty != null) {
          warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
        }
        if (presencePenalty != null) {
          warnings.push({ type: "unsupported", feature: "presencePenalty" });
        }
        if (seed != null) {
          warnings.push({ type: "unsupported", feature: "seed" });
        }
        if (temperature != null && temperature > 1) {
          warnings.push({
            type: "unsupported",
            feature: "temperature",
            details: `${temperature} exceeds anthropic maximum of 1.0. clamped to 1.0`
          });
          temperature = 1;
        } else if (temperature != null && temperature < 0) {
          warnings.push({
            type: "unsupported",
            feature: "temperature",
            details: `${temperature} is below anthropic minimum of 0. clamped to 0`
          });
          temperature = 0;
        }
        if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
          if (responseFormat.schema == null) {
            warnings.push({
              type: "unsupported",
              feature: "responseFormat",
              details: "JSON response format requires a schema. The response format is ignored."
            });
          }
        }
        const providerOptionsName = this.providerOptionsName;
        const canonicalOptions = await parseProviderOptions({
          provider: "anthropic",
          providerOptions,
          schema: anthropicLanguageModelOptions
        });
        const customProviderOptions = providerOptionsName !== "anthropic" ? await parseProviderOptions({
          provider: providerOptionsName,
          providerOptions,
          schema: anthropicLanguageModelOptions
        }) : null;
        const usedCustomProviderKey = customProviderOptions != null;
        const anthropicOptions = Object.assign(
          {},
          canonicalOptions != null ? canonicalOptions : {},
          customProviderOptions != null ? customProviderOptions : {}
        );
        const {
          maxOutputTokens: maxOutputTokensForModel,
          supportsStructuredOutput: modelSupportsStructuredOutput,
          isKnownModel
        } = getModelCapabilities(this.modelId);
        const supportsStructuredOutput = ((_a31 = this.config.supportsNativeStructuredOutput) != null ? _a31 : true) && modelSupportsStructuredOutput;
        const supportsStrictTools = ((_b27 = this.config.supportsStrictTools) != null ? _b27 : true) && modelSupportsStructuredOutput;
        const structureOutputMode = (_c = anthropicOptions == null ? void 0 : anthropicOptions.structuredOutputMode) != null ? _c : "auto";
        const useStructuredOutput = structureOutputMode === "outputFormat" || structureOutputMode === "auto" && supportsStructuredOutput;
        const jsonResponseTool = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !useStructuredOutput ? {
          type: "function",
          name: "json",
          description: "Respond with a JSON object.",
          inputSchema: responseFormat.schema
        } : void 0;
        const contextManagement = anthropicOptions == null ? void 0 : anthropicOptions.contextManagement;
        const cacheControlValidator = new CacheControlValidator();
        const toolNameMapping = createToolNameMapping({
          tools,
          providerToolNames: {
            "anthropic.code_execution_20250522": "code_execution",
            "anthropic.code_execution_20250825": "code_execution",
            "anthropic.code_execution_20260120": "code_execution",
            "anthropic.computer_20241022": "computer",
            "anthropic.computer_20250124": "computer",
            "anthropic.text_editor_20241022": "str_replace_editor",
            "anthropic.text_editor_20250124": "str_replace_editor",
            "anthropic.text_editor_20250429": "str_replace_based_edit_tool",
            "anthropic.text_editor_20250728": "str_replace_based_edit_tool",
            "anthropic.bash_20241022": "bash",
            "anthropic.bash_20250124": "bash",
            "anthropic.memory_20250818": "memory",
            "anthropic.web_search_20250305": "web_search",
            "anthropic.web_search_20260209": "web_search",
            "anthropic.web_fetch_20250910": "web_fetch",
            "anthropic.web_fetch_20260209": "web_fetch",
            "anthropic.tool_search_regex_20251119": "tool_search_tool_regex",
            "anthropic.tool_search_bm25_20251119": "tool_search_tool_bm25"
          }
        });
        const { prompt: messagesPrompt, betas } = await convertToAnthropicMessagesPrompt({
          prompt,
          sendReasoning: (_d = anthropicOptions == null ? void 0 : anthropicOptions.sendReasoning) != null ? _d : true,
          warnings,
          cacheControlValidator,
          toolNameMapping
        });
        const thinkingType = (_e = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _e.type;
        const isThinking = thinkingType === "enabled" || thinkingType === "adaptive";
        let thinkingBudget = thinkingType === "enabled" ? (_f = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _f.budgetTokens : void 0;
        const maxTokens = maxOutputTokens != null ? maxOutputTokens : maxOutputTokensForModel;
        const baseArgs = {
          // model id:
          model: this.modelId,
          // standardized settings:
          max_tokens: maxTokens,
          temperature,
          top_k: topK,
          top_p: topP,
          stop_sequences: stopSequences,
          // provider specific settings:
          ...isThinking && {
            thinking: {
              type: thinkingType,
              ...thinkingBudget != null && { budget_tokens: thinkingBudget }
            }
          },
          ...((anthropicOptions == null ? void 0 : anthropicOptions.effort) || useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null) && {
            output_config: {
              ...(anthropicOptions == null ? void 0 : anthropicOptions.effort) && {
                effort: anthropicOptions.effort
              },
              ...useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && {
                format: {
                  type: "json_schema",
                  schema: responseFormat.schema
                }
              }
            }
          },
          ...(anthropicOptions == null ? void 0 : anthropicOptions.speed) && {
            speed: anthropicOptions.speed
          },
          ...(anthropicOptions == null ? void 0 : anthropicOptions.cacheControl) && {
            cache_control: anthropicOptions.cacheControl
          },
          ...((_g = anthropicOptions == null ? void 0 : anthropicOptions.metadata) == null ? void 0 : _g.userId) != null && {
            metadata: { user_id: anthropicOptions.metadata.userId }
          },
          // mcp servers:
          ...(anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0 && {
            mcp_servers: anthropicOptions.mcpServers.map((server2) => ({
              type: server2.type,
              name: server2.name,
              url: server2.url,
              authorization_token: server2.authorizationToken,
              tool_configuration: server2.toolConfiguration ? {
                allowed_tools: server2.toolConfiguration.allowedTools,
                enabled: server2.toolConfiguration.enabled
              } : void 0
            }))
          },
          // container: For programmatic tool calling (just an ID string) or agent skills (object with id and skills)
          ...(anthropicOptions == null ? void 0 : anthropicOptions.container) && {
            container: anthropicOptions.container.skills && anthropicOptions.container.skills.length > 0 ? (
              // Object format when skills are provided (agent skills feature)
              {
                id: anthropicOptions.container.id,
                skills: anthropicOptions.container.skills.map((skill) => ({
                  type: skill.type,
                  skill_id: skill.skillId,
                  version: skill.version
                }))
              }
            ) : (
              // String format for container ID only (programmatic tool calling)
              anthropicOptions.container.id
            )
          },
          // prompt:
          system: messagesPrompt.system,
          messages: messagesPrompt.messages,
          ...contextManagement && {
            context_management: {
              edits: contextManagement.edits.map((edit) => {
                const strategy = edit.type;
                switch (strategy) {
                  case "clear_tool_uses_20250919":
                    return {
                      type: edit.type,
                      ...edit.trigger !== void 0 && {
                        trigger: edit.trigger
                      },
                      ...edit.keep !== void 0 && { keep: edit.keep },
                      ...edit.clearAtLeast !== void 0 && {
                        clear_at_least: edit.clearAtLeast
                      },
                      ...edit.clearToolInputs !== void 0 && {
                        clear_tool_inputs: edit.clearToolInputs
                      },
                      ...edit.excludeTools !== void 0 && {
                        exclude_tools: edit.excludeTools
                      }
                    };
                  case "clear_thinking_20251015":
                    return {
                      type: edit.type,
                      ...edit.keep !== void 0 && { keep: edit.keep }
                    };
                  case "compact_20260112":
                    return {
                      type: edit.type,
                      ...edit.trigger !== void 0 && {
                        trigger: edit.trigger
                      },
                      ...edit.pauseAfterCompaction !== void 0 && {
                        pause_after_compaction: edit.pauseAfterCompaction
                      },
                      ...edit.instructions !== void 0 && {
                        instructions: edit.instructions
                      }
                    };
                  default:
                    warnings.push({
                      type: "other",
                      message: `Unknown context management strategy: ${strategy}`
                    });
                    return void 0;
                }
              }).filter((edit) => edit !== void 0)
            }
          }
        };
        if (isThinking) {
          if (thinkingType === "enabled" && thinkingBudget == null) {
            warnings.push({
              type: "compatibility",
              feature: "extended thinking",
              details: "thinking budget is required when thinking is enabled. using default budget of 1024 tokens."
            });
            baseArgs.thinking = {
              type: "enabled",
              budget_tokens: 1024
            };
            thinkingBudget = 1024;
          }
          if (baseArgs.temperature != null) {
            baseArgs.temperature = void 0;
            warnings.push({
              type: "unsupported",
              feature: "temperature",
              details: "temperature is not supported when thinking is enabled"
            });
          }
          if (topK != null) {
            baseArgs.top_k = void 0;
            warnings.push({
              type: "unsupported",
              feature: "topK",
              details: "topK is not supported when thinking is enabled"
            });
          }
          if (topP != null) {
            baseArgs.top_p = void 0;
            warnings.push({
              type: "unsupported",
              feature: "topP",
              details: "topP is not supported when thinking is enabled"
            });
          }
          baseArgs.max_tokens = maxTokens + (thinkingBudget != null ? thinkingBudget : 0);
        } else {
          if (topP != null && temperature != null) {
            warnings.push({
              type: "unsupported",
              feature: "topP",
              details: `topP is not supported when temperature is set. topP is ignored.`
            });
            baseArgs.top_p = void 0;
          }
        }
        if (isKnownModel && baseArgs.max_tokens > maxOutputTokensForModel) {
          if (maxOutputTokens != null) {
            warnings.push({
              type: "unsupported",
              feature: "maxOutputTokens",
              details: `${baseArgs.max_tokens} (maxOutputTokens + thinkingBudget) is greater than ${this.modelId} ${maxOutputTokensForModel} max output tokens. The max output tokens have been limited to ${maxOutputTokensForModel}.`
            });
          }
          baseArgs.max_tokens = maxOutputTokensForModel;
        }
        if ((anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0) {
          betas.add("mcp-client-2025-04-04");
        }
        if (contextManagement) {
          betas.add("context-management-2025-06-27");
          if (contextManagement.edits.some((e) => e.type === "compact_20260112")) {
            betas.add("compact-2026-01-12");
          }
        }
        if ((anthropicOptions == null ? void 0 : anthropicOptions.container) && anthropicOptions.container.skills && anthropicOptions.container.skills.length > 0) {
          betas.add("code-execution-2025-08-25");
          betas.add("skills-2025-10-02");
          betas.add("files-api-2025-04-14");
          if (!(tools == null ? void 0 : tools.some(
            (tool3) => tool3.type === "provider" && (tool3.id === "anthropic.code_execution_20250825" || tool3.id === "anthropic.code_execution_20260120")
          ))) {
            warnings.push({
              type: "other",
              message: "code execution tool is required when using skills"
            });
          }
        }
        if (anthropicOptions == null ? void 0 : anthropicOptions.effort) {
          betas.add("effort-2025-11-24");
        }
        if ((anthropicOptions == null ? void 0 : anthropicOptions.speed) === "fast") {
          betas.add("fast-mode-2026-02-01");
        }
        if (stream4 && ((_h = anthropicOptions == null ? void 0 : anthropicOptions.toolStreaming) != null ? _h : true)) {
          betas.add("fine-grained-tool-streaming-2025-05-14");
        }
        const {
          tools: anthropicTools2,
          toolChoice: anthropicToolChoice,
          toolWarnings,
          betas: toolsBetas
        } = await prepareTools3(
          jsonResponseTool != null ? {
            tools: [...tools != null ? tools : [], jsonResponseTool],
            toolChoice: { type: "required" },
            disableParallelToolUse: true,
            cacheControlValidator,
            supportsStructuredOutput: false,
            supportsStrictTools
          } : {
            tools: tools != null ? tools : [],
            toolChoice,
            disableParallelToolUse: anthropicOptions == null ? void 0 : anthropicOptions.disableParallelToolUse,
            cacheControlValidator,
            supportsStructuredOutput,
            supportsStrictTools
          }
        );
        const cacheWarnings = cacheControlValidator.getWarnings();
        return {
          args: {
            ...baseArgs,
            tools: anthropicTools2,
            tool_choice: anthropicToolChoice,
            stream: stream4 === true ? true : void 0
            // do not send when not streaming
          },
          warnings: [...warnings, ...toolWarnings, ...cacheWarnings],
          betas: /* @__PURE__ */ new Set([
            ...betas,
            ...toolsBetas,
            ...userSuppliedBetas,
            ...(_i = anthropicOptions == null ? void 0 : anthropicOptions.anthropicBeta) != null ? _i : []
          ]),
          usesJsonResponseTool: jsonResponseTool != null,
          toolNameMapping,
          providerOptionsName,
          usedCustomProviderKey
        };
      }
      async getHeaders({
        betas,
        headers
      }) {
        return combineHeaders(
          await resolve(this.config.headers),
          headers,
          betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {}
        );
      }
      async getBetasFromHeaders(requestHeaders) {
        var _a31, _b27;
        const configHeaders = await resolve(this.config.headers);
        const configBetaHeader = (_a31 = configHeaders["anthropic-beta"]) != null ? _a31 : "";
        const requestBetaHeader = (_b27 = requestHeaders == null ? void 0 : requestHeaders["anthropic-beta"]) != null ? _b27 : "";
        return new Set(
          [
            ...configBetaHeader.toLowerCase().split(","),
            ...requestBetaHeader.toLowerCase().split(",")
          ].map((beta) => beta.trim()).filter((beta) => beta !== "")
        );
      }
      buildRequestUrl(isStreaming) {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).buildRequestUrl) == null ? void 0 : _b27.call(_a31, this.config.baseURL, isStreaming)) != null ? _c : `${this.config.baseURL}/messages`;
      }
      transformRequestBody(args, betas) {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).transformRequestBody) == null ? void 0 : _b27.call(_a31, args, betas)) != null ? _c : args;
      }
      extractCitationDocuments(prompt) {
        const isCitationPart = (part) => {
          var _a31, _b27;
          if (part.type !== "file") {
            return false;
          }
          if (part.mediaType !== "application/pdf" && part.mediaType !== "text/plain") {
            return false;
          }
          const anthropic2 = (_a31 = part.providerOptions) == null ? void 0 : _a31.anthropic;
          const citationsConfig = anthropic2 == null ? void 0 : anthropic2.citations;
          return (_b27 = citationsConfig == null ? void 0 : citationsConfig.enabled) != null ? _b27 : false;
        };
        return prompt.filter((message) => message.role === "user").flatMap((message) => message.content).filter(isCitationPart).map((part) => {
          var _a31;
          const filePart = part;
          return {
            title: (_a31 = filePart.filename) != null ? _a31 : "Untitled Document",
            filename: filePart.filename,
            mediaType: filePart.mediaType
          };
        });
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g;
        const {
          args,
          warnings,
          betas,
          usesJsonResponseTool,
          toolNameMapping,
          providerOptionsName,
          usedCustomProviderKey
        } = await this.getArgs({
          ...options,
          stream: false,
          userSuppliedBetas: await this.getBetasFromHeaders(options.headers)
        });
        const citationDocuments = [
          ...this.extractCitationDocuments(options.prompt)
        ];
        const markCodeExecutionDynamic = hasWebTool20260209WithoutCodeExecution(
          args.tools
        );
        const {
          responseHeaders,
          value: response,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: this.buildRequestUrl(false),
          headers: await this.getHeaders({ betas, headers: options.headers }),
          body: this.transformRequestBody(args, betas),
          failedResponseHandler: anthropicFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            anthropicMessagesResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const content = [];
        const mcpToolCalls = {};
        const serverToolCalls = {};
        let isJsonResponseFromTool = false;
        for (const part of response.content) {
          switch (part.type) {
            case "text": {
              if (!usesJsonResponseTool) {
                content.push({ type: "text", text: part.text });
                if (part.citations) {
                  for (const citation of part.citations) {
                    const source = createCitationSource(
                      citation,
                      citationDocuments,
                      this.generateId
                    );
                    if (source) {
                      content.push(source);
                    }
                  }
                }
              }
              break;
            }
            case "thinking": {
              content.push({
                type: "reasoning",
                text: part.thinking,
                providerMetadata: {
                  anthropic: {
                    signature: part.signature
                  }
                }
              });
              break;
            }
            case "redacted_thinking": {
              content.push({
                type: "reasoning",
                text: "",
                providerMetadata: {
                  anthropic: {
                    redactedData: part.data
                  }
                }
              });
              break;
            }
            case "compaction": {
              content.push({
                type: "text",
                text: part.content,
                providerMetadata: {
                  anthropic: {
                    type: "compaction"
                  }
                }
              });
              break;
            }
            case "tool_use": {
              const isJsonResponseTool = usesJsonResponseTool && part.name === "json";
              if (isJsonResponseTool) {
                isJsonResponseFromTool = true;
                content.push({
                  type: "text",
                  text: JSON.stringify(part.input)
                });
              } else {
                const caller = part.caller;
                const callerInfo = caller ? {
                  type: caller.type,
                  toolId: "tool_id" in caller ? caller.tool_id : void 0
                } : void 0;
                content.push({
                  type: "tool-call",
                  toolCallId: part.id,
                  toolName: part.name,
                  input: JSON.stringify(part.input),
                  ...callerInfo && {
                    providerMetadata: {
                      anthropic: {
                        caller: callerInfo
                      }
                    }
                  }
                });
              }
              break;
            }
            case "server_tool_use": {
              if (part.name === "text_editor_code_execution" || part.name === "bash_code_execution") {
                content.push({
                  type: "tool-call",
                  toolCallId: part.id,
                  toolName: toolNameMapping.toCustomToolName("code_execution"),
                  input: JSON.stringify({ type: part.name, ...part.input }),
                  providerExecuted: true
                });
              } else if (part.name === "web_search" || part.name === "code_execution" || part.name === "web_fetch") {
                const inputToSerialize = part.name === "code_execution" && part.input != null && typeof part.input === "object" && "code" in part.input && !("type" in part.input) ? { type: "programmatic-tool-call", ...part.input } : part.input;
                content.push({
                  type: "tool-call",
                  toolCallId: part.id,
                  toolName: toolNameMapping.toCustomToolName(part.name),
                  input: JSON.stringify(inputToSerialize),
                  providerExecuted: true,
                  // We want this 'code_execution' tool call to be allowed even if the tool is not explicitly provided.
                  // Since the validation generally bypasses dynamic tools, we mark this specific tool as dynamic.
                  ...markCodeExecutionDynamic && part.name === "code_execution" ? { dynamic: true } : {}
                });
              } else if (part.name === "tool_search_tool_regex" || part.name === "tool_search_tool_bm25") {
                serverToolCalls[part.id] = part.name;
                content.push({
                  type: "tool-call",
                  toolCallId: part.id,
                  toolName: toolNameMapping.toCustomToolName(part.name),
                  input: JSON.stringify(part.input),
                  providerExecuted: true
                });
              }
              break;
            }
            case "mcp_tool_use": {
              mcpToolCalls[part.id] = {
                type: "tool-call",
                toolCallId: part.id,
                toolName: part.name,
                input: JSON.stringify(part.input),
                providerExecuted: true,
                dynamic: true,
                providerMetadata: {
                  anthropic: {
                    type: "mcp-tool-use",
                    serverName: part.server_name
                  }
                }
              };
              content.push(mcpToolCalls[part.id]);
              break;
            }
            case "mcp_tool_result": {
              content.push({
                type: "tool-result",
                toolCallId: part.tool_use_id,
                toolName: mcpToolCalls[part.tool_use_id].toolName,
                isError: part.is_error,
                result: part.content,
                dynamic: true,
                providerMetadata: mcpToolCalls[part.tool_use_id].providerMetadata
              });
              break;
            }
            case "web_fetch_tool_result": {
              if (part.content.type === "web_fetch_result") {
                citationDocuments.push({
                  title: (_a31 = part.content.content.title) != null ? _a31 : part.content.url,
                  mediaType: part.content.content.source.media_type
                });
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("web_fetch"),
                  result: {
                    type: "web_fetch_result",
                    url: part.content.url,
                    retrievedAt: part.content.retrieved_at,
                    content: {
                      type: part.content.content.type,
                      title: part.content.content.title,
                      citations: part.content.content.citations,
                      source: {
                        type: part.content.content.source.type,
                        mediaType: part.content.content.source.media_type,
                        data: part.content.content.source.data
                      }
                    }
                  }
                });
              } else if (part.content.type === "web_fetch_tool_result_error") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("web_fetch"),
                  isError: true,
                  result: {
                    type: "web_fetch_tool_result_error",
                    errorCode: part.content.error_code
                  }
                });
              }
              break;
            }
            case "web_search_tool_result": {
              if (Array.isArray(part.content)) {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("web_search"),
                  result: part.content.map((result) => {
                    var _a211;
                    return {
                      url: result.url,
                      title: result.title,
                      pageAge: (_a211 = result.page_age) != null ? _a211 : null,
                      encryptedContent: result.encrypted_content,
                      type: result.type
                    };
                  })
                });
                for (const result of part.content) {
                  content.push({
                    type: "source",
                    sourceType: "url",
                    id: this.generateId(),
                    url: result.url,
                    title: result.title,
                    providerMetadata: {
                      anthropic: {
                        pageAge: (_b27 = result.page_age) != null ? _b27 : null
                      }
                    }
                  });
                }
              } else {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("web_search"),
                  isError: true,
                  result: {
                    type: "web_search_tool_result_error",
                    errorCode: part.content.error_code
                  }
                });
              }
              break;
            }
            // code execution 20250522:
            case "code_execution_tool_result": {
              if (part.content.type === "code_execution_result") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("code_execution"),
                  result: {
                    type: part.content.type,
                    stdout: part.content.stdout,
                    stderr: part.content.stderr,
                    return_code: part.content.return_code,
                    content: (_c = part.content.content) != null ? _c : []
                  }
                });
              } else if (part.content.type === "encrypted_code_execution_result") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("code_execution"),
                  result: {
                    type: part.content.type,
                    encrypted_stdout: part.content.encrypted_stdout,
                    stderr: part.content.stderr,
                    return_code: part.content.return_code,
                    content: (_d = part.content.content) != null ? _d : []
                  }
                });
              } else if (part.content.type === "code_execution_tool_result_error") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("code_execution"),
                  isError: true,
                  result: {
                    type: "code_execution_tool_result_error",
                    errorCode: part.content.error_code
                  }
                });
              }
              break;
            }
            // code execution 20250825:
            case "bash_code_execution_tool_result":
            case "text_editor_code_execution_tool_result": {
              content.push({
                type: "tool-result",
                toolCallId: part.tool_use_id,
                toolName: toolNameMapping.toCustomToolName("code_execution"),
                result: part.content
              });
              break;
            }
            // tool search tool results:
            case "tool_search_tool_result": {
              let providerToolName = serverToolCalls[part.tool_use_id];
              if (providerToolName == null) {
                const bm25CustomName = toolNameMapping.toCustomToolName(
                  "tool_search_tool_bm25"
                );
                const regexCustomName = toolNameMapping.toCustomToolName(
                  "tool_search_tool_regex"
                );
                if (bm25CustomName !== "tool_search_tool_bm25") {
                  providerToolName = "tool_search_tool_bm25";
                } else if (regexCustomName !== "tool_search_tool_regex") {
                  providerToolName = "tool_search_tool_regex";
                } else {
                  providerToolName = "tool_search_tool_regex";
                }
              }
              if (part.content.type === "tool_search_tool_search_result") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName(providerToolName),
                  result: part.content.tool_references.map((ref) => ({
                    type: ref.type,
                    toolName: ref.tool_name
                  }))
                });
              } else {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName(providerToolName),
                  isError: true,
                  result: {
                    type: "tool_search_tool_result_error",
                    errorCode: part.content.error_code
                  }
                });
              }
              break;
            }
          }
        }
        return {
          content,
          finishReason: {
            unified: mapAnthropicStopReason({
              finishReason: response.stop_reason,
              isJsonResponseFromTool
            }),
            raw: (_e = response.stop_reason) != null ? _e : void 0
          },
          usage: convertAnthropicMessagesUsage({ usage: response.usage }),
          request: { body: args },
          response: {
            id: (_f = response.id) != null ? _f : void 0,
            modelId: (_g = response.model) != null ? _g : void 0,
            headers: responseHeaders,
            body: rawResponse
          },
          warnings,
          providerMetadata: (() => {
            var _a211, _b28, _c2, _d2, _e2;
            const anthropicMetadata = {
              usage: response.usage,
              cacheCreationInputTokens: (_a211 = response.usage.cache_creation_input_tokens) != null ? _a211 : null,
              stopSequence: (_b28 = response.stop_sequence) != null ? _b28 : null,
              iterations: response.usage.iterations ? response.usage.iterations.map((iter) => ({
                type: iter.type,
                inputTokens: iter.input_tokens,
                outputTokens: iter.output_tokens
              })) : null,
              container: response.container ? {
                expiresAt: response.container.expires_at,
                id: response.container.id,
                skills: (_d2 = (_c2 = response.container.skills) == null ? void 0 : _c2.map((skill) => ({
                  type: skill.type,
                  skillId: skill.skill_id,
                  version: skill.version
                }))) != null ? _d2 : null
              } : null,
              contextManagement: (_e2 = mapAnthropicResponseContextManagement(
                response.context_management
              )) != null ? _e2 : null
            };
            const providerMetadata = {
              anthropic: anthropicMetadata
            };
            if (usedCustomProviderKey && providerOptionsName !== "anthropic") {
              providerMetadata[providerOptionsName] = anthropicMetadata;
            }
            return providerMetadata;
          })()
        };
      }
      async doStream(options) {
        var _a31, _b27;
        const {
          args: body,
          warnings,
          betas,
          usesJsonResponseTool,
          toolNameMapping,
          providerOptionsName,
          usedCustomProviderKey
        } = await this.getArgs({
          ...options,
          stream: true,
          userSuppliedBetas: await this.getBetasFromHeaders(options.headers)
        });
        const citationDocuments = [
          ...this.extractCitationDocuments(options.prompt)
        ];
        const markCodeExecutionDynamic = hasWebTool20260209WithoutCodeExecution(
          body.tools
        );
        const url4 = this.buildRequestUrl(true);
        const { responseHeaders, value: response } = await postJsonToApi({
          url: url4,
          headers: await this.getHeaders({ betas, headers: options.headers }),
          body: this.transformRequestBody(body, betas),
          failedResponseHandler: anthropicFailedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler(
            anthropicMessagesChunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        const usage = {
          input_tokens: 0,
          output_tokens: 0,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0,
          iterations: null
        };
        const contentBlocks = {};
        const mcpToolCalls = {};
        const serverToolCalls = {};
        let contextManagement = null;
        let rawUsage = void 0;
        let cacheCreationInputTokens = null;
        let stopSequence = null;
        let container = null;
        let isJsonResponseFromTool = false;
        let blockType = void 0;
        const generateId32 = this.generateId;
        const transformedStream = response.pipeThrough(
          new TransformStream({
            start(controller) {
              controller.enqueue({ type: "stream-start", warnings });
            },
            transform(chunk, controller) {
              var _a211, _b28, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
              if (options.includeRawChunks) {
                controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
              }
              if (!chunk.success) {
                controller.enqueue({ type: "error", error: chunk.error });
                return;
              }
              const value = chunk.value;
              switch (value.type) {
                case "ping": {
                  return;
                }
                case "content_block_start": {
                  const part = value.content_block;
                  const contentBlockType = part.type;
                  blockType = contentBlockType;
                  switch (contentBlockType) {
                    case "text": {
                      if (usesJsonResponseTool) {
                        return;
                      }
                      contentBlocks[value.index] = { type: "text" };
                      controller.enqueue({
                        type: "text-start",
                        id: String(value.index)
                      });
                      return;
                    }
                    case "thinking": {
                      contentBlocks[value.index] = { type: "reasoning" };
                      controller.enqueue({
                        type: "reasoning-start",
                        id: String(value.index)
                      });
                      return;
                    }
                    case "redacted_thinking": {
                      contentBlocks[value.index] = { type: "reasoning" };
                      controller.enqueue({
                        type: "reasoning-start",
                        id: String(value.index),
                        providerMetadata: {
                          anthropic: {
                            redactedData: part.data
                          }
                        }
                      });
                      return;
                    }
                    case "compaction": {
                      contentBlocks[value.index] = { type: "text" };
                      controller.enqueue({
                        type: "text-start",
                        id: String(value.index),
                        providerMetadata: {
                          anthropic: {
                            type: "compaction"
                          }
                        }
                      });
                      return;
                    }
                    case "tool_use": {
                      const isJsonResponseTool = usesJsonResponseTool && part.name === "json";
                      if (isJsonResponseTool) {
                        isJsonResponseFromTool = true;
                        contentBlocks[value.index] = { type: "text" };
                        controller.enqueue({
                          type: "text-start",
                          id: String(value.index)
                        });
                      } else {
                        const caller = part.caller;
                        const callerInfo = caller ? {
                          type: caller.type,
                          toolId: "tool_id" in caller ? caller.tool_id : void 0
                        } : void 0;
                        const hasNonEmptyInput = part.input && Object.keys(part.input).length > 0;
                        const initialInput = hasNonEmptyInput ? JSON.stringify(part.input) : "";
                        contentBlocks[value.index] = {
                          type: "tool-call",
                          toolCallId: part.id,
                          toolName: part.name,
                          input: initialInput,
                          firstDelta: initialInput.length === 0,
                          ...callerInfo && { caller: callerInfo }
                        };
                        controller.enqueue({
                          type: "tool-input-start",
                          id: part.id,
                          toolName: part.name
                        });
                      }
                      return;
                    }
                    case "server_tool_use": {
                      if ([
                        "web_fetch",
                        "web_search",
                        // code execution 20250825:
                        "code_execution",
                        // code execution 20250825 text editor:
                        "text_editor_code_execution",
                        // code execution 20250825 bash:
                        "bash_code_execution"
                      ].includes(part.name)) {
                        const providerToolName = part.name === "text_editor_code_execution" || part.name === "bash_code_execution" ? "code_execution" : part.name;
                        const customToolName = toolNameMapping.toCustomToolName(providerToolName);
                        const finalInput = part.input != null && typeof part.input === "object" && Object.keys(part.input).length > 0 ? JSON.stringify(part.input) : "";
                        contentBlocks[value.index] = {
                          type: "tool-call",
                          toolCallId: part.id,
                          toolName: customToolName,
                          input: finalInput,
                          providerExecuted: true,
                          ...markCodeExecutionDynamic && providerToolName === "code_execution" ? { dynamic: true } : {},
                          firstDelta: true,
                          providerToolName: part.name
                        };
                        controller.enqueue({
                          type: "tool-input-start",
                          id: part.id,
                          toolName: customToolName,
                          providerExecuted: true,
                          ...markCodeExecutionDynamic && providerToolName === "code_execution" ? { dynamic: true } : {}
                        });
                      } else if (part.name === "tool_search_tool_regex" || part.name === "tool_search_tool_bm25") {
                        serverToolCalls[part.id] = part.name;
                        const customToolName = toolNameMapping.toCustomToolName(
                          part.name
                        );
                        contentBlocks[value.index] = {
                          type: "tool-call",
                          toolCallId: part.id,
                          toolName: customToolName,
                          input: "",
                          providerExecuted: true,
                          firstDelta: true,
                          providerToolName: part.name
                        };
                        controller.enqueue({
                          type: "tool-input-start",
                          id: part.id,
                          toolName: customToolName,
                          providerExecuted: true
                        });
                      }
                      return;
                    }
                    case "web_fetch_tool_result": {
                      if (part.content.type === "web_fetch_result") {
                        citationDocuments.push({
                          title: (_a211 = part.content.content.title) != null ? _a211 : part.content.url,
                          mediaType: part.content.content.source.media_type
                        });
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("web_fetch"),
                          result: {
                            type: "web_fetch_result",
                            url: part.content.url,
                            retrievedAt: part.content.retrieved_at,
                            content: {
                              type: part.content.content.type,
                              title: part.content.content.title,
                              citations: part.content.content.citations,
                              source: {
                                type: part.content.content.source.type,
                                mediaType: part.content.content.source.media_type,
                                data: part.content.content.source.data
                              }
                            }
                          }
                        });
                      } else if (part.content.type === "web_fetch_tool_result_error") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("web_fetch"),
                          isError: true,
                          result: {
                            type: "web_fetch_tool_result_error",
                            errorCode: part.content.error_code
                          }
                        });
                      }
                      return;
                    }
                    case "web_search_tool_result": {
                      if (Array.isArray(part.content)) {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("web_search"),
                          result: part.content.map((result) => {
                            var _a37;
                            return {
                              url: result.url,
                              title: result.title,
                              pageAge: (_a37 = result.page_age) != null ? _a37 : null,
                              encryptedContent: result.encrypted_content,
                              type: result.type
                            };
                          })
                        });
                        for (const result of part.content) {
                          controller.enqueue({
                            type: "source",
                            sourceType: "url",
                            id: generateId32(),
                            url: result.url,
                            title: result.title,
                            providerMetadata: {
                              anthropic: {
                                pageAge: (_b28 = result.page_age) != null ? _b28 : null
                              }
                            }
                          });
                        }
                      } else {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("web_search"),
                          isError: true,
                          result: {
                            type: "web_search_tool_result_error",
                            errorCode: part.content.error_code
                          }
                        });
                      }
                      return;
                    }
                    // code execution 20250522:
                    case "code_execution_tool_result": {
                      if (part.content.type === "code_execution_result") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("code_execution"),
                          result: {
                            type: part.content.type,
                            stdout: part.content.stdout,
                            stderr: part.content.stderr,
                            return_code: part.content.return_code,
                            content: (_c = part.content.content) != null ? _c : []
                          }
                        });
                      } else if (part.content.type === "encrypted_code_execution_result") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("code_execution"),
                          result: {
                            type: part.content.type,
                            encrypted_stdout: part.content.encrypted_stdout,
                            stderr: part.content.stderr,
                            return_code: part.content.return_code,
                            content: (_d = part.content.content) != null ? _d : []
                          }
                        });
                      } else if (part.content.type === "code_execution_tool_result_error") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("code_execution"),
                          isError: true,
                          result: {
                            type: "code_execution_tool_result_error",
                            errorCode: part.content.error_code
                          }
                        });
                      }
                      return;
                    }
                    // code execution 20250825:
                    case "bash_code_execution_tool_result":
                    case "text_editor_code_execution_tool_result": {
                      controller.enqueue({
                        type: "tool-result",
                        toolCallId: part.tool_use_id,
                        toolName: toolNameMapping.toCustomToolName("code_execution"),
                        result: part.content
                      });
                      return;
                    }
                    // tool search tool results:
                    case "tool_search_tool_result": {
                      let providerToolName = serverToolCalls[part.tool_use_id];
                      if (providerToolName == null) {
                        const bm25CustomName = toolNameMapping.toCustomToolName(
                          "tool_search_tool_bm25"
                        );
                        const regexCustomName = toolNameMapping.toCustomToolName(
                          "tool_search_tool_regex"
                        );
                        if (bm25CustomName !== "tool_search_tool_bm25") {
                          providerToolName = "tool_search_tool_bm25";
                        } else if (regexCustomName !== "tool_search_tool_regex") {
                          providerToolName = "tool_search_tool_regex";
                        } else {
                          providerToolName = "tool_search_tool_regex";
                        }
                      }
                      if (part.content.type === "tool_search_tool_search_result") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName(providerToolName),
                          result: part.content.tool_references.map((ref) => ({
                            type: ref.type,
                            toolName: ref.tool_name
                          }))
                        });
                      } else {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName(providerToolName),
                          isError: true,
                          result: {
                            type: "tool_search_tool_result_error",
                            errorCode: part.content.error_code
                          }
                        });
                      }
                      return;
                    }
                    case "mcp_tool_use": {
                      mcpToolCalls[part.id] = {
                        type: "tool-call",
                        toolCallId: part.id,
                        toolName: part.name,
                        input: JSON.stringify(part.input),
                        providerExecuted: true,
                        dynamic: true,
                        providerMetadata: {
                          anthropic: {
                            type: "mcp-tool-use",
                            serverName: part.server_name
                          }
                        }
                      };
                      controller.enqueue(mcpToolCalls[part.id]);
                      return;
                    }
                    case "mcp_tool_result": {
                      controller.enqueue({
                        type: "tool-result",
                        toolCallId: part.tool_use_id,
                        toolName: mcpToolCalls[part.tool_use_id].toolName,
                        isError: part.is_error,
                        result: part.content,
                        dynamic: true,
                        providerMetadata: mcpToolCalls[part.tool_use_id].providerMetadata
                      });
                      return;
                    }
                    default: {
                      const _exhaustiveCheck = contentBlockType;
                      throw new Error(
                        `Unsupported content block type: ${_exhaustiveCheck}`
                      );
                    }
                  }
                }
                case "content_block_stop": {
                  if (contentBlocks[value.index] != null) {
                    const contentBlock = contentBlocks[value.index];
                    switch (contentBlock.type) {
                      case "text": {
                        controller.enqueue({
                          type: "text-end",
                          id: String(value.index)
                        });
                        break;
                      }
                      case "reasoning": {
                        controller.enqueue({
                          type: "reasoning-end",
                          id: String(value.index)
                        });
                        break;
                      }
                      case "tool-call":
                        const isJsonResponseTool = usesJsonResponseTool && contentBlock.toolName === "json";
                        if (!isJsonResponseTool) {
                          controller.enqueue({
                            type: "tool-input-end",
                            id: contentBlock.toolCallId
                          });
                          let finalInput = contentBlock.input === "" ? "{}" : contentBlock.input;
                          if (contentBlock.providerToolName === "code_execution") {
                            try {
                              const parsed = JSON.parse(finalInput);
                              if (parsed != null && typeof parsed === "object" && "code" in parsed && !("type" in parsed)) {
                                finalInput = JSON.stringify({
                                  type: "programmatic-tool-call",
                                  ...parsed
                                });
                              }
                            } catch (e) {
                            }
                          }
                          controller.enqueue({
                            type: "tool-call",
                            toolCallId: contentBlock.toolCallId,
                            toolName: contentBlock.toolName,
                            input: finalInput,
                            providerExecuted: contentBlock.providerExecuted,
                            ...markCodeExecutionDynamic && contentBlock.providerToolName === "code_execution" ? { dynamic: true } : {},
                            ...contentBlock.caller && {
                              providerMetadata: {
                                anthropic: {
                                  caller: contentBlock.caller
                                }
                              }
                            }
                          });
                        }
                        break;
                    }
                    delete contentBlocks[value.index];
                  }
                  blockType = void 0;
                  return;
                }
                case "content_block_delta": {
                  const deltaType = value.delta.type;
                  switch (deltaType) {
                    case "text_delta": {
                      if (usesJsonResponseTool) {
                        return;
                      }
                      controller.enqueue({
                        type: "text-delta",
                        id: String(value.index),
                        delta: value.delta.text
                      });
                      return;
                    }
                    case "thinking_delta": {
                      controller.enqueue({
                        type: "reasoning-delta",
                        id: String(value.index),
                        delta: value.delta.thinking
                      });
                      return;
                    }
                    case "signature_delta": {
                      if (blockType === "thinking") {
                        controller.enqueue({
                          type: "reasoning-delta",
                          id: String(value.index),
                          delta: "",
                          providerMetadata: {
                            anthropic: {
                              signature: value.delta.signature
                            }
                          }
                        });
                      }
                      return;
                    }
                    case "compaction_delta": {
                      if (value.delta.content != null) {
                        controller.enqueue({
                          type: "text-delta",
                          id: String(value.index),
                          delta: value.delta.content
                        });
                      }
                      return;
                    }
                    case "input_json_delta": {
                      const contentBlock = contentBlocks[value.index];
                      let delta = value.delta.partial_json;
                      if (delta.length === 0) {
                        return;
                      }
                      if (isJsonResponseFromTool) {
                        if ((contentBlock == null ? void 0 : contentBlock.type) !== "text") {
                          return;
                        }
                        controller.enqueue({
                          type: "text-delta",
                          id: String(value.index),
                          delta
                        });
                      } else {
                        if ((contentBlock == null ? void 0 : contentBlock.type) !== "tool-call") {
                          return;
                        }
                        if (contentBlock.firstDelta && (contentBlock.providerToolName === "bash_code_execution" || contentBlock.providerToolName === "text_editor_code_execution")) {
                          delta = `{"type": "${contentBlock.providerToolName}",${delta.substring(1)}`;
                        }
                        controller.enqueue({
                          type: "tool-input-delta",
                          id: contentBlock.toolCallId,
                          delta
                        });
                        contentBlock.input += delta;
                        contentBlock.firstDelta = false;
                      }
                      return;
                    }
                    case "citations_delta": {
                      const citation = value.delta.citation;
                      const source = createCitationSource(
                        citation,
                        citationDocuments,
                        generateId32
                      );
                      if (source) {
                        controller.enqueue(source);
                      }
                      return;
                    }
                    default: {
                      const _exhaustiveCheck = deltaType;
                      throw new Error(
                        `Unsupported delta type: ${_exhaustiveCheck}`
                      );
                    }
                  }
                }
                case "message_start": {
                  usage.input_tokens = value.message.usage.input_tokens;
                  usage.cache_read_input_tokens = (_e = value.message.usage.cache_read_input_tokens) != null ? _e : 0;
                  usage.cache_creation_input_tokens = (_f = value.message.usage.cache_creation_input_tokens) != null ? _f : 0;
                  rawUsage = {
                    ...value.message.usage
                  };
                  cacheCreationInputTokens = (_g = value.message.usage.cache_creation_input_tokens) != null ? _g : null;
                  if (value.message.container != null) {
                    container = {
                      expiresAt: value.message.container.expires_at,
                      id: value.message.container.id,
                      skills: null
                    };
                  }
                  if (value.message.stop_reason != null) {
                    finishReason = {
                      unified: mapAnthropicStopReason({
                        finishReason: value.message.stop_reason,
                        isJsonResponseFromTool
                      }),
                      raw: value.message.stop_reason
                    };
                  }
                  controller.enqueue({
                    type: "response-metadata",
                    id: (_h = value.message.id) != null ? _h : void 0,
                    modelId: (_i = value.message.model) != null ? _i : void 0
                  });
                  if (value.message.content != null) {
                    for (let contentIndex = 0; contentIndex < value.message.content.length; contentIndex++) {
                      const part = value.message.content[contentIndex];
                      if (part.type === "tool_use") {
                        const caller = part.caller;
                        const callerInfo = caller ? {
                          type: caller.type,
                          toolId: "tool_id" in caller ? caller.tool_id : void 0
                        } : void 0;
                        controller.enqueue({
                          type: "tool-input-start",
                          id: part.id,
                          toolName: part.name
                        });
                        const inputStr = JSON.stringify((_j = part.input) != null ? _j : {});
                        controller.enqueue({
                          type: "tool-input-delta",
                          id: part.id,
                          delta: inputStr
                        });
                        controller.enqueue({
                          type: "tool-input-end",
                          id: part.id
                        });
                        controller.enqueue({
                          type: "tool-call",
                          toolCallId: part.id,
                          toolName: part.name,
                          input: inputStr,
                          ...callerInfo && {
                            providerMetadata: {
                              anthropic: {
                                caller: callerInfo
                              }
                            }
                          }
                        });
                      }
                    }
                  }
                  return;
                }
                case "message_delta": {
                  if (value.usage.input_tokens != null && usage.input_tokens !== value.usage.input_tokens) {
                    usage.input_tokens = value.usage.input_tokens;
                  }
                  usage.output_tokens = value.usage.output_tokens;
                  if (value.usage.cache_read_input_tokens != null) {
                    usage.cache_read_input_tokens = value.usage.cache_read_input_tokens;
                  }
                  if (value.usage.cache_creation_input_tokens != null) {
                    usage.cache_creation_input_tokens = value.usage.cache_creation_input_tokens;
                    cacheCreationInputTokens = value.usage.cache_creation_input_tokens;
                  }
                  if (value.usage.iterations != null) {
                    usage.iterations = value.usage.iterations;
                  }
                  finishReason = {
                    unified: mapAnthropicStopReason({
                      finishReason: value.delta.stop_reason,
                      isJsonResponseFromTool
                    }),
                    raw: (_k = value.delta.stop_reason) != null ? _k : void 0
                  };
                  stopSequence = (_l = value.delta.stop_sequence) != null ? _l : null;
                  container = value.delta.container != null ? {
                    expiresAt: value.delta.container.expires_at,
                    id: value.delta.container.id,
                    skills: (_n = (_m = value.delta.container.skills) == null ? void 0 : _m.map((skill) => ({
                      type: skill.type,
                      skillId: skill.skill_id,
                      version: skill.version
                    }))) != null ? _n : null
                  } : null;
                  if (value.context_management) {
                    contextManagement = mapAnthropicResponseContextManagement(
                      value.context_management
                    );
                  }
                  rawUsage = {
                    ...rawUsage,
                    ...value.usage
                  };
                  return;
                }
                case "message_stop": {
                  const anthropicMetadata = {
                    usage: rawUsage != null ? rawUsage : null,
                    cacheCreationInputTokens,
                    stopSequence,
                    iterations: usage.iterations ? usage.iterations.map((iter) => ({
                      type: iter.type,
                      inputTokens: iter.input_tokens,
                      outputTokens: iter.output_tokens
                    })) : null,
                    container,
                    contextManagement
                  };
                  const providerMetadata = {
                    anthropic: anthropicMetadata
                  };
                  if (usedCustomProviderKey && providerOptionsName !== "anthropic") {
                    providerMetadata[providerOptionsName] = anthropicMetadata;
                  }
                  controller.enqueue({
                    type: "finish",
                    finishReason,
                    usage: convertAnthropicMessagesUsage({ usage, rawUsage }),
                    providerMetadata
                  });
                  return;
                }
                case "error": {
                  controller.enqueue({ type: "error", error: value.error });
                  return;
                }
                default: {
                  const _exhaustiveCheck = value;
                  throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
                }
              }
            }
          })
        );
        const [streamForFirstChunk, streamForConsumer] = transformedStream.tee();
        const firstChunkReader = streamForFirstChunk.getReader();
        try {
          await firstChunkReader.read();
          let result = await firstChunkReader.read();
          if (((_a31 = result.value) == null ? void 0 : _a31.type) === "raw") {
            result = await firstChunkReader.read();
          }
          if (((_b27 = result.value) == null ? void 0 : _b27.type) === "error") {
            const error73 = result.value.error;
            throw new APICallError({
              message: error73.message,
              url: url4,
              requestBodyValues: body,
              statusCode: error73.type === "overloaded_error" ? 529 : 500,
              responseHeaders,
              responseBody: JSON.stringify(error73),
              isRetryable: error73.type === "overloaded_error"
            });
          }
        } finally {
          firstChunkReader.cancel().catch(() => {
          });
          firstChunkReader.releaseLock();
        }
        return {
          stream: streamForConsumer,
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    bash_20241022InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          command: external_exports.string(),
          restart: external_exports.boolean().optional()
        })
      )
    );
    bash_20241022 = createProviderToolFactory({
      id: "anthropic.bash_20241022",
      inputSchema: bash_20241022InputSchema
    });
    bash_20250124InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          command: external_exports.string(),
          restart: external_exports.boolean().optional()
        })
      )
    );
    bash_20250124 = createProviderToolFactory({
      id: "anthropic.bash_20250124",
      inputSchema: bash_20250124InputSchema
    });
    computer_20241022InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          action: external_exports.enum([
            "key",
            "type",
            "mouse_move",
            "left_click",
            "left_click_drag",
            "right_click",
            "middle_click",
            "double_click",
            "screenshot",
            "cursor_position"
          ]),
          coordinate: external_exports.array(external_exports.number().int()).optional(),
          text: external_exports.string().optional()
        })
      )
    );
    computer_20241022 = createProviderToolFactory({
      id: "anthropic.computer_20241022",
      inputSchema: computer_20241022InputSchema
    });
    computer_20250124InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          action: external_exports.enum([
            "key",
            "hold_key",
            "type",
            "cursor_position",
            "mouse_move",
            "left_mouse_down",
            "left_mouse_up",
            "left_click",
            "left_click_drag",
            "right_click",
            "middle_click",
            "double_click",
            "triple_click",
            "scroll",
            "wait",
            "screenshot"
          ]),
          coordinate: external_exports.tuple([external_exports.number().int(), external_exports.number().int()]).optional(),
          duration: external_exports.number().optional(),
          scroll_amount: external_exports.number().optional(),
          scroll_direction: external_exports.enum(["up", "down", "left", "right"]).optional(),
          start_coordinate: external_exports.tuple([external_exports.number().int(), external_exports.number().int()]).optional(),
          text: external_exports.string().optional()
        })
      )
    );
    computer_20250124 = createProviderToolFactory({
      id: "anthropic.computer_20250124",
      inputSchema: computer_20250124InputSchema
    });
    computer_20251124InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          action: external_exports.enum([
            "key",
            "hold_key",
            "type",
            "cursor_position",
            "mouse_move",
            "left_mouse_down",
            "left_mouse_up",
            "left_click",
            "left_click_drag",
            "right_click",
            "middle_click",
            "double_click",
            "triple_click",
            "scroll",
            "wait",
            "screenshot",
            "zoom"
          ]),
          coordinate: external_exports.tuple([external_exports.number().int(), external_exports.number().int()]).optional(),
          duration: external_exports.number().optional(),
          region: external_exports.tuple([
            external_exports.number().int(),
            external_exports.number().int(),
            external_exports.number().int(),
            external_exports.number().int()
          ]).optional(),
          scroll_amount: external_exports.number().optional(),
          scroll_direction: external_exports.enum(["up", "down", "left", "right"]).optional(),
          start_coordinate: external_exports.tuple([external_exports.number().int(), external_exports.number().int()]).optional(),
          text: external_exports.string().optional()
        })
      )
    );
    computer_20251124 = createProviderToolFactory({
      id: "anthropic.computer_20251124",
      inputSchema: computer_20251124InputSchema
    });
    memory_20250818InputSchema = lazySchema(
      () => zodSchema(
        external_exports.discriminatedUnion("command", [
          external_exports.object({
            command: external_exports.literal("view"),
            path: external_exports.string(),
            view_range: external_exports.tuple([external_exports.number(), external_exports.number()]).optional()
          }),
          external_exports.object({
            command: external_exports.literal("create"),
            path: external_exports.string(),
            file_text: external_exports.string()
          }),
          external_exports.object({
            command: external_exports.literal("str_replace"),
            path: external_exports.string(),
            old_str: external_exports.string(),
            new_str: external_exports.string()
          }),
          external_exports.object({
            command: external_exports.literal("insert"),
            path: external_exports.string(),
            insert_line: external_exports.number(),
            insert_text: external_exports.string()
          }),
          external_exports.object({
            command: external_exports.literal("delete"),
            path: external_exports.string()
          }),
          external_exports.object({
            command: external_exports.literal("rename"),
            old_path: external_exports.string(),
            new_path: external_exports.string()
          })
        ])
      )
    );
    memory_20250818 = createProviderToolFactory({
      id: "anthropic.memory_20250818",
      inputSchema: memory_20250818InputSchema
    });
    textEditor_20241022InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          command: external_exports.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
          path: external_exports.string(),
          file_text: external_exports.string().optional(),
          insert_line: external_exports.number().int().optional(),
          new_str: external_exports.string().optional(),
          insert_text: external_exports.string().optional(),
          old_str: external_exports.string().optional(),
          view_range: external_exports.array(external_exports.number().int()).optional()
        })
      )
    );
    textEditor_20241022 = createProviderToolFactory({
      id: "anthropic.text_editor_20241022",
      inputSchema: textEditor_20241022InputSchema
    });
    textEditor_20250124InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          command: external_exports.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
          path: external_exports.string(),
          file_text: external_exports.string().optional(),
          insert_line: external_exports.number().int().optional(),
          new_str: external_exports.string().optional(),
          insert_text: external_exports.string().optional(),
          old_str: external_exports.string().optional(),
          view_range: external_exports.array(external_exports.number().int()).optional()
        })
      )
    );
    textEditor_20250124 = createProviderToolFactory({
      id: "anthropic.text_editor_20250124",
      inputSchema: textEditor_20250124InputSchema
    });
    textEditor_20250429InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          command: external_exports.enum(["view", "create", "str_replace", "insert"]),
          path: external_exports.string(),
          file_text: external_exports.string().optional(),
          insert_line: external_exports.number().int().optional(),
          new_str: external_exports.string().optional(),
          insert_text: external_exports.string().optional(),
          old_str: external_exports.string().optional(),
          view_range: external_exports.array(external_exports.number().int()).optional()
        })
      )
    );
    textEditor_20250429 = createProviderToolFactory({
      id: "anthropic.text_editor_20250429",
      inputSchema: textEditor_20250429InputSchema
    });
    toolSearchBm25_20251119OutputSchema = lazySchema(
      () => zodSchema(
        external_exports.array(
          external_exports.object({
            type: external_exports.literal("tool_reference"),
            toolName: external_exports.string()
          })
        )
      )
    );
    toolSearchBm25_20251119InputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          /**
           * A natural language query to search for tools.
           * Claude will use BM25 text search to find relevant tools.
           */
          query: external_exports.string(),
          /**
           * Maximum number of tools to return. Optional.
           */
          limit: external_exports.number().optional()
        })
      )
    );
    factory10 = createProviderToolFactoryWithOutputSchema({
      id: "anthropic.tool_search_bm25_20251119",
      inputSchema: toolSearchBm25_20251119InputSchema,
      outputSchema: toolSearchBm25_20251119OutputSchema,
      supportsDeferredResults: true
    });
    toolSearchBm25_20251119 = (args = {}) => {
      return factory10(args);
    };
    anthropicTools = {
      /**
       * The bash tool enables Claude to execute shell commands in a persistent bash session,
       * allowing system operations, script execution, and command-line automation.
       *
       * Image results are supported.
       */
      bash_20241022,
      /**
       * The bash tool enables Claude to execute shell commands in a persistent bash session,
       * allowing system operations, script execution, and command-line automation.
       *
       * Image results are supported.
       */
      bash_20250124,
      /**
       * Claude can analyze data, create visualizations, perform complex calculations,
       * run system commands, create and edit files, and process uploaded files directly within
       * the API conversation.
       *
       * The code execution tool allows Claude to run Bash commands and manipulate files,
       * including writing code, in a secure, sandboxed environment.
       */
      codeExecution_20250522,
      /**
       * Claude can analyze data, create visualizations, perform complex calculations,
       * run system commands, create and edit files, and process uploaded files directly within
       * the API conversation.
       *
       * The code execution tool allows Claude to run both Python and Bash commands and manipulate files,
       * including writing code, in a secure, sandboxed environment.
       *
       * This is the latest version with enhanced Bash support and file operations.
       */
      codeExecution_20250825,
      /**
       * Claude can analyze data, create visualizations, perform complex calculations,
       * run system commands, create and edit files, and process uploaded files directly within
       * the API conversation.
       *
       * The code execution tool allows Claude to run both Python and Bash commands and manipulate files,
       * including writing code, in a secure, sandboxed environment.
       *
       * This is the recommended version. Does not require a beta header.
       *
       * Supported models: Claude Opus 4.6, Sonnet 4.6, Sonnet 4.5, Opus 4.5
       */
      codeExecution_20260120,
      /**
       * Claude can interact with computer environments through the computer use tool, which
       * provides screenshot capabilities and mouse/keyboard control for autonomous desktop interaction.
       *
       * Image results are supported.
       *
       * @param displayWidthPx - The width of the display being controlled by the model in pixels.
       * @param displayHeightPx - The height of the display being controlled by the model in pixels.
       * @param displayNumber - The display number to control (only relevant for X11 environments). If specified, the tool will be provided a display number in the tool definition.
       */
      computer_20241022,
      /**
       * Claude can interact with computer environments through the computer use tool, which
       * provides screenshot capabilities and mouse/keyboard control for autonomous desktop interaction.
       *
       * Image results are supported.
       *
       * @param displayWidthPx - The width of the display being controlled by the model in pixels.
       * @param displayHeightPx - The height of the display being controlled by the model in pixels.
       * @param displayNumber - The display number to control (only relevant for X11 environments). If specified, the tool will be provided a display number in the tool definition.
       */
      computer_20250124,
      /**
       * Claude can interact with computer environments through the computer use tool, which
       * provides screenshot capabilities and mouse/keyboard control for autonomous desktop interaction.
       *
       * This version adds the zoom action for detailed screen region inspection.
       *
       * Image results are supported.
       *
       * Supported models: Claude Opus 4.5
       *
       * @param displayWidthPx - The width of the display being controlled by the model in pixels.
       * @param displayHeightPx - The height of the display being controlled by the model in pixels.
       * @param displayNumber - The display number to control (only relevant for X11 environments). If specified, the tool will be provided a display number in the tool definition.
       * @param enableZoom - Enable zoom action. Set to true to allow Claude to zoom into specific screen regions. Default: false.
       */
      computer_20251124,
      /**
       * The memory tool enables Claude to store and retrieve information across conversations through a memory file directory.
       * Claude can create, read, update, and delete files that persist between sessions,
       * allowing it to build knowledge over time without keeping everything in the context window.
       * The memory tool operates client-side—you control where and how the data is stored through your own infrastructure.
       *
       * Supported models: Claude Sonnet 4.5, Claude Sonnet 4, Claude Opus 4.1, Claude Opus 4.
       */
      memory_20250818,
      /**
       * Claude can use an Anthropic-defined text editor tool to view and modify text files,
       * helping you debug, fix, and improve your code or other text documents. This allows Claude
       * to directly interact with your files, providing hands-on assistance rather than just suggesting changes.
       *
       * Supported models: Claude Sonnet 3.5
       */
      textEditor_20241022,
      /**
       * Claude can use an Anthropic-defined text editor tool to view and modify text files,
       * helping you debug, fix, and improve your code or other text documents. This allows Claude
       * to directly interact with your files, providing hands-on assistance rather than just suggesting changes.
       *
       * Supported models: Claude Sonnet 3.7
       */
      textEditor_20250124,
      /**
       * Claude can use an Anthropic-defined text editor tool to view and modify text files,
       * helping you debug, fix, and improve your code or other text documents. This allows Claude
       * to directly interact with your files, providing hands-on assistance rather than just suggesting changes.
       *
       * Note: This version does not support the "undo_edit" command.
       *
       * @deprecated Use textEditor_20250728 instead
       */
      textEditor_20250429,
      /**
       * Claude can use an Anthropic-defined text editor tool to view and modify text files,
       * helping you debug, fix, and improve your code or other text documents. This allows Claude
       * to directly interact with your files, providing hands-on assistance rather than just suggesting changes.
       *
       * Note: This version does not support the "undo_edit" command and adds optional max_characters parameter.
       *
       * Supported models: Claude Sonnet 4, Opus 4, and Opus 4.1
       *
       * @param maxCharacters - Optional maximum number of characters to view in the file
       */
      textEditor_20250728,
      /**
       * Creates a web fetch tool that gives Claude direct access to real-time web content.
       *
       * @param maxUses - The max_uses parameter limits the number of web fetches performed
       * @param allowedDomains - Only fetch from these domains
       * @param blockedDomains - Never fetch from these domains
       * @param citations - Unlike web search where citations are always enabled, citations are optional for web fetch. Set "citations": {"enabled": true} to enable Claude to cite specific passages from fetched documents.
       * @param maxContentTokens - The max_content_tokens parameter limits the amount of content that will be included in the context.
       */
      webFetch_20250910,
      /**
       * Creates a web fetch tool that gives Claude direct access to real-time web content.
       *
       * @param maxUses - The max_uses parameter limits the number of web fetches performed
       * @param allowedDomains - Only fetch from these domains
       * @param blockedDomains - Never fetch from these domains
       * @param citations - Unlike web search where citations are always enabled, citations are optional for web fetch. Set "citations": {"enabled": true} to enable Claude to cite specific passages from fetched documents.
       * @param maxContentTokens - The max_content_tokens parameter limits the amount of content that will be included in the context.
       */
      webFetch_20260209,
      /**
       * Creates a web search tool that gives Claude direct access to real-time web content.
       *
       * @param maxUses - Maximum number of web searches Claude can perform during the conversation.
       * @param allowedDomains - Optional list of domains that Claude is allowed to search.
       * @param blockedDomains - Optional list of domains that Claude should avoid when searching.
       * @param userLocation - Optional user location information to provide geographically relevant search results.
       */
      webSearch_20250305,
      /**
       * Creates a web search tool that gives Claude direct access to real-time web content.
       *
       * @param maxUses - Maximum number of web searches Claude can perform during the conversation.
       * @param allowedDomains - Optional list of domains that Claude is allowed to search.
       * @param blockedDomains - Optional list of domains that Claude should avoid when searching.
       * @param userLocation - Optional user location information to provide geographically relevant search results.
       */
      webSearch_20260209,
      /**
       * Creates a tool search tool that uses regex patterns to find tools.
       *
       * The tool search tool enables Claude to work with hundreds or thousands of tools
       * by dynamically discovering and loading them on-demand. Instead of loading all
       * tool definitions into the context window upfront, Claude searches your tool
       * catalog and loads only the tools it needs.
       *
       * Use `providerOptions: { anthropic: { deferLoading: true } }` on other tools
       * to mark them for deferred loading.
       *
       * Supported models: Claude Opus 4.5, Claude Sonnet 4.5
       */
      toolSearchRegex_20251119,
      /**
       * Creates a tool search tool that uses BM25 (natural language) to find tools.
       *
       * The tool search tool enables Claude to work with hundreds or thousands of tools
       * by dynamically discovering and loading them on-demand. Instead of loading all
       * tool definitions into the context window upfront, Claude searches your tool
       * catalog and loads only the tools it needs.
       *
       * Use `providerOptions: { anthropic: { deferLoading: true } }` on other tools
       * to mark them for deferred loading.
       *
       * Supported models: Claude Opus 4.5, Claude Sonnet 4.5
       */
      toolSearchBm25_20251119
    };
    anthropic = createAnthropic();
  }
});

// node_modules/@ai-sdk/openai-compatible/dist/index.mjs
function convertOpenAICompatibleChatUsage(usage) {
  var _a31, _b27, _c, _d, _e, _f;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = (_a31 = usage.prompt_tokens) != null ? _a31 : 0;
  const completionTokens = (_b27 = usage.completion_tokens) != null ? _b27 : 0;
  const cacheReadTokens = (_d = (_c = usage.prompt_tokens_details) == null ? void 0 : _c.cached_tokens) != null ? _d : 0;
  const reasoningTokens = (_f = (_e = usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens - cacheReadTokens,
      cacheRead: cacheReadTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: completionTokens,
      text: completionTokens - reasoningTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function getOpenAIMetadata(message) {
  var _a31, _b27;
  return (_b27 = (_a31 = message == null ? void 0 : message.providerOptions) == null ? void 0 : _a31.openaiCompatible) != null ? _b27 : {};
}
function getAudioFormat(mediaType) {
  switch (mediaType) {
    case "audio/wav":
      return "wav";
    case "audio/mp3":
    case "audio/mpeg":
      return "mp3";
    default:
      return null;
  }
}
function convertToOpenAICompatibleChatMessages(prompt) {
  var _a31, _b27, _c;
  const messages = [];
  for (const { role, content, ...message } of prompt) {
    const metadata = getOpenAIMetadata({ ...message });
    switch (role) {
      case "system": {
        messages.push({ role: "system", content, ...metadata });
        break;
      }
      case "user": {
        if (content.length === 1 && content[0].type === "text") {
          messages.push({
            role: "user",
            content: content[0].text,
            ...getOpenAIMetadata(content[0])
          });
          break;
        }
        messages.push({
          role: "user",
          content: content.map((part) => {
            var _a211;
            const partMetadata = getOpenAIMetadata(part);
            switch (part.type) {
              case "text": {
                return { type: "text", text: part.text, ...partMetadata };
              }
              case "file": {
                if (part.mediaType.startsWith("image/")) {
                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
                  return {
                    type: "image_url",
                    image_url: {
                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
                    },
                    ...partMetadata
                  };
                }
                if (part.mediaType.startsWith("audio/")) {
                  if (part.data instanceof URL) {
                    throw new UnsupportedFunctionalityError({
                      functionality: "audio file parts with URLs"
                    });
                  }
                  const format = getAudioFormat(part.mediaType);
                  if (format === null) {
                    throw new UnsupportedFunctionalityError({
                      functionality: `audio media type ${part.mediaType}`
                    });
                  }
                  return {
                    type: "input_audio",
                    input_audio: {
                      data: convertToBase64(part.data),
                      format
                    },
                    ...partMetadata
                  };
                }
                if (part.mediaType === "application/pdf") {
                  if (part.data instanceof URL) {
                    throw new UnsupportedFunctionalityError({
                      functionality: "PDF file parts with URLs"
                    });
                  }
                  return {
                    type: "file",
                    file: {
                      filename: (_a211 = part.filename) != null ? _a211 : "document.pdf",
                      file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
                    },
                    ...partMetadata
                  };
                }
                if (part.mediaType.startsWith("text/")) {
                  const textContent = part.data instanceof URL ? part.data.toString() : typeof part.data === "string" ? new TextDecoder().decode(
                    convertBase64ToUint8Array(part.data)
                  ) : new TextDecoder().decode(part.data);
                  return {
                    type: "text",
                    text: textContent,
                    ...partMetadata
                  };
                }
                throw new UnsupportedFunctionalityError({
                  functionality: `file part media type ${part.mediaType}`
                });
              }
            }
          }),
          ...metadata
        });
        break;
      }
      case "assistant": {
        let text2 = "";
        let reasoning = "";
        const toolCalls = [];
        for (const part of content) {
          const partMetadata = getOpenAIMetadata(part);
          switch (part.type) {
            case "text": {
              text2 += part.text;
              break;
            }
            case "reasoning": {
              reasoning += part.text;
              break;
            }
            case "tool-call": {
              const thoughtSignature = (_b27 = (_a31 = part.providerOptions) == null ? void 0 : _a31.google) == null ? void 0 : _b27.thoughtSignature;
              toolCalls.push({
                id: part.toolCallId,
                type: "function",
                function: {
                  name: part.toolName,
                  arguments: JSON.stringify(part.input)
                },
                ...partMetadata,
                // Include extra_content for Google Gemini thought signatures
                ...thoughtSignature ? {
                  extra_content: {
                    google: {
                      thought_signature: String(thoughtSignature)
                    }
                  }
                } : {}
              });
              break;
            }
          }
        }
        messages.push({
          role: "assistant",
          content: text2,
          ...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
          ...metadata
        });
        break;
      }
      case "tool": {
        for (const toolResponse of content) {
          if (toolResponse.type === "tool-approval-response") {
            continue;
          }
          const output = toolResponse.output;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = (_c = output.reason) != null ? _c : "Tool execution denied.";
              break;
            case "content":
            case "json":
            case "error-json":
              contentValue = JSON.stringify(output.value);
              break;
          }
          const toolResponseMetadata = getOpenAIMetadata(toolResponse);
          messages.push({
            role: "tool",
            tool_call_id: toolResponse.toolCallId,
            content: contentValue,
            ...toolResponseMetadata
          });
        }
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return messages;
}
function getResponseMetadata5({
  id,
  model,
  created
}) {
  return {
    id: id != null ? id : void 0,
    modelId: model != null ? model : void 0,
    timestamp: created != null ? new Date(created * 1e3) : void 0
  };
}
function mapOpenAICompatibleFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "content_filter":
      return "content-filter";
    case "function_call":
    case "tool_calls":
      return "tool-calls";
    default:
      return "other";
  }
}
function prepareTools4({
  tools,
  toolChoice
}) {
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const openaiCompatTools = [];
  for (const tool3 of tools) {
    if (tool3.type === "provider") {
      toolWarnings.push({
        type: "unsupported",
        feature: `provider-defined tool ${tool3.id}`
      });
    } else {
      openaiCompatTools.push({
        type: "function",
        function: {
          name: tool3.name,
          description: tool3.description,
          parameters: tool3.inputSchema,
          ...tool3.strict != null ? { strict: tool3.strict } : {}
        }
      });
    }
  }
  if (toolChoice == null) {
    return { tools: openaiCompatTools, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
    case "required":
      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
    case "tool":
      return {
        tools: openaiCompatTools,
        toolChoice: {
          type: "function",
          function: { name: toolChoice.toolName }
        },
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new UnsupportedFunctionalityError({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
function convertOpenAICompatibleCompletionUsage(usage) {
  var _a31, _b27;
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = (_a31 = usage.prompt_tokens) != null ? _a31 : 0;
  const completionTokens = (_b27 = usage.completion_tokens) != null ? _b27 : 0;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens,
      cacheRead: void 0,
      cacheWrite: void 0
    },
    outputTokens: {
      total: completionTokens,
      text: completionTokens,
      reasoning: void 0
    },
    raw: usage
  };
}
function convertToOpenAICompatibleCompletionPrompt({
  prompt,
  user = "user",
  assistant = "assistant"
}) {
  let text2 = "";
  if (prompt[0].role === "system") {
    text2 += `${prompt[0].content}

`;
    prompt = prompt.slice(1);
  }
  for (const { role, content } of prompt) {
    switch (role) {
      case "system": {
        throw new InvalidPromptError({
          message: "Unexpected system message in prompt: ${content}",
          prompt
        });
      }
      case "user": {
        const userMessage = content.map((part) => {
          switch (part.type) {
            case "text": {
              return part.text;
            }
          }
        }).filter(Boolean).join("");
        text2 += `${user}:
${userMessage}

`;
        break;
      }
      case "assistant": {
        const assistantMessage = content.map((part) => {
          switch (part.type) {
            case "text": {
              return part.text;
            }
            case "tool-call": {
              throw new UnsupportedFunctionalityError({
                functionality: "tool-call messages"
              });
            }
          }
        }).join("");
        text2 += `${assistant}:
${assistantMessage}

`;
        break;
      }
      case "tool": {
        throw new UnsupportedFunctionalityError({
          functionality: "tool messages"
        });
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  text2 += `${assistant}:
`;
  return {
    prompt: text2,
    stopSequences: [`
${user}:`]
  };
}
function getResponseMetadata22({
  id,
  model,
  created
}) {
  return {
    id: id != null ? id : void 0,
    modelId: model != null ? model : void 0,
    timestamp: created != null ? new Date(created * 1e3) : void 0
  };
}
function mapOpenAICompatibleFinishReason2(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "content_filter":
      return "content-filter";
    case "function_call":
    case "tool_calls":
      return "tool-calls";
    default:
      return "other";
  }
}
async function fileToBlob2(file3) {
  if (file3.type === "url") {
    return downloadBlob(file3.url);
  }
  const data = file3.data instanceof Uint8Array ? file3.data : convertBase64ToUint8Array(file3.data);
  return new Blob([data], { type: file3.mediaType });
}
function toCamelCase2(str) {
  return str.replace(/[_-]([a-z])/g, (g) => g[1].toUpperCase());
}
function createOpenAICompatible(options) {
  const baseURL = withoutTrailingSlash(options.baseURL);
  const providerName = options.name;
  const headers = {
    ...options.apiKey && { Authorization: `Bearer ${options.apiKey}` },
    ...options.headers
  };
  const getHeaders = () => withUserAgentSuffix(headers, `ai-sdk/openai-compatible/${VERSION9}`);
  const getCommonModelConfig = (modelType) => ({
    provider: `${providerName}.${modelType}`,
    url: ({ path: path33 }) => {
      const url4 = new URL(`${baseURL}${path33}`);
      if (options.queryParams) {
        url4.search = new URLSearchParams(options.queryParams).toString();
      }
      return url4.toString();
    },
    headers: getHeaders,
    fetch: options.fetch
  });
  const createLanguageModel = (modelId) => createChatModel(modelId);
  const createChatModel = (modelId) => new OpenAICompatibleChatLanguageModel(modelId, {
    ...getCommonModelConfig("chat"),
    includeUsage: options.includeUsage,
    supportsStructuredOutputs: options.supportsStructuredOutputs,
    transformRequestBody: options.transformRequestBody,
    metadataExtractor: options.metadataExtractor
  });
  const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(modelId, {
    ...getCommonModelConfig("completion"),
    includeUsage: options.includeUsage
  });
  const createEmbeddingModel = (modelId) => new OpenAICompatibleEmbeddingModel(modelId, {
    ...getCommonModelConfig("embedding")
  });
  const createImageModel = (modelId) => new OpenAICompatibleImageModel(modelId, getCommonModelConfig("image"));
  const provider = (modelId) => createLanguageModel(modelId);
  provider.specificationVersion = "v3";
  provider.languageModel = createLanguageModel;
  provider.chatModel = createChatModel;
  provider.completionModel = createCompletionModel;
  provider.embeddingModel = createEmbeddingModel;
  provider.textEmbeddingModel = createEmbeddingModel;
  provider.imageModel = createImageModel;
  return provider;
}
var openaiCompatibleErrorDataSchema, defaultOpenAICompatibleErrorStructure, openaiCompatibleLanguageModelChatOptions, OpenAICompatibleChatLanguageModel, openaiCompatibleTokenUsageSchema, OpenAICompatibleChatResponseSchema, chunkBaseSchema, createOpenAICompatibleChatChunkSchema, openaiCompatibleLanguageModelCompletionOptions, OpenAICompatibleCompletionLanguageModel, usageSchema2, openaiCompatibleCompletionResponseSchema, createOpenAICompatibleCompletionChunkSchema, openaiCompatibleEmbeddingModelOptions, OpenAICompatibleEmbeddingModel, openaiTextEmbeddingResponseSchema2, OpenAICompatibleImageModel, openaiCompatibleImageResponseSchema, VERSION9;
var init_dist14 = __esm({
  "node_modules/@ai-sdk/openai-compatible/dist/index.mjs"() {
    "use strict";
    init_dist3();
    init_dist5();
    init_v42();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist3();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    openaiCompatibleErrorDataSchema = external_exports.object({
      error: external_exports.object({
        message: external_exports.string(),
        // The additional information below is handled loosely to support
        // OpenAI-compatible providers that have slightly different error
        // responses:
        type: external_exports.string().nullish(),
        param: external_exports.any().nullish(),
        code: external_exports.union([external_exports.string(), external_exports.number()]).nullish()
      })
    });
    defaultOpenAICompatibleErrorStructure = {
      errorSchema: openaiCompatibleErrorDataSchema,
      errorToMessage: (data) => data.error.message
    };
    openaiCompatibleLanguageModelChatOptions = external_exports.object({
      /**
       * A unique identifier representing your end-user, which can help the provider to
       * monitor and detect abuse.
       */
      user: external_exports.string().optional(),
      /**
       * Reasoning effort for reasoning models. Defaults to `medium`.
       */
      reasoningEffort: external_exports.string().optional(),
      /**
       * Controls the verbosity of the generated text. Defaults to `medium`.
       */
      textVerbosity: external_exports.string().optional(),
      /**
       * Whether to use strict JSON schema validation.
       * When true, the model uses constrained decoding to guarantee schema compliance.
       * Only used when the provider supports structured outputs and a schema is provided.
       *
       * @default true
       */
      strictJsonSchema: external_exports.boolean().optional()
    });
    OpenAICompatibleChatLanguageModel = class {
      // type inferred via constructor
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        var _a31, _b27;
        this.modelId = modelId;
        this.config = config3;
        const errorStructure = (_a31 = config3.errorStructure) != null ? _a31 : defaultOpenAICompatibleErrorStructure;
        this.chunkSchema = createOpenAICompatibleChatChunkSchema(
          errorStructure.errorSchema
        );
        this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
        this.supportsStructuredOutputs = (_b27 = config3.supportsStructuredOutputs) != null ? _b27 : false;
      }
      get provider() {
        return this.config.provider;
      }
      get providerOptionsName() {
        return this.config.provider.split(".")[0].trim();
      }
      get supportedUrls() {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).supportedUrls) == null ? void 0 : _b27.call(_a31)) != null ? _c : {};
      }
      transformRequestBody(args) {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).transformRequestBody) == null ? void 0 : _b27.call(_a31, args)) != null ? _c : args;
      }
      async getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        providerOptions,
        stopSequences,
        responseFormat,
        seed,
        toolChoice,
        tools
      }) {
        var _a31, _b27, _c, _d, _e;
        const warnings = [];
        const deprecatedOptions = await parseProviderOptions({
          provider: "openai-compatible",
          providerOptions,
          schema: openaiCompatibleLanguageModelChatOptions
        });
        if (deprecatedOptions != null) {
          warnings.push({
            type: "other",
            message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
          });
        }
        const compatibleOptions = Object.assign(
          deprecatedOptions != null ? deprecatedOptions : {},
          (_a31 = await parseProviderOptions({
            provider: "openaiCompatible",
            providerOptions,
            schema: openaiCompatibleLanguageModelChatOptions
          })) != null ? _a31 : {},
          (_b27 = await parseProviderOptions({
            provider: this.providerOptionsName,
            providerOptions,
            schema: openaiCompatibleLanguageModelChatOptions
          })) != null ? _b27 : {}
        );
        const strictJsonSchema = (_c = compatibleOptions == null ? void 0 : compatibleOptions.strictJsonSchema) != null ? _c : true;
        if (topK != null) {
          warnings.push({ type: "unsupported", feature: "topK" });
        }
        if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
          warnings.push({
            type: "unsupported",
            feature: "responseFormat",
            details: "JSON response format schema is only supported with structuredOutputs"
          });
        }
        const {
          tools: openaiTools2,
          toolChoice: openaiToolChoice,
          toolWarnings
        } = prepareTools4({
          tools,
          toolChoice
        });
        return {
          args: {
            // model id:
            model: this.modelId,
            // model specific settings:
            user: compatibleOptions.user,
            // standardized settings:
            max_tokens: maxOutputTokens,
            temperature,
            top_p: topP,
            frequency_penalty: frequencyPenalty,
            presence_penalty: presencePenalty,
            response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
              type: "json_schema",
              json_schema: {
                schema: responseFormat.schema,
                strict: strictJsonSchema,
                name: (_d = responseFormat.name) != null ? _d : "response",
                description: responseFormat.description
              }
            } : { type: "json_object" } : void 0,
            stop: stopSequences,
            seed,
            ...Object.fromEntries(
              Object.entries(
                (_e = providerOptions == null ? void 0 : providerOptions[this.providerOptionsName]) != null ? _e : {}
              ).filter(
                ([key]) => !Object.keys(
                  openaiCompatibleLanguageModelChatOptions.shape
                ).includes(key)
              )
            ),
            reasoning_effort: compatibleOptions.reasoningEffort,
            verbosity: compatibleOptions.textVerbosity,
            // messages:
            messages: convertToOpenAICompatibleChatMessages(prompt),
            // tools:
            tools: openaiTools2,
            tool_choice: openaiToolChoice
          },
          warnings: [...warnings, ...toolWarnings]
        };
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h;
        const { args, warnings } = await this.getArgs({ ...options });
        const transformedBody = this.transformRequestBody(args);
        const body = JSON.stringify(transformedBody);
        const {
          responseHeaders,
          value: responseBody,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body: transformedBody,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            OpenAICompatibleChatResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const choice2 = responseBody.choices[0];
        const content = [];
        const text2 = choice2.message.content;
        if (text2 != null && text2.length > 0) {
          content.push({ type: "text", text: text2 });
        }
        const reasoning = (_a31 = choice2.message.reasoning_content) != null ? _a31 : choice2.message.reasoning;
        if (reasoning != null && reasoning.length > 0) {
          content.push({
            type: "reasoning",
            text: reasoning
          });
        }
        if (choice2.message.tool_calls != null) {
          for (const toolCall of choice2.message.tool_calls) {
            const thoughtSignature = (_c = (_b27 = toolCall.extra_content) == null ? void 0 : _b27.google) == null ? void 0 : _c.thought_signature;
            content.push({
              type: "tool-call",
              toolCallId: (_d = toolCall.id) != null ? _d : generateId(),
              toolName: toolCall.function.name,
              input: toolCall.function.arguments,
              ...thoughtSignature ? {
                providerMetadata: {
                  [this.providerOptionsName]: { thoughtSignature }
                }
              } : {}
            });
          }
        }
        const providerMetadata = {
          [this.providerOptionsName]: {},
          ...await ((_f = (_e = this.config.metadataExtractor) == null ? void 0 : _e.extractMetadata) == null ? void 0 : _f.call(_e, {
            parsedBody: rawResponse
          }))
        };
        const completionTokenDetails = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens_details;
        if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
          providerMetadata[this.providerOptionsName].acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
        }
        if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
          providerMetadata[this.providerOptionsName].rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
        }
        return {
          content,
          finishReason: {
            unified: mapOpenAICompatibleFinishReason(choice2.finish_reason),
            raw: (_h = choice2.finish_reason) != null ? _h : void 0
          },
          usage: convertOpenAICompatibleChatUsage(responseBody.usage),
          providerMetadata,
          request: { body },
          response: {
            ...getResponseMetadata5(responseBody),
            headers: responseHeaders,
            body: rawResponse
          },
          warnings
        };
      }
      async doStream(options) {
        var _a31;
        const { args, warnings } = await this.getArgs({ ...options });
        const body = this.transformRequestBody({
          ...args,
          stream: true,
          // only include stream_options when in strict compatibility mode:
          stream_options: this.config.includeUsage ? { include_usage: true } : void 0
        });
        const metadataExtractor = (_a31 = this.config.metadataExtractor) == null ? void 0 : _a31.createStreamExtractor();
        const { responseHeaders, value: response } = await postJsonToApi({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler(
            this.chunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const toolCalls = [];
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        let usage = void 0;
        let isFirstChunk = true;
        const providerOptionsName = this.providerOptionsName;
        let isActiveReasoning = false;
        let isActiveText = false;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                var _a211, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                metadataExtractor == null ? void 0 : metadataExtractor.processChunk(chunk.rawValue);
                if ("error" in chunk.value) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({
                    type: "error",
                    error: chunk.value.error.message
                  });
                  return;
                }
                const value = chunk.value;
                if (isFirstChunk) {
                  isFirstChunk = false;
                  controller.enqueue({
                    type: "response-metadata",
                    ...getResponseMetadata5(value)
                  });
                }
                if (value.usage != null) {
                  usage = value.usage;
                }
                const choice2 = value.choices[0];
                if ((choice2 == null ? void 0 : choice2.finish_reason) != null) {
                  finishReason = {
                    unified: mapOpenAICompatibleFinishReason(choice2.finish_reason),
                    raw: (_a211 = choice2.finish_reason) != null ? _a211 : void 0
                  };
                }
                if ((choice2 == null ? void 0 : choice2.delta) == null) {
                  return;
                }
                const delta = choice2.delta;
                const reasoningContent = (_b27 = delta.reasoning_content) != null ? _b27 : delta.reasoning;
                if (reasoningContent) {
                  if (!isActiveReasoning) {
                    controller.enqueue({
                      type: "reasoning-start",
                      id: "reasoning-0"
                    });
                    isActiveReasoning = true;
                  }
                  controller.enqueue({
                    type: "reasoning-delta",
                    id: "reasoning-0",
                    delta: reasoningContent
                  });
                }
                if (delta.content) {
                  if (isActiveReasoning) {
                    controller.enqueue({
                      type: "reasoning-end",
                      id: "reasoning-0"
                    });
                    isActiveReasoning = false;
                  }
                  if (!isActiveText) {
                    controller.enqueue({ type: "text-start", id: "txt-0" });
                    isActiveText = true;
                  }
                  controller.enqueue({
                    type: "text-delta",
                    id: "txt-0",
                    delta: delta.content
                  });
                }
                if (delta.tool_calls != null) {
                  if (isActiveReasoning) {
                    controller.enqueue({
                      type: "reasoning-end",
                      id: "reasoning-0"
                    });
                    isActiveReasoning = false;
                  }
                  for (const toolCallDelta of delta.tool_calls) {
                    const index = (_c = toolCallDelta.index) != null ? _c : toolCalls.length;
                    if (toolCalls[index] == null) {
                      if (toolCallDelta.id == null) {
                        throw new InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'id' to be a string.`
                        });
                      }
                      if (((_d = toolCallDelta.function) == null ? void 0 : _d.name) == null) {
                        throw new InvalidResponseDataError({
                          data: toolCallDelta,
                          message: `Expected 'function.name' to be a string.`
                        });
                      }
                      controller.enqueue({
                        type: "tool-input-start",
                        id: toolCallDelta.id,
                        toolName: toolCallDelta.function.name
                      });
                      toolCalls[index] = {
                        id: toolCallDelta.id,
                        type: "function",
                        function: {
                          name: toolCallDelta.function.name,
                          arguments: (_e = toolCallDelta.function.arguments) != null ? _e : ""
                        },
                        hasFinished: false,
                        thoughtSignature: (_h = (_g = (_f = toolCallDelta.extra_content) == null ? void 0 : _f.google) == null ? void 0 : _g.thought_signature) != null ? _h : void 0
                      };
                      const toolCall2 = toolCalls[index];
                      if (((_i = toolCall2.function) == null ? void 0 : _i.name) != null && ((_j = toolCall2.function) == null ? void 0 : _j.arguments) != null) {
                        if (toolCall2.function.arguments.length > 0) {
                          controller.enqueue({
                            type: "tool-input-delta",
                            id: toolCall2.id,
                            delta: toolCall2.function.arguments
                          });
                        }
                        if (isParsableJson(toolCall2.function.arguments)) {
                          controller.enqueue({
                            type: "tool-input-end",
                            id: toolCall2.id
                          });
                          controller.enqueue({
                            type: "tool-call",
                            toolCallId: (_k = toolCall2.id) != null ? _k : generateId(),
                            toolName: toolCall2.function.name,
                            input: toolCall2.function.arguments,
                            ...toolCall2.thoughtSignature ? {
                              providerMetadata: {
                                [providerOptionsName]: {
                                  thoughtSignature: toolCall2.thoughtSignature
                                }
                              }
                            } : {}
                          });
                          toolCall2.hasFinished = true;
                        }
                      }
                      continue;
                    }
                    const toolCall = toolCalls[index];
                    if (toolCall.hasFinished) {
                      continue;
                    }
                    if (((_l = toolCallDelta.function) == null ? void 0 : _l.arguments) != null) {
                      toolCall.function.arguments += (_n = (_m = toolCallDelta.function) == null ? void 0 : _m.arguments) != null ? _n : "";
                    }
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.id,
                      delta: (_o = toolCallDelta.function.arguments) != null ? _o : ""
                    });
                    if (((_p = toolCall.function) == null ? void 0 : _p.name) != null && ((_q = toolCall.function) == null ? void 0 : _q.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: (_r = toolCall.id) != null ? _r : generateId(),
                        toolName: toolCall.function.name,
                        input: toolCall.function.arguments,
                        ...toolCall.thoughtSignature ? {
                          providerMetadata: {
                            [providerOptionsName]: {
                              thoughtSignature: toolCall.thoughtSignature
                            }
                          }
                        } : {}
                      });
                      toolCall.hasFinished = true;
                    }
                  }
                }
              },
              flush(controller) {
                var _a211, _b27, _c, _d, _e;
                if (isActiveReasoning) {
                  controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
                }
                if (isActiveText) {
                  controller.enqueue({ type: "text-end", id: "txt-0" });
                }
                for (const toolCall of toolCalls.filter(
                  (toolCall2) => !toolCall2.hasFinished
                )) {
                  controller.enqueue({
                    type: "tool-input-end",
                    id: toolCall.id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: (_a211 = toolCall.id) != null ? _a211 : generateId(),
                    toolName: toolCall.function.name,
                    input: toolCall.function.arguments,
                    ...toolCall.thoughtSignature ? {
                      providerMetadata: {
                        [providerOptionsName]: {
                          thoughtSignature: toolCall.thoughtSignature
                        }
                      }
                    } : {}
                  });
                }
                const providerMetadata = {
                  [providerOptionsName]: {},
                  ...metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata()
                };
                if (((_b27 = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _b27.accepted_prediction_tokens) != null) {
                  providerMetadata[providerOptionsName].acceptedPredictionTokens = (_c = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _c.accepted_prediction_tokens;
                }
                if (((_d = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _d.rejected_prediction_tokens) != null) {
                  providerMetadata[providerOptionsName].rejectedPredictionTokens = (_e = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _e.rejected_prediction_tokens;
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage: convertOpenAICompatibleChatUsage(usage),
                  providerMetadata
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    openaiCompatibleTokenUsageSchema = external_exports.looseObject({
      prompt_tokens: external_exports.number().nullish(),
      completion_tokens: external_exports.number().nullish(),
      total_tokens: external_exports.number().nullish(),
      prompt_tokens_details: external_exports.object({
        cached_tokens: external_exports.number().nullish()
      }).nullish(),
      completion_tokens_details: external_exports.object({
        reasoning_tokens: external_exports.number().nullish(),
        accepted_prediction_tokens: external_exports.number().nullish(),
        rejected_prediction_tokens: external_exports.number().nullish()
      }).nullish()
    }).nullish();
    OpenAICompatibleChatResponseSchema = external_exports.looseObject({
      id: external_exports.string().nullish(),
      created: external_exports.number().nullish(),
      model: external_exports.string().nullish(),
      choices: external_exports.array(
        external_exports.object({
          message: external_exports.object({
            role: external_exports.literal("assistant").nullish(),
            content: external_exports.string().nullish(),
            reasoning_content: external_exports.string().nullish(),
            reasoning: external_exports.string().nullish(),
            tool_calls: external_exports.array(
              external_exports.object({
                id: external_exports.string().nullish(),
                function: external_exports.object({
                  name: external_exports.string(),
                  arguments: external_exports.string()
                }),
                // Support for Google Gemini thought signatures via OpenAI compatibility
                extra_content: external_exports.object({
                  google: external_exports.object({
                    thought_signature: external_exports.string().nullish()
                  }).nullish()
                }).nullish()
              })
            ).nullish()
          }),
          finish_reason: external_exports.string().nullish()
        })
      ),
      usage: openaiCompatibleTokenUsageSchema
    });
    chunkBaseSchema = external_exports.looseObject({
      id: external_exports.string().nullish(),
      created: external_exports.number().nullish(),
      model: external_exports.string().nullish(),
      choices: external_exports.array(
        external_exports.object({
          delta: external_exports.object({
            role: external_exports.enum(["assistant"]).nullish(),
            content: external_exports.string().nullish(),
            // Most openai-compatible models set `reasoning_content`, but some
            // providers serving `gpt-oss` set `reasoning`. See #7866
            reasoning_content: external_exports.string().nullish(),
            reasoning: external_exports.string().nullish(),
            tool_calls: external_exports.array(
              external_exports.object({
                index: external_exports.number().nullish(),
                //google does not send index
                id: external_exports.string().nullish(),
                function: external_exports.object({
                  name: external_exports.string().nullish(),
                  arguments: external_exports.string().nullish()
                }),
                // Support for Google Gemini thought signatures via OpenAI compatibility
                extra_content: external_exports.object({
                  google: external_exports.object({
                    thought_signature: external_exports.string().nullish()
                  }).nullish()
                }).nullish()
              })
            ).nullish()
          }).nullish(),
          finish_reason: external_exports.string().nullish()
        })
      ),
      usage: openaiCompatibleTokenUsageSchema
    });
    createOpenAICompatibleChatChunkSchema = (errorSchema) => external_exports.union([chunkBaseSchema, errorSchema]);
    openaiCompatibleLanguageModelCompletionOptions = external_exports.object({
      /**
       * Echo back the prompt in addition to the completion.
       */
      echo: external_exports.boolean().optional(),
      /**
       * Modify the likelihood of specified tokens appearing in the completion.
       *
       * Accepts a JSON object that maps tokens (specified by their token ID in
       * the GPT tokenizer) to an associated bias value from -100 to 100.
       */
      logitBias: external_exports.record(external_exports.string(), external_exports.number()).optional(),
      /**
       * The suffix that comes after a completion of inserted text.
       */
      suffix: external_exports.string().optional(),
      /**
       * A unique identifier representing your end-user, which can help providers to
       * monitor and detect abuse.
       */
      user: external_exports.string().optional()
    });
    OpenAICompatibleCompletionLanguageModel = class {
      // type inferred via constructor
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        var _a31;
        this.modelId = modelId;
        this.config = config3;
        const errorStructure = (_a31 = config3.errorStructure) != null ? _a31 : defaultOpenAICompatibleErrorStructure;
        this.chunkSchema = createOpenAICompatibleCompletionChunkSchema(
          errorStructure.errorSchema
        );
        this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
      }
      get provider() {
        return this.config.provider;
      }
      get providerOptionsName() {
        return this.config.provider.split(".")[0].trim();
      }
      get supportedUrls() {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).supportedUrls) == null ? void 0 : _b27.call(_a31)) != null ? _c : {};
      }
      async getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        stopSequences: userStopSequences,
        responseFormat,
        seed,
        providerOptions,
        tools,
        toolChoice
      }) {
        var _a31;
        const warnings = [];
        const completionOptions = (_a31 = await parseProviderOptions({
          provider: this.providerOptionsName,
          providerOptions,
          schema: openaiCompatibleLanguageModelCompletionOptions
        })) != null ? _a31 : {};
        if (topK != null) {
          warnings.push({ type: "unsupported", feature: "topK" });
        }
        if (tools == null ? void 0 : tools.length) {
          warnings.push({ type: "unsupported", feature: "tools" });
        }
        if (toolChoice != null) {
          warnings.push({ type: "unsupported", feature: "toolChoice" });
        }
        if (responseFormat != null && responseFormat.type !== "text") {
          warnings.push({
            type: "unsupported",
            feature: "responseFormat",
            details: "JSON response format is not supported."
          });
        }
        const { prompt: completionPrompt, stopSequences } = convertToOpenAICompatibleCompletionPrompt({ prompt });
        const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
        return {
          args: {
            // model id:
            model: this.modelId,
            // model specific settings:
            echo: completionOptions.echo,
            logit_bias: completionOptions.logitBias,
            suffix: completionOptions.suffix,
            user: completionOptions.user,
            // standardized settings:
            max_tokens: maxOutputTokens,
            temperature,
            top_p: topP,
            frequency_penalty: frequencyPenalty,
            presence_penalty: presencePenalty,
            seed,
            ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
            // prompt:
            prompt: completionPrompt,
            // stop sequences:
            stop: stop.length > 0 ? stop : void 0
          },
          warnings
        };
      }
      async doGenerate(options) {
        const { args, warnings } = await this.getArgs(options);
        const {
          responseHeaders,
          value: response,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: this.config.url({
            path: "/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body: args,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            openaiCompatibleCompletionResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const choice2 = response.choices[0];
        const content = [];
        if (choice2.text != null && choice2.text.length > 0) {
          content.push({ type: "text", text: choice2.text });
        }
        return {
          content,
          usage: convertOpenAICompatibleCompletionUsage(response.usage),
          finishReason: {
            unified: mapOpenAICompatibleFinishReason2(choice2.finish_reason),
            raw: choice2.finish_reason
          },
          request: { body: args },
          response: {
            ...getResponseMetadata22(response),
            headers: responseHeaders,
            body: rawResponse
          },
          warnings
        };
      }
      async doStream(options) {
        const { args, warnings } = await this.getArgs(options);
        const body = {
          ...args,
          stream: true,
          // only include stream_options when in strict compatibility mode:
          stream_options: this.config.includeUsage ? { include_usage: true } : void 0
        };
        const { responseHeaders, value: response } = await postJsonToApi({
          url: this.config.url({
            path: "/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler(
            this.chunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        let usage = void 0;
        let isFirstChunk = true;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                var _a31;
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                if ("error" in value) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: value.error });
                  return;
                }
                if (isFirstChunk) {
                  isFirstChunk = false;
                  controller.enqueue({
                    type: "response-metadata",
                    ...getResponseMetadata22(value)
                  });
                  controller.enqueue({
                    type: "text-start",
                    id: "0"
                  });
                }
                if (value.usage != null) {
                  usage = value.usage;
                }
                const choice2 = value.choices[0];
                if ((choice2 == null ? void 0 : choice2.finish_reason) != null) {
                  finishReason = {
                    unified: mapOpenAICompatibleFinishReason2(choice2.finish_reason),
                    raw: (_a31 = choice2.finish_reason) != null ? _a31 : void 0
                  };
                }
                if ((choice2 == null ? void 0 : choice2.text) != null) {
                  controller.enqueue({
                    type: "text-delta",
                    id: "0",
                    delta: choice2.text
                  });
                }
              },
              flush(controller) {
                if (!isFirstChunk) {
                  controller.enqueue({ type: "text-end", id: "0" });
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage: convertOpenAICompatibleCompletionUsage(usage)
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    usageSchema2 = external_exports.object({
      prompt_tokens: external_exports.number(),
      completion_tokens: external_exports.number(),
      total_tokens: external_exports.number()
    });
    openaiCompatibleCompletionResponseSchema = external_exports.object({
      id: external_exports.string().nullish(),
      created: external_exports.number().nullish(),
      model: external_exports.string().nullish(),
      choices: external_exports.array(
        external_exports.object({
          text: external_exports.string(),
          finish_reason: external_exports.string()
        })
      ),
      usage: usageSchema2.nullish()
    });
    createOpenAICompatibleCompletionChunkSchema = (errorSchema) => external_exports.union([
      external_exports.object({
        id: external_exports.string().nullish(),
        created: external_exports.number().nullish(),
        model: external_exports.string().nullish(),
        choices: external_exports.array(
          external_exports.object({
            text: external_exports.string(),
            finish_reason: external_exports.string().nullish(),
            index: external_exports.number()
          })
        ),
        usage: usageSchema2.nullish()
      }),
      errorSchema
    ]);
    openaiCompatibleEmbeddingModelOptions = external_exports.object({
      /**
       * The number of dimensions the resulting output embeddings should have.
       * Only supported in text-embedding-3 and later models.
       */
      dimensions: external_exports.number().optional(),
      /**
       * A unique identifier representing your end-user, which can help providers to
       * monitor and detect abuse.
       */
      user: external_exports.string().optional()
    });
    OpenAICompatibleEmbeddingModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.modelId = modelId;
        this.config = config3;
      }
      get provider() {
        return this.config.provider;
      }
      get maxEmbeddingsPerCall() {
        var _a31;
        return (_a31 = this.config.maxEmbeddingsPerCall) != null ? _a31 : 2048;
      }
      get supportsParallelCalls() {
        var _a31;
        return (_a31 = this.config.supportsParallelCalls) != null ? _a31 : true;
      }
      get providerOptionsName() {
        return this.config.provider.split(".")[0].trim();
      }
      async doEmbed({
        values,
        headers,
        abortSignal,
        providerOptions
      }) {
        var _a31, _b27, _c;
        const warnings = [];
        const deprecatedOptions = await parseProviderOptions({
          provider: "openai-compatible",
          providerOptions,
          schema: openaiCompatibleEmbeddingModelOptions
        });
        if (deprecatedOptions != null) {
          warnings.push({
            type: "other",
            message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
          });
        }
        const compatibleOptions = Object.assign(
          deprecatedOptions != null ? deprecatedOptions : {},
          (_a31 = await parseProviderOptions({
            provider: "openaiCompatible",
            providerOptions,
            schema: openaiCompatibleEmbeddingModelOptions
          })) != null ? _a31 : {},
          (_b27 = await parseProviderOptions({
            provider: this.providerOptionsName,
            providerOptions,
            schema: openaiCompatibleEmbeddingModelOptions
          })) != null ? _b27 : {}
        );
        if (values.length > this.maxEmbeddingsPerCall) {
          throw new TooManyEmbeddingValuesForCallError({
            provider: this.provider,
            modelId: this.modelId,
            maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
            values
          });
        }
        const {
          responseHeaders,
          value: response,
          rawValue
        } = await postJsonToApi({
          url: this.config.url({
            path: "/embeddings",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), headers),
          body: {
            model: this.modelId,
            input: values,
            encoding_format: "float",
            dimensions: compatibleOptions.dimensions,
            user: compatibleOptions.user
          },
          failedResponseHandler: createJsonErrorResponseHandler(
            (_c = this.config.errorStructure) != null ? _c : defaultOpenAICompatibleErrorStructure
          ),
          successfulResponseHandler: createJsonResponseHandler(
            openaiTextEmbeddingResponseSchema2
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        return {
          warnings,
          embeddings: response.data.map((item) => item.embedding),
          usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
          providerMetadata: response.providerMetadata,
          response: { headers: responseHeaders, body: rawValue }
        };
      }
    };
    openaiTextEmbeddingResponseSchema2 = external_exports.object({
      data: external_exports.array(external_exports.object({ embedding: external_exports.array(external_exports.number()) })),
      usage: external_exports.object({ prompt_tokens: external_exports.number() }).nullish(),
      providerMetadata: external_exports.record(external_exports.string(), external_exports.record(external_exports.string(), external_exports.any())).optional()
    });
    OpenAICompatibleImageModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
        this.maxImagesPerCall = 10;
      }
      get provider() {
        return this.config.provider;
      }
      /**
       * The provider options key used to extract provider-specific options.
       */
      get providerOptionsKey() {
        return this.config.provider.split(".")[0].trim();
      }
      // TODO: deprecate non-camelCase keys and remove in future major version
      getArgs(providerOptions) {
        return {
          ...providerOptions[this.providerOptionsKey],
          ...providerOptions[toCamelCase2(this.providerOptionsKey)]
        };
      }
      async doGenerate({
        prompt,
        n,
        size,
        aspectRatio,
        seed,
        providerOptions,
        headers,
        abortSignal,
        files,
        mask
      }) {
        var _a31, _b27, _c, _d, _e;
        const warnings = [];
        if (aspectRatio != null) {
          warnings.push({
            type: "unsupported",
            feature: "aspectRatio",
            details: "This model does not support aspect ratio. Use `size` instead."
          });
        }
        if (seed != null) {
          warnings.push({ type: "unsupported", feature: "seed" });
        }
        const currentDate = (_c = (_b27 = (_a31 = this.config._internal) == null ? void 0 : _a31.currentDate) == null ? void 0 : _b27.call(_a31)) != null ? _c : /* @__PURE__ */ new Date();
        const args = this.getArgs(providerOptions);
        if (files != null && files.length > 0) {
          const { value: response2, responseHeaders: responseHeaders2 } = await postFormDataToApi({
            url: this.config.url({
              path: "/images/edits",
              modelId: this.modelId
            }),
            headers: combineHeaders(this.config.headers(), headers),
            formData: convertToFormData({
              model: this.modelId,
              prompt,
              image: await Promise.all(files.map((file3) => fileToBlob2(file3))),
              mask: mask != null ? await fileToBlob2(mask) : void 0,
              n,
              size,
              ...args
            }),
            failedResponseHandler: createJsonErrorResponseHandler(
              (_d = this.config.errorStructure) != null ? _d : defaultOpenAICompatibleErrorStructure
            ),
            successfulResponseHandler: createJsonResponseHandler(
              openaiCompatibleImageResponseSchema
            ),
            abortSignal,
            fetch: this.config.fetch
          });
          return {
            images: response2.data.map((item) => item.b64_json),
            warnings,
            response: {
              timestamp: currentDate,
              modelId: this.modelId,
              headers: responseHeaders2
            }
          };
        }
        const { value: response, responseHeaders } = await postJsonToApi({
          url: this.config.url({
            path: "/images/generations",
            modelId: this.modelId
          }),
          headers: combineHeaders(this.config.headers(), headers),
          body: {
            model: this.modelId,
            prompt,
            n,
            size,
            ...args,
            response_format: "b64_json"
          },
          failedResponseHandler: createJsonErrorResponseHandler(
            (_e = this.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure
          ),
          successfulResponseHandler: createJsonResponseHandler(
            openaiCompatibleImageResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        return {
          images: response.data.map((item) => item.b64_json),
          warnings,
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: responseHeaders
          }
        };
      }
    };
    openaiCompatibleImageResponseSchema = external_exports.object({
      data: external_exports.array(external_exports.object({ b64_json: external_exports.string() }))
    });
    VERSION9 = true ? "2.0.37" : "0.0.0-test";
  }
});

// node_modules/@ai-sdk/xai/dist/index.mjs
function convertToXaiChatMessages(prompt) {
  var _a31;
  const messages = [];
  const warnings = [];
  for (const { role, content } of prompt) {
    switch (role) {
      case "system": {
        messages.push({ role: "system", content });
        break;
      }
      case "user": {
        if (content.length === 1 && content[0].type === "text") {
          messages.push({ role: "user", content: content[0].text });
          break;
        }
        messages.push({
          role: "user",
          content: content.map((part) => {
            switch (part.type) {
              case "text": {
                return { type: "text", text: part.text };
              }
              case "file": {
                if (part.mediaType.startsWith("image/")) {
                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
                  return {
                    type: "image_url",
                    image_url: {
                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
                    }
                  };
                } else {
                  throw new UnsupportedFunctionalityError({
                    functionality: `file part media type ${part.mediaType}`
                  });
                }
              }
            }
          })
        });
        break;
      }
      case "assistant": {
        let text2 = "";
        const toolCalls = [];
        for (const part of content) {
          switch (part.type) {
            case "text": {
              text2 += part.text;
              break;
            }
            case "tool-call": {
              toolCalls.push({
                id: part.toolCallId,
                type: "function",
                function: {
                  name: part.toolName,
                  arguments: JSON.stringify(part.input)
                }
              });
              break;
            }
          }
        }
        messages.push({
          role: "assistant",
          content: text2,
          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
        });
        break;
      }
      case "tool": {
        for (const toolResponse of content) {
          if (toolResponse.type === "tool-approval-response") {
            continue;
          }
          const output = toolResponse.output;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = (_a31 = output.reason) != null ? _a31 : "Tool execution denied.";
              break;
            case "content":
            case "json":
            case "error-json":
              contentValue = JSON.stringify(output.value);
              break;
          }
          messages.push({
            role: "tool",
            tool_call_id: toolResponse.toolCallId,
            content: contentValue
          });
        }
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return { messages, warnings };
}
function convertXaiChatUsage(usage) {
  var _a31, _b27, _c, _d;
  const cacheReadTokens = (_b27 = (_a31 = usage.prompt_tokens_details) == null ? void 0 : _a31.cached_tokens) != null ? _b27 : 0;
  const reasoningTokens = (_d = (_c = usage.completion_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0;
  const promptTokensIncludesCached = cacheReadTokens <= usage.prompt_tokens;
  return {
    inputTokens: {
      total: promptTokensIncludesCached ? usage.prompt_tokens : usage.prompt_tokens + cacheReadTokens,
      noCache: promptTokensIncludesCached ? usage.prompt_tokens - cacheReadTokens : usage.prompt_tokens,
      cacheRead: cacheReadTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: usage.completion_tokens + reasoningTokens,
      text: usage.completion_tokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function getResponseMetadata6({
  id,
  model,
  created,
  created_at
}) {
  const unixTime = created != null ? created : created_at;
  return {
    id: id != null ? id : void 0,
    modelId: model != null ? model : void 0,
    timestamp: unixTime != null ? new Date(unixTime * 1e3) : void 0
  };
}
function mapXaiFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "tool_calls":
    case "function_call":
      return "tool-calls";
    case "content_filter":
      return "content-filter";
    default:
      return "other";
  }
}
function prepareTools5({
  tools,
  toolChoice
}) {
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const xaiTools2 = [];
  for (const tool3 of tools) {
    if (tool3.type === "provider") {
      toolWarnings.push({
        type: "unsupported",
        feature: `provider-defined tool ${tool3.name}`
      });
    } else {
      xaiTools2.push({
        type: "function",
        function: {
          name: tool3.name,
          description: tool3.description,
          parameters: tool3.inputSchema,
          ...tool3.strict != null ? { strict: tool3.strict } : {}
        }
      });
    }
  }
  if (toolChoice == null) {
    return { tools: xaiTools2, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
      return { tools: xaiTools2, toolChoice: type, toolWarnings };
    case "required":
      return { tools: xaiTools2, toolChoice: "required", toolWarnings };
    case "tool":
      return {
        tools: xaiTools2,
        toolChoice: {
          type: "function",
          function: { name: toolChoice.toolName }
        },
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new UnsupportedFunctionalityError({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
async function convertToXaiResponsesInput({
  prompt
}) {
  var _a31, _b27, _c, _d, _e;
  const input = [];
  const inputWarnings = [];
  for (const message of prompt) {
    switch (message.role) {
      case "system": {
        input.push({
          role: "system",
          content: message.content
        });
        break;
      }
      case "user": {
        const contentParts = [];
        for (const block of message.content) {
          switch (block.type) {
            case "text": {
              contentParts.push({ type: "input_text", text: block.text });
              break;
            }
            case "file": {
              if (block.mediaType.startsWith("image/")) {
                const mediaType = block.mediaType === "image/*" ? "image/jpeg" : block.mediaType;
                const imageUrl = block.data instanceof URL ? block.data.toString() : `data:${mediaType};base64,${convertToBase64(block.data)}`;
                contentParts.push({ type: "input_image", image_url: imageUrl });
              } else {
                throw new UnsupportedFunctionalityError({
                  functionality: `file part media type ${block.mediaType}`
                });
              }
              break;
            }
            default: {
              const _exhaustiveCheck = block;
              inputWarnings.push({
                type: "other",
                message: "xAI Responses API does not support this content type in user messages"
              });
            }
          }
        }
        input.push({
          role: "user",
          content: contentParts
        });
        break;
      }
      case "assistant": {
        for (const part of message.content) {
          switch (part.type) {
            case "text": {
              const id = typeof ((_b27 = (_a31 = part.providerOptions) == null ? void 0 : _a31.xai) == null ? void 0 : _b27.itemId) === "string" ? part.providerOptions.xai.itemId : void 0;
              input.push({
                role: "assistant",
                content: part.text,
                id
              });
              break;
            }
            case "tool-call": {
              if (part.providerExecuted) {
                break;
              }
              const id = typeof ((_d = (_c = part.providerOptions) == null ? void 0 : _c.xai) == null ? void 0 : _d.itemId) === "string" ? part.providerOptions.xai.itemId : void 0;
              input.push({
                type: "function_call",
                id: id != null ? id : part.toolCallId,
                call_id: part.toolCallId,
                name: part.toolName,
                arguments: JSON.stringify(part.input),
                status: "completed"
              });
              break;
            }
            case "tool-result": {
              break;
            }
            case "reasoning":
            case "file": {
              inputWarnings.push({
                type: "other",
                message: `xAI Responses API does not support ${part.type} in assistant messages`
              });
              break;
            }
            default: {
              const _exhaustiveCheck = part;
              inputWarnings.push({
                type: "other",
                message: "xAI Responses API does not support this content type in assistant messages"
              });
            }
          }
        }
        break;
      }
      case "tool": {
        for (const part of message.content) {
          if (part.type === "tool-approval-response") {
            continue;
          }
          const output = part.output;
          let outputValue;
          switch (output.type) {
            case "text":
            case "error-text":
              outputValue = output.value;
              break;
            case "execution-denied":
              outputValue = (_e = output.reason) != null ? _e : "tool execution denied";
              break;
            case "json":
            case "error-json":
              outputValue = JSON.stringify(output.value);
              break;
            case "content":
              outputValue = output.value.map((item) => {
                if (item.type === "text") {
                  return item.text;
                }
                return "";
              }).join("");
              break;
            default: {
              const _exhaustiveCheck = output;
              outputValue = "";
            }
          }
          input.push({
            type: "function_call_output",
            call_id: part.toolCallId,
            output: outputValue
          });
        }
        break;
      }
      default: {
        const _exhaustiveCheck = message;
        inputWarnings.push({
          type: "other",
          message: "unsupported message role"
        });
      }
    }
  }
  return { input, inputWarnings };
}
function convertXaiResponsesUsage(usage) {
  var _a31, _b27, _c, _d;
  const cacheReadTokens = (_b27 = (_a31 = usage.input_tokens_details) == null ? void 0 : _a31.cached_tokens) != null ? _b27 : 0;
  const reasoningTokens = (_d = (_c = usage.output_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0;
  const inputTokensIncludesCached = cacheReadTokens <= usage.input_tokens;
  return {
    inputTokens: {
      total: inputTokensIncludesCached ? usage.input_tokens : usage.input_tokens + cacheReadTokens,
      noCache: inputTokensIncludesCached ? usage.input_tokens - cacheReadTokens : usage.input_tokens,
      cacheRead: cacheReadTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: usage.output_tokens,
      text: usage.output_tokens - reasoningTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function mapXaiResponsesFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
    case "completed":
      return "stop";
    case "length":
      return "length";
    case "tool_calls":
    case "function_call":
      return "tool-calls";
    case "content_filter":
      return "content-filter";
    default:
      return "other";
  }
}
async function prepareResponsesTools2({
  tools,
  toolChoice
}) {
  const normalizedTools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  if (normalizedTools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const xaiTools2 = [];
  const toolByName = /* @__PURE__ */ new Map();
  for (const tool3 of normalizedTools) {
    toolByName.set(tool3.name, tool3);
    if (tool3.type === "provider") {
      switch (tool3.id) {
        case "xai.web_search": {
          const args = await validateTypes({
            value: tool3.args,
            schema: webSearchArgsSchema2
          });
          xaiTools2.push({
            type: "web_search",
            allowed_domains: args.allowedDomains,
            excluded_domains: args.excludedDomains,
            enable_image_understanding: args.enableImageUnderstanding
          });
          break;
        }
        case "xai.x_search": {
          const args = await validateTypes({
            value: tool3.args,
            schema: xSearchArgsSchema
          });
          xaiTools2.push({
            type: "x_search",
            allowed_x_handles: args.allowedXHandles,
            excluded_x_handles: args.excludedXHandles,
            from_date: args.fromDate,
            to_date: args.toDate,
            enable_image_understanding: args.enableImageUnderstanding,
            enable_video_understanding: args.enableVideoUnderstanding
          });
          break;
        }
        case "xai.code_execution": {
          xaiTools2.push({
            type: "code_interpreter"
          });
          break;
        }
        case "xai.view_image": {
          xaiTools2.push({
            type: "view_image"
          });
          break;
        }
        case "xai.view_x_video": {
          xaiTools2.push({
            type: "view_x_video"
          });
          break;
        }
        case "xai.file_search": {
          const args = await validateTypes({
            value: tool3.args,
            schema: fileSearchArgsSchema3
          });
          xaiTools2.push({
            type: "file_search",
            vector_store_ids: args.vectorStoreIds,
            max_num_results: args.maxNumResults
          });
          break;
        }
        case "xai.mcp": {
          const args = await validateTypes({
            value: tool3.args,
            schema: mcpServerArgsSchema
          });
          xaiTools2.push({
            type: "mcp",
            server_url: args.serverUrl,
            server_label: args.serverLabel,
            server_description: args.serverDescription,
            allowed_tools: args.allowedTools,
            headers: args.headers,
            authorization: args.authorization
          });
          break;
        }
        default: {
          toolWarnings.push({
            type: "unsupported",
            feature: `provider-defined tool ${tool3.name}`
          });
          break;
        }
      }
    } else {
      xaiTools2.push({
        type: "function",
        name: tool3.name,
        description: tool3.description,
        parameters: tool3.inputSchema,
        ...tool3.strict != null ? { strict: tool3.strict } : {}
      });
    }
  }
  if (toolChoice == null) {
    return { tools: xaiTools2, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
      return { tools: xaiTools2, toolChoice: type, toolWarnings };
    case "required":
      return { tools: xaiTools2, toolChoice: "required", toolWarnings };
    case "tool": {
      const selectedTool = toolByName.get(toolChoice.toolName);
      if (selectedTool == null) {
        return {
          tools: xaiTools2,
          toolChoice: void 0,
          toolWarnings
        };
      }
      if (selectedTool.type === "provider") {
        toolWarnings.push({
          type: "unsupported",
          feature: `toolChoice for server-side tool "${selectedTool.name}"`
        });
        return { tools: xaiTools2, toolChoice: void 0, toolWarnings };
      }
      return {
        tools: xaiTools2,
        toolChoice: { type: "function", name: selectedTool.name },
        toolWarnings
      };
    }
    default: {
      const _exhaustiveCheck = type;
      throw new UnsupportedFunctionalityError({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
function createXai(options = {}) {
  var _a31;
  const baseURL = withoutTrailingSlash(
    (_a31 = options.baseURL) != null ? _a31 : "https://api.x.ai/v1"
  );
  const getHeaders = () => withUserAgentSuffix(
    {
      Authorization: `Bearer ${loadApiKey({
        apiKey: options.apiKey,
        environmentVariableName: "XAI_API_KEY",
        description: "xAI API key"
      })}`,
      ...options.headers
    },
    `ai-sdk/xai/${VERSION10}`
  );
  const createChatLanguageModel = (modelId) => {
    return new XaiChatLanguageModel(modelId, {
      provider: "xai.chat",
      baseURL,
      headers: getHeaders,
      generateId,
      fetch: options.fetch
    });
  };
  const createResponsesLanguageModel = (modelId) => {
    return new XaiResponsesLanguageModel(modelId, {
      provider: "xai.responses",
      baseURL,
      headers: getHeaders,
      generateId,
      fetch: options.fetch
    });
  };
  const createImageModel = (modelId) => {
    return new XaiImageModel(modelId, {
      provider: "xai.image",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const createVideoModel = (modelId) => {
    return new XaiVideoModel(modelId, {
      provider: "xai.video",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const provider = (modelId) => createChatLanguageModel(modelId);
  provider.specificationVersion = "v3";
  provider.languageModel = createChatLanguageModel;
  provider.chat = createChatLanguageModel;
  provider.responses = createResponsesLanguageModel;
  provider.embeddingModel = (modelId) => {
    throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
  };
  provider.textEmbeddingModel = provider.embeddingModel;
  provider.imageModel = createImageModel;
  provider.image = createImageModel;
  provider.videoModel = createVideoModel;
  provider.video = createVideoModel;
  provider.tools = xaiTools;
  return provider;
}
var webSourceSchema, xSourceSchema, newsSourceSchema, rssSourceSchema, searchSourceSchema, xaiLanguageModelChatOptions, xaiErrorDataSchema, xaiFailedResponseHandler, XaiChatLanguageModel, xaiUsageSchema, xaiChatResponseSchema, xaiChatChunkSchema, xaiStreamErrorSchema, xaiImageModelOptions, XaiImageModel, xaiImageResponseSchema, annotationSchema, messageContentPartSchema, reasoningSummaryPartSchema, toolCallSchema, mcpCallSchema, outputItemSchema, xaiResponsesUsageSchema, xaiResponsesResponseSchema, xaiResponsesChunkSchema, xaiLanguageModelResponsesOptions, fileSearchArgsSchema3, fileSearchOutputSchema2, fileSearchToolFactory, fileSearch3, mcpServerArgsSchema, mcpServerOutputSchema, mcpServerToolFactory, mcpServer, webSearchArgsSchema2, webSearchOutputSchema2, webSearchToolFactory2, webSearch2, xSearchArgsSchema, xSearchOutputSchema, xSearchToolFactory, xSearch, XaiResponsesLanguageModel, codeExecutionOutputSchema, codeExecutionToolFactory, codeExecution2, viewImageOutputSchema, viewImageToolFactory, viewImage, viewXVideoOutputSchema, viewXVideoToolFactory, viewXVideo, xaiTools, VERSION10, xaiVideoModelOptionsSchema, RESOLUTION_MAP, XaiVideoModel, xaiCreateVideoResponseSchema, xaiVideoStatusResponseSchema, xai;
var init_dist15 = __esm({
  "node_modules/@ai-sdk/xai/dist/index.mjs"() {
    "use strict";
    init_dist3();
    init_dist5();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    init_v42();
    init_dist5();
    init_dist3();
    init_dist5();
    init_v42();
    init_v42();
    init_dist3();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    webSourceSchema = external_exports.object({
      type: external_exports.literal("web"),
      country: external_exports.string().length(2).optional(),
      excludedWebsites: external_exports.array(external_exports.string()).max(5).optional(),
      allowedWebsites: external_exports.array(external_exports.string()).max(5).optional(),
      safeSearch: external_exports.boolean().optional()
    });
    xSourceSchema = external_exports.object({
      type: external_exports.literal("x"),
      excludedXHandles: external_exports.array(external_exports.string()).optional(),
      includedXHandles: external_exports.array(external_exports.string()).optional(),
      postFavoriteCount: external_exports.number().int().optional(),
      postViewCount: external_exports.number().int().optional(),
      /**
       * @deprecated use `includedXHandles` instead
       */
      xHandles: external_exports.array(external_exports.string()).optional()
    });
    newsSourceSchema = external_exports.object({
      type: external_exports.literal("news"),
      country: external_exports.string().length(2).optional(),
      excludedWebsites: external_exports.array(external_exports.string()).max(5).optional(),
      safeSearch: external_exports.boolean().optional()
    });
    rssSourceSchema = external_exports.object({
      type: external_exports.literal("rss"),
      links: external_exports.array(external_exports.string().url()).max(1)
      // currently only supports one RSS link
    });
    searchSourceSchema = external_exports.discriminatedUnion("type", [
      webSourceSchema,
      xSourceSchema,
      newsSourceSchema,
      rssSourceSchema
    ]);
    xaiLanguageModelChatOptions = external_exports.object({
      reasoningEffort: external_exports.enum(["low", "high"]).optional(),
      logprobs: external_exports.boolean().optional(),
      topLogprobs: external_exports.number().int().min(0).max(8).optional(),
      /**
       * Whether to enable parallel function calling during tool use.
       * When true, the model can call multiple functions in parallel.
       * When false, the model will call functions sequentially.
       * Defaults to true.
       */
      parallel_function_calling: external_exports.boolean().optional(),
      searchParameters: external_exports.object({
        /**
         * search mode preference
         * - "off": disables search completely
         * - "auto": model decides whether to search (default)
         * - "on": always enables search
         */
        mode: external_exports.enum(["off", "auto", "on"]),
        /**
         * whether to return citations in the response
         * defaults to true
         */
        returnCitations: external_exports.boolean().optional(),
        /**
         * start date for search data (ISO8601 format: YYYY-MM-DD)
         */
        fromDate: external_exports.string().optional(),
        /**
         * end date for search data (ISO8601 format: YYYY-MM-DD)
         */
        toDate: external_exports.string().optional(),
        /**
         * maximum number of search results to consider
         * defaults to 20
         */
        maxSearchResults: external_exports.number().min(1).max(50).optional(),
        /**
         * data sources to search from.
         * defaults to [{ type: 'web' }, { type: 'x' }] if not specified.
         *
         * @example
         * sources: [{ type: 'web', country: 'US' }, { type: 'x' }]
         */
        sources: external_exports.array(searchSourceSchema).optional()
      }).optional()
    });
    xaiErrorDataSchema = external_exports.object({
      error: external_exports.object({
        message: external_exports.string(),
        type: external_exports.string().nullish(),
        param: external_exports.any().nullish(),
        code: external_exports.union([external_exports.string(), external_exports.number()]).nullish()
      })
    });
    xaiFailedResponseHandler = createJsonErrorResponseHandler({
      errorSchema: xaiErrorDataSchema,
      errorToMessage: (data) => data.error.message
    });
    XaiChatLanguageModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.supportedUrls = {
          "image/*": [/^https?:\/\/.*$/]
        };
        this.modelId = modelId;
        this.config = config3;
      }
      get provider() {
        return this.config.provider;
      }
      async getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        stopSequences,
        seed,
        responseFormat,
        providerOptions,
        tools,
        toolChoice
      }) {
        var _a31, _b27, _c;
        const warnings = [];
        const options = (_a31 = await parseProviderOptions({
          provider: "xai",
          providerOptions,
          schema: xaiLanguageModelChatOptions
        })) != null ? _a31 : {};
        if (topK != null) {
          warnings.push({ type: "unsupported", feature: "topK" });
        }
        if (frequencyPenalty != null) {
          warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
        }
        if (presencePenalty != null) {
          warnings.push({ type: "unsupported", feature: "presencePenalty" });
        }
        if (stopSequences != null) {
          warnings.push({ type: "unsupported", feature: "stopSequences" });
        }
        const { messages, warnings: messageWarnings } = convertToXaiChatMessages(prompt);
        warnings.push(...messageWarnings);
        const {
          tools: xaiTools2,
          toolChoice: xaiToolChoice,
          toolWarnings
        } = prepareTools5({
          tools,
          toolChoice
        });
        warnings.push(...toolWarnings);
        const baseArgs = {
          // model id
          model: this.modelId,
          // standard generation settings
          logprobs: options.logprobs === true || options.topLogprobs != null ? true : void 0,
          top_logprobs: options.topLogprobs,
          max_completion_tokens: maxOutputTokens,
          temperature,
          top_p: topP,
          seed,
          reasoning_effort: options.reasoningEffort,
          // parallel function calling
          parallel_function_calling: options.parallel_function_calling,
          // response format
          response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
            type: "json_schema",
            json_schema: {
              name: (_b27 = responseFormat.name) != null ? _b27 : "response",
              schema: responseFormat.schema,
              strict: true
            }
          } : { type: "json_object" } : void 0,
          // search parameters
          search_parameters: options.searchParameters ? {
            mode: options.searchParameters.mode,
            return_citations: options.searchParameters.returnCitations,
            from_date: options.searchParameters.fromDate,
            to_date: options.searchParameters.toDate,
            max_search_results: options.searchParameters.maxSearchResults,
            sources: (_c = options.searchParameters.sources) == null ? void 0 : _c.map((source) => {
              var _a211;
              return {
                type: source.type,
                ...source.type === "web" && {
                  country: source.country,
                  excluded_websites: source.excludedWebsites,
                  allowed_websites: source.allowedWebsites,
                  safe_search: source.safeSearch
                },
                ...source.type === "x" && {
                  excluded_x_handles: source.excludedXHandles,
                  included_x_handles: (_a211 = source.includedXHandles) != null ? _a211 : source.xHandles,
                  post_favorite_count: source.postFavoriteCount,
                  post_view_count: source.postViewCount
                },
                ...source.type === "news" && {
                  country: source.country,
                  excluded_websites: source.excludedWebsites,
                  safe_search: source.safeSearch
                },
                ...source.type === "rss" && {
                  links: source.links
                }
              };
            })
          } : void 0,
          // messages in xai format
          messages,
          // tools in xai format
          tools: xaiTools2,
          tool_choice: xaiToolChoice
        };
        return {
          args: baseArgs,
          warnings
        };
      }
      async doGenerate(options) {
        var _a31, _b27;
        const { args: body, warnings } = await this.getArgs(options);
        const url4 = `${(_a31 = this.config.baseURL) != null ? _a31 : "https://api.x.ai/v1"}/chat/completions`;
        const {
          responseHeaders,
          value: response,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: url4,
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: xaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            xaiChatResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        if (response.error != null) {
          throw new APICallError({
            message: response.error,
            url: url4,
            requestBodyValues: body,
            statusCode: 200,
            responseHeaders,
            responseBody: JSON.stringify(rawResponse),
            isRetryable: response.code === "The service is currently unavailable"
          });
        }
        const choice2 = response.choices[0];
        const content = [];
        if (choice2.message.content != null && choice2.message.content.length > 0) {
          let text2 = choice2.message.content;
          const lastMessage = body.messages[body.messages.length - 1];
          if ((lastMessage == null ? void 0 : lastMessage.role) === "assistant" && text2 === lastMessage.content) {
            text2 = "";
          }
          if (text2.length > 0) {
            content.push({ type: "text", text: text2 });
          }
        }
        if (choice2.message.reasoning_content != null && choice2.message.reasoning_content.length > 0) {
          content.push({
            type: "reasoning",
            text: choice2.message.reasoning_content
          });
        }
        if (choice2.message.tool_calls != null) {
          for (const toolCall of choice2.message.tool_calls) {
            content.push({
              type: "tool-call",
              toolCallId: toolCall.id,
              toolName: toolCall.function.name,
              input: toolCall.function.arguments
            });
          }
        }
        if (response.citations != null) {
          for (const url22 of response.citations) {
            content.push({
              type: "source",
              sourceType: "url",
              id: this.config.generateId(),
              url: url22
            });
          }
        }
        return {
          content,
          finishReason: {
            unified: mapXaiFinishReason(choice2.finish_reason),
            raw: (_b27 = choice2.finish_reason) != null ? _b27 : void 0
          },
          usage: response.usage ? convertXaiChatUsage(response.usage) : {
            inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
            outputTokens: { total: 0, text: 0, reasoning: 0 }
          },
          request: { body },
          response: {
            ...getResponseMetadata6(response),
            headers: responseHeaders,
            body: rawResponse
          },
          warnings
        };
      }
      async doStream(options) {
        var _a31;
        const { args, warnings } = await this.getArgs(options);
        const body = {
          ...args,
          stream: true,
          stream_options: {
            include_usage: true
          }
        };
        const url4 = `${(_a31 = this.config.baseURL) != null ? _a31 : "https://api.x.ai/v1"}/chat/completions`;
        const { responseHeaders, value: response } = await postJsonToApi({
          url: url4,
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: xaiFailedResponseHandler,
          successfulResponseHandler: async ({ response: response2 }) => {
            const responseHeaders2 = extractResponseHeaders(response2);
            const contentType = response2.headers.get("content-type");
            if (contentType == null ? void 0 : contentType.includes("application/json")) {
              const responseBody = await response2.text();
              const parsedError = await safeParseJSON({
                text: responseBody,
                schema: xaiStreamErrorSchema
              });
              if (parsedError.success) {
                throw new APICallError({
                  message: parsedError.value.error,
                  url: url4,
                  requestBodyValues: body,
                  statusCode: 200,
                  responseHeaders: responseHeaders2,
                  responseBody,
                  isRetryable: parsedError.value.code === "The service is currently unavailable"
                });
              }
              throw new APICallError({
                message: "Invalid JSON response",
                url: url4,
                requestBodyValues: body,
                statusCode: 200,
                responseHeaders: responseHeaders2,
                responseBody
              });
            }
            return createEventSourceResponseHandler(xaiChatChunkSchema)({
              response: response2,
              url: url4,
              requestBodyValues: body
            });
          },
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        let usage = void 0;
        let isFirstChunk = true;
        const contentBlocks = {};
        const lastReasoningDeltas = {};
        let activeReasoningBlockId = void 0;
        const self2 = this;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const value = chunk.value;
                if (isFirstChunk) {
                  controller.enqueue({
                    type: "response-metadata",
                    ...getResponseMetadata6(value)
                  });
                  isFirstChunk = false;
                }
                if (value.citations != null) {
                  for (const url22 of value.citations) {
                    controller.enqueue({
                      type: "source",
                      sourceType: "url",
                      id: self2.config.generateId(),
                      url: url22
                    });
                  }
                }
                if (value.usage != null) {
                  usage = convertXaiChatUsage(value.usage);
                }
                const choice2 = value.choices[0];
                if ((choice2 == null ? void 0 : choice2.finish_reason) != null) {
                  finishReason = {
                    unified: mapXaiFinishReason(choice2.finish_reason),
                    raw: choice2.finish_reason
                  };
                }
                if ((choice2 == null ? void 0 : choice2.delta) == null) {
                  return;
                }
                const delta = choice2.delta;
                const choiceIndex = choice2.index;
                if (delta.content != null && delta.content.length > 0) {
                  const textContent = delta.content;
                  if (activeReasoningBlockId != null && !contentBlocks[activeReasoningBlockId].ended) {
                    controller.enqueue({
                      type: "reasoning-end",
                      id: activeReasoningBlockId
                    });
                    contentBlocks[activeReasoningBlockId].ended = true;
                    activeReasoningBlockId = void 0;
                  }
                  const lastMessage = body.messages[body.messages.length - 1];
                  if ((lastMessage == null ? void 0 : lastMessage.role) === "assistant" && textContent === lastMessage.content) {
                    return;
                  }
                  const blockId = `text-${value.id || choiceIndex}`;
                  if (contentBlocks[blockId] == null) {
                    contentBlocks[blockId] = { type: "text", ended: false };
                    controller.enqueue({
                      type: "text-start",
                      id: blockId
                    });
                  }
                  controller.enqueue({
                    type: "text-delta",
                    id: blockId,
                    delta: textContent
                  });
                }
                if (delta.reasoning_content != null && delta.reasoning_content.length > 0) {
                  const blockId = `reasoning-${value.id || choiceIndex}`;
                  if (lastReasoningDeltas[blockId] === delta.reasoning_content) {
                    return;
                  }
                  lastReasoningDeltas[blockId] = delta.reasoning_content;
                  if (contentBlocks[blockId] == null) {
                    contentBlocks[blockId] = { type: "reasoning", ended: false };
                    activeReasoningBlockId = blockId;
                    controller.enqueue({
                      type: "reasoning-start",
                      id: blockId
                    });
                  }
                  controller.enqueue({
                    type: "reasoning-delta",
                    id: blockId,
                    delta: delta.reasoning_content
                  });
                }
                if (delta.tool_calls != null) {
                  if (activeReasoningBlockId != null && !contentBlocks[activeReasoningBlockId].ended) {
                    controller.enqueue({
                      type: "reasoning-end",
                      id: activeReasoningBlockId
                    });
                    contentBlocks[activeReasoningBlockId].ended = true;
                    activeReasoningBlockId = void 0;
                  }
                  for (const toolCall of delta.tool_calls) {
                    const toolCallId = toolCall.id;
                    controller.enqueue({
                      type: "tool-input-start",
                      id: toolCallId,
                      toolName: toolCall.function.name
                    });
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCallId,
                      delta: toolCall.function.arguments
                    });
                    controller.enqueue({
                      type: "tool-input-end",
                      id: toolCallId
                    });
                    controller.enqueue({
                      type: "tool-call",
                      toolCallId,
                      toolName: toolCall.function.name,
                      input: toolCall.function.arguments
                    });
                  }
                }
              },
              flush(controller) {
                for (const [blockId, block] of Object.entries(contentBlocks)) {
                  if (!block.ended) {
                    controller.enqueue({
                      type: block.type === "text" ? "text-end" : "reasoning-end",
                      id: blockId
                    });
                  }
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage: usage != null ? usage : {
                    inputTokens: {
                      total: 0,
                      noCache: 0,
                      cacheRead: 0,
                      cacheWrite: 0
                    },
                    outputTokens: { total: 0, text: 0, reasoning: 0 }
                  }
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    xaiUsageSchema = external_exports.object({
      prompt_tokens: external_exports.number(),
      completion_tokens: external_exports.number(),
      total_tokens: external_exports.number(),
      prompt_tokens_details: external_exports.object({
        text_tokens: external_exports.number().nullish(),
        audio_tokens: external_exports.number().nullish(),
        image_tokens: external_exports.number().nullish(),
        cached_tokens: external_exports.number().nullish()
      }).nullish(),
      completion_tokens_details: external_exports.object({
        reasoning_tokens: external_exports.number().nullish(),
        audio_tokens: external_exports.number().nullish(),
        accepted_prediction_tokens: external_exports.number().nullish(),
        rejected_prediction_tokens: external_exports.number().nullish()
      }).nullish()
    });
    xaiChatResponseSchema = external_exports.object({
      id: external_exports.string().nullish(),
      created: external_exports.number().nullish(),
      model: external_exports.string().nullish(),
      choices: external_exports.array(
        external_exports.object({
          message: external_exports.object({
            role: external_exports.literal("assistant"),
            content: external_exports.string().nullish(),
            reasoning_content: external_exports.string().nullish(),
            tool_calls: external_exports.array(
              external_exports.object({
                id: external_exports.string(),
                type: external_exports.literal("function"),
                function: external_exports.object({
                  name: external_exports.string(),
                  arguments: external_exports.string()
                })
              })
            ).nullish()
          }),
          index: external_exports.number(),
          finish_reason: external_exports.string().nullish()
        })
      ).nullish(),
      object: external_exports.literal("chat.completion").nullish(),
      usage: xaiUsageSchema.nullish(),
      citations: external_exports.array(external_exports.string().url()).nullish(),
      code: external_exports.string().nullish(),
      error: external_exports.string().nullish()
    });
    xaiChatChunkSchema = external_exports.object({
      id: external_exports.string().nullish(),
      created: external_exports.number().nullish(),
      model: external_exports.string().nullish(),
      choices: external_exports.array(
        external_exports.object({
          delta: external_exports.object({
            role: external_exports.enum(["assistant"]).optional(),
            content: external_exports.string().nullish(),
            reasoning_content: external_exports.string().nullish(),
            tool_calls: external_exports.array(
              external_exports.object({
                id: external_exports.string(),
                type: external_exports.literal("function"),
                function: external_exports.object({
                  name: external_exports.string(),
                  arguments: external_exports.string()
                })
              })
            ).nullish()
          }),
          finish_reason: external_exports.string().nullish(),
          index: external_exports.number()
        })
      ),
      usage: xaiUsageSchema.nullish(),
      citations: external_exports.array(external_exports.string().url()).nullish()
    });
    xaiStreamErrorSchema = external_exports.object({
      code: external_exports.string(),
      error: external_exports.string()
    });
    xaiImageModelOptions = external_exports.object({
      aspect_ratio: external_exports.string().optional(),
      output_format: external_exports.string().optional(),
      sync_mode: external_exports.boolean().optional(),
      resolution: external_exports.enum(["1k", "2k"]).optional(),
      quality: external_exports.enum(["low", "medium", "high"]).optional(),
      user: external_exports.string().optional()
    });
    XaiImageModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
        this.maxImagesPerCall = 3;
      }
      get provider() {
        return this.config.provider;
      }
      async doGenerate({
        prompt,
        n,
        size,
        aspectRatio,
        seed,
        providerOptions,
        headers,
        abortSignal,
        files,
        mask
      }) {
        var _a31, _b27, _c, _d, _e;
        const warnings = [];
        if (size != null) {
          warnings.push({
            type: "unsupported",
            feature: "size",
            details: "This model does not support the `size` option. Use `aspectRatio` instead."
          });
        }
        if (seed != null) {
          warnings.push({
            type: "unsupported",
            feature: "seed"
          });
        }
        if (mask != null) {
          warnings.push({
            type: "unsupported",
            feature: "mask"
          });
        }
        const xaiOptions = await parseProviderOptions({
          provider: "xai",
          providerOptions,
          schema: xaiImageModelOptions
        });
        const hasFiles = files != null && files.length > 0;
        const imageUrls = hasFiles ? files.map((file3) => convertImageModelFileToDataUri(file3)) : [];
        const endpoint2 = hasFiles ? "/images/edits" : "/images/generations";
        const body = {
          model: this.modelId,
          prompt,
          n,
          response_format: "b64_json"
        };
        if (aspectRatio != null) {
          body.aspect_ratio = aspectRatio;
        }
        if ((xaiOptions == null ? void 0 : xaiOptions.output_format) != null) {
          body.output_format = xaiOptions.output_format;
        }
        if ((xaiOptions == null ? void 0 : xaiOptions.sync_mode) != null) {
          body.sync_mode = xaiOptions.sync_mode;
        }
        if ((xaiOptions == null ? void 0 : xaiOptions.aspect_ratio) != null && aspectRatio == null) {
          body.aspect_ratio = xaiOptions.aspect_ratio;
        }
        if ((xaiOptions == null ? void 0 : xaiOptions.resolution) != null) {
          body.resolution = xaiOptions.resolution;
        }
        if ((xaiOptions == null ? void 0 : xaiOptions.quality) != null) {
          body.quality = xaiOptions.quality;
        }
        if ((xaiOptions == null ? void 0 : xaiOptions.user) != null) {
          body.user = xaiOptions.user;
        }
        if (imageUrls.length === 1) {
          body.image = { url: imageUrls[0], type: "image_url" };
        } else if (imageUrls.length > 1) {
          body.images = imageUrls.map((url4) => ({ url: url4, type: "image_url" }));
        }
        const baseURL = (_a31 = this.config.baseURL) != null ? _a31 : "https://api.x.ai/v1";
        const currentDate = (_d = (_c = (_b27 = this.config._internal) == null ? void 0 : _b27.currentDate) == null ? void 0 : _c.call(_b27)) != null ? _d : /* @__PURE__ */ new Date();
        const { value: response, responseHeaders } = await postJsonToApi({
          url: `${baseURL}${endpoint2}`,
          headers: combineHeaders(this.config.headers(), headers),
          body,
          failedResponseHandler: xaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            xaiImageResponseSchema
          ),
          abortSignal,
          fetch: this.config.fetch
        });
        const hasAllBase64 = response.data.every((image) => image.b64_json != null);
        const images = hasAllBase64 ? response.data.map((image) => image.b64_json) : await Promise.all(
          response.data.map(
            (image) => this.downloadImage(image.url, abortSignal)
          )
        );
        return {
          images,
          warnings,
          response: {
            timestamp: currentDate,
            modelId: this.modelId,
            headers: responseHeaders
          },
          providerMetadata: {
            xai: {
              images: response.data.map((item) => ({
                ...item.revised_prompt ? { revisedPrompt: item.revised_prompt } : {}
              })),
              ...((_e = response.usage) == null ? void 0 : _e.cost_in_usd_ticks) != null ? { costInUsdTicks: response.usage.cost_in_usd_ticks } : {}
            }
          }
        };
      }
      async downloadImage(url4, abortSignal) {
        const { value } = await getFromApi({
          url: url4,
          abortSignal,
          failedResponseHandler: createStatusCodeErrorResponseHandler(),
          successfulResponseHandler: createBinaryResponseHandler(),
          fetch: this.config.fetch
        });
        return value;
      }
    };
    xaiImageResponseSchema = external_exports.object({
      data: external_exports.array(
        external_exports.object({
          url: external_exports.string().nullish(),
          b64_json: external_exports.string().nullish(),
          revised_prompt: external_exports.string().nullish()
        })
      ),
      usage: external_exports.object({
        cost_in_usd_ticks: external_exports.number().nullish()
      }).nullish()
    });
    annotationSchema = external_exports.union([
      external_exports.object({
        type: external_exports.literal("url_citation"),
        url: external_exports.string(),
        title: external_exports.string().optional()
      }),
      external_exports.object({
        type: external_exports.string()
      })
    ]);
    messageContentPartSchema = external_exports.object({
      type: external_exports.string(),
      text: external_exports.string().optional(),
      logprobs: external_exports.array(external_exports.any()).optional(),
      annotations: external_exports.array(annotationSchema).optional()
    });
    reasoningSummaryPartSchema = external_exports.object({
      type: external_exports.string(),
      text: external_exports.string()
    });
    toolCallSchema = external_exports.object({
      name: external_exports.string().optional(),
      arguments: external_exports.string().optional(),
      input: external_exports.string().optional(),
      call_id: external_exports.string().optional(),
      id: external_exports.string(),
      status: external_exports.string(),
      action: external_exports.any().optional()
    });
    mcpCallSchema = external_exports.object({
      name: external_exports.string().optional(),
      arguments: external_exports.string().optional(),
      output: external_exports.string().optional(),
      error: external_exports.string().optional(),
      id: external_exports.string(),
      status: external_exports.string(),
      server_label: external_exports.string().optional()
    });
    outputItemSchema = external_exports.discriminatedUnion("type", [
      external_exports.object({
        type: external_exports.literal("web_search_call"),
        ...toolCallSchema.shape
      }),
      external_exports.object({
        type: external_exports.literal("x_search_call"),
        ...toolCallSchema.shape
      }),
      external_exports.object({
        type: external_exports.literal("code_interpreter_call"),
        ...toolCallSchema.shape
      }),
      external_exports.object({
        type: external_exports.literal("code_execution_call"),
        ...toolCallSchema.shape
      }),
      external_exports.object({
        type: external_exports.literal("view_image_call"),
        ...toolCallSchema.shape
      }),
      external_exports.object({
        type: external_exports.literal("view_x_video_call"),
        ...toolCallSchema.shape
      }),
      external_exports.object({
        type: external_exports.literal("file_search_call"),
        id: external_exports.string(),
        status: external_exports.string(),
        queries: external_exports.array(external_exports.string()).optional(),
        results: external_exports.array(
          external_exports.object({
            file_id: external_exports.string(),
            filename: external_exports.string(),
            score: external_exports.number(),
            text: external_exports.string()
          })
        ).nullish()
      }),
      external_exports.object({
        type: external_exports.literal("custom_tool_call"),
        ...toolCallSchema.shape
      }),
      external_exports.object({
        type: external_exports.literal("mcp_call"),
        ...mcpCallSchema.shape
      }),
      external_exports.object({
        type: external_exports.literal("message"),
        role: external_exports.string(),
        content: external_exports.array(messageContentPartSchema),
        id: external_exports.string(),
        status: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("function_call"),
        name: external_exports.string(),
        arguments: external_exports.string(),
        call_id: external_exports.string(),
        id: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("reasoning"),
        id: external_exports.string(),
        summary: external_exports.array(reasoningSummaryPartSchema),
        status: external_exports.string(),
        encrypted_content: external_exports.string().nullish()
      })
    ]);
    xaiResponsesUsageSchema = external_exports.object({
      input_tokens: external_exports.number(),
      output_tokens: external_exports.number(),
      total_tokens: external_exports.number().optional(),
      input_tokens_details: external_exports.object({
        cached_tokens: external_exports.number().optional()
      }).optional(),
      output_tokens_details: external_exports.object({
        reasoning_tokens: external_exports.number().optional()
      }).optional(),
      num_sources_used: external_exports.number().optional(),
      num_server_side_tools_used: external_exports.number().optional()
    });
    xaiResponsesResponseSchema = external_exports.object({
      id: external_exports.string().nullish(),
      created_at: external_exports.number().nullish(),
      model: external_exports.string().nullish(),
      object: external_exports.literal("response"),
      output: external_exports.array(outputItemSchema),
      usage: xaiResponsesUsageSchema.nullish(),
      status: external_exports.string()
    });
    xaiResponsesChunkSchema = external_exports.union([
      external_exports.object({
        type: external_exports.literal("response.created"),
        response: xaiResponsesResponseSchema.partial({ usage: true, status: true })
      }),
      external_exports.object({
        type: external_exports.literal("response.in_progress"),
        response: xaiResponsesResponseSchema.partial({ usage: true, status: true })
      }),
      external_exports.object({
        type: external_exports.literal("response.output_item.added"),
        item: outputItemSchema,
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.output_item.done"),
        item: outputItemSchema,
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.content_part.added"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        content_index: external_exports.number(),
        part: messageContentPartSchema
      }),
      external_exports.object({
        type: external_exports.literal("response.content_part.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        content_index: external_exports.number(),
        part: messageContentPartSchema
      }),
      external_exports.object({
        type: external_exports.literal("response.output_text.delta"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        content_index: external_exports.number(),
        delta: external_exports.string(),
        logprobs: external_exports.array(external_exports.any()).optional()
      }),
      external_exports.object({
        type: external_exports.literal("response.output_text.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        content_index: external_exports.number(),
        text: external_exports.string(),
        logprobs: external_exports.array(external_exports.any()).optional(),
        annotations: external_exports.array(annotationSchema).optional()
      }),
      external_exports.object({
        type: external_exports.literal("response.output_text.annotation.added"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        content_index: external_exports.number(),
        annotation_index: external_exports.number(),
        annotation: annotationSchema
      }),
      external_exports.object({
        type: external_exports.literal("response.reasoning_summary_part.added"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        summary_index: external_exports.number(),
        part: reasoningSummaryPartSchema
      }),
      external_exports.object({
        type: external_exports.literal("response.reasoning_summary_part.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        summary_index: external_exports.number(),
        part: reasoningSummaryPartSchema
      }),
      external_exports.object({
        type: external_exports.literal("response.reasoning_summary_text.delta"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        summary_index: external_exports.number(),
        delta: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.reasoning_summary_text.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        summary_index: external_exports.number(),
        text: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.reasoning_text.delta"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        content_index: external_exports.number(),
        delta: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.reasoning_text.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        content_index: external_exports.number(),
        text: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.web_search_call.in_progress"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.web_search_call.searching"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.web_search_call.completed"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.x_search_call.in_progress"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.x_search_call.searching"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.x_search_call.completed"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.file_search_call.in_progress"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.file_search_call.searching"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.file_search_call.completed"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.code_execution_call.in_progress"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.code_execution_call.executing"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.code_execution_call.completed"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.code_interpreter_call.in_progress"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.code_interpreter_call.executing"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.code_interpreter_call.interpreting"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.code_interpreter_call.completed"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      // Code interpreter code streaming events
      external_exports.object({
        type: external_exports.literal("response.code_interpreter_call_code.delta"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        delta: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.code_interpreter_call_code.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        code: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.custom_tool_call_input.delta"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        delta: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.custom_tool_call_input.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        input: external_exports.string()
      }),
      // Function call arguments streaming events (standard function tools)
      external_exports.object({
        type: external_exports.literal("response.function_call_arguments.delta"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        delta: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.function_call_arguments.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        arguments: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.mcp_call.in_progress"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.mcp_call.executing"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.mcp_call.completed"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.mcp_call.failed"),
        item_id: external_exports.string(),
        output_index: external_exports.number()
      }),
      external_exports.object({
        type: external_exports.literal("response.mcp_call_arguments.delta"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        delta: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.mcp_call_arguments.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        arguments: external_exports.string().optional()
      }),
      external_exports.object({
        type: external_exports.literal("response.mcp_call_output.delta"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        delta: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("response.mcp_call_output.done"),
        item_id: external_exports.string(),
        output_index: external_exports.number(),
        output: external_exports.string().optional()
      }),
      external_exports.object({
        type: external_exports.literal("response.done"),
        response: xaiResponsesResponseSchema
      }),
      external_exports.object({
        type: external_exports.literal("response.completed"),
        response: xaiResponsesResponseSchema
      })
    ]);
    xaiLanguageModelResponsesOptions = external_exports.object({
      /**
       * Constrains how hard a reasoning model thinks before responding.
       * Possible values are `low` (uses fewer reasoning tokens), `medium` and `high` (uses more reasoning tokens).
       */
      reasoningEffort: external_exports.enum(["low", "medium", "high"]).optional(),
      logprobs: external_exports.boolean().optional(),
      topLogprobs: external_exports.number().int().min(0).max(8).optional(),
      /**
       * Whether to store the input message(s) and model response for later retrieval.
       * @default true
       */
      store: external_exports.boolean().optional(),
      /**
       * The ID of the previous response from the model.
       */
      previousResponseId: external_exports.string().optional(),
      /**
       * Specify additional output data to include in the model response.
       * Example values: 'file_search_call.results'.
       */
      include: external_exports.array(external_exports.enum(["file_search_call.results"])).nullish()
    });
    fileSearchArgsSchema3 = lazySchema(
      () => zodSchema(
        external_exports.object({
          vectorStoreIds: external_exports.array(external_exports.string()),
          maxNumResults: external_exports.number().optional()
        })
      )
    );
    fileSearchOutputSchema2 = lazySchema(
      () => zodSchema(
        external_exports.object({
          queries: external_exports.array(external_exports.string()),
          results: external_exports.array(
            external_exports.object({
              fileId: external_exports.string(),
              filename: external_exports.string(),
              score: external_exports.number().min(0).max(1),
              text: external_exports.string()
            })
          ).nullable()
        })
      )
    );
    fileSearchToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "xai.file_search",
      inputSchema: lazySchema(() => zodSchema(external_exports.object({}))),
      outputSchema: fileSearchOutputSchema2
    });
    fileSearch3 = (args) => fileSearchToolFactory(args);
    mcpServerArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          serverUrl: external_exports.string().describe("The URL of the MCP server"),
          serverLabel: external_exports.string().optional().describe("A label for the MCP server"),
          serverDescription: external_exports.string().optional().describe("Description of the MCP server"),
          allowedTools: external_exports.array(external_exports.string()).optional().describe("List of allowed tool names"),
          headers: external_exports.record(external_exports.string(), external_exports.string()).optional().describe("Custom headers to send"),
          authorization: external_exports.string().optional().describe("Authorization header value")
        })
      )
    );
    mcpServerOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          name: external_exports.string(),
          arguments: external_exports.string(),
          result: external_exports.unknown()
        })
      )
    );
    mcpServerToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "xai.mcp",
      inputSchema: lazySchema(() => zodSchema(external_exports.object({}))),
      outputSchema: mcpServerOutputSchema
    });
    mcpServer = (args) => mcpServerToolFactory(args);
    webSearchArgsSchema2 = lazySchema(
      () => zodSchema(
        external_exports.object({
          allowedDomains: external_exports.array(external_exports.string()).max(5).optional(),
          excludedDomains: external_exports.array(external_exports.string()).max(5).optional(),
          enableImageUnderstanding: external_exports.boolean().optional()
        })
      )
    );
    webSearchOutputSchema2 = lazySchema(
      () => zodSchema(
        external_exports.object({
          query: external_exports.string(),
          sources: external_exports.array(
            external_exports.object({
              title: external_exports.string(),
              url: external_exports.string(),
              snippet: external_exports.string()
            })
          )
        })
      )
    );
    webSearchToolFactory2 = createProviderToolFactoryWithOutputSchema({
      id: "xai.web_search",
      inputSchema: lazySchema(() => zodSchema(external_exports.object({}))),
      outputSchema: webSearchOutputSchema2
    });
    webSearch2 = (args = {}) => webSearchToolFactory2(args);
    xSearchArgsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          allowedXHandles: external_exports.array(external_exports.string()).max(10).optional(),
          excludedXHandles: external_exports.array(external_exports.string()).max(10).optional(),
          fromDate: external_exports.string().optional(),
          toDate: external_exports.string().optional(),
          enableImageUnderstanding: external_exports.boolean().optional(),
          enableVideoUnderstanding: external_exports.boolean().optional()
        })
      )
    );
    xSearchOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          query: external_exports.string(),
          posts: external_exports.array(
            external_exports.object({
              author: external_exports.string(),
              text: external_exports.string(),
              url: external_exports.string(),
              likes: external_exports.number()
            })
          )
        })
      )
    );
    xSearchToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "xai.x_search",
      inputSchema: lazySchema(() => zodSchema(external_exports.object({}))),
      outputSchema: xSearchOutputSchema
    });
    xSearch = (args = {}) => xSearchToolFactory(args);
    XaiResponsesLanguageModel = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.supportedUrls = {
          "image/*": [/^https?:\/\/.*$/]
        };
        this.modelId = modelId;
        this.config = config3;
      }
      get provider() {
        return this.config.provider;
      }
      async getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        stopSequences,
        seed,
        responseFormat,
        providerOptions,
        tools,
        toolChoice
      }) {
        var _a31, _b27, _c, _d, _e, _f, _g;
        const warnings = [];
        const options = (_a31 = await parseProviderOptions({
          provider: "xai",
          providerOptions,
          schema: xaiLanguageModelResponsesOptions
        })) != null ? _a31 : {};
        if (stopSequences != null) {
          warnings.push({ type: "unsupported", feature: "stopSequences" });
        }
        const webSearchToolName = (_b27 = tools == null ? void 0 : tools.find(
          (tool3) => tool3.type === "provider" && tool3.id === "xai.web_search"
        )) == null ? void 0 : _b27.name;
        const xSearchToolName = (_c = tools == null ? void 0 : tools.find(
          (tool3) => tool3.type === "provider" && tool3.id === "xai.x_search"
        )) == null ? void 0 : _c.name;
        const codeExecutionToolName = (_d = tools == null ? void 0 : tools.find(
          (tool3) => tool3.type === "provider" && tool3.id === "xai.code_execution"
        )) == null ? void 0 : _d.name;
        const mcpToolName = (_e = tools == null ? void 0 : tools.find(
          (tool3) => tool3.type === "provider" && tool3.id === "xai.mcp"
        )) == null ? void 0 : _e.name;
        const fileSearchToolName = (_f = tools == null ? void 0 : tools.find(
          (tool3) => tool3.type === "provider" && tool3.id === "xai.file_search"
        )) == null ? void 0 : _f.name;
        const { input, inputWarnings } = await convertToXaiResponsesInput({
          prompt,
          store: true
        });
        warnings.push(...inputWarnings);
        const {
          tools: xaiTools2,
          toolChoice: xaiToolChoice,
          toolWarnings
        } = await prepareResponsesTools2({
          tools,
          toolChoice
        });
        warnings.push(...toolWarnings);
        let include = options.include ? [...options.include] : void 0;
        if (options.store === false) {
          if (include == null) {
            include = ["reasoning.encrypted_content"];
          } else {
            include = [...include, "reasoning.encrypted_content"];
          }
        }
        const baseArgs = {
          model: this.modelId,
          input,
          logprobs: options.logprobs === true || options.topLogprobs != null ? true : void 0,
          top_logprobs: options.topLogprobs,
          max_output_tokens: maxOutputTokens,
          temperature,
          top_p: topP,
          seed,
          ...(responseFormat == null ? void 0 : responseFormat.type) === "json" && {
            text: {
              format: responseFormat.schema != null ? {
                type: "json_schema",
                strict: true,
                name: (_g = responseFormat.name) != null ? _g : "response",
                description: responseFormat.description,
                schema: responseFormat.schema
              } : { type: "json_object" }
            }
          },
          ...options.reasoningEffort != null && {
            reasoning: { effort: options.reasoningEffort }
          },
          ...options.store === false && {
            store: options.store
          },
          ...include != null && {
            include
          },
          ...options.previousResponseId != null && {
            previous_response_id: options.previousResponseId
          }
        };
        if (xaiTools2 && xaiTools2.length > 0) {
          baseArgs.tools = xaiTools2;
        }
        if (xaiToolChoice != null) {
          baseArgs.tool_choice = xaiToolChoice;
        }
        return {
          args: baseArgs,
          warnings,
          webSearchToolName,
          xSearchToolName,
          codeExecutionToolName,
          mcpToolName,
          fileSearchToolName
        };
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
        const {
          args: body,
          warnings,
          webSearchToolName,
          xSearchToolName,
          codeExecutionToolName,
          mcpToolName,
          fileSearchToolName
        } = await this.getArgs(options);
        const {
          responseHeaders,
          value: response,
          rawValue: rawResponse
        } = await postJsonToApi({
          url: `${(_a31 = this.config.baseURL) != null ? _a31 : "https://api.x.ai/v1"}/responses`,
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: xaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            xaiResponsesResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const content = [];
        let hasFunctionCall = false;
        const webSearchSubTools = [
          "web_search",
          "web_search_with_snippets",
          "browse_page"
        ];
        const xSearchSubTools = [
          "x_user_search",
          "x_keyword_search",
          "x_semantic_search",
          "x_thread_fetch"
        ];
        for (const part of response.output) {
          if (part.type === "file_search_call") {
            const toolName = fileSearchToolName != null ? fileSearchToolName : "file_search";
            content.push({
              type: "tool-call",
              toolCallId: part.id,
              toolName,
              input: "",
              providerExecuted: true
            });
            content.push({
              type: "tool-result",
              toolCallId: part.id,
              toolName,
              result: {
                queries: (_b27 = part.queries) != null ? _b27 : [],
                results: (_d = (_c = part.results) == null ? void 0 : _c.map((result) => ({
                  fileId: result.file_id,
                  filename: result.filename,
                  score: result.score,
                  text: result.text
                }))) != null ? _d : null
              }
            });
            continue;
          }
          if (part.type === "web_search_call" || part.type === "x_search_call" || part.type === "code_interpreter_call" || part.type === "code_execution_call" || part.type === "view_image_call" || part.type === "view_x_video_call" || part.type === "custom_tool_call" || part.type === "mcp_call") {
            let toolName = (_e = part.name) != null ? _e : "";
            if (webSearchSubTools.includes((_f = part.name) != null ? _f : "") || part.type === "web_search_call") {
              toolName = webSearchToolName != null ? webSearchToolName : "web_search";
            } else if (xSearchSubTools.includes((_g = part.name) != null ? _g : "") || part.type === "x_search_call") {
              toolName = xSearchToolName != null ? xSearchToolName : "x_search";
            } else if (part.name === "code_execution" || part.type === "code_interpreter_call" || part.type === "code_execution_call") {
              toolName = codeExecutionToolName != null ? codeExecutionToolName : "code_execution";
            } else if (part.type === "mcp_call") {
              toolName = (_h = mcpToolName != null ? mcpToolName : part.name) != null ? _h : "mcp";
            }
            const toolInput = part.type === "custom_tool_call" ? (_i = part.input) != null ? _i : "" : part.type === "mcp_call" ? (_j = part.arguments) != null ? _j : "" : (_k = part.arguments) != null ? _k : "";
            content.push({
              type: "tool-call",
              toolCallId: part.id,
              toolName,
              input: toolInput,
              providerExecuted: true
            });
            continue;
          }
          switch (part.type) {
            case "message": {
              for (const contentPart of part.content) {
                if (contentPart.text) {
                  content.push({
                    type: "text",
                    text: contentPart.text
                  });
                }
                if (contentPart.annotations) {
                  for (const annotation of contentPart.annotations) {
                    if (annotation.type === "url_citation" && "url" in annotation) {
                      content.push({
                        type: "source",
                        sourceType: "url",
                        id: this.config.generateId(),
                        url: annotation.url,
                        title: (_l = annotation.title) != null ? _l : annotation.url
                      });
                    }
                  }
                }
              }
              break;
            }
            case "function_call": {
              hasFunctionCall = true;
              content.push({
                type: "tool-call",
                toolCallId: part.call_id,
                toolName: part.name,
                input: part.arguments
              });
              break;
            }
            case "reasoning": {
              const summaryTexts = part.summary.map((s) => s.text).filter((text2) => text2 && text2.length > 0);
              if (summaryTexts.length > 0) {
                const reasoningText = summaryTexts.join("");
                if (part.encrypted_content || part.id) {
                  content.push({
                    type: "reasoning",
                    text: reasoningText,
                    providerMetadata: {
                      xai: {
                        ...part.encrypted_content && {
                          reasoningEncryptedContent: part.encrypted_content
                        },
                        ...part.id && { itemId: part.id }
                      }
                    }
                  });
                } else {
                  content.push({
                    type: "reasoning",
                    text: reasoningText
                  });
                }
              }
              break;
            }
            default: {
              break;
            }
          }
        }
        return {
          content,
          finishReason: {
            unified: hasFunctionCall ? "tool-calls" : mapXaiResponsesFinishReason(response.status),
            raw: (_m = response.status) != null ? _m : void 0
          },
          usage: response.usage ? convertXaiResponsesUsage(response.usage) : {
            inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
            outputTokens: { total: 0, text: 0, reasoning: 0 }
          },
          request: { body },
          response: {
            ...getResponseMetadata6(response),
            headers: responseHeaders,
            body: rawResponse
          },
          warnings
        };
      }
      async doStream(options) {
        var _a31;
        const {
          args,
          warnings,
          webSearchToolName,
          xSearchToolName,
          codeExecutionToolName,
          mcpToolName,
          fileSearchToolName
        } = await this.getArgs(options);
        const body = {
          ...args,
          stream: true
        };
        const { responseHeaders, value: response } = await postJsonToApi({
          url: `${(_a31 = this.config.baseURL) != null ? _a31 : "https://api.x.ai/v1"}/responses`,
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: xaiFailedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler(
            xaiResponsesChunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        let hasFunctionCall = false;
        let usage = void 0;
        let isFirstChunk = true;
        const contentBlocks = {};
        const seenToolCalls = /* @__PURE__ */ new Set();
        const ongoingToolCalls = {};
        const activeReasoning = {};
        const self2 = this;
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                var _a211, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                const event = chunk.value;
                if (event.type === "response.created" || event.type === "response.in_progress") {
                  if (isFirstChunk) {
                    controller.enqueue({
                      type: "response-metadata",
                      ...getResponseMetadata6(event.response)
                    });
                    isFirstChunk = false;
                  }
                  return;
                }
                if (event.type === "response.reasoning_summary_part.added") {
                  const blockId = `reasoning-${event.item_id}`;
                  activeReasoning[event.item_id] = {};
                  controller.enqueue({
                    type: "reasoning-start",
                    id: blockId,
                    providerMetadata: {
                      xai: {
                        itemId: event.item_id
                      }
                    }
                  });
                }
                if (event.type === "response.reasoning_summary_text.delta") {
                  const blockId = `reasoning-${event.item_id}`;
                  controller.enqueue({
                    type: "reasoning-delta",
                    id: blockId,
                    delta: event.delta,
                    providerMetadata: {
                      xai: {
                        itemId: event.item_id
                      }
                    }
                  });
                  return;
                }
                if (event.type === "response.reasoning_summary_text.done") {
                  return;
                }
                if (event.type === "response.reasoning_text.delta") {
                  const blockId = `reasoning-${event.item_id}`;
                  if (activeReasoning[event.item_id] == null) {
                    activeReasoning[event.item_id] = {};
                    controller.enqueue({
                      type: "reasoning-start",
                      id: blockId,
                      providerMetadata: {
                        xai: {
                          itemId: event.item_id
                        }
                      }
                    });
                  }
                  controller.enqueue({
                    type: "reasoning-delta",
                    id: blockId,
                    delta: event.delta,
                    providerMetadata: {
                      xai: {
                        itemId: event.item_id
                      }
                    }
                  });
                  return;
                }
                if (event.type === "response.reasoning_text.done") {
                  return;
                }
                if (event.type === "response.output_text.delta") {
                  const blockId = `text-${event.item_id}`;
                  if (contentBlocks[blockId] == null) {
                    contentBlocks[blockId] = { type: "text" };
                    controller.enqueue({
                      type: "text-start",
                      id: blockId
                    });
                  }
                  controller.enqueue({
                    type: "text-delta",
                    id: blockId,
                    delta: event.delta
                  });
                  return;
                }
                if (event.type === "response.output_text.done") {
                  if (event.annotations) {
                    for (const annotation of event.annotations) {
                      if (annotation.type === "url_citation" && "url" in annotation) {
                        controller.enqueue({
                          type: "source",
                          sourceType: "url",
                          id: self2.config.generateId(),
                          url: annotation.url,
                          title: (_a211 = annotation.title) != null ? _a211 : annotation.url
                        });
                      }
                    }
                  }
                  return;
                }
                if (event.type === "response.output_text.annotation.added") {
                  const annotation = event.annotation;
                  if (annotation.type === "url_citation" && "url" in annotation) {
                    controller.enqueue({
                      type: "source",
                      sourceType: "url",
                      id: self2.config.generateId(),
                      url: annotation.url,
                      title: (_b27 = annotation.title) != null ? _b27 : annotation.url
                    });
                  }
                  return;
                }
                if (event.type === "response.done" || event.type === "response.completed") {
                  const response2 = event.response;
                  if (response2.usage) {
                    usage = convertXaiResponsesUsage(response2.usage);
                  }
                  if (response2.status) {
                    finishReason = {
                      unified: hasFunctionCall ? "tool-calls" : mapXaiResponsesFinishReason(response2.status),
                      raw: response2.status
                    };
                  }
                  return;
                }
                if (event.type === "response.custom_tool_call_input.delta" || event.type === "response.custom_tool_call_input.done") {
                  return;
                }
                if (event.type === "response.function_call_arguments.delta") {
                  const toolCall = ongoingToolCalls[event.output_index];
                  if (toolCall != null) {
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.toolCallId,
                      delta: event.delta
                    });
                  }
                  return;
                }
                if (event.type === "response.function_call_arguments.done") {
                  return;
                }
                if (event.type === "response.output_item.added" || event.type === "response.output_item.done") {
                  const part = event.item;
                  if (part.type === "reasoning") {
                    if (event.type === "response.output_item.done") {
                      const blockId = `reasoning-${part.id}`;
                      if (!(part.id in activeReasoning)) {
                        activeReasoning[part.id] = {};
                        controller.enqueue({
                          type: "reasoning-start",
                          id: blockId,
                          providerMetadata: {
                            xai: {
                              ...part.id && { itemId: part.id }
                            }
                          }
                        });
                      }
                      controller.enqueue({
                        type: "reasoning-end",
                        id: blockId,
                        providerMetadata: {
                          xai: {
                            ...part.encrypted_content && {
                              reasoningEncryptedContent: part.encrypted_content
                            },
                            ...part.id && { itemId: part.id }
                          }
                        }
                      });
                      delete activeReasoning[part.id];
                    }
                    return;
                  }
                  if (part.type === "file_search_call") {
                    const toolName = fileSearchToolName != null ? fileSearchToolName : "file_search";
                    if (!seenToolCalls.has(part.id)) {
                      seenToolCalls.add(part.id);
                      controller.enqueue({
                        type: "tool-input-start",
                        id: part.id,
                        toolName
                      });
                      controller.enqueue({
                        type: "tool-input-delta",
                        id: part.id,
                        delta: ""
                      });
                      controller.enqueue({
                        type: "tool-input-end",
                        id: part.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: part.id,
                        toolName,
                        input: "",
                        providerExecuted: true
                      });
                    }
                    if (event.type === "response.output_item.done") {
                      controller.enqueue({
                        type: "tool-result",
                        toolCallId: part.id,
                        toolName,
                        result: {
                          queries: (_c = part.queries) != null ? _c : [],
                          results: (_e = (_d = part.results) == null ? void 0 : _d.map((result) => ({
                            fileId: result.file_id,
                            filename: result.filename,
                            score: result.score,
                            text: result.text
                          }))) != null ? _e : null
                        }
                      });
                    }
                    return;
                  }
                  if (part.type === "web_search_call" || part.type === "x_search_call" || part.type === "code_interpreter_call" || part.type === "code_execution_call" || part.type === "view_image_call" || part.type === "view_x_video_call" || part.type === "custom_tool_call" || part.type === "mcp_call") {
                    const webSearchSubTools = [
                      "web_search",
                      "web_search_with_snippets",
                      "browse_page"
                    ];
                    const xSearchSubTools = [
                      "x_user_search",
                      "x_keyword_search",
                      "x_semantic_search",
                      "x_thread_fetch"
                    ];
                    let toolName = (_f = part.name) != null ? _f : "";
                    if (webSearchSubTools.includes((_g = part.name) != null ? _g : "") || part.type === "web_search_call") {
                      toolName = webSearchToolName != null ? webSearchToolName : "web_search";
                    } else if (xSearchSubTools.includes((_h = part.name) != null ? _h : "") || part.type === "x_search_call") {
                      toolName = xSearchToolName != null ? xSearchToolName : "x_search";
                    } else if (part.name === "code_execution" || part.type === "code_interpreter_call" || part.type === "code_execution_call") {
                      toolName = codeExecutionToolName != null ? codeExecutionToolName : "code_execution";
                    } else if (part.type === "mcp_call") {
                      toolName = (_i = mcpToolName != null ? mcpToolName : part.name) != null ? _i : "mcp";
                    }
                    const toolInput = part.type === "custom_tool_call" ? (_j = part.input) != null ? _j : "" : part.type === "mcp_call" ? (_k = part.arguments) != null ? _k : "" : (_l = part.arguments) != null ? _l : "";
                    const shouldEmit = part.type === "custom_tool_call" ? event.type === "response.output_item.done" : !seenToolCalls.has(part.id);
                    if (shouldEmit && !seenToolCalls.has(part.id)) {
                      seenToolCalls.add(part.id);
                      controller.enqueue({
                        type: "tool-input-start",
                        id: part.id,
                        toolName
                      });
                      controller.enqueue({
                        type: "tool-input-delta",
                        id: part.id,
                        delta: toolInput
                      });
                      controller.enqueue({
                        type: "tool-input-end",
                        id: part.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: part.id,
                        toolName,
                        input: toolInput,
                        providerExecuted: true
                      });
                    }
                    return;
                  }
                  if (part.type === "message") {
                    for (const contentPart of part.content) {
                      if (contentPart.text && contentPart.text.length > 0) {
                        const blockId = `text-${part.id}`;
                        if (contentBlocks[blockId] == null) {
                          contentBlocks[blockId] = { type: "text" };
                          controller.enqueue({
                            type: "text-start",
                            id: blockId
                          });
                          controller.enqueue({
                            type: "text-delta",
                            id: blockId,
                            delta: contentPart.text
                          });
                        }
                      }
                      if (contentPart.annotations) {
                        for (const annotation of contentPart.annotations) {
                          if (annotation.type === "url_citation" && "url" in annotation) {
                            controller.enqueue({
                              type: "source",
                              sourceType: "url",
                              id: self2.config.generateId(),
                              url: annotation.url,
                              title: (_m = annotation.title) != null ? _m : annotation.url
                            });
                          }
                        }
                      }
                    }
                  } else if (part.type === "function_call") {
                    if (event.type === "response.output_item.added") {
                      ongoingToolCalls[event.output_index] = {
                        toolName: part.name,
                        toolCallId: part.call_id
                      };
                      controller.enqueue({
                        type: "tool-input-start",
                        id: part.call_id,
                        toolName: part.name
                      });
                    } else if (event.type === "response.output_item.done") {
                      hasFunctionCall = true;
                      ongoingToolCalls[event.output_index] = void 0;
                      controller.enqueue({
                        type: "tool-input-end",
                        id: part.call_id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: part.call_id,
                        toolName: part.name,
                        input: part.arguments
                      });
                    }
                  }
                }
              },
              flush(controller) {
                for (const [blockId, block] of Object.entries(contentBlocks)) {
                  if (block.type === "text") {
                    controller.enqueue({
                      type: "text-end",
                      id: blockId
                    });
                  }
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage: usage != null ? usage : {
                    inputTokens: {
                      total: 0,
                      noCache: 0,
                      cacheRead: 0,
                      cacheWrite: 0
                    },
                    outputTokens: { total: 0, text: 0, reasoning: 0 }
                  }
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    codeExecutionOutputSchema = external_exports.object({
      output: external_exports.string().describe("the output of the code execution"),
      error: external_exports.string().optional().describe("any error that occurred")
    });
    codeExecutionToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "xai.code_execution",
      inputSchema: external_exports.object({}).describe("no input parameters"),
      outputSchema: codeExecutionOutputSchema
    });
    codeExecution2 = (args = {}) => codeExecutionToolFactory(args);
    viewImageOutputSchema = external_exports.object({
      description: external_exports.string().describe("description of the image"),
      objects: external_exports.array(external_exports.string()).optional().describe("objects detected in the image")
    });
    viewImageToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "xai.view_image",
      inputSchema: external_exports.object({}).describe("no input parameters"),
      outputSchema: viewImageOutputSchema
    });
    viewImage = (args = {}) => viewImageToolFactory(args);
    viewXVideoOutputSchema = external_exports.object({
      transcript: external_exports.string().optional().describe("transcript of the video"),
      description: external_exports.string().describe("description of the video content"),
      duration: external_exports.number().optional().describe("duration in seconds")
    });
    viewXVideoToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "xai.view_x_video",
      inputSchema: external_exports.object({}).describe("no input parameters"),
      outputSchema: viewXVideoOutputSchema
    });
    viewXVideo = (args = {}) => viewXVideoToolFactory(args);
    xaiTools = {
      codeExecution: codeExecution2,
      fileSearch: fileSearch3,
      mcpServer,
      viewImage,
      viewXVideo,
      webSearch: webSearch2,
      xSearch
    };
    VERSION10 = true ? "3.0.75" : "0.0.0-test";
    xaiVideoModelOptionsSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          pollIntervalMs: external_exports.number().positive().nullish(),
          pollTimeoutMs: external_exports.number().positive().nullish(),
          resolution: external_exports.enum(["480p", "720p"]).nullish(),
          videoUrl: external_exports.string().nullish()
        }).passthrough()
      )
    );
    RESOLUTION_MAP = {
      "1280x720": "720p",
      "854x480": "480p",
      "640x480": "480p"
    };
    XaiVideoModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
        this.maxVideosPerCall = 1;
      }
      get provider() {
        return this.config.provider;
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j;
        const currentDate = (_c = (_b27 = (_a31 = this.config._internal) == null ? void 0 : _a31.currentDate) == null ? void 0 : _b27.call(_a31)) != null ? _c : /* @__PURE__ */ new Date();
        const warnings = [];
        const xaiOptions = await parseProviderOptions({
          provider: "xai",
          providerOptions: options.providerOptions,
          schema: xaiVideoModelOptionsSchema
        });
        const isEdit = (xaiOptions == null ? void 0 : xaiOptions.videoUrl) != null;
        if (options.fps != null) {
          warnings.push({
            type: "unsupported",
            feature: "fps",
            details: "xAI video models do not support custom FPS."
          });
        }
        if (options.seed != null) {
          warnings.push({
            type: "unsupported",
            feature: "seed",
            details: "xAI video models do not support seed."
          });
        }
        if (options.n != null && options.n > 1) {
          warnings.push({
            type: "unsupported",
            feature: "n",
            details: "xAI video models do not support generating multiple videos per call. Only 1 video will be generated."
          });
        }
        if (isEdit && options.duration != null) {
          warnings.push({
            type: "unsupported",
            feature: "duration",
            details: "xAI video editing does not support custom duration."
          });
        }
        if (isEdit && options.aspectRatio != null) {
          warnings.push({
            type: "unsupported",
            feature: "aspectRatio",
            details: "xAI video editing does not support custom aspect ratio."
          });
        }
        if (isEdit && ((xaiOptions == null ? void 0 : xaiOptions.resolution) != null || options.resolution != null)) {
          warnings.push({
            type: "unsupported",
            feature: "resolution",
            details: "xAI video editing does not support custom resolution."
          });
        }
        const body = {
          model: this.modelId,
          prompt: options.prompt
        };
        if (!isEdit && options.duration != null) {
          body.duration = options.duration;
        }
        if (!isEdit && options.aspectRatio != null) {
          body.aspect_ratio = options.aspectRatio;
        }
        if (!isEdit && (xaiOptions == null ? void 0 : xaiOptions.resolution) != null) {
          body.resolution = xaiOptions.resolution;
        } else if (!isEdit && options.resolution != null) {
          const mapped = RESOLUTION_MAP[options.resolution];
          if (mapped != null) {
            body.resolution = mapped;
          } else {
            warnings.push({
              type: "unsupported",
              feature: "resolution",
              details: `Unrecognized resolution "${options.resolution}". Use providerOptions.xai.resolution with "480p" or "720p" instead.`
            });
          }
        }
        if ((xaiOptions == null ? void 0 : xaiOptions.videoUrl) != null) {
          body.video = { url: xaiOptions.videoUrl };
        }
        if (options.image != null) {
          if (options.image.type === "url") {
            body.image = { url: options.image.url };
          } else {
            const base64Data = typeof options.image.data === "string" ? options.image.data : convertUint8ArrayToBase64(options.image.data);
            body.image = {
              url: `data:${options.image.mediaType};base64,${base64Data}`
            };
          }
        }
        if (xaiOptions != null) {
          for (const [key, value] of Object.entries(xaiOptions)) {
            if (![
              "pollIntervalMs",
              "pollTimeoutMs",
              "resolution",
              "videoUrl"
            ].includes(key)) {
              body[key] = value;
            }
          }
        }
        const baseURL = (_d = this.config.baseURL) != null ? _d : "https://api.x.ai/v1";
        const { value: createResponse } = await postJsonToApi({
          url: `${baseURL}/videos/${isEdit ? "edits" : "generations"}`,
          headers: combineHeaders(this.config.headers(), options.headers),
          body,
          failedResponseHandler: xaiFailedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler(
            xaiCreateVideoResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const requestId = createResponse.request_id;
        if (!requestId) {
          throw new AISDKError({
            name: "XAI_VIDEO_GENERATION_ERROR",
            message: `No request_id returned from xAI API. Response: ${JSON.stringify(createResponse)}`
          });
        }
        const pollIntervalMs = (_e = xaiOptions == null ? void 0 : xaiOptions.pollIntervalMs) != null ? _e : 5e3;
        const pollTimeoutMs = (_f = xaiOptions == null ? void 0 : xaiOptions.pollTimeoutMs) != null ? _f : 6e5;
        const startTime = Date.now();
        let responseHeaders;
        while (true) {
          await delay(pollIntervalMs, { abortSignal: options.abortSignal });
          if (Date.now() - startTime > pollTimeoutMs) {
            throw new AISDKError({
              name: "XAI_VIDEO_GENERATION_TIMEOUT",
              message: `Video generation timed out after ${pollTimeoutMs}ms`
            });
          }
          const { value: statusResponse, responseHeaders: pollHeaders } = await getFromApi({
            url: `${baseURL}/videos/${requestId}`,
            headers: combineHeaders(this.config.headers(), options.headers),
            successfulResponseHandler: createJsonResponseHandler(
              xaiVideoStatusResponseSchema
            ),
            failedResponseHandler: xaiFailedResponseHandler,
            abortSignal: options.abortSignal,
            fetch: this.config.fetch
          });
          responseHeaders = pollHeaders;
          if (statusResponse.status === "done" || statusResponse.status == null && ((_g = statusResponse.video) == null ? void 0 : _g.url)) {
            if (((_h = statusResponse.video) == null ? void 0 : _h.respect_moderation) === false) {
              throw new AISDKError({
                name: "XAI_VIDEO_MODERATION_ERROR",
                message: "Video generation was blocked due to a content policy violation."
              });
            }
            if (!((_i = statusResponse.video) == null ? void 0 : _i.url)) {
              throw new AISDKError({
                name: "XAI_VIDEO_GENERATION_ERROR",
                message: "Video generation completed but no video URL was returned."
              });
            }
            return {
              videos: [
                {
                  type: "url",
                  url: statusResponse.video.url,
                  mediaType: "video/mp4"
                }
              ],
              warnings,
              response: {
                timestamp: currentDate,
                modelId: this.modelId,
                headers: responseHeaders
              },
              providerMetadata: {
                xai: {
                  requestId,
                  videoUrl: statusResponse.video.url,
                  ...statusResponse.video.duration != null ? { duration: statusResponse.video.duration } : {},
                  ...((_j = statusResponse.usage) == null ? void 0 : _j.cost_in_usd_ticks) != null ? { costInUsdTicks: statusResponse.usage.cost_in_usd_ticks } : {}
                }
              }
            };
          }
          if (statusResponse.status === "expired") {
            throw new AISDKError({
              name: "XAI_VIDEO_GENERATION_EXPIRED",
              message: "Video generation request expired."
            });
          }
        }
      }
    };
    xaiCreateVideoResponseSchema = external_exports.object({
      request_id: external_exports.string().nullish()
    });
    xaiVideoStatusResponseSchema = external_exports.object({
      status: external_exports.string().nullish(),
      video: external_exports.object({
        url: external_exports.string(),
        duration: external_exports.number().nullish(),
        respect_moderation: external_exports.boolean().nullish()
      }).nullish(),
      model: external_exports.string().nullish(),
      usage: external_exports.object({
        cost_in_usd_ticks: external_exports.number().nullish()
      }).nullish()
    });
    xai = createXai();
  }
});

// node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/anthropic/node_modules/@ai-sdk/provider/dist/index.mjs
function getErrorMessage4(error73) {
  if (error73 == null) {
    return "unknown error";
  }
  if (typeof error73 === "string") {
    return error73;
  }
  if (error73 instanceof Error) {
    return error73.message;
  }
  return JSON.stringify(error73);
}
var marker18, symbol20, _a20, _b18, AISDKError3, name17, marker23, symbol23, _a24, _b23, APICallError3, name23, marker33, symbol33, _a33, _b33, EmptyResponseBodyError3, name33, marker43, symbol43, _a43, _b43, InvalidArgumentError3, name43, marker53, symbol53, _a53, _b53, InvalidPromptError3, name53, marker63, symbol63, _a63, _b63, InvalidResponseDataError3, name63, marker73, symbol73, _a73, _b73, JSONParseError3, name73, marker83, symbol83, _a83, _b83, LoadAPIKeyError3, name83, marker93, symbol93, _a93, _b93, LoadSettingError3, name93, marker103, symbol103, _a103, _b103, NoContentGeneratedError3, name103, marker113, symbol113, _a113, _b113, NoSuchModelError3, name113, marker123, symbol123, _a123, _b123, TooManyEmbeddingValuesForCallError3, name123, marker133, symbol133, _a133, _b133, TypeValidationError3, name133, marker143, symbol143, _a143, _b143, UnsupportedFunctionalityError3;
var init_dist16 = __esm({
  "node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/anthropic/node_modules/@ai-sdk/provider/dist/index.mjs"() {
    "use strict";
    marker18 = "vercel.ai.error";
    symbol20 = Symbol.for(marker18);
    AISDKError3 = class _AISDKError3 extends (_b18 = Error, _a20 = symbol20, _b18) {
      /**
       * Creates an AI SDK Error.
       *
       * @param {Object} params - The parameters for creating the error.
       * @param {string} params.name - The name of the error.
       * @param {string} params.message - The error message.
       * @param {unknown} [params.cause] - The underlying cause of the error.
       */
      constructor({
        name: name143,
        message,
        cause
      }) {
        super(message);
        this[_a20] = true;
        this.name = name143;
        this.cause = cause;
      }
      /**
       * Checks if the given error is an AI SDK Error.
       * @param {unknown} error - The error to check.
       * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
       */
      static isInstance(error73) {
        return _AISDKError3.hasMarker(error73, marker18);
      }
      static hasMarker(error73, marker153) {
        const markerSymbol = Symbol.for(marker153);
        return error73 != null && typeof error73 === "object" && markerSymbol in error73 && typeof error73[markerSymbol] === "boolean" && error73[markerSymbol] === true;
      }
    };
    name17 = "AI_APICallError";
    marker23 = `vercel.ai.error.${name17}`;
    symbol23 = Symbol.for(marker23);
    APICallError3 = class extends (_b23 = AISDKError3, _a24 = symbol23, _b23) {
      constructor({
        message,
        url: url4,
        requestBodyValues,
        statusCode,
        responseHeaders,
        responseBody,
        cause,
        isRetryable = statusCode != null && (statusCode === 408 || // request timeout
        statusCode === 409 || // conflict
        statusCode === 429 || // too many requests
        statusCode >= 500),
        // server error
        data
      }) {
        super({ name: name17, message, cause });
        this[_a24] = true;
        this.url = url4;
        this.requestBodyValues = requestBodyValues;
        this.statusCode = statusCode;
        this.responseHeaders = responseHeaders;
        this.responseBody = responseBody;
        this.isRetryable = isRetryable;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker23);
      }
    };
    name23 = "AI_EmptyResponseBodyError";
    marker33 = `vercel.ai.error.${name23}`;
    symbol33 = Symbol.for(marker33);
    EmptyResponseBodyError3 = class extends (_b33 = AISDKError3, _a33 = symbol33, _b33) {
      // used in isInstance
      constructor({ message = "Empty response body" } = {}) {
        super({ name: name23, message });
        this[_a33] = true;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker33);
      }
    };
    name33 = "AI_InvalidArgumentError";
    marker43 = `vercel.ai.error.${name33}`;
    symbol43 = Symbol.for(marker43);
    InvalidArgumentError3 = class extends (_b43 = AISDKError3, _a43 = symbol43, _b43) {
      constructor({
        message,
        cause,
        argument
      }) {
        super({ name: name33, message, cause });
        this[_a43] = true;
        this.argument = argument;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker43);
      }
    };
    name43 = "AI_InvalidPromptError";
    marker53 = `vercel.ai.error.${name43}`;
    symbol53 = Symbol.for(marker53);
    InvalidPromptError3 = class extends (_b53 = AISDKError3, _a53 = symbol53, _b53) {
      constructor({
        prompt,
        message,
        cause
      }) {
        super({ name: name43, message: `Invalid prompt: ${message}`, cause });
        this[_a53] = true;
        this.prompt = prompt;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker53);
      }
    };
    name53 = "AI_InvalidResponseDataError";
    marker63 = `vercel.ai.error.${name53}`;
    symbol63 = Symbol.for(marker63);
    InvalidResponseDataError3 = class extends (_b63 = AISDKError3, _a63 = symbol63, _b63) {
      constructor({
        data,
        message = `Invalid response data: ${JSON.stringify(data)}.`
      }) {
        super({ name: name53, message });
        this[_a63] = true;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker63);
      }
    };
    name63 = "AI_JSONParseError";
    marker73 = `vercel.ai.error.${name63}`;
    symbol73 = Symbol.for(marker73);
    JSONParseError3 = class extends (_b73 = AISDKError3, _a73 = symbol73, _b73) {
      constructor({ text: text2, cause }) {
        super({
          name: name63,
          message: `JSON parsing failed: Text: ${text2}.
Error message: ${getErrorMessage4(cause)}`,
          cause
        });
        this[_a73] = true;
        this.text = text2;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker73);
      }
    };
    name73 = "AI_LoadAPIKeyError";
    marker83 = `vercel.ai.error.${name73}`;
    symbol83 = Symbol.for(marker83);
    LoadAPIKeyError3 = class extends (_b83 = AISDKError3, _a83 = symbol83, _b83) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name73, message });
        this[_a83] = true;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker83);
      }
    };
    name83 = "AI_LoadSettingError";
    marker93 = `vercel.ai.error.${name83}`;
    symbol93 = Symbol.for(marker93);
    LoadSettingError3 = class extends (_b93 = AISDKError3, _a93 = symbol93, _b93) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name83, message });
        this[_a93] = true;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker93);
      }
    };
    name93 = "AI_NoContentGeneratedError";
    marker103 = `vercel.ai.error.${name93}`;
    symbol103 = Symbol.for(marker103);
    NoContentGeneratedError3 = class extends (_b103 = AISDKError3, _a103 = symbol103, _b103) {
      // used in isInstance
      constructor({
        message = "No content generated."
      } = {}) {
        super({ name: name93, message });
        this[_a103] = true;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker103);
      }
    };
    name103 = "AI_NoSuchModelError";
    marker113 = `vercel.ai.error.${name103}`;
    symbol113 = Symbol.for(marker113);
    NoSuchModelError3 = class extends (_b113 = AISDKError3, _a113 = symbol113, _b113) {
      constructor({
        errorName = name103,
        modelId,
        modelType,
        message = `No such ${modelType}: ${modelId}`
      }) {
        super({ name: errorName, message });
        this[_a113] = true;
        this.modelId = modelId;
        this.modelType = modelType;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker113);
      }
    };
    name113 = "AI_TooManyEmbeddingValuesForCallError";
    marker123 = `vercel.ai.error.${name113}`;
    symbol123 = Symbol.for(marker123);
    TooManyEmbeddingValuesForCallError3 = class extends (_b123 = AISDKError3, _a123 = symbol123, _b123) {
      constructor(options) {
        super({
          name: name113,
          message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
        });
        this[_a123] = true;
        this.provider = options.provider;
        this.modelId = options.modelId;
        this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
        this.values = options.values;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker123);
      }
    };
    name123 = "AI_TypeValidationError";
    marker133 = `vercel.ai.error.${name123}`;
    symbol133 = Symbol.for(marker133);
    TypeValidationError3 = class _TypeValidationError3 extends (_b133 = AISDKError3, _a133 = symbol133, _b133) {
      constructor({ value, cause }) {
        super({
          name: name123,
          message: `Type validation failed: Value: ${JSON.stringify(value)}.
Error message: ${getErrorMessage4(cause)}`,
          cause
        });
        this[_a133] = true;
        this.value = value;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker133);
      }
      /**
       * Wraps an error into a TypeValidationError.
       * If the cause is already a TypeValidationError with the same value, it returns the cause.
       * Otherwise, it creates a new TypeValidationError.
       *
       * @param {Object} params - The parameters for wrapping the error.
       * @param {unknown} params.value - The value that failed validation.
       * @param {unknown} params.cause - The original error or cause of the validation failure.
       * @returns {TypeValidationError} A TypeValidationError instance.
       */
      static wrap({
        value,
        cause
      }) {
        return _TypeValidationError3.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError3({ value, cause });
      }
    };
    name133 = "AI_UnsupportedFunctionalityError";
    marker143 = `vercel.ai.error.${name133}`;
    symbol143 = Symbol.for(marker143);
    UnsupportedFunctionalityError3 = class extends (_b143 = AISDKError3, _a143 = symbol143, _b143) {
      constructor({
        functionality,
        message = `'${functionality}' functionality not supported.`
      }) {
        super({ name: name133, message });
        this[_a143] = true;
        this.functionality = functionality;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker143);
      }
    };
  }
});

// node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/anthropic/node_modules/@ai-sdk/provider-utils/dist/index.mjs
function combineHeaders3(...headers) {
  return headers.reduce(
    (combinedHeaders, currentHeaders) => ({
      ...combinedHeaders,
      ...currentHeaders != null ? currentHeaders : {}
    }),
    {}
  );
}
function createToolNameMapping2({
  tools = [],
  providerToolNames
}) {
  const customToolNameToProviderToolName = {};
  const providerToolNameToCustomToolName = {};
  for (const tool22 of tools) {
    if (tool22.type === "provider" && tool22.id in providerToolNames) {
      const providerToolName = providerToolNames[tool22.id];
      customToolNameToProviderToolName[tool22.name] = providerToolName;
      providerToolNameToCustomToolName[providerToolName] = tool22.name;
    }
  }
  return {
    toProviderToolName: (customToolName) => {
      var _a211;
      return (_a211 = customToolNameToProviderToolName[customToolName]) != null ? _a211 : customToolName;
    },
    toCustomToolName: (providerToolName) => {
      var _a211;
      return (_a211 = providerToolNameToCustomToolName[providerToolName]) != null ? _a211 : providerToolName;
    }
  };
}
function extractResponseHeaders3(response) {
  return Object.fromEntries([...response.headers]);
}
function convertUint8ArrayToBase643(array4) {
  let latin1string = "";
  for (let i = 0; i < array4.length; i++) {
    latin1string += String.fromCodePoint(array4[i]);
  }
  return btoa4(latin1string);
}
function convertToBase642(value) {
  return value instanceof Uint8Array ? convertUint8ArrayToBase643(value) : value;
}
function isAbortError3(error73) {
  return (error73 instanceof Error || error73 instanceof DOMException) && (error73.name === "AbortError" || error73.name === "ResponseAborted" || // Next.js
  error73.name === "TimeoutError");
}
function handleFetchError3({
  error: error73,
  url: url4,
  requestBodyValues
}) {
  if (isAbortError3(error73)) {
    return error73;
  }
  if (error73 instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES3.includes(error73.message.toLowerCase())) {
    const cause = error73.cause;
    if (cause != null) {
      return new APICallError3({
        message: `Cannot connect to API: ${cause.message}`,
        cause,
        url: url4,
        requestBodyValues,
        isRetryable: true
        // retry when network error
      });
    }
  }
  return error73;
}
function getRuntimeEnvironmentUserAgent3(globalThisAny = globalThis) {
  var _a211, _b27, _c;
  if (globalThisAny.window) {
    return `runtime/browser`;
  }
  if ((_a211 = globalThisAny.navigator) == null ? void 0 : _a211.userAgent) {
    return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
  }
  if ((_c = (_b27 = globalThisAny.process) == null ? void 0 : _b27.versions) == null ? void 0 : _c.node) {
    return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
  }
  if (globalThisAny.EdgeRuntime) {
    return `runtime/vercel-edge`;
  }
  return "runtime/unknown";
}
function normalizeHeaders3(headers) {
  if (headers == null) {
    return {};
  }
  const normalized = {};
  if (headers instanceof Headers) {
    headers.forEach((value, key) => {
      normalized[key.toLowerCase()] = value;
    });
  } else {
    if (!Array.isArray(headers)) {
      headers = Object.entries(headers);
    }
    for (const [key, value] of headers) {
      if (value != null) {
        normalized[key.toLowerCase()] = value;
      }
    }
  }
  return normalized;
}
function withUserAgentSuffix3(headers, ...userAgentSuffixParts) {
  const normalizedHeaders = new Headers(normalizeHeaders3(headers));
  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
  normalizedHeaders.set(
    "user-agent",
    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
  );
  return Object.fromEntries(normalizedHeaders.entries());
}
function isNonNullable2(value) {
  return value != null;
}
function _parse5(text2) {
  const obj = JSON.parse(text2);
  if (obj === null || typeof obj !== "object") {
    return obj;
  }
  if (suspectProtoRx3.test(text2) === false && suspectConstructorRx3.test(text2) === false) {
    return obj;
  }
  return filter4(obj);
}
function filter4(obj) {
  let next = [obj];
  while (next.length) {
    const nodes = next;
    next = [];
    for (const node of nodes) {
      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      for (const key in node) {
        const value = node[key];
        if (value && typeof value === "object") {
          next.push(value);
        }
      }
    }
  }
  return obj;
}
function secureJsonParse3(text2) {
  const { stackTraceLimit } = Error;
  try {
    Error.stackTraceLimit = 0;
  } catch (e) {
    return _parse5(text2);
  }
  try {
    return _parse5(text2);
  } finally {
    Error.stackTraceLimit = stackTraceLimit;
  }
}
function addAdditionalPropertiesToJsonSchema2(jsonSchema22) {
  if (jsonSchema22.type === "object" || Array.isArray(jsonSchema22.type) && jsonSchema22.type.includes("object")) {
    jsonSchema22.additionalProperties = false;
    const { properties } = jsonSchema22;
    if (properties != null) {
      for (const key of Object.keys(properties)) {
        properties[key] = visit2(properties[key]);
      }
    }
  }
  if (jsonSchema22.items != null) {
    jsonSchema22.items = Array.isArray(jsonSchema22.items) ? jsonSchema22.items.map(visit2) : visit2(jsonSchema22.items);
  }
  if (jsonSchema22.anyOf != null) {
    jsonSchema22.anyOf = jsonSchema22.anyOf.map(visit2);
  }
  if (jsonSchema22.allOf != null) {
    jsonSchema22.allOf = jsonSchema22.allOf.map(visit2);
  }
  if (jsonSchema22.oneOf != null) {
    jsonSchema22.oneOf = jsonSchema22.oneOf.map(visit2);
  }
  const { definitions } = jsonSchema22;
  if (definitions != null) {
    for (const key of Object.keys(definitions)) {
      definitions[key] = visit2(definitions[key]);
    }
  }
  return jsonSchema22;
}
function visit2(def) {
  if (typeof def === "boolean") return def;
  return addAdditionalPropertiesToJsonSchema2(def);
}
function parseAnyDef2() {
  return {};
}
function parseArrayDef2(def, refs) {
  var _a211, _b27, _c;
  const res = {
    type: "array"
  };
  if (((_a211 = def.type) == null ? void 0 : _a211._def) && ((_c = (_b27 = def.type) == null ? void 0 : _b27._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind2.ZodAny) {
    res.items = parseDef2(def.type._def, {
      ...refs,
      currentPath: [...refs.currentPath, "items"]
    });
  }
  if (def.minLength) {
    res.minItems = def.minLength.value;
  }
  if (def.maxLength) {
    res.maxItems = def.maxLength.value;
  }
  if (def.exactLength) {
    res.minItems = def.exactLength.value;
    res.maxItems = def.exactLength.value;
  }
  return res;
}
function parseBigintDef2(def) {
  const res = {
    type: "integer",
    format: "int64"
  };
  if (!def.checks) return res;
  for (const check3 of def.checks) {
    switch (check3.kind) {
      case "min":
        if (check3.inclusive) {
          res.minimum = check3.value;
        } else {
          res.exclusiveMinimum = check3.value;
        }
        break;
      case "max":
        if (check3.inclusive) {
          res.maximum = check3.value;
        } else {
          res.exclusiveMaximum = check3.value;
        }
        break;
      case "multipleOf":
        res.multipleOf = check3.value;
        break;
    }
  }
  return res;
}
function parseBooleanDef2() {
  return { type: "boolean" };
}
function parseBrandedDef2(_def, refs) {
  return parseDef2(_def.type._def, refs);
}
function parseDateDef2(def, refs, overrideDateStrategy) {
  const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
  if (Array.isArray(strategy)) {
    return {
      anyOf: strategy.map((item, i) => parseDateDef2(def, refs, item))
    };
  }
  switch (strategy) {
    case "string":
    case "format:date-time":
      return {
        type: "string",
        format: "date-time"
      };
    case "format:date":
      return {
        type: "string",
        format: "date"
      };
    case "integer":
      return integerDateParser2(def);
  }
}
function parseDefaultDef2(_def, refs) {
  return {
    ...parseDef2(_def.innerType._def, refs),
    default: _def.defaultValue()
  };
}
function parseEffectsDef2(_def, refs) {
  return refs.effectStrategy === "input" ? parseDef2(_def.schema._def, refs) : parseAnyDef2();
}
function parseEnumDef2(def) {
  return {
    type: "string",
    enum: Array.from(def.values)
  };
}
function parseIntersectionDef2(def, refs) {
  const allOf = [
    parseDef2(def.left._def, {
      ...refs,
      currentPath: [...refs.currentPath, "allOf", "0"]
    }),
    parseDef2(def.right._def, {
      ...refs,
      currentPath: [...refs.currentPath, "allOf", "1"]
    })
  ].filter((x) => !!x);
  const mergedAllOf = [];
  allOf.forEach((schema) => {
    if (isJsonSchema7AllOfType2(schema)) {
      mergedAllOf.push(...schema.allOf);
    } else {
      let nestedSchema = schema;
      if ("additionalProperties" in schema && schema.additionalProperties === false) {
        const { additionalProperties, ...rest } = schema;
        nestedSchema = rest;
      }
      mergedAllOf.push(nestedSchema);
    }
  });
  return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
}
function parseLiteralDef2(def) {
  const parsedType3 = typeof def.value;
  if (parsedType3 !== "bigint" && parsedType3 !== "number" && parsedType3 !== "boolean" && parsedType3 !== "string") {
    return {
      type: Array.isArray(def.value) ? "array" : "object"
    };
  }
  return {
    type: parsedType3 === "bigint" ? "integer" : parsedType3,
    const: def.value
  };
}
function parseStringDef2(def, refs) {
  const res = {
    type: "string"
  };
  if (def.checks) {
    for (const check3 of def.checks) {
      switch (check3.kind) {
        case "min":
          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value;
          break;
        case "max":
          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value;
          break;
        case "email":
          switch (refs.emailStrategy) {
            case "format:email":
              addFormat2(res, "email", check3.message, refs);
              break;
            case "format:idn-email":
              addFormat2(res, "idn-email", check3.message, refs);
              break;
            case "pattern:zod":
              addPattern2(res, zodPatterns2.email, check3.message, refs);
              break;
          }
          break;
        case "url":
          addFormat2(res, "uri", check3.message, refs);
          break;
        case "uuid":
          addFormat2(res, "uuid", check3.message, refs);
          break;
        case "regex":
          addPattern2(res, check3.regex, check3.message, refs);
          break;
        case "cuid":
          addPattern2(res, zodPatterns2.cuid, check3.message, refs);
          break;
        case "cuid2":
          addPattern2(res, zodPatterns2.cuid2, check3.message, refs);
          break;
        case "startsWith":
          addPattern2(
            res,
            RegExp(`^${escapeLiteralCheckValue2(check3.value, refs)}`),
            check3.message,
            refs
          );
          break;
        case "endsWith":
          addPattern2(
            res,
            RegExp(`${escapeLiteralCheckValue2(check3.value, refs)}$`),
            check3.message,
            refs
          );
          break;
        case "datetime":
          addFormat2(res, "date-time", check3.message, refs);
          break;
        case "date":
          addFormat2(res, "date", check3.message, refs);
          break;
        case "time":
          addFormat2(res, "time", check3.message, refs);
          break;
        case "duration":
          addFormat2(res, "duration", check3.message, refs);
          break;
        case "length":
          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value;
          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value;
          break;
        case "includes": {
          addPattern2(
            res,
            RegExp(escapeLiteralCheckValue2(check3.value, refs)),
            check3.message,
            refs
          );
          break;
        }
        case "ip": {
          if (check3.version !== "v6") {
            addFormat2(res, "ipv4", check3.message, refs);
          }
          if (check3.version !== "v4") {
            addFormat2(res, "ipv6", check3.message, refs);
          }
          break;
        }
        case "base64url":
          addPattern2(res, zodPatterns2.base64url, check3.message, refs);
          break;
        case "jwt":
          addPattern2(res, zodPatterns2.jwt, check3.message, refs);
          break;
        case "cidr": {
          if (check3.version !== "v6") {
            addPattern2(res, zodPatterns2.ipv4Cidr, check3.message, refs);
          }
          if (check3.version !== "v4") {
            addPattern2(res, zodPatterns2.ipv6Cidr, check3.message, refs);
          }
          break;
        }
        case "emoji":
          addPattern2(res, zodPatterns2.emoji(), check3.message, refs);
          break;
        case "ulid": {
          addPattern2(res, zodPatterns2.ulid, check3.message, refs);
          break;
        }
        case "base64": {
          switch (refs.base64Strategy) {
            case "format:binary": {
              addFormat2(res, "binary", check3.message, refs);
              break;
            }
            case "contentEncoding:base64": {
              res.contentEncoding = "base64";
              break;
            }
            case "pattern:zod": {
              addPattern2(res, zodPatterns2.base64, check3.message, refs);
              break;
            }
          }
          break;
        }
        case "nanoid": {
          addPattern2(res, zodPatterns2.nanoid, check3.message, refs);
        }
        case "toLowerCase":
        case "toUpperCase":
        case "trim":
          break;
        default:
          /* @__PURE__ */ ((_) => {
          })(check3);
      }
    }
  }
  return res;
}
function escapeLiteralCheckValue2(literal3, refs) {
  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric2(literal3) : literal3;
}
function escapeNonAlphaNumeric2(source) {
  let result = "";
  for (let i = 0; i < source.length; i++) {
    if (!ALPHA_NUMERIC3.has(source[i])) {
      result += "\\";
    }
    result += source[i];
  }
  return result;
}
function addFormat2(schema, value, message, refs) {
  var _a211;
  if (schema.format || ((_a211 = schema.anyOf) == null ? void 0 : _a211.some((x) => x.format))) {
    if (!schema.anyOf) {
      schema.anyOf = [];
    }
    if (schema.format) {
      schema.anyOf.push({
        format: schema.format
      });
      delete schema.format;
    }
    schema.anyOf.push({
      format: value,
      ...message && refs.errorMessages && { errorMessage: { format: message } }
    });
  } else {
    schema.format = value;
  }
}
function addPattern2(schema, regex, message, refs) {
  var _a211;
  if (schema.pattern || ((_a211 = schema.allOf) == null ? void 0 : _a211.some((x) => x.pattern))) {
    if (!schema.allOf) {
      schema.allOf = [];
    }
    if (schema.pattern) {
      schema.allOf.push({
        pattern: schema.pattern
      });
      delete schema.pattern;
    }
    schema.allOf.push({
      pattern: stringifyRegExpWithFlags2(regex, refs),
      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
    });
  } else {
    schema.pattern = stringifyRegExpWithFlags2(regex, refs);
  }
}
function stringifyRegExpWithFlags2(regex, refs) {
  var _a211;
  if (!refs.applyRegexFlags || !regex.flags) {
    return regex.source;
  }
  const flags = {
    i: regex.flags.includes("i"),
    // Case-insensitive
    m: regex.flags.includes("m"),
    // `^` and `$` matches adjacent to newline characters
    s: regex.flags.includes("s")
    // `.` matches newlines
  };
  const source = flags.i ? regex.source.toLowerCase() : regex.source;
  let pattern = "";
  let isEscaped = false;
  let inCharGroup = false;
  let inCharRange = false;
  for (let i = 0; i < source.length; i++) {
    if (isEscaped) {
      pattern += source[i];
      isEscaped = false;
      continue;
    }
    if (flags.i) {
      if (inCharGroup) {
        if (source[i].match(/[a-z]/)) {
          if (inCharRange) {
            pattern += source[i];
            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
            inCharRange = false;
          } else if (source[i + 1] === "-" && ((_a211 = source[i + 2]) == null ? void 0 : _a211.match(/[a-z]/))) {
            pattern += source[i];
            inCharRange = true;
          } else {
            pattern += `${source[i]}${source[i].toUpperCase()}`;
          }
          continue;
        }
      } else if (source[i].match(/[a-z]/)) {
        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
        continue;
      }
    }
    if (flags.m) {
      if (source[i] === "^") {
        pattern += `(^|(?<=[\r
]))`;
        continue;
      } else if (source[i] === "$") {
        pattern += `($|(?=[\r
]))`;
        continue;
      }
    }
    if (flags.s && source[i] === ".") {
      pattern += inCharGroup ? `${source[i]}\r
` : `[${source[i]}\r
]`;
      continue;
    }
    pattern += source[i];
    if (source[i] === "\\") {
      isEscaped = true;
    } else if (inCharGroup && source[i] === "]") {
      inCharGroup = false;
    } else if (!inCharGroup && source[i] === "[") {
      inCharGroup = true;
    }
  }
  try {
    new RegExp(pattern);
  } catch (e) {
    console.warn(
      `Could not convert regex pattern at ${refs.currentPath.join(
        "/"
      )} to a flag-independent form! Falling back to the flag-ignorant source`
    );
    return regex.source;
  }
  return pattern;
}
function parseRecordDef2(def, refs) {
  var _a211, _b27, _c, _d, _e, _f;
  const schema = {
    type: "object",
    additionalProperties: (_a211 = parseDef2(def.valueType._def, {
      ...refs,
      currentPath: [...refs.currentPath, "additionalProperties"]
    })) != null ? _a211 : refs.allowedAdditionalProperties
  };
  if (((_b27 = def.keyType) == null ? void 0 : _b27._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
    const { type, ...keyType } = parseStringDef2(def.keyType._def, refs);
    return {
      ...schema,
      propertyNames: keyType
    };
  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind2.ZodEnum) {
    return {
      ...schema,
      propertyNames: {
        enum: def.keyType._def.values
      }
    };
  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
    const { type, ...keyType } = parseBrandedDef2(
      def.keyType._def,
      refs
    );
    return {
      ...schema,
      propertyNames: keyType
    };
  }
  return schema;
}
function parseMapDef2(def, refs) {
  if (refs.mapStrategy === "record") {
    return parseRecordDef2(def, refs);
  }
  const keys2 = parseDef2(def.keyType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items", "items", "0"]
  }) || parseAnyDef2();
  const values = parseDef2(def.valueType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items", "items", "1"]
  }) || parseAnyDef2();
  return {
    type: "array",
    maxItems: 125,
    items: {
      type: "array",
      items: [keys2, values],
      minItems: 2,
      maxItems: 2
    }
  };
}
function parseNativeEnumDef2(def) {
  const object4 = def.values;
  const actualKeys = Object.keys(def.values).filter((key) => {
    return typeof object4[object4[key]] !== "number";
  });
  const actualValues = actualKeys.map((key) => object4[key]);
  const parsedTypes = Array.from(
    new Set(actualValues.map((values) => typeof values))
  );
  return {
    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
    enum: actualValues
  };
}
function parseNeverDef2() {
  return { not: parseAnyDef2() };
}
function parseNullDef2() {
  return {
    type: "null"
  };
}
function parseUnionDef2(def, refs) {
  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
  if (options.every(
    (x) => x._def.typeName in primitiveMappings2 && (!x._def.checks || !x._def.checks.length)
  )) {
    const types = options.reduce((types2, x) => {
      const type = primitiveMappings2[x._def.typeName];
      return type && !types2.includes(type) ? [...types2, type] : types2;
    }, []);
    return {
      type: types.length > 1 ? types : types[0]
    };
  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
    const types = options.reduce(
      (acc, x) => {
        const type = typeof x._def.value;
        switch (type) {
          case "string":
          case "number":
          case "boolean":
            return [...acc, type];
          case "bigint":
            return [...acc, "integer"];
          case "object":
            if (x._def.value === null) return [...acc, "null"];
          case "symbol":
          case "undefined":
          case "function":
          default:
            return acc;
        }
      },
      []
    );
    if (types.length === options.length) {
      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
      return {
        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
        enum: options.reduce(
          (acc, x) => {
            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
          },
          []
        )
      };
    }
  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
    return {
      type: "string",
      enum: options.reduce(
        (acc, x) => [
          ...acc,
          ...x._def.values.filter((x2) => !acc.includes(x2))
        ],
        []
      )
    };
  }
  return asAnyOf2(def, refs);
}
function parseNullableDef2(def, refs) {
  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
    def.innerType._def.typeName
  ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
    return {
      type: [
        primitiveMappings2[def.innerType._def.typeName],
        "null"
      ]
    };
  }
  const base = parseDef2(def.innerType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "anyOf", "0"]
  });
  return base && { anyOf: [base, { type: "null" }] };
}
function parseNumberDef2(def) {
  const res = {
    type: "number"
  };
  if (!def.checks) return res;
  for (const check3 of def.checks) {
    switch (check3.kind) {
      case "int":
        res.type = "integer";
        break;
      case "min":
        if (check3.inclusive) {
          res.minimum = check3.value;
        } else {
          res.exclusiveMinimum = check3.value;
        }
        break;
      case "max":
        if (check3.inclusive) {
          res.maximum = check3.value;
        } else {
          res.exclusiveMaximum = check3.value;
        }
        break;
      case "multipleOf":
        res.multipleOf = check3.value;
        break;
    }
  }
  return res;
}
function parseObjectDef2(def, refs) {
  const result = {
    type: "object",
    properties: {}
  };
  const required3 = [];
  const shape = def.shape();
  for (const propName in shape) {
    let propDef = shape[propName];
    if (propDef === void 0 || propDef._def === void 0) {
      continue;
    }
    const propOptional = safeIsOptional2(propDef);
    const parsedDef = parseDef2(propDef._def, {
      ...refs,
      currentPath: [...refs.currentPath, "properties", propName],
      propertyPath: [...refs.currentPath, "properties", propName]
    });
    if (parsedDef === void 0) {
      continue;
    }
    result.properties[propName] = parsedDef;
    if (!propOptional) {
      required3.push(propName);
    }
  }
  if (required3.length) {
    result.required = required3;
  }
  const additionalProperties = decideAdditionalProperties2(def, refs);
  if (additionalProperties !== void 0) {
    result.additionalProperties = additionalProperties;
  }
  return result;
}
function decideAdditionalProperties2(def, refs) {
  if (def.catchall._def.typeName !== "ZodNever") {
    return parseDef2(def.catchall._def, {
      ...refs,
      currentPath: [...refs.currentPath, "additionalProperties"]
    });
  }
  switch (def.unknownKeys) {
    case "passthrough":
      return refs.allowedAdditionalProperties;
    case "strict":
      return refs.rejectedAdditionalProperties;
    case "strip":
      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
  }
}
function safeIsOptional2(schema) {
  try {
    return schema.isOptional();
  } catch (e) {
    return true;
  }
}
function parsePromiseDef2(def, refs) {
  return parseDef2(def.type._def, refs);
}
function parseSetDef2(def, refs) {
  const items = parseDef2(def.valueType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items"]
  });
  const schema = {
    type: "array",
    uniqueItems: true,
    items
  };
  if (def.minSize) {
    schema.minItems = def.minSize.value;
  }
  if (def.maxSize) {
    schema.maxItems = def.maxSize.value;
  }
  return schema;
}
function parseTupleDef2(def, refs) {
  if (def.rest) {
    return {
      type: "array",
      minItems: def.items.length,
      items: def.items.map(
        (x, i) => parseDef2(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "items", `${i}`]
        })
      ).reduce(
        (acc, x) => x === void 0 ? acc : [...acc, x],
        []
      ),
      additionalItems: parseDef2(def.rest._def, {
        ...refs,
        currentPath: [...refs.currentPath, "additionalItems"]
      })
    };
  } else {
    return {
      type: "array",
      minItems: def.items.length,
      maxItems: def.items.length,
      items: def.items.map(
        (x, i) => parseDef2(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "items", `${i}`]
        })
      ).reduce(
        (acc, x) => x === void 0 ? acc : [...acc, x],
        []
      )
    };
  }
}
function parseUndefinedDef2() {
  return {
    not: parseAnyDef2()
  };
}
function parseUnknownDef2() {
  return parseAnyDef2();
}
function parseDef2(def, refs, forceResolution = false) {
  var _a211;
  const seenItem = refs.seen.get(def);
  if (refs.override) {
    const overrideResult = (_a211 = refs.override) == null ? void 0 : _a211.call(
      refs,
      def,
      refs,
      seenItem,
      forceResolution
    );
    if (overrideResult !== ignoreOverride2) {
      return overrideResult;
    }
  }
  if (seenItem && !forceResolution) {
    const seenSchema = get$ref2(seenItem, refs);
    if (seenSchema !== void 0) {
      return seenSchema;
    }
  }
  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
  refs.seen.set(def, newItem);
  const jsonSchemaOrGetter = selectParser2(def, def.typeName, refs);
  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef2(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
  if (jsonSchema22) {
    addMeta2(def, refs, jsonSchema22);
  }
  if (refs.postProcess) {
    const postProcessResult = refs.postProcess(jsonSchema22, def, refs);
    newItem.jsonSchema = jsonSchema22;
    return postProcessResult;
  }
  newItem.jsonSchema = jsonSchema22;
  return jsonSchema22;
}
function lazySchema2(createSchema) {
  let schema;
  return () => {
    if (schema == null) {
      schema = createSchema();
    }
    return schema;
  };
}
function jsonSchema2(jsonSchema22, {
  validate
} = {}) {
  return {
    [schemaSymbol2]: true,
    _type: void 0,
    // should never be used directly
    get jsonSchema() {
      if (typeof jsonSchema22 === "function") {
        jsonSchema22 = jsonSchema22();
      }
      return jsonSchema22;
    },
    validate
  };
}
function isSchema2(value) {
  return typeof value === "object" && value !== null && schemaSymbol2 in value && value[schemaSymbol2] === true && "jsonSchema" in value && "validate" in value;
}
function asSchema2(schema) {
  return schema == null ? jsonSchema2({ properties: {}, additionalProperties: false }) : isSchema2(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema2(schema) : standardSchema2(schema) : schema();
}
function standardSchema2(standardSchema22) {
  return jsonSchema2(
    () => standardSchema22["~standard"].jsonSchema.input({
      target: "draft-07"
    }),
    {
      validate: async (value) => {
        const result = await standardSchema22["~standard"].validate(value);
        return "value" in result ? { success: true, value: result.value } : {
          success: false,
          error: new TypeValidationError3({
            value,
            cause: result.issues
          })
        };
      }
    }
  );
}
function zod3Schema2(zodSchema22, options) {
  var _a211;
  const useReferences = (_a211 = options == null ? void 0 : options.useReferences) != null ? _a211 : false;
  return jsonSchema2(
    // defer json schema creation to avoid unnecessary computation when only validation is needed
    () => zod3ToJsonSchema2(zodSchema22, {
      $refStrategy: useReferences ? "root" : "none"
    }),
    {
      validate: async (value) => {
        const result = await zodSchema22.safeParseAsync(value);
        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
      }
    }
  );
}
function zod4Schema2(zodSchema22, options) {
  var _a211;
  const useReferences = (_a211 = options == null ? void 0 : options.useReferences) != null ? _a211 : false;
  return jsonSchema2(
    // defer json schema creation to avoid unnecessary computation when only validation is needed
    () => addAdditionalPropertiesToJsonSchema2(
      toJSONSchema(zodSchema22, {
        target: "draft-7",
        io: "input",
        reused: useReferences ? "ref" : "inline"
      })
    ),
    {
      validate: async (value) => {
        const result = await safeParseAsync2(zodSchema22, value);
        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
      }
    }
  );
}
function isZod4Schema2(zodSchema22) {
  return "_zod" in zodSchema22;
}
function zodSchema2(zodSchema22, options) {
  if (isZod4Schema2(zodSchema22)) {
    return zod4Schema2(zodSchema22, options);
  } else {
    return zod3Schema2(zodSchema22, options);
  }
}
async function validateTypes3({
  value,
  schema
}) {
  const result = await safeValidateTypes3({ value, schema });
  if (!result.success) {
    throw TypeValidationError3.wrap({ value, cause: result.error });
  }
  return result.value;
}
async function safeValidateTypes3({
  value,
  schema
}) {
  const actualSchema = asSchema2(schema);
  try {
    if (actualSchema.validate == null) {
      return { success: true, value, rawValue: value };
    }
    const result = await actualSchema.validate(value);
    if (result.success) {
      return { success: true, value: result.value, rawValue: value };
    }
    return {
      success: false,
      error: TypeValidationError3.wrap({ value, cause: result.error }),
      rawValue: value
    };
  } catch (error73) {
    return {
      success: false,
      error: TypeValidationError3.wrap({ value, cause: error73 }),
      rawValue: value
    };
  }
}
async function parseJSON3({
  text: text2,
  schema
}) {
  try {
    const value = secureJsonParse3(text2);
    if (schema == null) {
      return value;
    }
    return validateTypes3({ value, schema });
  } catch (error73) {
    if (JSONParseError3.isInstance(error73) || TypeValidationError3.isInstance(error73)) {
      throw error73;
    }
    throw new JSONParseError3({ text: text2, cause: error73 });
  }
}
async function safeParseJSON3({
  text: text2,
  schema
}) {
  try {
    const value = secureJsonParse3(text2);
    if (schema == null) {
      return { success: true, value, rawValue: value };
    }
    return await safeValidateTypes3({ value, schema });
  } catch (error73) {
    return {
      success: false,
      error: JSONParseError3.isInstance(error73) ? error73 : new JSONParseError3({ text: text2, cause: error73 }),
      rawValue: void 0
    };
  }
}
function parseJsonEventStream3({
  stream: stream4,
  schema
}) {
  return stream4.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream2()).pipeThrough(
    new TransformStream({
      async transform({ data }, controller) {
        if (data === "[DONE]") {
          return;
        }
        controller.enqueue(await safeParseJSON3({ text: data, schema }));
      }
    })
  );
}
async function parseProviderOptions2({
  provider,
  providerOptions,
  schema
}) {
  if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
    return void 0;
  }
  const parsedProviderOptions = await safeValidateTypes3({
    value: providerOptions[provider],
    schema
  });
  if (!parsedProviderOptions.success) {
    throw new InvalidArgumentError3({
      argument: "providerOptions",
      message: `invalid ${provider} provider options`,
      cause: parsedProviderOptions.error
    });
  }
  return parsedProviderOptions.value;
}
function tool2(tool22) {
  return tool22;
}
function createProviderToolFactory2({
  id,
  inputSchema
}) {
  return ({
    execute,
    outputSchema: outputSchema2,
    needsApproval,
    toModelOutput,
    onInputStart,
    onInputDelta,
    onInputAvailable,
    ...args
  }) => tool2({
    type: "provider",
    id,
    args,
    inputSchema,
    outputSchema: outputSchema2,
    execute,
    needsApproval,
    toModelOutput,
    onInputStart,
    onInputDelta,
    onInputAvailable
  });
}
function createProviderToolFactoryWithOutputSchema2({
  id,
  inputSchema,
  outputSchema: outputSchema2,
  supportsDeferredResults
}) {
  return ({
    execute,
    needsApproval,
    toModelOutput,
    onInputStart,
    onInputDelta,
    onInputAvailable,
    ...args
  }) => tool2({
    type: "provider",
    id,
    args,
    inputSchema,
    outputSchema: outputSchema2,
    execute,
    needsApproval,
    toModelOutput,
    onInputStart,
    onInputDelta,
    onInputAvailable,
    supportsDeferredResults
  });
}
async function resolve2(value) {
  if (typeof value === "function") {
    value = value();
  }
  return Promise.resolve(value);
}
var btoa4, atob4, name18, marker19, symbol21, _a21, _b19, DownloadError3, createIdGenerator3, generateId3, FETCH_FAILED_ERROR_MESSAGES3, VERSION11, suspectProtoRx3, suspectConstructorRx3, ignoreOverride2, defaultOptions2, getDefaultOptions2, parseCatchDef2, integerDateParser2, isJsonSchema7AllOfType2, emojiRegex3, zodPatterns2, ALPHA_NUMERIC3, primitiveMappings2, asAnyOf2, parseOptionalDef2, parsePipelineDef2, parseReadonlyDef2, selectParser2, getRelativePath2, get$ref2, addMeta2, getRefs2, zod3ToJsonSchema2, schemaSymbol2, getOriginalFetch23, postJsonToApi3, postToApi3, createJsonErrorResponseHandler3, createEventSourceResponseHandler3, createJsonResponseHandler3;
var init_dist17 = __esm({
  "node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/anthropic/node_modules/@ai-sdk/provider-utils/dist/index.mjs"() {
    "use strict";
    init_dist16();
    init_dist16();
    init_dist16();
    init_dist16();
    init_dist16();
    init_dist16();
    init_v42();
    init_v3();
    init_v3();
    init_v3();
    init_stream();
    init_dist16();
    init_dist16();
    init_dist16();
    init_dist9();
    ({ btoa: btoa4, atob: atob4 } = globalThis);
    name18 = "AI_DownloadError";
    marker19 = `vercel.ai.error.${name18}`;
    symbol21 = Symbol.for(marker19);
    DownloadError3 = class extends (_b19 = AISDKError3, _a21 = symbol21, _b19) {
      constructor({
        url: url4,
        statusCode,
        statusText,
        cause,
        message = cause == null ? `Failed to download ${url4}: ${statusCode} ${statusText}` : `Failed to download ${url4}: ${cause}`
      }) {
        super({ name: name18, message, cause });
        this[_a21] = true;
        this.url = url4;
        this.statusCode = statusCode;
        this.statusText = statusText;
      }
      static isInstance(error73) {
        return AISDKError3.hasMarker(error73, marker19);
      }
    };
    createIdGenerator3 = ({
      prefix,
      size = 16,
      alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
      separator = "-"
    } = {}) => {
      const generator = () => {
        const alphabetLength = alphabet.length;
        const chars = new Array(size);
        for (let i = 0; i < size; i++) {
          chars[i] = alphabet[Math.random() * alphabetLength | 0];
        }
        return chars.join("");
      };
      if (prefix == null) {
        return generator;
      }
      if (alphabet.includes(separator)) {
        throw new InvalidArgumentError3({
          argument: "separator",
          message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
        });
      }
      return () => `${prefix}${separator}${generator()}`;
    };
    generateId3 = createIdGenerator3();
    FETCH_FAILED_ERROR_MESSAGES3 = ["fetch failed", "failed to fetch"];
    VERSION11 = true ? "4.0.3" : "0.0.0-test";
    suspectProtoRx3 = /"__proto__"\s*:/;
    suspectConstructorRx3 = /"constructor"\s*:/;
    ignoreOverride2 = /* @__PURE__ */ Symbol(
      "Let zodToJsonSchema decide on which parser to use"
    );
    defaultOptions2 = {
      name: void 0,
      $refStrategy: "root",
      basePath: ["#"],
      effectStrategy: "input",
      pipeStrategy: "all",
      dateStrategy: "format:date-time",
      mapStrategy: "entries",
      removeAdditionalStrategy: "passthrough",
      allowedAdditionalProperties: true,
      rejectedAdditionalProperties: false,
      definitionPath: "definitions",
      strictUnions: false,
      definitions: {},
      errorMessages: false,
      patternStrategy: "escape",
      applyRegexFlags: false,
      emailStrategy: "format:email",
      base64Strategy: "contentEncoding:base64",
      nameStrategy: "ref"
    };
    getDefaultOptions2 = (options) => typeof options === "string" ? {
      ...defaultOptions2,
      name: options
    } : {
      ...defaultOptions2,
      ...options
    };
    parseCatchDef2 = (def, refs) => {
      return parseDef2(def.innerType._def, refs);
    };
    integerDateParser2 = (def) => {
      const res = {
        type: "integer",
        format: "unix-time"
      };
      for (const check3 of def.checks) {
        switch (check3.kind) {
          case "min":
            res.minimum = check3.value;
            break;
          case "max":
            res.maximum = check3.value;
            break;
        }
      }
      return res;
    };
    isJsonSchema7AllOfType2 = (type) => {
      if ("type" in type && type.type === "string") return false;
      return "allOf" in type;
    };
    emojiRegex3 = void 0;
    zodPatterns2 = {
      /**
       * `c` was changed to `[cC]` to replicate /i flag
       */
      cuid: /^[cC][^\s-]{8,}$/,
      cuid2: /^[0-9a-z]+$/,
      ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
      /**
       * `a-z` was added to replicate /i flag
       */
      email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
      /**
       * Constructed a valid Unicode RegExp
       *
       * Lazily instantiate since this type of regex isn't supported
       * in all envs (e.g. React Native).
       *
       * See:
       * https://github.com/colinhacks/zod/issues/2433
       * Fix in Zod:
       * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
       */
      emoji: () => {
        if (emojiRegex3 === void 0) {
          emojiRegex3 = RegExp(
            "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
            "u"
          );
        }
        return emojiRegex3;
      },
      /**
       * Unused
       */
      uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
      /**
       * Unused
       */
      ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
      ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
      /**
       * Unused
       */
      ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
      ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
      base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
      base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
      nanoid: /^[a-zA-Z0-9_-]{21}$/,
      jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
    };
    ALPHA_NUMERIC3 = new Set(
      "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
    );
    primitiveMappings2 = {
      ZodString: "string",
      ZodNumber: "number",
      ZodBigInt: "integer",
      ZodBoolean: "boolean",
      ZodNull: "null"
    };
    asAnyOf2 = (def, refs) => {
      const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
        (x, i) => parseDef2(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "anyOf", `${i}`]
        })
      ).filter(
        (x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
      );
      return anyOf.length ? { anyOf } : void 0;
    };
    parseOptionalDef2 = (def, refs) => {
      var _a211;
      if (refs.currentPath.toString() === ((_a211 = refs.propertyPath) == null ? void 0 : _a211.toString())) {
        return parseDef2(def.innerType._def, refs);
      }
      const innerSchema = parseDef2(def.innerType._def, {
        ...refs,
        currentPath: [...refs.currentPath, "anyOf", "1"]
      });
      return innerSchema ? { anyOf: [{ not: parseAnyDef2() }, innerSchema] } : parseAnyDef2();
    };
    parsePipelineDef2 = (def, refs) => {
      if (refs.pipeStrategy === "input") {
        return parseDef2(def.in._def, refs);
      } else if (refs.pipeStrategy === "output") {
        return parseDef2(def.out._def, refs);
      }
      const a = parseDef2(def.in._def, {
        ...refs,
        currentPath: [...refs.currentPath, "allOf", "0"]
      });
      const b = parseDef2(def.out._def, {
        ...refs,
        currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
      });
      return {
        allOf: [a, b].filter((x) => x !== void 0)
      };
    };
    parseReadonlyDef2 = (def, refs) => {
      return parseDef2(def.innerType._def, refs);
    };
    selectParser2 = (def, typeName, refs) => {
      switch (typeName) {
        case ZodFirstPartyTypeKind2.ZodString:
          return parseStringDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodNumber:
          return parseNumberDef2(def);
        case ZodFirstPartyTypeKind2.ZodObject:
          return parseObjectDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodBigInt:
          return parseBigintDef2(def);
        case ZodFirstPartyTypeKind2.ZodBoolean:
          return parseBooleanDef2();
        case ZodFirstPartyTypeKind2.ZodDate:
          return parseDateDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodUndefined:
          return parseUndefinedDef2();
        case ZodFirstPartyTypeKind2.ZodNull:
          return parseNullDef2();
        case ZodFirstPartyTypeKind2.ZodArray:
          return parseArrayDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodUnion:
        case ZodFirstPartyTypeKind2.ZodDiscriminatedUnion:
          return parseUnionDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodIntersection:
          return parseIntersectionDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodTuple:
          return parseTupleDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodRecord:
          return parseRecordDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodLiteral:
          return parseLiteralDef2(def);
        case ZodFirstPartyTypeKind2.ZodEnum:
          return parseEnumDef2(def);
        case ZodFirstPartyTypeKind2.ZodNativeEnum:
          return parseNativeEnumDef2(def);
        case ZodFirstPartyTypeKind2.ZodNullable:
          return parseNullableDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodOptional:
          return parseOptionalDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodMap:
          return parseMapDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodSet:
          return parseSetDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodLazy:
          return () => def.getter()._def;
        case ZodFirstPartyTypeKind2.ZodPromise:
          return parsePromiseDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodNaN:
        case ZodFirstPartyTypeKind2.ZodNever:
          return parseNeverDef2();
        case ZodFirstPartyTypeKind2.ZodEffects:
          return parseEffectsDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodAny:
          return parseAnyDef2();
        case ZodFirstPartyTypeKind2.ZodUnknown:
          return parseUnknownDef2();
        case ZodFirstPartyTypeKind2.ZodDefault:
          return parseDefaultDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodBranded:
          return parseBrandedDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodReadonly:
          return parseReadonlyDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodCatch:
          return parseCatchDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodPipeline:
          return parsePipelineDef2(def, refs);
        case ZodFirstPartyTypeKind2.ZodFunction:
        case ZodFirstPartyTypeKind2.ZodVoid:
        case ZodFirstPartyTypeKind2.ZodSymbol:
          return void 0;
        default:
          return /* @__PURE__ */ ((_) => void 0)(typeName);
      }
    };
    getRelativePath2 = (pathA, pathB) => {
      let i = 0;
      for (; i < pathA.length && i < pathB.length; i++) {
        if (pathA[i] !== pathB[i]) break;
      }
      return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
    };
    get$ref2 = (item, refs) => {
      switch (refs.$refStrategy) {
        case "root":
          return { $ref: item.path.join("/") };
        case "relative":
          return { $ref: getRelativePath2(refs.currentPath, item.path) };
        case "none":
        case "seen": {
          if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
            console.warn(
              `Recursive reference detected at ${refs.currentPath.join(
                "/"
              )}! Defaulting to any`
            );
            return parseAnyDef2();
          }
          return refs.$refStrategy === "seen" ? parseAnyDef2() : void 0;
        }
      }
    };
    addMeta2 = (def, refs, jsonSchema22) => {
      if (def.description) {
        jsonSchema22.description = def.description;
      }
      return jsonSchema22;
    };
    getRefs2 = (options) => {
      const _options = getDefaultOptions2(options);
      const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
      return {
        ..._options,
        currentPath,
        propertyPath: void 0,
        seen: new Map(
          Object.entries(_options.definitions).map(([name28, def]) => [
            def._def,
            {
              def: def._def,
              path: [..._options.basePath, _options.definitionPath, name28],
              // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
              jsonSchema: void 0
            }
          ])
        )
      };
    };
    zod3ToJsonSchema2 = (schema, options) => {
      var _a211;
      const refs = getRefs2(options);
      let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
        (acc, [name37, schema2]) => {
          var _a37;
          return {
            ...acc,
            [name37]: (_a37 = parseDef2(
              schema2._def,
              {
                ...refs,
                currentPath: [...refs.basePath, refs.definitionPath, name37]
              },
              true
            )) != null ? _a37 : parseAnyDef2()
          };
        },
        {}
      ) : void 0;
      const name28 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
      const main = (_a211 = parseDef2(
        schema._def,
        name28 === void 0 ? refs : {
          ...refs,
          currentPath: [...refs.basePath, refs.definitionPath, name28]
        },
        false
      )) != null ? _a211 : parseAnyDef2();
      const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
      if (title !== void 0) {
        main.title = title;
      }
      const combined = name28 === void 0 ? definitions ? {
        ...main,
        [refs.definitionPath]: definitions
      } : main : {
        $ref: [
          ...refs.$refStrategy === "relative" ? [] : refs.basePath,
          refs.definitionPath,
          name28
        ].join("/"),
        [refs.definitionPath]: {
          ...definitions,
          [name28]: main
        }
      };
      combined.$schema = "http://json-schema.org/draft-07/schema#";
      return combined;
    };
    schemaSymbol2 = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
    getOriginalFetch23 = () => globalThis.fetch;
    postJsonToApi3 = async ({
      url: url4,
      headers,
      body,
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    }) => postToApi3({
      url: url4,
      headers: {
        "Content-Type": "application/json",
        ...headers
      },
      body: {
        content: JSON.stringify(body),
        values: body
      },
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    });
    postToApi3 = async ({
      url: url4,
      headers = {},
      body,
      successfulResponseHandler,
      failedResponseHandler,
      abortSignal,
      fetch: fetch2 = getOriginalFetch23()
    }) => {
      try {
        const response = await fetch2(url4, {
          method: "POST",
          headers: withUserAgentSuffix3(
            headers,
            `ai-sdk/provider-utils/${VERSION11}`,
            getRuntimeEnvironmentUserAgent3()
          ),
          body: body.content,
          signal: abortSignal
        });
        const responseHeaders = extractResponseHeaders3(response);
        if (!response.ok) {
          let errorInformation;
          try {
            errorInformation = await failedResponseHandler({
              response,
              url: url4,
              requestBodyValues: body.values
            });
          } catch (error73) {
            if (isAbortError3(error73) || APICallError3.isInstance(error73)) {
              throw error73;
            }
            throw new APICallError3({
              message: "Failed to process error response",
              cause: error73,
              statusCode: response.status,
              url: url4,
              responseHeaders,
              requestBodyValues: body.values
            });
          }
          throw errorInformation.value;
        }
        try {
          return await successfulResponseHandler({
            response,
            url: url4,
            requestBodyValues: body.values
          });
        } catch (error73) {
          if (error73 instanceof Error) {
            if (isAbortError3(error73) || APICallError3.isInstance(error73)) {
              throw error73;
            }
          }
          throw new APICallError3({
            message: "Failed to process successful response",
            cause: error73,
            statusCode: response.status,
            url: url4,
            responseHeaders,
            requestBodyValues: body.values
          });
        }
      } catch (error73) {
        throw handleFetchError3({ error: error73, url: url4, requestBodyValues: body.values });
      }
    };
    createJsonErrorResponseHandler3 = ({
      errorSchema,
      errorToMessage,
      isRetryable
    }) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const responseHeaders = extractResponseHeaders3(response);
      if (responseBody.trim() === "") {
        return {
          responseHeaders,
          value: new APICallError3({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
      try {
        const parsedError = await parseJSON3({
          text: responseBody,
          schema: errorSchema
        });
        return {
          responseHeaders,
          value: new APICallError3({
            message: errorToMessage(parsedError),
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            data: parsedError,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
          })
        };
      } catch (parseError) {
        return {
          responseHeaders,
          value: new APICallError3({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
    };
    createEventSourceResponseHandler3 = (chunkSchema2) => async ({ response }) => {
      const responseHeaders = extractResponseHeaders3(response);
      if (response.body == null) {
        throw new EmptyResponseBodyError3({});
      }
      return {
        responseHeaders,
        value: parseJsonEventStream3({
          stream: response.body,
          schema: chunkSchema2
        })
      };
    };
    createJsonResponseHandler3 = (responseSchema2) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const parsedResult = await safeParseJSON3({
        text: responseBody,
        schema: responseSchema2
      });
      const responseHeaders = extractResponseHeaders3(response);
      if (!parsedResult.success) {
        throw new APICallError3({
          message: "Invalid JSON response",
          cause: parsedResult.error,
          statusCode: response.status,
          responseHeaders,
          responseBody,
          url: url4,
          requestBodyValues
        });
      }
      return {
        responseHeaders,
        value: parsedResult.value,
        rawValue: parsedResult.rawValue
      };
    };
  }
});

// node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/anthropic/dist/internal/index.mjs
function getCacheControl2(providerMetadata) {
  var _a31;
  const anthropic2 = providerMetadata == null ? void 0 : providerMetadata.anthropic;
  const cacheControlValue = (_a31 = anthropic2 == null ? void 0 : anthropic2.cacheControl) != null ? _a31 : anthropic2 == null ? void 0 : anthropic2.cache_control;
  return cacheControlValue;
}
async function prepareTools6({
  tools,
  toolChoice,
  disableParallelToolUse,
  cacheControlValidator,
  supportsStructuredOutput
}) {
  var _a31;
  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
  const toolWarnings = [];
  const betas = /* @__PURE__ */ new Set();
  const validator2 = cacheControlValidator || new CacheControlValidator2();
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings, betas };
  }
  const anthropicTools2 = [];
  for (const tool3 of tools) {
    switch (tool3.type) {
      case "function": {
        const cacheControl = validator2.getCacheControl(tool3.providerOptions, {
          type: "tool definition",
          canCache: true
        });
        const anthropicOptions = (_a31 = tool3.providerOptions) == null ? void 0 : _a31.anthropic;
        const deferLoading = anthropicOptions == null ? void 0 : anthropicOptions.deferLoading;
        const allowedCallers = anthropicOptions == null ? void 0 : anthropicOptions.allowedCallers;
        anthropicTools2.push({
          name: tool3.name,
          description: tool3.description,
          input_schema: tool3.inputSchema,
          cache_control: cacheControl,
          ...supportsStructuredOutput === true && tool3.strict != null ? { strict: tool3.strict } : {},
          ...deferLoading != null ? { defer_loading: deferLoading } : {},
          ...allowedCallers != null ? { allowed_callers: allowedCallers } : {},
          ...tool3.inputExamples != null ? {
            input_examples: tool3.inputExamples.map(
              (example) => example.input
            )
          } : {}
        });
        if (supportsStructuredOutput === true) {
          betas.add("structured-outputs-2025-11-13");
        }
        if (tool3.inputExamples != null || allowedCallers != null) {
          betas.add("advanced-tool-use-2025-11-20");
        }
        break;
      }
      case "provider": {
        switch (tool3.id) {
          case "anthropic.code_execution_20250522": {
            betas.add("code-execution-2025-05-22");
            anthropicTools2.push({
              type: "code_execution_20250522",
              name: "code_execution",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.code_execution_20250825": {
            betas.add("code-execution-2025-08-25");
            anthropicTools2.push({
              type: "code_execution_20250825",
              name: "code_execution"
            });
            break;
          }
          case "anthropic.computer_20250124": {
            betas.add("computer-use-2025-01-24");
            anthropicTools2.push({
              name: "computer",
              type: "computer_20250124",
              display_width_px: tool3.args.displayWidthPx,
              display_height_px: tool3.args.displayHeightPx,
              display_number: tool3.args.displayNumber,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.computer_20241022": {
            betas.add("computer-use-2024-10-22");
            anthropicTools2.push({
              name: "computer",
              type: "computer_20241022",
              display_width_px: tool3.args.displayWidthPx,
              display_height_px: tool3.args.displayHeightPx,
              display_number: tool3.args.displayNumber,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.text_editor_20250124": {
            betas.add("computer-use-2025-01-24");
            anthropicTools2.push({
              name: "str_replace_editor",
              type: "text_editor_20250124",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.text_editor_20241022": {
            betas.add("computer-use-2024-10-22");
            anthropicTools2.push({
              name: "str_replace_editor",
              type: "text_editor_20241022",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.text_editor_20250429": {
            betas.add("computer-use-2025-01-24");
            anthropicTools2.push({
              name: "str_replace_based_edit_tool",
              type: "text_editor_20250429",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.text_editor_20250728": {
            const args = await validateTypes3({
              value: tool3.args,
              schema: textEditor_20250728ArgsSchema2
            });
            anthropicTools2.push({
              name: "str_replace_based_edit_tool",
              type: "text_editor_20250728",
              max_characters: args.maxCharacters,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.bash_20250124": {
            betas.add("computer-use-2025-01-24");
            anthropicTools2.push({
              name: "bash",
              type: "bash_20250124",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.bash_20241022": {
            betas.add("computer-use-2024-10-22");
            anthropicTools2.push({
              name: "bash",
              type: "bash_20241022",
              cache_control: void 0
            });
            break;
          }
          case "anthropic.memory_20250818": {
            betas.add("context-management-2025-06-27");
            anthropicTools2.push({
              name: "memory",
              type: "memory_20250818"
            });
            break;
          }
          case "anthropic.web_fetch_20250910": {
            betas.add("web-fetch-2025-09-10");
            const args = await validateTypes3({
              value: tool3.args,
              schema: webFetch_20250910ArgsSchema2
            });
            anthropicTools2.push({
              type: "web_fetch_20250910",
              name: "web_fetch",
              max_uses: args.maxUses,
              allowed_domains: args.allowedDomains,
              blocked_domains: args.blockedDomains,
              citations: args.citations,
              max_content_tokens: args.maxContentTokens,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.web_search_20250305": {
            const args = await validateTypes3({
              value: tool3.args,
              schema: webSearch_20250305ArgsSchema2
            });
            anthropicTools2.push({
              type: "web_search_20250305",
              name: "web_search",
              max_uses: args.maxUses,
              allowed_domains: args.allowedDomains,
              blocked_domains: args.blockedDomains,
              user_location: args.userLocation,
              cache_control: void 0
            });
            break;
          }
          case "anthropic.tool_search_regex_20251119": {
            betas.add("advanced-tool-use-2025-11-20");
            anthropicTools2.push({
              type: "tool_search_tool_regex_20251119",
              name: "tool_search_tool_regex"
            });
            break;
          }
          case "anthropic.tool_search_bm25_20251119": {
            betas.add("advanced-tool-use-2025-11-20");
            anthropicTools2.push({
              type: "tool_search_tool_bm25_20251119",
              name: "tool_search_tool_bm25"
            });
            break;
          }
          default: {
            toolWarnings.push({
              type: "unsupported",
              feature: `provider-defined tool ${tool3.id}`
            });
            break;
          }
        }
        break;
      }
      default: {
        toolWarnings.push({
          type: "unsupported",
          feature: `tool ${tool3}`
        });
        break;
      }
    }
  }
  if (toolChoice == null) {
    return {
      tools: anthropicTools2,
      toolChoice: disableParallelToolUse ? { type: "auto", disable_parallel_tool_use: disableParallelToolUse } : void 0,
      toolWarnings,
      betas
    };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
      return {
        tools: anthropicTools2,
        toolChoice: {
          type: "auto",
          disable_parallel_tool_use: disableParallelToolUse
        },
        toolWarnings,
        betas
      };
    case "required":
      return {
        tools: anthropicTools2,
        toolChoice: {
          type: "any",
          disable_parallel_tool_use: disableParallelToolUse
        },
        toolWarnings,
        betas
      };
    case "none":
      return { tools: void 0, toolChoice: void 0, toolWarnings, betas };
    case "tool":
      return {
        tools: anthropicTools2,
        toolChoice: {
          type: "tool",
          name: toolChoice.toolName,
          disable_parallel_tool_use: disableParallelToolUse
        },
        toolWarnings,
        betas
      };
    default: {
      const _exhaustiveCheck = type;
      throw new UnsupportedFunctionalityError3({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
function convertAnthropicMessagesUsage2(usage) {
  var _a31, _b27;
  const inputTokens = usage.input_tokens;
  const outputTokens = usage.output_tokens;
  const cacheCreationTokens = (_a31 = usage.cache_creation_input_tokens) != null ? _a31 : 0;
  const cacheReadTokens = (_b27 = usage.cache_read_input_tokens) != null ? _b27 : 0;
  return {
    inputTokens: {
      total: inputTokens + cacheCreationTokens + cacheReadTokens,
      noCache: inputTokens,
      cacheRead: cacheReadTokens,
      cacheWrite: cacheCreationTokens
    },
    outputTokens: {
      total: outputTokens,
      text: void 0,
      reasoning: void 0
    },
    raw: usage
  };
}
function convertToString2(data) {
  if (typeof data === "string") {
    return Buffer.from(data, "base64").toString("utf-8");
  }
  if (data instanceof Uint8Array) {
    return new TextDecoder().decode(data);
  }
  if (data instanceof URL) {
    throw new UnsupportedFunctionalityError3({
      functionality: "URL-based text documents are not supported for citations"
    });
  }
  throw new UnsupportedFunctionalityError3({
    functionality: `unsupported data type for text documents: ${typeof data}`
  });
}
async function convertToAnthropicMessagesPrompt2({
  prompt,
  sendReasoning,
  warnings,
  cacheControlValidator,
  toolNameMapping
}) {
  var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
  const betas = /* @__PURE__ */ new Set();
  const blocks = groupIntoBlocks2(prompt);
  const validator2 = cacheControlValidator || new CacheControlValidator2();
  let system = void 0;
  const messages = [];
  async function shouldEnableCitations(providerMetadata) {
    var _a211, _b28;
    const anthropicOptions = await parseProviderOptions2({
      provider: "anthropic",
      providerOptions: providerMetadata,
      schema: anthropicFilePartProviderOptions2
    });
    return (_b28 = (_a211 = anthropicOptions == null ? void 0 : anthropicOptions.citations) == null ? void 0 : _a211.enabled) != null ? _b28 : false;
  }
  async function getDocumentMetadata(providerMetadata) {
    const anthropicOptions = await parseProviderOptions2({
      provider: "anthropic",
      providerOptions: providerMetadata,
      schema: anthropicFilePartProviderOptions2
    });
    return {
      title: anthropicOptions == null ? void 0 : anthropicOptions.title,
      context: anthropicOptions == null ? void 0 : anthropicOptions.context
    };
  }
  for (let i = 0; i < blocks.length; i++) {
    const block = blocks[i];
    const isLastBlock = i === blocks.length - 1;
    const type = block.type;
    switch (type) {
      case "system": {
        if (system != null) {
          throw new UnsupportedFunctionalityError3({
            functionality: "Multiple system messages that are separated by user/assistant messages"
          });
        }
        system = block.messages.map(({ content, providerOptions }) => ({
          type: "text",
          text: content,
          cache_control: validator2.getCacheControl(providerOptions, {
            type: "system message",
            canCache: true
          })
        }));
        break;
      }
      case "user": {
        const anthropicContent = [];
        for (const message of block.messages) {
          const { role, content } = message;
          switch (role) {
            case "user": {
              for (let j = 0; j < content.length; j++) {
                const part = content[j];
                const isLastPart = j === content.length - 1;
                const cacheControl = (_a31 = validator2.getCacheControl(part.providerOptions, {
                  type: "user message part",
                  canCache: true
                })) != null ? _a31 : isLastPart ? validator2.getCacheControl(message.providerOptions, {
                  type: "user message",
                  canCache: true
                }) : void 0;
                switch (part.type) {
                  case "text": {
                    anthropicContent.push({
                      type: "text",
                      text: part.text,
                      cache_control: cacheControl
                    });
                    break;
                  }
                  case "file": {
                    if (part.mediaType.startsWith("image/")) {
                      anthropicContent.push({
                        type: "image",
                        source: part.data instanceof URL ? {
                          type: "url",
                          url: part.data.toString()
                        } : {
                          type: "base64",
                          media_type: part.mediaType === "image/*" ? "image/jpeg" : part.mediaType,
                          data: convertToBase642(part.data)
                        },
                        cache_control: cacheControl
                      });
                    } else if (part.mediaType === "application/pdf") {
                      betas.add("pdfs-2024-09-25");
                      const enableCitations = await shouldEnableCitations(
                        part.providerOptions
                      );
                      const metadata = await getDocumentMetadata(
                        part.providerOptions
                      );
                      anthropicContent.push({
                        type: "document",
                        source: part.data instanceof URL ? {
                          type: "url",
                          url: part.data.toString()
                        } : {
                          type: "base64",
                          media_type: "application/pdf",
                          data: convertToBase642(part.data)
                        },
                        title: (_b27 = metadata.title) != null ? _b27 : part.filename,
                        ...metadata.context && { context: metadata.context },
                        ...enableCitations && {
                          citations: { enabled: true }
                        },
                        cache_control: cacheControl
                      });
                    } else if (part.mediaType === "text/plain") {
                      const enableCitations = await shouldEnableCitations(
                        part.providerOptions
                      );
                      const metadata = await getDocumentMetadata(
                        part.providerOptions
                      );
                      anthropicContent.push({
                        type: "document",
                        source: part.data instanceof URL ? {
                          type: "url",
                          url: part.data.toString()
                        } : {
                          type: "text",
                          media_type: "text/plain",
                          data: convertToString2(part.data)
                        },
                        title: (_c = metadata.title) != null ? _c : part.filename,
                        ...metadata.context && { context: metadata.context },
                        ...enableCitations && {
                          citations: { enabled: true }
                        },
                        cache_control: cacheControl
                      });
                    } else {
                      throw new UnsupportedFunctionalityError3({
                        functionality: `media type: ${part.mediaType}`
                      });
                    }
                    break;
                  }
                }
              }
              break;
            }
            case "tool": {
              for (let i2 = 0; i2 < content.length; i2++) {
                const part = content[i2];
                if (part.type === "tool-approval-response") {
                  continue;
                }
                const isLastPart = i2 === content.length - 1;
                const cacheControl = (_d = validator2.getCacheControl(part.providerOptions, {
                  type: "tool result part",
                  canCache: true
                })) != null ? _d : isLastPart ? validator2.getCacheControl(message.providerOptions, {
                  type: "tool result message",
                  canCache: true
                }) : void 0;
                const output = part.output;
                let contentValue;
                switch (output.type) {
                  case "content":
                    contentValue = output.value.map((contentPart) => {
                      switch (contentPart.type) {
                        case "text":
                          return {
                            type: "text",
                            text: contentPart.text
                          };
                        case "image-data": {
                          return {
                            type: "image",
                            source: {
                              type: "base64",
                              media_type: contentPart.mediaType,
                              data: contentPart.data
                            }
                          };
                        }
                        case "image-url": {
                          return {
                            type: "image",
                            source: {
                              type: "url",
                              url: contentPart.url
                            }
                          };
                        }
                        case "file-url": {
                          return {
                            type: "document",
                            source: {
                              type: "url",
                              url: contentPart.url
                            }
                          };
                        }
                        case "file-data": {
                          if (contentPart.mediaType === "application/pdf") {
                            betas.add("pdfs-2024-09-25");
                            return {
                              type: "document",
                              source: {
                                type: "base64",
                                media_type: contentPart.mediaType,
                                data: contentPart.data
                              }
                            };
                          }
                          warnings.push({
                            type: "other",
                            message: `unsupported tool content part type: ${contentPart.type} with media type: ${contentPart.mediaType}`
                          });
                          return void 0;
                        }
                        default: {
                          warnings.push({
                            type: "other",
                            message: `unsupported tool content part type: ${contentPart.type}`
                          });
                          return void 0;
                        }
                      }
                    }).filter(isNonNullable2);
                    break;
                  case "text":
                  case "error-text":
                    contentValue = output.value;
                    break;
                  case "execution-denied":
                    contentValue = (_e = output.reason) != null ? _e : "Tool execution denied.";
                    break;
                  case "json":
                  case "error-json":
                  default:
                    contentValue = JSON.stringify(output.value);
                    break;
                }
                anthropicContent.push({
                  type: "tool_result",
                  tool_use_id: part.toolCallId,
                  content: contentValue,
                  is_error: output.type === "error-text" || output.type === "error-json" ? true : void 0,
                  cache_control: cacheControl
                });
              }
              break;
            }
            default: {
              const _exhaustiveCheck = role;
              throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
            }
          }
        }
        messages.push({ role: "user", content: anthropicContent });
        break;
      }
      case "assistant": {
        const anthropicContent = [];
        const mcpToolUseIds = /* @__PURE__ */ new Set();
        for (let j = 0; j < block.messages.length; j++) {
          const message = block.messages[j];
          const isLastMessage = j === block.messages.length - 1;
          const { content } = message;
          for (let k = 0; k < content.length; k++) {
            const part = content[k];
            const isLastContentPart = k === content.length - 1;
            const cacheControl = (_f = validator2.getCacheControl(part.providerOptions, {
              type: "assistant message part",
              canCache: true
            })) != null ? _f : isLastContentPart ? validator2.getCacheControl(message.providerOptions, {
              type: "assistant message",
              canCache: true
            }) : void 0;
            switch (part.type) {
              case "text": {
                anthropicContent.push({
                  type: "text",
                  text: (
                    // trim the last text part if it's the last message in the block
                    // because Anthropic does not allow trailing whitespace
                    // in pre-filled assistant responses
                    isLastBlock && isLastMessage && isLastContentPart ? part.text.trim() : part.text
                  ),
                  cache_control: cacheControl
                });
                break;
              }
              case "reasoning": {
                if (sendReasoning) {
                  const reasoningMetadata = await parseProviderOptions2({
                    provider: "anthropic",
                    providerOptions: part.providerOptions,
                    schema: anthropicReasoningMetadataSchema2
                  });
                  if (reasoningMetadata != null) {
                    if (reasoningMetadata.signature != null) {
                      validator2.getCacheControl(part.providerOptions, {
                        type: "thinking block",
                        canCache: false
                      });
                      anthropicContent.push({
                        type: "thinking",
                        thinking: part.text,
                        signature: reasoningMetadata.signature
                      });
                    } else if (reasoningMetadata.redactedData != null) {
                      validator2.getCacheControl(part.providerOptions, {
                        type: "redacted thinking block",
                        canCache: false
                      });
                      anthropicContent.push({
                        type: "redacted_thinking",
                        data: reasoningMetadata.redactedData
                      });
                    } else {
                      warnings.push({
                        type: "other",
                        message: "unsupported reasoning metadata"
                      });
                    }
                  } else {
                    warnings.push({
                      type: "other",
                      message: "unsupported reasoning metadata"
                    });
                  }
                } else {
                  warnings.push({
                    type: "other",
                    message: "sending reasoning content is disabled for this model"
                  });
                }
                break;
              }
              case "tool-call": {
                if (part.providerExecuted) {
                  const providerToolName = toolNameMapping.toProviderToolName(
                    part.toolName
                  );
                  const isMcpToolUse = ((_h = (_g = part.providerOptions) == null ? void 0 : _g.anthropic) == null ? void 0 : _h.type) === "mcp-tool-use";
                  if (isMcpToolUse) {
                    mcpToolUseIds.add(part.toolCallId);
                    const serverName = (_j = (_i = part.providerOptions) == null ? void 0 : _i.anthropic) == null ? void 0 : _j.serverName;
                    if (serverName == null || typeof serverName !== "string") {
                      warnings.push({
                        type: "other",
                        message: "mcp tool use server name is required and must be a string"
                      });
                      break;
                    }
                    anthropicContent.push({
                      type: "mcp_tool_use",
                      id: part.toolCallId,
                      name: part.toolName,
                      input: part.input,
                      server_name: serverName,
                      cache_control: cacheControl
                    });
                  } else if (
                    // code execution 20250825:
                    providerToolName === "code_execution" && part.input != null && typeof part.input === "object" && "type" in part.input && typeof part.input.type === "string" && (part.input.type === "bash_code_execution" || part.input.type === "text_editor_code_execution")
                  ) {
                    anthropicContent.push({
                      type: "server_tool_use",
                      id: part.toolCallId,
                      name: part.input.type,
                      // map back to subtool name
                      input: part.input,
                      cache_control: cacheControl
                    });
                  } else if (
                    // code execution 20250825 programmatic tool calling:
                    // Strip the fake 'programmatic-tool-call' type before sending to Anthropic
                    providerToolName === "code_execution" && part.input != null && typeof part.input === "object" && "type" in part.input && part.input.type === "programmatic-tool-call"
                  ) {
                    const { type: _, ...inputWithoutType } = part.input;
                    anthropicContent.push({
                      type: "server_tool_use",
                      id: part.toolCallId,
                      name: "code_execution",
                      input: inputWithoutType,
                      cache_control: cacheControl
                    });
                  } else {
                    if (providerToolName === "code_execution" || // code execution 20250522
                    providerToolName === "web_fetch" || providerToolName === "web_search") {
                      anthropicContent.push({
                        type: "server_tool_use",
                        id: part.toolCallId,
                        name: providerToolName,
                        input: part.input,
                        cache_control: cacheControl
                      });
                    } else if (providerToolName === "tool_search_tool_regex" || providerToolName === "tool_search_tool_bm25") {
                      anthropicContent.push({
                        type: "server_tool_use",
                        id: part.toolCallId,
                        name: providerToolName,
                        input: part.input,
                        cache_control: cacheControl
                      });
                    } else {
                      warnings.push({
                        type: "other",
                        message: `provider executed tool call for tool ${part.toolName} is not supported`
                      });
                    }
                  }
                  break;
                }
                const callerOptions = (_k = part.providerOptions) == null ? void 0 : _k.anthropic;
                const caller = (callerOptions == null ? void 0 : callerOptions.caller) ? callerOptions.caller.type === "code_execution_20250825" && callerOptions.caller.toolId ? {
                  type: "code_execution_20250825",
                  tool_id: callerOptions.caller.toolId
                } : callerOptions.caller.type === "direct" ? { type: "direct" } : void 0 : void 0;
                anthropicContent.push({
                  type: "tool_use",
                  id: part.toolCallId,
                  name: part.toolName,
                  input: part.input,
                  ...caller && { caller },
                  cache_control: cacheControl
                });
                break;
              }
              case "tool-result": {
                const providerToolName = toolNameMapping.toProviderToolName(
                  part.toolName
                );
                if (mcpToolUseIds.has(part.toolCallId)) {
                  const output = part.output;
                  if (output.type !== "json" && output.type !== "error-json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  anthropicContent.push({
                    type: "mcp_tool_result",
                    tool_use_id: part.toolCallId,
                    is_error: output.type === "error-json",
                    content: output.value,
                    cache_control: cacheControl
                  });
                } else if (providerToolName === "code_execution") {
                  const output = part.output;
                  if (output.type === "error-text" || output.type === "error-json") {
                    let errorInfo = {};
                    try {
                      if (typeof output.value === "string") {
                        errorInfo = JSON.parse(output.value);
                      } else if (typeof output.value === "object" && output.value !== null) {
                        errorInfo = output.value;
                      }
                    } catch (e) {
                    }
                    if (errorInfo.type === "code_execution_tool_result_error") {
                      anthropicContent.push({
                        type: "code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        content: {
                          type: "code_execution_tool_result_error",
                          error_code: (_l = errorInfo.errorCode) != null ? _l : "unknown"
                        },
                        cache_control: cacheControl
                      });
                    } else {
                      anthropicContent.push({
                        type: "bash_code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        cache_control: cacheControl,
                        content: {
                          type: "bash_code_execution_tool_result_error",
                          error_code: (_m = errorInfo.errorCode) != null ? _m : "unknown"
                        }
                      });
                    }
                    break;
                  }
                  if (output.type !== "json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  if (output.value == null || typeof output.value !== "object" || !("type" in output.value) || typeof output.value.type !== "string") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output value is not a valid code execution result for tool ${part.toolName}`
                    });
                    break;
                  }
                  if (output.value.type === "code_execution_result") {
                    const codeExecutionOutput = await validateTypes3({
                      value: output.value,
                      schema: codeExecution_20250522OutputSchema2
                    });
                    anthropicContent.push({
                      type: "code_execution_tool_result",
                      tool_use_id: part.toolCallId,
                      content: {
                        type: codeExecutionOutput.type,
                        stdout: codeExecutionOutput.stdout,
                        stderr: codeExecutionOutput.stderr,
                        return_code: codeExecutionOutput.return_code,
                        content: (_n = codeExecutionOutput.content) != null ? _n : []
                      },
                      cache_control: cacheControl
                    });
                  } else {
                    const codeExecutionOutput = await validateTypes3({
                      value: output.value,
                      schema: codeExecution_20250825OutputSchema2
                    });
                    if (codeExecutionOutput.type === "code_execution_result") {
                      anthropicContent.push({
                        type: "code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        content: {
                          type: codeExecutionOutput.type,
                          stdout: codeExecutionOutput.stdout,
                          stderr: codeExecutionOutput.stderr,
                          return_code: codeExecutionOutput.return_code,
                          content: (_o = codeExecutionOutput.content) != null ? _o : []
                        },
                        cache_control: cacheControl
                      });
                    } else if (codeExecutionOutput.type === "bash_code_execution_result" || codeExecutionOutput.type === "bash_code_execution_tool_result_error") {
                      anthropicContent.push({
                        type: "bash_code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        cache_control: cacheControl,
                        content: codeExecutionOutput
                      });
                    } else {
                      anthropicContent.push({
                        type: "text_editor_code_execution_tool_result",
                        tool_use_id: part.toolCallId,
                        cache_control: cacheControl,
                        content: codeExecutionOutput
                      });
                    }
                  }
                  break;
                }
                if (providerToolName === "web_fetch") {
                  const output = part.output;
                  if (output.type === "error-json") {
                    const errorValue = JSON.parse(output.value);
                    anthropicContent.push({
                      type: "web_fetch_tool_result",
                      tool_use_id: part.toolCallId,
                      content: {
                        type: "web_fetch_tool_result_error",
                        error_code: errorValue.errorCode
                      },
                      cache_control: cacheControl
                    });
                    break;
                  }
                  if (output.type !== "json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  const webFetchOutput = await validateTypes3({
                    value: output.value,
                    schema: webFetch_20250910OutputSchema2
                  });
                  anthropicContent.push({
                    type: "web_fetch_tool_result",
                    tool_use_id: part.toolCallId,
                    content: {
                      type: "web_fetch_result",
                      url: webFetchOutput.url,
                      retrieved_at: webFetchOutput.retrievedAt,
                      content: {
                        type: "document",
                        title: webFetchOutput.content.title,
                        citations: webFetchOutput.content.citations,
                        source: {
                          type: webFetchOutput.content.source.type,
                          media_type: webFetchOutput.content.source.mediaType,
                          data: webFetchOutput.content.source.data
                        }
                      }
                    },
                    cache_control: cacheControl
                  });
                  break;
                }
                if (providerToolName === "web_search") {
                  const output = part.output;
                  if (output.type !== "json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  const webSearchOutput = await validateTypes3({
                    value: output.value,
                    schema: webSearch_20250305OutputSchema2
                  });
                  anthropicContent.push({
                    type: "web_search_tool_result",
                    tool_use_id: part.toolCallId,
                    content: webSearchOutput.map((result) => ({
                      url: result.url,
                      title: result.title,
                      page_age: result.pageAge,
                      encrypted_content: result.encryptedContent,
                      type: result.type
                    })),
                    cache_control: cacheControl
                  });
                  break;
                }
                if (providerToolName === "tool_search_tool_regex" || providerToolName === "tool_search_tool_bm25") {
                  const output = part.output;
                  if (output.type !== "json") {
                    warnings.push({
                      type: "other",
                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
                    });
                    break;
                  }
                  const toolSearchOutput = await validateTypes3({
                    value: output.value,
                    schema: toolSearchRegex_20251119OutputSchema2
                  });
                  const toolReferences = toolSearchOutput.map((ref) => ({
                    type: "tool_reference",
                    tool_name: ref.toolName
                  }));
                  anthropicContent.push({
                    type: "tool_search_tool_result",
                    tool_use_id: part.toolCallId,
                    content: {
                      type: "tool_search_tool_search_result",
                      tool_references: toolReferences
                    },
                    cache_control: cacheControl
                  });
                  break;
                }
                warnings.push({
                  type: "other",
                  message: `provider executed tool result for tool ${part.toolName} is not supported`
                });
                break;
              }
            }
          }
        }
        messages.push({ role: "assistant", content: anthropicContent });
        break;
      }
      default: {
        const _exhaustiveCheck = type;
        throw new Error(`content type: ${_exhaustiveCheck}`);
      }
    }
  }
  return {
    prompt: { system, messages },
    betas
  };
}
function groupIntoBlocks2(prompt) {
  const blocks = [];
  let currentBlock = void 0;
  for (const message of prompt) {
    const { role } = message;
    switch (role) {
      case "system": {
        if ((currentBlock == null ? void 0 : currentBlock.type) !== "system") {
          currentBlock = { type: "system", messages: [] };
          blocks.push(currentBlock);
        }
        currentBlock.messages.push(message);
        break;
      }
      case "assistant": {
        if ((currentBlock == null ? void 0 : currentBlock.type) !== "assistant") {
          currentBlock = { type: "assistant", messages: [] };
          blocks.push(currentBlock);
        }
        currentBlock.messages.push(message);
        break;
      }
      case "user": {
        if ((currentBlock == null ? void 0 : currentBlock.type) !== "user") {
          currentBlock = { type: "user", messages: [] };
          blocks.push(currentBlock);
        }
        currentBlock.messages.push(message);
        break;
      }
      case "tool": {
        if ((currentBlock == null ? void 0 : currentBlock.type) !== "user") {
          currentBlock = { type: "user", messages: [] };
          blocks.push(currentBlock);
        }
        currentBlock.messages.push(message);
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return blocks;
}
function mapAnthropicStopReason2({
  finishReason,
  isJsonResponseFromTool
}) {
  switch (finishReason) {
    case "pause_turn":
    case "end_turn":
    case "stop_sequence":
      return "stop";
    case "refusal":
      return "content-filter";
    case "tool_use":
      return isJsonResponseFromTool ? "stop" : "tool-calls";
    case "max_tokens":
    case "model_context_window_exceeded":
      return "length";
    default:
      return "other";
  }
}
function createCitationSource2(citation, citationDocuments, generateId22) {
  var _a31;
  if (citation.type !== "page_location" && citation.type !== "char_location") {
    return;
  }
  const documentInfo = citationDocuments[citation.document_index];
  if (!documentInfo) {
    return;
  }
  return {
    type: "source",
    sourceType: "document",
    id: generateId22(),
    mediaType: documentInfo.mediaType,
    title: (_a31 = citation.document_title) != null ? _a31 : documentInfo.title,
    filename: documentInfo.filename,
    providerMetadata: {
      anthropic: citation.type === "page_location" ? {
        citedText: citation.cited_text,
        startPageNumber: citation.start_page_number,
        endPageNumber: citation.end_page_number
      } : {
        citedText: citation.cited_text,
        startCharIndex: citation.start_char_index,
        endCharIndex: citation.end_char_index
      }
    }
  };
}
function getModelCapabilities2(modelId) {
  if (modelId.includes("claude-sonnet-4-5") || modelId.includes("claude-opus-4-5")) {
    return {
      maxOutputTokens: 64e3,
      supportsStructuredOutput: true,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-opus-4-1")) {
    return {
      maxOutputTokens: 32e3,
      supportsStructuredOutput: true,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-sonnet-4-") || modelId.includes("claude-3-7-sonnet") || modelId.includes("claude-haiku-4-5")) {
    return {
      maxOutputTokens: 64e3,
      supportsStructuredOutput: false,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-opus-4-")) {
    return {
      maxOutputTokens: 32e3,
      supportsStructuredOutput: false,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-3-5-haiku")) {
    return {
      maxOutputTokens: 8192,
      supportsStructuredOutput: false,
      isKnownModel: true
    };
  } else if (modelId.includes("claude-3-haiku")) {
    return {
      maxOutputTokens: 4096,
      supportsStructuredOutput: false,
      isKnownModel: true
    };
  } else {
    return {
      maxOutputTokens: 4096,
      supportsStructuredOutput: false,
      isKnownModel: false
    };
  }
}
function mapAnthropicResponseContextManagement2(contextManagement) {
  return contextManagement ? {
    appliedEdits: contextManagement.applied_edits.map((edit) => {
      const strategy = edit.type;
      switch (strategy) {
        case "clear_tool_uses_20250919":
          return {
            type: edit.type,
            clearedToolUses: edit.cleared_tool_uses,
            clearedInputTokens: edit.cleared_input_tokens
          };
        case "clear_thinking_20251015":
          return {
            type: edit.type,
            clearedThinkingTurns: edit.cleared_thinking_turns,
            clearedInputTokens: edit.cleared_input_tokens
          };
      }
    }).filter((edit) => edit !== void 0)
  } : null;
}
var anthropicErrorDataSchema2, anthropicFailedResponseHandler2, anthropicMessagesResponseSchema2, anthropicMessagesChunkSchema2, anthropicReasoningMetadataSchema2, anthropicFilePartProviderOptions2, anthropicProviderOptions, MAX_CACHE_BREAKPOINTS2, CacheControlValidator2, textEditor_20250728ArgsSchema2, textEditor_20250728InputSchema2, factory11, webSearch_20250305ArgsSchema2, webSearch_20250305OutputSchema2, webSearch_20250305InputSchema2, factory23, webFetch_20250910ArgsSchema2, webFetch_20250910OutputSchema2, webFetch_20250910InputSchema2, factory32, codeExecution_20250522OutputSchema2, codeExecution_20250522InputSchema2, factory42, codeExecution_20250825OutputSchema2, codeExecution_20250825InputSchema2, factory52, toolSearchRegex_20251119OutputSchema2, toolSearchRegex_20251119InputSchema2, factory62, AnthropicMessagesLanguageModel2, bash_20241022InputSchema2, bash_202410222, bash_20250124InputSchema2, bash_202501242, computer_20241022InputSchema2, computer_202410222, computer_20250124InputSchema2, computer_202501242, memory_20250818InputSchema2, memory_202508182, textEditor_20241022InputSchema2, textEditor_202410222, textEditor_20250124InputSchema2, textEditor_202501242, textEditor_20250429InputSchema2, textEditor_202504292, toolSearchBm25_20251119OutputSchema2, toolSearchBm25_20251119InputSchema2, factory72;
var init_internal = __esm({
  "node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/anthropic/dist/internal/index.mjs"() {
    "use strict";
    init_dist16();
    init_dist17();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_v42();
    init_dist16();
    init_dist17();
    init_v42();
    init_dist17();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_dist16();
    init_dist17();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    init_dist17();
    init_v42();
    anthropicErrorDataSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          type: external_exports.literal("error"),
          error: external_exports.object({
            type: external_exports.string(),
            message: external_exports.string()
          })
        })
      )
    );
    anthropicFailedResponseHandler2 = createJsonErrorResponseHandler3({
      errorSchema: anthropicErrorDataSchema2,
      errorToMessage: (data) => data.error.message
    });
    anthropicMessagesResponseSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          type: external_exports.literal("message"),
          id: external_exports.string().nullish(),
          model: external_exports.string().nullish(),
          content: external_exports.array(
            external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("text"),
                text: external_exports.string(),
                citations: external_exports.array(
                  external_exports.discriminatedUnion("type", [
                    external_exports.object({
                      type: external_exports.literal("web_search_result_location"),
                      cited_text: external_exports.string(),
                      url: external_exports.string(),
                      title: external_exports.string(),
                      encrypted_index: external_exports.string()
                    }),
                    external_exports.object({
                      type: external_exports.literal("page_location"),
                      cited_text: external_exports.string(),
                      document_index: external_exports.number(),
                      document_title: external_exports.string().nullable(),
                      start_page_number: external_exports.number(),
                      end_page_number: external_exports.number()
                    }),
                    external_exports.object({
                      type: external_exports.literal("char_location"),
                      cited_text: external_exports.string(),
                      document_index: external_exports.number(),
                      document_title: external_exports.string().nullable(),
                      start_char_index: external_exports.number(),
                      end_char_index: external_exports.number()
                    })
                  ])
                ).optional()
              }),
              external_exports.object({
                type: external_exports.literal("thinking"),
                thinking: external_exports.string(),
                signature: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("redacted_thinking"),
                data: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.unknown(),
                // Programmatic tool calling: caller info when triggered from code execution
                caller: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_20250825"),
                    tool_id: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("direct")
                  })
                ]).optional()
              }),
              external_exports.object({
                type: external_exports.literal("server_tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.record(external_exports.string(), external_exports.unknown()).nullish()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.unknown(),
                server_name: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_tool_result"),
                tool_use_id: external_exports.string(),
                is_error: external_exports.boolean(),
                content: external_exports.array(
                  external_exports.union([
                    external_exports.string(),
                    external_exports.object({ type: external_exports.literal("text"), text: external_exports.string() })
                  ])
                )
              }),
              external_exports.object({
                type: external_exports.literal("web_fetch_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("web_fetch_result"),
                    url: external_exports.string(),
                    retrieved_at: external_exports.string(),
                    content: external_exports.object({
                      type: external_exports.literal("document"),
                      title: external_exports.string().nullable(),
                      citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
                      source: external_exports.union([
                        external_exports.object({
                          type: external_exports.literal("base64"),
                          media_type: external_exports.literal("application/pdf"),
                          data: external_exports.string()
                        }),
                        external_exports.object({
                          type: external_exports.literal("text"),
                          media_type: external_exports.literal("text/plain"),
                          data: external_exports.string()
                        })
                      ])
                    })
                  }),
                  external_exports.object({
                    type: external_exports.literal("web_fetch_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              external_exports.object({
                type: external_exports.literal("web_search_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.array(
                    external_exports.object({
                      type: external_exports.literal("web_search_result"),
                      url: external_exports.string(),
                      title: external_exports.string(),
                      encrypted_content: external_exports.string(),
                      page_age: external_exports.string().nullish()
                    })
                  ),
                  external_exports.object({
                    type: external_exports.literal("web_search_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // code execution results for code_execution_20250522 tool:
              external_exports.object({
                type: external_exports.literal("code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_result"),
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number(),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ).optional().default([])
                  }),
                  external_exports.object({
                    type: external_exports.literal("code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // bash code execution results for code_execution_20250825 tool:
              external_exports.object({
                type: external_exports.literal("bash_code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("bash_code_execution_result"),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("bash_code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ),
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number()
                  }),
                  external_exports.object({
                    type: external_exports.literal("bash_code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // text editor code execution results for code_execution_20250825 tool:
              external_exports.object({
                type: external_exports.literal("text_editor_code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_view_result"),
                    content: external_exports.string(),
                    file_type: external_exports.string(),
                    num_lines: external_exports.number().nullable(),
                    start_line: external_exports.number().nullable(),
                    total_lines: external_exports.number().nullable()
                  }),
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_create_result"),
                    is_file_update: external_exports.boolean()
                  }),
                  external_exports.object({
                    type: external_exports.literal(
                      "text_editor_code_execution_str_replace_result"
                    ),
                    lines: external_exports.array(external_exports.string()).nullable(),
                    new_lines: external_exports.number().nullable(),
                    new_start: external_exports.number().nullable(),
                    old_lines: external_exports.number().nullable(),
                    old_start: external_exports.number().nullable()
                  })
                ])
              }),
              // tool search tool results for tool_search_tool_regex_20251119 and tool_search_tool_bm25_20251119:
              external_exports.object({
                type: external_exports.literal("tool_search_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("tool_search_tool_search_result"),
                    tool_references: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("tool_reference"),
                        tool_name: external_exports.string()
                      })
                    )
                  }),
                  external_exports.object({
                    type: external_exports.literal("tool_search_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              })
            ])
          ),
          stop_reason: external_exports.string().nullish(),
          stop_sequence: external_exports.string().nullish(),
          usage: external_exports.looseObject({
            input_tokens: external_exports.number(),
            output_tokens: external_exports.number(),
            cache_creation_input_tokens: external_exports.number().nullish(),
            cache_read_input_tokens: external_exports.number().nullish()
          }),
          container: external_exports.object({
            expires_at: external_exports.string(),
            id: external_exports.string(),
            skills: external_exports.array(
              external_exports.object({
                type: external_exports.union([external_exports.literal("anthropic"), external_exports.literal("custom")]),
                skill_id: external_exports.string(),
                version: external_exports.string()
              })
            ).nullish()
          }).nullish(),
          context_management: external_exports.object({
            applied_edits: external_exports.array(
              external_exports.union([
                external_exports.object({
                  type: external_exports.literal("clear_tool_uses_20250919"),
                  cleared_tool_uses: external_exports.number(),
                  cleared_input_tokens: external_exports.number()
                }),
                external_exports.object({
                  type: external_exports.literal("clear_thinking_20251015"),
                  cleared_thinking_turns: external_exports.number(),
                  cleared_input_tokens: external_exports.number()
                })
              ])
            )
          }).nullish()
        })
      )
    );
    anthropicMessagesChunkSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.discriminatedUnion("type", [
          external_exports.object({
            type: external_exports.literal("message_start"),
            message: external_exports.object({
              id: external_exports.string().nullish(),
              model: external_exports.string().nullish(),
              role: external_exports.string().nullish(),
              usage: external_exports.looseObject({
                input_tokens: external_exports.number(),
                cache_creation_input_tokens: external_exports.number().nullish(),
                cache_read_input_tokens: external_exports.number().nullish()
              }),
              // Programmatic tool calling: content may be pre-populated for deferred tool calls
              content: external_exports.array(
                external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("tool_use"),
                    id: external_exports.string(),
                    name: external_exports.string(),
                    input: external_exports.unknown(),
                    caller: external_exports.union([
                      external_exports.object({
                        type: external_exports.literal("code_execution_20250825"),
                        tool_id: external_exports.string()
                      }),
                      external_exports.object({
                        type: external_exports.literal("direct")
                      })
                    ]).optional()
                  })
                ])
              ).nullish(),
              stop_reason: external_exports.string().nullish(),
              container: external_exports.object({
                expires_at: external_exports.string(),
                id: external_exports.string()
              }).nullish()
            })
          }),
          external_exports.object({
            type: external_exports.literal("content_block_start"),
            index: external_exports.number(),
            content_block: external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("text"),
                text: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("thinking"),
                thinking: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                // Programmatic tool calling: input may be present directly for deferred tool calls
                input: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
                // Programmatic tool calling: caller info when triggered from code execution
                caller: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_20250825"),
                    tool_id: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("direct")
                  })
                ]).optional()
              }),
              external_exports.object({
                type: external_exports.literal("redacted_thinking"),
                data: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("server_tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.record(external_exports.string(), external_exports.unknown()).nullish()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_tool_use"),
                id: external_exports.string(),
                name: external_exports.string(),
                input: external_exports.unknown(),
                server_name: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("mcp_tool_result"),
                tool_use_id: external_exports.string(),
                is_error: external_exports.boolean(),
                content: external_exports.array(
                  external_exports.union([
                    external_exports.string(),
                    external_exports.object({ type: external_exports.literal("text"), text: external_exports.string() })
                  ])
                )
              }),
              external_exports.object({
                type: external_exports.literal("web_fetch_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("web_fetch_result"),
                    url: external_exports.string(),
                    retrieved_at: external_exports.string(),
                    content: external_exports.object({
                      type: external_exports.literal("document"),
                      title: external_exports.string().nullable(),
                      citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
                      source: external_exports.union([
                        external_exports.object({
                          type: external_exports.literal("base64"),
                          media_type: external_exports.literal("application/pdf"),
                          data: external_exports.string()
                        }),
                        external_exports.object({
                          type: external_exports.literal("text"),
                          media_type: external_exports.literal("text/plain"),
                          data: external_exports.string()
                        })
                      ])
                    })
                  }),
                  external_exports.object({
                    type: external_exports.literal("web_fetch_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              external_exports.object({
                type: external_exports.literal("web_search_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.array(
                    external_exports.object({
                      type: external_exports.literal("web_search_result"),
                      url: external_exports.string(),
                      title: external_exports.string(),
                      encrypted_content: external_exports.string(),
                      page_age: external_exports.string().nullish()
                    })
                  ),
                  external_exports.object({
                    type: external_exports.literal("web_search_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // code execution results for code_execution_20250522 tool:
              external_exports.object({
                type: external_exports.literal("code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("code_execution_result"),
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number(),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ).optional().default([])
                  }),
                  external_exports.object({
                    type: external_exports.literal("code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // bash code execution results for code_execution_20250825 tool:
              external_exports.object({
                type: external_exports.literal("bash_code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("bash_code_execution_result"),
                    content: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("bash_code_execution_output"),
                        file_id: external_exports.string()
                      })
                    ),
                    stdout: external_exports.string(),
                    stderr: external_exports.string(),
                    return_code: external_exports.number()
                  }),
                  external_exports.object({
                    type: external_exports.literal("bash_code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              }),
              // text editor code execution results for code_execution_20250825 tool:
              external_exports.object({
                type: external_exports.literal("text_editor_code_execution_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_tool_result_error"),
                    error_code: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_view_result"),
                    content: external_exports.string(),
                    file_type: external_exports.string(),
                    num_lines: external_exports.number().nullable(),
                    start_line: external_exports.number().nullable(),
                    total_lines: external_exports.number().nullable()
                  }),
                  external_exports.object({
                    type: external_exports.literal("text_editor_code_execution_create_result"),
                    is_file_update: external_exports.boolean()
                  }),
                  external_exports.object({
                    type: external_exports.literal(
                      "text_editor_code_execution_str_replace_result"
                    ),
                    lines: external_exports.array(external_exports.string()).nullable(),
                    new_lines: external_exports.number().nullable(),
                    new_start: external_exports.number().nullable(),
                    old_lines: external_exports.number().nullable(),
                    old_start: external_exports.number().nullable()
                  })
                ])
              }),
              // tool search tool results for tool_search_tool_regex_20251119 and tool_search_tool_bm25_20251119:
              external_exports.object({
                type: external_exports.literal("tool_search_tool_result"),
                tool_use_id: external_exports.string(),
                content: external_exports.union([
                  external_exports.object({
                    type: external_exports.literal("tool_search_tool_search_result"),
                    tool_references: external_exports.array(
                      external_exports.object({
                        type: external_exports.literal("tool_reference"),
                        tool_name: external_exports.string()
                      })
                    )
                  }),
                  external_exports.object({
                    type: external_exports.literal("tool_search_tool_result_error"),
                    error_code: external_exports.string()
                  })
                ])
              })
            ])
          }),
          external_exports.object({
            type: external_exports.literal("content_block_delta"),
            index: external_exports.number(),
            delta: external_exports.discriminatedUnion("type", [
              external_exports.object({
                type: external_exports.literal("input_json_delta"),
                partial_json: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("text_delta"),
                text: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("thinking_delta"),
                thinking: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("signature_delta"),
                signature: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("citations_delta"),
                citation: external_exports.discriminatedUnion("type", [
                  external_exports.object({
                    type: external_exports.literal("web_search_result_location"),
                    cited_text: external_exports.string(),
                    url: external_exports.string(),
                    title: external_exports.string(),
                    encrypted_index: external_exports.string()
                  }),
                  external_exports.object({
                    type: external_exports.literal("page_location"),
                    cited_text: external_exports.string(),
                    document_index: external_exports.number(),
                    document_title: external_exports.string().nullable(),
                    start_page_number: external_exports.number(),
                    end_page_number: external_exports.number()
                  }),
                  external_exports.object({
                    type: external_exports.literal("char_location"),
                    cited_text: external_exports.string(),
                    document_index: external_exports.number(),
                    document_title: external_exports.string().nullable(),
                    start_char_index: external_exports.number(),
                    end_char_index: external_exports.number()
                  })
                ])
              })
            ])
          }),
          external_exports.object({
            type: external_exports.literal("content_block_stop"),
            index: external_exports.number()
          }),
          external_exports.object({
            type: external_exports.literal("error"),
            error: external_exports.object({
              type: external_exports.string(),
              message: external_exports.string()
            })
          }),
          external_exports.object({
            type: external_exports.literal("message_delta"),
            delta: external_exports.object({
              stop_reason: external_exports.string().nullish(),
              stop_sequence: external_exports.string().nullish(),
              container: external_exports.object({
                expires_at: external_exports.string(),
                id: external_exports.string(),
                skills: external_exports.array(
                  external_exports.object({
                    type: external_exports.union([
                      external_exports.literal("anthropic"),
                      external_exports.literal("custom")
                    ]),
                    skill_id: external_exports.string(),
                    version: external_exports.string()
                  })
                ).nullish()
              }).nullish(),
              context_management: external_exports.object({
                applied_edits: external_exports.array(
                  external_exports.union([
                    external_exports.object({
                      type: external_exports.literal("clear_tool_uses_20250919"),
                      cleared_tool_uses: external_exports.number(),
                      cleared_input_tokens: external_exports.number()
                    }),
                    external_exports.object({
                      type: external_exports.literal("clear_thinking_20251015"),
                      cleared_thinking_turns: external_exports.number(),
                      cleared_input_tokens: external_exports.number()
                    })
                  ])
                )
              }).nullish()
            }),
            usage: external_exports.looseObject({
              output_tokens: external_exports.number(),
              cache_creation_input_tokens: external_exports.number().nullish()
            })
          }),
          external_exports.object({
            type: external_exports.literal("message_stop")
          }),
          external_exports.object({
            type: external_exports.literal("ping")
          })
        ])
      )
    );
    anthropicReasoningMetadataSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          signature: external_exports.string().optional(),
          redactedData: external_exports.string().optional()
        })
      )
    );
    anthropicFilePartProviderOptions2 = external_exports.object({
      /**
       * Citation configuration for this document.
       * When enabled, this document will generate citations in the response.
       */
      citations: external_exports.object({
        /**
         * Enable citations for this document
         */
        enabled: external_exports.boolean()
      }).optional(),
      /**
       * Custom title for the document.
       * If not provided, the filename will be used.
       */
      title: external_exports.string().optional(),
      /**
       * Context about the document that will be passed to the model
       * but not used towards cited content.
       * Useful for storing document metadata as text or stringified JSON.
       */
      context: external_exports.string().optional()
    });
    anthropicProviderOptions = external_exports.object({
      /**
       * Whether to send reasoning to the model.
       *
       * This allows you to deactivate reasoning inputs for models that do not support them.
       */
      sendReasoning: external_exports.boolean().optional(),
      /**
       * Determines how structured outputs are generated.
       *
       * - `outputFormat`: Use the `output_format` parameter to specify the structured output format.
       * - `jsonTool`: Use a special 'json' tool to specify the structured output format.
       * - `auto`: Use 'outputFormat' when supported, otherwise use 'jsonTool' (default).
       */
      structuredOutputMode: external_exports.enum(["outputFormat", "jsonTool", "auto"]).optional(),
      /**
       * Configuration for enabling Claude's extended thinking.
       *
       * When enabled, responses include thinking content blocks showing Claude's thinking process before the final answer.
       * Requires a minimum budget of 1,024 tokens and counts towards the `max_tokens` limit.
       */
      thinking: external_exports.object({
        type: external_exports.union([external_exports.literal("enabled"), external_exports.literal("disabled")]),
        budgetTokens: external_exports.number().optional()
      }).optional(),
      /**
       * Whether to disable parallel function calling during tool use. Default is false.
       * When set to true, Claude will use at most one tool per response.
       */
      disableParallelToolUse: external_exports.boolean().optional(),
      /**
       * Cache control settings for this message.
       * See https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
       */
      cacheControl: external_exports.object({
        type: external_exports.literal("ephemeral"),
        ttl: external_exports.union([external_exports.literal("5m"), external_exports.literal("1h")]).optional()
      }).optional(),
      /**
       * MCP servers to be utilized in this request.
       */
      mcpServers: external_exports.array(
        external_exports.object({
          type: external_exports.literal("url"),
          name: external_exports.string(),
          url: external_exports.string(),
          authorizationToken: external_exports.string().nullish(),
          toolConfiguration: external_exports.object({
            enabled: external_exports.boolean().nullish(),
            allowedTools: external_exports.array(external_exports.string()).nullish()
          }).nullish()
        })
      ).optional(),
      /**
       * Agent Skills configuration. Skills enable Claude to perform specialized tasks
       * like document processing (PPTX, DOCX, PDF, XLSX) and data analysis.
       * Requires code execution tool to be enabled.
       */
      container: external_exports.object({
        id: external_exports.string().optional(),
        skills: external_exports.array(
          external_exports.object({
            type: external_exports.union([external_exports.literal("anthropic"), external_exports.literal("custom")]),
            skillId: external_exports.string(),
            version: external_exports.string().optional()
          })
        ).optional()
      }).optional(),
      /**
       * Whether to enable tool streaming (and structured output streaming).
       *
       * When set to false, the model will return all tool calls and results
       * at once after a delay.
       *
       * @default true
       */
      toolStreaming: external_exports.boolean().optional(),
      /**
       * @default 'high'
       */
      effort: external_exports.enum(["low", "medium", "high"]).optional(),
      contextManagement: external_exports.object({
        edits: external_exports.array(
          external_exports.discriminatedUnion("type", [
            external_exports.object({
              type: external_exports.literal("clear_tool_uses_20250919"),
              trigger: external_exports.discriminatedUnion("type", [
                external_exports.object({
                  type: external_exports.literal("input_tokens"),
                  value: external_exports.number()
                }),
                external_exports.object({
                  type: external_exports.literal("tool_uses"),
                  value: external_exports.number()
                })
              ]).optional(),
              keep: external_exports.object({
                type: external_exports.literal("tool_uses"),
                value: external_exports.number()
              }).optional(),
              clearAtLeast: external_exports.object({
                type: external_exports.literal("input_tokens"),
                value: external_exports.number()
              }).optional(),
              clearToolInputs: external_exports.boolean().optional(),
              excludeTools: external_exports.array(external_exports.string()).optional()
            }),
            external_exports.object({
              type: external_exports.literal("clear_thinking_20251015"),
              keep: external_exports.union([
                external_exports.literal("all"),
                external_exports.object({
                  type: external_exports.literal("thinking_turns"),
                  value: external_exports.number()
                })
              ]).optional()
            })
          ])
        )
      }).optional()
    });
    MAX_CACHE_BREAKPOINTS2 = 4;
    CacheControlValidator2 = class {
      constructor() {
        this.breakpointCount = 0;
        this.warnings = [];
      }
      getCacheControl(providerMetadata, context2) {
        const cacheControlValue = getCacheControl2(providerMetadata);
        if (!cacheControlValue) {
          return void 0;
        }
        if (!context2.canCache) {
          this.warnings.push({
            type: "unsupported",
            feature: "cache_control on non-cacheable context",
            details: `cache_control cannot be set on ${context2.type}. It will be ignored.`
          });
          return void 0;
        }
        this.breakpointCount++;
        if (this.breakpointCount > MAX_CACHE_BREAKPOINTS2) {
          this.warnings.push({
            type: "unsupported",
            feature: "cacheControl breakpoint limit",
            details: `Maximum ${MAX_CACHE_BREAKPOINTS2} cache breakpoints exceeded (found ${this.breakpointCount}). This breakpoint will be ignored.`
          });
          return void 0;
        }
        return cacheControlValue;
      }
      getWarnings() {
        return this.warnings;
      }
    };
    textEditor_20250728ArgsSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          maxCharacters: external_exports.number().optional()
        })
      )
    );
    textEditor_20250728InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          command: external_exports.enum(["view", "create", "str_replace", "insert"]),
          path: external_exports.string(),
          file_text: external_exports.string().optional(),
          insert_line: external_exports.number().int().optional(),
          new_str: external_exports.string().optional(),
          old_str: external_exports.string().optional(),
          view_range: external_exports.array(external_exports.number().int()).optional()
        })
      )
    );
    factory11 = createProviderToolFactory2({
      id: "anthropic.text_editor_20250728",
      inputSchema: textEditor_20250728InputSchema2
    });
    webSearch_20250305ArgsSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          maxUses: external_exports.number().optional(),
          allowedDomains: external_exports.array(external_exports.string()).optional(),
          blockedDomains: external_exports.array(external_exports.string()).optional(),
          userLocation: external_exports.object({
            type: external_exports.literal("approximate"),
            city: external_exports.string().optional(),
            region: external_exports.string().optional(),
            country: external_exports.string().optional(),
            timezone: external_exports.string().optional()
          }).optional()
        })
      )
    );
    webSearch_20250305OutputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.array(
          external_exports.object({
            url: external_exports.string(),
            title: external_exports.string().nullable(),
            pageAge: external_exports.string().nullable(),
            encryptedContent: external_exports.string(),
            type: external_exports.literal("web_search_result")
          })
        )
      )
    );
    webSearch_20250305InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          query: external_exports.string()
        })
      )
    );
    factory23 = createProviderToolFactoryWithOutputSchema2({
      id: "anthropic.web_search_20250305",
      inputSchema: webSearch_20250305InputSchema2,
      outputSchema: webSearch_20250305OutputSchema2,
      supportsDeferredResults: true
    });
    webFetch_20250910ArgsSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          maxUses: external_exports.number().optional(),
          allowedDomains: external_exports.array(external_exports.string()).optional(),
          blockedDomains: external_exports.array(external_exports.string()).optional(),
          citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
          maxContentTokens: external_exports.number().optional()
        })
      )
    );
    webFetch_20250910OutputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          type: external_exports.literal("web_fetch_result"),
          url: external_exports.string(),
          content: external_exports.object({
            type: external_exports.literal("document"),
            title: external_exports.string().nullable(),
            citations: external_exports.object({ enabled: external_exports.boolean() }).optional(),
            source: external_exports.union([
              external_exports.object({
                type: external_exports.literal("base64"),
                mediaType: external_exports.literal("application/pdf"),
                data: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("text"),
                mediaType: external_exports.literal("text/plain"),
                data: external_exports.string()
              })
            ])
          }),
          retrievedAt: external_exports.string().nullable()
        })
      )
    );
    webFetch_20250910InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          url: external_exports.string()
        })
      )
    );
    factory32 = createProviderToolFactoryWithOutputSchema2({
      id: "anthropic.web_fetch_20250910",
      inputSchema: webFetch_20250910InputSchema2,
      outputSchema: webFetch_20250910OutputSchema2,
      supportsDeferredResults: true
    });
    codeExecution_20250522OutputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          type: external_exports.literal("code_execution_result"),
          stdout: external_exports.string(),
          stderr: external_exports.string(),
          return_code: external_exports.number(),
          content: external_exports.array(
            external_exports.object({
              type: external_exports.literal("code_execution_output"),
              file_id: external_exports.string()
            })
          ).optional().default([])
        })
      )
    );
    codeExecution_20250522InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          code: external_exports.string()
        })
      )
    );
    factory42 = createProviderToolFactoryWithOutputSchema2({
      id: "anthropic.code_execution_20250522",
      inputSchema: codeExecution_20250522InputSchema2,
      outputSchema: codeExecution_20250522OutputSchema2
    });
    codeExecution_20250825OutputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.discriminatedUnion("type", [
          external_exports.object({
            type: external_exports.literal("code_execution_result"),
            stdout: external_exports.string(),
            stderr: external_exports.string(),
            return_code: external_exports.number(),
            content: external_exports.array(
              external_exports.object({
                type: external_exports.literal("code_execution_output"),
                file_id: external_exports.string()
              })
            ).optional().default([])
          }),
          external_exports.object({
            type: external_exports.literal("bash_code_execution_result"),
            content: external_exports.array(
              external_exports.object({
                type: external_exports.literal("bash_code_execution_output"),
                file_id: external_exports.string()
              })
            ),
            stdout: external_exports.string(),
            stderr: external_exports.string(),
            return_code: external_exports.number()
          }),
          external_exports.object({
            type: external_exports.literal("bash_code_execution_tool_result_error"),
            error_code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_tool_result_error"),
            error_code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_view_result"),
            content: external_exports.string(),
            file_type: external_exports.string(),
            num_lines: external_exports.number().nullable(),
            start_line: external_exports.number().nullable(),
            total_lines: external_exports.number().nullable()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_create_result"),
            is_file_update: external_exports.boolean()
          }),
          external_exports.object({
            type: external_exports.literal("text_editor_code_execution_str_replace_result"),
            lines: external_exports.array(external_exports.string()).nullable(),
            new_lines: external_exports.number().nullable(),
            new_start: external_exports.number().nullable(),
            old_lines: external_exports.number().nullable(),
            old_start: external_exports.number().nullable()
          })
        ])
      )
    );
    codeExecution_20250825InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.discriminatedUnion("type", [
          // Programmatic tool calling format (mapped from { code } by AI SDK)
          external_exports.object({
            type: external_exports.literal("programmatic-tool-call"),
            code: external_exports.string()
          }),
          external_exports.object({
            type: external_exports.literal("bash_code_execution"),
            command: external_exports.string()
          }),
          external_exports.discriminatedUnion("command", [
            external_exports.object({
              type: external_exports.literal("text_editor_code_execution"),
              command: external_exports.literal("view"),
              path: external_exports.string()
            }),
            external_exports.object({
              type: external_exports.literal("text_editor_code_execution"),
              command: external_exports.literal("create"),
              path: external_exports.string(),
              file_text: external_exports.string().nullish()
            }),
            external_exports.object({
              type: external_exports.literal("text_editor_code_execution"),
              command: external_exports.literal("str_replace"),
              path: external_exports.string(),
              old_str: external_exports.string(),
              new_str: external_exports.string()
            })
          ])
        ])
      )
    );
    factory52 = createProviderToolFactoryWithOutputSchema2({
      id: "anthropic.code_execution_20250825",
      inputSchema: codeExecution_20250825InputSchema2,
      outputSchema: codeExecution_20250825OutputSchema2,
      // Programmatic tool calling: tool results may be deferred to a later turn
      // when code execution triggers a client-executed tool that needs to be
      // resolved before the code execution result can be returned.
      supportsDeferredResults: true
    });
    toolSearchRegex_20251119OutputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.array(
          external_exports.object({
            type: external_exports.literal("tool_reference"),
            toolName: external_exports.string()
          })
        )
      )
    );
    toolSearchRegex_20251119InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          /**
           * A regex pattern to search for tools.
           * Uses Python re.search() syntax. Maximum 200 characters.
           *
           * Examples:
           * - "weather" - matches tool names/descriptions containing "weather"
           * - "get_.*_data" - matches tools like get_user_data, get_weather_data
           * - "database.*query|query.*database" - OR patterns for flexibility
           * - "(?i)slack" - case-insensitive search
           */
          pattern: external_exports.string(),
          /**
           * Maximum number of tools to return. Optional.
           */
          limit: external_exports.number().optional()
        })
      )
    );
    factory62 = createProviderToolFactoryWithOutputSchema2({
      id: "anthropic.tool_search_regex_20251119",
      inputSchema: toolSearchRegex_20251119InputSchema2,
      outputSchema: toolSearchRegex_20251119OutputSchema2
    });
    AnthropicMessagesLanguageModel2 = class {
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        var _a31;
        this.modelId = modelId;
        this.config = config3;
        this.generateId = (_a31 = config3.generateId) != null ? _a31 : generateId3;
      }
      supportsUrl(url4) {
        return url4.protocol === "https:";
      }
      get provider() {
        return this.config.provider;
      }
      get supportedUrls() {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).supportedUrls) == null ? void 0 : _b27.call(_a31)) != null ? _c : {};
      }
      async getArgs({
        userSuppliedBetas,
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        stopSequences,
        responseFormat,
        seed,
        tools,
        toolChoice,
        providerOptions,
        stream: stream4
      }) {
        var _a31, _b27, _c, _d, _e, _f;
        const warnings = [];
        if (frequencyPenalty != null) {
          warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
        }
        if (presencePenalty != null) {
          warnings.push({ type: "unsupported", feature: "presencePenalty" });
        }
        if (seed != null) {
          warnings.push({ type: "unsupported", feature: "seed" });
        }
        if (temperature != null && temperature > 1) {
          warnings.push({
            type: "unsupported",
            feature: "temperature",
            details: `${temperature} exceeds anthropic maximum of 1.0. clamped to 1.0`
          });
          temperature = 1;
        } else if (temperature != null && temperature < 0) {
          warnings.push({
            type: "unsupported",
            feature: "temperature",
            details: `${temperature} is below anthropic minimum of 0. clamped to 0`
          });
          temperature = 0;
        }
        if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
          if (responseFormat.schema == null) {
            warnings.push({
              type: "unsupported",
              feature: "responseFormat",
              details: "JSON response format requires a schema. The response format is ignored."
            });
          }
        }
        const anthropicOptions = await parseProviderOptions2({
          provider: "anthropic",
          providerOptions,
          schema: anthropicProviderOptions
        });
        const {
          maxOutputTokens: maxOutputTokensForModel,
          supportsStructuredOutput: modelSupportsStructuredOutput,
          isKnownModel
        } = getModelCapabilities2(this.modelId);
        const supportsStructuredOutput = ((_a31 = this.config.supportsNativeStructuredOutput) != null ? _a31 : true) && modelSupportsStructuredOutput;
        const structureOutputMode = (_b27 = anthropicOptions == null ? void 0 : anthropicOptions.structuredOutputMode) != null ? _b27 : "auto";
        const useStructuredOutput = structureOutputMode === "outputFormat" || structureOutputMode === "auto" && supportsStructuredOutput;
        const jsonResponseTool = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !useStructuredOutput ? {
          type: "function",
          name: "json",
          description: "Respond with a JSON object.",
          inputSchema: responseFormat.schema
        } : void 0;
        const contextManagement = anthropicOptions == null ? void 0 : anthropicOptions.contextManagement;
        const cacheControlValidator = new CacheControlValidator2();
        const toolNameMapping = createToolNameMapping2({
          tools,
          providerToolNames: {
            "anthropic.code_execution_20250522": "code_execution",
            "anthropic.code_execution_20250825": "code_execution",
            "anthropic.computer_20241022": "computer",
            "anthropic.computer_20250124": "computer",
            "anthropic.text_editor_20241022": "str_replace_editor",
            "anthropic.text_editor_20250124": "str_replace_editor",
            "anthropic.text_editor_20250429": "str_replace_based_edit_tool",
            "anthropic.text_editor_20250728": "str_replace_based_edit_tool",
            "anthropic.bash_20241022": "bash",
            "anthropic.bash_20250124": "bash",
            "anthropic.memory_20250818": "memory",
            "anthropic.web_search_20250305": "web_search",
            "anthropic.web_fetch_20250910": "web_fetch",
            "anthropic.tool_search_regex_20251119": "tool_search_tool_regex",
            "anthropic.tool_search_bm25_20251119": "tool_search_tool_bm25"
          }
        });
        const { prompt: messagesPrompt, betas } = await convertToAnthropicMessagesPrompt2({
          prompt,
          sendReasoning: (_c = anthropicOptions == null ? void 0 : anthropicOptions.sendReasoning) != null ? _c : true,
          warnings,
          cacheControlValidator,
          toolNameMapping
        });
        const isThinking = ((_d = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _d.type) === "enabled";
        let thinkingBudget = (_e = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _e.budgetTokens;
        const maxTokens = maxOutputTokens != null ? maxOutputTokens : maxOutputTokensForModel;
        const baseArgs = {
          // model id:
          model: this.modelId,
          // standardized settings:
          max_tokens: maxTokens,
          temperature,
          top_k: topK,
          top_p: topP,
          stop_sequences: stopSequences,
          // provider specific settings:
          ...isThinking && {
            thinking: { type: "enabled", budget_tokens: thinkingBudget }
          },
          ...(anthropicOptions == null ? void 0 : anthropicOptions.effort) && {
            output_config: { effort: anthropicOptions.effort }
          },
          // structured output:
          ...useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && {
            output_format: {
              type: "json_schema",
              schema: responseFormat.schema
            }
          },
          // mcp servers:
          ...(anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0 && {
            mcp_servers: anthropicOptions.mcpServers.map((server2) => ({
              type: server2.type,
              name: server2.name,
              url: server2.url,
              authorization_token: server2.authorizationToken,
              tool_configuration: server2.toolConfiguration ? {
                allowed_tools: server2.toolConfiguration.allowedTools,
                enabled: server2.toolConfiguration.enabled
              } : void 0
            }))
          },
          // container: For programmatic tool calling (just an ID string) or agent skills (object with id and skills)
          ...(anthropicOptions == null ? void 0 : anthropicOptions.container) && {
            container: anthropicOptions.container.skills && anthropicOptions.container.skills.length > 0 ? (
              // Object format when skills are provided (agent skills feature)
              {
                id: anthropicOptions.container.id,
                skills: anthropicOptions.container.skills.map((skill) => ({
                  type: skill.type,
                  skill_id: skill.skillId,
                  version: skill.version
                }))
              }
            ) : (
              // String format for container ID only (programmatic tool calling)
              anthropicOptions.container.id
            )
          },
          // prompt:
          system: messagesPrompt.system,
          messages: messagesPrompt.messages,
          ...contextManagement && {
            context_management: {
              edits: contextManagement.edits.map((edit) => {
                const strategy = edit.type;
                switch (strategy) {
                  case "clear_tool_uses_20250919":
                    return {
                      type: edit.type,
                      ...edit.trigger !== void 0 && {
                        trigger: edit.trigger
                      },
                      ...edit.keep !== void 0 && { keep: edit.keep },
                      ...edit.clearAtLeast !== void 0 && {
                        clear_at_least: edit.clearAtLeast
                      },
                      ...edit.clearToolInputs !== void 0 && {
                        clear_tool_inputs: edit.clearToolInputs
                      },
                      ...edit.excludeTools !== void 0 && {
                        exclude_tools: edit.excludeTools
                      }
                    };
                  case "clear_thinking_20251015":
                    return {
                      type: edit.type,
                      ...edit.keep !== void 0 && { keep: edit.keep }
                    };
                  default:
                    warnings.push({
                      type: "other",
                      message: `Unknown context management strategy: ${strategy}`
                    });
                    return void 0;
                }
              }).filter((edit) => edit !== void 0)
            }
          }
        };
        if (isThinking) {
          if (thinkingBudget == null) {
            warnings.push({
              type: "compatibility",
              feature: "extended thinking",
              details: "thinking budget is required when thinking is enabled. using default budget of 1024 tokens."
            });
            baseArgs.thinking = {
              type: "enabled",
              budget_tokens: 1024
            };
            thinkingBudget = 1024;
          }
          if (baseArgs.temperature != null) {
            baseArgs.temperature = void 0;
            warnings.push({
              type: "unsupported",
              feature: "temperature",
              details: "temperature is not supported when thinking is enabled"
            });
          }
          if (topK != null) {
            baseArgs.top_k = void 0;
            warnings.push({
              type: "unsupported",
              feature: "topK",
              details: "topK is not supported when thinking is enabled"
            });
          }
          if (topP != null) {
            baseArgs.top_p = void 0;
            warnings.push({
              type: "unsupported",
              feature: "topP",
              details: "topP is not supported when thinking is enabled"
            });
          }
          baseArgs.max_tokens = maxTokens + (thinkingBudget != null ? thinkingBudget : 0);
        } else {
          if (topP != null && temperature != null) {
            warnings.push({
              type: "unsupported",
              feature: "topP",
              details: `topP is not supported when temperature is set. topP is ignored.`
            });
            baseArgs.top_p = void 0;
          }
        }
        if (isKnownModel && baseArgs.max_tokens > maxOutputTokensForModel) {
          if (maxOutputTokens != null) {
            warnings.push({
              type: "unsupported",
              feature: "maxOutputTokens",
              details: `${baseArgs.max_tokens} (maxOutputTokens + thinkingBudget) is greater than ${this.modelId} ${maxOutputTokensForModel} max output tokens. The max output tokens have been limited to ${maxOutputTokensForModel}.`
            });
          }
          baseArgs.max_tokens = maxOutputTokensForModel;
        }
        if ((anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0) {
          betas.add("mcp-client-2025-04-04");
        }
        if (contextManagement) {
          betas.add("context-management-2025-06-27");
        }
        if ((anthropicOptions == null ? void 0 : anthropicOptions.container) && anthropicOptions.container.skills && anthropicOptions.container.skills.length > 0) {
          betas.add("code-execution-2025-08-25");
          betas.add("skills-2025-10-02");
          betas.add("files-api-2025-04-14");
          if (!(tools == null ? void 0 : tools.some(
            (tool3) => tool3.type === "provider" && tool3.id === "anthropic.code_execution_20250825"
          ))) {
            warnings.push({
              type: "other",
              message: "code execution tool is required when using skills"
            });
          }
        }
        if (anthropicOptions == null ? void 0 : anthropicOptions.effort) {
          betas.add("effort-2025-11-24");
        }
        if (stream4 && ((_f = anthropicOptions == null ? void 0 : anthropicOptions.toolStreaming) != null ? _f : true)) {
          betas.add("fine-grained-tool-streaming-2025-05-14");
        }
        const usingNativeOutputFormat = useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null;
        if (usingNativeOutputFormat) {
          betas.add("structured-outputs-2025-11-13");
        }
        const {
          tools: anthropicTools2,
          toolChoice: anthropicToolChoice,
          toolWarnings,
          betas: toolsBetas
        } = await prepareTools6(
          jsonResponseTool != null ? {
            tools: [...tools != null ? tools : [], jsonResponseTool],
            toolChoice: { type: "required" },
            disableParallelToolUse: true,
            cacheControlValidator,
            supportsStructuredOutput
          } : {
            tools: tools != null ? tools : [],
            toolChoice,
            disableParallelToolUse: anthropicOptions == null ? void 0 : anthropicOptions.disableParallelToolUse,
            cacheControlValidator,
            supportsStructuredOutput
          }
        );
        const cacheWarnings = cacheControlValidator.getWarnings();
        return {
          args: {
            ...baseArgs,
            tools: anthropicTools2,
            tool_choice: anthropicToolChoice,
            stream: stream4 === true ? true : void 0
            // do not send when not streaming
          },
          warnings: [...warnings, ...toolWarnings, ...cacheWarnings],
          betas: /* @__PURE__ */ new Set([...betas, ...toolsBetas, ...userSuppliedBetas]),
          usesJsonResponseTool: jsonResponseTool != null,
          toolNameMapping
        };
      }
      async getHeaders({
        betas,
        headers
      }) {
        return combineHeaders3(
          await resolve2(this.config.headers),
          headers,
          betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {}
        );
      }
      async getBetasFromHeaders(requestHeaders) {
        var _a31, _b27;
        const configHeaders = await resolve2(this.config.headers);
        const configBetaHeader = (_a31 = configHeaders["anthropic-beta"]) != null ? _a31 : "";
        const requestBetaHeader = (_b27 = requestHeaders == null ? void 0 : requestHeaders["anthropic-beta"]) != null ? _b27 : "";
        return new Set(
          [
            ...configBetaHeader.toLowerCase().split(","),
            ...requestBetaHeader.toLowerCase().split(",")
          ].map((beta) => beta.trim()).filter((beta) => beta !== "")
        );
      }
      buildRequestUrl(isStreaming) {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).buildRequestUrl) == null ? void 0 : _b27.call(_a31, this.config.baseURL, isStreaming)) != null ? _c : `${this.config.baseURL}/messages`;
      }
      transformRequestBody(args) {
        var _a31, _b27, _c;
        return (_c = (_b27 = (_a31 = this.config).transformRequestBody) == null ? void 0 : _b27.call(_a31, args)) != null ? _c : args;
      }
      extractCitationDocuments(prompt) {
        const isCitationPart = (part) => {
          var _a31, _b27;
          if (part.type !== "file") {
            return false;
          }
          if (part.mediaType !== "application/pdf" && part.mediaType !== "text/plain") {
            return false;
          }
          const anthropic2 = (_a31 = part.providerOptions) == null ? void 0 : _a31.anthropic;
          const citationsConfig = anthropic2 == null ? void 0 : anthropic2.citations;
          return (_b27 = citationsConfig == null ? void 0 : citationsConfig.enabled) != null ? _b27 : false;
        };
        return prompt.filter((message) => message.role === "user").flatMap((message) => message.content).filter(isCitationPart).map((part) => {
          var _a31;
          const filePart = part;
          return {
            title: (_a31 = filePart.filename) != null ? _a31 : "Untitled Document",
            filename: filePart.filename,
            mediaType: filePart.mediaType
          };
        });
      }
      async doGenerate(options) {
        var _a31, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k;
        const { args, warnings, betas, usesJsonResponseTool, toolNameMapping } = await this.getArgs({
          ...options,
          stream: false,
          userSuppliedBetas: await this.getBetasFromHeaders(options.headers)
        });
        const citationDocuments = this.extractCitationDocuments(options.prompt);
        const {
          responseHeaders,
          value: response,
          rawValue: rawResponse
        } = await postJsonToApi3({
          url: this.buildRequestUrl(false),
          headers: await this.getHeaders({ betas, headers: options.headers }),
          body: this.transformRequestBody(args),
          failedResponseHandler: anthropicFailedResponseHandler2,
          successfulResponseHandler: createJsonResponseHandler3(
            anthropicMessagesResponseSchema2
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const content = [];
        const mcpToolCalls = {};
        const serverToolCalls = {};
        let isJsonResponseFromTool = false;
        for (const part of response.content) {
          switch (part.type) {
            case "text": {
              if (!usesJsonResponseTool) {
                content.push({ type: "text", text: part.text });
                if (part.citations) {
                  for (const citation of part.citations) {
                    const source = createCitationSource2(
                      citation,
                      citationDocuments,
                      this.generateId
                    );
                    if (source) {
                      content.push(source);
                    }
                  }
                }
              }
              break;
            }
            case "thinking": {
              content.push({
                type: "reasoning",
                text: part.thinking,
                providerMetadata: {
                  anthropic: {
                    signature: part.signature
                  }
                }
              });
              break;
            }
            case "redacted_thinking": {
              content.push({
                type: "reasoning",
                text: "",
                providerMetadata: {
                  anthropic: {
                    redactedData: part.data
                  }
                }
              });
              break;
            }
            case "tool_use": {
              const isJsonResponseTool = usesJsonResponseTool && part.name === "json";
              if (isJsonResponseTool) {
                isJsonResponseFromTool = true;
                content.push({
                  type: "text",
                  text: JSON.stringify(part.input)
                });
              } else {
                const caller = part.caller;
                const callerInfo = caller ? {
                  type: caller.type,
                  toolId: "tool_id" in caller ? caller.tool_id : void 0
                } : void 0;
                content.push({
                  type: "tool-call",
                  toolCallId: part.id,
                  toolName: part.name,
                  input: JSON.stringify(part.input),
                  ...callerInfo && {
                    providerMetadata: {
                      anthropic: {
                        caller: callerInfo
                      }
                    }
                  }
                });
              }
              break;
            }
            case "server_tool_use": {
              if (part.name === "text_editor_code_execution" || part.name === "bash_code_execution") {
                content.push({
                  type: "tool-call",
                  toolCallId: part.id,
                  toolName: toolNameMapping.toCustomToolName("code_execution"),
                  input: JSON.stringify({ type: part.name, ...part.input }),
                  providerExecuted: true
                });
              } else if (part.name === "web_search" || part.name === "code_execution" || part.name === "web_fetch") {
                const inputToSerialize = part.name === "code_execution" && part.input != null && typeof part.input === "object" && "code" in part.input && !("type" in part.input) ? { type: "programmatic-tool-call", ...part.input } : part.input;
                content.push({
                  type: "tool-call",
                  toolCallId: part.id,
                  toolName: toolNameMapping.toCustomToolName(part.name),
                  input: JSON.stringify(inputToSerialize),
                  providerExecuted: true
                });
              } else if (part.name === "tool_search_tool_regex" || part.name === "tool_search_tool_bm25") {
                serverToolCalls[part.id] = part.name;
                content.push({
                  type: "tool-call",
                  toolCallId: part.id,
                  toolName: toolNameMapping.toCustomToolName(part.name),
                  input: JSON.stringify(part.input),
                  providerExecuted: true
                });
              }
              break;
            }
            case "mcp_tool_use": {
              mcpToolCalls[part.id] = {
                type: "tool-call",
                toolCallId: part.id,
                toolName: part.name,
                input: JSON.stringify(part.input),
                providerExecuted: true,
                dynamic: true,
                providerMetadata: {
                  anthropic: {
                    type: "mcp-tool-use",
                    serverName: part.server_name
                  }
                }
              };
              content.push(mcpToolCalls[part.id]);
              break;
            }
            case "mcp_tool_result": {
              content.push({
                type: "tool-result",
                toolCallId: part.tool_use_id,
                toolName: mcpToolCalls[part.tool_use_id].toolName,
                isError: part.is_error,
                result: part.content,
                dynamic: true,
                providerMetadata: mcpToolCalls[part.tool_use_id].providerMetadata
              });
              break;
            }
            case "web_fetch_tool_result": {
              if (part.content.type === "web_fetch_result") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("web_fetch"),
                  result: {
                    type: "web_fetch_result",
                    url: part.content.url,
                    retrievedAt: part.content.retrieved_at,
                    content: {
                      type: part.content.content.type,
                      title: part.content.content.title,
                      citations: part.content.content.citations,
                      source: {
                        type: part.content.content.source.type,
                        mediaType: part.content.content.source.media_type,
                        data: part.content.content.source.data
                      }
                    }
                  }
                });
              } else if (part.content.type === "web_fetch_tool_result_error") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("web_fetch"),
                  isError: true,
                  result: {
                    type: "web_fetch_tool_result_error",
                    errorCode: part.content.error_code
                  }
                });
              }
              break;
            }
            case "web_search_tool_result": {
              if (Array.isArray(part.content)) {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("web_search"),
                  result: part.content.map((result) => {
                    var _a211;
                    return {
                      url: result.url,
                      title: result.title,
                      pageAge: (_a211 = result.page_age) != null ? _a211 : null,
                      encryptedContent: result.encrypted_content,
                      type: result.type
                    };
                  })
                });
                for (const result of part.content) {
                  content.push({
                    type: "source",
                    sourceType: "url",
                    id: this.generateId(),
                    url: result.url,
                    title: result.title,
                    providerMetadata: {
                      anthropic: {
                        pageAge: (_a31 = result.page_age) != null ? _a31 : null
                      }
                    }
                  });
                }
              } else {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("web_search"),
                  isError: true,
                  result: {
                    type: "web_search_tool_result_error",
                    errorCode: part.content.error_code
                  }
                });
              }
              break;
            }
            // code execution 20250522:
            case "code_execution_tool_result": {
              if (part.content.type === "code_execution_result") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("code_execution"),
                  result: {
                    type: part.content.type,
                    stdout: part.content.stdout,
                    stderr: part.content.stderr,
                    return_code: part.content.return_code,
                    content: (_b27 = part.content.content) != null ? _b27 : []
                  }
                });
              } else if (part.content.type === "code_execution_tool_result_error") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName("code_execution"),
                  isError: true,
                  result: {
                    type: "code_execution_tool_result_error",
                    errorCode: part.content.error_code
                  }
                });
              }
              break;
            }
            // code execution 20250825:
            case "bash_code_execution_tool_result":
            case "text_editor_code_execution_tool_result": {
              content.push({
                type: "tool-result",
                toolCallId: part.tool_use_id,
                toolName: toolNameMapping.toCustomToolName("code_execution"),
                result: part.content
              });
              break;
            }
            // tool search tool results:
            case "tool_search_tool_result": {
              const providerToolName = (_c = serverToolCalls[part.tool_use_id]) != null ? _c : "tool_search_tool_regex";
              if (part.content.type === "tool_search_tool_search_result") {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName(providerToolName),
                  result: part.content.tool_references.map((ref) => ({
                    type: ref.type,
                    toolName: ref.tool_name
                  }))
                });
              } else {
                content.push({
                  type: "tool-result",
                  toolCallId: part.tool_use_id,
                  toolName: toolNameMapping.toCustomToolName(providerToolName),
                  isError: true,
                  result: {
                    type: "tool_search_tool_result_error",
                    errorCode: part.content.error_code
                  }
                });
              }
              break;
            }
          }
        }
        return {
          content,
          finishReason: {
            unified: mapAnthropicStopReason2({
              finishReason: response.stop_reason,
              isJsonResponseFromTool
            }),
            raw: (_d = response.stop_reason) != null ? _d : void 0
          },
          usage: convertAnthropicMessagesUsage2(response.usage),
          request: { body: args },
          response: {
            id: (_e = response.id) != null ? _e : void 0,
            modelId: (_f = response.model) != null ? _f : void 0,
            headers: responseHeaders,
            body: rawResponse
          },
          warnings,
          providerMetadata: {
            anthropic: {
              usage: response.usage,
              cacheCreationInputTokens: (_g = response.usage.cache_creation_input_tokens) != null ? _g : null,
              stopSequence: (_h = response.stop_sequence) != null ? _h : null,
              container: response.container ? {
                expiresAt: response.container.expires_at,
                id: response.container.id,
                skills: (_j = (_i = response.container.skills) == null ? void 0 : _i.map((skill) => ({
                  type: skill.type,
                  skillId: skill.skill_id,
                  version: skill.version
                }))) != null ? _j : null
              } : null,
              contextManagement: (_k = mapAnthropicResponseContextManagement2(
                response.context_management
              )) != null ? _k : null
            }
          }
        };
      }
      async doStream(options) {
        var _a31, _b27;
        const {
          args: body,
          warnings,
          betas,
          usesJsonResponseTool,
          toolNameMapping
        } = await this.getArgs({
          ...options,
          stream: true,
          userSuppliedBetas: await this.getBetasFromHeaders(options.headers)
        });
        const citationDocuments = this.extractCitationDocuments(options.prompt);
        const url4 = this.buildRequestUrl(true);
        const { responseHeaders, value: response } = await postJsonToApi3({
          url: url4,
          headers: await this.getHeaders({ betas, headers: options.headers }),
          body: this.transformRequestBody(body),
          failedResponseHandler: anthropicFailedResponseHandler2,
          successfulResponseHandler: createEventSourceResponseHandler3(
            anthropicMessagesChunkSchema2
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        const usage = {
          input_tokens: 0,
          output_tokens: 0,
          cache_creation_input_tokens: 0,
          cache_read_input_tokens: 0
        };
        const contentBlocks = {};
        const mcpToolCalls = {};
        const serverToolCalls = {};
        let contextManagement = null;
        let rawUsage = void 0;
        let cacheCreationInputTokens = null;
        let stopSequence = null;
        let container = null;
        let isJsonResponseFromTool = false;
        let blockType = void 0;
        const generateId22 = this.generateId;
        const transformedStream = response.pipeThrough(
          new TransformStream({
            start(controller) {
              controller.enqueue({ type: "stream-start", warnings });
            },
            transform(chunk, controller) {
              var _a211, _b28, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
              if (options.includeRawChunks) {
                controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
              }
              if (!chunk.success) {
                controller.enqueue({ type: "error", error: chunk.error });
                return;
              }
              const value = chunk.value;
              switch (value.type) {
                case "ping": {
                  return;
                }
                case "content_block_start": {
                  const part = value.content_block;
                  const contentBlockType = part.type;
                  blockType = contentBlockType;
                  switch (contentBlockType) {
                    case "text": {
                      if (usesJsonResponseTool) {
                        return;
                      }
                      contentBlocks[value.index] = { type: "text" };
                      controller.enqueue({
                        type: "text-start",
                        id: String(value.index)
                      });
                      return;
                    }
                    case "thinking": {
                      contentBlocks[value.index] = { type: "reasoning" };
                      controller.enqueue({
                        type: "reasoning-start",
                        id: String(value.index)
                      });
                      return;
                    }
                    case "redacted_thinking": {
                      contentBlocks[value.index] = { type: "reasoning" };
                      controller.enqueue({
                        type: "reasoning-start",
                        id: String(value.index),
                        providerMetadata: {
                          anthropic: {
                            redactedData: part.data
                          }
                        }
                      });
                      return;
                    }
                    case "tool_use": {
                      const isJsonResponseTool = usesJsonResponseTool && part.name === "json";
                      if (isJsonResponseTool) {
                        isJsonResponseFromTool = true;
                        contentBlocks[value.index] = { type: "text" };
                        controller.enqueue({
                          type: "text-start",
                          id: String(value.index)
                        });
                      } else {
                        const caller = part.caller;
                        const callerInfo = caller ? {
                          type: caller.type,
                          toolId: "tool_id" in caller ? caller.tool_id : void 0
                        } : void 0;
                        const hasNonEmptyInput = part.input && Object.keys(part.input).length > 0;
                        const initialInput = hasNonEmptyInput ? JSON.stringify(part.input) : "";
                        contentBlocks[value.index] = {
                          type: "tool-call",
                          toolCallId: part.id,
                          toolName: part.name,
                          input: initialInput,
                          firstDelta: initialInput.length === 0,
                          ...callerInfo && { caller: callerInfo }
                        };
                        controller.enqueue({
                          type: "tool-input-start",
                          id: part.id,
                          toolName: part.name
                        });
                      }
                      return;
                    }
                    case "server_tool_use": {
                      if ([
                        "web_fetch",
                        "web_search",
                        // code execution 20250825:
                        "code_execution",
                        // code execution 20250825 text editor:
                        "text_editor_code_execution",
                        // code execution 20250825 bash:
                        "bash_code_execution"
                      ].includes(part.name)) {
                        const providerToolName = part.name === "text_editor_code_execution" || part.name === "bash_code_execution" ? "code_execution" : part.name;
                        const customToolName = toolNameMapping.toCustomToolName(providerToolName);
                        contentBlocks[value.index] = {
                          type: "tool-call",
                          toolCallId: part.id,
                          toolName: customToolName,
                          input: "",
                          providerExecuted: true,
                          firstDelta: true,
                          providerToolName: part.name
                        };
                        controller.enqueue({
                          type: "tool-input-start",
                          id: part.id,
                          toolName: customToolName,
                          providerExecuted: true
                        });
                      } else if (part.name === "tool_search_tool_regex" || part.name === "tool_search_tool_bm25") {
                        serverToolCalls[part.id] = part.name;
                        const customToolName = toolNameMapping.toCustomToolName(
                          part.name
                        );
                        contentBlocks[value.index] = {
                          type: "tool-call",
                          toolCallId: part.id,
                          toolName: customToolName,
                          input: "",
                          providerExecuted: true,
                          firstDelta: true,
                          providerToolName: part.name
                        };
                        controller.enqueue({
                          type: "tool-input-start",
                          id: part.id,
                          toolName: customToolName,
                          providerExecuted: true
                        });
                      }
                      return;
                    }
                    case "web_fetch_tool_result": {
                      if (part.content.type === "web_fetch_result") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("web_fetch"),
                          result: {
                            type: "web_fetch_result",
                            url: part.content.url,
                            retrievedAt: part.content.retrieved_at,
                            content: {
                              type: part.content.content.type,
                              title: part.content.content.title,
                              citations: part.content.content.citations,
                              source: {
                                type: part.content.content.source.type,
                                mediaType: part.content.content.source.media_type,
                                data: part.content.content.source.data
                              }
                            }
                          }
                        });
                      } else if (part.content.type === "web_fetch_tool_result_error") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("web_fetch"),
                          isError: true,
                          result: {
                            type: "web_fetch_tool_result_error",
                            errorCode: part.content.error_code
                          }
                        });
                      }
                      return;
                    }
                    case "web_search_tool_result": {
                      if (Array.isArray(part.content)) {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("web_search"),
                          result: part.content.map((result) => {
                            var _a37;
                            return {
                              url: result.url,
                              title: result.title,
                              pageAge: (_a37 = result.page_age) != null ? _a37 : null,
                              encryptedContent: result.encrypted_content,
                              type: result.type
                            };
                          })
                        });
                        for (const result of part.content) {
                          controller.enqueue({
                            type: "source",
                            sourceType: "url",
                            id: generateId22(),
                            url: result.url,
                            title: result.title,
                            providerMetadata: {
                              anthropic: {
                                pageAge: (_a211 = result.page_age) != null ? _a211 : null
                              }
                            }
                          });
                        }
                      } else {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("web_search"),
                          isError: true,
                          result: {
                            type: "web_search_tool_result_error",
                            errorCode: part.content.error_code
                          }
                        });
                      }
                      return;
                    }
                    // code execution 20250522:
                    case "code_execution_tool_result": {
                      if (part.content.type === "code_execution_result") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("code_execution"),
                          result: {
                            type: part.content.type,
                            stdout: part.content.stdout,
                            stderr: part.content.stderr,
                            return_code: part.content.return_code,
                            content: (_b28 = part.content.content) != null ? _b28 : []
                          }
                        });
                      } else if (part.content.type === "code_execution_tool_result_error") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName("code_execution"),
                          isError: true,
                          result: {
                            type: "code_execution_tool_result_error",
                            errorCode: part.content.error_code
                          }
                        });
                      }
                      return;
                    }
                    // code execution 20250825:
                    case "bash_code_execution_tool_result":
                    case "text_editor_code_execution_tool_result": {
                      controller.enqueue({
                        type: "tool-result",
                        toolCallId: part.tool_use_id,
                        toolName: toolNameMapping.toCustomToolName("code_execution"),
                        result: part.content
                      });
                      return;
                    }
                    // tool search tool results:
                    case "tool_search_tool_result": {
                      const providerToolName = (_c = serverToolCalls[part.tool_use_id]) != null ? _c : "tool_search_tool_regex";
                      if (part.content.type === "tool_search_tool_search_result") {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName(providerToolName),
                          result: part.content.tool_references.map((ref) => ({
                            type: ref.type,
                            toolName: ref.tool_name
                          }))
                        });
                      } else {
                        controller.enqueue({
                          type: "tool-result",
                          toolCallId: part.tool_use_id,
                          toolName: toolNameMapping.toCustomToolName(providerToolName),
                          isError: true,
                          result: {
                            type: "tool_search_tool_result_error",
                            errorCode: part.content.error_code
                          }
                        });
                      }
                      return;
                    }
                    case "mcp_tool_use": {
                      mcpToolCalls[part.id] = {
                        type: "tool-call",
                        toolCallId: part.id,
                        toolName: part.name,
                        input: JSON.stringify(part.input),
                        providerExecuted: true,
                        dynamic: true,
                        providerMetadata: {
                          anthropic: {
                            type: "mcp-tool-use",
                            serverName: part.server_name
                          }
                        }
                      };
                      controller.enqueue(mcpToolCalls[part.id]);
                      return;
                    }
                    case "mcp_tool_result": {
                      controller.enqueue({
                        type: "tool-result",
                        toolCallId: part.tool_use_id,
                        toolName: mcpToolCalls[part.tool_use_id].toolName,
                        isError: part.is_error,
                        result: part.content,
                        dynamic: true,
                        providerMetadata: mcpToolCalls[part.tool_use_id].providerMetadata
                      });
                      return;
                    }
                    default: {
                      const _exhaustiveCheck = contentBlockType;
                      throw new Error(
                        `Unsupported content block type: ${_exhaustiveCheck}`
                      );
                    }
                  }
                }
                case "content_block_stop": {
                  if (contentBlocks[value.index] != null) {
                    const contentBlock = contentBlocks[value.index];
                    switch (contentBlock.type) {
                      case "text": {
                        controller.enqueue({
                          type: "text-end",
                          id: String(value.index)
                        });
                        break;
                      }
                      case "reasoning": {
                        controller.enqueue({
                          type: "reasoning-end",
                          id: String(value.index)
                        });
                        break;
                      }
                      case "tool-call":
                        const isJsonResponseTool = usesJsonResponseTool && contentBlock.toolName === "json";
                        if (!isJsonResponseTool) {
                          controller.enqueue({
                            type: "tool-input-end",
                            id: contentBlock.toolCallId
                          });
                          let finalInput = contentBlock.input === "" ? "{}" : contentBlock.input;
                          if (contentBlock.providerToolName === "code_execution") {
                            try {
                              const parsed = JSON.parse(finalInput);
                              if (parsed != null && typeof parsed === "object" && "code" in parsed && !("type" in parsed)) {
                                finalInput = JSON.stringify({
                                  type: "programmatic-tool-call",
                                  ...parsed
                                });
                              }
                            } catch (e) {
                            }
                          }
                          controller.enqueue({
                            type: "tool-call",
                            toolCallId: contentBlock.toolCallId,
                            toolName: contentBlock.toolName,
                            input: finalInput,
                            providerExecuted: contentBlock.providerExecuted,
                            ...contentBlock.caller && {
                              providerMetadata: {
                                anthropic: {
                                  caller: contentBlock.caller
                                }
                              }
                            }
                          });
                        }
                        break;
                    }
                    delete contentBlocks[value.index];
                  }
                  blockType = void 0;
                  return;
                }
                case "content_block_delta": {
                  const deltaType = value.delta.type;
                  switch (deltaType) {
                    case "text_delta": {
                      if (usesJsonResponseTool) {
                        return;
                      }
                      controller.enqueue({
                        type: "text-delta",
                        id: String(value.index),
                        delta: value.delta.text
                      });
                      return;
                    }
                    case "thinking_delta": {
                      controller.enqueue({
                        type: "reasoning-delta",
                        id: String(value.index),
                        delta: value.delta.thinking
                      });
                      return;
                    }
                    case "signature_delta": {
                      if (blockType === "thinking") {
                        controller.enqueue({
                          type: "reasoning-delta",
                          id: String(value.index),
                          delta: "",
                          providerMetadata: {
                            anthropic: {
                              signature: value.delta.signature
                            }
                          }
                        });
                      }
                      return;
                    }
                    case "input_json_delta": {
                      const contentBlock = contentBlocks[value.index];
                      let delta = value.delta.partial_json;
                      if (delta.length === 0) {
                        return;
                      }
                      if (isJsonResponseFromTool) {
                        if ((contentBlock == null ? void 0 : contentBlock.type) !== "text") {
                          return;
                        }
                        controller.enqueue({
                          type: "text-delta",
                          id: String(value.index),
                          delta
                        });
                      } else {
                        if ((contentBlock == null ? void 0 : contentBlock.type) !== "tool-call") {
                          return;
                        }
                        if (contentBlock.firstDelta && (contentBlock.providerToolName === "bash_code_execution" || contentBlock.providerToolName === "text_editor_code_execution")) {
                          delta = `{"type": "${contentBlock.providerToolName}",${delta.substring(1)}`;
                        }
                        controller.enqueue({
                          type: "tool-input-delta",
                          id: contentBlock.toolCallId,
                          delta
                        });
                        contentBlock.input += delta;
                        contentBlock.firstDelta = false;
                      }
                      return;
                    }
                    case "citations_delta": {
                      const citation = value.delta.citation;
                      const source = createCitationSource2(
                        citation,
                        citationDocuments,
                        generateId22
                      );
                      if (source) {
                        controller.enqueue(source);
                      }
                      return;
                    }
                    default: {
                      const _exhaustiveCheck = deltaType;
                      throw new Error(
                        `Unsupported delta type: ${_exhaustiveCheck}`
                      );
                    }
                  }
                }
                case "message_start": {
                  usage.input_tokens = value.message.usage.input_tokens;
                  usage.cache_read_input_tokens = (_d = value.message.usage.cache_read_input_tokens) != null ? _d : 0;
                  usage.cache_creation_input_tokens = (_e = value.message.usage.cache_creation_input_tokens) != null ? _e : 0;
                  rawUsage = {
                    ...value.message.usage
                  };
                  cacheCreationInputTokens = (_f = value.message.usage.cache_creation_input_tokens) != null ? _f : null;
                  if (value.message.container != null) {
                    container = {
                      expiresAt: value.message.container.expires_at,
                      id: value.message.container.id,
                      skills: null
                    };
                  }
                  if (value.message.stop_reason != null) {
                    finishReason = {
                      unified: mapAnthropicStopReason2({
                        finishReason: value.message.stop_reason,
                        isJsonResponseFromTool
                      }),
                      raw: value.message.stop_reason
                    };
                  }
                  controller.enqueue({
                    type: "response-metadata",
                    id: (_g = value.message.id) != null ? _g : void 0,
                    modelId: (_h = value.message.model) != null ? _h : void 0
                  });
                  if (value.message.content != null) {
                    for (let contentIndex = 0; contentIndex < value.message.content.length; contentIndex++) {
                      const part = value.message.content[contentIndex];
                      if (part.type === "tool_use") {
                        const caller = part.caller;
                        const callerInfo = caller ? {
                          type: caller.type,
                          toolId: "tool_id" in caller ? caller.tool_id : void 0
                        } : void 0;
                        controller.enqueue({
                          type: "tool-input-start",
                          id: part.id,
                          toolName: part.name
                        });
                        const inputStr = JSON.stringify((_i = part.input) != null ? _i : {});
                        controller.enqueue({
                          type: "tool-input-delta",
                          id: part.id,
                          delta: inputStr
                        });
                        controller.enqueue({
                          type: "tool-input-end",
                          id: part.id
                        });
                        controller.enqueue({
                          type: "tool-call",
                          toolCallId: part.id,
                          toolName: part.name,
                          input: inputStr,
                          ...callerInfo && {
                            providerMetadata: {
                              anthropic: {
                                caller: callerInfo
                              }
                            }
                          }
                        });
                      }
                    }
                  }
                  return;
                }
                case "message_delta": {
                  usage.output_tokens = value.usage.output_tokens;
                  finishReason = {
                    unified: mapAnthropicStopReason2({
                      finishReason: value.delta.stop_reason,
                      isJsonResponseFromTool
                    }),
                    raw: (_j = value.delta.stop_reason) != null ? _j : void 0
                  };
                  stopSequence = (_k = value.delta.stop_sequence) != null ? _k : null;
                  container = value.delta.container != null ? {
                    expiresAt: value.delta.container.expires_at,
                    id: value.delta.container.id,
                    skills: (_m = (_l = value.delta.container.skills) == null ? void 0 : _l.map((skill) => ({
                      type: skill.type,
                      skillId: skill.skill_id,
                      version: skill.version
                    }))) != null ? _m : null
                  } : null;
                  if (value.delta.context_management) {
                    contextManagement = mapAnthropicResponseContextManagement2(
                      value.delta.context_management
                    );
                  }
                  rawUsage = {
                    ...rawUsage,
                    ...value.usage
                  };
                  return;
                }
                case "message_stop": {
                  controller.enqueue({
                    type: "finish",
                    finishReason,
                    usage: convertAnthropicMessagesUsage2(usage),
                    providerMetadata: {
                      anthropic: {
                        usage: rawUsage != null ? rawUsage : null,
                        cacheCreationInputTokens,
                        stopSequence,
                        container,
                        contextManagement
                      }
                    }
                  });
                  return;
                }
                case "error": {
                  controller.enqueue({ type: "error", error: value.error });
                  return;
                }
                default: {
                  const _exhaustiveCheck = value;
                  throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
                }
              }
            }
          })
        );
        const [streamForFirstChunk, streamForConsumer] = transformedStream.tee();
        const firstChunkReader = streamForFirstChunk.getReader();
        try {
          await firstChunkReader.read();
          let result = await firstChunkReader.read();
          if (((_a31 = result.value) == null ? void 0 : _a31.type) === "raw") {
            result = await firstChunkReader.read();
          }
          if (((_b27 = result.value) == null ? void 0 : _b27.type) === "error") {
            const error73 = result.value.error;
            throw new APICallError3({
              message: error73.message,
              url: url4,
              requestBodyValues: body,
              statusCode: error73.type === "overloaded_error" ? 529 : 500,
              responseHeaders,
              responseBody: JSON.stringify(error73),
              isRetryable: error73.type === "overloaded_error"
            });
          }
        } finally {
          firstChunkReader.cancel().catch(() => {
          });
          firstChunkReader.releaseLock();
        }
        return {
          stream: streamForConsumer,
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    bash_20241022InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          command: external_exports.string(),
          restart: external_exports.boolean().optional()
        })
      )
    );
    bash_202410222 = createProviderToolFactory2({
      id: "anthropic.bash_20241022",
      inputSchema: bash_20241022InputSchema2
    });
    bash_20250124InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          command: external_exports.string(),
          restart: external_exports.boolean().optional()
        })
      )
    );
    bash_202501242 = createProviderToolFactory2({
      id: "anthropic.bash_20250124",
      inputSchema: bash_20250124InputSchema2
    });
    computer_20241022InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          action: external_exports.enum([
            "key",
            "type",
            "mouse_move",
            "left_click",
            "left_click_drag",
            "right_click",
            "middle_click",
            "double_click",
            "screenshot",
            "cursor_position"
          ]),
          coordinate: external_exports.array(external_exports.number().int()).optional(),
          text: external_exports.string().optional()
        })
      )
    );
    computer_202410222 = createProviderToolFactory2({
      id: "anthropic.computer_20241022",
      inputSchema: computer_20241022InputSchema2
    });
    computer_20250124InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          action: external_exports.enum([
            "key",
            "hold_key",
            "type",
            "cursor_position",
            "mouse_move",
            "left_mouse_down",
            "left_mouse_up",
            "left_click",
            "left_click_drag",
            "right_click",
            "middle_click",
            "double_click",
            "triple_click",
            "scroll",
            "wait",
            "screenshot"
          ]),
          coordinate: external_exports.tuple([external_exports.number().int(), external_exports.number().int()]).optional(),
          duration: external_exports.number().optional(),
          scroll_amount: external_exports.number().optional(),
          scroll_direction: external_exports.enum(["up", "down", "left", "right"]).optional(),
          start_coordinate: external_exports.tuple([external_exports.number().int(), external_exports.number().int()]).optional(),
          text: external_exports.string().optional()
        })
      )
    );
    computer_202501242 = createProviderToolFactory2({
      id: "anthropic.computer_20250124",
      inputSchema: computer_20250124InputSchema2
    });
    memory_20250818InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.discriminatedUnion("command", [
          external_exports.object({
            command: external_exports.literal("view"),
            path: external_exports.string(),
            view_range: external_exports.tuple([external_exports.number(), external_exports.number()]).optional()
          }),
          external_exports.object({
            command: external_exports.literal("create"),
            path: external_exports.string(),
            file_text: external_exports.string()
          }),
          external_exports.object({
            command: external_exports.literal("str_replace"),
            path: external_exports.string(),
            old_str: external_exports.string(),
            new_str: external_exports.string()
          }),
          external_exports.object({
            command: external_exports.literal("insert"),
            path: external_exports.string(),
            insert_line: external_exports.number(),
            insert_text: external_exports.string()
          }),
          external_exports.object({
            command: external_exports.literal("delete"),
            path: external_exports.string()
          }),
          external_exports.object({
            command: external_exports.literal("rename"),
            old_path: external_exports.string(),
            new_path: external_exports.string()
          })
        ])
      )
    );
    memory_202508182 = createProviderToolFactory2({
      id: "anthropic.memory_20250818",
      inputSchema: memory_20250818InputSchema2
    });
    textEditor_20241022InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          command: external_exports.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
          path: external_exports.string(),
          file_text: external_exports.string().optional(),
          insert_line: external_exports.number().int().optional(),
          new_str: external_exports.string().optional(),
          old_str: external_exports.string().optional(),
          view_range: external_exports.array(external_exports.number().int()).optional()
        })
      )
    );
    textEditor_202410222 = createProviderToolFactory2({
      id: "anthropic.text_editor_20241022",
      inputSchema: textEditor_20241022InputSchema2
    });
    textEditor_20250124InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          command: external_exports.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
          path: external_exports.string(),
          file_text: external_exports.string().optional(),
          insert_line: external_exports.number().int().optional(),
          new_str: external_exports.string().optional(),
          old_str: external_exports.string().optional(),
          view_range: external_exports.array(external_exports.number().int()).optional()
        })
      )
    );
    textEditor_202501242 = createProviderToolFactory2({
      id: "anthropic.text_editor_20250124",
      inputSchema: textEditor_20250124InputSchema2
    });
    textEditor_20250429InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          command: external_exports.enum(["view", "create", "str_replace", "insert"]),
          path: external_exports.string(),
          file_text: external_exports.string().optional(),
          insert_line: external_exports.number().int().optional(),
          new_str: external_exports.string().optional(),
          old_str: external_exports.string().optional(),
          view_range: external_exports.array(external_exports.number().int()).optional()
        })
      )
    );
    textEditor_202504292 = createProviderToolFactory2({
      id: "anthropic.text_editor_20250429",
      inputSchema: textEditor_20250429InputSchema2
    });
    toolSearchBm25_20251119OutputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.array(
          external_exports.object({
            type: external_exports.literal("tool_reference"),
            toolName: external_exports.string()
          })
        )
      )
    );
    toolSearchBm25_20251119InputSchema2 = lazySchema2(
      () => zodSchema2(
        external_exports.object({
          /**
           * A natural language query to search for tools.
           * Claude will use BM25 text search to find relevant tools.
           */
          query: external_exports.string(),
          /**
           * Maximum number of tools to return. Optional.
           */
          limit: external_exports.number().optional()
        })
      )
    );
    factory72 = createProviderToolFactoryWithOutputSchema2({
      id: "anthropic.tool_search_bm25_20251119",
      inputSchema: toolSearchBm25_20251119InputSchema2,
      outputSchema: toolSearchBm25_20251119OutputSchema2
    });
  }
});

// node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/provider/dist/index.mjs
function getErrorMessage5(error73) {
  if (error73 == null) {
    return "unknown error";
  }
  if (typeof error73 === "string") {
    return error73;
  }
  if (error73 instanceof Error) {
    return error73.message;
  }
  return JSON.stringify(error73);
}
var marker20, symbol24, _a25, _b20, AISDKError4, name19, marker24, symbol25, _a26, _b24, APICallError4, name24, marker34, symbol34, _a34, _b34, EmptyResponseBodyError4, name34, marker44, symbol44, _a44, _b44, InvalidArgumentError4, name44, marker54, symbol54, _a54, _b54, InvalidPromptError4, name54, marker64, symbol64, _a64, _b64, InvalidResponseDataError4, name64, marker74, symbol74, _a74, _b74, JSONParseError4, name74, marker84, symbol84, _a84, _b84, LoadAPIKeyError4, name84, marker94, symbol94, _a94, _b94, LoadSettingError4, name94, marker104, symbol104, _a104, _b104, NoContentGeneratedError4, name104, marker114, symbol114, _a114, _b114, NoSuchModelError4, name114, marker124, symbol124, _a124, _b124, TooManyEmbeddingValuesForCallError4, name124, marker134, symbol134, _a134, _b134, TypeValidationError4, name134, marker144, symbol144, _a144, _b144, UnsupportedFunctionalityError4;
var init_dist18 = __esm({
  "node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/provider/dist/index.mjs"() {
    "use strict";
    marker20 = "vercel.ai.error";
    symbol24 = Symbol.for(marker20);
    AISDKError4 = class _AISDKError4 extends (_b20 = Error, _a25 = symbol24, _b20) {
      /**
       * Creates an AI SDK Error.
       *
       * @param {Object} params - The parameters for creating the error.
       * @param {string} params.name - The name of the error.
       * @param {string} params.message - The error message.
       * @param {unknown} [params.cause] - The underlying cause of the error.
       */
      constructor({
        name: name143,
        message,
        cause
      }) {
        super(message);
        this[_a25] = true;
        this.name = name143;
        this.cause = cause;
      }
      /**
       * Checks if the given error is an AI SDK Error.
       * @param {unknown} error - The error to check.
       * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
       */
      static isInstance(error73) {
        return _AISDKError4.hasMarker(error73, marker20);
      }
      static hasMarker(error73, marker153) {
        const markerSymbol = Symbol.for(marker153);
        return error73 != null && typeof error73 === "object" && markerSymbol in error73 && typeof error73[markerSymbol] === "boolean" && error73[markerSymbol] === true;
      }
    };
    name19 = "AI_APICallError";
    marker24 = `vercel.ai.error.${name19}`;
    symbol25 = Symbol.for(marker24);
    APICallError4 = class extends (_b24 = AISDKError4, _a26 = symbol25, _b24) {
      constructor({
        message,
        url: url4,
        requestBodyValues,
        statusCode,
        responseHeaders,
        responseBody,
        cause,
        isRetryable = statusCode != null && (statusCode === 408 || // request timeout
        statusCode === 409 || // conflict
        statusCode === 429 || // too many requests
        statusCode >= 500),
        // server error
        data
      }) {
        super({ name: name19, message, cause });
        this[_a26] = true;
        this.url = url4;
        this.requestBodyValues = requestBodyValues;
        this.statusCode = statusCode;
        this.responseHeaders = responseHeaders;
        this.responseBody = responseBody;
        this.isRetryable = isRetryable;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker24);
      }
    };
    name24 = "AI_EmptyResponseBodyError";
    marker34 = `vercel.ai.error.${name24}`;
    symbol34 = Symbol.for(marker34);
    EmptyResponseBodyError4 = class extends (_b34 = AISDKError4, _a34 = symbol34, _b34) {
      // used in isInstance
      constructor({ message = "Empty response body" } = {}) {
        super({ name: name24, message });
        this[_a34] = true;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker34);
      }
    };
    name34 = "AI_InvalidArgumentError";
    marker44 = `vercel.ai.error.${name34}`;
    symbol44 = Symbol.for(marker44);
    InvalidArgumentError4 = class extends (_b44 = AISDKError4, _a44 = symbol44, _b44) {
      constructor({
        message,
        cause,
        argument
      }) {
        super({ name: name34, message, cause });
        this[_a44] = true;
        this.argument = argument;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker44);
      }
    };
    name44 = "AI_InvalidPromptError";
    marker54 = `vercel.ai.error.${name44}`;
    symbol54 = Symbol.for(marker54);
    InvalidPromptError4 = class extends (_b54 = AISDKError4, _a54 = symbol54, _b54) {
      constructor({
        prompt,
        message,
        cause
      }) {
        super({ name: name44, message: `Invalid prompt: ${message}`, cause });
        this[_a54] = true;
        this.prompt = prompt;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker54);
      }
    };
    name54 = "AI_InvalidResponseDataError";
    marker64 = `vercel.ai.error.${name54}`;
    symbol64 = Symbol.for(marker64);
    InvalidResponseDataError4 = class extends (_b64 = AISDKError4, _a64 = symbol64, _b64) {
      constructor({
        data,
        message = `Invalid response data: ${JSON.stringify(data)}.`
      }) {
        super({ name: name54, message });
        this[_a64] = true;
        this.data = data;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker64);
      }
    };
    name64 = "AI_JSONParseError";
    marker74 = `vercel.ai.error.${name64}`;
    symbol74 = Symbol.for(marker74);
    JSONParseError4 = class extends (_b74 = AISDKError4, _a74 = symbol74, _b74) {
      constructor({ text: text2, cause }) {
        super({
          name: name64,
          message: `JSON parsing failed: Text: ${text2}.
Error message: ${getErrorMessage5(cause)}`,
          cause
        });
        this[_a74] = true;
        this.text = text2;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker74);
      }
    };
    name74 = "AI_LoadAPIKeyError";
    marker84 = `vercel.ai.error.${name74}`;
    symbol84 = Symbol.for(marker84);
    LoadAPIKeyError4 = class extends (_b84 = AISDKError4, _a84 = symbol84, _b84) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name74, message });
        this[_a84] = true;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker84);
      }
    };
    name84 = "AI_LoadSettingError";
    marker94 = `vercel.ai.error.${name84}`;
    symbol94 = Symbol.for(marker94);
    LoadSettingError4 = class extends (_b94 = AISDKError4, _a94 = symbol94, _b94) {
      // used in isInstance
      constructor({ message }) {
        super({ name: name84, message });
        this[_a94] = true;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker94);
      }
    };
    name94 = "AI_NoContentGeneratedError";
    marker104 = `vercel.ai.error.${name94}`;
    symbol104 = Symbol.for(marker104);
    NoContentGeneratedError4 = class extends (_b104 = AISDKError4, _a104 = symbol104, _b104) {
      // used in isInstance
      constructor({
        message = "No content generated."
      } = {}) {
        super({ name: name94, message });
        this[_a104] = true;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker104);
      }
    };
    name104 = "AI_NoSuchModelError";
    marker114 = `vercel.ai.error.${name104}`;
    symbol114 = Symbol.for(marker114);
    NoSuchModelError4 = class extends (_b114 = AISDKError4, _a114 = symbol114, _b114) {
      constructor({
        errorName = name104,
        modelId,
        modelType,
        message = `No such ${modelType}: ${modelId}`
      }) {
        super({ name: errorName, message });
        this[_a114] = true;
        this.modelId = modelId;
        this.modelType = modelType;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker114);
      }
    };
    name114 = "AI_TooManyEmbeddingValuesForCallError";
    marker124 = `vercel.ai.error.${name114}`;
    symbol124 = Symbol.for(marker124);
    TooManyEmbeddingValuesForCallError4 = class extends (_b124 = AISDKError4, _a124 = symbol124, _b124) {
      constructor(options) {
        super({
          name: name114,
          message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
        });
        this[_a124] = true;
        this.provider = options.provider;
        this.modelId = options.modelId;
        this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
        this.values = options.values;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker124);
      }
    };
    name124 = "AI_TypeValidationError";
    marker134 = `vercel.ai.error.${name124}`;
    symbol134 = Symbol.for(marker134);
    TypeValidationError4 = class _TypeValidationError4 extends (_b134 = AISDKError4, _a134 = symbol134, _b134) {
      constructor({ value, cause }) {
        super({
          name: name124,
          message: `Type validation failed: Value: ${JSON.stringify(value)}.
Error message: ${getErrorMessage5(cause)}`,
          cause
        });
        this[_a134] = true;
        this.value = value;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker134);
      }
      /**
       * Wraps an error into a TypeValidationError.
       * If the cause is already a TypeValidationError with the same value, it returns the cause.
       * Otherwise, it creates a new TypeValidationError.
       *
       * @param {Object} params - The parameters for wrapping the error.
       * @param {unknown} params.value - The value that failed validation.
       * @param {unknown} params.cause - The original error or cause of the validation failure.
       * @returns {TypeValidationError} A TypeValidationError instance.
       */
      static wrap({
        value,
        cause
      }) {
        return _TypeValidationError4.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError4({ value, cause });
      }
    };
    name134 = "AI_UnsupportedFunctionalityError";
    marker144 = `vercel.ai.error.${name134}`;
    symbol144 = Symbol.for(marker144);
    UnsupportedFunctionalityError4 = class extends (_b144 = AISDKError4, _a144 = symbol144, _b144) {
      constructor({
        functionality,
        message = `'${functionality}' functionality not supported.`
      }) {
        super({ name: name134, message });
        this[_a144] = true;
        this.functionality = functionality;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker144);
      }
    };
  }
});

// node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/provider-utils/dist/index.mjs
function combineHeaders4(...headers) {
  return headers.reduce(
    (combinedHeaders, currentHeaders) => ({
      ...combinedHeaders,
      ...currentHeaders != null ? currentHeaders : {}
    }),
    {}
  );
}
function extractResponseHeaders4(response) {
  return Object.fromEntries([...response.headers]);
}
function convertUint8ArrayToBase644(array4) {
  let latin1string = "";
  for (let i = 0; i < array4.length; i++) {
    latin1string += String.fromCodePoint(array4[i]);
  }
  return btoa5(latin1string);
}
function convertToBase643(value) {
  return value instanceof Uint8Array ? convertUint8ArrayToBase644(value) : value;
}
function isAbortError4(error73) {
  return (error73 instanceof Error || error73 instanceof DOMException) && (error73.name === "AbortError" || error73.name === "ResponseAborted" || // Next.js
  error73.name === "TimeoutError");
}
function handleFetchError4({
  error: error73,
  url: url4,
  requestBodyValues
}) {
  if (isAbortError4(error73)) {
    return error73;
  }
  if (error73 instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES4.includes(error73.message.toLowerCase())) {
    const cause = error73.cause;
    if (cause != null) {
      return new APICallError4({
        message: `Cannot connect to API: ${cause.message}`,
        cause,
        url: url4,
        requestBodyValues,
        isRetryable: true
        // retry when network error
      });
    }
  }
  return error73;
}
function getRuntimeEnvironmentUserAgent4(globalThisAny = globalThis) {
  var _a211, _b27, _c;
  if (globalThisAny.window) {
    return `runtime/browser`;
  }
  if ((_a211 = globalThisAny.navigator) == null ? void 0 : _a211.userAgent) {
    return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
  }
  if ((_c = (_b27 = globalThisAny.process) == null ? void 0 : _b27.versions) == null ? void 0 : _c.node) {
    return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
  }
  if (globalThisAny.EdgeRuntime) {
    return `runtime/vercel-edge`;
  }
  return "runtime/unknown";
}
function normalizeHeaders4(headers) {
  if (headers == null) {
    return {};
  }
  const normalized = {};
  if (headers instanceof Headers) {
    headers.forEach((value, key) => {
      normalized[key.toLowerCase()] = value;
    });
  } else {
    if (!Array.isArray(headers)) {
      headers = Object.entries(headers);
    }
    for (const [key, value] of headers) {
      if (value != null) {
        normalized[key.toLowerCase()] = value;
      }
    }
  }
  return normalized;
}
function withUserAgentSuffix4(headers, ...userAgentSuffixParts) {
  const normalizedHeaders = new Headers(normalizeHeaders4(headers));
  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
  normalizedHeaders.set(
    "user-agent",
    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
  );
  return Object.fromEntries(normalizedHeaders.entries());
}
function loadApiKey3({
  apiKey,
  environmentVariableName,
  apiKeyParameterName = "apiKey",
  description
}) {
  if (typeof apiKey === "string") {
    return apiKey;
  }
  if (apiKey != null) {
    throw new LoadAPIKeyError4({
      message: `${description} API key must be a string.`
    });
  }
  if (typeof process === "undefined") {
    throw new LoadAPIKeyError4({
      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
    });
  }
  apiKey = process.env[environmentVariableName];
  if (apiKey == null) {
    throw new LoadAPIKeyError4({
      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
    });
  }
  if (typeof apiKey !== "string") {
    throw new LoadAPIKeyError4({
      message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
    });
  }
  return apiKey;
}
function _parse6(text2) {
  const obj = JSON.parse(text2);
  if (obj === null || typeof obj !== "object") {
    return obj;
  }
  if (suspectProtoRx4.test(text2) === false && suspectConstructorRx4.test(text2) === false) {
    return obj;
  }
  return filter5(obj);
}
function filter5(obj) {
  let next = [obj];
  while (next.length) {
    const nodes = next;
    next = [];
    for (const node of nodes) {
      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
        throw new SyntaxError("Object contains forbidden prototype property");
      }
      for (const key in node) {
        const value = node[key];
        if (value && typeof value === "object") {
          next.push(value);
        }
      }
    }
  }
  return obj;
}
function secureJsonParse4(text2) {
  const { stackTraceLimit } = Error;
  try {
    Error.stackTraceLimit = 0;
  } catch (e) {
    return _parse6(text2);
  }
  try {
    return _parse6(text2);
  } finally {
    Error.stackTraceLimit = stackTraceLimit;
  }
}
function addAdditionalPropertiesToJsonSchema3(jsonSchema22) {
  if (jsonSchema22.type === "object" || Array.isArray(jsonSchema22.type) && jsonSchema22.type.includes("object")) {
    jsonSchema22.additionalProperties = false;
    const { properties } = jsonSchema22;
    if (properties != null) {
      for (const key of Object.keys(properties)) {
        properties[key] = visit3(properties[key]);
      }
    }
  }
  if (jsonSchema22.items != null) {
    jsonSchema22.items = Array.isArray(jsonSchema22.items) ? jsonSchema22.items.map(visit3) : visit3(jsonSchema22.items);
  }
  if (jsonSchema22.anyOf != null) {
    jsonSchema22.anyOf = jsonSchema22.anyOf.map(visit3);
  }
  if (jsonSchema22.allOf != null) {
    jsonSchema22.allOf = jsonSchema22.allOf.map(visit3);
  }
  if (jsonSchema22.oneOf != null) {
    jsonSchema22.oneOf = jsonSchema22.oneOf.map(visit3);
  }
  const { definitions } = jsonSchema22;
  if (definitions != null) {
    for (const key of Object.keys(definitions)) {
      definitions[key] = visit3(definitions[key]);
    }
  }
  return jsonSchema22;
}
function visit3(def) {
  if (typeof def === "boolean") return def;
  return addAdditionalPropertiesToJsonSchema3(def);
}
function parseAnyDef3() {
  return {};
}
function parseArrayDef3(def, refs) {
  var _a211, _b27, _c;
  const res = {
    type: "array"
  };
  if (((_a211 = def.type) == null ? void 0 : _a211._def) && ((_c = (_b27 = def.type) == null ? void 0 : _b27._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind2.ZodAny) {
    res.items = parseDef3(def.type._def, {
      ...refs,
      currentPath: [...refs.currentPath, "items"]
    });
  }
  if (def.minLength) {
    res.minItems = def.minLength.value;
  }
  if (def.maxLength) {
    res.maxItems = def.maxLength.value;
  }
  if (def.exactLength) {
    res.minItems = def.exactLength.value;
    res.maxItems = def.exactLength.value;
  }
  return res;
}
function parseBigintDef3(def) {
  const res = {
    type: "integer",
    format: "int64"
  };
  if (!def.checks) return res;
  for (const check3 of def.checks) {
    switch (check3.kind) {
      case "min":
        if (check3.inclusive) {
          res.minimum = check3.value;
        } else {
          res.exclusiveMinimum = check3.value;
        }
        break;
      case "max":
        if (check3.inclusive) {
          res.maximum = check3.value;
        } else {
          res.exclusiveMaximum = check3.value;
        }
        break;
      case "multipleOf":
        res.multipleOf = check3.value;
        break;
    }
  }
  return res;
}
function parseBooleanDef3() {
  return { type: "boolean" };
}
function parseBrandedDef3(_def, refs) {
  return parseDef3(_def.type._def, refs);
}
function parseDateDef3(def, refs, overrideDateStrategy) {
  const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
  if (Array.isArray(strategy)) {
    return {
      anyOf: strategy.map((item, i) => parseDateDef3(def, refs, item))
    };
  }
  switch (strategy) {
    case "string":
    case "format:date-time":
      return {
        type: "string",
        format: "date-time"
      };
    case "format:date":
      return {
        type: "string",
        format: "date"
      };
    case "integer":
      return integerDateParser3(def);
  }
}
function parseDefaultDef3(_def, refs) {
  return {
    ...parseDef3(_def.innerType._def, refs),
    default: _def.defaultValue()
  };
}
function parseEffectsDef3(_def, refs) {
  return refs.effectStrategy === "input" ? parseDef3(_def.schema._def, refs) : parseAnyDef3();
}
function parseEnumDef3(def) {
  return {
    type: "string",
    enum: Array.from(def.values)
  };
}
function parseIntersectionDef3(def, refs) {
  const allOf = [
    parseDef3(def.left._def, {
      ...refs,
      currentPath: [...refs.currentPath, "allOf", "0"]
    }),
    parseDef3(def.right._def, {
      ...refs,
      currentPath: [...refs.currentPath, "allOf", "1"]
    })
  ].filter((x) => !!x);
  const mergedAllOf = [];
  allOf.forEach((schema) => {
    if (isJsonSchema7AllOfType3(schema)) {
      mergedAllOf.push(...schema.allOf);
    } else {
      let nestedSchema = schema;
      if ("additionalProperties" in schema && schema.additionalProperties === false) {
        const { additionalProperties, ...rest } = schema;
        nestedSchema = rest;
      }
      mergedAllOf.push(nestedSchema);
    }
  });
  return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
}
function parseLiteralDef3(def) {
  const parsedType3 = typeof def.value;
  if (parsedType3 !== "bigint" && parsedType3 !== "number" && parsedType3 !== "boolean" && parsedType3 !== "string") {
    return {
      type: Array.isArray(def.value) ? "array" : "object"
    };
  }
  return {
    type: parsedType3 === "bigint" ? "integer" : parsedType3,
    const: def.value
  };
}
function parseStringDef3(def, refs) {
  const res = {
    type: "string"
  };
  if (def.checks) {
    for (const check3 of def.checks) {
      switch (check3.kind) {
        case "min":
          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value;
          break;
        case "max":
          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value;
          break;
        case "email":
          switch (refs.emailStrategy) {
            case "format:email":
              addFormat3(res, "email", check3.message, refs);
              break;
            case "format:idn-email":
              addFormat3(res, "idn-email", check3.message, refs);
              break;
            case "pattern:zod":
              addPattern3(res, zodPatterns3.email, check3.message, refs);
              break;
          }
          break;
        case "url":
          addFormat3(res, "uri", check3.message, refs);
          break;
        case "uuid":
          addFormat3(res, "uuid", check3.message, refs);
          break;
        case "regex":
          addPattern3(res, check3.regex, check3.message, refs);
          break;
        case "cuid":
          addPattern3(res, zodPatterns3.cuid, check3.message, refs);
          break;
        case "cuid2":
          addPattern3(res, zodPatterns3.cuid2, check3.message, refs);
          break;
        case "startsWith":
          addPattern3(
            res,
            RegExp(`^${escapeLiteralCheckValue3(check3.value, refs)}`),
            check3.message,
            refs
          );
          break;
        case "endsWith":
          addPattern3(
            res,
            RegExp(`${escapeLiteralCheckValue3(check3.value, refs)}$`),
            check3.message,
            refs
          );
          break;
        case "datetime":
          addFormat3(res, "date-time", check3.message, refs);
          break;
        case "date":
          addFormat3(res, "date", check3.message, refs);
          break;
        case "time":
          addFormat3(res, "time", check3.message, refs);
          break;
        case "duration":
          addFormat3(res, "duration", check3.message, refs);
          break;
        case "length":
          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value;
          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value;
          break;
        case "includes": {
          addPattern3(
            res,
            RegExp(escapeLiteralCheckValue3(check3.value, refs)),
            check3.message,
            refs
          );
          break;
        }
        case "ip": {
          if (check3.version !== "v6") {
            addFormat3(res, "ipv4", check3.message, refs);
          }
          if (check3.version !== "v4") {
            addFormat3(res, "ipv6", check3.message, refs);
          }
          break;
        }
        case "base64url":
          addPattern3(res, zodPatterns3.base64url, check3.message, refs);
          break;
        case "jwt":
          addPattern3(res, zodPatterns3.jwt, check3.message, refs);
          break;
        case "cidr": {
          if (check3.version !== "v6") {
            addPattern3(res, zodPatterns3.ipv4Cidr, check3.message, refs);
          }
          if (check3.version !== "v4") {
            addPattern3(res, zodPatterns3.ipv6Cidr, check3.message, refs);
          }
          break;
        }
        case "emoji":
          addPattern3(res, zodPatterns3.emoji(), check3.message, refs);
          break;
        case "ulid": {
          addPattern3(res, zodPatterns3.ulid, check3.message, refs);
          break;
        }
        case "base64": {
          switch (refs.base64Strategy) {
            case "format:binary": {
              addFormat3(res, "binary", check3.message, refs);
              break;
            }
            case "contentEncoding:base64": {
              res.contentEncoding = "base64";
              break;
            }
            case "pattern:zod": {
              addPattern3(res, zodPatterns3.base64, check3.message, refs);
              break;
            }
          }
          break;
        }
        case "nanoid": {
          addPattern3(res, zodPatterns3.nanoid, check3.message, refs);
        }
        case "toLowerCase":
        case "toUpperCase":
        case "trim":
          break;
        default:
          /* @__PURE__ */ ((_) => {
          })(check3);
      }
    }
  }
  return res;
}
function escapeLiteralCheckValue3(literal3, refs) {
  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric3(literal3) : literal3;
}
function escapeNonAlphaNumeric3(source) {
  let result = "";
  for (let i = 0; i < source.length; i++) {
    if (!ALPHA_NUMERIC4.has(source[i])) {
      result += "\\";
    }
    result += source[i];
  }
  return result;
}
function addFormat3(schema, value, message, refs) {
  var _a211;
  if (schema.format || ((_a211 = schema.anyOf) == null ? void 0 : _a211.some((x) => x.format))) {
    if (!schema.anyOf) {
      schema.anyOf = [];
    }
    if (schema.format) {
      schema.anyOf.push({
        format: schema.format
      });
      delete schema.format;
    }
    schema.anyOf.push({
      format: value,
      ...message && refs.errorMessages && { errorMessage: { format: message } }
    });
  } else {
    schema.format = value;
  }
}
function addPattern3(schema, regex, message, refs) {
  var _a211;
  if (schema.pattern || ((_a211 = schema.allOf) == null ? void 0 : _a211.some((x) => x.pattern))) {
    if (!schema.allOf) {
      schema.allOf = [];
    }
    if (schema.pattern) {
      schema.allOf.push({
        pattern: schema.pattern
      });
      delete schema.pattern;
    }
    schema.allOf.push({
      pattern: stringifyRegExpWithFlags3(regex, refs),
      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
    });
  } else {
    schema.pattern = stringifyRegExpWithFlags3(regex, refs);
  }
}
function stringifyRegExpWithFlags3(regex, refs) {
  var _a211;
  if (!refs.applyRegexFlags || !regex.flags) {
    return regex.source;
  }
  const flags = {
    i: regex.flags.includes("i"),
    // Case-insensitive
    m: regex.flags.includes("m"),
    // `^` and `$` matches adjacent to newline characters
    s: regex.flags.includes("s")
    // `.` matches newlines
  };
  const source = flags.i ? regex.source.toLowerCase() : regex.source;
  let pattern = "";
  let isEscaped = false;
  let inCharGroup = false;
  let inCharRange = false;
  for (let i = 0; i < source.length; i++) {
    if (isEscaped) {
      pattern += source[i];
      isEscaped = false;
      continue;
    }
    if (flags.i) {
      if (inCharGroup) {
        if (source[i].match(/[a-z]/)) {
          if (inCharRange) {
            pattern += source[i];
            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
            inCharRange = false;
          } else if (source[i + 1] === "-" && ((_a211 = source[i + 2]) == null ? void 0 : _a211.match(/[a-z]/))) {
            pattern += source[i];
            inCharRange = true;
          } else {
            pattern += `${source[i]}${source[i].toUpperCase()}`;
          }
          continue;
        }
      } else if (source[i].match(/[a-z]/)) {
        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
        continue;
      }
    }
    if (flags.m) {
      if (source[i] === "^") {
        pattern += `(^|(?<=[\r
]))`;
        continue;
      } else if (source[i] === "$") {
        pattern += `($|(?=[\r
]))`;
        continue;
      }
    }
    if (flags.s && source[i] === ".") {
      pattern += inCharGroup ? `${source[i]}\r
` : `[${source[i]}\r
]`;
      continue;
    }
    pattern += source[i];
    if (source[i] === "\\") {
      isEscaped = true;
    } else if (inCharGroup && source[i] === "]") {
      inCharGroup = false;
    } else if (!inCharGroup && source[i] === "[") {
      inCharGroup = true;
    }
  }
  try {
    new RegExp(pattern);
  } catch (e) {
    console.warn(
      `Could not convert regex pattern at ${refs.currentPath.join(
        "/"
      )} to a flag-independent form! Falling back to the flag-ignorant source`
    );
    return regex.source;
  }
  return pattern;
}
function parseRecordDef3(def, refs) {
  var _a211, _b27, _c, _d, _e, _f;
  const schema = {
    type: "object",
    additionalProperties: (_a211 = parseDef3(def.valueType._def, {
      ...refs,
      currentPath: [...refs.currentPath, "additionalProperties"]
    })) != null ? _a211 : refs.allowedAdditionalProperties
  };
  if (((_b27 = def.keyType) == null ? void 0 : _b27._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
    const { type, ...keyType } = parseStringDef3(def.keyType._def, refs);
    return {
      ...schema,
      propertyNames: keyType
    };
  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind2.ZodEnum) {
    return {
      ...schema,
      propertyNames: {
        enum: def.keyType._def.values
      }
    };
  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
    const { type, ...keyType } = parseBrandedDef3(
      def.keyType._def,
      refs
    );
    return {
      ...schema,
      propertyNames: keyType
    };
  }
  return schema;
}
function parseMapDef3(def, refs) {
  if (refs.mapStrategy === "record") {
    return parseRecordDef3(def, refs);
  }
  const keys2 = parseDef3(def.keyType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items", "items", "0"]
  }) || parseAnyDef3();
  const values = parseDef3(def.valueType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items", "items", "1"]
  }) || parseAnyDef3();
  return {
    type: "array",
    maxItems: 125,
    items: {
      type: "array",
      items: [keys2, values],
      minItems: 2,
      maxItems: 2
    }
  };
}
function parseNativeEnumDef3(def) {
  const object4 = def.values;
  const actualKeys = Object.keys(def.values).filter((key) => {
    return typeof object4[object4[key]] !== "number";
  });
  const actualValues = actualKeys.map((key) => object4[key]);
  const parsedTypes = Array.from(
    new Set(actualValues.map((values) => typeof values))
  );
  return {
    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
    enum: actualValues
  };
}
function parseNeverDef3() {
  return { not: parseAnyDef3() };
}
function parseNullDef3() {
  return {
    type: "null"
  };
}
function parseUnionDef3(def, refs) {
  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
  if (options.every(
    (x) => x._def.typeName in primitiveMappings3 && (!x._def.checks || !x._def.checks.length)
  )) {
    const types = options.reduce((types2, x) => {
      const type = primitiveMappings3[x._def.typeName];
      return type && !types2.includes(type) ? [...types2, type] : types2;
    }, []);
    return {
      type: types.length > 1 ? types : types[0]
    };
  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
    const types = options.reduce(
      (acc, x) => {
        const type = typeof x._def.value;
        switch (type) {
          case "string":
          case "number":
          case "boolean":
            return [...acc, type];
          case "bigint":
            return [...acc, "integer"];
          case "object":
            if (x._def.value === null) return [...acc, "null"];
          case "symbol":
          case "undefined":
          case "function":
          default:
            return acc;
        }
      },
      []
    );
    if (types.length === options.length) {
      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
      return {
        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
        enum: options.reduce(
          (acc, x) => {
            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
          },
          []
        )
      };
    }
  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
    return {
      type: "string",
      enum: options.reduce(
        (acc, x) => [
          ...acc,
          ...x._def.values.filter((x2) => !acc.includes(x2))
        ],
        []
      )
    };
  }
  return asAnyOf3(def, refs);
}
function parseNullableDef3(def, refs) {
  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
    def.innerType._def.typeName
  ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
    return {
      type: [
        primitiveMappings3[def.innerType._def.typeName],
        "null"
      ]
    };
  }
  const base = parseDef3(def.innerType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "anyOf", "0"]
  });
  return base && { anyOf: [base, { type: "null" }] };
}
function parseNumberDef3(def) {
  const res = {
    type: "number"
  };
  if (!def.checks) return res;
  for (const check3 of def.checks) {
    switch (check3.kind) {
      case "int":
        res.type = "integer";
        break;
      case "min":
        if (check3.inclusive) {
          res.minimum = check3.value;
        } else {
          res.exclusiveMinimum = check3.value;
        }
        break;
      case "max":
        if (check3.inclusive) {
          res.maximum = check3.value;
        } else {
          res.exclusiveMaximum = check3.value;
        }
        break;
      case "multipleOf":
        res.multipleOf = check3.value;
        break;
    }
  }
  return res;
}
function parseObjectDef3(def, refs) {
  const result = {
    type: "object",
    properties: {}
  };
  const required3 = [];
  const shape = def.shape();
  for (const propName in shape) {
    let propDef = shape[propName];
    if (propDef === void 0 || propDef._def === void 0) {
      continue;
    }
    const propOptional = safeIsOptional3(propDef);
    const parsedDef = parseDef3(propDef._def, {
      ...refs,
      currentPath: [...refs.currentPath, "properties", propName],
      propertyPath: [...refs.currentPath, "properties", propName]
    });
    if (parsedDef === void 0) {
      continue;
    }
    result.properties[propName] = parsedDef;
    if (!propOptional) {
      required3.push(propName);
    }
  }
  if (required3.length) {
    result.required = required3;
  }
  const additionalProperties = decideAdditionalProperties3(def, refs);
  if (additionalProperties !== void 0) {
    result.additionalProperties = additionalProperties;
  }
  return result;
}
function decideAdditionalProperties3(def, refs) {
  if (def.catchall._def.typeName !== "ZodNever") {
    return parseDef3(def.catchall._def, {
      ...refs,
      currentPath: [...refs.currentPath, "additionalProperties"]
    });
  }
  switch (def.unknownKeys) {
    case "passthrough":
      return refs.allowedAdditionalProperties;
    case "strict":
      return refs.rejectedAdditionalProperties;
    case "strip":
      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
  }
}
function safeIsOptional3(schema) {
  try {
    return schema.isOptional();
  } catch (e) {
    return true;
  }
}
function parsePromiseDef3(def, refs) {
  return parseDef3(def.type._def, refs);
}
function parseSetDef3(def, refs) {
  const items = parseDef3(def.valueType._def, {
    ...refs,
    currentPath: [...refs.currentPath, "items"]
  });
  const schema = {
    type: "array",
    uniqueItems: true,
    items
  };
  if (def.minSize) {
    schema.minItems = def.minSize.value;
  }
  if (def.maxSize) {
    schema.maxItems = def.maxSize.value;
  }
  return schema;
}
function parseTupleDef3(def, refs) {
  if (def.rest) {
    return {
      type: "array",
      minItems: def.items.length,
      items: def.items.map(
        (x, i) => parseDef3(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "items", `${i}`]
        })
      ).reduce(
        (acc, x) => x === void 0 ? acc : [...acc, x],
        []
      ),
      additionalItems: parseDef3(def.rest._def, {
        ...refs,
        currentPath: [...refs.currentPath, "additionalItems"]
      })
    };
  } else {
    return {
      type: "array",
      minItems: def.items.length,
      maxItems: def.items.length,
      items: def.items.map(
        (x, i) => parseDef3(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "items", `${i}`]
        })
      ).reduce(
        (acc, x) => x === void 0 ? acc : [...acc, x],
        []
      )
    };
  }
}
function parseUndefinedDef3() {
  return {
    not: parseAnyDef3()
  };
}
function parseUnknownDef3() {
  return parseAnyDef3();
}
function parseDef3(def, refs, forceResolution = false) {
  var _a211;
  const seenItem = refs.seen.get(def);
  if (refs.override) {
    const overrideResult = (_a211 = refs.override) == null ? void 0 : _a211.call(
      refs,
      def,
      refs,
      seenItem,
      forceResolution
    );
    if (overrideResult !== ignoreOverride3) {
      return overrideResult;
    }
  }
  if (seenItem && !forceResolution) {
    const seenSchema = get$ref3(seenItem, refs);
    if (seenSchema !== void 0) {
      return seenSchema;
    }
  }
  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
  refs.seen.set(def, newItem);
  const jsonSchemaOrGetter = selectParser3(def, def.typeName, refs);
  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef3(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
  if (jsonSchema22) {
    addMeta3(def, refs, jsonSchema22);
  }
  if (refs.postProcess) {
    const postProcessResult = refs.postProcess(jsonSchema22, def, refs);
    newItem.jsonSchema = jsonSchema22;
    return postProcessResult;
  }
  newItem.jsonSchema = jsonSchema22;
  return jsonSchema22;
}
function jsonSchema3(jsonSchema22, {
  validate
} = {}) {
  return {
    [schemaSymbol3]: true,
    _type: void 0,
    // should never be used directly
    get jsonSchema() {
      if (typeof jsonSchema22 === "function") {
        jsonSchema22 = jsonSchema22();
      }
      return jsonSchema22;
    },
    validate
  };
}
function isSchema3(value) {
  return typeof value === "object" && value !== null && schemaSymbol3 in value && value[schemaSymbol3] === true && "jsonSchema" in value && "validate" in value;
}
function asSchema3(schema) {
  return schema == null ? jsonSchema3({ properties: {}, additionalProperties: false }) : isSchema3(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema3(schema) : standardSchema3(schema) : schema();
}
function standardSchema3(standardSchema22) {
  return jsonSchema3(
    () => standardSchema22["~standard"].jsonSchema.input({
      target: "draft-07"
    }),
    {
      validate: async (value) => {
        const result = await standardSchema22["~standard"].validate(value);
        return "value" in result ? { success: true, value: result.value } : {
          success: false,
          error: new TypeValidationError4({
            value,
            cause: result.issues
          })
        };
      }
    }
  );
}
function zod3Schema3(zodSchema22, options) {
  var _a211;
  const useReferences = (_a211 = options == null ? void 0 : options.useReferences) != null ? _a211 : false;
  return jsonSchema3(
    // defer json schema creation to avoid unnecessary computation when only validation is needed
    () => zod3ToJsonSchema3(zodSchema22, {
      $refStrategy: useReferences ? "root" : "none"
    }),
    {
      validate: async (value) => {
        const result = await zodSchema22.safeParseAsync(value);
        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
      }
    }
  );
}
function zod4Schema3(zodSchema22, options) {
  var _a211;
  const useReferences = (_a211 = options == null ? void 0 : options.useReferences) != null ? _a211 : false;
  return jsonSchema3(
    // defer json schema creation to avoid unnecessary computation when only validation is needed
    () => addAdditionalPropertiesToJsonSchema3(
      toJSONSchema(zodSchema22, {
        target: "draft-7",
        io: "input",
        reused: useReferences ? "ref" : "inline"
      })
    ),
    {
      validate: async (value) => {
        const result = await safeParseAsync2(zodSchema22, value);
        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
      }
    }
  );
}
function isZod4Schema3(zodSchema22) {
  return "_zod" in zodSchema22;
}
function zodSchema3(zodSchema22, options) {
  if (isZod4Schema3(zodSchema22)) {
    return zod4Schema3(zodSchema22, options);
  } else {
    return zod3Schema3(zodSchema22, options);
  }
}
async function validateTypes4({
  value,
  schema
}) {
  const result = await safeValidateTypes4({ value, schema });
  if (!result.success) {
    throw TypeValidationError4.wrap({ value, cause: result.error });
  }
  return result.value;
}
async function safeValidateTypes4({
  value,
  schema
}) {
  const actualSchema = asSchema3(schema);
  try {
    if (actualSchema.validate == null) {
      return { success: true, value, rawValue: value };
    }
    const result = await actualSchema.validate(value);
    if (result.success) {
      return { success: true, value: result.value, rawValue: value };
    }
    return {
      success: false,
      error: TypeValidationError4.wrap({ value, cause: result.error }),
      rawValue: value
    };
  } catch (error73) {
    return {
      success: false,
      error: TypeValidationError4.wrap({ value, cause: error73 }),
      rawValue: value
    };
  }
}
async function parseJSON4({
  text: text2,
  schema
}) {
  try {
    const value = secureJsonParse4(text2);
    if (schema == null) {
      return value;
    }
    return validateTypes4({ value, schema });
  } catch (error73) {
    if (JSONParseError4.isInstance(error73) || TypeValidationError4.isInstance(error73)) {
      throw error73;
    }
    throw new JSONParseError4({ text: text2, cause: error73 });
  }
}
async function safeParseJSON4({
  text: text2,
  schema
}) {
  try {
    const value = secureJsonParse4(text2);
    if (schema == null) {
      return { success: true, value, rawValue: value };
    }
    return await safeValidateTypes4({ value, schema });
  } catch (error73) {
    return {
      success: false,
      error: JSONParseError4.isInstance(error73) ? error73 : new JSONParseError4({ text: text2, cause: error73 }),
      rawValue: void 0
    };
  }
}
function isParsableJson3(input) {
  try {
    secureJsonParse4(input);
    return true;
  } catch (e) {
    return false;
  }
}
function parseJsonEventStream4({
  stream: stream4,
  schema
}) {
  return stream4.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream2()).pipeThrough(
    new TransformStream({
      async transform({ data }, controller) {
        if (data === "[DONE]") {
          return;
        }
        controller.enqueue(await safeParseJSON4({ text: data, schema }));
      }
    })
  );
}
async function parseProviderOptions3({
  provider,
  providerOptions,
  schema
}) {
  if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
    return void 0;
  }
  const parsedProviderOptions = await safeValidateTypes4({
    value: providerOptions[provider],
    schema
  });
  if (!parsedProviderOptions.success) {
    throw new InvalidArgumentError4({
      argument: "providerOptions",
      message: `invalid ${provider} provider options`,
      cause: parsedProviderOptions.error
    });
  }
  return parsedProviderOptions.value;
}
function withoutTrailingSlash3(url4) {
  return url4 == null ? void 0 : url4.replace(/\/$/, "");
}
var btoa5, atob5, name20, marker21, symbol26, _a27, _b21, DownloadError4, createIdGenerator4, generateId4, FETCH_FAILED_ERROR_MESSAGES4, VERSION12, suspectProtoRx4, suspectConstructorRx4, ignoreOverride3, defaultOptions3, getDefaultOptions3, parseCatchDef3, integerDateParser3, isJsonSchema7AllOfType3, emojiRegex4, zodPatterns3, ALPHA_NUMERIC4, primitiveMappings3, asAnyOf3, parseOptionalDef3, parsePipelineDef3, parseReadonlyDef3, selectParser3, getRelativePath3, get$ref3, addMeta3, getRefs3, zod3ToJsonSchema3, schemaSymbol3, getOriginalFetch24, postJsonToApi4, postToApi4, createJsonErrorResponseHandler4, createEventSourceResponseHandler4, createJsonResponseHandler4;
var init_dist19 = __esm({
  "node_modules/vercel-minimax-ai-provider/node_modules/@ai-sdk/provider-utils/dist/index.mjs"() {
    "use strict";
    init_dist18();
    init_dist18();
    init_dist18();
    init_dist18();
    init_dist18();
    init_dist18();
    init_dist18();
    init_v42();
    init_v3();
    init_v3();
    init_v3();
    init_stream();
    init_dist18();
    init_dist18();
    init_dist18();
    init_dist9();
    ({ btoa: btoa5, atob: atob5 } = globalThis);
    name20 = "AI_DownloadError";
    marker21 = `vercel.ai.error.${name20}`;
    symbol26 = Symbol.for(marker21);
    DownloadError4 = class extends (_b21 = AISDKError4, _a27 = symbol26, _b21) {
      constructor({
        url: url4,
        statusCode,
        statusText,
        cause,
        message = cause == null ? `Failed to download ${url4}: ${statusCode} ${statusText}` : `Failed to download ${url4}: ${cause}`
      }) {
        super({ name: name20, message, cause });
        this[_a27] = true;
        this.url = url4;
        this.statusCode = statusCode;
        this.statusText = statusText;
      }
      static isInstance(error73) {
        return AISDKError4.hasMarker(error73, marker21);
      }
    };
    createIdGenerator4 = ({
      prefix,
      size = 16,
      alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
      separator = "-"
    } = {}) => {
      const generator = () => {
        const alphabetLength = alphabet.length;
        const chars = new Array(size);
        for (let i = 0; i < size; i++) {
          chars[i] = alphabet[Math.random() * alphabetLength | 0];
        }
        return chars.join("");
      };
      if (prefix == null) {
        return generator;
      }
      if (alphabet.includes(separator)) {
        throw new InvalidArgumentError4({
          argument: "separator",
          message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
        });
      }
      return () => `${prefix}${separator}${generator()}`;
    };
    generateId4 = createIdGenerator4();
    FETCH_FAILED_ERROR_MESSAGES4 = ["fetch failed", "failed to fetch"];
    VERSION12 = true ? "4.0.4" : "0.0.0-test";
    suspectProtoRx4 = /"__proto__"\s*:/;
    suspectConstructorRx4 = /"constructor"\s*:/;
    ignoreOverride3 = /* @__PURE__ */ Symbol(
      "Let zodToJsonSchema decide on which parser to use"
    );
    defaultOptions3 = {
      name: void 0,
      $refStrategy: "root",
      basePath: ["#"],
      effectStrategy: "input",
      pipeStrategy: "all",
      dateStrategy: "format:date-time",
      mapStrategy: "entries",
      removeAdditionalStrategy: "passthrough",
      allowedAdditionalProperties: true,
      rejectedAdditionalProperties: false,
      definitionPath: "definitions",
      strictUnions: false,
      definitions: {},
      errorMessages: false,
      patternStrategy: "escape",
      applyRegexFlags: false,
      emailStrategy: "format:email",
      base64Strategy: "contentEncoding:base64",
      nameStrategy: "ref"
    };
    getDefaultOptions3 = (options) => typeof options === "string" ? {
      ...defaultOptions3,
      name: options
    } : {
      ...defaultOptions3,
      ...options
    };
    parseCatchDef3 = (def, refs) => {
      return parseDef3(def.innerType._def, refs);
    };
    integerDateParser3 = (def) => {
      const res = {
        type: "integer",
        format: "unix-time"
      };
      for (const check3 of def.checks) {
        switch (check3.kind) {
          case "min":
            res.minimum = check3.value;
            break;
          case "max":
            res.maximum = check3.value;
            break;
        }
      }
      return res;
    };
    isJsonSchema7AllOfType3 = (type) => {
      if ("type" in type && type.type === "string") return false;
      return "allOf" in type;
    };
    emojiRegex4 = void 0;
    zodPatterns3 = {
      /**
       * `c` was changed to `[cC]` to replicate /i flag
       */
      cuid: /^[cC][^\s-]{8,}$/,
      cuid2: /^[0-9a-z]+$/,
      ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
      /**
       * `a-z` was added to replicate /i flag
       */
      email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
      /**
       * Constructed a valid Unicode RegExp
       *
       * Lazily instantiate since this type of regex isn't supported
       * in all envs (e.g. React Native).
       *
       * See:
       * https://github.com/colinhacks/zod/issues/2433
       * Fix in Zod:
       * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
       */
      emoji: () => {
        if (emojiRegex4 === void 0) {
          emojiRegex4 = RegExp(
            "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
            "u"
          );
        }
        return emojiRegex4;
      },
      /**
       * Unused
       */
      uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
      /**
       * Unused
       */
      ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
      ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
      /**
       * Unused
       */
      ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
      ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
      base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
      base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
      nanoid: /^[a-zA-Z0-9_-]{21}$/,
      jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
    };
    ALPHA_NUMERIC4 = new Set(
      "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
    );
    primitiveMappings3 = {
      ZodString: "string",
      ZodNumber: "number",
      ZodBigInt: "integer",
      ZodBoolean: "boolean",
      ZodNull: "null"
    };
    asAnyOf3 = (def, refs) => {
      const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
        (x, i) => parseDef3(x._def, {
          ...refs,
          currentPath: [...refs.currentPath, "anyOf", `${i}`]
        })
      ).filter(
        (x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
      );
      return anyOf.length ? { anyOf } : void 0;
    };
    parseOptionalDef3 = (def, refs) => {
      var _a211;
      if (refs.currentPath.toString() === ((_a211 = refs.propertyPath) == null ? void 0 : _a211.toString())) {
        return parseDef3(def.innerType._def, refs);
      }
      const innerSchema = parseDef3(def.innerType._def, {
        ...refs,
        currentPath: [...refs.currentPath, "anyOf", "1"]
      });
      return innerSchema ? { anyOf: [{ not: parseAnyDef3() }, innerSchema] } : parseAnyDef3();
    };
    parsePipelineDef3 = (def, refs) => {
      if (refs.pipeStrategy === "input") {
        return parseDef3(def.in._def, refs);
      } else if (refs.pipeStrategy === "output") {
        return parseDef3(def.out._def, refs);
      }
      const a = parseDef3(def.in._def, {
        ...refs,
        currentPath: [...refs.currentPath, "allOf", "0"]
      });
      const b = parseDef3(def.out._def, {
        ...refs,
        currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
      });
      return {
        allOf: [a, b].filter((x) => x !== void 0)
      };
    };
    parseReadonlyDef3 = (def, refs) => {
      return parseDef3(def.innerType._def, refs);
    };
    selectParser3 = (def, typeName, refs) => {
      switch (typeName) {
        case ZodFirstPartyTypeKind2.ZodString:
          return parseStringDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodNumber:
          return parseNumberDef3(def);
        case ZodFirstPartyTypeKind2.ZodObject:
          return parseObjectDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodBigInt:
          return parseBigintDef3(def);
        case ZodFirstPartyTypeKind2.ZodBoolean:
          return parseBooleanDef3();
        case ZodFirstPartyTypeKind2.ZodDate:
          return parseDateDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodUndefined:
          return parseUndefinedDef3();
        case ZodFirstPartyTypeKind2.ZodNull:
          return parseNullDef3();
        case ZodFirstPartyTypeKind2.ZodArray:
          return parseArrayDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodUnion:
        case ZodFirstPartyTypeKind2.ZodDiscriminatedUnion:
          return parseUnionDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodIntersection:
          return parseIntersectionDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodTuple:
          return parseTupleDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodRecord:
          return parseRecordDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodLiteral:
          return parseLiteralDef3(def);
        case ZodFirstPartyTypeKind2.ZodEnum:
          return parseEnumDef3(def);
        case ZodFirstPartyTypeKind2.ZodNativeEnum:
          return parseNativeEnumDef3(def);
        case ZodFirstPartyTypeKind2.ZodNullable:
          return parseNullableDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodOptional:
          return parseOptionalDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodMap:
          return parseMapDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodSet:
          return parseSetDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodLazy:
          return () => def.getter()._def;
        case ZodFirstPartyTypeKind2.ZodPromise:
          return parsePromiseDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodNaN:
        case ZodFirstPartyTypeKind2.ZodNever:
          return parseNeverDef3();
        case ZodFirstPartyTypeKind2.ZodEffects:
          return parseEffectsDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodAny:
          return parseAnyDef3();
        case ZodFirstPartyTypeKind2.ZodUnknown:
          return parseUnknownDef3();
        case ZodFirstPartyTypeKind2.ZodDefault:
          return parseDefaultDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodBranded:
          return parseBrandedDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodReadonly:
          return parseReadonlyDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodCatch:
          return parseCatchDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodPipeline:
          return parsePipelineDef3(def, refs);
        case ZodFirstPartyTypeKind2.ZodFunction:
        case ZodFirstPartyTypeKind2.ZodVoid:
        case ZodFirstPartyTypeKind2.ZodSymbol:
          return void 0;
        default:
          return /* @__PURE__ */ ((_) => void 0)(typeName);
      }
    };
    getRelativePath3 = (pathA, pathB) => {
      let i = 0;
      for (; i < pathA.length && i < pathB.length; i++) {
        if (pathA[i] !== pathB[i]) break;
      }
      return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
    };
    get$ref3 = (item, refs) => {
      switch (refs.$refStrategy) {
        case "root":
          return { $ref: item.path.join("/") };
        case "relative":
          return { $ref: getRelativePath3(refs.currentPath, item.path) };
        case "none":
        case "seen": {
          if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
            console.warn(
              `Recursive reference detected at ${refs.currentPath.join(
                "/"
              )}! Defaulting to any`
            );
            return parseAnyDef3();
          }
          return refs.$refStrategy === "seen" ? parseAnyDef3() : void 0;
        }
      }
    };
    addMeta3 = (def, refs, jsonSchema22) => {
      if (def.description) {
        jsonSchema22.description = def.description;
      }
      return jsonSchema22;
    };
    getRefs3 = (options) => {
      const _options = getDefaultOptions3(options);
      const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
      return {
        ..._options,
        currentPath,
        propertyPath: void 0,
        seen: new Map(
          Object.entries(_options.definitions).map(([name28, def]) => [
            def._def,
            {
              def: def._def,
              path: [..._options.basePath, _options.definitionPath, name28],
              // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
              jsonSchema: void 0
            }
          ])
        )
      };
    };
    zod3ToJsonSchema3 = (schema, options) => {
      var _a211;
      const refs = getRefs3(options);
      let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
        (acc, [name37, schema2]) => {
          var _a37;
          return {
            ...acc,
            [name37]: (_a37 = parseDef3(
              schema2._def,
              {
                ...refs,
                currentPath: [...refs.basePath, refs.definitionPath, name37]
              },
              true
            )) != null ? _a37 : parseAnyDef3()
          };
        },
        {}
      ) : void 0;
      const name28 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
      const main = (_a211 = parseDef3(
        schema._def,
        name28 === void 0 ? refs : {
          ...refs,
          currentPath: [...refs.basePath, refs.definitionPath, name28]
        },
        false
      )) != null ? _a211 : parseAnyDef3();
      const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
      if (title !== void 0) {
        main.title = title;
      }
      const combined = name28 === void 0 ? definitions ? {
        ...main,
        [refs.definitionPath]: definitions
      } : main : {
        $ref: [
          ...refs.$refStrategy === "relative" ? [] : refs.basePath,
          refs.definitionPath,
          name28
        ].join("/"),
        [refs.definitionPath]: {
          ...definitions,
          [name28]: main
        }
      };
      combined.$schema = "http://json-schema.org/draft-07/schema#";
      return combined;
    };
    schemaSymbol3 = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
    getOriginalFetch24 = () => globalThis.fetch;
    postJsonToApi4 = async ({
      url: url4,
      headers,
      body,
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    }) => postToApi4({
      url: url4,
      headers: {
        "Content-Type": "application/json",
        ...headers
      },
      body: {
        content: JSON.stringify(body),
        values: body
      },
      failedResponseHandler,
      successfulResponseHandler,
      abortSignal,
      fetch: fetch2
    });
    postToApi4 = async ({
      url: url4,
      headers = {},
      body,
      successfulResponseHandler,
      failedResponseHandler,
      abortSignal,
      fetch: fetch2 = getOriginalFetch24()
    }) => {
      try {
        const response = await fetch2(url4, {
          method: "POST",
          headers: withUserAgentSuffix4(
            headers,
            `ai-sdk/provider-utils/${VERSION12}`,
            getRuntimeEnvironmentUserAgent4()
          ),
          body: body.content,
          signal: abortSignal
        });
        const responseHeaders = extractResponseHeaders4(response);
        if (!response.ok) {
          let errorInformation;
          try {
            errorInformation = await failedResponseHandler({
              response,
              url: url4,
              requestBodyValues: body.values
            });
          } catch (error73) {
            if (isAbortError4(error73) || APICallError4.isInstance(error73)) {
              throw error73;
            }
            throw new APICallError4({
              message: "Failed to process error response",
              cause: error73,
              statusCode: response.status,
              url: url4,
              responseHeaders,
              requestBodyValues: body.values
            });
          }
          throw errorInformation.value;
        }
        try {
          return await successfulResponseHandler({
            response,
            url: url4,
            requestBodyValues: body.values
          });
        } catch (error73) {
          if (error73 instanceof Error) {
            if (isAbortError4(error73) || APICallError4.isInstance(error73)) {
              throw error73;
            }
          }
          throw new APICallError4({
            message: "Failed to process successful response",
            cause: error73,
            statusCode: response.status,
            url: url4,
            responseHeaders,
            requestBodyValues: body.values
          });
        }
      } catch (error73) {
        throw handleFetchError4({ error: error73, url: url4, requestBodyValues: body.values });
      }
    };
    createJsonErrorResponseHandler4 = ({
      errorSchema,
      errorToMessage,
      isRetryable
    }) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const responseHeaders = extractResponseHeaders4(response);
      if (responseBody.trim() === "") {
        return {
          responseHeaders,
          value: new APICallError4({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
      try {
        const parsedError = await parseJSON4({
          text: responseBody,
          schema: errorSchema
        });
        return {
          responseHeaders,
          value: new APICallError4({
            message: errorToMessage(parsedError),
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            data: parsedError,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
          })
        };
      } catch (parseError) {
        return {
          responseHeaders,
          value: new APICallError4({
            message: response.statusText,
            url: url4,
            requestBodyValues,
            statusCode: response.status,
            responseHeaders,
            responseBody,
            isRetryable: isRetryable == null ? void 0 : isRetryable(response)
          })
        };
      }
    };
    createEventSourceResponseHandler4 = (chunkSchema2) => async ({ response }) => {
      const responseHeaders = extractResponseHeaders4(response);
      if (response.body == null) {
        throw new EmptyResponseBodyError4({});
      }
      return {
        responseHeaders,
        value: parseJsonEventStream4({
          stream: response.body,
          schema: chunkSchema2
        })
      };
    };
    createJsonResponseHandler4 = (responseSchema2) => async ({ response, url: url4, requestBodyValues }) => {
      const responseBody = await response.text();
      const parsedResult = await safeParseJSON4({
        text: responseBody,
        schema: responseSchema2
      });
      const responseHeaders = extractResponseHeaders4(response);
      if (!parsedResult.success) {
        throw new APICallError4({
          message: "Invalid JSON response",
          cause: parsedResult.error,
          statusCode: response.status,
          responseHeaders,
          responseBody,
          url: url4,
          requestBodyValues
        });
      }
      return {
        responseHeaders,
        value: parsedResult.value,
        rawValue: parsedResult.rawValue
      };
    };
  }
});

// node_modules/vercel-minimax-ai-provider/dist/index.mjs
function createMinimaxAnthropic(options = {}) {
  const baseURL = withoutTrailingSlash3(
    options.baseURL ?? "https://api.minimax.io/anthropic/v1"
  );
  const getHeaders = () => withUserAgentSuffix4(
    {
      "anthropic-version": "2023-06-01",
      "x-api-key": loadApiKey3({
        apiKey: options.apiKey,
        environmentVariableName: "MINIMAX_API_KEY",
        description: "MiniMax API key"
      }),
      ...options.headers
    },
    `minimax-ai-provider`
  );
  const createLanguageModel = (modelId) => {
    return new AnthropicMessagesLanguageModel2(modelId, {
      provider: "minimax.messages",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch,
      generateId: generateId4,
      supportedUrls: () => ({
        "image/*": [/^https?:\/\/.*$/]
      })
    });
  };
  const provider = (modelId) => createLanguageModel(modelId);
  provider.languageModel = createLanguageModel;
  provider.chat = createLanguageModel;
  provider.specificationVersion = "v3";
  provider.embeddingModel = (modelId) => {
    throw new NoSuchModelError4({ modelId, modelType: "embeddingModel" });
  };
  provider.imageModel = (modelId) => {
    throw new NoSuchModelError4({ modelId, modelType: "imageModel" });
  };
  return provider;
}
function convertMinimaxChatUsage(usage) {
  if (usage == null) {
    return {
      inputTokens: {
        total: void 0,
        noCache: void 0,
        cacheRead: void 0,
        cacheWrite: void 0
      },
      outputTokens: {
        total: void 0,
        text: void 0,
        reasoning: void 0
      },
      raw: void 0
    };
  }
  const promptTokens = usage.prompt_tokens ?? 0;
  const completionTokens = usage.completion_tokens ?? 0;
  const cacheReadTokens = usage.prompt_tokens_details?.cached_tokens ?? 0;
  const reasoningTokens = usage.completion_tokens_details?.reasoning_tokens ?? 0;
  return {
    inputTokens: {
      total: promptTokens,
      noCache: promptTokens - cacheReadTokens,
      cacheRead: cacheReadTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: completionTokens,
      text: completionTokens - reasoningTokens,
      reasoning: reasoningTokens
    },
    raw: usage
  };
}
function getOpenAIMetadata2(message) {
  return message?.providerOptions?.openaiCompatible ?? {};
}
function getMinimaxMetadata(message) {
  return message?.providerOptions?.minimax ?? {};
}
function convertToMinimaxChatMessages(prompt) {
  const messages = [];
  for (const { role, content, ...message } of prompt) {
    const metadata = getOpenAIMetadata2({ ...message });
    switch (role) {
      case "system": {
        messages.push({ role: "system", content, ...metadata });
        break;
      }
      case "user": {
        if (content.length === 1 && content[0].type === "text") {
          messages.push({
            role: "user",
            content: content[0].text,
            ...getOpenAIMetadata2(content[0])
          });
          break;
        }
        messages.push({
          role: "user",
          content: content.map((part) => {
            const partMetadata = getOpenAIMetadata2(part);
            switch (part.type) {
              case "text": {
                return { type: "text", text: part.text, ...partMetadata };
              }
              case "file": {
                if (part.mediaType.startsWith("image/")) {
                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
                  return {
                    type: "image_url",
                    image_url: {
                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase643(part.data)}`
                    },
                    ...partMetadata
                  };
                } else {
                  throw new UnsupportedFunctionalityError4({
                    functionality: `file part media type ${part.mediaType}`
                  });
                }
              }
            }
          }),
          ...metadata
        });
        break;
      }
      case "assistant": {
        let text2 = "";
        const toolCalls = [];
        let reasoningDetails = void 0;
        for (const part of content) {
          const partMetadata = getOpenAIMetadata2(part);
          const partMinimaxMetadata = getMinimaxMetadata(part);
          switch (part.type) {
            case "text": {
              text2 += part.text;
              break;
            }
            case "tool-call": {
              toolCalls.push({
                id: part.toolCallId,
                type: "function",
                function: {
                  name: part.toolName,
                  arguments: JSON.stringify(part.input)
                },
                ...partMetadata
              });
              break;
            }
            case "reasoning": {
              if (partMinimaxMetadata?.reasoningDetails) {
                reasoningDetails = partMinimaxMetadata.reasoningDetails;
              }
              break;
            }
          }
        }
        const messageObj = {
          role: "assistant",
          content: text2,
          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
          ...metadata
        };
        if (reasoningDetails) {
          messageObj.reasoning_details = reasoningDetails;
        }
        messages.push(messageObj);
        break;
      }
      case "tool": {
        for (const toolResponse of content) {
          if (toolResponse.type === "tool-approval-response") {
            continue;
          }
          const output = toolResponse.output;
          let contentValue;
          switch (output.type) {
            case "text":
            case "error-text":
              contentValue = output.value;
              break;
            case "execution-denied":
              contentValue = output.reason ?? "Tool execution denied.";
              break;
            case "content":
            case "json":
            case "error-json":
              contentValue = JSON.stringify(output.value);
              break;
          }
          const toolResponseMetadata = getOpenAIMetadata2(toolResponse);
          messages.push({
            role: "tool",
            tool_call_id: toolResponse.toolCallId,
            content: contentValue,
            ...toolResponseMetadata
          });
        }
        break;
      }
      default: {
        const _exhaustiveCheck = role;
        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
      }
    }
  }
  return messages;
}
function mapMinimaxFinishReason(finishReason) {
  switch (finishReason) {
    case "stop":
      return "stop";
    case "length":
      return "length";
    case "content_filter":
      return "content-filter";
    case "function_call":
    case "tool_calls":
      return "tool-calls";
    default:
      return "other";
  }
}
function prepareTools7({
  tools,
  toolChoice
}) {
  tools = tools?.length ? tools : void 0;
  const toolWarnings = [];
  if (tools == null) {
    return { tools: void 0, toolChoice: void 0, toolWarnings };
  }
  const openaiCompatTools = [];
  for (const tool3 of tools) {
    if (tool3.type === "provider") {
      toolWarnings.push({
        type: "unsupported",
        feature: `provider-defined tool ${tool3.id}`
      });
    } else {
      openaiCompatTools.push({
        type: "function",
        function: {
          name: tool3.name,
          description: tool3.description,
          parameters: tool3.inputSchema,
          ...tool3.strict != null ? { strict: tool3.strict } : {}
        }
      });
    }
  }
  if (toolChoice == null) {
    return { tools: openaiCompatTools, toolChoice: void 0, toolWarnings };
  }
  const type = toolChoice.type;
  switch (type) {
    case "auto":
    case "none":
    case "required":
      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
    case "tool":
      return {
        tools: openaiCompatTools,
        toolChoice: {
          type: "function",
          function: { name: toolChoice.toolName }
        },
        toolWarnings
      };
    default: {
      const _exhaustiveCheck = type;
      throw new UnsupportedFunctionalityError4({
        functionality: `tool choice type: ${_exhaustiveCheck}`
      });
    }
  }
}
function getResponseMetadata7({
  id,
  model,
  created
}) {
  return {
    id: id ?? void 0,
    modelId: model ?? void 0,
    timestamp: created != null ? new Date(created * 1e3) : void 0
  };
}
function createMinimax(options = {}) {
  const baseURL = withoutTrailingSlash3(
    options.baseURL ?? "https://api.minimax.io/v1"
  );
  const getHeaders = () => withUserAgentSuffix4(
    {
      Authorization: `Bearer ${loadApiKey3({
        apiKey: options.apiKey,
        environmentVariableName: "MINIMAX_API_KEY",
        description: "MiniMax API key"
      })}`,
      ...options.headers
    },
    `minimax-ai-provider`
  );
  const createLanguageModel = (modelId) => {
    return new MinimaxChatLanguageModel(modelId, {
      provider: `minimax.chat`,
      url: ({ path: path33 }) => `${baseURL}${path33}`,
      headers: getHeaders,
      fetch: options.fetch
    });
  };
  const provider = (modelId) => createLanguageModel(modelId);
  provider.languageModel = createLanguageModel;
  provider.chat = createLanguageModel;
  provider.specificationVersion = "v3";
  provider.embeddingModel = (modelId) => {
    throw new NoSuchModelError4({ modelId, modelType: "embeddingModel" });
  };
  provider.imageModel = (modelId) => {
    throw new NoSuchModelError4({ modelId, modelType: "imageModel" });
  };
  return provider;
}
var minimaxAnthropic, minimaxChatProviderOptions, minimaxErrorDataSchema, defaultMinimaxErrorStructure, MinimaxChatLanguageModel, openaiCompatibleTokenUsageSchema2, MinimaxChatResponseSchema, chunkBaseSchema2, createOpenAICompatibleChatChunkSchema2, minimax, minimaxOpenAI;
var init_dist20 = __esm({
  "node_modules/vercel-minimax-ai-provider/dist/index.mjs"() {
    "use strict";
    init_internal();
    init_dist18();
    init_dist19();
    init_dist18();
    init_dist19();
    init_dist18();
    init_dist19();
    init_v42();
    init_v42();
    init_dist18();
    init_dist19();
    init_dist18();
    minimaxAnthropic = createMinimaxAnthropic();
    minimaxChatProviderOptions = external_exports.object({
      /**
       * A unique identifier representing your end-user, which can help the provider to
       * monitor and detect abuse.
       */
      user: external_exports.string().optional(),
      /**
       * Reasoning effort for reasoning models. Defaults to `medium`.
       */
      reasoningEffort: external_exports.string().optional(),
      /**
       * Controls the verbosity of the generated text. Defaults to `medium`.
       */
      textVerbosity: external_exports.string().optional()
    });
    minimaxErrorDataSchema = external_exports.object({
      error: external_exports.object({
        message: external_exports.string(),
        type: external_exports.string().nullish(),
        param: external_exports.any().nullish(),
        code: external_exports.union([external_exports.string(), external_exports.number()]).nullish()
      })
    });
    defaultMinimaxErrorStructure = {
      errorSchema: minimaxErrorDataSchema,
      errorToMessage: (data) => data.error.message
    };
    MinimaxChatLanguageModel = class {
      // type inferred via constructor
      constructor(modelId, config3) {
        this.specificationVersion = "v3";
        this.modelId = modelId;
        this.config = config3;
        const errorStructure = config3.errorStructure ?? defaultMinimaxErrorStructure;
        this.chunkSchema = createOpenAICompatibleChatChunkSchema2(
          errorStructure.errorSchema
        );
        this.failedResponseHandler = createJsonErrorResponseHandler4(errorStructure);
        this.supportsStructuredOutputs = config3.supportsStructuredOutputs ?? false;
      }
      get provider() {
        return this.config.provider;
      }
      get providerOptionsName() {
        return this.config.provider.split(".")[0].trim();
      }
      get supportedUrls() {
        return this.config.supportedUrls?.() ?? {};
      }
      async getArgs({
        prompt,
        maxOutputTokens,
        temperature,
        topP,
        topK,
        frequencyPenalty,
        presencePenalty,
        providerOptions,
        stopSequences,
        responseFormat,
        seed,
        toolChoice,
        tools
      }) {
        const warnings = [];
        const compatibleOptions = Object.assign(
          await parseProviderOptions3({
            provider: "openai-compatible",
            providerOptions,
            schema: minimaxChatProviderOptions
          }) ?? {},
          await parseProviderOptions3({
            provider: this.providerOptionsName,
            providerOptions,
            schema: minimaxChatProviderOptions
          }) ?? {}
        );
        if (topK != null) {
          warnings.push({ type: "unsupported", feature: "topK" });
        }
        if (responseFormat?.type === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
          warnings.push({
            type: "unsupported",
            feature: "responseFormat",
            details: "JSON response format schema is only supported with structuredOutputs"
          });
        }
        const {
          tools: openaiTools2,
          toolChoice: openaiToolChoice,
          toolWarnings
        } = prepareTools7({
          tools,
          toolChoice
        });
        return {
          args: {
            // model id:
            model: this.modelId,
            // model specific settings:
            user: compatibleOptions.user,
            // standardized settings:
            max_tokens: maxOutputTokens,
            temperature,
            top_p: topP,
            frequency_penalty: frequencyPenalty,
            presence_penalty: presencePenalty,
            response_format: responseFormat?.type === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
              type: "json_schema",
              json_schema: {
                schema: responseFormat.schema,
                name: responseFormat.name ?? "response",
                description: responseFormat.description
              }
            } : { type: "json_object" } : void 0,
            stop: stopSequences,
            seed,
            ...Object.fromEntries(
              Object.entries(
                providerOptions?.[this.providerOptionsName] ?? {}
              ).filter(
                ([key]) => !Object.keys(minimaxChatProviderOptions.shape).includes(key)
              )
            ),
            reasoning_effort: compatibleOptions.reasoningEffort,
            verbosity: compatibleOptions.textVerbosity,
            // MiniMax specific: enable reasoning_split for M2 models
            reasoning_split: true,
            // messages:
            messages: convertToMinimaxChatMessages(prompt),
            // tools:
            tools: openaiTools2,
            tool_choice: openaiToolChoice
          },
          warnings: [...warnings, ...toolWarnings]
        };
      }
      async doGenerate(options) {
        const { args, warnings } = await this.getArgs({ ...options });
        const body = JSON.stringify(args);
        const {
          responseHeaders,
          value: responseBody,
          rawValue: rawResponse
        } = await postJsonToApi4({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders4(this.config.headers(), options.headers),
          body: args,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: createJsonResponseHandler4(
            MinimaxChatResponseSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const choice2 = responseBody.choices[0];
        const content = [];
        const text2 = choice2.message.content;
        if (text2 != null && text2.length > 0) {
          content.push({ type: "text", text: text2 });
        }
        if (choice2.message.reasoning_details?.length) {
          const reasoningBlock = choice2.message.reasoning_details.find(
            (block) => block.type === "reasoning.text"
          );
          if (reasoningBlock?.text) {
            content.push({
              type: "reasoning",
              text: reasoningBlock.text,
              // Store original reasoning_details in providerMetadata for round-trip
              providerMetadata: {
                minimax: {
                  reasoningDetails: choice2.message.reasoning_details
                }
              }
            });
          }
        }
        if (choice2.message.tool_calls != null) {
          for (const toolCall of choice2.message.tool_calls) {
            content.push({
              type: "tool-call",
              toolCallId: toolCall.id ?? generateId4(),
              toolName: toolCall.function.name,
              input: toolCall.function.arguments
            });
          }
        }
        const providerMetadata = {
          [this.providerOptionsName]: {},
          ...await this.config.metadataExtractor?.extractMetadata?.({
            parsedBody: rawResponse
          })
        };
        const completionTokenDetails = responseBody.usage?.completion_tokens_details;
        if (completionTokenDetails?.accepted_prediction_tokens != null) {
          providerMetadata[this.providerOptionsName].acceptedPredictionTokens = completionTokenDetails?.accepted_prediction_tokens;
        }
        if (completionTokenDetails?.rejected_prediction_tokens != null) {
          providerMetadata[this.providerOptionsName].rejectedPredictionTokens = completionTokenDetails?.rejected_prediction_tokens;
        }
        return {
          content,
          finishReason: {
            unified: mapMinimaxFinishReason(choice2.finish_reason),
            raw: choice2.finish_reason ?? void 0
          },
          usage: convertMinimaxChatUsage(responseBody.usage),
          providerMetadata,
          request: { body },
          response: {
            ...getResponseMetadata7(responseBody),
            headers: responseHeaders,
            body: rawResponse
          },
          warnings
        };
      }
      async doStream(options) {
        const { args, warnings } = await this.getArgs({ ...options });
        const body = {
          ...args,
          stream: true,
          // only include stream_options when in strict compatibility mode:
          stream_options: this.config.includeUsage ? { include_usage: true } : void 0
        };
        const metadataExtractor = this.config.metadataExtractor?.createStreamExtractor();
        const { responseHeaders, value: response } = await postJsonToApi4({
          url: this.config.url({
            path: "/chat/completions",
            modelId: this.modelId
          }),
          headers: combineHeaders4(this.config.headers(), options.headers),
          body,
          failedResponseHandler: this.failedResponseHandler,
          successfulResponseHandler: createEventSourceResponseHandler4(
            this.chunkSchema
          ),
          abortSignal: options.abortSignal,
          fetch: this.config.fetch
        });
        const toolCalls = [];
        let finishReason = {
          unified: "other",
          raw: void 0
        };
        let usage = void 0;
        let isFirstChunk = true;
        const providerOptionsName = this.providerOptionsName;
        let isActiveReasoning = false;
        let isActiveText = false;
        let accumulatedReasoningDetails = [];
        return {
          stream: response.pipeThrough(
            new TransformStream({
              start(controller) {
                controller.enqueue({ type: "stream-start", warnings });
              },
              transform(chunk, controller) {
                if (options.includeRawChunks) {
                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
                }
                if (!chunk.success) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({ type: "error", error: chunk.error });
                  return;
                }
                metadataExtractor?.processChunk(chunk.rawValue);
                if ("error" in chunk.value) {
                  finishReason = { unified: "error", raw: void 0 };
                  controller.enqueue({
                    type: "error",
                    error: chunk.value.error.message
                  });
                  return;
                }
                const value = chunk.value;
                if (isFirstChunk) {
                  isFirstChunk = false;
                  controller.enqueue({
                    type: "response-metadata",
                    ...getResponseMetadata7(value)
                  });
                }
                if (value.usage != null) {
                  usage = value.usage;
                }
                const choice2 = value.choices[0];
                if (choice2?.finish_reason != null) {
                  finishReason = {
                    unified: mapMinimaxFinishReason(choice2.finish_reason),
                    raw: choice2.finish_reason ?? void 0
                  };
                }
                if (choice2?.delta == null) {
                  return;
                }
                const delta = choice2.delta;
                if (delta.reasoning_details?.length) {
                  if (accumulatedReasoningDetails.length === 0) {
                    accumulatedReasoningDetails = delta.reasoning_details;
                  } else {
                    for (const block of delta.reasoning_details) {
                      const existingIndex = accumulatedReasoningDetails.findIndex(
                        (b) => b.type === block.type && b.id === block.id
                      );
                      if (existingIndex >= 0) {
                        const existing = accumulatedReasoningDetails[existingIndex];
                        if (block.text) {
                          existing.text = (existing.text || "") + block.text;
                        }
                      } else {
                        accumulatedReasoningDetails.push({ ...block });
                      }
                    }
                  }
                  const reasoningBlock = delta.reasoning_details.find(
                    (block) => block.type === "reasoning.text"
                  );
                  if (reasoningBlock?.text) {
                    if (!isActiveReasoning) {
                      controller.enqueue({
                        type: "reasoning-start",
                        id: "reasoning-0"
                      });
                      isActiveReasoning = true;
                    }
                    controller.enqueue({
                      type: "reasoning-delta",
                      id: "reasoning-0",
                      delta: reasoningBlock.text
                    });
                  }
                }
                if (delta.content) {
                  if (!isActiveText) {
                    controller.enqueue({ type: "text-start", id: "txt-0" });
                    isActiveText = true;
                  }
                  controller.enqueue({
                    type: "text-delta",
                    id: "txt-0",
                    delta: delta.content
                  });
                }
                if (delta.tool_calls != null) {
                  for (const toolCallDelta of delta.tool_calls) {
                    const index = toolCallDelta.index;
                    if (toolCalls[index] == null) {
                      if (toolCallDelta.id == null) {
                        throw new InvalidResponseDataError4({
                          data: toolCallDelta,
                          message: `Expected 'id' to be a string.`
                        });
                      }
                      if (toolCallDelta.function?.name == null) {
                        throw new InvalidResponseDataError4({
                          data: toolCallDelta,
                          message: `Expected 'function.name' to be a string.`
                        });
                      }
                      controller.enqueue({
                        type: "tool-input-start",
                        id: toolCallDelta.id,
                        toolName: toolCallDelta.function.name
                      });
                      toolCalls[index] = {
                        id: toolCallDelta.id,
                        type: "function",
                        function: {
                          name: toolCallDelta.function.name,
                          arguments: toolCallDelta.function.arguments ?? ""
                        },
                        hasFinished: false
                      };
                      const toolCall2 = toolCalls[index];
                      if (toolCall2.function?.name != null && toolCall2.function?.arguments != null) {
                        if (toolCall2.function.arguments.length > 0) {
                          controller.enqueue({
                            type: "tool-input-delta",
                            id: toolCall2.id,
                            delta: toolCall2.function.arguments
                          });
                        }
                        if (isParsableJson3(toolCall2.function.arguments)) {
                          controller.enqueue({
                            type: "tool-input-end",
                            id: toolCall2.id
                          });
                          controller.enqueue({
                            type: "tool-call",
                            toolCallId: toolCall2.id ?? generateId4(),
                            toolName: toolCall2.function.name,
                            input: toolCall2.function.arguments
                          });
                          toolCall2.hasFinished = true;
                        }
                      }
                      continue;
                    }
                    const toolCall = toolCalls[index];
                    if (toolCall.hasFinished) {
                      continue;
                    }
                    if (toolCallDelta.function?.arguments != null) {
                      toolCall.function.arguments += toolCallDelta.function?.arguments ?? "";
                    }
                    controller.enqueue({
                      type: "tool-input-delta",
                      id: toolCall.id,
                      delta: toolCallDelta.function.arguments ?? ""
                    });
                    if (toolCall.function?.name != null && toolCall.function?.arguments != null && isParsableJson3(toolCall.function.arguments)) {
                      controller.enqueue({
                        type: "tool-input-end",
                        id: toolCall.id
                      });
                      controller.enqueue({
                        type: "tool-call",
                        toolCallId: toolCall.id ?? generateId4(),
                        toolName: toolCall.function.name,
                        input: toolCall.function.arguments
                      });
                      toolCall.hasFinished = true;
                    }
                  }
                }
              },
              flush(controller) {
                if (isActiveReasoning) {
                  controller.enqueue({
                    type: "reasoning-end",
                    id: "reasoning-0",
                    // Attach reasoning_details for round-trip (MiniMax specific)
                    providerMetadata: accumulatedReasoningDetails.length > 0 ? {
                      minimax: {
                        reasoningDetails: accumulatedReasoningDetails
                      }
                    } : void 0
                  });
                }
                if (isActiveText) {
                  controller.enqueue({ type: "text-end", id: "txt-0" });
                }
                for (const toolCall of toolCalls.filter(
                  (toolCall2) => !toolCall2.hasFinished
                )) {
                  controller.enqueue({
                    type: "tool-input-end",
                    id: toolCall.id
                  });
                  controller.enqueue({
                    type: "tool-call",
                    toolCallId: toolCall.id ?? generateId4(),
                    toolName: toolCall.function.name,
                    input: toolCall.function.arguments
                  });
                }
                const providerMetadata = {
                  [providerOptionsName]: {},
                  ...metadataExtractor?.buildMetadata()
                };
                if (usage?.completion_tokens_details?.accepted_prediction_tokens != null) {
                  providerMetadata[providerOptionsName].acceptedPredictionTokens = usage?.completion_tokens_details?.accepted_prediction_tokens;
                }
                if (usage?.completion_tokens_details?.rejected_prediction_tokens != null) {
                  providerMetadata[providerOptionsName].rejectedPredictionTokens = usage?.completion_tokens_details?.rejected_prediction_tokens;
                }
                controller.enqueue({
                  type: "finish",
                  finishReason,
                  usage: convertMinimaxChatUsage(usage),
                  providerMetadata
                });
              }
            })
          ),
          request: { body },
          response: { headers: responseHeaders }
        };
      }
    };
    openaiCompatibleTokenUsageSchema2 = external_exports.object({
      prompt_tokens: external_exports.number().nullish(),
      completion_tokens: external_exports.number().nullish(),
      total_tokens: external_exports.number().nullish(),
      prompt_tokens_details: external_exports.object({
        cached_tokens: external_exports.number().nullish()
      }).nullish(),
      completion_tokens_details: external_exports.object({
        reasoning_tokens: external_exports.number().nullish(),
        accepted_prediction_tokens: external_exports.number().nullish(),
        rejected_prediction_tokens: external_exports.number().nullish()
      }).nullish()
    }).nullish();
    MinimaxChatResponseSchema = external_exports.object({
      id: external_exports.string().nullish(),
      created: external_exports.number().nullish(),
      model: external_exports.string().nullish(),
      choices: external_exports.array(
        external_exports.object({
          message: external_exports.object({
            role: external_exports.literal("assistant").nullish(),
            content: external_exports.string().nullish(),
            reasoning_details: external_exports.array(external_exports.any()).nullish(),
            // MiniMax specific
            tool_calls: external_exports.array(
              external_exports.object({
                id: external_exports.string().nullish(),
                function: external_exports.object({
                  name: external_exports.string(),
                  arguments: external_exports.string()
                })
              })
            ).nullish()
          }),
          finish_reason: external_exports.string().nullish()
        })
      ),
      usage: openaiCompatibleTokenUsageSchema2
    });
    chunkBaseSchema2 = external_exports.object({
      id: external_exports.string().nullish(),
      created: external_exports.number().nullish(),
      model: external_exports.string().nullish(),
      choices: external_exports.array(
        external_exports.object({
          delta: external_exports.object({
            role: external_exports.enum(["assistant"]).nullish(),
            content: external_exports.string().nullish(),
            reasoning_details: external_exports.array(external_exports.any()).nullish(),
            // MiniMax specific
            tool_calls: external_exports.array(
              external_exports.object({
                index: external_exports.number(),
                id: external_exports.string().nullish(),
                function: external_exports.object({
                  name: external_exports.string().nullish(),
                  arguments: external_exports.string().nullish()
                })
              })
            ).nullish()
          }).nullish(),
          finish_reason: external_exports.string().nullish()
        })
      ),
      usage: openaiCompatibleTokenUsageSchema2
    });
    createOpenAICompatibleChatChunkSchema2 = (errorSchema) => external_exports.union([chunkBaseSchema2, errorSchema]);
    minimax = createMinimax();
    minimaxOpenAI = createMinimax();
  }
});

// node_modules/safe-buffer/index.js
var require_safe_buffer2 = __commonJS({
  "node_modules/safe-buffer/index.js"(exports2, module2) {
    "use strict";
    var buffer = require("buffer");
    var Buffer3 = buffer.Buffer;
    function copyProps(src, dst) {
      for (var key in src) {
        dst[key] = src[key];
      }
    }
    if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow) {
      module2.exports = buffer;
    } else {
      copyProps(buffer, exports2);
      exports2.Buffer = SafeBuffer;
    }
    function SafeBuffer(arg, encodingOrOffset, length) {
      return Buffer3(arg, encodingOrOffset, length);
    }
    SafeBuffer.prototype = Object.create(Buffer3.prototype);
    copyProps(Buffer3, SafeBuffer);
    SafeBuffer.from = function(arg, encodingOrOffset, length) {
      if (typeof arg === "number") {
        throw new TypeError("Argument must not be a number");
      }
      return Buffer3(arg, encodingOrOffset, length);
    };
    SafeBuffer.alloc = function(size, fill, encoding) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      var buf = Buffer3(size);
      if (fill !== void 0) {
        if (typeof encoding === "string") {
          buf.fill(fill, encoding);
        } else {
          buf.fill(fill);
        }
      } else {
        buf.fill(0);
      }
      return buf;
    };
    SafeBuffer.allocUnsafe = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return Buffer3(size);
    };
    SafeBuffer.allocUnsafeSlow = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return buffer.SlowBuffer(size);
    };
  }
});

// node_modules/jws/lib/data-stream.js
var require_data_stream = __commonJS({
  "node_modules/jws/lib/data-stream.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safe_buffer2().Buffer;
    var Stream = require("stream");
    var util4 = require("util");
    function DataStream(data) {
      this.buffer = null;
      this.writable = true;
      this.readable = true;
      if (!data) {
        this.buffer = Buffer3.alloc(0);
        return this;
      }
      if (typeof data.pipe === "function") {
        this.buffer = Buffer3.alloc(0);
        data.pipe(this);
        return this;
      }
      if (data.length || typeof data === "object") {
        this.buffer = data;
        this.writable = false;
        process.nextTick(function() {
          this.emit("end", data);
          this.readable = false;
          this.emit("close");
        }.bind(this));
        return this;
      }
      throw new TypeError("Unexpected data type (" + typeof data + ")");
    }
    util4.inherits(DataStream, Stream);
    DataStream.prototype.write = function write(data) {
      this.buffer = Buffer3.concat([this.buffer, Buffer3.from(data)]);
      this.emit("data", data);
    };
    DataStream.prototype.end = function end(data) {
      if (data)
        this.write(data);
      this.emit("end", data);
      this.emit("close");
      this.writable = false;
      this.readable = false;
    };
    module2.exports = DataStream;
  }
});

// node_modules/ecdsa-sig-formatter/src/param-bytes-for-alg.js
var require_param_bytes_for_alg = __commonJS({
  "node_modules/ecdsa-sig-formatter/src/param-bytes-for-alg.js"(exports2, module2) {
    "use strict";
    function getParamSize(keySize) {
      var result = (keySize / 8 | 0) + (keySize % 8 === 0 ? 0 : 1);
      return result;
    }
    var paramBytesForAlg = {
      ES256: getParamSize(256),
      ES384: getParamSize(384),
      ES512: getParamSize(521)
    };
    function getParamBytesForAlg(alg) {
      var paramBytes = paramBytesForAlg[alg];
      if (paramBytes) {
        return paramBytes;
      }
      throw new Error('Unknown algorithm "' + alg + '"');
    }
    module2.exports = getParamBytesForAlg;
  }
});

// node_modules/ecdsa-sig-formatter/src/ecdsa-sig-formatter.js
var require_ecdsa_sig_formatter = __commonJS({
  "node_modules/ecdsa-sig-formatter/src/ecdsa-sig-formatter.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safe_buffer2().Buffer;
    var getParamBytesForAlg = require_param_bytes_for_alg();
    var MAX_OCTET = 128;
    var CLASS_UNIVERSAL = 0;
    var PRIMITIVE_BIT = 32;
    var TAG_SEQ = 16;
    var TAG_INT = 2;
    var ENCODED_TAG_SEQ = TAG_SEQ | PRIMITIVE_BIT | CLASS_UNIVERSAL << 6;
    var ENCODED_TAG_INT = TAG_INT | CLASS_UNIVERSAL << 6;
    function base64Url(base644) {
      return base644.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
    }
    function signatureAsBuffer(signature) {
      if (Buffer3.isBuffer(signature)) {
        return signature;
      } else if ("string" === typeof signature) {
        return Buffer3.from(signature, "base64");
      }
      throw new TypeError("ECDSA signature must be a Base64 string or a Buffer");
    }
    function derToJose(signature, alg) {
      signature = signatureAsBuffer(signature);
      var paramBytes = getParamBytesForAlg(alg);
      var maxEncodedParamLength = paramBytes + 1;
      var inputLength = signature.length;
      var offset = 0;
      if (signature[offset++] !== ENCODED_TAG_SEQ) {
        throw new Error('Could not find expected "seq"');
      }
      var seqLength = signature[offset++];
      if (seqLength === (MAX_OCTET | 1)) {
        seqLength = signature[offset++];
      }
      if (inputLength - offset < seqLength) {
        throw new Error('"seq" specified length of "' + seqLength + '", only "' + (inputLength - offset) + '" remaining');
      }
      if (signature[offset++] !== ENCODED_TAG_INT) {
        throw new Error('Could not find expected "int" for "r"');
      }
      var rLength = signature[offset++];
      if (inputLength - offset - 2 < rLength) {
        throw new Error('"r" specified length of "' + rLength + '", only "' + (inputLength - offset - 2) + '" available');
      }
      if (maxEncodedParamLength < rLength) {
        throw new Error('"r" specified length of "' + rLength + '", max of "' + maxEncodedParamLength + '" is acceptable');
      }
      var rOffset = offset;
      offset += rLength;
      if (signature[offset++] !== ENCODED_TAG_INT) {
        throw new Error('Could not find expected "int" for "s"');
      }
      var sLength = signature[offset++];
      if (inputLength - offset !== sLength) {
        throw new Error('"s" specified length of "' + sLength + '", expected "' + (inputLength - offset) + '"');
      }
      if (maxEncodedParamLength < sLength) {
        throw new Error('"s" specified length of "' + sLength + '", max of "' + maxEncodedParamLength + '" is acceptable');
      }
      var sOffset = offset;
      offset += sLength;
      if (offset !== inputLength) {
        throw new Error('Expected to consume entire buffer, but "' + (inputLength - offset) + '" bytes remain');
      }
      var rPadding = paramBytes - rLength, sPadding = paramBytes - sLength;
      var dst = Buffer3.allocUnsafe(rPadding + rLength + sPadding + sLength);
      for (offset = 0; offset < rPadding; ++offset) {
        dst[offset] = 0;
      }
      signature.copy(dst, offset, rOffset + Math.max(-rPadding, 0), rOffset + rLength);
      offset = paramBytes;
      for (var o = offset; offset < o + sPadding; ++offset) {
        dst[offset] = 0;
      }
      signature.copy(dst, offset, sOffset + Math.max(-sPadding, 0), sOffset + sLength);
      dst = dst.toString("base64");
      dst = base64Url(dst);
      return dst;
    }
    function countPadding(buf, start, stop) {
      var padding = 0;
      while (start + padding < stop && buf[start + padding] === 0) {
        ++padding;
      }
      var needsSign = buf[start + padding] >= MAX_OCTET;
      if (needsSign) {
        --padding;
      }
      return padding;
    }
    function joseToDer(signature, alg) {
      signature = signatureAsBuffer(signature);
      var paramBytes = getParamBytesForAlg(alg);
      var signatureBytes = signature.length;
      if (signatureBytes !== paramBytes * 2) {
        throw new TypeError('"' + alg + '" signatures must be "' + paramBytes * 2 + '" bytes, saw "' + signatureBytes + '"');
      }
      var rPadding = countPadding(signature, 0, paramBytes);
      var sPadding = countPadding(signature, paramBytes, signature.length);
      var rLength = paramBytes - rPadding;
      var sLength = paramBytes - sPadding;
      var rsBytes = 1 + 1 + rLength + 1 + 1 + sLength;
      var shortLength = rsBytes < MAX_OCTET;
      var dst = Buffer3.allocUnsafe((shortLength ? 2 : 3) + rsBytes);
      var offset = 0;
      dst[offset++] = ENCODED_TAG_SEQ;
      if (shortLength) {
        dst[offset++] = rsBytes;
      } else {
        dst[offset++] = MAX_OCTET | 1;
        dst[offset++] = rsBytes & 255;
      }
      dst[offset++] = ENCODED_TAG_INT;
      dst[offset++] = rLength;
      if (rPadding < 0) {
        dst[offset++] = 0;
        offset += signature.copy(dst, offset, 0, paramBytes);
      } else {
        offset += signature.copy(dst, offset, rPadding, paramBytes);
      }
      dst[offset++] = ENCODED_TAG_INT;
      dst[offset++] = sLength;
      if (sPadding < 0) {
        dst[offset++] = 0;
        signature.copy(dst, offset, paramBytes);
      } else {
        signature.copy(dst, offset, paramBytes + sPadding);
      }
      return dst;
    }
    module2.exports = {
      derToJose,
      joseToDer
    };
  }
});

// node_modules/buffer-equal-constant-time/index.js
var require_buffer_equal_constant_time = __commonJS({
  "node_modules/buffer-equal-constant-time/index.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require("buffer").Buffer;
    var SlowBuffer = require("buffer").SlowBuffer;
    module2.exports = bufferEq;
    function bufferEq(a, b) {
      if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) {
        return false;
      }
      if (a.length !== b.length) {
        return false;
      }
      var c = 0;
      for (var i = 0; i < a.length; i++) {
        c |= a[i] ^ b[i];
      }
      return c === 0;
    }
    bufferEq.install = function() {
      Buffer3.prototype.equal = SlowBuffer.prototype.equal = function equal(that) {
        return bufferEq(this, that);
      };
    };
    var origBufEqual = Buffer3.prototype.equal;
    var origSlowBufEqual = SlowBuffer.prototype.equal;
    bufferEq.restore = function() {
      Buffer3.prototype.equal = origBufEqual;
      SlowBuffer.prototype.equal = origSlowBufEqual;
    };
  }
});

// node_modules/jwa/index.js
var require_jwa = __commonJS({
  "node_modules/jwa/index.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safe_buffer2().Buffer;
    var crypto7 = require("crypto");
    var formatEcdsa = require_ecdsa_sig_formatter();
    var util4 = require("util");
    var MSG_INVALID_ALGORITHM = '"%s" is not a valid algorithm.\n  Supported algorithms are:\n  "HS256", "HS384", "HS512", "RS256", "RS384", "RS512", "PS256", "PS384", "PS512", "ES256", "ES384", "ES512" and "none".';
    var MSG_INVALID_SECRET = "secret must be a string or buffer";
    var MSG_INVALID_VERIFIER_KEY = "key must be a string or a buffer";
    var MSG_INVALID_SIGNER_KEY = "key must be a string, a buffer or an object";
    var supportsKeyObjects = typeof crypto7.createPublicKey === "function";
    if (supportsKeyObjects) {
      MSG_INVALID_VERIFIER_KEY += " or a KeyObject";
      MSG_INVALID_SECRET += "or a KeyObject";
    }
    function checkIsPublicKey(key) {
      if (Buffer3.isBuffer(key)) {
        return;
      }
      if (typeof key === "string") {
        return;
      }
      if (!supportsKeyObjects) {
        throw typeError(MSG_INVALID_VERIFIER_KEY);
      }
      if (typeof key !== "object") {
        throw typeError(MSG_INVALID_VERIFIER_KEY);
      }
      if (typeof key.type !== "string") {
        throw typeError(MSG_INVALID_VERIFIER_KEY);
      }
      if (typeof key.asymmetricKeyType !== "string") {
        throw typeError(MSG_INVALID_VERIFIER_KEY);
      }
      if (typeof key.export !== "function") {
        throw typeError(MSG_INVALID_VERIFIER_KEY);
      }
    }
    function checkIsPrivateKey(key) {
      if (Buffer3.isBuffer(key)) {
        return;
      }
      if (typeof key === "string") {
        return;
      }
      if (typeof key === "object") {
        return;
      }
      throw typeError(MSG_INVALID_SIGNER_KEY);
    }
    function checkIsSecretKey(key) {
      if (Buffer3.isBuffer(key)) {
        return;
      }
      if (typeof key === "string") {
        return key;
      }
      if (!supportsKeyObjects) {
        throw typeError(MSG_INVALID_SECRET);
      }
      if (typeof key !== "object") {
        throw typeError(MSG_INVALID_SECRET);
      }
      if (key.type !== "secret") {
        throw typeError(MSG_INVALID_SECRET);
      }
      if (typeof key.export !== "function") {
        throw typeError(MSG_INVALID_SECRET);
      }
    }
    function fromBase64(base644) {
      return base644.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
    }
    function toBase64(base64url4) {
      base64url4 = base64url4.toString();
      var padding = 4 - base64url4.length % 4;
      if (padding !== 4) {
        for (var i = 0; i < padding; ++i) {
          base64url4 += "=";
        }
      }
      return base64url4.replace(/\-/g, "+").replace(/_/g, "/");
    }
    function typeError(template) {
      var args = [].slice.call(arguments, 1);
      var errMsg = util4.format.bind(util4, template).apply(null, args);
      return new TypeError(errMsg);
    }
    function bufferOrString(obj) {
      return Buffer3.isBuffer(obj) || typeof obj === "string";
    }
    function normalizeInput(thing) {
      if (!bufferOrString(thing))
        thing = JSON.stringify(thing);
      return thing;
    }
    function createHmacSigner(bits) {
      return function sign(thing, secret) {
        checkIsSecretKey(secret);
        thing = normalizeInput(thing);
        var hmac = crypto7.createHmac("sha" + bits, secret);
        var sig = (hmac.update(thing), hmac.digest("base64"));
        return fromBase64(sig);
      };
    }
    var bufferEqual;
    var timingSafeEqual = "timingSafeEqual" in crypto7 ? function timingSafeEqual2(a, b) {
      if (a.byteLength !== b.byteLength) {
        return false;
      }
      return crypto7.timingSafeEqual(a, b);
    } : function timingSafeEqual2(a, b) {
      if (!bufferEqual) {
        bufferEqual = require_buffer_equal_constant_time();
      }
      return bufferEqual(a, b);
    };
    function createHmacVerifier(bits) {
      return function verify(thing, signature, secret) {
        var computedSig = createHmacSigner(bits)(thing, secret);
        return timingSafeEqual(Buffer3.from(signature), Buffer3.from(computedSig));
      };
    }
    function createKeySigner(bits) {
      return function sign(thing, privateKey) {
        checkIsPrivateKey(privateKey);
        thing = normalizeInput(thing);
        var signer = crypto7.createSign("RSA-SHA" + bits);
        var sig = (signer.update(thing), signer.sign(privateKey, "base64"));
        return fromBase64(sig);
      };
    }
    function createKeyVerifier(bits) {
      return function verify(thing, signature, publicKey) {
        checkIsPublicKey(publicKey);
        thing = normalizeInput(thing);
        signature = toBase64(signature);
        var verifier = crypto7.createVerify("RSA-SHA" + bits);
        verifier.update(thing);
        return verifier.verify(publicKey, signature, "base64");
      };
    }
    function createPSSKeySigner(bits) {
      return function sign(thing, privateKey) {
        checkIsPrivateKey(privateKey);
        thing = normalizeInput(thing);
        var signer = crypto7.createSign("RSA-SHA" + bits);
        var sig = (signer.update(thing), signer.sign({
          key: privateKey,
          padding: crypto7.constants.RSA_PKCS1_PSS_PADDING,
          saltLength: crypto7.constants.RSA_PSS_SALTLEN_DIGEST
        }, "base64"));
        return fromBase64(sig);
      };
    }
    function createPSSKeyVerifier(bits) {
      return function verify(thing, signature, publicKey) {
        checkIsPublicKey(publicKey);
        thing = normalizeInput(thing);
        signature = toBase64(signature);
        var verifier = crypto7.createVerify("RSA-SHA" + bits);
        verifier.update(thing);
        return verifier.verify({
          key: publicKey,
          padding: crypto7.constants.RSA_PKCS1_PSS_PADDING,
          saltLength: crypto7.constants.RSA_PSS_SALTLEN_DIGEST
        }, signature, "base64");
      };
    }
    function createECDSASigner(bits) {
      var inner = createKeySigner(bits);
      return function sign() {
        var signature = inner.apply(null, arguments);
        signature = formatEcdsa.derToJose(signature, "ES" + bits);
        return signature;
      };
    }
    function createECDSAVerifer(bits) {
      var inner = createKeyVerifier(bits);
      return function verify(thing, signature, publicKey) {
        signature = formatEcdsa.joseToDer(signature, "ES" + bits).toString("base64");
        var result = inner(thing, signature, publicKey);
        return result;
      };
    }
    function createNoneSigner() {
      return function sign() {
        return "";
      };
    }
    function createNoneVerifier() {
      return function verify(thing, signature) {
        return signature === "";
      };
    }
    module2.exports = function jwa(algorithm) {
      var signerFactories = {
        hs: createHmacSigner,
        rs: createKeySigner,
        ps: createPSSKeySigner,
        es: createECDSASigner,
        none: createNoneSigner
      };
      var verifierFactories = {
        hs: createHmacVerifier,
        rs: createKeyVerifier,
        ps: createPSSKeyVerifier,
        es: createECDSAVerifer,
        none: createNoneVerifier
      };
      var match = algorithm.match(/^(RS|PS|ES|HS)(256|384|512)$|^(none)$/);
      if (!match)
        throw typeError(MSG_INVALID_ALGORITHM, algorithm);
      var algo = (match[1] || match[3]).toLowerCase();
      var bits = match[2];
      return {
        sign: signerFactories[algo](bits),
        verify: verifierFactories[algo](bits)
      };
    };
  }
});

// node_modules/jws/lib/tostring.js
var require_tostring = __commonJS({
  "node_modules/jws/lib/tostring.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require("buffer").Buffer;
    module2.exports = function toString4(obj) {
      if (typeof obj === "string")
        return obj;
      if (typeof obj === "number" || Buffer3.isBuffer(obj))
        return obj.toString();
      return JSON.stringify(obj);
    };
  }
});

// node_modules/jws/lib/sign-stream.js
var require_sign_stream = __commonJS({
  "node_modules/jws/lib/sign-stream.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safe_buffer2().Buffer;
    var DataStream = require_data_stream();
    var jwa = require_jwa();
    var Stream = require("stream");
    var toString4 = require_tostring();
    var util4 = require("util");
    function base64url4(string5, encoding) {
      return Buffer3.from(string5, encoding).toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
    }
    function jwsSecuredInput(header, payload, encoding) {
      encoding = encoding || "utf8";
      var encodedHeader = base64url4(toString4(header), "binary");
      var encodedPayload = base64url4(toString4(payload), encoding);
      return util4.format("%s.%s", encodedHeader, encodedPayload);
    }
    function jwsSign(opts) {
      var header = opts.header;
      var payload = opts.payload;
      var secretOrKey = opts.secret || opts.privateKey;
      var encoding = opts.encoding;
      var algo = jwa(header.alg);
      var securedInput = jwsSecuredInput(header, payload, encoding);
      var signature = algo.sign(securedInput, secretOrKey);
      return util4.format("%s.%s", securedInput, signature);
    }
    function SignStream(opts) {
      var secret = opts.secret;
      secret = secret == null ? opts.privateKey : secret;
      secret = secret == null ? opts.key : secret;
      if (/^hs/i.test(opts.header.alg) === true && secret == null) {
        throw new TypeError("secret must be a string or buffer or a KeyObject");
      }
      var secretStream = new DataStream(secret);
      this.readable = true;
      this.header = opts.header;
      this.encoding = opts.encoding;
      this.secret = this.privateKey = this.key = secretStream;
      this.payload = new DataStream(opts.payload);
      this.secret.once("close", function() {
        if (!this.payload.writable && this.readable)
          this.sign();
      }.bind(this));
      this.payload.once("close", function() {
        if (!this.secret.writable && this.readable)
          this.sign();
      }.bind(this));
    }
    util4.inherits(SignStream, Stream);
    SignStream.prototype.sign = function sign() {
      try {
        var signature = jwsSign({
          header: this.header,
          payload: this.payload.buffer,
          secret: this.secret.buffer,
          encoding: this.encoding
        });
        this.emit("done", signature);
        this.emit("data", signature);
        this.emit("end");
        this.readable = false;
        return signature;
      } catch (e) {
        this.readable = false;
        this.emit("error", e);
        this.emit("close");
      }
    };
    SignStream.sign = jwsSign;
    module2.exports = SignStream;
  }
});

// node_modules/jws/lib/verify-stream.js
var require_verify_stream = __commonJS({
  "node_modules/jws/lib/verify-stream.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safe_buffer2().Buffer;
    var DataStream = require_data_stream();
    var jwa = require_jwa();
    var Stream = require("stream");
    var toString4 = require_tostring();
    var util4 = require("util");
    var JWS_REGEX = /^[a-zA-Z0-9\-_]+?\.[a-zA-Z0-9\-_]+?\.([a-zA-Z0-9\-_]+)?$/;
    function isObject5(thing) {
      return Object.prototype.toString.call(thing) === "[object Object]";
    }
    function safeJsonParse(thing) {
      if (isObject5(thing))
        return thing;
      try {
        return JSON.parse(thing);
      } catch (e) {
        return void 0;
      }
    }
    function headerFromJWS(jwsSig) {
      var encodedHeader = jwsSig.split(".", 1)[0];
      return safeJsonParse(Buffer3.from(encodedHeader, "base64").toString("binary"));
    }
    function securedInputFromJWS(jwsSig) {
      return jwsSig.split(".", 2).join(".");
    }
    function signatureFromJWS(jwsSig) {
      return jwsSig.split(".")[2];
    }
    function payloadFromJWS(jwsSig, encoding) {
      encoding = encoding || "utf8";
      var payload = jwsSig.split(".")[1];
      return Buffer3.from(payload, "base64").toString(encoding);
    }
    function isValidJws(string5) {
      return JWS_REGEX.test(string5) && !!headerFromJWS(string5);
    }
    function jwsVerify(jwsSig, algorithm, secretOrKey) {
      if (!algorithm) {
        var err = new Error("Missing algorithm parameter for jws.verify");
        err.code = "MISSING_ALGORITHM";
        throw err;
      }
      jwsSig = toString4(jwsSig);
      var signature = signatureFromJWS(jwsSig);
      var securedInput = securedInputFromJWS(jwsSig);
      var algo = jwa(algorithm);
      return algo.verify(securedInput, signature, secretOrKey);
    }
    function jwsDecode(jwsSig, opts) {
      opts = opts || {};
      jwsSig = toString4(jwsSig);
      if (!isValidJws(jwsSig))
        return null;
      var header = headerFromJWS(jwsSig);
      if (!header)
        return null;
      var payload = payloadFromJWS(jwsSig);
      if (header.typ === "JWT" || opts.json)
        payload = JSON.parse(payload, opts.encoding);
      return {
        header,
        payload,
        signature: signatureFromJWS(jwsSig)
      };
    }
    function VerifyStream(opts) {
      opts = opts || {};
      var secretOrKey = opts.secret;
      secretOrKey = secretOrKey == null ? opts.publicKey : secretOrKey;
      secretOrKey = secretOrKey == null ? opts.key : secretOrKey;
      if (/^hs/i.test(opts.algorithm) === true && secretOrKey == null) {
        throw new TypeError("secret must be a string or buffer or a KeyObject");
      }
      var secretStream = new DataStream(secretOrKey);
      this.readable = true;
      this.algorithm = opts.algorithm;
      this.encoding = opts.encoding;
      this.secret = this.publicKey = this.key = secretStream;
      this.signature = new DataStream(opts.signature);
      this.secret.once("close", function() {
        if (!this.signature.writable && this.readable)
          this.verify();
      }.bind(this));
      this.signature.once("close", function() {
        if (!this.secret.writable && this.readable)
          this.verify();
      }.bind(this));
    }
    util4.inherits(VerifyStream, Stream);
    VerifyStream.prototype.verify = function verify() {
      try {
        var valid = jwsVerify(this.signature.buffer, this.algorithm, this.key.buffer);
        var obj = jwsDecode(this.signature.buffer, this.encoding);
        this.emit("done", valid, obj);
        this.emit("data", valid);
        this.emit("end");
        this.readable = false;
        return valid;
      } catch (e) {
        this.readable = false;
        this.emit("error", e);
        this.emit("close");
      }
    };
    VerifyStream.decode = jwsDecode;
    VerifyStream.isValid = isValidJws;
    VerifyStream.verify = jwsVerify;
    module2.exports = VerifyStream;
  }
});

// node_modules/jws/index.js
var require_jws = __commonJS({
  "node_modules/jws/index.js"(exports2) {
    "use strict";
    var SignStream = require_sign_stream();
    var VerifyStream = require_verify_stream();
    var ALGORITHMS = [
      "HS256",
      "HS384",
      "HS512",
      "RS256",
      "RS384",
      "RS512",
      "PS256",
      "PS384",
      "PS512",
      "ES256",
      "ES384",
      "ES512"
    ];
    exports2.ALGORITHMS = ALGORITHMS;
    exports2.sign = SignStream.sign;
    exports2.verify = VerifyStream.verify;
    exports2.decode = VerifyStream.decode;
    exports2.isValid = VerifyStream.isValid;
    exports2.createSign = function createSign(opts) {
      return new SignStream(opts);
    };
    exports2.createVerify = function createVerify(opts) {
      return new VerifyStream(opts);
    };
  }
});

// node_modules/jsonwebtoken/decode.js
var require_decode = __commonJS({
  "node_modules/jsonwebtoken/decode.js"(exports2, module2) {
    "use strict";
    var jws = require_jws();
    module2.exports = function(jwt4, options) {
      options = options || {};
      var decoded = jws.decode(jwt4, options);
      if (!decoded) {
        return null;
      }
      var payload = decoded.payload;
      if (typeof payload === "string") {
        try {
          var obj = JSON.parse(payload);
          if (obj !== null && typeof obj === "object") {
            payload = obj;
          }
        } catch (e) {
        }
      }
      if (options.complete === true) {
        return {
          header: decoded.header,
          payload,
          signature: decoded.signature
        };
      }
      return payload;
    };
  }
});

// node_modules/jsonwebtoken/lib/JsonWebTokenError.js
var require_JsonWebTokenError = __commonJS({
  "node_modules/jsonwebtoken/lib/JsonWebTokenError.js"(exports2, module2) {
    "use strict";
    var JsonWebTokenError = function(message, error73) {
      Error.call(this, message);
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, this.constructor);
      }
      this.name = "JsonWebTokenError";
      this.message = message;
      if (error73) this.inner = error73;
    };
    JsonWebTokenError.prototype = Object.create(Error.prototype);
    JsonWebTokenError.prototype.constructor = JsonWebTokenError;
    module2.exports = JsonWebTokenError;
  }
});

// node_modules/jsonwebtoken/lib/NotBeforeError.js
var require_NotBeforeError = __commonJS({
  "node_modules/jsonwebtoken/lib/NotBeforeError.js"(exports2, module2) {
    "use strict";
    var JsonWebTokenError = require_JsonWebTokenError();
    var NotBeforeError = function(message, date6) {
      JsonWebTokenError.call(this, message);
      this.name = "NotBeforeError";
      this.date = date6;
    };
    NotBeforeError.prototype = Object.create(JsonWebTokenError.prototype);
    NotBeforeError.prototype.constructor = NotBeforeError;
    module2.exports = NotBeforeError;
  }
});

// node_modules/jsonwebtoken/lib/TokenExpiredError.js
var require_TokenExpiredError = __commonJS({
  "node_modules/jsonwebtoken/lib/TokenExpiredError.js"(exports2, module2) {
    "use strict";
    var JsonWebTokenError = require_JsonWebTokenError();
    var TokenExpiredError = function(message, expiredAt) {
      JsonWebTokenError.call(this, message);
      this.name = "TokenExpiredError";
      this.expiredAt = expiredAt;
    };
    TokenExpiredError.prototype = Object.create(JsonWebTokenError.prototype);
    TokenExpiredError.prototype.constructor = TokenExpiredError;
    module2.exports = TokenExpiredError;
  }
});

// node_modules/jsonwebtoken/lib/timespan.js
var require_timespan = __commonJS({
  "node_modules/jsonwebtoken/lib/timespan.js"(exports2, module2) {
    "use strict";
    var ms = require_ms();
    module2.exports = function(time4, iat) {
      var timestamp = iat || Math.floor(Date.now() / 1e3);
      if (typeof time4 === "string") {
        var milliseconds = ms(time4);
        if (typeof milliseconds === "undefined") {
          return;
        }
        return Math.floor(timestamp + milliseconds / 1e3);
      } else if (typeof time4 === "number") {
        return timestamp + time4;
      } else {
        return;
      }
    };
  }
});

// node_modules/semver/internal/constants.js
var require_constants8 = __commonJS({
  "node_modules/semver/internal/constants.js"(exports2, module2) {
    "use strict";
    var SEMVER_SPEC_VERSION = "2.0.0";
    var MAX_LENGTH = 256;
    var MAX_SAFE_INTEGER3 = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
    9007199254740991;
    var MAX_SAFE_COMPONENT_LENGTH = 16;
    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
    var RELEASE_TYPES = [
      "major",
      "premajor",
      "minor",
      "preminor",
      "patch",
      "prepatch",
      "prerelease"
    ];
    module2.exports = {
      MAX_LENGTH,
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_SAFE_INTEGER: MAX_SAFE_INTEGER3,
      RELEASE_TYPES,
      SEMVER_SPEC_VERSION,
      FLAG_INCLUDE_PRERELEASE: 1,
      FLAG_LOOSE: 2
    };
  }
});

// node_modules/semver/internal/debug.js
var require_debug3 = __commonJS({
  "node_modules/semver/internal/debug.js"(exports2, module2) {
    "use strict";
    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
    };
    module2.exports = debug;
  }
});

// node_modules/semver/internal/re.js
var require_re = __commonJS({
  "node_modules/semver/internal/re.js"(exports2, module2) {
    "use strict";
    var {
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_LENGTH
    } = require_constants8();
    var debug = require_debug3();
    exports2 = module2.exports = {};
    var re2 = exports2.re = [];
    var safeRe = exports2.safeRe = [];
    var src = exports2.src = [];
    var safeSrc = exports2.safeSrc = [];
    var t = exports2.t = {};
    var R = 0;
    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
    var safeRegexReplacements = [
      ["\\s", 1],
      ["\\d", MAX_LENGTH],
      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
    ];
    var makeSafeRegex = (value) => {
      for (const [token, max] of safeRegexReplacements) {
        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
      }
      return value;
    };
    var createToken = (name28, value, isGlobal) => {
      const safe = makeSafeRegex(value);
      const index = R++;
      debug(name28, index, value);
      t[name28] = index;
      src[index] = value;
      safeSrc[index] = safe;
      re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
    };
    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
    createToken("GTLT", "((?:<|>)?=?)");
    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
    createToken("COERCERTL", src[t.COERCE], true);
    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
    createToken("LONETILDE", "(?:~>?)");
    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
    exports2.tildeTrimReplace = "$1~";
    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
    createToken("LONECARET", "(?:\\^)");
    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
    exports2.caretTrimReplace = "$1^";
    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
    exports2.comparatorTrimReplace = "$1$2$3";
    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
    createToken("STAR", "(<|>)?=?\\s*\\*");
    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
  }
});

// node_modules/semver/internal/parse-options.js
var require_parse_options = __commonJS({
  "node_modules/semver/internal/parse-options.js"(exports2, module2) {
    "use strict";
    var looseOption = Object.freeze({ loose: true });
    var emptyOpts = Object.freeze({});
    var parseOptions = (options) => {
      if (!options) {
        return emptyOpts;
      }
      if (typeof options !== "object") {
        return looseOption;
      }
      return options;
    };
    module2.exports = parseOptions;
  }
});

// node_modules/semver/internal/identifiers.js
var require_identifiers = __commonJS({
  "node_modules/semver/internal/identifiers.js"(exports2, module2) {
    "use strict";
    var numeric = /^[0-9]+$/;
    var compareIdentifiers = (a, b) => {
      if (typeof a === "number" && typeof b === "number") {
        return a === b ? 0 : a < b ? -1 : 1;
      }
      const anum = numeric.test(a);
      const bnum = numeric.test(b);
      if (anum && bnum) {
        a = +a;
        b = +b;
      }
      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
    };
    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
    module2.exports = {
      compareIdentifiers,
      rcompareIdentifiers
    };
  }
});

// node_modules/semver/classes/semver.js
var require_semver = __commonJS({
  "node_modules/semver/classes/semver.js"(exports2, module2) {
    "use strict";
    var debug = require_debug3();
    var { MAX_LENGTH, MAX_SAFE_INTEGER: MAX_SAFE_INTEGER3 } = require_constants8();
    var { safeRe: re2, t } = require_re();
    var parseOptions = require_parse_options();
    var { compareIdentifiers } = require_identifiers();
    var SemVer = class _SemVer {
      constructor(version3, options) {
        options = parseOptions(options);
        if (version3 instanceof _SemVer) {
          if (version3.loose === !!options.loose && version3.includePrerelease === !!options.includePrerelease) {
            return version3;
          } else {
            version3 = version3.version;
          }
        } else if (typeof version3 !== "string") {
          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version3}".`);
        }
        if (version3.length > MAX_LENGTH) {
          throw new TypeError(
            `version is longer than ${MAX_LENGTH} characters`
          );
        }
        debug("SemVer", version3, options);
        this.options = options;
        this.loose = !!options.loose;
        this.includePrerelease = !!options.includePrerelease;
        const m = version3.trim().match(options.loose ? re2[t.LOOSE] : re2[t.FULL]);
        if (!m) {
          throw new TypeError(`Invalid Version: ${version3}`);
        }
        this.raw = version3;
        this.major = +m[1];
        this.minor = +m[2];
        this.patch = +m[3];
        if (this.major > MAX_SAFE_INTEGER3 || this.major < 0) {
          throw new TypeError("Invalid major version");
        }
        if (this.minor > MAX_SAFE_INTEGER3 || this.minor < 0) {
          throw new TypeError("Invalid minor version");
        }
        if (this.patch > MAX_SAFE_INTEGER3 || this.patch < 0) {
          throw new TypeError("Invalid patch version");
        }
        if (!m[4]) {
          this.prerelease = [];
        } else {
          this.prerelease = m[4].split(".").map((id) => {
            if (/^[0-9]+$/.test(id)) {
              const num = +id;
              if (num >= 0 && num < MAX_SAFE_INTEGER3) {
                return num;
              }
            }
            return id;
          });
        }
        this.build = m[5] ? m[5].split(".") : [];
        this.format();
      }
      format() {
        this.version = `${this.major}.${this.minor}.${this.patch}`;
        if (this.prerelease.length) {
          this.version += `-${this.prerelease.join(".")}`;
        }
        return this.version;
      }
      toString() {
        return this.version;
      }
      compare(other) {
        debug("SemVer.compare", this.version, this.options, other);
        if (!(other instanceof _SemVer)) {
          if (typeof other === "string" && other === this.version) {
            return 0;
          }
          other = new _SemVer(other, this.options);
        }
        if (other.version === this.version) {
          return 0;
        }
        return this.compareMain(other) || this.comparePre(other);
      }
      compareMain(other) {
        if (!(other instanceof _SemVer)) {
          other = new _SemVer(other, this.options);
        }
        if (this.major < other.major) {
          return -1;
        }
        if (this.major > other.major) {
          return 1;
        }
        if (this.minor < other.minor) {
          return -1;
        }
        if (this.minor > other.minor) {
          return 1;
        }
        if (this.patch < other.patch) {
          return -1;
        }
        if (this.patch > other.patch) {
          return 1;
        }
        return 0;
      }
      comparePre(other) {
        if (!(other instanceof _SemVer)) {
          other = new _SemVer(other, this.options);
        }
        if (this.prerelease.length && !other.prerelease.length) {
          return -1;
        } else if (!this.prerelease.length && other.prerelease.length) {
          return 1;
        } else if (!this.prerelease.length && !other.prerelease.length) {
          return 0;
        }
        let i = 0;
        do {
          const a = this.prerelease[i];
          const b = other.prerelease[i];
          debug("prerelease compare", i, a, b);
          if (a === void 0 && b === void 0) {
            return 0;
          } else if (b === void 0) {
            return 1;
          } else if (a === void 0) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      }
      compareBuild(other) {
        if (!(other instanceof _SemVer)) {
          other = new _SemVer(other, this.options);
        }
        let i = 0;
        do {
          const a = this.build[i];
          const b = other.build[i];
          debug("build compare", i, a, b);
          if (a === void 0 && b === void 0) {
            return 0;
          } else if (b === void 0) {
            return 1;
          } else if (a === void 0) {
            return -1;
          } else if (a === b) {
            continue;
          } else {
            return compareIdentifiers(a, b);
          }
        } while (++i);
      }
      // preminor will bump the version up to the next minor release, and immediately
      // down to pre-release. premajor and prepatch work the same way.
      inc(release, identifier, identifierBase) {
        if (release.startsWith("pre")) {
          if (!identifier && identifierBase === false) {
            throw new Error("invalid increment argument: identifier is empty");
          }
          if (identifier) {
            const match = `-${identifier}`.match(this.options.loose ? re2[t.PRERELEASELOOSE] : re2[t.PRERELEASE]);
            if (!match || match[1] !== identifier) {
              throw new Error(`invalid identifier: ${identifier}`);
            }
          }
        }
        switch (release) {
          case "premajor":
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor = 0;
            this.major++;
            this.inc("pre", identifier, identifierBase);
            break;
          case "preminor":
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor++;
            this.inc("pre", identifier, identifierBase);
            break;
          case "prepatch":
            this.prerelease.length = 0;
            this.inc("patch", identifier, identifierBase);
            this.inc("pre", identifier, identifierBase);
            break;
          // If the input is a non-prerelease version, this acts the same as
          // prepatch.
          case "prerelease":
            if (this.prerelease.length === 0) {
              this.inc("patch", identifier, identifierBase);
            }
            this.inc("pre", identifier, identifierBase);
            break;
          case "release":
            if (this.prerelease.length === 0) {
              throw new Error(`version ${this.raw} is not a prerelease`);
            }
            this.prerelease.length = 0;
            break;
          case "major":
            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
              this.major++;
            }
            this.minor = 0;
            this.patch = 0;
            this.prerelease = [];
            break;
          case "minor":
            if (this.patch !== 0 || this.prerelease.length === 0) {
              this.minor++;
            }
            this.patch = 0;
            this.prerelease = [];
            break;
          case "patch":
            if (this.prerelease.length === 0) {
              this.patch++;
            }
            this.prerelease = [];
            break;
          // This probably shouldn't be used publicly.
          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
          case "pre": {
            const base = Number(identifierBase) ? 1 : 0;
            if (this.prerelease.length === 0) {
              this.prerelease = [base];
            } else {
              let i = this.prerelease.length;
              while (--i >= 0) {
                if (typeof this.prerelease[i] === "number") {
                  this.prerelease[i]++;
                  i = -2;
                }
              }
              if (i === -1) {
                if (identifier === this.prerelease.join(".") && identifierBase === false) {
                  throw new Error("invalid increment argument: identifier already exists");
                }
                this.prerelease.push(base);
              }
            }
            if (identifier) {
              let prerelease = [identifier, base];
              if (identifierBase === false) {
                prerelease = [identifier];
              }
              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
                if (isNaN(this.prerelease[1])) {
                  this.prerelease = prerelease;
                }
              } else {
                this.prerelease = prerelease;
              }
            }
            break;
          }
          default:
            throw new Error(`invalid increment argument: ${release}`);
        }
        this.raw = this.format();
        if (this.build.length) {
          this.raw += `+${this.build.join(".")}`;
        }
        return this;
      }
    };
    module2.exports = SemVer;
  }
});

// node_modules/semver/functions/parse.js
var require_parse6 = __commonJS({
  "node_modules/semver/functions/parse.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var parse4 = (version3, options, throwErrors = false) => {
      if (version3 instanceof SemVer) {
        return version3;
      }
      try {
        return new SemVer(version3, options);
      } catch (er) {
        if (!throwErrors) {
          return null;
        }
        throw er;
      }
    };
    module2.exports = parse4;
  }
});

// node_modules/semver/functions/valid.js
var require_valid = __commonJS({
  "node_modules/semver/functions/valid.js"(exports2, module2) {
    "use strict";
    var parse4 = require_parse6();
    var valid = (version3, options) => {
      const v = parse4(version3, options);
      return v ? v.version : null;
    };
    module2.exports = valid;
  }
});

// node_modules/semver/functions/clean.js
var require_clean = __commonJS({
  "node_modules/semver/functions/clean.js"(exports2, module2) {
    "use strict";
    var parse4 = require_parse6();
    var clean = (version3, options) => {
      const s = parse4(version3.trim().replace(/^[=v]+/, ""), options);
      return s ? s.version : null;
    };
    module2.exports = clean;
  }
});

// node_modules/semver/functions/inc.js
var require_inc = __commonJS({
  "node_modules/semver/functions/inc.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var inc = (version3, release, options, identifier, identifierBase) => {
      if (typeof options === "string") {
        identifierBase = identifier;
        identifier = options;
        options = void 0;
      }
      try {
        return new SemVer(
          version3 instanceof SemVer ? version3.version : version3,
          options
        ).inc(release, identifier, identifierBase).version;
      } catch (er) {
        return null;
      }
    };
    module2.exports = inc;
  }
});

// node_modules/semver/functions/diff.js
var require_diff = __commonJS({
  "node_modules/semver/functions/diff.js"(exports2, module2) {
    "use strict";
    var parse4 = require_parse6();
    var diff = (version1, version22) => {
      const v1 = parse4(version1, null, true);
      const v2 = parse4(version22, null, true);
      const comparison = v1.compare(v2);
      if (comparison === 0) {
        return null;
      }
      const v1Higher = comparison > 0;
      const highVersion = v1Higher ? v1 : v2;
      const lowVersion = v1Higher ? v2 : v1;
      const highHasPre = !!highVersion.prerelease.length;
      const lowHasPre = !!lowVersion.prerelease.length;
      if (lowHasPre && !highHasPre) {
        if (!lowVersion.patch && !lowVersion.minor) {
          return "major";
        }
        if (lowVersion.compareMain(highVersion) === 0) {
          if (lowVersion.minor && !lowVersion.patch) {
            return "minor";
          }
          return "patch";
        }
      }
      const prefix = highHasPre ? "pre" : "";
      if (v1.major !== v2.major) {
        return prefix + "major";
      }
      if (v1.minor !== v2.minor) {
        return prefix + "minor";
      }
      if (v1.patch !== v2.patch) {
        return prefix + "patch";
      }
      return "prerelease";
    };
    module2.exports = diff;
  }
});

// node_modules/semver/functions/major.js
var require_major = __commonJS({
  "node_modules/semver/functions/major.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var major2 = (a, loose) => new SemVer(a, loose).major;
    module2.exports = major2;
  }
});

// node_modules/semver/functions/minor.js
var require_minor = __commonJS({
  "node_modules/semver/functions/minor.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var minor = (a, loose) => new SemVer(a, loose).minor;
    module2.exports = minor;
  }
});

// node_modules/semver/functions/patch.js
var require_patch = __commonJS({
  "node_modules/semver/functions/patch.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var patch = (a, loose) => new SemVer(a, loose).patch;
    module2.exports = patch;
  }
});

// node_modules/semver/functions/prerelease.js
var require_prerelease = __commonJS({
  "node_modules/semver/functions/prerelease.js"(exports2, module2) {
    "use strict";
    var parse4 = require_parse6();
    var prerelease = (version3, options) => {
      const parsed = parse4(version3, options);
      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
    };
    module2.exports = prerelease;
  }
});

// node_modules/semver/functions/compare.js
var require_compare = __commonJS({
  "node_modules/semver/functions/compare.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
    module2.exports = compare;
  }
});

// node_modules/semver/functions/rcompare.js
var require_rcompare = __commonJS({
  "node_modules/semver/functions/rcompare.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var rcompare = (a, b, loose) => compare(b, a, loose);
    module2.exports = rcompare;
  }
});

// node_modules/semver/functions/compare-loose.js
var require_compare_loose = __commonJS({
  "node_modules/semver/functions/compare-loose.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var compareLoose = (a, b) => compare(a, b, true);
    module2.exports = compareLoose;
  }
});

// node_modules/semver/functions/compare-build.js
var require_compare_build = __commonJS({
  "node_modules/semver/functions/compare-build.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var compareBuild = (a, b, loose) => {
      const versionA = new SemVer(a, loose);
      const versionB = new SemVer(b, loose);
      return versionA.compare(versionB) || versionA.compareBuild(versionB);
    };
    module2.exports = compareBuild;
  }
});

// node_modules/semver/functions/sort.js
var require_sort = __commonJS({
  "node_modules/semver/functions/sort.js"(exports2, module2) {
    "use strict";
    var compareBuild = require_compare_build();
    var sort = (list2, loose) => list2.sort((a, b) => compareBuild(a, b, loose));
    module2.exports = sort;
  }
});

// node_modules/semver/functions/rsort.js
var require_rsort = __commonJS({
  "node_modules/semver/functions/rsort.js"(exports2, module2) {
    "use strict";
    var compareBuild = require_compare_build();
    var rsort = (list2, loose) => list2.sort((a, b) => compareBuild(b, a, loose));
    module2.exports = rsort;
  }
});

// node_modules/semver/functions/gt.js
var require_gt = __commonJS({
  "node_modules/semver/functions/gt.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var gt = (a, b, loose) => compare(a, b, loose) > 0;
    module2.exports = gt;
  }
});

// node_modules/semver/functions/lt.js
var require_lt2 = __commonJS({
  "node_modules/semver/functions/lt.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var lt = (a, b, loose) => compare(a, b, loose) < 0;
    module2.exports = lt;
  }
});

// node_modules/semver/functions/eq.js
var require_eq2 = __commonJS({
  "node_modules/semver/functions/eq.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var eq2 = (a, b, loose) => compare(a, b, loose) === 0;
    module2.exports = eq2;
  }
});

// node_modules/semver/functions/neq.js
var require_neq = __commonJS({
  "node_modules/semver/functions/neq.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
    module2.exports = neq;
  }
});

// node_modules/semver/functions/gte.js
var require_gte = __commonJS({
  "node_modules/semver/functions/gte.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
    module2.exports = gte;
  }
});

// node_modules/semver/functions/lte.js
var require_lte = __commonJS({
  "node_modules/semver/functions/lte.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
    module2.exports = lte;
  }
});

// node_modules/semver/functions/cmp.js
var require_cmp = __commonJS({
  "node_modules/semver/functions/cmp.js"(exports2, module2) {
    "use strict";
    var eq2 = require_eq2();
    var neq = require_neq();
    var gt = require_gt();
    var gte = require_gte();
    var lt = require_lt2();
    var lte = require_lte();
    var cmp = (a, op, b, loose) => {
      switch (op) {
        case "===":
          if (typeof a === "object") {
            a = a.version;
          }
          if (typeof b === "object") {
            b = b.version;
          }
          return a === b;
        case "!==":
          if (typeof a === "object") {
            a = a.version;
          }
          if (typeof b === "object") {
            b = b.version;
          }
          return a !== b;
        case "":
        case "=":
        case "==":
          return eq2(a, b, loose);
        case "!=":
          return neq(a, b, loose);
        case ">":
          return gt(a, b, loose);
        case ">=":
          return gte(a, b, loose);
        case "<":
          return lt(a, b, loose);
        case "<=":
          return lte(a, b, loose);
        default:
          throw new TypeError(`Invalid operator: ${op}`);
      }
    };
    module2.exports = cmp;
  }
});

// node_modules/semver/functions/coerce.js
var require_coerce2 = __commonJS({
  "node_modules/semver/functions/coerce.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var parse4 = require_parse6();
    var { safeRe: re2, t } = require_re();
    var coerce = (version3, options) => {
      if (version3 instanceof SemVer) {
        return version3;
      }
      if (typeof version3 === "number") {
        version3 = String(version3);
      }
      if (typeof version3 !== "string") {
        return null;
      }
      options = options || {};
      let match = null;
      if (!options.rtl) {
        match = version3.match(options.includePrerelease ? re2[t.COERCEFULL] : re2[t.COERCE]);
      } else {
        const coerceRtlRegex = options.includePrerelease ? re2[t.COERCERTLFULL] : re2[t.COERCERTL];
        let next;
        while ((next = coerceRtlRegex.exec(version3)) && (!match || match.index + match[0].length !== version3.length)) {
          if (!match || next.index + next[0].length !== match.index + match[0].length) {
            match = next;
          }
          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
        }
        coerceRtlRegex.lastIndex = -1;
      }
      if (match === null) {
        return null;
      }
      const major2 = match[2];
      const minor = match[3] || "0";
      const patch = match[4] || "0";
      const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
      const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
      return parse4(`${major2}.${minor}.${patch}${prerelease}${build}`, options);
    };
    module2.exports = coerce;
  }
});

// node_modules/semver/internal/lrucache.js
var require_lrucache = __commonJS({
  "node_modules/semver/internal/lrucache.js"(exports2, module2) {
    "use strict";
    var LRUCache = class {
      constructor() {
        this.max = 1e3;
        this.map = /* @__PURE__ */ new Map();
      }
      get(key) {
        const value = this.map.get(key);
        if (value === void 0) {
          return void 0;
        } else {
          this.map.delete(key);
          this.map.set(key, value);
          return value;
        }
      }
      delete(key) {
        return this.map.delete(key);
      }
      set(key, value) {
        const deleted = this.delete(key);
        if (!deleted && value !== void 0) {
          if (this.map.size >= this.max) {
            const firstKey = this.map.keys().next().value;
            this.delete(firstKey);
          }
          this.map.set(key, value);
        }
        return this;
      }
    };
    module2.exports = LRUCache;
  }
});

// node_modules/semver/classes/range.js
var require_range2 = __commonJS({
  "node_modules/semver/classes/range.js"(exports2, module2) {
    "use strict";
    var SPACE_CHARACTERS = /\s+/g;
    var Range = class _Range {
      constructor(range, options) {
        options = parseOptions(options);
        if (range instanceof _Range) {
          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
            return range;
          } else {
            return new _Range(range.raw, options);
          }
        }
        if (range instanceof Comparator) {
          this.raw = range.value;
          this.set = [[range]];
          this.formatted = void 0;
          return this;
        }
        this.options = options;
        this.loose = !!options.loose;
        this.includePrerelease = !!options.includePrerelease;
        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
        if (!this.set.length) {
          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
        }
        if (this.set.length > 1) {
          const first = this.set[0];
          this.set = this.set.filter((c) => !isNullSet(c[0]));
          if (this.set.length === 0) {
            this.set = [first];
          } else if (this.set.length > 1) {
            for (const c of this.set) {
              if (c.length === 1 && isAny(c[0])) {
                this.set = [c];
                break;
              }
            }
          }
        }
        this.formatted = void 0;
      }
      get range() {
        if (this.formatted === void 0) {
          this.formatted = "";
          for (let i = 0; i < this.set.length; i++) {
            if (i > 0) {
              this.formatted += "||";
            }
            const comps = this.set[i];
            for (let k = 0; k < comps.length; k++) {
              if (k > 0) {
                this.formatted += " ";
              }
              this.formatted += comps[k].toString().trim();
            }
          }
        }
        return this.formatted;
      }
      format() {
        return this.range;
      }
      toString() {
        return this.range;
      }
      parseRange(range) {
        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
        const memoKey = memoOpts + ":" + range;
        const cached3 = cache.get(memoKey);
        if (cached3) {
          return cached3;
        }
        const loose = this.options.loose;
        const hr = loose ? re2[t.HYPHENRANGELOOSE] : re2[t.HYPHENRANGE];
        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
        debug("hyphen replace", range);
        range = range.replace(re2[t.COMPARATORTRIM], comparatorTrimReplace);
        debug("comparator trim", range);
        range = range.replace(re2[t.TILDETRIM], tildeTrimReplace);
        debug("tilde trim", range);
        range = range.replace(re2[t.CARETTRIM], caretTrimReplace);
        debug("caret trim", range);
        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
        if (loose) {
          rangeList = rangeList.filter((comp) => {
            debug("loose invalid filter", comp, this.options);
            return !!comp.match(re2[t.COMPARATORLOOSE]);
          });
        }
        debug("range list", rangeList);
        const rangeMap = /* @__PURE__ */ new Map();
        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
        for (const comp of comparators) {
          if (isNullSet(comp)) {
            return [comp];
          }
          rangeMap.set(comp.value, comp);
        }
        if (rangeMap.size > 1 && rangeMap.has("")) {
          rangeMap.delete("");
        }
        const result = [...rangeMap.values()];
        cache.set(memoKey, result);
        return result;
      }
      intersects(range, options) {
        if (!(range instanceof _Range)) {
          throw new TypeError("a Range is required");
        }
        return this.set.some((thisComparators) => {
          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
              return rangeComparators.every((rangeComparator) => {
                return thisComparator.intersects(rangeComparator, options);
              });
            });
          });
        });
      }
      // if ANY of the sets match ALL of its comparators, then pass
      test(version3) {
        if (!version3) {
          return false;
        }
        if (typeof version3 === "string") {
          try {
            version3 = new SemVer(version3, this.options);
          } catch (er) {
            return false;
          }
        }
        for (let i = 0; i < this.set.length; i++) {
          if (testSet(this.set[i], version3, this.options)) {
            return true;
          }
        }
        return false;
      }
    };
    module2.exports = Range;
    var LRU = require_lrucache();
    var cache = new LRU();
    var parseOptions = require_parse_options();
    var Comparator = require_comparator();
    var debug = require_debug3();
    var SemVer = require_semver();
    var {
      safeRe: re2,
      t,
      comparatorTrimReplace,
      tildeTrimReplace,
      caretTrimReplace
    } = require_re();
    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants8();
    var isNullSet = (c) => c.value === "<0.0.0-0";
    var isAny = (c) => c.value === "";
    var isSatisfiable = (comparators, options) => {
      let result = true;
      const remainingComparators = comparators.slice();
      let testComparator = remainingComparators.pop();
      while (result && remainingComparators.length) {
        result = remainingComparators.every((otherComparator) => {
          return testComparator.intersects(otherComparator, options);
        });
        testComparator = remainingComparators.pop();
      }
      return result;
    };
    var parseComparator = (comp, options) => {
      comp = comp.replace(re2[t.BUILD], "");
      debug("comp", comp, options);
      comp = replaceCarets(comp, options);
      debug("caret", comp);
      comp = replaceTildes(comp, options);
      debug("tildes", comp);
      comp = replaceXRanges(comp, options);
      debug("xrange", comp);
      comp = replaceStars(comp, options);
      debug("stars", comp);
      return comp;
    };
    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
    var replaceTildes = (comp, options) => {
      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
    };
    var replaceTilde = (comp, options) => {
      const r = options.loose ? re2[t.TILDELOOSE] : re2[t.TILDE];
      return comp.replace(r, (_, M, m, p3, pr) => {
        debug("tilde", comp, _, M, m, p3, pr);
        let ret;
        if (isX(M)) {
          ret = "";
        } else if (isX(m)) {
          ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
        } else if (isX(p3)) {
          ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
        } else if (pr) {
          debug("replaceTilde pr", pr);
          ret = `>=${M}.${m}.${p3}-${pr} <${M}.${+m + 1}.0-0`;
        } else {
          ret = `>=${M}.${m}.${p3} <${M}.${+m + 1}.0-0`;
        }
        debug("tilde return", ret);
        return ret;
      });
    };
    var replaceCarets = (comp, options) => {
      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
    };
    var replaceCaret = (comp, options) => {
      debug("caret", comp, options);
      const r = options.loose ? re2[t.CARETLOOSE] : re2[t.CARET];
      const z3 = options.includePrerelease ? "-0" : "";
      return comp.replace(r, (_, M, m, p3, pr) => {
        debug("caret", comp, _, M, m, p3, pr);
        let ret;
        if (isX(M)) {
          ret = "";
        } else if (isX(m)) {
          ret = `>=${M}.0.0${z3} <${+M + 1}.0.0-0`;
        } else if (isX(p3)) {
          if (M === "0") {
            ret = `>=${M}.${m}.0${z3} <${M}.${+m + 1}.0-0`;
          } else {
            ret = `>=${M}.${m}.0${z3} <${+M + 1}.0.0-0`;
          }
        } else if (pr) {
          debug("replaceCaret pr", pr);
          if (M === "0") {
            if (m === "0") {
              ret = `>=${M}.${m}.${p3}-${pr} <${M}.${m}.${+p3 + 1}-0`;
            } else {
              ret = `>=${M}.${m}.${p3}-${pr} <${M}.${+m + 1}.0-0`;
            }
          } else {
            ret = `>=${M}.${m}.${p3}-${pr} <${+M + 1}.0.0-0`;
          }
        } else {
          debug("no pr");
          if (M === "0") {
            if (m === "0") {
              ret = `>=${M}.${m}.${p3}${z3} <${M}.${m}.${+p3 + 1}-0`;
            } else {
              ret = `>=${M}.${m}.${p3}${z3} <${M}.${+m + 1}.0-0`;
            }
          } else {
            ret = `>=${M}.${m}.${p3} <${+M + 1}.0.0-0`;
          }
        }
        debug("caret return", ret);
        return ret;
      });
    };
    var replaceXRanges = (comp, options) => {
      debug("replaceXRanges", comp, options);
      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
    };
    var replaceXRange = (comp, options) => {
      comp = comp.trim();
      const r = options.loose ? re2[t.XRANGELOOSE] : re2[t.XRANGE];
      return comp.replace(r, (ret, gtlt, M, m, p3, pr) => {
        debug("xRange", comp, ret, gtlt, M, m, p3, pr);
        const xM = isX(M);
        const xm = xM || isX(m);
        const xp = xm || isX(p3);
        const anyX = xp;
        if (gtlt === "=" && anyX) {
          gtlt = "";
        }
        pr = options.includePrerelease ? "-0" : "";
        if (xM) {
          if (gtlt === ">" || gtlt === "<") {
            ret = "<0.0.0-0";
          } else {
            ret = "*";
          }
        } else if (gtlt && anyX) {
          if (xm) {
            m = 0;
          }
          p3 = 0;
          if (gtlt === ">") {
            gtlt = ">=";
            if (xm) {
              M = +M + 1;
              m = 0;
              p3 = 0;
            } else {
              m = +m + 1;
              p3 = 0;
            }
          } else if (gtlt === "<=") {
            gtlt = "<";
            if (xm) {
              M = +M + 1;
            } else {
              m = +m + 1;
            }
          }
          if (gtlt === "<") {
            pr = "-0";
          }
          ret = `${gtlt + M}.${m}.${p3}${pr}`;
        } else if (xm) {
          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
        } else if (xp) {
          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
        }
        debug("xRange return", ret);
        return ret;
      });
    };
    var replaceStars = (comp, options) => {
      debug("replaceStars", comp, options);
      return comp.trim().replace(re2[t.STAR], "");
    };
    var replaceGTE0 = (comp, options) => {
      debug("replaceGTE0", comp, options);
      return comp.trim().replace(re2[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
    };
    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
      if (isX(fM)) {
        from = "";
      } else if (isX(fm)) {
        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
      } else if (isX(fp)) {
        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
      } else if (fpr) {
        from = `>=${from}`;
      } else {
        from = `>=${from}${incPr ? "-0" : ""}`;
      }
      if (isX(tM)) {
        to = "";
      } else if (isX(tm)) {
        to = `<${+tM + 1}.0.0-0`;
      } else if (isX(tp)) {
        to = `<${tM}.${+tm + 1}.0-0`;
      } else if (tpr) {
        to = `<=${tM}.${tm}.${tp}-${tpr}`;
      } else if (incPr) {
        to = `<${tM}.${tm}.${+tp + 1}-0`;
      } else {
        to = `<=${to}`;
      }
      return `${from} ${to}`.trim();
    };
    var testSet = (set3, version3, options) => {
      for (let i = 0; i < set3.length; i++) {
        if (!set3[i].test(version3)) {
          return false;
        }
      }
      if (version3.prerelease.length && !options.includePrerelease) {
        for (let i = 0; i < set3.length; i++) {
          debug(set3[i].semver);
          if (set3[i].semver === Comparator.ANY) {
            continue;
          }
          if (set3[i].semver.prerelease.length > 0) {
            const allowed = set3[i].semver;
            if (allowed.major === version3.major && allowed.minor === version3.minor && allowed.patch === version3.patch) {
              return true;
            }
          }
        }
        return false;
      }
      return true;
    };
  }
});

// node_modules/semver/classes/comparator.js
var require_comparator = __commonJS({
  "node_modules/semver/classes/comparator.js"(exports2, module2) {
    "use strict";
    var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
    var Comparator = class _Comparator {
      static get ANY() {
        return ANY;
      }
      constructor(comp, options) {
        options = parseOptions(options);
        if (comp instanceof _Comparator) {
          if (comp.loose === !!options.loose) {
            return comp;
          } else {
            comp = comp.value;
          }
        }
        comp = comp.trim().split(/\s+/).join(" ");
        debug("comparator", comp, options);
        this.options = options;
        this.loose = !!options.loose;
        this.parse(comp);
        if (this.semver === ANY) {
          this.value = "";
        } else {
          this.value = this.operator + this.semver.version;
        }
        debug("comp", this);
      }
      parse(comp) {
        const r = this.options.loose ? re2[t.COMPARATORLOOSE] : re2[t.COMPARATOR];
        const m = comp.match(r);
        if (!m) {
          throw new TypeError(`Invalid comparator: ${comp}`);
        }
        this.operator = m[1] !== void 0 ? m[1] : "";
        if (this.operator === "=") {
          this.operator = "";
        }
        if (!m[2]) {
          this.semver = ANY;
        } else {
          this.semver = new SemVer(m[2], this.options.loose);
        }
      }
      toString() {
        return this.value;
      }
      test(version3) {
        debug("Comparator.test", version3, this.options.loose);
        if (this.semver === ANY || version3 === ANY) {
          return true;
        }
        if (typeof version3 === "string") {
          try {
            version3 = new SemVer(version3, this.options);
          } catch (er) {
            return false;
          }
        }
        return cmp(version3, this.operator, this.semver, this.options);
      }
      intersects(comp, options) {
        if (!(comp instanceof _Comparator)) {
          throw new TypeError("a Comparator is required");
        }
        if (this.operator === "") {
          if (this.value === "") {
            return true;
          }
          return new Range(comp.value, options).test(this.value);
        } else if (comp.operator === "") {
          if (comp.value === "") {
            return true;
          }
          return new Range(this.value, options).test(comp.semver);
        }
        options = parseOptions(options);
        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
          return false;
        }
        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
          return false;
        }
        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
          return true;
        }
        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
          return true;
        }
        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
          return true;
        }
        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
          return true;
        }
        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
          return true;
        }
        return false;
      }
    };
    module2.exports = Comparator;
    var parseOptions = require_parse_options();
    var { safeRe: re2, t } = require_re();
    var cmp = require_cmp();
    var debug = require_debug3();
    var SemVer = require_semver();
    var Range = require_range2();
  }
});

// node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS({
  "node_modules/semver/functions/satisfies.js"(exports2, module2) {
    "use strict";
    var Range = require_range2();
    var satisfies = (version3, range, options) => {
      try {
        range = new Range(range, options);
      } catch (er) {
        return false;
      }
      return range.test(version3);
    };
    module2.exports = satisfies;
  }
});

// node_modules/semver/ranges/to-comparators.js
var require_to_comparators = __commonJS({
  "node_modules/semver/ranges/to-comparators.js"(exports2, module2) {
    "use strict";
    var Range = require_range2();
    var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
    module2.exports = toComparators;
  }
});

// node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = __commonJS({
  "node_modules/semver/ranges/max-satisfying.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var Range = require_range2();
    var maxSatisfying = (versions, range, options) => {
      let max = null;
      let maxSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range(range, options);
      } catch (er) {
        return null;
      }
      versions.forEach((v) => {
        if (rangeObj.test(v)) {
          if (!max || maxSV.compare(v) === -1) {
            max = v;
            maxSV = new SemVer(max, options);
          }
        }
      });
      return max;
    };
    module2.exports = maxSatisfying;
  }
});

// node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = __commonJS({
  "node_modules/semver/ranges/min-satisfying.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var Range = require_range2();
    var minSatisfying = (versions, range, options) => {
      let min = null;
      let minSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range(range, options);
      } catch (er) {
        return null;
      }
      versions.forEach((v) => {
        if (rangeObj.test(v)) {
          if (!min || minSV.compare(v) === 1) {
            min = v;
            minSV = new SemVer(min, options);
          }
        }
      });
      return min;
    };
    module2.exports = minSatisfying;
  }
});

// node_modules/semver/ranges/min-version.js
var require_min_version = __commonJS({
  "node_modules/semver/ranges/min-version.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var Range = require_range2();
    var gt = require_gt();
    var minVersion = (range, loose) => {
      range = new Range(range, loose);
      let minver = new SemVer("0.0.0");
      if (range.test(minver)) {
        return minver;
      }
      minver = new SemVer("0.0.0-0");
      if (range.test(minver)) {
        return minver;
      }
      minver = null;
      for (let i = 0; i < range.set.length; ++i) {
        const comparators = range.set[i];
        let setMin = null;
        comparators.forEach((comparator) => {
          const compver = new SemVer(comparator.semver.version);
          switch (comparator.operator) {
            case ">":
              if (compver.prerelease.length === 0) {
                compver.patch++;
              } else {
                compver.prerelease.push(0);
              }
              compver.raw = compver.format();
            /* fallthrough */
            case "":
            case ">=":
              if (!setMin || gt(compver, setMin)) {
                setMin = compver;
              }
              break;
            case "<":
            case "<=":
              break;
            /* istanbul ignore next */
            default:
              throw new Error(`Unexpected operation: ${comparator.operator}`);
          }
        });
        if (setMin && (!minver || gt(minver, setMin))) {
          minver = setMin;
        }
      }
      if (minver && range.test(minver)) {
        return minver;
      }
      return null;
    };
    module2.exports = minVersion;
  }
});

// node_modules/semver/ranges/valid.js
var require_valid2 = __commonJS({
  "node_modules/semver/ranges/valid.js"(exports2, module2) {
    "use strict";
    var Range = require_range2();
    var validRange = (range, options) => {
      try {
        return new Range(range, options).range || "*";
      } catch (er) {
        return null;
      }
    };
    module2.exports = validRange;
  }
});

// node_modules/semver/ranges/outside.js
var require_outside = __commonJS({
  "node_modules/semver/ranges/outside.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var Comparator = require_comparator();
    var { ANY } = Comparator;
    var Range = require_range2();
    var satisfies = require_satisfies();
    var gt = require_gt();
    var lt = require_lt2();
    var lte = require_lte();
    var gte = require_gte();
    var outside = (version3, range, hilo, options) => {
      version3 = new SemVer(version3, options);
      range = new Range(range, options);
      let gtfn, ltefn, ltfn, comp, ecomp;
      switch (hilo) {
        case ">":
          gtfn = gt;
          ltefn = lte;
          ltfn = lt;
          comp = ">";
          ecomp = ">=";
          break;
        case "<":
          gtfn = lt;
          ltefn = gte;
          ltfn = gt;
          comp = "<";
          ecomp = "<=";
          break;
        default:
          throw new TypeError('Must provide a hilo val of "<" or ">"');
      }
      if (satisfies(version3, range, options)) {
        return false;
      }
      for (let i = 0; i < range.set.length; ++i) {
        const comparators = range.set[i];
        let high = null;
        let low = null;
        comparators.forEach((comparator) => {
          if (comparator.semver === ANY) {
            comparator = new Comparator(">=0.0.0");
          }
          high = high || comparator;
          low = low || comparator;
          if (gtfn(comparator.semver, high.semver, options)) {
            high = comparator;
          } else if (ltfn(comparator.semver, low.semver, options)) {
            low = comparator;
          }
        });
        if (high.operator === comp || high.operator === ecomp) {
          return false;
        }
        if ((!low.operator || low.operator === comp) && ltefn(version3, low.semver)) {
          return false;
        } else if (low.operator === ecomp && ltfn(version3, low.semver)) {
          return false;
        }
      }
      return true;
    };
    module2.exports = outside;
  }
});

// node_modules/semver/ranges/gtr.js
var require_gtr = __commonJS({
  "node_modules/semver/ranges/gtr.js"(exports2, module2) {
    "use strict";
    var outside = require_outside();
    var gtr = (version3, range, options) => outside(version3, range, ">", options);
    module2.exports = gtr;
  }
});

// node_modules/semver/ranges/ltr.js
var require_ltr = __commonJS({
  "node_modules/semver/ranges/ltr.js"(exports2, module2) {
    "use strict";
    var outside = require_outside();
    var ltr = (version3, range, options) => outside(version3, range, "<", options);
    module2.exports = ltr;
  }
});

// node_modules/semver/ranges/intersects.js
var require_intersects = __commonJS({
  "node_modules/semver/ranges/intersects.js"(exports2, module2) {
    "use strict";
    var Range = require_range2();
    var intersects = (r1, r2, options) => {
      r1 = new Range(r1, options);
      r2 = new Range(r2, options);
      return r1.intersects(r2, options);
    };
    module2.exports = intersects;
  }
});

// node_modules/semver/ranges/simplify.js
var require_simplify = __commonJS({
  "node_modules/semver/ranges/simplify.js"(exports2, module2) {
    "use strict";
    var satisfies = require_satisfies();
    var compare = require_compare();
    module2.exports = (versions, range, options) => {
      const set3 = [];
      let first = null;
      let prev = null;
      const v = versions.sort((a, b) => compare(a, b, options));
      for (const version3 of v) {
        const included = satisfies(version3, range, options);
        if (included) {
          prev = version3;
          if (!first) {
            first = version3;
          }
        } else {
          if (prev) {
            set3.push([first, prev]);
          }
          prev = null;
          first = null;
        }
      }
      if (first) {
        set3.push([first, null]);
      }
      const ranges = [];
      for (const [min, max] of set3) {
        if (min === max) {
          ranges.push(min);
        } else if (!max && min === v[0]) {
          ranges.push("*");
        } else if (!max) {
          ranges.push(`>=${min}`);
        } else if (min === v[0]) {
          ranges.push(`<=${max}`);
        } else {
          ranges.push(`${min} - ${max}`);
        }
      }
      const simplified = ranges.join(" || ");
      const original = typeof range.raw === "string" ? range.raw : String(range);
      return simplified.length < original.length ? simplified : range;
    };
  }
});

// node_modules/semver/ranges/subset.js
var require_subset = __commonJS({
  "node_modules/semver/ranges/subset.js"(exports2, module2) {
    "use strict";
    var Range = require_range2();
    var Comparator = require_comparator();
    var { ANY } = Comparator;
    var satisfies = require_satisfies();
    var compare = require_compare();
    var subset = (sub, dom, options = {}) => {
      if (sub === dom) {
        return true;
      }
      sub = new Range(sub, options);
      dom = new Range(dom, options);
      let sawNonNull = false;
      OUTER: for (const simpleSub of sub.set) {
        for (const simpleDom of dom.set) {
          const isSub = simpleSubset(simpleSub, simpleDom, options);
          sawNonNull = sawNonNull || isSub !== null;
          if (isSub) {
            continue OUTER;
          }
        }
        if (sawNonNull) {
          return false;
        }
      }
      return true;
    };
    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
    var minimumVersion = [new Comparator(">=0.0.0")];
    var simpleSubset = (sub, dom, options) => {
      if (sub === dom) {
        return true;
      }
      if (sub.length === 1 && sub[0].semver === ANY) {
        if (dom.length === 1 && dom[0].semver === ANY) {
          return true;
        } else if (options.includePrerelease) {
          sub = minimumVersionWithPreRelease;
        } else {
          sub = minimumVersion;
        }
      }
      if (dom.length === 1 && dom[0].semver === ANY) {
        if (options.includePrerelease) {
          return true;
        } else {
          dom = minimumVersion;
        }
      }
      const eqSet = /* @__PURE__ */ new Set();
      let gt, lt;
      for (const c of sub) {
        if (c.operator === ">" || c.operator === ">=") {
          gt = higherGT(gt, c, options);
        } else if (c.operator === "<" || c.operator === "<=") {
          lt = lowerLT(lt, c, options);
        } else {
          eqSet.add(c.semver);
        }
      }
      if (eqSet.size > 1) {
        return null;
      }
      let gtltComp;
      if (gt && lt) {
        gtltComp = compare(gt.semver, lt.semver, options);
        if (gtltComp > 0) {
          return null;
        } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
          return null;
        }
      }
      for (const eq2 of eqSet) {
        if (gt && !satisfies(eq2, String(gt), options)) {
          return null;
        }
        if (lt && !satisfies(eq2, String(lt), options)) {
          return null;
        }
        for (const c of dom) {
          if (!satisfies(eq2, String(c), options)) {
            return false;
          }
        }
        return true;
      }
      let higher, lower;
      let hasDomLT, hasDomGT;
      let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
      let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
        needDomLTPre = false;
      }
      for (const c of dom) {
        hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
        hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
        if (gt) {
          if (needDomGTPre) {
            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
              needDomGTPre = false;
            }
          }
          if (c.operator === ">" || c.operator === ">=") {
            higher = higherGT(gt, c, options);
            if (higher === c && higher !== gt) {
              return false;
            }
          } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
            return false;
          }
        }
        if (lt) {
          if (needDomLTPre) {
            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
              needDomLTPre = false;
            }
          }
          if (c.operator === "<" || c.operator === "<=") {
            lower = lowerLT(lt, c, options);
            if (lower === c && lower !== lt) {
              return false;
            }
          } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
            return false;
          }
        }
        if (!c.operator && (lt || gt) && gtltComp !== 0) {
          return false;
        }
      }
      if (gt && hasDomLT && !lt && gtltComp !== 0) {
        return false;
      }
      if (lt && hasDomGT && !gt && gtltComp !== 0) {
        return false;
      }
      if (needDomGTPre || needDomLTPre) {
        return false;
      }
      return true;
    };
    var higherGT = (a, b, options) => {
      if (!a) {
        return b;
      }
      const comp = compare(a.semver, b.semver, options);
      return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
    };
    var lowerLT = (a, b, options) => {
      if (!a) {
        return b;
      }
      const comp = compare(a.semver, b.semver, options);
      return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
    };
    module2.exports = subset;
  }
});

// node_modules/semver/index.js
var require_semver2 = __commonJS({
  "node_modules/semver/index.js"(exports2, module2) {
    "use strict";
    var internalRe = require_re();
    var constants = require_constants8();
    var SemVer = require_semver();
    var identifiers = require_identifiers();
    var parse4 = require_parse6();
    var valid = require_valid();
    var clean = require_clean();
    var inc = require_inc();
    var diff = require_diff();
    var major2 = require_major();
    var minor = require_minor();
    var patch = require_patch();
    var prerelease = require_prerelease();
    var compare = require_compare();
    var rcompare = require_rcompare();
    var compareLoose = require_compare_loose();
    var compareBuild = require_compare_build();
    var sort = require_sort();
    var rsort = require_rsort();
    var gt = require_gt();
    var lt = require_lt2();
    var eq2 = require_eq2();
    var neq = require_neq();
    var gte = require_gte();
    var lte = require_lte();
    var cmp = require_cmp();
    var coerce = require_coerce2();
    var Comparator = require_comparator();
    var Range = require_range2();
    var satisfies = require_satisfies();
    var toComparators = require_to_comparators();
    var maxSatisfying = require_max_satisfying();
    var minSatisfying = require_min_satisfying();
    var minVersion = require_min_version();
    var validRange = require_valid2();
    var outside = require_outside();
    var gtr = require_gtr();
    var ltr = require_ltr();
    var intersects = require_intersects();
    var simplifyRange = require_simplify();
    var subset = require_subset();
    module2.exports = {
      parse: parse4,
      valid,
      clean,
      inc,
      diff,
      major: major2,
      minor,
      patch,
      prerelease,
      compare,
      rcompare,
      compareLoose,
      compareBuild,
      sort,
      rsort,
      gt,
      lt,
      eq: eq2,
      neq,
      gte,
      lte,
      cmp,
      coerce,
      Comparator,
      Range,
      satisfies,
      toComparators,
      maxSatisfying,
      minSatisfying,
      minVersion,
      validRange,
      outside,
      gtr,
      ltr,
      intersects,
      simplifyRange,
      subset,
      SemVer,
      re: internalRe.re,
      src: internalRe.src,
      tokens: internalRe.t,
      SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
      RELEASE_TYPES: constants.RELEASE_TYPES,
      compareIdentifiers: identifiers.compareIdentifiers,
      rcompareIdentifiers: identifiers.rcompareIdentifiers
    };
  }
});

// node_modules/jsonwebtoken/lib/asymmetricKeyDetailsSupported.js
var require_asymmetricKeyDetailsSupported = __commonJS({
  "node_modules/jsonwebtoken/lib/asymmetricKeyDetailsSupported.js"(exports2, module2) {
    "use strict";
    var semver = require_semver2();
    module2.exports = semver.satisfies(process.version, ">=15.7.0");
  }
});

// node_modules/jsonwebtoken/lib/rsaPssKeyDetailsSupported.js
var require_rsaPssKeyDetailsSupported = __commonJS({
  "node_modules/jsonwebtoken/lib/rsaPssKeyDetailsSupported.js"(exports2, module2) {
    "use strict";
    var semver = require_semver2();
    module2.exports = semver.satisfies(process.version, ">=16.9.0");
  }
});

// node_modules/jsonwebtoken/lib/validateAsymmetricKey.js
var require_validateAsymmetricKey = __commonJS({
  "node_modules/jsonwebtoken/lib/validateAsymmetricKey.js"(exports2, module2) {
    "use strict";
    var ASYMMETRIC_KEY_DETAILS_SUPPORTED = require_asymmetricKeyDetailsSupported();
    var RSA_PSS_KEY_DETAILS_SUPPORTED = require_rsaPssKeyDetailsSupported();
    var allowedAlgorithmsForKeys = {
      "ec": ["ES256", "ES384", "ES512"],
      "rsa": ["RS256", "PS256", "RS384", "PS384", "RS512", "PS512"],
      "rsa-pss": ["PS256", "PS384", "PS512"]
    };
    var allowedCurves = {
      ES256: "prime256v1",
      ES384: "secp384r1",
      ES512: "secp521r1"
    };
    module2.exports = function(algorithm, key) {
      if (!algorithm || !key) return;
      const keyType = key.asymmetricKeyType;
      if (!keyType) return;
      const allowedAlgorithms = allowedAlgorithmsForKeys[keyType];
      if (!allowedAlgorithms) {
        throw new Error(`Unknown key type "${keyType}".`);
      }
      if (!allowedAlgorithms.includes(algorithm)) {
        throw new Error(`"alg" parameter for "${keyType}" key type must be one of: ${allowedAlgorithms.join(", ")}.`);
      }
      if (ASYMMETRIC_KEY_DETAILS_SUPPORTED) {
        switch (keyType) {
          case "ec":
            const keyCurve = key.asymmetricKeyDetails.namedCurve;
            const allowedCurve = allowedCurves[algorithm];
            if (keyCurve !== allowedCurve) {
              throw new Error(`"alg" parameter "${algorithm}" requires curve "${allowedCurve}".`);
            }
            break;
          case "rsa-pss":
            if (RSA_PSS_KEY_DETAILS_SUPPORTED) {
              const length = parseInt(algorithm.slice(-3), 10);
              const { hashAlgorithm, mgf1HashAlgorithm, saltLength } = key.asymmetricKeyDetails;
              if (hashAlgorithm !== `sha${length}` || mgf1HashAlgorithm !== hashAlgorithm) {
                throw new Error(`Invalid key for this operation, its RSA-PSS parameters do not meet the requirements of "alg" ${algorithm}.`);
              }
              if (saltLength !== void 0 && saltLength > length >> 3) {
                throw new Error(`Invalid key for this operation, its RSA-PSS parameter saltLength does not meet the requirements of "alg" ${algorithm}.`);
              }
            }
            break;
        }
      }
    };
  }
});

// node_modules/jsonwebtoken/lib/psSupported.js
var require_psSupported = __commonJS({
  "node_modules/jsonwebtoken/lib/psSupported.js"(exports2, module2) {
    "use strict";
    var semver = require_semver2();
    module2.exports = semver.satisfies(process.version, "^6.12.0 || >=8.0.0");
  }
});

// node_modules/jsonwebtoken/verify.js
var require_verify = __commonJS({
  "node_modules/jsonwebtoken/verify.js"(exports2, module2) {
    "use strict";
    var JsonWebTokenError = require_JsonWebTokenError();
    var NotBeforeError = require_NotBeforeError();
    var TokenExpiredError = require_TokenExpiredError();
    var decode4 = require_decode();
    var timespan = require_timespan();
    var validateAsymmetricKey = require_validateAsymmetricKey();
    var PS_SUPPORTED = require_psSupported();
    var jws = require_jws();
    var { KeyObject, createSecretKey, createPublicKey } = require("crypto");
    var PUB_KEY_ALGS = ["RS256", "RS384", "RS512"];
    var EC_KEY_ALGS = ["ES256", "ES384", "ES512"];
    var RSA_KEY_ALGS = ["RS256", "RS384", "RS512"];
    var HS_ALGS = ["HS256", "HS384", "HS512"];
    if (PS_SUPPORTED) {
      PUB_KEY_ALGS.splice(PUB_KEY_ALGS.length, 0, "PS256", "PS384", "PS512");
      RSA_KEY_ALGS.splice(RSA_KEY_ALGS.length, 0, "PS256", "PS384", "PS512");
    }
    module2.exports = function(jwtString, secretOrPublicKey, options, callback) {
      if (typeof options === "function" && !callback) {
        callback = options;
        options = {};
      }
      if (!options) {
        options = {};
      }
      options = Object.assign({}, options);
      let done;
      if (callback) {
        done = callback;
      } else {
        done = function(err, data) {
          if (err) throw err;
          return data;
        };
      }
      if (options.clockTimestamp && typeof options.clockTimestamp !== "number") {
        return done(new JsonWebTokenError("clockTimestamp must be a number"));
      }
      if (options.nonce !== void 0 && (typeof options.nonce !== "string" || options.nonce.trim() === "")) {
        return done(new JsonWebTokenError("nonce must be a non-empty string"));
      }
      if (options.allowInvalidAsymmetricKeyTypes !== void 0 && typeof options.allowInvalidAsymmetricKeyTypes !== "boolean") {
        return done(new JsonWebTokenError("allowInvalidAsymmetricKeyTypes must be a boolean"));
      }
      const clockTimestamp = options.clockTimestamp || Math.floor(Date.now() / 1e3);
      if (!jwtString) {
        return done(new JsonWebTokenError("jwt must be provided"));
      }
      if (typeof jwtString !== "string") {
        return done(new JsonWebTokenError("jwt must be a string"));
      }
      const parts = jwtString.split(".");
      if (parts.length !== 3) {
        return done(new JsonWebTokenError("jwt malformed"));
      }
      let decodedToken;
      try {
        decodedToken = decode4(jwtString, { complete: true });
      } catch (err) {
        return done(err);
      }
      if (!decodedToken) {
        return done(new JsonWebTokenError("invalid token"));
      }
      const header = decodedToken.header;
      let getSecret;
      if (typeof secretOrPublicKey === "function") {
        if (!callback) {
          return done(new JsonWebTokenError("verify must be called asynchronous if secret or public key is provided as a callback"));
        }
        getSecret = secretOrPublicKey;
      } else {
        getSecret = function(header2, secretCallback) {
          return secretCallback(null, secretOrPublicKey);
        };
      }
      return getSecret(header, function(err, secretOrPublicKey2) {
        if (err) {
          return done(new JsonWebTokenError("error in secret or public key callback: " + err.message));
        }
        const hasSignature = parts[2].trim() !== "";
        if (!hasSignature && secretOrPublicKey2) {
          return done(new JsonWebTokenError("jwt signature is required"));
        }
        if (hasSignature && !secretOrPublicKey2) {
          return done(new JsonWebTokenError("secret or public key must be provided"));
        }
        if (!hasSignature && !options.algorithms) {
          return done(new JsonWebTokenError('please specify "none" in "algorithms" to verify unsigned tokens'));
        }
        if (secretOrPublicKey2 != null && !(secretOrPublicKey2 instanceof KeyObject)) {
          try {
            secretOrPublicKey2 = createPublicKey(secretOrPublicKey2);
          } catch (_) {
            try {
              secretOrPublicKey2 = createSecretKey(typeof secretOrPublicKey2 === "string" ? Buffer.from(secretOrPublicKey2) : secretOrPublicKey2);
            } catch (_2) {
              return done(new JsonWebTokenError("secretOrPublicKey is not valid key material"));
            }
          }
        }
        if (!options.algorithms) {
          if (secretOrPublicKey2.type === "secret") {
            options.algorithms = HS_ALGS;
          } else if (["rsa", "rsa-pss"].includes(secretOrPublicKey2.asymmetricKeyType)) {
            options.algorithms = RSA_KEY_ALGS;
          } else if (secretOrPublicKey2.asymmetricKeyType === "ec") {
            options.algorithms = EC_KEY_ALGS;
          } else {
            options.algorithms = PUB_KEY_ALGS;
          }
        }
        if (options.algorithms.indexOf(decodedToken.header.alg) === -1) {
          return done(new JsonWebTokenError("invalid algorithm"));
        }
        if (header.alg.startsWith("HS") && secretOrPublicKey2.type !== "secret") {
          return done(new JsonWebTokenError(`secretOrPublicKey must be a symmetric key when using ${header.alg}`));
        } else if (/^(?:RS|PS|ES)/.test(header.alg) && secretOrPublicKey2.type !== "public") {
          return done(new JsonWebTokenError(`secretOrPublicKey must be an asymmetric key when using ${header.alg}`));
        }
        if (!options.allowInvalidAsymmetricKeyTypes) {
          try {
            validateAsymmetricKey(header.alg, secretOrPublicKey2);
          } catch (e) {
            return done(e);
          }
        }
        let valid;
        try {
          valid = jws.verify(jwtString, decodedToken.header.alg, secretOrPublicKey2);
        } catch (e) {
          return done(e);
        }
        if (!valid) {
          return done(new JsonWebTokenError("invalid signature"));
        }
        const payload = decodedToken.payload;
        if (typeof payload.nbf !== "undefined" && !options.ignoreNotBefore) {
          if (typeof payload.nbf !== "number") {
            return done(new JsonWebTokenError("invalid nbf value"));
          }
          if (payload.nbf > clockTimestamp + (options.clockTolerance || 0)) {
            return done(new NotBeforeError("jwt not active", new Date(payload.nbf * 1e3)));
          }
        }
        if (typeof payload.exp !== "undefined" && !options.ignoreExpiration) {
          if (typeof payload.exp !== "number") {
            return done(new JsonWebTokenError("invalid exp value"));
          }
          if (clockTimestamp >= payload.exp + (options.clockTolerance || 0)) {
            return done(new TokenExpiredError("jwt expired", new Date(payload.exp * 1e3)));
          }
        }
        if (options.audience) {
          const audiences = Array.isArray(options.audience) ? options.audience : [options.audience];
          const target = Array.isArray(payload.aud) ? payload.aud : [payload.aud];
          const match = target.some(function(targetAudience) {
            return audiences.some(function(audience) {
              return audience instanceof RegExp ? audience.test(targetAudience) : audience === targetAudience;
            });
          });
          if (!match) {
            return done(new JsonWebTokenError("jwt audience invalid. expected: " + audiences.join(" or ")));
          }
        }
        if (options.issuer) {
          const invalid_issuer = typeof options.issuer === "string" && payload.iss !== options.issuer || Array.isArray(options.issuer) && options.issuer.indexOf(payload.iss) === -1;
          if (invalid_issuer) {
            return done(new JsonWebTokenError("jwt issuer invalid. expected: " + options.issuer));
          }
        }
        if (options.subject) {
          if (payload.sub !== options.subject) {
            return done(new JsonWebTokenError("jwt subject invalid. expected: " + options.subject));
          }
        }
        if (options.jwtid) {
          if (payload.jti !== options.jwtid) {
            return done(new JsonWebTokenError("jwt jwtid invalid. expected: " + options.jwtid));
          }
        }
        if (options.nonce) {
          if (payload.nonce !== options.nonce) {
            return done(new JsonWebTokenError("jwt nonce invalid. expected: " + options.nonce));
          }
        }
        if (options.maxAge) {
          if (typeof payload.iat !== "number") {
            return done(new JsonWebTokenError("iat required when maxAge is specified"));
          }
          const maxAgeTimestamp = timespan(options.maxAge, payload.iat);
          if (typeof maxAgeTimestamp === "undefined") {
            return done(new JsonWebTokenError('"maxAge" should be a number of seconds or string representing a timespan eg: "1d", "20h", 60'));
          }
          if (clockTimestamp >= maxAgeTimestamp + (options.clockTolerance || 0)) {
            return done(new TokenExpiredError("maxAge exceeded", new Date(maxAgeTimestamp * 1e3)));
          }
        }
        if (options.complete === true) {
          const signature = decodedToken.signature;
          return done(null, {
            header,
            payload,
            signature
          });
        }
        return done(null, payload);
      });
    };
  }
});

// node_modules/lodash.includes/index.js
var require_lodash = __commonJS({
  "node_modules/lodash.includes/index.js"(exports2, module2) {
    "use strict";
    var INFINITY4 = 1 / 0;
    var MAX_SAFE_INTEGER3 = 9007199254740991;
    var MAX_INTEGER = 17976931348623157e292;
    var NAN = 0 / 0;
    var argsTag4 = "[object Arguments]";
    var funcTag3 = "[object Function]";
    var genTag2 = "[object GeneratorFunction]";
    var stringTag3 = "[object String]";
    var symbolTag3 = "[object Symbol]";
    var reTrim = /^\s+|\s+$/g;
    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
    var reIsBinary = /^0b[01]+$/i;
    var reIsOctal = /^0o[0-7]+$/i;
    var reIsUint2 = /^(?:0|[1-9]\d*)$/;
    var freeParseInt = parseInt;
    function arrayMap2(array4, iteratee) {
      var index = -1, length = array4 ? array4.length : 0, result = Array(length);
      while (++index < length) {
        result[index] = iteratee(array4[index], index, array4);
      }
      return result;
    }
    function baseFindIndex2(array4, predicate, fromIndex, fromRight) {
      var length = array4.length, index = fromIndex + (fromRight ? 1 : -1);
      while (fromRight ? index-- : ++index < length) {
        if (predicate(array4[index], index, array4)) {
          return index;
        }
      }
      return -1;
    }
    function baseIndexOf2(array4, value, fromIndex) {
      if (value !== value) {
        return baseFindIndex2(array4, baseIsNaN2, fromIndex);
      }
      var index = fromIndex - 1, length = array4.length;
      while (++index < length) {
        if (array4[index] === value) {
          return index;
        }
      }
      return -1;
    }
    function baseIsNaN2(value) {
      return value !== value;
    }
    function baseTimes2(n, iteratee) {
      var index = -1, result = Array(n);
      while (++index < n) {
        result[index] = iteratee(index);
      }
      return result;
    }
    function baseValues(object4, props) {
      return arrayMap2(props, function(key) {
        return object4[key];
      });
    }
    function overArg2(func, transform8) {
      return function(arg) {
        return func(transform8(arg));
      };
    }
    var objectProto13 = Object.prototype;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    var objectToString2 = objectProto13.toString;
    var propertyIsEnumerable3 = objectProto13.propertyIsEnumerable;
    var nativeKeys2 = overArg2(Object.keys, Object);
    var nativeMax = Math.max;
    function arrayLikeKeys2(value, inherited) {
      var result = isArray3(value) || isArguments2(value) ? baseTimes2(value.length, String) : [];
      var length = result.length, skipIndexes = !!length;
      for (var key in value) {
        if ((inherited || hasOwnProperty11.call(value, key)) && !(skipIndexes && (key == "length" || isIndex2(key, length)))) {
          result.push(key);
        }
      }
      return result;
    }
    function baseKeys2(object4) {
      if (!isPrototype2(object4)) {
        return nativeKeys2(object4);
      }
      var result = [];
      for (var key in Object(object4)) {
        if (hasOwnProperty11.call(object4, key) && key != "constructor") {
          result.push(key);
        }
      }
      return result;
    }
    function isIndex2(value, length) {
      length = length == null ? MAX_SAFE_INTEGER3 : length;
      return !!length && (typeof value == "number" || reIsUint2.test(value)) && (value > -1 && value % 1 == 0 && value < length);
    }
    function isPrototype2(value) {
      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto13;
      return value === proto;
    }
    function includes(collection, value, fromIndex, guard) {
      collection = isArrayLike2(collection) ? collection : values(collection);
      fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
      var length = collection.length;
      if (fromIndex < 0) {
        fromIndex = nativeMax(length + fromIndex, 0);
      }
      return isString2(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf2(collection, value, fromIndex) > -1;
    }
    function isArguments2(value) {
      return isArrayLikeObject(value) && hasOwnProperty11.call(value, "callee") && (!propertyIsEnumerable3.call(value, "callee") || objectToString2.call(value) == argsTag4);
    }
    var isArray3 = Array.isArray;
    function isArrayLike2(value) {
      return value != null && isLength2(value.length) && !isFunction4(value);
    }
    function isArrayLikeObject(value) {
      return isObjectLike2(value) && isArrayLike2(value);
    }
    function isFunction4(value) {
      var tag = isObject5(value) ? objectToString2.call(value) : "";
      return tag == funcTag3 || tag == genTag2;
    }
    function isLength2(value) {
      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER3;
    }
    function isObject5(value) {
      var type = typeof value;
      return !!value && (type == "object" || type == "function");
    }
    function isObjectLike2(value) {
      return !!value && typeof value == "object";
    }
    function isString2(value) {
      return typeof value == "string" || !isArray3(value) && isObjectLike2(value) && objectToString2.call(value) == stringTag3;
    }
    function isSymbol2(value) {
      return typeof value == "symbol" || isObjectLike2(value) && objectToString2.call(value) == symbolTag3;
    }
    function toFinite(value) {
      if (!value) {
        return value === 0 ? value : 0;
      }
      value = toNumber2(value);
      if (value === INFINITY4 || value === -INFINITY4) {
        var sign = value < 0 ? -1 : 1;
        return sign * MAX_INTEGER;
      }
      return value === value ? value : 0;
    }
    function toInteger(value) {
      var result = toFinite(value), remainder = result % 1;
      return result === result ? remainder ? result - remainder : result : 0;
    }
    function toNumber2(value) {
      if (typeof value == "number") {
        return value;
      }
      if (isSymbol2(value)) {
        return NAN;
      }
      if (isObject5(value)) {
        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
        value = isObject5(other) ? other + "" : other;
      }
      if (typeof value != "string") {
        return value === 0 ? value : +value;
      }
      value = value.replace(reTrim, "");
      var isBinary = reIsBinary.test(value);
      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
    }
    function keys2(object4) {
      return isArrayLike2(object4) ? arrayLikeKeys2(object4) : baseKeys2(object4);
    }
    function values(object4) {
      return object4 ? baseValues(object4, keys2(object4)) : [];
    }
    module2.exports = includes;
  }
});

// node_modules/lodash.isboolean/index.js
var require_lodash2 = __commonJS({
  "node_modules/lodash.isboolean/index.js"(exports2, module2) {
    "use strict";
    var boolTag3 = "[object Boolean]";
    var objectProto13 = Object.prototype;
    var objectToString2 = objectProto13.toString;
    function isBoolean2(value) {
      return value === true || value === false || isObjectLike2(value) && objectToString2.call(value) == boolTag3;
    }
    function isObjectLike2(value) {
      return !!value && typeof value == "object";
    }
    module2.exports = isBoolean2;
  }
});

// node_modules/lodash.isinteger/index.js
var require_lodash3 = __commonJS({
  "node_modules/lodash.isinteger/index.js"(exports2, module2) {
    "use strict";
    var INFINITY4 = 1 / 0;
    var MAX_INTEGER = 17976931348623157e292;
    var NAN = 0 / 0;
    var symbolTag3 = "[object Symbol]";
    var reTrim = /^\s+|\s+$/g;
    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
    var reIsBinary = /^0b[01]+$/i;
    var reIsOctal = /^0o[0-7]+$/i;
    var freeParseInt = parseInt;
    var objectProto13 = Object.prototype;
    var objectToString2 = objectProto13.toString;
    function isInteger(value) {
      return typeof value == "number" && value == toInteger(value);
    }
    function isObject5(value) {
      var type = typeof value;
      return !!value && (type == "object" || type == "function");
    }
    function isObjectLike2(value) {
      return !!value && typeof value == "object";
    }
    function isSymbol2(value) {
      return typeof value == "symbol" || isObjectLike2(value) && objectToString2.call(value) == symbolTag3;
    }
    function toFinite(value) {
      if (!value) {
        return value === 0 ? value : 0;
      }
      value = toNumber2(value);
      if (value === INFINITY4 || value === -INFINITY4) {
        var sign = value < 0 ? -1 : 1;
        return sign * MAX_INTEGER;
      }
      return value === value ? value : 0;
    }
    function toInteger(value) {
      var result = toFinite(value), remainder = result % 1;
      return result === result ? remainder ? result - remainder : result : 0;
    }
    function toNumber2(value) {
      if (typeof value == "number") {
        return value;
      }
      if (isSymbol2(value)) {
        return NAN;
      }
      if (isObject5(value)) {
        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
        value = isObject5(other) ? other + "" : other;
      }
      if (typeof value != "string") {
        return value === 0 ? value : +value;
      }
      value = value.replace(reTrim, "");
      var isBinary = reIsBinary.test(value);
      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
    }
    module2.exports = isInteger;
  }
});

// node_modules/lodash.isnumber/index.js
var require_lodash4 = __commonJS({
  "node_modules/lodash.isnumber/index.js"(exports2, module2) {
    "use strict";
    var numberTag3 = "[object Number]";
    var objectProto13 = Object.prototype;
    var objectToString2 = objectProto13.toString;
    function isObjectLike2(value) {
      return !!value && typeof value == "object";
    }
    function isNumber2(value) {
      return typeof value == "number" || isObjectLike2(value) && objectToString2.call(value) == numberTag3;
    }
    module2.exports = isNumber2;
  }
});

// node_modules/lodash.isplainobject/index.js
var require_lodash5 = __commonJS({
  "node_modules/lodash.isplainobject/index.js"(exports2, module2) {
    "use strict";
    var objectTag4 = "[object Object]";
    function isHostObject(value) {
      var result = false;
      if (value != null && typeof value.toString != "function") {
        try {
          result = !!(value + "");
        } catch (e) {
        }
      }
      return result;
    }
    function overArg2(func, transform8) {
      return function(arg) {
        return func(transform8(arg));
      };
    }
    var funcProto3 = Function.prototype;
    var objectProto13 = Object.prototype;
    var funcToString3 = funcProto3.toString;
    var hasOwnProperty11 = objectProto13.hasOwnProperty;
    var objectCtorString = funcToString3.call(Object);
    var objectToString2 = objectProto13.toString;
    var getPrototype = overArg2(Object.getPrototypeOf, Object);
    function isObjectLike2(value) {
      return !!value && typeof value == "object";
    }
    function isPlainObject4(value) {
      if (!isObjectLike2(value) || objectToString2.call(value) != objectTag4 || isHostObject(value)) {
        return false;
      }
      var proto = getPrototype(value);
      if (proto === null) {
        return true;
      }
      var Ctor = hasOwnProperty11.call(proto, "constructor") && proto.constructor;
      return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString3.call(Ctor) == objectCtorString;
    }
    module2.exports = isPlainObject4;
  }
});

// node_modules/lodash.isstring/index.js
var require_lodash6 = __commonJS({
  "node_modules/lodash.isstring/index.js"(exports2, module2) {
    "use strict";
    var stringTag3 = "[object String]";
    var objectProto13 = Object.prototype;
    var objectToString2 = objectProto13.toString;
    var isArray3 = Array.isArray;
    function isObjectLike2(value) {
      return !!value && typeof value == "object";
    }
    function isString2(value) {
      return typeof value == "string" || !isArray3(value) && isObjectLike2(value) && objectToString2.call(value) == stringTag3;
    }
    module2.exports = isString2;
  }
});

// node_modules/lodash.once/index.js
var require_lodash7 = __commonJS({
  "node_modules/lodash.once/index.js"(exports2, module2) {
    "use strict";
    var FUNC_ERROR_TEXT2 = "Expected a function";
    var INFINITY4 = 1 / 0;
    var MAX_INTEGER = 17976931348623157e292;
    var NAN = 0 / 0;
    var symbolTag3 = "[object Symbol]";
    var reTrim = /^\s+|\s+$/g;
    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
    var reIsBinary = /^0b[01]+$/i;
    var reIsOctal = /^0o[0-7]+$/i;
    var freeParseInt = parseInt;
    var objectProto13 = Object.prototype;
    var objectToString2 = objectProto13.toString;
    function before(n, func) {
      var result;
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT2);
      }
      n = toInteger(n);
      return function() {
        if (--n > 0) {
          result = func.apply(this, arguments);
        }
        if (n <= 1) {
          func = void 0;
        }
        return result;
      };
    }
    function once(func) {
      return before(2, func);
    }
    function isObject5(value) {
      var type = typeof value;
      return !!value && (type == "object" || type == "function");
    }
    function isObjectLike2(value) {
      return !!value && typeof value == "object";
    }
    function isSymbol2(value) {
      return typeof value == "symbol" || isObjectLike2(value) && objectToString2.call(value) == symbolTag3;
    }
    function toFinite(value) {
      if (!value) {
        return value === 0 ? value : 0;
      }
      value = toNumber2(value);
      if (value === INFINITY4 || value === -INFINITY4) {
        var sign = value < 0 ? -1 : 1;
        return sign * MAX_INTEGER;
      }
      return value === value ? value : 0;
    }
    function toInteger(value) {
      var result = toFinite(value), remainder = result % 1;
      return result === result ? remainder ? result - remainder : result : 0;
    }
    function toNumber2(value) {
      if (typeof value == "number") {
        return value;
      }
      if (isSymbol2(value)) {
        return NAN;
      }
      if (isObject5(value)) {
        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
        value = isObject5(other) ? other + "" : other;
      }
      if (typeof value != "string") {
        return value === 0 ? value : +value;
      }
      value = value.replace(reTrim, "");
      var isBinary = reIsBinary.test(value);
      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
    }
    module2.exports = once;
  }
});

// node_modules/jsonwebtoken/sign.js
var require_sign2 = __commonJS({
  "node_modules/jsonwebtoken/sign.js"(exports2, module2) {
    "use strict";
    var timespan = require_timespan();
    var PS_SUPPORTED = require_psSupported();
    var validateAsymmetricKey = require_validateAsymmetricKey();
    var jws = require_jws();
    var includes = require_lodash();
    var isBoolean2 = require_lodash2();
    var isInteger = require_lodash3();
    var isNumber2 = require_lodash4();
    var isPlainObject4 = require_lodash5();
    var isString2 = require_lodash6();
    var once = require_lodash7();
    var { KeyObject, createSecretKey, createPrivateKey } = require("crypto");
    var SUPPORTED_ALGS = ["RS256", "RS384", "RS512", "ES256", "ES384", "ES512", "HS256", "HS384", "HS512", "none"];
    if (PS_SUPPORTED) {
      SUPPORTED_ALGS.splice(3, 0, "PS256", "PS384", "PS512");
    }
    var sign_options_schema = {
      expiresIn: { isValid: function(value) {
        return isInteger(value) || isString2(value) && value;
      }, message: '"expiresIn" should be a number of seconds or string representing a timespan' },
      notBefore: { isValid: function(value) {
        return isInteger(value) || isString2(value) && value;
      }, message: '"notBefore" should be a number of seconds or string representing a timespan' },
      audience: { isValid: function(value) {
        return isString2(value) || Array.isArray(value);
      }, message: '"audience" must be a string or array' },
      algorithm: { isValid: includes.bind(null, SUPPORTED_ALGS), message: '"algorithm" must be a valid string enum value' },
      header: { isValid: isPlainObject4, message: '"header" must be an object' },
      encoding: { isValid: isString2, message: '"encoding" must be a string' },
      issuer: { isValid: isString2, message: '"issuer" must be a string' },
      subject: { isValid: isString2, message: '"subject" must be a string' },
      jwtid: { isValid: isString2, message: '"jwtid" must be a string' },
      noTimestamp: { isValid: isBoolean2, message: '"noTimestamp" must be a boolean' },
      keyid: { isValid: isString2, message: '"keyid" must be a string' },
      mutatePayload: { isValid: isBoolean2, message: '"mutatePayload" must be a boolean' },
      allowInsecureKeySizes: { isValid: isBoolean2, message: '"allowInsecureKeySizes" must be a boolean' },
      allowInvalidAsymmetricKeyTypes: { isValid: isBoolean2, message: '"allowInvalidAsymmetricKeyTypes" must be a boolean' }
    };
    var registered_claims_schema = {
      iat: { isValid: isNumber2, message: '"iat" should be a number of seconds' },
      exp: { isValid: isNumber2, message: '"exp" should be a number of seconds' },
      nbf: { isValid: isNumber2, message: '"nbf" should be a number of seconds' }
    };
    function validate(schema, allowUnknown, object4, parameterName) {
      if (!isPlainObject4(object4)) {
        throw new Error('Expected "' + parameterName + '" to be a plain object.');
      }
      Object.keys(object4).forEach(function(key) {
        const validator2 = schema[key];
        if (!validator2) {
          if (!allowUnknown) {
            throw new Error('"' + key + '" is not allowed in "' + parameterName + '"');
          }
          return;
        }
        if (!validator2.isValid(object4[key])) {
          throw new Error(validator2.message);
        }
      });
    }
    function validateOptions(options) {
      return validate(sign_options_schema, false, options, "options");
    }
    function validatePayload(payload) {
      return validate(registered_claims_schema, true, payload, "payload");
    }
    var options_to_payload = {
      "audience": "aud",
      "issuer": "iss",
      "subject": "sub",
      "jwtid": "jti"
    };
    var options_for_objects = [
      "expiresIn",
      "notBefore",
      "noTimestamp",
      "audience",
      "issuer",
      "subject",
      "jwtid"
    ];
    module2.exports = function(payload, secretOrPrivateKey, options, callback) {
      if (typeof options === "function") {
        callback = options;
        options = {};
      } else {
        options = options || {};
      }
      const isObjectPayload = typeof payload === "object" && !Buffer.isBuffer(payload);
      const header = Object.assign({
        alg: options.algorithm || "HS256",
        typ: isObjectPayload ? "JWT" : void 0,
        kid: options.keyid
      }, options.header);
      function failure(err) {
        if (callback) {
          return callback(err);
        }
        throw err;
      }
      if (!secretOrPrivateKey && options.algorithm !== "none") {
        return failure(new Error("secretOrPrivateKey must have a value"));
      }
      if (secretOrPrivateKey != null && !(secretOrPrivateKey instanceof KeyObject)) {
        try {
          secretOrPrivateKey = createPrivateKey(secretOrPrivateKey);
        } catch (_) {
          try {
            secretOrPrivateKey = createSecretKey(typeof secretOrPrivateKey === "string" ? Buffer.from(secretOrPrivateKey) : secretOrPrivateKey);
          } catch (_2) {
            return failure(new Error("secretOrPrivateKey is not valid key material"));
          }
        }
      }
      if (header.alg.startsWith("HS") && secretOrPrivateKey.type !== "secret") {
        return failure(new Error(`secretOrPrivateKey must be a symmetric key when using ${header.alg}`));
      } else if (/^(?:RS|PS|ES)/.test(header.alg)) {
        if (secretOrPrivateKey.type !== "private") {
          return failure(new Error(`secretOrPrivateKey must be an asymmetric key when using ${header.alg}`));
        }
        if (!options.allowInsecureKeySizes && !header.alg.startsWith("ES") && secretOrPrivateKey.asymmetricKeyDetails !== void 0 && //KeyObject.asymmetricKeyDetails is supported in Node 15+
        secretOrPrivateKey.asymmetricKeyDetails.modulusLength < 2048) {
          return failure(new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`));
        }
      }
      if (typeof payload === "undefined") {
        return failure(new Error("payload is required"));
      } else if (isObjectPayload) {
        try {
          validatePayload(payload);
        } catch (error73) {
          return failure(error73);
        }
        if (!options.mutatePayload) {
          payload = Object.assign({}, payload);
        }
      } else {
        const invalid_options = options_for_objects.filter(function(opt) {
          return typeof options[opt] !== "undefined";
        });
        if (invalid_options.length > 0) {
          return failure(new Error("invalid " + invalid_options.join(",") + " option for " + typeof payload + " payload"));
        }
      }
      if (typeof payload.exp !== "undefined" && typeof options.expiresIn !== "undefined") {
        return failure(new Error('Bad "options.expiresIn" option the payload already has an "exp" property.'));
      }
      if (typeof payload.nbf !== "undefined" && typeof options.notBefore !== "undefined") {
        return failure(new Error('Bad "options.notBefore" option the payload already has an "nbf" property.'));
      }
      try {
        validateOptions(options);
      } catch (error73) {
        return failure(error73);
      }
      if (!options.allowInvalidAsymmetricKeyTypes) {
        try {
          validateAsymmetricKey(header.alg, secretOrPrivateKey);
        } catch (error73) {
          return failure(error73);
        }
      }
      const timestamp = payload.iat || Math.floor(Date.now() / 1e3);
      if (options.noTimestamp) {
        delete payload.iat;
      } else if (isObjectPayload) {
        payload.iat = timestamp;
      }
      if (typeof options.notBefore !== "undefined") {
        try {
          payload.nbf = timespan(options.notBefore, timestamp);
        } catch (err) {
          return failure(err);
        }
        if (typeof payload.nbf === "undefined") {
          return failure(new Error('"notBefore" should be a number of seconds or string representing a timespan eg: "1d", "20h", 60'));
        }
      }
      if (typeof options.expiresIn !== "undefined" && typeof payload === "object") {
        try {
          payload.exp = timespan(options.expiresIn, timestamp);
        } catch (err) {
          return failure(err);
        }
        if (typeof payload.exp === "undefined") {
          return failure(new Error('"expiresIn" should be a number of seconds or string representing a timespan eg: "1d", "20h", 60'));
        }
      }
      Object.keys(options_to_payload).forEach(function(key) {
        const claim = options_to_payload[key];
        if (typeof options[key] !== "undefined") {
          if (typeof payload[claim] !== "undefined") {
            return failure(new Error('Bad "options.' + key + '" option. The payload already has an "' + claim + '" property.'));
          }
          payload[claim] = options[key];
        }
      });
      const encoding = options.encoding || "utf8";
      if (typeof callback === "function") {
        callback = callback && once(callback);
        jws.createSign({
          header,
          privateKey: secretOrPrivateKey,
          payload,
          encoding
        }).once("error", callback).once("done", function(signature) {
          if (!options.allowInsecureKeySizes && /^(?:RS|PS)/.test(header.alg) && signature.length < 256) {
            return callback(new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`));
          }
          callback(null, signature);
        });
      } else {
        let signature = jws.sign({ header, payload, secret: secretOrPrivateKey, encoding });
        if (!options.allowInsecureKeySizes && /^(?:RS|PS)/.test(header.alg) && signature.length < 256) {
          throw new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`);
        }
        return signature;
      }
    };
  }
});

// node_modules/jsonwebtoken/index.js
var require_jsonwebtoken = __commonJS({
  "node_modules/jsonwebtoken/index.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      decode: require_decode(),
      verify: require_verify(),
      sign: require_sign2(),
      JsonWebTokenError: require_JsonWebTokenError(),
      NotBeforeError: require_NotBeforeError(),
      TokenExpiredError: require_TokenExpiredError()
    };
  }
});

// src/utils/vm.ts
function runCode(code, vendor) {
  code = code.replace(/export\s*\{\s*\};?/g, "");
  const exports2 = {};
  const sandbox = {
    createOpenAI,
    createDeepSeek,
    createZhipu,
    createQwen: import_qwen_ai_provider_v5.createQwen,
    createAnthropic,
    createOpenAICompatible,
    createXai,
    createMinimax: createMinimaxAnthropic,
    createGoogleGenerativeAI,
    zipImage,
    zipImageResolution,
    urlToBase64,
    mergeImages,
    pollTask,
    fetch,
    exports: exports2,
    axios: axios_default,
    FormData: import_form_data2.default,
    logger,
    jsonwebtoken: import_jsonwebtoken.default
  };
  if (vendor !== void 0) {
    sandbox.vendor = vendor;
  }
  const vm = new import_vm2.VM({
    timeout: 0,
    sandbox,
    compiler: "javascript",
    eval: false,
    wasm: false
  });
  vm.run(code);
  return exports2;
}
function logger(logstring) {
  console.log("\u3010VM\u3011" + JSON.stringify(logstring));
}
async function zipImage(completeBase64, size) {
  let quality = 80;
  let buffer = Buffer.from(completeBase64.split(",")[1], "base64");
  let output = await (0, import_sharp2.default)(buffer).jpeg({ quality }).toBuffer();
  while (output.length > size && quality > 10) {
    quality -= 10;
    output = await (0, import_sharp2.default)(buffer).jpeg({ quality }).toBuffer();
  }
  return "data:image/jpeg;base64," + output.toString("base64");
}
async function zipImageResolution(completeBase64, width, height) {
  const buffer = Buffer.from(completeBase64.split(",")[1], "base64");
  const out = await (0, import_sharp2.default)(buffer).resize(width, height).toBuffer();
  return `data:image/jpeg;base64,${out.toString("base64")}`;
}
async function urlToBase64(url4) {
  const res = await axios_default.get(url4, { responseType: "arraybuffer" });
  const mime = res.headers["content-type"] || "image/jpeg";
  const b64 = Buffer.from(res.data).toString("base64");
  return `data:${mime};base64,${b64}`;
}
async function pollTask(fn, interval = 3e3, timeout = 3e6) {
  const start = Date.now();
  while (Date.now() - start < timeout) {
    try {
      const result = await fn();
      if (result.completed) return result;
      if (result?.error) return result;
    } catch (e) {
      return { completed: false, error: utils_default.error(e).message || "poll error" };
    }
    await new Promise((res) => setTimeout(res, interval));
  }
  return { completed: false, error: "timeout" };
}
async function mergeImages(imageBase64List, maxSize = "10mb") {
  if (imageBase64List.length === 0) {
    throw new Error("\u56FE\u7247\u5217\u8868\u4E0D\u80FD\u4E3A\u7A7A");
  }
  const maxBytes = parseSize(maxSize);
  const imageBuffers = imageBase64List.map(base64ToBuffer);
  const imageMetadatas = await Promise.all(imageBuffers.map((buffer) => (0, import_sharp2.default)(buffer).metadata()));
  const maxHeight = Math.max(...imageMetadatas.map((m) => m.height || 0));
  const imageWidths = imageMetadatas.map((metadata) => {
    const aspectRatio = (metadata.width || 1) / (metadata.height || 1);
    return Math.round(maxHeight * aspectRatio);
  });
  const totalWidth = imageWidths.reduce((sum, w) => sum + w, 0);
  const resizedImages = await Promise.all(
    imageBuffers.map(async (buffer, index) => {
      return (0, import_sharp2.default)(buffer).resize(imageWidths[index], maxHeight, { fit: "cover" }).toBuffer();
    })
  );
  let currentX = 0;
  const compositeInputs = resizedImages.map((buffer, index) => {
    const input = { input: buffer, left: currentX, top: 0 };
    currentX += imageWidths[index];
    return input;
  });
  const mergedBuffer = await (0, import_sharp2.default)({
    create: {
      width: totalWidth,
      height: maxHeight,
      channels: 4,
      background: { r: 255, g: 255, b: 255, alpha: 1 }
    }
  }).composite(compositeInputs).jpeg({ quality: 90 }).toBuffer();
  const resultBuffer = await compressToSize(mergedBuffer, maxBytes, totalWidth, maxHeight);
  return resultBuffer.toString("base64");
}
function parseSize(size) {
  const match = size.toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(kb|mb|gb|b)?$/);
  if (!match) {
    throw new Error(`\u65E0\u6548\u7684\u5927\u5C0F\u683C\u5F0F: ${size}`);
  }
  const value = parseFloat(match[1]);
  const unit = match[2] || "b";
  const multipliers = {
    b: 1,
    kb: 1024,
    mb: 1024 * 1024,
    gb: 1024 * 1024 * 1024
  };
  return Math.floor(value * multipliers[unit]);
}
function base64ToBuffer(base644) {
  const base64Data = base644.replace(/^data:image\/\w+;base64,/, "");
  return Buffer.from(base64Data, "base64");
}
async function compressToSize(imageBuffer, maxBytes, originalWidth, originalHeight) {
  let quality = 90;
  let scale = 1;
  while (true) {
    const targetWidth = Math.round(originalWidth * scale);
    const targetHeight = Math.round(originalHeight * scale);
    const resultBuffer = await (0, import_sharp2.default)(imageBuffer).resize(targetWidth, targetHeight, { fit: "fill" }).jpeg({ quality }).toBuffer();
    if (resultBuffer.length <= maxBytes) {
      return resultBuffer;
    }
    if (quality > 10) {
      quality -= 10;
    } else {
      quality = 90;
      scale *= 0.8;
    }
  }
}
var import_vm2, import_sharp2, import_qwen_ai_provider_v5, import_form_data2, import_jsonwebtoken;
var init_vm = __esm({
  "src/utils/vm.ts"() {
    "use strict";
    import_vm2 = require("vm2");
    import_sharp2 = __toESM(require("sharp"));
    init_axios2();
    init_dist6();
    init_dist7();
    init_dist11();
    import_qwen_ai_provider_v5 = __toESM(require_dist9());
    init_dist12();
    init_dist13();
    init_dist14();
    init_dist15();
    init_dist20();
    import_form_data2 = __toESM(require_form_data());
    import_jsonwebtoken = __toESM(require_jsonwebtoken());
    init_utils3();
  }
});

// src/utils/taskRecord.ts
async function taskRecord(projectId, taskClass, modelName, opts = {}) {
  const { content, describe: describe4 = "" } = opts;
  let opteorContent;
  if (content === void 0 || content === null) {
    opteorContent = void 0;
  } else if (typeof content === "string") {
    opteorContent = content;
  } else if (typeof content === "function") {
    throw new Error("\u4E0D\u652F\u6301\u7684\u7C7B\u578B");
  } else {
    try {
      opteorContent = JSON.stringify(content);
    } catch (e) {
      opteorContent = content.toString();
    }
  }
  const [id] = await db_default("o_tasks").insert({
    projectId,
    taskClass,
    relatedObjects: opteorContent,
    model: modelName,
    describe: describe4,
    state: taskStateMap[0],
    startTime: Date.now()
  });
  return async function done(state, reason) {
    await db_default("o_tasks").where("id", id).update({
      state: taskStateMap[state],
      reason: state === -1 ? reason ?? "" : null
    });
  };
}
var taskStateMap;
var init_taskRecord = __esm({
  "src/utils/taskRecord.ts"() {
    "use strict";
    init_db();
    taskStateMap = {
      "0": "\u8FDB\u884C\u4E2D",
      "1": "\u5DF2\u5B8C\u6210",
      "-1": "\u751F\u6210\u5931\u8D25"
    };
  }
});

// node_modules/zod/index.js
var zod_default;
var init_zod = __esm({
  "node_modules/zod/index.js"() {
    "use strict";
    init_external();
    init_external();
    zod_default = external_exports;
  }
});

// node_modules/@vercel/oidc/dist/get-context.js
var require_get_context = __commonJS({
  "node_modules/@vercel/oidc/dist/get-context.js"(exports2, module2) {
    "use strict";
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var get_context_exports = {};
    __export4(get_context_exports, {
      SYMBOL_FOR_REQ_CONTEXT: () => SYMBOL_FOR_REQ_CONTEXT,
      getContext: () => getContext3
    });
    module2.exports = __toCommonJS2(get_context_exports);
    var SYMBOL_FOR_REQ_CONTEXT = /* @__PURE__ */ Symbol.for("@vercel/request-context");
    function getContext3() {
      const fromSymbol = globalThis;
      return fromSymbol[SYMBOL_FOR_REQ_CONTEXT]?.get?.() ?? {};
    }
  }
});

// node_modules/@vercel/oidc/dist/token-error.js
var require_token_error = __commonJS({
  "node_modules/@vercel/oidc/dist/token-error.js"(exports2, module2) {
    "use strict";
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var token_error_exports = {};
    __export4(token_error_exports, {
      VercelOidcTokenError: () => VercelOidcTokenError
    });
    module2.exports = __toCommonJS2(token_error_exports);
    var VercelOidcTokenError = class extends Error {
      constructor(message, cause) {
        super(message);
        this.name = "VercelOidcTokenError";
        this.cause = cause;
      }
      toString() {
        if (this.cause) {
          return `${this.name}: ${this.message}: ${this.cause}`;
        }
        return `${this.name}: ${this.message}`;
      }
    };
  }
});

// node_modules/@vercel/oidc/dist/token-io.js
var require_token_io = __commonJS({
  "node_modules/@vercel/oidc/dist/token-io.js"(exports2, module2) {
    "use strict";
    var __create2 = Object.create;
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
      // If the importer is in node compatibility mode or this is not an ESM
      // file that has been converted to a CommonJS file using a Babel-
      // compatible transform (i.e. "__esModule" has not been set), then set
      // "default" to the CommonJS "module.exports" for node compatibility.
      isNodeMode || !mod || !mod.__esModule ? __defProp4(target, "default", { value: mod, enumerable: true }) : target,
      mod
    ));
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var token_io_exports = {};
    __export4(token_io_exports, {
      findRootDir: () => findRootDir,
      getUserDataDir: () => getUserDataDir
    });
    module2.exports = __toCommonJS2(token_io_exports);
    var import_path30 = __toESM2(require("path"));
    var import_fs19 = __toESM2(require("fs"));
    var import_os = __toESM2(require("os"));
    var import_token_error = require_token_error();
    function findRootDir() {
      try {
        let dir = process.cwd();
        while (dir !== import_path30.default.dirname(dir)) {
          const pkgPath = import_path30.default.join(dir, ".vercel");
          if (import_fs19.default.existsSync(pkgPath)) {
            return dir;
          }
          dir = import_path30.default.dirname(dir);
        }
      } catch (e) {
        throw new import_token_error.VercelOidcTokenError(
          "Token refresh only supported in node server environments"
        );
      }
      return null;
    }
    function getUserDataDir() {
      if (process.env.XDG_DATA_HOME) {
        return process.env.XDG_DATA_HOME;
      }
      switch (import_os.default.platform()) {
        case "darwin":
          return import_path30.default.join(import_os.default.homedir(), "Library/Application Support");
        case "linux":
          return import_path30.default.join(import_os.default.homedir(), ".local/share");
        case "win32":
          if (process.env.LOCALAPPDATA) {
            return process.env.LOCALAPPDATA;
          }
          return null;
        default:
          return null;
      }
    }
  }
});

// node_modules/@vercel/oidc/dist/auth-config.js
var require_auth_config = __commonJS({
  "node_modules/@vercel/oidc/dist/auth-config.js"(exports2, module2) {
    "use strict";
    var __create2 = Object.create;
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
      // If the importer is in node compatibility mode or this is not an ESM
      // file that has been converted to a CommonJS file using a Babel-
      // compatible transform (i.e. "__esModule" has not been set), then set
      // "default" to the CommonJS "module.exports" for node compatibility.
      isNodeMode || !mod || !mod.__esModule ? __defProp4(target, "default", { value: mod, enumerable: true }) : target,
      mod
    ));
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var auth_config_exports = {};
    __export4(auth_config_exports, {
      isValidAccessToken: () => isValidAccessToken,
      readAuthConfig: () => readAuthConfig,
      writeAuthConfig: () => writeAuthConfig
    });
    module2.exports = __toCommonJS2(auth_config_exports);
    var fs34 = __toESM2(require("fs"));
    var path33 = __toESM2(require("path"));
    var import_token_util = require_token_util();
    function getAuthConfigPath() {
      const dataDir = (0, import_token_util.getVercelDataDir)();
      if (!dataDir) {
        throw new Error(
          `Unable to find Vercel CLI data directory. Your platform: ${process.platform}. Supported: darwin, linux, win32.`
        );
      }
      return path33.join(dataDir, "auth.json");
    }
    function readAuthConfig() {
      try {
        const authPath = getAuthConfigPath();
        if (!fs34.existsSync(authPath)) {
          return null;
        }
        const content = fs34.readFileSync(authPath, "utf8");
        if (!content) {
          return null;
        }
        return JSON.parse(content);
      } catch (error73) {
        return null;
      }
    }
    function writeAuthConfig(config3) {
      const authPath = getAuthConfigPath();
      const authDir = path33.dirname(authPath);
      if (!fs34.existsSync(authDir)) {
        fs34.mkdirSync(authDir, { mode: 504, recursive: true });
      }
      fs34.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
    }
    function isValidAccessToken(authConfig) {
      if (!authConfig.token)
        return false;
      if (typeof authConfig.expiresAt !== "number")
        return true;
      const nowInSeconds = Math.floor(Date.now() / 1e3);
      return authConfig.expiresAt >= nowInSeconds;
    }
  }
});

// node_modules/@vercel/oidc/dist/oauth.js
var require_oauth = __commonJS({
  "node_modules/@vercel/oidc/dist/oauth.js"(exports2, module2) {
    "use strict";
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var oauth_exports = {};
    __export4(oauth_exports, {
      processTokenResponse: () => processTokenResponse,
      refreshTokenRequest: () => refreshTokenRequest
    });
    module2.exports = __toCommonJS2(oauth_exports);
    var import_os = require("os");
    var VERCEL_ISSUER = "https://vercel.com";
    var VERCEL_CLI_CLIENT_ID = "cl_HYyOPBNtFMfHhaUn9L4QPfTZz6TP47bp";
    var userAgent = `@vercel/oidc node-${process.version} ${(0, import_os.platform)()} (${(0, import_os.arch)()}) ${(0, import_os.hostname)()}`;
    var _tokenEndpoint = null;
    async function getTokenEndpoint() {
      if (_tokenEndpoint) {
        return _tokenEndpoint;
      }
      const discoveryUrl = `${VERCEL_ISSUER}/.well-known/openid-configuration`;
      const response = await fetch(discoveryUrl, {
        headers: { "user-agent": userAgent }
      });
      if (!response.ok) {
        throw new Error("Failed to discover OAuth endpoints");
      }
      const metadata = await response.json();
      if (!metadata || typeof metadata.token_endpoint !== "string") {
        throw new Error("Invalid OAuth discovery response");
      }
      const endpoint2 = metadata.token_endpoint;
      _tokenEndpoint = endpoint2;
      return endpoint2;
    }
    async function refreshTokenRequest(options) {
      const tokenEndpoint = await getTokenEndpoint();
      return await fetch(tokenEndpoint, {
        method: "POST",
        headers: {
          "Content-Type": "application/x-www-form-urlencoded",
          "user-agent": userAgent
        },
        body: new URLSearchParams({
          client_id: VERCEL_CLI_CLIENT_ID,
          grant_type: "refresh_token",
          ...options
        })
      });
    }
    async function processTokenResponse(response) {
      const json4 = await response.json();
      if (!response.ok) {
        const errorMsg = typeof json4 === "object" && json4 && "error" in json4 ? String(json4.error) : "Token refresh failed";
        return [new Error(errorMsg)];
      }
      if (typeof json4 !== "object" || json4 === null) {
        return [new Error("Invalid token response")];
      }
      if (typeof json4.access_token !== "string") {
        return [new Error("Missing access_token in response")];
      }
      if (json4.token_type !== "Bearer") {
        return [new Error("Invalid token_type in response")];
      }
      if (typeof json4.expires_in !== "number") {
        return [new Error("Missing expires_in in response")];
      }
      return [null, json4];
    }
  }
});

// node_modules/@vercel/oidc/dist/token-util.js
var require_token_util = __commonJS({
  "node_modules/@vercel/oidc/dist/token-util.js"(exports2, module2) {
    "use strict";
    var __create2 = Object.create;
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
      // If the importer is in node compatibility mode or this is not an ESM
      // file that has been converted to a CommonJS file using a Babel-
      // compatible transform (i.e. "__esModule" has not been set), then set
      // "default" to the CommonJS "module.exports" for node compatibility.
      isNodeMode || !mod || !mod.__esModule ? __defProp4(target, "default", { value: mod, enumerable: true }) : target,
      mod
    ));
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var token_util_exports = {};
    __export4(token_util_exports, {
      assertVercelOidcTokenResponse: () => assertVercelOidcTokenResponse,
      findProjectInfo: () => findProjectInfo,
      getTokenPayload: () => getTokenPayload,
      getVercelCliToken: () => getVercelCliToken,
      getVercelDataDir: () => getVercelDataDir,
      getVercelOidcToken: () => getVercelOidcToken3,
      isExpired: () => isExpired,
      loadToken: () => loadToken,
      saveToken: () => saveToken
    });
    module2.exports = __toCommonJS2(token_util_exports);
    var path33 = __toESM2(require("path"));
    var fs34 = __toESM2(require("fs"));
    var import_token_error = require_token_error();
    var import_token_io = require_token_io();
    var import_auth_config = require_auth_config();
    var import_oauth = require_oauth();
    function getVercelDataDir() {
      const vercelFolder = "com.vercel.cli";
      const dataDir = (0, import_token_io.getUserDataDir)();
      if (!dataDir) {
        return null;
      }
      return path33.join(dataDir, vercelFolder);
    }
    async function getVercelCliToken() {
      const authConfig = (0, import_auth_config.readAuthConfig)();
      if (!authConfig) {
        return null;
      }
      if ((0, import_auth_config.isValidAccessToken)(authConfig)) {
        return authConfig.token || null;
      }
      if (!authConfig.refreshToken) {
        (0, import_auth_config.writeAuthConfig)({});
        return null;
      }
      try {
        const tokenResponse = await (0, import_oauth.refreshTokenRequest)({
          refresh_token: authConfig.refreshToken
        });
        const [tokensError, tokens] = await (0, import_oauth.processTokenResponse)(tokenResponse);
        if (tokensError || !tokens) {
          (0, import_auth_config.writeAuthConfig)({});
          return null;
        }
        const updatedConfig = {
          token: tokens.access_token,
          expiresAt: Math.floor(Date.now() / 1e3) + tokens.expires_in
        };
        if (tokens.refresh_token) {
          updatedConfig.refreshToken = tokens.refresh_token;
        }
        (0, import_auth_config.writeAuthConfig)(updatedConfig);
        return updatedConfig.token ?? null;
      } catch (error73) {
        (0, import_auth_config.writeAuthConfig)({});
        return null;
      }
    }
    async function getVercelOidcToken3(authToken, projectId, teamId) {
      const url4 = `https://api.vercel.com/v1/projects/${projectId}/token?source=vercel-oidc-refresh${teamId ? `&teamId=${teamId}` : ""}`;
      const res = await fetch(url4, {
        method: "POST",
        headers: {
          Authorization: `Bearer ${authToken}`
        }
      });
      if (!res.ok) {
        throw new import_token_error.VercelOidcTokenError(
          `Failed to refresh OIDC token: ${res.statusText}`
        );
      }
      const tokenRes = await res.json();
      assertVercelOidcTokenResponse(tokenRes);
      return tokenRes;
    }
    function assertVercelOidcTokenResponse(res) {
      if (!res || typeof res !== "object") {
        throw new TypeError(
          "Vercel OIDC token is malformed. Expected an object. Please run `vc env pull` and try again"
        );
      }
      if (!("token" in res) || typeof res.token !== "string") {
        throw new TypeError(
          "Vercel OIDC token is malformed. Expected a string-valued token property. Please run `vc env pull` and try again"
        );
      }
    }
    function findProjectInfo() {
      const dir = (0, import_token_io.findRootDir)();
      if (!dir) {
        throw new import_token_error.VercelOidcTokenError(
          "Unable to find project root directory. Have you linked your project with `vc link?`"
        );
      }
      const prjPath = path33.join(dir, ".vercel", "project.json");
      if (!fs34.existsSync(prjPath)) {
        throw new import_token_error.VercelOidcTokenError(
          "project.json not found, have you linked your project with `vc link?`"
        );
      }
      const prj = JSON.parse(fs34.readFileSync(prjPath, "utf8"));
      if (typeof prj.projectId !== "string" && typeof prj.orgId !== "string") {
        throw new TypeError(
          "Expected a string-valued projectId property. Try running `vc link` to re-link your project."
        );
      }
      return { projectId: prj.projectId, teamId: prj.orgId };
    }
    function saveToken(token, projectId) {
      const dir = (0, import_token_io.getUserDataDir)();
      if (!dir) {
        throw new import_token_error.VercelOidcTokenError(
          "Unable to find user data directory. Please reach out to Vercel support."
        );
      }
      const tokenPath = path33.join(dir, "com.vercel.token", `${projectId}.json`);
      const tokenJson = JSON.stringify(token);
      fs34.mkdirSync(path33.dirname(tokenPath), { mode: 504, recursive: true });
      fs34.writeFileSync(tokenPath, tokenJson);
      fs34.chmodSync(tokenPath, 432);
      return;
    }
    function loadToken(projectId) {
      const dir = (0, import_token_io.getUserDataDir)();
      if (!dir) {
        throw new import_token_error.VercelOidcTokenError(
          "Unable to find user data directory. Please reach out to Vercel support."
        );
      }
      const tokenPath = path33.join(dir, "com.vercel.token", `${projectId}.json`);
      if (!fs34.existsSync(tokenPath)) {
        return null;
      }
      const token = JSON.parse(fs34.readFileSync(tokenPath, "utf8"));
      assertVercelOidcTokenResponse(token);
      return token;
    }
    function getTokenPayload(token) {
      const tokenParts = token.split(".");
      if (tokenParts.length !== 3) {
        throw new import_token_error.VercelOidcTokenError(
          "Invalid token. Please run `vc env pull` and try again"
        );
      }
      const base644 = tokenParts[1].replace(/-/g, "+").replace(/_/g, "/");
      const padded = base644.padEnd(
        base644.length + (4 - base644.length % 4) % 4,
        "="
      );
      return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
    }
    function isExpired(token) {
      return token.exp * 1e3 < Date.now();
    }
  }
});

// node_modules/@vercel/oidc/dist/token.js
var require_token = __commonJS({
  "node_modules/@vercel/oidc/dist/token.js"(exports2, module2) {
    "use strict";
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var token_exports = {};
    __export4(token_exports, {
      refreshToken: () => refreshToken
    });
    module2.exports = __toCommonJS2(token_exports);
    var import_token_error = require_token_error();
    var import_token_util = require_token_util();
    async function refreshToken() {
      const { projectId, teamId } = (0, import_token_util.findProjectInfo)();
      let maybeToken = (0, import_token_util.loadToken)(projectId);
      if (!maybeToken || (0, import_token_util.isExpired)((0, import_token_util.getTokenPayload)(maybeToken.token))) {
        const authToken = await (0, import_token_util.getVercelCliToken)();
        if (!authToken) {
          throw new import_token_error.VercelOidcTokenError(
            "Failed to refresh OIDC token: Log in to Vercel CLI and link your project with `vc link`"
          );
        }
        if (!projectId) {
          throw new import_token_error.VercelOidcTokenError(
            "Failed to refresh OIDC token: Try re-linking your project with `vc link`"
          );
        }
        maybeToken = await (0, import_token_util.getVercelOidcToken)(authToken, projectId, teamId);
        if (!maybeToken) {
          throw new import_token_error.VercelOidcTokenError("Failed to refresh OIDC token");
        }
        (0, import_token_util.saveToken)(maybeToken, projectId);
      }
      process.env.VERCEL_OIDC_TOKEN = maybeToken.token;
      return;
    }
  }
});

// node_modules/@vercel/oidc/dist/get-vercel-oidc-token.js
var require_get_vercel_oidc_token = __commonJS({
  "node_modules/@vercel/oidc/dist/get-vercel-oidc-token.js"(exports2, module2) {
    "use strict";
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var get_vercel_oidc_token_exports = {};
    __export4(get_vercel_oidc_token_exports, {
      getVercelOidcToken: () => getVercelOidcToken3,
      getVercelOidcTokenSync: () => getVercelOidcTokenSync2
    });
    module2.exports = __toCommonJS2(get_vercel_oidc_token_exports);
    var import_get_context = require_get_context();
    var import_token_error = require_token_error();
    async function getVercelOidcToken3() {
      let token = "";
      let err;
      try {
        token = getVercelOidcTokenSync2();
      } catch (error73) {
        err = error73;
      }
      try {
        const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
          await Promise.resolve().then(() => __toESM(require_token_util())),
          await Promise.resolve().then(() => __toESM(require_token()))
        ]);
        if (!token || isExpired(getTokenPayload(token))) {
          await refreshToken();
          token = getVercelOidcTokenSync2();
        }
      } catch (error73) {
        let message = err instanceof Error ? err.message : "";
        if (error73 instanceof Error) {
          message = `${message}
${error73.message}`;
        }
        if (message) {
          throw new import_token_error.VercelOidcTokenError(message);
        }
        throw error73;
      }
      return token;
    }
    function getVercelOidcTokenSync2() {
      const token = (0, import_get_context.getContext)().headers?.["x-vercel-oidc-token"] ?? process.env.VERCEL_OIDC_TOKEN;
      if (!token) {
        throw new Error(
          `The 'x-vercel-oidc-token' header is missing from the request. Do you have the OIDC option enabled in the Vercel project settings?`
        );
      }
      return token;
    }
  }
});

// node_modules/@vercel/oidc/dist/index.js
var require_dist10 = __commonJS({
  "node_modules/@vercel/oidc/dist/index.js"(exports2, module2) {
    "use strict";
    var __defProp4 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export4 = (target, all3) => {
      for (var name28 in all3)
        __defProp4(target, name28, { get: all3[name28], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS2 = (mod) => __copyProps2(__defProp4({}, "__esModule", { value: true }), mod);
    var src_exports = {};
    __export4(src_exports, {
      getContext: () => import_get_context.getContext,
      getVercelOidcToken: () => import_get_vercel_oidc_token.getVercelOidcToken,
      getVercelOidcTokenSync: () => import_get_vercel_oidc_token.getVercelOidcTokenSync
    });
    module2.exports = __toCommonJS2(src_exports);
    var import_get_vercel_oidc_token = require_get_vercel_oidc_token();
    var import_get_context = require_get_context();
  }
});

// node_modules/@ai-sdk/gateway/dist/index.mjs
async function createGatewayErrorFromResponse({
  response,
  statusCode,
  defaultMessage = "Gateway request failed",
  cause,
  authMethod
}) {
  var _a96;
  const parseResult = await safeValidateTypes({
    value: response,
    schema: gatewayErrorResponseSchema
  });
  if (!parseResult.success) {
    const rawGenerationId = typeof response === "object" && response !== null && "generationId" in response ? response.generationId : void 0;
    return new GatewayResponseError({
      message: `Invalid error response format: ${defaultMessage}`,
      statusCode,
      response,
      validationError: parseResult.error,
      cause,
      generationId: rawGenerationId
    });
  }
  const validatedResponse = parseResult.value;
  const errorType = validatedResponse.error.type;
  const message = validatedResponse.error.message;
  const generationId = (_a96 = validatedResponse.generationId) != null ? _a96 : void 0;
  switch (errorType) {
    case "authentication_error":
      return GatewayAuthenticationError.createContextualError({
        apiKeyProvided: authMethod === "api-key",
        oidcTokenProvided: authMethod === "oidc",
        statusCode,
        cause,
        generationId
      });
    case "invalid_request_error":
      return new GatewayInvalidRequestError({
        message,
        statusCode,
        cause,
        generationId
      });
    case "rate_limit_exceeded":
      return new GatewayRateLimitError({
        message,
        statusCode,
        cause,
        generationId
      });
    case "model_not_found": {
      const modelResult = await safeValidateTypes({
        value: validatedResponse.error.param,
        schema: modelNotFoundParamSchema
      });
      return new GatewayModelNotFoundError({
        message,
        statusCode,
        modelId: modelResult.success ? modelResult.value.modelId : void 0,
        cause,
        generationId
      });
    }
    case "internal_server_error":
      return new GatewayInternalServerError({
        message,
        statusCode,
        cause,
        generationId
      });
    default:
      return new GatewayInternalServerError({
        message,
        statusCode,
        cause,
        generationId
      });
  }
}
function isTimeoutError(error73) {
  if (!(error73 instanceof Error)) {
    return false;
  }
  const errorCode = error73.code;
  if (typeof errorCode === "string") {
    const undiciTimeoutCodes = [
      "UND_ERR_HEADERS_TIMEOUT",
      "UND_ERR_BODY_TIMEOUT",
      "UND_ERR_CONNECT_TIMEOUT"
    ];
    return undiciTimeoutCodes.includes(errorCode);
  }
  return false;
}
async function asGatewayError(error73, authMethod) {
  var _a96;
  if (GatewayError.isInstance(error73)) {
    return error73;
  }
  if (isTimeoutError(error73)) {
    return GatewayTimeoutError.createTimeoutError({
      originalMessage: error73 instanceof Error ? error73.message : "Unknown error",
      cause: error73
    });
  }
  if (APICallError.isInstance(error73)) {
    if (error73.cause && isTimeoutError(error73.cause)) {
      return GatewayTimeoutError.createTimeoutError({
        originalMessage: error73.message,
        cause: error73
      });
    }
    return await createGatewayErrorFromResponse({
      response: extractApiCallResponse(error73),
      statusCode: (_a96 = error73.statusCode) != null ? _a96 : 500,
      defaultMessage: "Gateway request failed",
      cause: error73,
      authMethod
    });
  }
  return await createGatewayErrorFromResponse({
    response: {},
    statusCode: 500,
    defaultMessage: error73 instanceof Error ? `Gateway request failed: ${error73.message}` : "Unknown Gateway error",
    cause: error73,
    authMethod
  });
}
function extractApiCallResponse(error73) {
  if (error73.data !== void 0) {
    return error73.data;
  }
  if (error73.responseBody != null) {
    try {
      return JSON.parse(error73.responseBody);
    } catch (e) {
      return error73.responseBody;
    }
  }
  return {};
}
async function parseAuthMethod(headers) {
  const result = await safeValidateTypes({
    value: headers[GATEWAY_AUTH_METHOD_HEADER],
    schema: gatewayAuthMethodSchema
  });
  return result.success ? result.value : void 0;
}
function maybeEncodeImageFile(file3) {
  if (file3.type === "file" && file3.data instanceof Uint8Array) {
    return {
      ...file3,
      data: convertUint8ArrayToBase64(file3.data)
    };
  }
  return file3;
}
function maybeEncodeVideoFile(file3) {
  if (file3.type === "file" && file3.data instanceof Uint8Array) {
    return {
      ...file3,
      data: convertUint8ArrayToBase64(file3.data)
    };
  }
  return file3;
}
async function getVercelRequestId() {
  var _a96;
  return (_a96 = (0, import_oidc.getContext)().headers) == null ? void 0 : _a96["x-vercel-id"];
}
function createGatewayProvider(options = {}) {
  var _a96, _b95;
  let pendingMetadata = null;
  let metadataCache = null;
  const cacheRefreshMillis = (_a96 = options.metadataCacheRefreshMillis) != null ? _a96 : 1e3 * 60 * 5;
  let lastFetchTime = 0;
  const baseURL = (_b95 = withoutTrailingSlash(options.baseURL)) != null ? _b95 : "https://ai-gateway.vercel.sh/v3/ai";
  const getHeaders = async () => {
    try {
      const auth = await getGatewayAuthToken(options);
      return withUserAgentSuffix(
        {
          Authorization: `Bearer ${auth.token}`,
          "ai-gateway-protocol-version": AI_GATEWAY_PROTOCOL_VERSION,
          [GATEWAY_AUTH_METHOD_HEADER]: auth.authMethod,
          ...options.headers
        },
        `ai-sdk/gateway/${VERSION13}`
      );
    } catch (error73) {
      throw GatewayAuthenticationError.createContextualError({
        apiKeyProvided: false,
        oidcTokenProvided: false,
        statusCode: 401,
        cause: error73
      });
    }
  };
  const createO11yHeaders = () => {
    const deploymentId = loadOptionalSetting({
      settingValue: void 0,
      environmentVariableName: "VERCEL_DEPLOYMENT_ID"
    });
    const environment = loadOptionalSetting({
      settingValue: void 0,
      environmentVariableName: "VERCEL_ENV"
    });
    const region = loadOptionalSetting({
      settingValue: void 0,
      environmentVariableName: "VERCEL_REGION"
    });
    const projectId = loadOptionalSetting({
      settingValue: void 0,
      environmentVariableName: "VERCEL_PROJECT_ID"
    });
    return async () => {
      const requestId = await getVercelRequestId();
      return {
        ...deploymentId && { "ai-o11y-deployment-id": deploymentId },
        ...environment && { "ai-o11y-environment": environment },
        ...region && { "ai-o11y-region": region },
        ...requestId && { "ai-o11y-request-id": requestId },
        ...projectId && { "ai-o11y-project-id": projectId }
      };
    };
  };
  const createLanguageModel = (modelId) => {
    return new GatewayLanguageModel(modelId, {
      provider: "gateway",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch,
      o11yHeaders: createO11yHeaders()
    });
  };
  const getAvailableModels = async () => {
    var _a106, _b105, _c;
    const now2 = (_c = (_b105 = (_a106 = options._internal) == null ? void 0 : _a106.currentDate) == null ? void 0 : _b105.call(_a106).getTime()) != null ? _c : Date.now();
    if (!pendingMetadata || now2 - lastFetchTime > cacheRefreshMillis) {
      lastFetchTime = now2;
      pendingMetadata = new GatewayFetchMetadata({
        baseURL,
        headers: getHeaders,
        fetch: options.fetch
      }).getAvailableModels().then((metadata) => {
        metadataCache = metadata;
        return metadata;
      }).catch(async (error73) => {
        throw await asGatewayError(
          error73,
          await parseAuthMethod(await getHeaders())
        );
      });
    }
    return metadataCache ? Promise.resolve(metadataCache) : pendingMetadata;
  };
  const getCredits = async () => {
    return new GatewayFetchMetadata({
      baseURL,
      headers: getHeaders,
      fetch: options.fetch
    }).getCredits().catch(async (error73) => {
      throw await asGatewayError(
        error73,
        await parseAuthMethod(await getHeaders())
      );
    });
  };
  const getSpendReport = async (params) => {
    return new GatewaySpendReport({
      baseURL,
      headers: getHeaders,
      fetch: options.fetch
    }).getSpendReport(params).catch(async (error73) => {
      throw await asGatewayError(
        error73,
        await parseAuthMethod(await getHeaders())
      );
    });
  };
  const getGenerationInfo = async (params) => {
    return new GatewayGenerationInfoFetcher({
      baseURL,
      headers: getHeaders,
      fetch: options.fetch
    }).getGenerationInfo(params).catch(async (error73) => {
      throw await asGatewayError(
        error73,
        await parseAuthMethod(await getHeaders())
      );
    });
  };
  const provider = function(modelId) {
    if (new.target) {
      throw new Error(
        "The Gateway Provider model function cannot be called with the new keyword."
      );
    }
    return createLanguageModel(modelId);
  };
  provider.specificationVersion = "v3";
  provider.getAvailableModels = getAvailableModels;
  provider.getCredits = getCredits;
  provider.getSpendReport = getSpendReport;
  provider.getGenerationInfo = getGenerationInfo;
  provider.imageModel = (modelId) => {
    return new GatewayImageModel(modelId, {
      provider: "gateway",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch,
      o11yHeaders: createO11yHeaders()
    });
  };
  provider.languageModel = createLanguageModel;
  const createEmbeddingModel = (modelId) => {
    return new GatewayEmbeddingModel(modelId, {
      provider: "gateway",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch,
      o11yHeaders: createO11yHeaders()
    });
  };
  provider.embeddingModel = createEmbeddingModel;
  provider.textEmbeddingModel = createEmbeddingModel;
  provider.videoModel = (modelId) => {
    return new GatewayVideoModel(modelId, {
      provider: "gateway",
      baseURL,
      headers: getHeaders,
      fetch: options.fetch,
      o11yHeaders: createO11yHeaders()
    });
  };
  provider.chat = provider.languageModel;
  provider.embedding = provider.embeddingModel;
  provider.image = provider.imageModel;
  provider.video = provider.videoModel;
  provider.tools = gatewayTools;
  return provider;
}
async function getGatewayAuthToken(options) {
  const apiKey = loadOptionalSetting({
    settingValue: options.apiKey,
    environmentVariableName: "AI_GATEWAY_API_KEY"
  });
  if (apiKey) {
    return {
      token: apiKey,
      authMethod: "api-key"
    };
  }
  const oidcToken = await (0, import_oidc2.getVercelOidcToken)();
  return {
    token: oidcToken,
    authMethod: "oidc"
  };
}
var import_oidc, import_oidc2, marker25, symbol27, _a28, _b25, GatewayError, name21, marker26, symbol28, _a29, _b26, GatewayAuthenticationError, name25, marker35, symbol35, _a35, _b35, GatewayInvalidRequestError, name35, marker45, symbol45, _a45, _b45, GatewayRateLimitError, name45, marker55, symbol55, modelNotFoundParamSchema, _a55, _b55, GatewayModelNotFoundError, name55, marker65, symbol65, _a65, _b65, GatewayInternalServerError, name65, marker75, symbol75, _a75, _b75, GatewayResponseError, gatewayErrorResponseSchema, name75, marker85, symbol85, _a85, _b85, GatewayTimeoutError, GATEWAY_AUTH_METHOD_HEADER, gatewayAuthMethodSchema, GatewayFetchMetadata, gatewayAvailableModelsResponseSchema, gatewayCreditsResponseSchema, GatewaySpendReport, gatewaySpendReportResponseSchema, GatewayGenerationInfoFetcher, gatewayGenerationInfoResponseSchema, GatewayLanguageModel, GatewayEmbeddingModel, gatewayEmbeddingResponseSchema, GatewayImageModel, providerMetadataEntrySchema, gatewayImageWarningSchema, gatewayImageUsageSchema, gatewayImageResponseSchema, GatewayVideoModel, providerMetadataEntrySchema2, gatewayVideoDataSchema, gatewayVideoWarningSchema, gatewayVideoEventSchema, parallelSearchInputSchema, parallelSearchOutputSchema, parallelSearchToolFactory, parallelSearch, perplexitySearchInputSchema, perplexitySearchOutputSchema, perplexitySearchToolFactory, perplexitySearch, gatewayTools, VERSION13, AI_GATEWAY_PROTOCOL_VERSION, gateway;
var init_dist21 = __esm({
  "node_modules/@ai-sdk/gateway/dist/index.mjs"() {
    "use strict";
    init_dist5();
    init_dist3();
    init_v42();
    init_v42();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist5();
    init_zod();
    init_dist5();
    init_zod();
    import_oidc = __toESM(require_dist10(), 1);
    import_oidc2 = __toESM(require_dist10(), 1);
    init_dist5();
    marker25 = "vercel.ai.gateway.error";
    symbol27 = Symbol.for(marker25);
    GatewayError = class _GatewayError extends (_b25 = Error, _a28 = symbol27, _b25) {
      constructor({
        message,
        statusCode = 500,
        cause,
        generationId
      }) {
        super(generationId ? `${message} [${generationId}]` : message);
        this[_a28] = true;
        this.statusCode = statusCode;
        this.cause = cause;
        this.generationId = generationId;
      }
      /**
       * Checks if the given error is a Gateway Error.
       * @param {unknown} error - The error to check.
       * @returns {boolean} True if the error is a Gateway Error, false otherwise.
       */
      static isInstance(error73) {
        return _GatewayError.hasMarker(error73);
      }
      static hasMarker(error73) {
        return typeof error73 === "object" && error73 !== null && symbol27 in error73 && error73[symbol27] === true;
      }
    };
    name21 = "GatewayAuthenticationError";
    marker26 = `vercel.ai.gateway.error.${name21}`;
    symbol28 = Symbol.for(marker26);
    GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b26 = GatewayError, _a29 = symbol28, _b26) {
      constructor({
        message = "Authentication failed",
        statusCode = 401,
        cause,
        generationId
      } = {}) {
        super({ message, statusCode, cause, generationId });
        this[_a29] = true;
        this.name = name21;
        this.type = "authentication_error";
      }
      static isInstance(error73) {
        return GatewayError.hasMarker(error73) && symbol28 in error73;
      }
      /**
       * Creates a contextual error message when authentication fails
       */
      static createContextualError({
        apiKeyProvided,
        oidcTokenProvided,
        message = "Authentication failed",
        statusCode = 401,
        cause,
        generationId
      }) {
        let contextualMessage;
        if (apiKeyProvided) {
          contextualMessage = `AI Gateway authentication failed: Invalid API key.

Create a new API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys

Provide via 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.`;
        } else if (oidcTokenProvided) {
          contextualMessage = `AI Gateway authentication failed: Invalid OIDC token.

Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the token.

Alternatively, use an API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys`;
        } else {
          contextualMessage = `AI Gateway authentication failed: No authentication provided.

Option 1 - API key:
Create an API key: https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai%2Fapi-keys
Provide via 'apiKey' option or 'AI_GATEWAY_API_KEY' environment variable.

Option 2 - OIDC token:
Run 'npx vercel link' to link your project, then 'vc env pull' to fetch the token.`;
        }
        return new _GatewayAuthenticationError({
          message: contextualMessage,
          statusCode,
          cause,
          generationId
        });
      }
    };
    name25 = "GatewayInvalidRequestError";
    marker35 = `vercel.ai.gateway.error.${name25}`;
    symbol35 = Symbol.for(marker35);
    GatewayInvalidRequestError = class extends (_b35 = GatewayError, _a35 = symbol35, _b35) {
      constructor({
        message = "Invalid request",
        statusCode = 400,
        cause,
        generationId
      } = {}) {
        super({ message, statusCode, cause, generationId });
        this[_a35] = true;
        this.name = name25;
        this.type = "invalid_request_error";
      }
      static isInstance(error73) {
        return GatewayError.hasMarker(error73) && symbol35 in error73;
      }
    };
    name35 = "GatewayRateLimitError";
    marker45 = `vercel.ai.gateway.error.${name35}`;
    symbol45 = Symbol.for(marker45);
    GatewayRateLimitError = class extends (_b45 = GatewayError, _a45 = symbol45, _b45) {
      constructor({
        message = "Rate limit exceeded",
        statusCode = 429,
        cause,
        generationId
      } = {}) {
        super({ message, statusCode, cause, generationId });
        this[_a45] = true;
        this.name = name35;
        this.type = "rate_limit_exceeded";
      }
      static isInstance(error73) {
        return GatewayError.hasMarker(error73) && symbol45 in error73;
      }
    };
    name45 = "GatewayModelNotFoundError";
    marker55 = `vercel.ai.gateway.error.${name45}`;
    symbol55 = Symbol.for(marker55);
    modelNotFoundParamSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          modelId: external_exports.string()
        })
      )
    );
    GatewayModelNotFoundError = class extends (_b55 = GatewayError, _a55 = symbol55, _b55) {
      constructor({
        message = "Model not found",
        statusCode = 404,
        modelId,
        cause,
        generationId
      } = {}) {
        super({ message, statusCode, cause, generationId });
        this[_a55] = true;
        this.name = name45;
        this.type = "model_not_found";
        this.modelId = modelId;
      }
      static isInstance(error73) {
        return GatewayError.hasMarker(error73) && symbol55 in error73;
      }
    };
    name55 = "GatewayInternalServerError";
    marker65 = `vercel.ai.gateway.error.${name55}`;
    symbol65 = Symbol.for(marker65);
    GatewayInternalServerError = class extends (_b65 = GatewayError, _a65 = symbol65, _b65) {
      constructor({
        message = "Internal server error",
        statusCode = 500,
        cause,
        generationId
      } = {}) {
        super({ message, statusCode, cause, generationId });
        this[_a65] = true;
        this.name = name55;
        this.type = "internal_server_error";
      }
      static isInstance(error73) {
        return GatewayError.hasMarker(error73) && symbol65 in error73;
      }
    };
    name65 = "GatewayResponseError";
    marker75 = `vercel.ai.gateway.error.${name65}`;
    symbol75 = Symbol.for(marker75);
    GatewayResponseError = class extends (_b75 = GatewayError, _a75 = symbol75, _b75) {
      constructor({
        message = "Invalid response from Gateway",
        statusCode = 502,
        response,
        validationError,
        cause,
        generationId
      } = {}) {
        super({ message, statusCode, cause, generationId });
        this[_a75] = true;
        this.name = name65;
        this.type = "response_error";
        this.response = response;
        this.validationError = validationError;
      }
      static isInstance(error73) {
        return GatewayError.hasMarker(error73) && symbol75 in error73;
      }
    };
    gatewayErrorResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          error: external_exports.object({
            message: external_exports.string(),
            type: external_exports.string().nullish(),
            param: external_exports.unknown().nullish(),
            code: external_exports.union([external_exports.string(), external_exports.number()]).nullish()
          }),
          generationId: external_exports.string().nullish()
        })
      )
    );
    name75 = "GatewayTimeoutError";
    marker85 = `vercel.ai.gateway.error.${name75}`;
    symbol85 = Symbol.for(marker85);
    GatewayTimeoutError = class _GatewayTimeoutError extends (_b85 = GatewayError, _a85 = symbol85, _b85) {
      constructor({
        message = "Request timed out",
        statusCode = 408,
        cause,
        generationId
      } = {}) {
        super({ message, statusCode, cause, generationId });
        this[_a85] = true;
        this.name = name75;
        this.type = "timeout_error";
      }
      static isInstance(error73) {
        return GatewayError.hasMarker(error73) && symbol85 in error73;
      }
      /**
       * Creates a helpful timeout error message with troubleshooting guidance
       */
      static createTimeoutError({
        originalMessage,
        statusCode = 408,
        cause,
        generationId
      }) {
        const message = `Gateway request timed out: ${originalMessage}

    This is a client-side timeout. To resolve this, increase your timeout configuration: https://vercel.com/docs/ai-gateway/capabilities/video-generation#extending-timeouts-for-node.js`;
        return new _GatewayTimeoutError({
          message,
          statusCode,
          cause,
          generationId
        });
      }
    };
    GATEWAY_AUTH_METHOD_HEADER = "ai-gateway-auth-method";
    gatewayAuthMethodSchema = lazySchema(
      () => zodSchema(external_exports.union([external_exports.literal("api-key"), external_exports.literal("oidc")]))
    );
    GatewayFetchMetadata = class {
      constructor(config3) {
        this.config = config3;
      }
      async getAvailableModels() {
        try {
          const { value } = await getFromApi({
            url: `${this.config.baseURL}/config`,
            headers: await resolve(this.config.headers()),
            successfulResponseHandler: createJsonResponseHandler(
              gatewayAvailableModelsResponseSchema
            ),
            failedResponseHandler: createJsonErrorResponseHandler({
              errorSchema: external_exports.any(),
              errorToMessage: (data) => data
            }),
            fetch: this.config.fetch
          });
          return value;
        } catch (error73) {
          throw await asGatewayError(error73);
        }
      }
      async getCredits() {
        try {
          const baseUrl = new URL(this.config.baseURL);
          const { value } = await getFromApi({
            url: `${baseUrl.origin}/v1/credits`,
            headers: await resolve(this.config.headers()),
            successfulResponseHandler: createJsonResponseHandler(
              gatewayCreditsResponseSchema
            ),
            failedResponseHandler: createJsonErrorResponseHandler({
              errorSchema: external_exports.any(),
              errorToMessage: (data) => data
            }),
            fetch: this.config.fetch
          });
          return value;
        } catch (error73) {
          throw await asGatewayError(error73);
        }
      }
    };
    gatewayAvailableModelsResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          models: external_exports.array(
            external_exports.object({
              id: external_exports.string(),
              name: external_exports.string(),
              description: external_exports.string().nullish(),
              pricing: external_exports.object({
                input: external_exports.string(),
                output: external_exports.string(),
                input_cache_read: external_exports.string().nullish(),
                input_cache_write: external_exports.string().nullish()
              }).transform(
                ({ input, output, input_cache_read, input_cache_write }) => ({
                  input,
                  output,
                  ...input_cache_read ? { cachedInputTokens: input_cache_read } : {},
                  ...input_cache_write ? { cacheCreationInputTokens: input_cache_write } : {}
                })
              ).nullish(),
              specification: external_exports.object({
                specificationVersion: external_exports.literal("v3"),
                provider: external_exports.string(),
                modelId: external_exports.string()
              }),
              modelType: external_exports.enum(["embedding", "image", "language", "video"]).nullish()
            })
          )
        })
      )
    );
    gatewayCreditsResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          balance: external_exports.string(),
          total_used: external_exports.string()
        }).transform(({ balance, total_used }) => ({
          balance,
          totalUsed: total_used
        }))
      )
    );
    GatewaySpendReport = class {
      constructor(config3) {
        this.config = config3;
      }
      async getSpendReport(params) {
        try {
          const baseUrl = new URL(this.config.baseURL);
          const searchParams = new URLSearchParams();
          searchParams.set("start_date", params.startDate);
          searchParams.set("end_date", params.endDate);
          if (params.groupBy) {
            searchParams.set("group_by", params.groupBy);
          }
          if (params.datePart) {
            searchParams.set("date_part", params.datePart);
          }
          if (params.userId) {
            searchParams.set("user_id", params.userId);
          }
          if (params.model) {
            searchParams.set("model", params.model);
          }
          if (params.provider) {
            searchParams.set("provider", params.provider);
          }
          if (params.credentialType) {
            searchParams.set("credential_type", params.credentialType);
          }
          if (params.tags && params.tags.length > 0) {
            searchParams.set("tags", params.tags.join(","));
          }
          const { value } = await getFromApi({
            url: `${baseUrl.origin}/v1/report?${searchParams.toString()}`,
            headers: await resolve(this.config.headers()),
            successfulResponseHandler: createJsonResponseHandler(
              gatewaySpendReportResponseSchema
            ),
            failedResponseHandler: createJsonErrorResponseHandler({
              errorSchema: external_exports.any(),
              errorToMessage: (data) => data
            }),
            fetch: this.config.fetch
          });
          return value;
        } catch (error73) {
          throw await asGatewayError(error73);
        }
      }
    };
    gatewaySpendReportResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          results: external_exports.array(
            external_exports.object({
              day: external_exports.string().optional(),
              hour: external_exports.string().optional(),
              user: external_exports.string().optional(),
              model: external_exports.string().optional(),
              tag: external_exports.string().optional(),
              provider: external_exports.string().optional(),
              credential_type: external_exports.enum(["byok", "system"]).optional(),
              total_cost: external_exports.number(),
              market_cost: external_exports.number().optional(),
              input_tokens: external_exports.number().optional(),
              output_tokens: external_exports.number().optional(),
              cached_input_tokens: external_exports.number().optional(),
              cache_creation_input_tokens: external_exports.number().optional(),
              reasoning_tokens: external_exports.number().optional(),
              request_count: external_exports.number().optional()
            }).transform(
              ({
                credential_type,
                total_cost,
                market_cost,
                input_tokens,
                output_tokens,
                cached_input_tokens,
                cache_creation_input_tokens,
                reasoning_tokens,
                request_count,
                ...rest
              }) => ({
                ...rest,
                ...credential_type !== void 0 ? { credentialType: credential_type } : {},
                totalCost: total_cost,
                ...market_cost !== void 0 ? { marketCost: market_cost } : {},
                ...input_tokens !== void 0 ? { inputTokens: input_tokens } : {},
                ...output_tokens !== void 0 ? { outputTokens: output_tokens } : {},
                ...cached_input_tokens !== void 0 ? { cachedInputTokens: cached_input_tokens } : {},
                ...cache_creation_input_tokens !== void 0 ? { cacheCreationInputTokens: cache_creation_input_tokens } : {},
                ...reasoning_tokens !== void 0 ? { reasoningTokens: reasoning_tokens } : {},
                ...request_count !== void 0 ? { requestCount: request_count } : {}
              })
            )
          )
        })
      )
    );
    GatewayGenerationInfoFetcher = class {
      constructor(config3) {
        this.config = config3;
      }
      async getGenerationInfo(params) {
        try {
          const baseUrl = new URL(this.config.baseURL);
          const { value } = await getFromApi({
            url: `${baseUrl.origin}/v1/generation?id=${encodeURIComponent(params.id)}`,
            headers: await resolve(this.config.headers()),
            successfulResponseHandler: createJsonResponseHandler(
              gatewayGenerationInfoResponseSchema
            ),
            failedResponseHandler: createJsonErrorResponseHandler({
              errorSchema: external_exports.any(),
              errorToMessage: (data) => data
            }),
            fetch: this.config.fetch
          });
          return value;
        } catch (error73) {
          throw await asGatewayError(error73);
        }
      }
    };
    gatewayGenerationInfoResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          data: external_exports.object({
            id: external_exports.string(),
            total_cost: external_exports.number(),
            upstream_inference_cost: external_exports.number(),
            usage: external_exports.number(),
            created_at: external_exports.string(),
            model: external_exports.string(),
            is_byok: external_exports.boolean(),
            provider_name: external_exports.string(),
            streamed: external_exports.boolean(),
            finish_reason: external_exports.string(),
            latency: external_exports.number(),
            generation_time: external_exports.number(),
            native_tokens_prompt: external_exports.number(),
            native_tokens_completion: external_exports.number(),
            native_tokens_reasoning: external_exports.number(),
            native_tokens_cached: external_exports.number(),
            native_tokens_cache_creation: external_exports.number(),
            billable_web_search_calls: external_exports.number()
          }).transform(
            ({
              total_cost,
              upstream_inference_cost,
              created_at,
              is_byok,
              provider_name,
              finish_reason,
              generation_time,
              native_tokens_prompt,
              native_tokens_completion,
              native_tokens_reasoning,
              native_tokens_cached,
              native_tokens_cache_creation,
              billable_web_search_calls,
              ...rest
            }) => ({
              ...rest,
              totalCost: total_cost,
              upstreamInferenceCost: upstream_inference_cost,
              createdAt: created_at,
              isByok: is_byok,
              providerName: provider_name,
              finishReason: finish_reason,
              generationTime: generation_time,
              promptTokens: native_tokens_prompt,
              completionTokens: native_tokens_completion,
              reasoningTokens: native_tokens_reasoning,
              cachedTokens: native_tokens_cached,
              cacheCreationTokens: native_tokens_cache_creation,
              billableWebSearchCalls: billable_web_search_calls
            })
          )
        }).transform(({ data }) => data)
      )
    );
    GatewayLanguageModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
        this.supportedUrls = { "*/*": [/.*/] };
      }
      get provider() {
        return this.config.provider;
      }
      async getArgs(options) {
        const { abortSignal: _abortSignal, ...optionsWithoutSignal } = options;
        return {
          args: this.maybeEncodeFileParts(optionsWithoutSignal),
          warnings: []
        };
      }
      async doGenerate(options) {
        const { args, warnings } = await this.getArgs(options);
        const { abortSignal } = options;
        const resolvedHeaders = await resolve(this.config.headers());
        try {
          const {
            responseHeaders,
            value: responseBody,
            rawValue: rawResponse
          } = await postJsonToApi({
            url: this.getUrl(),
            headers: combineHeaders(
              resolvedHeaders,
              options.headers,
              this.getModelConfigHeaders(this.modelId, false),
              await resolve(this.config.o11yHeaders)
            ),
            body: args,
            successfulResponseHandler: createJsonResponseHandler(external_exports.any()),
            failedResponseHandler: createJsonErrorResponseHandler({
              errorSchema: external_exports.any(),
              errorToMessage: (data) => data
            }),
            ...abortSignal && { abortSignal },
            fetch: this.config.fetch
          });
          return {
            ...responseBody,
            request: { body: args },
            response: { headers: responseHeaders, body: rawResponse },
            warnings
          };
        } catch (error73) {
          throw await asGatewayError(error73, await parseAuthMethod(resolvedHeaders));
        }
      }
      async doStream(options) {
        const { args, warnings } = await this.getArgs(options);
        const { abortSignal } = options;
        const resolvedHeaders = await resolve(this.config.headers());
        try {
          const { value: response, responseHeaders } = await postJsonToApi({
            url: this.getUrl(),
            headers: combineHeaders(
              resolvedHeaders,
              options.headers,
              this.getModelConfigHeaders(this.modelId, true),
              await resolve(this.config.o11yHeaders)
            ),
            body: args,
            successfulResponseHandler: createEventSourceResponseHandler(external_exports.any()),
            failedResponseHandler: createJsonErrorResponseHandler({
              errorSchema: external_exports.any(),
              errorToMessage: (data) => data
            }),
            ...abortSignal && { abortSignal },
            fetch: this.config.fetch
          });
          return {
            stream: response.pipeThrough(
              new TransformStream({
                start(controller) {
                  if (warnings.length > 0) {
                    controller.enqueue({ type: "stream-start", warnings });
                  }
                },
                transform(chunk, controller) {
                  if (chunk.success) {
                    const streamPart = chunk.value;
                    if (streamPart.type === "raw" && !options.includeRawChunks) {
                      return;
                    }
                    if (streamPart.type === "response-metadata" && streamPart.timestamp && typeof streamPart.timestamp === "string") {
                      streamPart.timestamp = new Date(streamPart.timestamp);
                    }
                    controller.enqueue(streamPart);
                  } else {
                    controller.error(
                      chunk.error
                    );
                  }
                }
              })
            ),
            request: { body: args },
            response: { headers: responseHeaders }
          };
        } catch (error73) {
          throw await asGatewayError(error73, await parseAuthMethod(resolvedHeaders));
        }
      }
      isFilePart(part) {
        return part && typeof part === "object" && "type" in part && part.type === "file";
      }
      /**
       * Encodes file parts in the prompt to base64. Mutates the passed options
       * instance directly to avoid copying the file data.
       * @param options - The options to encode.
       * @returns The options with the file parts encoded.
       */
      maybeEncodeFileParts(options) {
        for (const message of options.prompt) {
          for (const part of message.content) {
            if (this.isFilePart(part)) {
              const filePart = part;
              if (filePart.data instanceof Uint8Array) {
                const buffer = Uint8Array.from(filePart.data);
                const base64Data = Buffer.from(buffer).toString("base64");
                filePart.data = new URL(
                  `data:${filePart.mediaType || "application/octet-stream"};base64,${base64Data}`
                );
              }
            }
          }
        }
        return options;
      }
      getUrl() {
        return `${this.config.baseURL}/language-model`;
      }
      getModelConfigHeaders(modelId, streaming) {
        return {
          "ai-language-model-specification-version": "3",
          "ai-language-model-id": modelId,
          "ai-language-model-streaming": String(streaming)
        };
      }
    };
    GatewayEmbeddingModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
        this.maxEmbeddingsPerCall = 2048;
        this.supportsParallelCalls = true;
      }
      get provider() {
        return this.config.provider;
      }
      async doEmbed({
        values,
        headers,
        abortSignal,
        providerOptions
      }) {
        var _a96;
        const resolvedHeaders = await resolve(this.config.headers());
        try {
          const {
            responseHeaders,
            value: responseBody,
            rawValue
          } = await postJsonToApi({
            url: this.getUrl(),
            headers: combineHeaders(
              resolvedHeaders,
              headers != null ? headers : {},
              this.getModelConfigHeaders(),
              await resolve(this.config.o11yHeaders)
            ),
            body: {
              values,
              ...providerOptions ? { providerOptions } : {}
            },
            successfulResponseHandler: createJsonResponseHandler(
              gatewayEmbeddingResponseSchema
            ),
            failedResponseHandler: createJsonErrorResponseHandler({
              errorSchema: external_exports.any(),
              errorToMessage: (data) => data
            }),
            ...abortSignal && { abortSignal },
            fetch: this.config.fetch
          });
          return {
            embeddings: responseBody.embeddings,
            usage: (_a96 = responseBody.usage) != null ? _a96 : void 0,
            providerMetadata: responseBody.providerMetadata,
            response: { headers: responseHeaders, body: rawValue },
            warnings: []
          };
        } catch (error73) {
          throw await asGatewayError(error73, await parseAuthMethod(resolvedHeaders));
        }
      }
      getUrl() {
        return `${this.config.baseURL}/embedding-model`;
      }
      getModelConfigHeaders() {
        return {
          "ai-embedding-model-specification-version": "3",
          "ai-model-id": this.modelId
        };
      }
    };
    gatewayEmbeddingResponseSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          embeddings: external_exports.array(external_exports.array(external_exports.number())),
          usage: external_exports.object({ tokens: external_exports.number() }).nullish(),
          providerMetadata: external_exports.record(external_exports.string(), external_exports.record(external_exports.string(), external_exports.unknown())).optional()
        })
      )
    );
    GatewayImageModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
        this.maxImagesPerCall = Number.MAX_SAFE_INTEGER;
      }
      get provider() {
        return this.config.provider;
      }
      async doGenerate({
        prompt,
        n,
        size,
        aspectRatio,
        seed,
        files,
        mask,
        providerOptions,
        headers,
        abortSignal
      }) {
        var _a96, _b95, _c, _d;
        const resolvedHeaders = await resolve(this.config.headers());
        try {
          const {
            responseHeaders,
            value: responseBody,
            rawValue
          } = await postJsonToApi({
            url: this.getUrl(),
            headers: combineHeaders(
              resolvedHeaders,
              headers != null ? headers : {},
              this.getModelConfigHeaders(),
              await resolve(this.config.o11yHeaders)
            ),
            body: {
              prompt,
              n,
              ...size && { size },
              ...aspectRatio && { aspectRatio },
              ...seed && { seed },
              ...providerOptions && { providerOptions },
              ...files && {
                files: files.map((file3) => maybeEncodeImageFile(file3))
              },
              ...mask && { mask: maybeEncodeImageFile(mask) }
            },
            successfulResponseHandler: createJsonResponseHandler(
              gatewayImageResponseSchema
            ),
            failedResponseHandler: createJsonErrorResponseHandler({
              errorSchema: external_exports.any(),
              errorToMessage: (data) => data
            }),
            ...abortSignal && { abortSignal },
            fetch: this.config.fetch
          });
          return {
            images: responseBody.images,
            // Always base64 strings from server
            warnings: (_a96 = responseBody.warnings) != null ? _a96 : [],
            providerMetadata: responseBody.providerMetadata,
            response: {
              timestamp: /* @__PURE__ */ new Date(),
              modelId: this.modelId,
              headers: responseHeaders
            },
            ...responseBody.usage != null && {
              usage: {
                inputTokens: (_b95 = responseBody.usage.inputTokens) != null ? _b95 : void 0,
                outputTokens: (_c = responseBody.usage.outputTokens) != null ? _c : void 0,
                totalTokens: (_d = responseBody.usage.totalTokens) != null ? _d : void 0
              }
            }
          };
        } catch (error73) {
          throw await asGatewayError(error73, await parseAuthMethod(resolvedHeaders));
        }
      }
      getUrl() {
        return `${this.config.baseURL}/image-model`;
      }
      getModelConfigHeaders() {
        return {
          "ai-image-model-specification-version": "3",
          "ai-model-id": this.modelId
        };
      }
    };
    providerMetadataEntrySchema = external_exports.object({
      images: external_exports.array(external_exports.unknown()).optional()
    }).catchall(external_exports.unknown());
    gatewayImageWarningSchema = external_exports.discriminatedUnion("type", [
      external_exports.object({
        type: external_exports.literal("unsupported"),
        feature: external_exports.string(),
        details: external_exports.string().optional()
      }),
      external_exports.object({
        type: external_exports.literal("compatibility"),
        feature: external_exports.string(),
        details: external_exports.string().optional()
      }),
      external_exports.object({
        type: external_exports.literal("other"),
        message: external_exports.string()
      })
    ]);
    gatewayImageUsageSchema = external_exports.object({
      inputTokens: external_exports.number().nullish(),
      outputTokens: external_exports.number().nullish(),
      totalTokens: external_exports.number().nullish()
    });
    gatewayImageResponseSchema = external_exports.object({
      images: external_exports.array(external_exports.string()),
      // Always base64 strings over the wire
      warnings: external_exports.array(gatewayImageWarningSchema).optional(),
      providerMetadata: external_exports.record(external_exports.string(), providerMetadataEntrySchema).optional(),
      usage: gatewayImageUsageSchema.optional()
    });
    GatewayVideoModel = class {
      constructor(modelId, config3) {
        this.modelId = modelId;
        this.config = config3;
        this.specificationVersion = "v3";
        this.maxVideosPerCall = Number.MAX_SAFE_INTEGER;
      }
      get provider() {
        return this.config.provider;
      }
      async doGenerate({
        prompt,
        n,
        aspectRatio,
        resolution,
        duration: duration4,
        fps,
        seed,
        image,
        providerOptions,
        headers,
        abortSignal
      }) {
        var _a96;
        const resolvedHeaders = await resolve(this.config.headers());
        try {
          const { responseHeaders, value: responseBody } = await postJsonToApi({
            url: this.getUrl(),
            headers: combineHeaders(
              resolvedHeaders,
              headers != null ? headers : {},
              this.getModelConfigHeaders(),
              await resolve(this.config.o11yHeaders),
              { accept: "text/event-stream" }
            ),
            body: {
              prompt,
              n,
              ...aspectRatio && { aspectRatio },
              ...resolution && { resolution },
              ...duration4 && { duration: duration4 },
              ...fps && { fps },
              ...seed && { seed },
              ...providerOptions && { providerOptions },
              ...image && { image: maybeEncodeVideoFile(image) }
            },
            successfulResponseHandler: async ({
              response,
              url: url4,
              requestBodyValues
            }) => {
              if (response.body == null) {
                throw new APICallError({
                  message: "SSE response body is empty",
                  url: url4,
                  requestBodyValues,
                  statusCode: response.status
                });
              }
              const eventStream = parseJsonEventStream({
                stream: response.body,
                schema: gatewayVideoEventSchema
              });
              const reader = eventStream.getReader();
              const { done, value: parseResult } = await reader.read();
              reader.releaseLock();
              if (done || !parseResult) {
                throw new APICallError({
                  message: "SSE stream ended without a data event",
                  url: url4,
                  requestBodyValues,
                  statusCode: response.status
                });
              }
              if (!parseResult.success) {
                throw new APICallError({
                  message: "Failed to parse video SSE event",
                  cause: parseResult.error,
                  url: url4,
                  requestBodyValues,
                  statusCode: response.status
                });
              }
              const event = parseResult.value;
              if (event.type === "error") {
                throw new APICallError({
                  message: event.message,
                  statusCode: event.statusCode,
                  url: url4,
                  requestBodyValues,
                  responseHeaders: Object.fromEntries([...response.headers]),
                  responseBody: JSON.stringify(event),
                  data: {
                    error: {
                      message: event.message,
                      type: event.errorType,
                      param: event.param
                    }
                  }
                });
              }
              return {
                value: {
                  videos: event.videos,
                  warnings: event.warnings,
                  providerMetadata: event.providerMetadata
                },
                responseHeaders: Object.fromEntries([...response.headers])
              };
            },
            failedResponseHandler: createJsonErrorResponseHandler({
              errorSchema: external_exports.any(),
              errorToMessage: (data) => data
            }),
            ...abortSignal && { abortSignal },
            fetch: this.config.fetch
          });
          return {
            videos: responseBody.videos,
            warnings: (_a96 = responseBody.warnings) != null ? _a96 : [],
            providerMetadata: responseBody.providerMetadata,
            response: {
              timestamp: /* @__PURE__ */ new Date(),
              modelId: this.modelId,
              headers: responseHeaders
            }
          };
        } catch (error73) {
          throw await asGatewayError(error73, await parseAuthMethod(resolvedHeaders));
        }
      }
      getUrl() {
        return `${this.config.baseURL}/video-model`;
      }
      getModelConfigHeaders() {
        return {
          "ai-video-model-specification-version": "3",
          "ai-model-id": this.modelId
        };
      }
    };
    providerMetadataEntrySchema2 = external_exports.object({
      videos: external_exports.array(external_exports.unknown()).optional()
    }).catchall(external_exports.unknown());
    gatewayVideoDataSchema = external_exports.union([
      external_exports.object({
        type: external_exports.literal("url"),
        url: external_exports.string(),
        mediaType: external_exports.string()
      }),
      external_exports.object({
        type: external_exports.literal("base64"),
        data: external_exports.string(),
        mediaType: external_exports.string()
      })
    ]);
    gatewayVideoWarningSchema = external_exports.discriminatedUnion("type", [
      external_exports.object({
        type: external_exports.literal("unsupported"),
        feature: external_exports.string(),
        details: external_exports.string().optional()
      }),
      external_exports.object({
        type: external_exports.literal("compatibility"),
        feature: external_exports.string(),
        details: external_exports.string().optional()
      }),
      external_exports.object({
        type: external_exports.literal("other"),
        message: external_exports.string()
      })
    ]);
    gatewayVideoEventSchema = external_exports.discriminatedUnion("type", [
      external_exports.object({
        type: external_exports.literal("result"),
        videos: external_exports.array(gatewayVideoDataSchema),
        warnings: external_exports.array(gatewayVideoWarningSchema).optional(),
        providerMetadata: external_exports.record(external_exports.string(), providerMetadataEntrySchema2).optional()
      }),
      external_exports.object({
        type: external_exports.literal("error"),
        message: external_exports.string(),
        errorType: external_exports.string(),
        statusCode: external_exports.number(),
        param: external_exports.unknown().nullable()
      })
    ]);
    parallelSearchInputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          objective: external_exports.string().describe(
            "Natural-language description of the web research goal, including source or freshness guidance and broader context from the task. Maximum 5000 characters."
          ),
          search_queries: external_exports.array(external_exports.string()).optional().describe(
            "Optional search queries to supplement the objective. Maximum 200 characters per query."
          ),
          mode: external_exports.enum(["one-shot", "agentic"]).optional().describe(
            'Mode preset: "one-shot" for comprehensive results with longer excerpts (default), "agentic" for concise, token-efficient results for multi-step workflows.'
          ),
          max_results: external_exports.number().optional().describe(
            "Maximum number of results to return (1-20). Defaults to 10 if not specified."
          ),
          source_policy: external_exports.object({
            include_domains: external_exports.array(external_exports.string()).optional().describe("List of domains to include in search results."),
            exclude_domains: external_exports.array(external_exports.string()).optional().describe("List of domains to exclude from search results."),
            after_date: external_exports.string().optional().describe(
              "Only include results published after this date (ISO 8601 format)."
            )
          }).optional().describe(
            "Source policy for controlling which domains to include/exclude and freshness."
          ),
          excerpts: external_exports.object({
            max_chars_per_result: external_exports.number().optional().describe("Maximum characters per result."),
            max_chars_total: external_exports.number().optional().describe("Maximum total characters across all results.")
          }).optional().describe("Excerpt configuration for controlling result length."),
          fetch_policy: external_exports.object({
            max_age_seconds: external_exports.number().optional().describe(
              "Maximum age in seconds for cached content. Set to 0 to always fetch fresh content."
            )
          }).optional().describe("Fetch policy for controlling content freshness.")
        })
      )
    );
    parallelSearchOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.union([
          // Success response
          external_exports.object({
            searchId: external_exports.string(),
            results: external_exports.array(
              external_exports.object({
                url: external_exports.string(),
                title: external_exports.string(),
                excerpt: external_exports.string(),
                publishDate: external_exports.string().nullable().optional(),
                relevanceScore: external_exports.number().optional()
              })
            )
          }),
          // Error response
          external_exports.object({
            error: external_exports.enum([
              "api_error",
              "rate_limit",
              "timeout",
              "invalid_input",
              "configuration_error",
              "unknown"
            ]),
            statusCode: external_exports.number().optional(),
            message: external_exports.string()
          })
        ])
      )
    );
    parallelSearchToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "gateway.parallel_search",
      inputSchema: parallelSearchInputSchema,
      outputSchema: parallelSearchOutputSchema
    });
    parallelSearch = (config3 = {}) => parallelSearchToolFactory(config3);
    perplexitySearchInputSchema = lazySchema(
      () => zodSchema(
        external_exports.object({
          query: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).describe(
            "Search query (string) or multiple queries (array of up to 5 strings). Multi-query searches return combined results from all queries."
          ),
          max_results: external_exports.number().optional().describe(
            "Maximum number of search results to return (1-20, default: 10)"
          ),
          max_tokens_per_page: external_exports.number().optional().describe(
            "Maximum number of tokens to extract per search result page (256-2048, default: 2048)"
          ),
          max_tokens: external_exports.number().optional().describe(
            "Maximum total tokens across all search results (default: 25000, max: 1000000)"
          ),
          country: external_exports.string().optional().describe(
            "Two-letter ISO 3166-1 alpha-2 country code for regional search results (e.g., 'US', 'GB', 'FR')"
          ),
          search_domain_filter: external_exports.array(external_exports.string()).optional().describe(
            "List of domains to include or exclude from search results (max 20). To include: ['nature.com', 'science.org']. To exclude: ['-example.com', '-spam.net']"
          ),
          search_language_filter: external_exports.array(external_exports.string()).optional().describe(
            "List of ISO 639-1 language codes to filter results (max 10, lowercase). Examples: ['en', 'fr', 'de']"
          ),
          search_after_date: external_exports.string().optional().describe(
            "Include only results published after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
          ),
          search_before_date: external_exports.string().optional().describe(
            "Include only results published before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
          ),
          last_updated_after_filter: external_exports.string().optional().describe(
            "Include only results last updated after this date. Format: 'MM/DD/YYYY' (e.g., '3/1/2025'). Cannot be used with search_recency_filter."
          ),
          last_updated_before_filter: external_exports.string().optional().describe(
            "Include only results last updated before this date. Format: 'MM/DD/YYYY' (e.g., '3/15/2025'). Cannot be used with search_recency_filter."
          ),
          search_recency_filter: external_exports.enum(["day", "week", "month", "year"]).optional().describe(
            "Filter results by relative time period. Cannot be used with search_after_date or search_before_date."
          )
        })
      )
    );
    perplexitySearchOutputSchema = lazySchema(
      () => zodSchema(
        external_exports.union([
          // Success response
          external_exports.object({
            results: external_exports.array(
              external_exports.object({
                title: external_exports.string(),
                url: external_exports.string(),
                snippet: external_exports.string(),
                date: external_exports.string().optional(),
                lastUpdated: external_exports.string().optional()
              })
            ),
            id: external_exports.string()
          }),
          // Error response
          external_exports.object({
            error: external_exports.enum([
              "api_error",
              "rate_limit",
              "timeout",
              "invalid_input",
              "unknown"
            ]),
            statusCode: external_exports.number().optional(),
            message: external_exports.string()
          })
        ])
      )
    );
    perplexitySearchToolFactory = createProviderToolFactoryWithOutputSchema({
      id: "gateway.perplexity_search",
      inputSchema: perplexitySearchInputSchema,
      outputSchema: perplexitySearchOutputSchema
    });
    perplexitySearch = (config3 = {}) => perplexitySearchToolFactory(config3);
    gatewayTools = {
      /**
       * Search the web using Parallel AI's Search API for LLM-optimized excerpts.
       *
       * Takes a natural language objective and returns relevant excerpts,
       * replacing multiple keyword searches with a single call for broad
       * or complex queries. Supports different search types for depth vs
       * breadth tradeoffs.
       */
      parallelSearch,
      /**
       * Search the web using Perplexity's Search API for real-time information,
       * news, research papers, and articles.
       *
       * Provides ranked search results with advanced filtering options including
       * domain, language, date range, and recency filters.
       */
      perplexitySearch
    };
    VERSION13 = true ? "3.0.83" : "0.0.0-test";
    AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
    gateway = createGatewayProvider();
  }
});

// node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
var _globalThis;
var init_globalThis = __esm({
  "node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js"() {
    "use strict";
    _globalThis = typeof globalThis === "object" ? globalThis : global;
  }
});

// node_modules/@opentelemetry/api/build/esm/platform/node/index.js
var init_node2 = __esm({
  "node_modules/@opentelemetry/api/build/esm/platform/node/index.js"() {
    "use strict";
    init_globalThis();
  }
});

// node_modules/@opentelemetry/api/build/esm/platform/index.js
var init_platform2 = __esm({
  "node_modules/@opentelemetry/api/build/esm/platform/index.js"() {
    "use strict";
    init_node2();
  }
});

// node_modules/@opentelemetry/api/build/esm/version.js
var VERSION14;
var init_version = __esm({
  "node_modules/@opentelemetry/api/build/esm/version.js"() {
    "use strict";
    VERSION14 = "1.9.0";
  }
});

// node_modules/@opentelemetry/api/build/esm/internal/semver.js
function _makeCompatibilityCheck(ownVersion) {
  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
  var rejectedVersions = /* @__PURE__ */ new Set();
  var myVersionMatch = ownVersion.match(re);
  if (!myVersionMatch) {
    return function() {
      return false;
    };
  }
  var ownVersionParsed = {
    major: +myVersionMatch[1],
    minor: +myVersionMatch[2],
    patch: +myVersionMatch[3],
    prerelease: myVersionMatch[4]
  };
  if (ownVersionParsed.prerelease != null) {
    return function isExactmatch(globalVersion) {
      return globalVersion === ownVersion;
    };
  }
  function _reject(v) {
    rejectedVersions.add(v);
    return false;
  }
  function _accept(v) {
    acceptedVersions.add(v);
    return true;
  }
  return function isCompatible2(globalVersion) {
    if (acceptedVersions.has(globalVersion)) {
      return true;
    }
    if (rejectedVersions.has(globalVersion)) {
      return false;
    }
    var globalVersionMatch = globalVersion.match(re);
    if (!globalVersionMatch) {
      return _reject(globalVersion);
    }
    var globalVersionParsed = {
      major: +globalVersionMatch[1],
      minor: +globalVersionMatch[2],
      patch: +globalVersionMatch[3],
      prerelease: globalVersionMatch[4]
    };
    if (globalVersionParsed.prerelease != null) {
      return _reject(globalVersion);
    }
    if (ownVersionParsed.major !== globalVersionParsed.major) {
      return _reject(globalVersion);
    }
    if (ownVersionParsed.major === 0) {
      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
        return _accept(globalVersion);
      }
      return _reject(globalVersion);
    }
    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
      return _accept(globalVersion);
    }
    return _reject(globalVersion);
  };
}
var re, isCompatible;
var init_semver = __esm({
  "node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
    "use strict";
    init_version();
    re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
    isCompatible = _makeCompatibilityCheck(VERSION14);
  }
});

// node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
function registerGlobal(type, instance, diag, allowOverride) {
  var _a31;
  if (allowOverride === void 0) {
    allowOverride = false;
  }
  var api = _global2[GLOBAL_OPENTELEMETRY_API_KEY] = (_a31 = _global2[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a31 !== void 0 ? _a31 : {
    version: VERSION14
  };
  if (!allowOverride && api[type]) {
    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
    diag.error(err.stack || err.message);
    return false;
  }
  if (api.version !== VERSION14) {
    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION14);
    diag.error(err.stack || err.message);
    return false;
  }
  api[type] = instance;
  diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION14 + ".");
  return true;
}
function getGlobal2(type) {
  var _a31, _b27;
  var globalVersion = (_a31 = _global2[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a31 === void 0 ? void 0 : _a31.version;
  if (!globalVersion || !isCompatible(globalVersion)) {
    return;
  }
  return (_b27 = _global2[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b27 === void 0 ? void 0 : _b27[type];
}
function unregisterGlobal(type, diag) {
  diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION14 + ".");
  var api = _global2[GLOBAL_OPENTELEMETRY_API_KEY];
  if (api) {
    delete api[type];
  }
}
var major, GLOBAL_OPENTELEMETRY_API_KEY, _global2;
var init_global_utils = __esm({
  "node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
    "use strict";
    init_platform2();
    init_version();
    init_semver();
    major = VERSION14.split(".")[0];
    GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for("opentelemetry.js.api." + major);
    _global2 = _globalThis;
  }
});

// node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
function logProxy(funcName, namespace, args) {
  var logger3 = getGlobal2("diag");
  if (!logger3) {
    return;
  }
  args.unshift(namespace);
  return logger3[funcName].apply(logger3, __spreadArray([], __read(args), false));
}
var __read, __spreadArray, DiagComponentLogger;
var init_ComponentLogger = __esm({
  "node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() {
    "use strict";
    init_global_utils();
    __read = function(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      } catch (error73) {
        e = { error: error73 };
      } finally {
        try {
          if (r && !r.done && (m = i["return"])) m.call(i);
        } finally {
          if (e) throw e.error;
        }
      }
      return ar;
    };
    __spreadArray = function(to, from, pack) {
      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
          ar[i] = from[i];
        }
      }
      return to.concat(ar || Array.prototype.slice.call(from));
    };
    DiagComponentLogger = /** @class */
    (function() {
      function DiagComponentLogger2(props) {
        this._namespace = props.namespace || "DiagComponentLogger";
      }
      DiagComponentLogger2.prototype.debug = function() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          args[_i] = arguments[_i];
        }
        return logProxy("debug", this._namespace, args);
      };
      DiagComponentLogger2.prototype.error = function() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          args[_i] = arguments[_i];
        }
        return logProxy("error", this._namespace, args);
      };
      DiagComponentLogger2.prototype.info = function() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          args[_i] = arguments[_i];
        }
        return logProxy("info", this._namespace, args);
      };
      DiagComponentLogger2.prototype.warn = function() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          args[_i] = arguments[_i];
        }
        return logProxy("warn", this._namespace, args);
      };
      DiagComponentLogger2.prototype.verbose = function() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          args[_i] = arguments[_i];
        }
        return logProxy("verbose", this._namespace, args);
      };
      return DiagComponentLogger2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/diag/types.js
var DiagLogLevel;
var init_types2 = __esm({
  "node_modules/@opentelemetry/api/build/esm/diag/types.js"() {
    "use strict";
    (function(DiagLogLevel2) {
      DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
      DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
      DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
      DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
      DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
      DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
      DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
    })(DiagLogLevel || (DiagLogLevel = {}));
  }
});

// node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
function createLogLevelDiagLogger(maxLevel, logger3) {
  if (maxLevel < DiagLogLevel.NONE) {
    maxLevel = DiagLogLevel.NONE;
  } else if (maxLevel > DiagLogLevel.ALL) {
    maxLevel = DiagLogLevel.ALL;
  }
  logger3 = logger3 || {};
  function _filterFunc(funcName, theLevel) {
    var theFunc = logger3[funcName];
    if (typeof theFunc === "function" && maxLevel >= theLevel) {
      return theFunc.bind(logger3);
    }
    return function() {
    };
  }
  return {
    error: _filterFunc("error", DiagLogLevel.ERROR),
    warn: _filterFunc("warn", DiagLogLevel.WARN),
    info: _filterFunc("info", DiagLogLevel.INFO),
    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
  };
}
var init_logLevelLogger = __esm({
  "node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() {
    "use strict";
    init_types2();
  }
});

// node_modules/@opentelemetry/api/build/esm/api/diag.js
var __read2, __spreadArray2, API_NAME, DiagAPI;
var init_diag = __esm({
  "node_modules/@opentelemetry/api/build/esm/api/diag.js"() {
    "use strict";
    init_ComponentLogger();
    init_logLevelLogger();
    init_types2();
    init_global_utils();
    __read2 = function(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      } catch (error73) {
        e = { error: error73 };
      } finally {
        try {
          if (r && !r.done && (m = i["return"])) m.call(i);
        } finally {
          if (e) throw e.error;
        }
      }
      return ar;
    };
    __spreadArray2 = function(to, from, pack) {
      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
          ar[i] = from[i];
        }
      }
      return to.concat(ar || Array.prototype.slice.call(from));
    };
    API_NAME = "diag";
    DiagAPI = /** @class */
    (function() {
      function DiagAPI2() {
        function _logProxy(funcName) {
          return function() {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
            }
            var logger3 = getGlobal2("diag");
            if (!logger3)
              return;
            return logger3[funcName].apply(logger3, __spreadArray2([], __read2(args), false));
          };
        }
        var self2 = this;
        var setLogger = function(logger3, optionsOrLogLevel) {
          var _a31, _b27, _c;
          if (optionsOrLogLevel === void 0) {
            optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
          }
          if (logger3 === self2) {
            var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
            self2.error((_a31 = err.stack) !== null && _a31 !== void 0 ? _a31 : err.message);
            return false;
          }
          if (typeof optionsOrLogLevel === "number") {
            optionsOrLogLevel = {
              logLevel: optionsOrLogLevel
            };
          }
          var oldLogger = getGlobal2("diag");
          var newLogger = createLogLevelDiagLogger((_b27 = optionsOrLogLevel.logLevel) !== null && _b27 !== void 0 ? _b27 : DiagLogLevel.INFO, logger3);
          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
            var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
            oldLogger.warn("Current logger will be overwritten from " + stack);
            newLogger.warn("Current logger will overwrite one already registered from " + stack);
          }
          return registerGlobal("diag", newLogger, self2, true);
        };
        self2.setLogger = setLogger;
        self2.disable = function() {
          unregisterGlobal(API_NAME, self2);
        };
        self2.createComponentLogger = function(options) {
          return new DiagComponentLogger(options);
        };
        self2.verbose = _logProxy("verbose");
        self2.debug = _logProxy("debug");
        self2.info = _logProxy("info");
        self2.warn = _logProxy("warn");
        self2.error = _logProxy("error");
      }
      DiagAPI2.instance = function() {
        if (!this._instance) {
          this._instance = new DiagAPI2();
        }
        return this._instance;
      };
      return DiagAPI2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/context/context.js
function createContextKey(description) {
  return Symbol.for(description);
}
var BaseContext, ROOT_CONTEXT;
var init_context = __esm({
  "node_modules/@opentelemetry/api/build/esm/context/context.js"() {
    "use strict";
    BaseContext = /** @class */
    /* @__PURE__ */ (function() {
      function BaseContext2(parentContext) {
        var self2 = this;
        self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
        self2.getValue = function(key) {
          return self2._currentContext.get(key);
        };
        self2.setValue = function(key, value) {
          var context2 = new BaseContext2(self2._currentContext);
          context2._currentContext.set(key, value);
          return context2;
        };
        self2.deleteValue = function(key) {
          var context2 = new BaseContext2(self2._currentContext);
          context2._currentContext.delete(key);
          return context2;
        };
      }
      return BaseContext2;
    })();
    ROOT_CONTEXT = new BaseContext();
  }
});

// node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
var __read3, __spreadArray3, NoopContextManager;
var init_NoopContextManager = __esm({
  "node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js"() {
    "use strict";
    init_context();
    __read3 = function(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      } catch (error73) {
        e = { error: error73 };
      } finally {
        try {
          if (r && !r.done && (m = i["return"])) m.call(i);
        } finally {
          if (e) throw e.error;
        }
      }
      return ar;
    };
    __spreadArray3 = function(to, from, pack) {
      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
          ar[i] = from[i];
        }
      }
      return to.concat(ar || Array.prototype.slice.call(from));
    };
    NoopContextManager = /** @class */
    (function() {
      function NoopContextManager2() {
      }
      NoopContextManager2.prototype.active = function() {
        return ROOT_CONTEXT;
      };
      NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
        var args = [];
        for (var _i = 3; _i < arguments.length; _i++) {
          args[_i - 3] = arguments[_i];
        }
        return fn.call.apply(fn, __spreadArray3([thisArg], __read3(args), false));
      };
      NoopContextManager2.prototype.bind = function(_context, target) {
        return target;
      };
      NoopContextManager2.prototype.enable = function() {
        return this;
      };
      NoopContextManager2.prototype.disable = function() {
        return this;
      };
      return NoopContextManager2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/api/context.js
var __read4, __spreadArray4, API_NAME2, NOOP_CONTEXT_MANAGER, ContextAPI;
var init_context2 = __esm({
  "node_modules/@opentelemetry/api/build/esm/api/context.js"() {
    "use strict";
    init_NoopContextManager();
    init_global_utils();
    init_diag();
    __read4 = function(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      } catch (error73) {
        e = { error: error73 };
      } finally {
        try {
          if (r && !r.done && (m = i["return"])) m.call(i);
        } finally {
          if (e) throw e.error;
        }
      }
      return ar;
    };
    __spreadArray4 = function(to, from, pack) {
      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
          ar[i] = from[i];
        }
      }
      return to.concat(ar || Array.prototype.slice.call(from));
    };
    API_NAME2 = "context";
    NOOP_CONTEXT_MANAGER = new NoopContextManager();
    ContextAPI = /** @class */
    (function() {
      function ContextAPI2() {
      }
      ContextAPI2.getInstance = function() {
        if (!this._instance) {
          this._instance = new ContextAPI2();
        }
        return this._instance;
      };
      ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
        return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
      };
      ContextAPI2.prototype.active = function() {
        return this._getContextManager().active();
      };
      ContextAPI2.prototype.with = function(context2, fn, thisArg) {
        var _a31;
        var args = [];
        for (var _i = 3; _i < arguments.length; _i++) {
          args[_i - 3] = arguments[_i];
        }
        return (_a31 = this._getContextManager()).with.apply(_a31, __spreadArray4([context2, fn, thisArg], __read4(args), false));
      };
      ContextAPI2.prototype.bind = function(context2, target) {
        return this._getContextManager().bind(context2, target);
      };
      ContextAPI2.prototype._getContextManager = function() {
        return getGlobal2(API_NAME2) || NOOP_CONTEXT_MANAGER;
      };
      ContextAPI2.prototype.disable = function() {
        this._getContextManager().disable();
        unregisterGlobal(API_NAME2, DiagAPI.instance());
      };
      return ContextAPI2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
var TraceFlags;
var init_trace_flags = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js"() {
    "use strict";
    (function(TraceFlags2) {
      TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
      TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
    })(TraceFlags || (TraceFlags = {}));
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT;
var init_invalid_span_constants = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js"() {
    "use strict";
    init_trace_flags();
    INVALID_SPANID = "0000000000000000";
    INVALID_TRACEID = "00000000000000000000000000000000";
    INVALID_SPAN_CONTEXT = {
      traceId: INVALID_TRACEID,
      spanId: INVALID_SPANID,
      traceFlags: TraceFlags.NONE
    };
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
var NonRecordingSpan;
var init_NonRecordingSpan = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js"() {
    "use strict";
    init_invalid_span_constants();
    NonRecordingSpan = /** @class */
    (function() {
      function NonRecordingSpan2(_spanContext) {
        if (_spanContext === void 0) {
          _spanContext = INVALID_SPAN_CONTEXT;
        }
        this._spanContext = _spanContext;
      }
      NonRecordingSpan2.prototype.spanContext = function() {
        return this._spanContext;
      };
      NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
        return this;
      };
      NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
        return this;
      };
      NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
        return this;
      };
      NonRecordingSpan2.prototype.addLink = function(_link) {
        return this;
      };
      NonRecordingSpan2.prototype.addLinks = function(_links) {
        return this;
      };
      NonRecordingSpan2.prototype.setStatus = function(_status) {
        return this;
      };
      NonRecordingSpan2.prototype.updateName = function(_name) {
        return this;
      };
      NonRecordingSpan2.prototype.end = function(_endTime) {
      };
      NonRecordingSpan2.prototype.isRecording = function() {
        return false;
      };
      NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
      };
      return NonRecordingSpan2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
function getSpan(context2) {
  return context2.getValue(SPAN_KEY) || void 0;
}
function getActiveSpan() {
  return getSpan(ContextAPI.getInstance().active());
}
function setSpan(context2, span) {
  return context2.setValue(SPAN_KEY, span);
}
function deleteSpan(context2) {
  return context2.deleteValue(SPAN_KEY);
}
function setSpanContext(context2, spanContext) {
  return setSpan(context2, new NonRecordingSpan(spanContext));
}
function getSpanContext(context2) {
  var _a31;
  return (_a31 = getSpan(context2)) === null || _a31 === void 0 ? void 0 : _a31.spanContext();
}
var SPAN_KEY;
var init_context_utils = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/context-utils.js"() {
    "use strict";
    init_context();
    init_NonRecordingSpan();
    init_context2();
    SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
function isValidTraceId(traceId) {
  return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
}
function isValidSpanId(spanId) {
  return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
}
function isSpanContextValid(spanContext) {
  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
}
function wrapSpanContext(spanContext) {
  return new NonRecordingSpan(spanContext);
}
var VALID_TRACEID_REGEX, VALID_SPANID_REGEX;
var init_spancontext_utils = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js"() {
    "use strict";
    init_invalid_span_constants();
    init_NonRecordingSpan();
    VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
    VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
function isSpanContext(spanContext) {
  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
}
var contextApi, NoopTracer;
var init_NoopTracer = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js"() {
    "use strict";
    init_context2();
    init_context_utils();
    init_NonRecordingSpan();
    init_spancontext_utils();
    contextApi = ContextAPI.getInstance();
    NoopTracer = /** @class */
    (function() {
      function NoopTracer2() {
      }
      NoopTracer2.prototype.startSpan = function(name28, options, context2) {
        if (context2 === void 0) {
          context2 = contextApi.active();
        }
        var root2 = Boolean(options === null || options === void 0 ? void 0 : options.root);
        if (root2) {
          return new NonRecordingSpan();
        }
        var parentFromContext = context2 && getSpanContext(context2);
        if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
          return new NonRecordingSpan(parentFromContext);
        } else {
          return new NonRecordingSpan();
        }
      };
      NoopTracer2.prototype.startActiveSpan = function(name28, arg2, arg3, arg4) {
        var opts;
        var ctx;
        var fn;
        if (arguments.length < 2) {
          return;
        } else if (arguments.length === 2) {
          fn = arg2;
        } else if (arguments.length === 3) {
          opts = arg2;
          fn = arg3;
        } else {
          opts = arg2;
          ctx = arg3;
          fn = arg4;
        }
        var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
        var span = this.startSpan(name28, opts, parentContext);
        var contextWithSpanSet = setSpan(parentContext, span);
        return contextApi.with(contextWithSpanSet, fn, void 0, span);
      };
      return NoopTracer2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
var NOOP_TRACER, ProxyTracer;
var init_ProxyTracer = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js"() {
    "use strict";
    init_NoopTracer();
    NOOP_TRACER = new NoopTracer();
    ProxyTracer = /** @class */
    (function() {
      function ProxyTracer2(_provider, name28, version3, options) {
        this._provider = _provider;
        this.name = name28;
        this.version = version3;
        this.options = options;
      }
      ProxyTracer2.prototype.startSpan = function(name28, options, context2) {
        return this._getTracer().startSpan(name28, options, context2);
      };
      ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
        var tracer = this._getTracer();
        return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
      };
      ProxyTracer2.prototype._getTracer = function() {
        if (this._delegate) {
          return this._delegate;
        }
        var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
        if (!tracer) {
          return NOOP_TRACER;
        }
        this._delegate = tracer;
        return this._delegate;
      };
      return ProxyTracer2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
var NoopTracerProvider;
var init_NoopTracerProvider = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js"() {
    "use strict";
    init_NoopTracer();
    NoopTracerProvider = /** @class */
    (function() {
      function NoopTracerProvider2() {
      }
      NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
        return new NoopTracer();
      };
      return NoopTracerProvider2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
var NOOP_TRACER_PROVIDER, ProxyTracerProvider;
var init_ProxyTracerProvider = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js"() {
    "use strict";
    init_ProxyTracer();
    init_NoopTracerProvider();
    NOOP_TRACER_PROVIDER = new NoopTracerProvider();
    ProxyTracerProvider = /** @class */
    (function() {
      function ProxyTracerProvider2() {
      }
      ProxyTracerProvider2.prototype.getTracer = function(name28, version3, options) {
        var _a31;
        return (_a31 = this.getDelegateTracer(name28, version3, options)) !== null && _a31 !== void 0 ? _a31 : new ProxyTracer(this, name28, version3, options);
      };
      ProxyTracerProvider2.prototype.getDelegate = function() {
        var _a31;
        return (_a31 = this._delegate) !== null && _a31 !== void 0 ? _a31 : NOOP_TRACER_PROVIDER;
      };
      ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
        this._delegate = delegate;
      };
      ProxyTracerProvider2.prototype.getDelegateTracer = function(name28, version3, options) {
        var _a31;
        return (_a31 = this._delegate) === null || _a31 === void 0 ? void 0 : _a31.getTracer(name28, version3, options);
      };
      return ProxyTracerProvider2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/trace/status.js
var SpanStatusCode;
var init_status = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace/status.js"() {
    "use strict";
    (function(SpanStatusCode2) {
      SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
      SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
      SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
    })(SpanStatusCode || (SpanStatusCode = {}));
  }
});

// node_modules/@opentelemetry/api/build/esm/context-api.js
var context;
var init_context_api = __esm({
  "node_modules/@opentelemetry/api/build/esm/context-api.js"() {
    "use strict";
    init_context2();
    context = ContextAPI.getInstance();
  }
});

// node_modules/@opentelemetry/api/build/esm/api/trace.js
var API_NAME3, TraceAPI;
var init_trace = __esm({
  "node_modules/@opentelemetry/api/build/esm/api/trace.js"() {
    "use strict";
    init_global_utils();
    init_ProxyTracerProvider();
    init_spancontext_utils();
    init_context_utils();
    init_diag();
    API_NAME3 = "trace";
    TraceAPI = /** @class */
    (function() {
      function TraceAPI2() {
        this._proxyTracerProvider = new ProxyTracerProvider();
        this.wrapSpanContext = wrapSpanContext;
        this.isSpanContextValid = isSpanContextValid;
        this.deleteSpan = deleteSpan;
        this.getSpan = getSpan;
        this.getActiveSpan = getActiveSpan;
        this.getSpanContext = getSpanContext;
        this.setSpan = setSpan;
        this.setSpanContext = setSpanContext;
      }
      TraceAPI2.getInstance = function() {
        if (!this._instance) {
          this._instance = new TraceAPI2();
        }
        return this._instance;
      };
      TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
        var success5 = registerGlobal(API_NAME3, this._proxyTracerProvider, DiagAPI.instance());
        if (success5) {
          this._proxyTracerProvider.setDelegate(provider);
        }
        return success5;
      };
      TraceAPI2.prototype.getTracerProvider = function() {
        return getGlobal2(API_NAME3) || this._proxyTracerProvider;
      };
      TraceAPI2.prototype.getTracer = function(name28, version3) {
        return this.getTracerProvider().getTracer(name28, version3);
      };
      TraceAPI2.prototype.disable = function() {
        unregisterGlobal(API_NAME3, DiagAPI.instance());
        this._proxyTracerProvider = new ProxyTracerProvider();
      };
      return TraceAPI2;
    })();
  }
});

// node_modules/@opentelemetry/api/build/esm/trace-api.js
var trace;
var init_trace_api = __esm({
  "node_modules/@opentelemetry/api/build/esm/trace-api.js"() {
    "use strict";
    init_trace();
    trace = TraceAPI.getInstance();
  }
});

// node_modules/@opentelemetry/api/build/esm/index.js
var init_esm = __esm({
  "node_modules/@opentelemetry/api/build/esm/index.js"() {
    "use strict";
    init_status();
    init_context_api();
    init_trace_api();
  }
});

// node_modules/ai/dist/index.mjs
function asArray(value) {
  return value === void 0 ? [] : Array.isArray(value) ? value : [value];
}
async function notify(options) {
  for (const callback of asArray(options.callbacks)) {
    if (callback == null)
      continue;
    try {
      await callback(options.event);
    } catch (_ignored) {
    }
  }
}
function formatWarning({
  warning,
  provider,
  model
}) {
  const prefix = `AI SDK Warning (${provider} / ${model}):`;
  switch (warning.type) {
    case "unsupported": {
      let message = `${prefix} The feature "${warning.feature}" is not supported.`;
      if (warning.details) {
        message += ` ${warning.details}`;
      }
      return message;
    }
    case "compatibility": {
      let message = `${prefix} The feature "${warning.feature}" is used in a compatibility mode.`;
      if (warning.details) {
        message += ` ${warning.details}`;
      }
      return message;
    }
    case "other": {
      return `${prefix} ${warning.message}`;
    }
    default: {
      return `${prefix} ${JSON.stringify(warning, null, 2)}`;
    }
  }
}
function logV2CompatibilityWarning({
  provider,
  modelId
}) {
  logWarnings({
    warnings: [
      {
        type: "compatibility",
        feature: "specificationVersion",
        details: `Using v2 specification compatibility mode. Some features may not be available.`
      }
    ],
    provider,
    model: modelId
  });
}
function asLanguageModelV3(model) {
  if (model.specificationVersion === "v3") {
    return model;
  }
  logV2CompatibilityWarning({
    provider: model.provider,
    modelId: model.modelId
  });
  return new Proxy(model, {
    get(target, prop) {
      switch (prop) {
        case "specificationVersion":
          return "v3";
        case "doGenerate":
          return async (...args) => {
            const result = await target.doGenerate(...args);
            return {
              ...result,
              finishReason: convertV2FinishReasonToV3(result.finishReason),
              usage: convertV2UsageToV3(result.usage)
            };
          };
        case "doStream":
          return async (...args) => {
            const result = await target.doStream(...args);
            return {
              ...result,
              stream: convertV2StreamToV3(result.stream)
            };
          };
        default:
          return target[prop];
      }
    }
  });
}
function convertV2StreamToV3(stream4) {
  return stream4.pipeThrough(
    new TransformStream({
      transform(chunk, controller) {
        switch (chunk.type) {
          case "finish":
            controller.enqueue({
              ...chunk,
              finishReason: convertV2FinishReasonToV3(chunk.finishReason),
              usage: convertV2UsageToV3(chunk.usage)
            });
            break;
          default:
            controller.enqueue(chunk);
            break;
        }
      }
    })
  );
}
function convertV2FinishReasonToV3(finishReason) {
  return {
    unified: finishReason === "unknown" ? "other" : finishReason,
    raw: void 0
  };
}
function convertV2UsageToV3(usage) {
  return {
    inputTokens: {
      total: usage.inputTokens,
      noCache: void 0,
      cacheRead: usage.cachedInputTokens,
      cacheWrite: void 0
    },
    outputTokens: {
      total: usage.outputTokens,
      text: void 0,
      reasoning: usage.reasoningTokens
    }
  };
}
function resolveLanguageModel(model) {
  if (typeof model !== "string") {
    if (model.specificationVersion !== "v3" && model.specificationVersion !== "v2") {
      const unsupportedModel = model;
      throw new UnsupportedModelVersionError({
        version: unsupportedModel.specificationVersion,
        provider: unsupportedModel.provider,
        modelId: unsupportedModel.modelId
      });
    }
    return asLanguageModelV3(model);
  }
  return getGlobalProvider().languageModel(model);
}
function getGlobalProvider() {
  var _a212;
  return (_a212 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a212 : gateway;
}
function getTotalTimeoutMs(timeout) {
  if (timeout == null) {
    return void 0;
  }
  if (typeof timeout === "number") {
    return timeout;
  }
  return timeout.totalMs;
}
function getStepTimeoutMs(timeout) {
  if (timeout == null || typeof timeout === "number") {
    return void 0;
  }
  return timeout.stepMs;
}
function getChunkTimeoutMs(timeout) {
  if (timeout == null || typeof timeout === "number") {
    return void 0;
  }
  return timeout.chunkMs;
}
function stripID3TagsIfPresent(data) {
  const hasId3 = typeof data === "string" && data.startsWith("SUQz") || typeof data !== "string" && data.length > 10 && data[0] === 73 && // 'I'
  data[1] === 68 && // 'D'
  data[2] === 51;
  return hasId3 ? stripID3(data) : data;
}
function detectMediaType({
  data,
  signatures
}) {
  const processedData = stripID3TagsIfPresent(data);
  const bytes = typeof processedData === "string" ? convertBase64ToUint8Array(
    processedData.substring(0, Math.min(processedData.length, 24))
  ) : processedData;
  for (const signature of signatures) {
    if (bytes.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
      (byte, index) => byte === null || bytes[index] === byte
    )) {
      return signature.mediaType;
    }
  }
  return void 0;
}
function splitDataUrl(dataUrl) {
  try {
    const [header, base64Content] = dataUrl.split(",");
    return {
      mediaType: header.split(";")[0].split(":")[1],
      base64Content
    };
  } catch (error73) {
    return {
      mediaType: void 0,
      base64Content: void 0
    };
  }
}
function convertToLanguageModelV3DataContent(content) {
  if (content instanceof Uint8Array) {
    return { data: content, mediaType: void 0 };
  }
  if (content instanceof ArrayBuffer) {
    return { data: new Uint8Array(content), mediaType: void 0 };
  }
  if (typeof content === "string") {
    try {
      content = new URL(content);
    } catch (error73) {
    }
  }
  if (content instanceof URL && content.protocol === "data:") {
    const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(
      content.toString()
    );
    if (dataUrlMediaType == null || base64Content == null) {
      throw new AISDKError({
        name: "InvalidDataContentError",
        message: `Invalid data URL format in content ${content.toString()}`
      });
    }
    return { data: base64Content, mediaType: dataUrlMediaType };
  }
  return { data: content, mediaType: void 0 };
}
function convertDataContentToBase64String(content) {
  if (typeof content === "string") {
    return content;
  }
  if (content instanceof ArrayBuffer) {
    return convertUint8ArrayToBase64(new Uint8Array(content));
  }
  return convertUint8ArrayToBase64(content);
}
async function convertToLanguageModelPrompt({
  prompt,
  supportedUrls,
  download: download2 = createDefaultDownloadFunction()
}) {
  const downloadedAssets = await downloadAssets(
    prompt.messages,
    download2,
    supportedUrls
  );
  const approvalIdToToolCallId = /* @__PURE__ */ new Map();
  for (const message of prompt.messages) {
    if (message.role === "assistant" && Array.isArray(message.content)) {
      for (const part of message.content) {
        if (part.type === "tool-approval-request" && "approvalId" in part && "toolCallId" in part) {
          approvalIdToToolCallId.set(
            part.approvalId,
            part.toolCallId
          );
        }
      }
    }
  }
  const approvedToolCallIds = /* @__PURE__ */ new Set();
  for (const message of prompt.messages) {
    if (message.role === "tool") {
      for (const part of message.content) {
        if (part.type === "tool-approval-response") {
          const toolCallId = approvalIdToToolCallId.get(part.approvalId);
          if (toolCallId) {
            approvedToolCallIds.add(toolCallId);
          }
        }
      }
    }
  }
  const messages = [
    ...prompt.system != null ? typeof prompt.system === "string" ? [{ role: "system", content: prompt.system }] : asArray(prompt.system).map((message) => ({
      role: "system",
      content: message.content,
      providerOptions: message.providerOptions
    })) : [],
    ...prompt.messages.map(
      (message) => convertToLanguageModelMessage({ message, downloadedAssets })
    )
  ];
  const combinedMessages = [];
  for (const message of messages) {
    if (message.role !== "tool") {
      combinedMessages.push(message);
      continue;
    }
    const lastCombinedMessage = combinedMessages.at(-1);
    if ((lastCombinedMessage == null ? void 0 : lastCombinedMessage.role) === "tool") {
      lastCombinedMessage.content.push(...message.content);
    } else {
      combinedMessages.push(message);
    }
  }
  const toolCallIds = /* @__PURE__ */ new Set();
  for (const message of combinedMessages) {
    switch (message.role) {
      case "assistant": {
        for (const content of message.content) {
          if (content.type === "tool-call" && !content.providerExecuted) {
            toolCallIds.add(content.toolCallId);
          }
        }
        break;
      }
      case "tool": {
        for (const content of message.content) {
          if (content.type === "tool-result") {
            toolCallIds.delete(content.toolCallId);
          }
        }
        break;
      }
      case "user":
      case "system":
        for (const id of approvedToolCallIds) {
          toolCallIds.delete(id);
        }
        if (toolCallIds.size > 0) {
          throw new MissingToolResultsError({
            toolCallIds: Array.from(toolCallIds)
          });
        }
        break;
    }
  }
  for (const id of approvedToolCallIds) {
    toolCallIds.delete(id);
  }
  if (toolCallIds.size > 0) {
    throw new MissingToolResultsError({ toolCallIds: Array.from(toolCallIds) });
  }
  return combinedMessages.filter(
    // Filter out empty tool messages (e.g. if they only contained
    // tool-approval-response parts that were removed).
    // This prevents sending invalid empty messages to the provider.
    // Note: provider-executed tool-approval-response parts are preserved.
    (message) => message.role !== "tool" || message.content.length > 0
  );
}
function convertToLanguageModelMessage({
  message,
  downloadedAssets
}) {
  const role = message.role;
  switch (role) {
    case "system": {
      return {
        role: "system",
        content: message.content,
        providerOptions: message.providerOptions
      };
    }
    case "user": {
      if (typeof message.content === "string") {
        return {
          role: "user",
          content: [{ type: "text", text: message.content }],
          providerOptions: message.providerOptions
        };
      }
      return {
        role: "user",
        content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
        providerOptions: message.providerOptions
      };
    }
    case "assistant": {
      if (typeof message.content === "string") {
        return {
          role: "assistant",
          content: [{ type: "text", text: message.content }],
          providerOptions: message.providerOptions
        };
      }
      return {
        role: "assistant",
        content: message.content.filter(
          // remove empty text parts (no text, and no provider options):
          (part) => part.type !== "text" || part.text !== "" || part.providerOptions != null
        ).filter(
          (part) => part.type !== "tool-approval-request"
        ).map((part) => {
          const providerOptions = part.providerOptions;
          switch (part.type) {
            case "file": {
              const { data, mediaType } = convertToLanguageModelV3DataContent(
                part.data
              );
              return {
                type: "file",
                data,
                filename: part.filename,
                mediaType: mediaType != null ? mediaType : part.mediaType,
                providerOptions
              };
            }
            case "reasoning": {
              return {
                type: "reasoning",
                text: part.text,
                providerOptions
              };
            }
            case "text": {
              return {
                type: "text",
                text: part.text,
                providerOptions
              };
            }
            case "tool-call": {
              return {
                type: "tool-call",
                toolCallId: part.toolCallId,
                toolName: part.toolName,
                input: part.input,
                providerExecuted: part.providerExecuted,
                providerOptions
              };
            }
            case "tool-result": {
              return {
                type: "tool-result",
                toolCallId: part.toolCallId,
                toolName: part.toolName,
                output: mapToolResultOutput(part.output),
                providerOptions
              };
            }
          }
        }),
        providerOptions: message.providerOptions
      };
    }
    case "tool": {
      return {
        role: "tool",
        content: message.content.filter(
          // Only include tool-approval-response for provider-executed tools
          (part) => part.type !== "tool-approval-response" || part.providerExecuted
        ).map((part) => {
          switch (part.type) {
            case "tool-result": {
              return {
                type: "tool-result",
                toolCallId: part.toolCallId,
                toolName: part.toolName,
                output: mapToolResultOutput(part.output),
                providerOptions: part.providerOptions
              };
            }
            case "tool-approval-response": {
              return {
                type: "tool-approval-response",
                approvalId: part.approvalId,
                approved: part.approved,
                reason: part.reason
              };
            }
          }
        }),
        providerOptions: message.providerOptions
      };
    }
    default: {
      const _exhaustiveCheck = role;
      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
    }
  }
}
async function downloadAssets(messages, download2, supportedUrls) {
  const plannedDownloads = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
    (content) => Array.isArray(content)
  ).flat().filter(
    (part) => part.type === "image" || part.type === "file"
  ).map((part) => {
    var _a212;
    const mediaType = (_a212 = part.mediaType) != null ? _a212 : part.type === "image" ? "image/*" : void 0;
    let data = part.type === "image" ? part.image : part.data;
    if (typeof data === "string") {
      try {
        data = new URL(data);
      } catch (ignored) {
      }
    }
    return { mediaType, data };
  }).filter(
    (part) => part.data instanceof URL
  ).map((part) => ({
    url: part.data,
    isUrlSupportedByModel: part.mediaType != null && isUrlSupported({
      url: part.data.toString(),
      mediaType: part.mediaType,
      supportedUrls
    })
  }));
  const downloadedFiles = await download2(plannedDownloads);
  return Object.fromEntries(
    downloadedFiles.map(
      (file3, index) => file3 == null ? null : [
        plannedDownloads[index].url.toString(),
        { data: file3.data, mediaType: file3.mediaType }
      ]
    ).filter((file3) => file3 != null)
  );
}
function convertPartToLanguageModelPart(part, downloadedAssets) {
  var _a212;
  if (part.type === "text") {
    return {
      type: "text",
      text: part.text,
      providerOptions: part.providerOptions
    };
  }
  let originalData;
  const type = part.type;
  switch (type) {
    case "image":
      originalData = part.image;
      break;
    case "file":
      originalData = part.data;
      break;
    default:
      throw new Error(`Unsupported part type: ${type}`);
  }
  const { data: convertedData, mediaType: convertedMediaType } = convertToLanguageModelV3DataContent(originalData);
  let mediaType = convertedMediaType != null ? convertedMediaType : part.mediaType;
  let data = convertedData;
  if (data instanceof URL) {
    const downloadedFile = downloadedAssets[data.toString()];
    if (downloadedFile) {
      data = downloadedFile.data;
      mediaType != null ? mediaType : mediaType = downloadedFile.mediaType;
    }
  }
  switch (type) {
    case "image": {
      if (data instanceof Uint8Array || typeof data === "string") {
        mediaType = (_a212 = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _a212 : mediaType;
      }
      return {
        type: "file",
        mediaType: mediaType != null ? mediaType : "image/*",
        // any image
        filename: void 0,
        data,
        providerOptions: part.providerOptions
      };
    }
    case "file": {
      if (mediaType == null) {
        throw new Error(`Media type is missing for file part`);
      }
      return {
        type: "file",
        mediaType,
        filename: part.filename,
        data,
        providerOptions: part.providerOptions
      };
    }
  }
}
function mapToolResultOutput(output) {
  if (output.type !== "content") {
    return output;
  }
  return {
    type: "content",
    value: output.value.map((item) => {
      if (item.type !== "media") {
        return item;
      }
      if (item.mediaType.startsWith("image/")) {
        return {
          type: "image-data",
          data: item.data,
          mediaType: item.mediaType
        };
      }
      return {
        type: "file-data",
        data: item.data,
        mediaType: item.mediaType
      };
    })
  };
}
async function createToolModelOutput({
  toolCallId,
  input,
  output,
  tool: tool22,
  errorMode
}) {
  if (errorMode === "text") {
    return { type: "error-text", value: getErrorMessage(output) };
  } else if (errorMode === "json") {
    return { type: "error-json", value: toJSONValue(output) };
  }
  if (tool22 == null ? void 0 : tool22.toModelOutput) {
    return await tool22.toModelOutput({ toolCallId, input, output });
  }
  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: toJSONValue(output) };
}
function toJSONValue(value) {
  return value === void 0 ? null : value;
}
function prepareCallSettings({
  maxOutputTokens,
  temperature,
  topP,
  topK,
  presencePenalty,
  frequencyPenalty,
  seed,
  stopSequences
}) {
  if (maxOutputTokens != null) {
    if (!Number.isInteger(maxOutputTokens)) {
      throw new InvalidArgumentError5({
        parameter: "maxOutputTokens",
        value: maxOutputTokens,
        message: "maxOutputTokens must be an integer"
      });
    }
    if (maxOutputTokens < 1) {
      throw new InvalidArgumentError5({
        parameter: "maxOutputTokens",
        value: maxOutputTokens,
        message: "maxOutputTokens must be >= 1"
      });
    }
  }
  if (temperature != null) {
    if (typeof temperature !== "number") {
      throw new InvalidArgumentError5({
        parameter: "temperature",
        value: temperature,
        message: "temperature must be a number"
      });
    }
  }
  if (topP != null) {
    if (typeof topP !== "number") {
      throw new InvalidArgumentError5({
        parameter: "topP",
        value: topP,
        message: "topP must be a number"
      });
    }
  }
  if (topK != null) {
    if (typeof topK !== "number") {
      throw new InvalidArgumentError5({
        parameter: "topK",
        value: topK,
        message: "topK must be a number"
      });
    }
  }
  if (presencePenalty != null) {
    if (typeof presencePenalty !== "number") {
      throw new InvalidArgumentError5({
        parameter: "presencePenalty",
        value: presencePenalty,
        message: "presencePenalty must be a number"
      });
    }
  }
  if (frequencyPenalty != null) {
    if (typeof frequencyPenalty !== "number") {
      throw new InvalidArgumentError5({
        parameter: "frequencyPenalty",
        value: frequencyPenalty,
        message: "frequencyPenalty must be a number"
      });
    }
  }
  if (seed != null) {
    if (!Number.isInteger(seed)) {
      throw new InvalidArgumentError5({
        parameter: "seed",
        value: seed,
        message: "seed must be an integer"
      });
    }
  }
  return {
    maxOutputTokens,
    temperature,
    topP,
    topK,
    presencePenalty,
    frequencyPenalty,
    stopSequences,
    seed
  };
}
function isNonEmptyObject(object22) {
  return object22 != null && Object.keys(object22).length > 0;
}
async function prepareToolsAndToolChoice({
  tools,
  toolChoice,
  activeTools
}) {
  if (!isNonEmptyObject(tools)) {
    return {
      tools: void 0,
      toolChoice: void 0
    };
  }
  const filteredTools = activeTools != null ? Object.entries(tools).filter(
    ([name212]) => activeTools.includes(name212)
  ) : Object.entries(tools);
  const languageModelTools = [];
  for (const [name212, tool22] of filteredTools) {
    const toolType = tool22.type;
    switch (toolType) {
      case void 0:
      case "dynamic":
      case "function":
        languageModelTools.push({
          type: "function",
          name: name212,
          description: tool22.description,
          inputSchema: await asSchema(tool22.inputSchema).jsonSchema,
          ...tool22.inputExamples != null ? { inputExamples: tool22.inputExamples } : {},
          providerOptions: tool22.providerOptions,
          ...tool22.strict != null ? { strict: tool22.strict } : {}
        });
        break;
      case "provider":
        languageModelTools.push({
          type: "provider",
          name: name212,
          id: tool22.id,
          args: tool22.args
        });
        break;
      default: {
        const exhaustiveCheck = toolType;
        throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
      }
    }
  }
  return {
    tools: languageModelTools,
    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
  };
}
async function standardizePrompt(prompt) {
  if (prompt.prompt == null && prompt.messages == null) {
    throw new InvalidPromptError({
      prompt,
      message: "prompt or messages must be defined"
    });
  }
  if (prompt.prompt != null && prompt.messages != null) {
    throw new InvalidPromptError({
      prompt,
      message: "prompt and messages cannot be defined at the same time"
    });
  }
  if (prompt.system != null && typeof prompt.system !== "string" && !asArray(prompt.system).every(
    (message) => typeof message === "object" && message !== null && "role" in message && message.role === "system"
  )) {
    throw new InvalidPromptError({
      prompt,
      message: "system must be a string, SystemModelMessage, or array of SystemModelMessage"
    });
  }
  let messages;
  if (prompt.prompt != null && typeof prompt.prompt === "string") {
    messages = [{ role: "user", content: prompt.prompt }];
  } else if (prompt.prompt != null && Array.isArray(prompt.prompt)) {
    messages = prompt.prompt;
  } else if (prompt.messages != null) {
    messages = prompt.messages;
  } else {
    throw new InvalidPromptError({
      prompt,
      message: "prompt or messages must be defined"
    });
  }
  if (messages.length === 0) {
    throw new InvalidPromptError({
      prompt,
      message: "messages must not be empty"
    });
  }
  const validationResult = await safeValidateTypes({
    value: messages,
    schema: external_exports.array(modelMessageSchema)
  });
  if (!validationResult.success) {
    throw new InvalidPromptError({
      prompt,
      message: "The messages do not match the ModelMessage[] schema.",
      cause: validationResult.error
    });
  }
  return {
    messages,
    system: prompt.system
  };
}
function wrapGatewayError(error73) {
  if (!GatewayAuthenticationError.isInstance(error73))
    return error73;
  const isProductionEnv = (process == null ? void 0 : process.env.NODE_ENV) === "production";
  const moreInfoURL = "https://ai-sdk.dev/unauthenticated-ai-gateway";
  if (isProductionEnv) {
    return new AISDKError({
      name: "GatewayError",
      message: `Unauthenticated. Configure AI_GATEWAY_API_KEY or use a provider module. Learn more: ${moreInfoURL}`
    });
  }
  return Object.assign(
    new Error(`\x1B[1m\x1B[31mUnauthenticated request to AI Gateway.\x1B[0m

To authenticate, set the \x1B[33mAI_GATEWAY_API_KEY\x1B[0m environment variable with your API key.

Alternatively, you can use a provider module instead of the AI Gateway.

Learn more: \x1B[34m${moreInfoURL}\x1B[0m

`),
    { name: "GatewayAuthenticationError" }
  );
}
function assembleOperationName({
  operationId,
  telemetry
}) {
  return {
    // standardized operation and resource name:
    "operation.name": `${operationId}${(telemetry == null ? void 0 : telemetry.functionId) != null ? ` ${telemetry.functionId}` : ""}`,
    "resource.name": telemetry == null ? void 0 : telemetry.functionId,
    // detailed, AI SDK specific data:
    "ai.operationId": operationId,
    "ai.telemetry.functionId": telemetry == null ? void 0 : telemetry.functionId
  };
}
function getBaseTelemetryAttributes({
  model,
  settings,
  telemetry,
  headers
}) {
  var _a212;
  return {
    "ai.model.provider": model.provider,
    "ai.model.id": model.modelId,
    // settings:
    ...Object.entries(settings).reduce((attributes, [key, value]) => {
      if (key === "timeout") {
        const totalTimeoutMs = getTotalTimeoutMs(
          value
        );
        if (totalTimeoutMs != null) {
          attributes[`ai.settings.${key}`] = totalTimeoutMs;
        }
      } else {
        attributes[`ai.settings.${key}`] = value;
      }
      return attributes;
    }, {}),
    // add metadata as attributes:
    ...Object.entries((_a212 = telemetry == null ? void 0 : telemetry.metadata) != null ? _a212 : {}).reduce(
      (attributes, [key, value]) => {
        attributes[`ai.telemetry.metadata.${key}`] = value;
        return attributes;
      },
      {}
    ),
    // request headers
    ...Object.entries(headers != null ? headers : {}).reduce((attributes, [key, value]) => {
      if (value !== void 0) {
        attributes[`ai.request.headers.${key}`] = value;
      }
      return attributes;
    }, {})
  };
}
function getTracer({
  isEnabled = false,
  tracer
} = {}) {
  if (!isEnabled) {
    return noopTracer;
  }
  if (tracer) {
    return tracer;
  }
  return trace.getTracer("ai");
}
async function recordSpan({
  name: name212,
  tracer,
  attributes,
  fn,
  endWhenDone = true
}) {
  return tracer.startActiveSpan(
    name212,
    { attributes: await attributes },
    async (span) => {
      const ctx = context.active();
      try {
        const result = await context.with(ctx, () => fn(span));
        if (endWhenDone) {
          span.end();
        }
        return result;
      } catch (error73) {
        try {
          recordErrorOnSpan(span, error73);
        } finally {
          span.end();
        }
        throw error73;
      }
    }
  );
}
function recordErrorOnSpan(span, error73) {
  if (error73 instanceof Error) {
    span.recordException({
      name: error73.name,
      message: error73.message,
      stack: error73.stack
    });
    span.setStatus({
      code: SpanStatusCode.ERROR,
      message: error73.message
    });
  } else {
    span.setStatus({ code: SpanStatusCode.ERROR });
  }
}
async function selectTelemetryAttributes({
  telemetry,
  attributes
}) {
  if ((telemetry == null ? void 0 : telemetry.isEnabled) !== true) {
    return {};
  }
  const resultAttributes = {};
  for (const [key, value] of Object.entries(attributes)) {
    if (value == null) {
      continue;
    }
    if (typeof value === "object" && "input" in value && typeof value.input === "function") {
      if ((telemetry == null ? void 0 : telemetry.recordInputs) === false) {
        continue;
      }
      const result = await value.input();
      if (result != null) {
        resultAttributes[key] = result;
      }
      continue;
    }
    if (typeof value === "object" && "output" in value && typeof value.output === "function") {
      if ((telemetry == null ? void 0 : telemetry.recordOutputs) === false) {
        continue;
      }
      const result = await value.output();
      if (result != null) {
        resultAttributes[key] = result;
      }
      continue;
    }
    resultAttributes[key] = value;
  }
  return resultAttributes;
}
function stringifyForTelemetry(prompt) {
  return JSON.stringify(
    prompt.map((message) => ({
      ...message,
      content: typeof message.content === "string" ? message.content : message.content.map(
        (part) => part.type === "file" ? {
          ...part,
          data: part.data instanceof Uint8Array ? convertDataContentToBase64String(part.data) : part.data
        } : part
      )
    }))
  );
}
function getGlobalTelemetryIntegrations() {
  var _a212;
  return (_a212 = globalThis.AI_SDK_TELEMETRY_INTEGRATIONS) != null ? _a212 : [];
}
function getGlobalTelemetryIntegration() {
  const globalIntegrations = getGlobalTelemetryIntegrations();
  return (integrations) => {
    const localIntegrations = asArray(integrations);
    const allIntegrations = [...globalIntegrations, ...localIntegrations];
    function createTelemetryComposite(getListenerFromIntegration) {
      const listeners = allIntegrations.map(getListenerFromIntegration).filter(Boolean);
      return async (event) => {
        for (const listener of listeners) {
          try {
            await listener(event);
          } catch (_ignored) {
          }
        }
      };
    }
    return {
      onStart: createTelemetryComposite((integration) => integration.onStart),
      onStepStart: createTelemetryComposite(
        (integration) => integration.onStepStart
      ),
      onToolCallStart: createTelemetryComposite(
        (integration) => integration.onToolCallStart
      ),
      onToolCallFinish: createTelemetryComposite(
        (integration) => integration.onToolCallFinish
      ),
      onStepFinish: createTelemetryComposite(
        (integration) => integration.onStepFinish
      ),
      onFinish: createTelemetryComposite((integration) => integration.onFinish)
    };
  };
}
function asLanguageModelUsage(usage) {
  return {
    inputTokens: usage.inputTokens.total,
    inputTokenDetails: {
      noCacheTokens: usage.inputTokens.noCache,
      cacheReadTokens: usage.inputTokens.cacheRead,
      cacheWriteTokens: usage.inputTokens.cacheWrite
    },
    outputTokens: usage.outputTokens.total,
    outputTokenDetails: {
      textTokens: usage.outputTokens.text,
      reasoningTokens: usage.outputTokens.reasoning
    },
    totalTokens: addTokenCounts(
      usage.inputTokens.total,
      usage.outputTokens.total
    ),
    raw: usage.raw,
    reasoningTokens: usage.outputTokens.reasoning,
    cachedInputTokens: usage.inputTokens.cacheRead
  };
}
function createNullLanguageModelUsage() {
  return {
    inputTokens: void 0,
    inputTokenDetails: {
      noCacheTokens: void 0,
      cacheReadTokens: void 0,
      cacheWriteTokens: void 0
    },
    outputTokens: void 0,
    outputTokenDetails: {
      textTokens: void 0,
      reasoningTokens: void 0
    },
    totalTokens: void 0,
    raw: void 0
  };
}
function addLanguageModelUsage(usage1, usage2) {
  var _a212, _b27, _c, _d, _e, _f, _g, _h, _i, _j;
  return {
    inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
    inputTokenDetails: {
      noCacheTokens: addTokenCounts(
        (_a212 = usage1.inputTokenDetails) == null ? void 0 : _a212.noCacheTokens,
        (_b27 = usage2.inputTokenDetails) == null ? void 0 : _b27.noCacheTokens
      ),
      cacheReadTokens: addTokenCounts(
        (_c = usage1.inputTokenDetails) == null ? void 0 : _c.cacheReadTokens,
        (_d = usage2.inputTokenDetails) == null ? void 0 : _d.cacheReadTokens
      ),
      cacheWriteTokens: addTokenCounts(
        (_e = usage1.inputTokenDetails) == null ? void 0 : _e.cacheWriteTokens,
        (_f = usage2.inputTokenDetails) == null ? void 0 : _f.cacheWriteTokens
      )
    },
    outputTokens: addTokenCounts(usage1.outputTokens, usage2.outputTokens),
    outputTokenDetails: {
      textTokens: addTokenCounts(
        (_g = usage1.outputTokenDetails) == null ? void 0 : _g.textTokens,
        (_h = usage2.outputTokenDetails) == null ? void 0 : _h.textTokens
      ),
      reasoningTokens: addTokenCounts(
        (_i = usage1.outputTokenDetails) == null ? void 0 : _i.reasoningTokens,
        (_j = usage2.outputTokenDetails) == null ? void 0 : _j.reasoningTokens
      )
    },
    totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens),
    reasoningTokens: addTokenCounts(
      usage1.reasoningTokens,
      usage2.reasoningTokens
    ),
    cachedInputTokens: addTokenCounts(
      usage1.cachedInputTokens,
      usage2.cachedInputTokens
    )
  };
}
function addTokenCounts(tokenCount1, tokenCount2) {
  return tokenCount1 == null && tokenCount2 == null ? void 0 : (tokenCount1 != null ? tokenCount1 : 0) + (tokenCount2 != null ? tokenCount2 : 0);
}
function mergeObjects(base, overrides) {
  if (base === void 0 && overrides === void 0) {
    return void 0;
  }
  if (base === void 0) {
    return overrides;
  }
  if (overrides === void 0) {
    return base;
  }
  const result = { ...base };
  for (const key in overrides) {
    if (Object.prototype.hasOwnProperty.call(overrides, key)) {
      const overridesValue = overrides[key];
      if (overridesValue === void 0)
        continue;
      const baseValue = key in base ? base[key] : void 0;
      const isSourceObject = overridesValue !== null && typeof overridesValue === "object" && !Array.isArray(overridesValue) && !(overridesValue instanceof Date) && !(overridesValue instanceof RegExp);
      const isTargetObject = baseValue !== null && baseValue !== void 0 && typeof baseValue === "object" && !Array.isArray(baseValue) && !(baseValue instanceof Date) && !(baseValue instanceof RegExp);
      if (isSourceObject && isTargetObject) {
        result[key] = mergeObjects(
          baseValue,
          overridesValue
        );
      } else {
        result[key] = overridesValue;
      }
    }
  }
  return result;
}
function getRetryDelayInMs({
  error: error73,
  exponentialBackoffDelay
}) {
  const headers = error73.responseHeaders;
  if (!headers)
    return exponentialBackoffDelay;
  let ms;
  const retryAfterMs = headers["retry-after-ms"];
  if (retryAfterMs) {
    const timeoutMs = parseFloat(retryAfterMs);
    if (!Number.isNaN(timeoutMs)) {
      ms = timeoutMs;
    }
  }
  const retryAfter = headers["retry-after"];
  if (retryAfter && ms === void 0) {
    const timeoutSeconds = parseFloat(retryAfter);
    if (!Number.isNaN(timeoutSeconds)) {
      ms = timeoutSeconds * 1e3;
    } else {
      ms = Date.parse(retryAfter) - Date.now();
    }
  }
  if (ms != null && !Number.isNaN(ms) && 0 <= ms && (ms < 60 * 1e3 || ms < exponentialBackoffDelay)) {
    return ms;
  }
  return exponentialBackoffDelay;
}
async function _retryWithExponentialBackoff(f, {
  maxRetries,
  delayInMs,
  backoffFactor,
  abortSignal
}, errors = []) {
  try {
    return await f();
  } catch (error73) {
    if (isAbortError(error73)) {
      throw error73;
    }
    if (maxRetries === 0) {
      throw error73;
    }
    const errorMessage = getErrorMessage2(error73);
    const newErrors = [...errors, error73];
    const tryNumber = newErrors.length;
    if (tryNumber > maxRetries) {
      throw new RetryError({
        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
        reason: "maxRetriesExceeded",
        errors: newErrors
      });
    }
    if (error73 instanceof Error && APICallError.isInstance(error73) && error73.isRetryable === true && tryNumber <= maxRetries) {
      await delay(
        getRetryDelayInMs({
          error: error73,
          exponentialBackoffDelay: delayInMs
        }),
        { abortSignal }
      );
      return _retryWithExponentialBackoff(
        f,
        {
          maxRetries,
          delayInMs: backoffFactor * delayInMs,
          backoffFactor,
          abortSignal
        },
        newErrors
      );
    }
    if (tryNumber === 1) {
      throw error73;
    }
    throw new RetryError({
      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
      reason: "errorNotRetryable",
      errors: newErrors
    });
  }
}
function prepareRetries({
  maxRetries,
  abortSignal
}) {
  if (maxRetries != null) {
    if (!Number.isInteger(maxRetries)) {
      throw new InvalidArgumentError5({
        parameter: "maxRetries",
        value: maxRetries,
        message: "maxRetries must be an integer"
      });
    }
    if (maxRetries < 0) {
      throw new InvalidArgumentError5({
        parameter: "maxRetries",
        value: maxRetries,
        message: "maxRetries must be >= 0"
      });
    }
  }
  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
  return {
    maxRetries: maxRetriesResult,
    retry: retryWithExponentialBackoffRespectingRetryHeaders({
      maxRetries: maxRetriesResult,
      abortSignal
    })
  };
}
function collectToolApprovals({
  messages
}) {
  const lastMessage = messages.at(-1);
  if ((lastMessage == null ? void 0 : lastMessage.role) != "tool") {
    return {
      approvedToolApprovals: [],
      deniedToolApprovals: []
    };
  }
  const toolCallsByToolCallId = {};
  for (const message of messages) {
    if (message.role === "assistant" && typeof message.content !== "string") {
      const content = message.content;
      for (const part of content) {
        if (part.type === "tool-call") {
          toolCallsByToolCallId[part.toolCallId] = part;
        }
      }
    }
  }
  const toolApprovalRequestsByApprovalId = {};
  for (const message of messages) {
    if (message.role === "assistant" && typeof message.content !== "string") {
      const content = message.content;
      for (const part of content) {
        if (part.type === "tool-approval-request") {
          toolApprovalRequestsByApprovalId[part.approvalId] = part;
        }
      }
    }
  }
  const toolResults = {};
  for (const part of lastMessage.content) {
    if (part.type === "tool-result") {
      toolResults[part.toolCallId] = part;
    }
  }
  const approvedToolApprovals = [];
  const deniedToolApprovals = [];
  const approvalResponses = lastMessage.content.filter(
    (part) => part.type === "tool-approval-response"
  );
  for (const approvalResponse of approvalResponses) {
    const approvalRequest = toolApprovalRequestsByApprovalId[approvalResponse.approvalId];
    if (approvalRequest == null) {
      throw new InvalidToolApprovalError({
        approvalId: approvalResponse.approvalId
      });
    }
    if (toolResults[approvalRequest.toolCallId] != null) {
      continue;
    }
    const toolCall = toolCallsByToolCallId[approvalRequest.toolCallId];
    if (toolCall == null) {
      throw new ToolCallNotFoundForApprovalError({
        toolCallId: approvalRequest.toolCallId,
        approvalId: approvalRequest.approvalId
      });
    }
    const approval = {
      approvalRequest,
      approvalResponse,
      toolCall
    };
    if (approvalResponse.approved) {
      approvedToolApprovals.push(approval);
    } else {
      deniedToolApprovals.push(approval);
    }
  }
  return { approvedToolApprovals, deniedToolApprovals };
}
function now() {
  var _a212, _b27;
  return (_b27 = (_a212 = globalThis == null ? void 0 : globalThis.performance) == null ? void 0 : _a212.now()) != null ? _b27 : Date.now();
}
async function executeToolCall({
  toolCall,
  tools,
  tracer,
  telemetry,
  messages,
  abortSignal,
  experimental_context,
  stepNumber,
  model,
  onPreliminaryToolResult,
  onToolCallStart,
  onToolCallFinish
}) {
  const { toolName, toolCallId, input } = toolCall;
  const tool22 = tools == null ? void 0 : tools[toolName];
  if ((tool22 == null ? void 0 : tool22.execute) == null) {
    return void 0;
  }
  const baseCallbackEvent = {
    stepNumber,
    model,
    toolCall,
    messages,
    abortSignal,
    functionId: telemetry == null ? void 0 : telemetry.functionId,
    metadata: telemetry == null ? void 0 : telemetry.metadata,
    experimental_context
  };
  return recordSpan({
    name: "ai.toolCall",
    attributes: selectTelemetryAttributes({
      telemetry,
      attributes: {
        ...assembleOperationName({
          operationId: "ai.toolCall",
          telemetry
        }),
        "ai.toolCall.name": toolName,
        "ai.toolCall.id": toolCallId,
        "ai.toolCall.args": {
          output: () => JSON.stringify(input)
        }
      }
    }),
    tracer,
    fn: async (span) => {
      let output;
      await notify({ event: baseCallbackEvent, callbacks: onToolCallStart });
      const startTime = now();
      try {
        const stream4 = executeTool({
          execute: tool22.execute.bind(tool22),
          input,
          options: {
            toolCallId,
            messages,
            abortSignal,
            experimental_context
          }
        });
        for await (const part of stream4) {
          if (part.type === "preliminary") {
            onPreliminaryToolResult == null ? void 0 : onPreliminaryToolResult({
              ...toolCall,
              type: "tool-result",
              output: part.output,
              preliminary: true
            });
          } else {
            output = part.output;
          }
        }
      } catch (error73) {
        const durationMs2 = now() - startTime;
        await notify({
          event: {
            ...baseCallbackEvent,
            success: false,
            error: error73,
            durationMs: durationMs2
          },
          callbacks: onToolCallFinish
        });
        recordErrorOnSpan(span, error73);
        return {
          type: "tool-error",
          toolCallId,
          toolName,
          input,
          error: error73,
          dynamic: tool22.type === "dynamic",
          ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {}
        };
      }
      const durationMs = now() - startTime;
      await notify({
        event: {
          ...baseCallbackEvent,
          success: true,
          output,
          durationMs
        },
        callbacks: onToolCallFinish
      });
      try {
        span.setAttributes(
          await selectTelemetryAttributes({
            telemetry,
            attributes: {
              "ai.toolCall.result": {
                output: () => JSON.stringify(output)
              }
            }
          })
        );
      } catch (ignored) {
      }
      return {
        type: "tool-result",
        toolCallId,
        toolName,
        input,
        output,
        dynamic: tool22.type === "dynamic",
        ...toolCall.providerMetadata != null ? { providerMetadata: toolCall.providerMetadata } : {}
      };
    }
  });
}
function extractReasoningContent(content) {
  const parts = content.filter(
    (content2) => content2.type === "reasoning"
  );
  return parts.length === 0 ? void 0 : parts.map((content2) => content2.text).join("\n");
}
function extractTextContent(content) {
  const parts = content.filter(
    (content2) => content2.type === "text"
  );
  if (parts.length === 0) {
    return void 0;
  }
  return parts.map((content2) => content2.text).join("");
}
async function isApprovalNeeded({
  tool: tool22,
  toolCall,
  messages,
  experimental_context
}) {
  if (tool22.needsApproval == null) {
    return false;
  }
  if (typeof tool22.needsApproval === "boolean") {
    return tool22.needsApproval;
  }
  return await tool22.needsApproval(toolCall.input, {
    toolCallId: toolCall.toolCallId,
    messages,
    experimental_context
  });
}
function fixJson(input) {
  const stack = ["ROOT"];
  let lastValidIndex = -1;
  let literalStart = null;
  function processValueStart(char, i, swapState) {
    {
      switch (char) {
        case '"': {
          lastValidIndex = i;
          stack.pop();
          stack.push(swapState);
          stack.push("INSIDE_STRING");
          break;
        }
        case "f":
        case "t":
        case "n": {
          lastValidIndex = i;
          literalStart = i;
          stack.pop();
          stack.push(swapState);
          stack.push("INSIDE_LITERAL");
          break;
        }
        case "-": {
          stack.pop();
          stack.push(swapState);
          stack.push("INSIDE_NUMBER");
          break;
        }
        case "0":
        case "1":
        case "2":
        case "3":
        case "4":
        case "5":
        case "6":
        case "7":
        case "8":
        case "9": {
          lastValidIndex = i;
          stack.pop();
          stack.push(swapState);
          stack.push("INSIDE_NUMBER");
          break;
        }
        case "{": {
          lastValidIndex = i;
          stack.pop();
          stack.push(swapState);
          stack.push("INSIDE_OBJECT_START");
          break;
        }
        case "[": {
          lastValidIndex = i;
          stack.pop();
          stack.push(swapState);
          stack.push("INSIDE_ARRAY_START");
          break;
        }
      }
    }
  }
  function processAfterObjectValue(char, i) {
    switch (char) {
      case ",": {
        stack.pop();
        stack.push("INSIDE_OBJECT_AFTER_COMMA");
        break;
      }
      case "}": {
        lastValidIndex = i;
        stack.pop();
        break;
      }
    }
  }
  function processAfterArrayValue(char, i) {
    switch (char) {
      case ",": {
        stack.pop();
        stack.push("INSIDE_ARRAY_AFTER_COMMA");
        break;
      }
      case "]": {
        lastValidIndex = i;
        stack.pop();
        break;
      }
    }
  }
  for (let i = 0; i < input.length; i++) {
    const char = input[i];
    const currentState = stack[stack.length - 1];
    switch (currentState) {
      case "ROOT":
        processValueStart(char, i, "FINISH");
        break;
      case "INSIDE_OBJECT_START": {
        switch (char) {
          case '"': {
            stack.pop();
            stack.push("INSIDE_OBJECT_KEY");
            break;
          }
          case "}": {
            lastValidIndex = i;
            stack.pop();
            break;
          }
        }
        break;
      }
      case "INSIDE_OBJECT_AFTER_COMMA": {
        switch (char) {
          case '"': {
            stack.pop();
            stack.push("INSIDE_OBJECT_KEY");
            break;
          }
        }
        break;
      }
      case "INSIDE_OBJECT_KEY": {
        switch (char) {
          case '"': {
            stack.pop();
            stack.push("INSIDE_OBJECT_AFTER_KEY");
            break;
          }
        }
        break;
      }
      case "INSIDE_OBJECT_AFTER_KEY": {
        switch (char) {
          case ":": {
            stack.pop();
            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
            break;
          }
        }
        break;
      }
      case "INSIDE_OBJECT_BEFORE_VALUE": {
        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
        break;
      }
      case "INSIDE_OBJECT_AFTER_VALUE": {
        processAfterObjectValue(char, i);
        break;
      }
      case "INSIDE_STRING": {
        switch (char) {
          case '"': {
            stack.pop();
            lastValidIndex = i;
            break;
          }
          case "\\": {
            stack.push("INSIDE_STRING_ESCAPE");
            break;
          }
          default: {
            lastValidIndex = i;
          }
        }
        break;
      }
      case "INSIDE_ARRAY_START": {
        switch (char) {
          case "]": {
            lastValidIndex = i;
            stack.pop();
            break;
          }
          default: {
            lastValidIndex = i;
            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
            break;
          }
        }
        break;
      }
      case "INSIDE_ARRAY_AFTER_VALUE": {
        switch (char) {
          case ",": {
            stack.pop();
            stack.push("INSIDE_ARRAY_AFTER_COMMA");
            break;
          }
          case "]": {
            lastValidIndex = i;
            stack.pop();
            break;
          }
          default: {
            lastValidIndex = i;
            break;
          }
        }
        break;
      }
      case "INSIDE_ARRAY_AFTER_COMMA": {
        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
        break;
      }
      case "INSIDE_STRING_ESCAPE": {
        stack.pop();
        lastValidIndex = i;
        break;
      }
      case "INSIDE_NUMBER": {
        switch (char) {
          case "0":
          case "1":
          case "2":
          case "3":
          case "4":
          case "5":
          case "6":
          case "7":
          case "8":
          case "9": {
            lastValidIndex = i;
            break;
          }
          case "e":
          case "E":
          case "-":
          case ".": {
            break;
          }
          case ",": {
            stack.pop();
            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
              processAfterArrayValue(char, i);
            }
            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
              processAfterObjectValue(char, i);
            }
            break;
          }
          case "}": {
            stack.pop();
            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
              processAfterObjectValue(char, i);
            }
            break;
          }
          case "]": {
            stack.pop();
            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
              processAfterArrayValue(char, i);
            }
            break;
          }
          default: {
            stack.pop();
            break;
          }
        }
        break;
      }
      case "INSIDE_LITERAL": {
        const partialLiteral = input.substring(literalStart, i + 1);
        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
          stack.pop();
          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
            processAfterObjectValue(char, i);
          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
            processAfterArrayValue(char, i);
          }
        } else {
          lastValidIndex = i;
        }
        break;
      }
    }
  }
  let result = input.slice(0, lastValidIndex + 1);
  for (let i = stack.length - 1; i >= 0; i--) {
    const state = stack[i];
    switch (state) {
      case "INSIDE_STRING": {
        result += '"';
        break;
      }
      case "INSIDE_OBJECT_KEY":
      case "INSIDE_OBJECT_AFTER_KEY":
      case "INSIDE_OBJECT_AFTER_COMMA":
      case "INSIDE_OBJECT_START":
      case "INSIDE_OBJECT_BEFORE_VALUE":
      case "INSIDE_OBJECT_AFTER_VALUE": {
        result += "}";
        break;
      }
      case "INSIDE_ARRAY_START":
      case "INSIDE_ARRAY_AFTER_COMMA":
      case "INSIDE_ARRAY_AFTER_VALUE": {
        result += "]";
        break;
      }
      case "INSIDE_LITERAL": {
        const partialLiteral = input.substring(literalStart, input.length);
        if ("true".startsWith(partialLiteral)) {
          result += "true".slice(partialLiteral.length);
        } else if ("false".startsWith(partialLiteral)) {
          result += "false".slice(partialLiteral.length);
        } else if ("null".startsWith(partialLiteral)) {
          result += "null".slice(partialLiteral.length);
        }
      }
    }
  }
  return result;
}
async function parsePartialJson(jsonText) {
  if (jsonText === void 0) {
    return { value: void 0, state: "undefined-input" };
  }
  let result = await safeParseJSON({ text: jsonText });
  if (result.success) {
    return { value: result.value, state: "successful-parse" };
  }
  result = await safeParseJSON({ text: fixJson(jsonText) });
  if (result.success) {
    return { value: result.value, state: "repaired-parse" };
  }
  return { value: void 0, state: "failed-parse" };
}
async function parseToolCall({
  toolCall,
  tools,
  repairToolCall,
  system,
  messages
}) {
  var _a212;
  try {
    if (tools == null) {
      if (toolCall.providerExecuted && toolCall.dynamic) {
        return await parseProviderExecutedDynamicToolCall(toolCall);
      }
      throw new NoSuchToolError({ toolName: toolCall.toolName });
    }
    try {
      return await doParseToolCall({ toolCall, tools });
    } catch (error73) {
      if (repairToolCall == null || !(NoSuchToolError.isInstance(error73) || InvalidToolInputError.isInstance(error73))) {
        throw error73;
      }
      let repairedToolCall = null;
      try {
        repairedToolCall = await repairToolCall({
          toolCall,
          tools,
          inputSchema: async ({ toolName }) => {
            const { inputSchema } = tools[toolName];
            return await asSchema(inputSchema).jsonSchema;
          },
          system,
          messages,
          error: error73
        });
      } catch (repairError) {
        throw new ToolCallRepairError({
          cause: repairError,
          originalError: error73
        });
      }
      if (repairedToolCall == null) {
        throw error73;
      }
      return await doParseToolCall({ toolCall: repairedToolCall, tools });
    }
  } catch (error73) {
    const parsedInput = await safeParseJSON({ text: toolCall.input });
    const input = parsedInput.success ? parsedInput.value : toolCall.input;
    return {
      type: "tool-call",
      toolCallId: toolCall.toolCallId,
      toolName: toolCall.toolName,
      input,
      dynamic: true,
      invalid: true,
      error: error73,
      title: (_a212 = tools == null ? void 0 : tools[toolCall.toolName]) == null ? void 0 : _a212.title,
      providerExecuted: toolCall.providerExecuted,
      providerMetadata: toolCall.providerMetadata
    };
  }
}
async function parseProviderExecutedDynamicToolCall(toolCall) {
  const parseResult = toolCall.input.trim() === "" ? { success: true, value: {} } : await safeParseJSON({ text: toolCall.input });
  if (parseResult.success === false) {
    throw new InvalidToolInputError({
      toolName: toolCall.toolName,
      toolInput: toolCall.input,
      cause: parseResult.error
    });
  }
  return {
    type: "tool-call",
    toolCallId: toolCall.toolCallId,
    toolName: toolCall.toolName,
    input: parseResult.value,
    providerExecuted: true,
    dynamic: true,
    providerMetadata: toolCall.providerMetadata
  };
}
async function doParseToolCall({
  toolCall,
  tools
}) {
  const toolName = toolCall.toolName;
  const tool22 = tools[toolName];
  if (tool22 == null) {
    if (toolCall.providerExecuted && toolCall.dynamic) {
      return await parseProviderExecutedDynamicToolCall(toolCall);
    }
    throw new NoSuchToolError({
      toolName: toolCall.toolName,
      availableTools: Object.keys(tools)
    });
  }
  const schema = asSchema(tool22.inputSchema);
  const parseResult = toolCall.input.trim() === "" ? await safeValidateTypes({ value: {}, schema }) : await safeParseJSON({ text: toolCall.input, schema });
  if (parseResult.success === false) {
    throw new InvalidToolInputError({
      toolName,
      toolInput: toolCall.input,
      cause: parseResult.error
    });
  }
  return tool22.type === "dynamic" ? {
    type: "tool-call",
    toolCallId: toolCall.toolCallId,
    toolName: toolCall.toolName,
    input: parseResult.value,
    providerExecuted: toolCall.providerExecuted,
    providerMetadata: toolCall.providerMetadata,
    dynamic: true,
    title: tool22.title
  } : {
    type: "tool-call",
    toolCallId: toolCall.toolCallId,
    toolName,
    input: parseResult.value,
    providerExecuted: toolCall.providerExecuted,
    providerMetadata: toolCall.providerMetadata,
    title: tool22.title
  };
}
function stepCountIs(stepCount) {
  return ({ steps }) => steps.length === stepCount;
}
async function isStopConditionMet({
  stopConditions,
  steps
}) {
  return (await Promise.all(stopConditions.map((condition) => condition({ steps })))).some((result) => result);
}
async function toResponseMessages({
  content: inputContent,
  tools
}) {
  const responseMessages = [];
  const content = [];
  for (const part of inputContent) {
    if (part.type === "source") {
      continue;
    }
    if ((part.type === "tool-result" || part.type === "tool-error") && !part.providerExecuted) {
      continue;
    }
    if (part.type === "text" && part.text.length === 0) {
      continue;
    }
    switch (part.type) {
      case "text":
        content.push({
          type: "text",
          text: part.text,
          providerOptions: part.providerMetadata
        });
        break;
      case "reasoning":
        content.push({
          type: "reasoning",
          text: part.text,
          providerOptions: part.providerMetadata
        });
        break;
      case "file":
        content.push({
          type: "file",
          data: part.file.base64,
          mediaType: part.file.mediaType,
          providerOptions: part.providerMetadata
        });
        break;
      case "tool-call":
        content.push({
          type: "tool-call",
          toolCallId: part.toolCallId,
          toolName: part.toolName,
          input: part.input,
          providerExecuted: part.providerExecuted,
          providerOptions: part.providerMetadata
        });
        break;
      case "tool-result": {
        const output = await createToolModelOutput({
          toolCallId: part.toolCallId,
          input: part.input,
          tool: tools == null ? void 0 : tools[part.toolName],
          output: part.output,
          errorMode: "none"
        });
        content.push({
          type: "tool-result",
          toolCallId: part.toolCallId,
          toolName: part.toolName,
          output,
          providerOptions: part.providerMetadata
        });
        break;
      }
      case "tool-error": {
        const output = await createToolModelOutput({
          toolCallId: part.toolCallId,
          input: part.input,
          tool: tools == null ? void 0 : tools[part.toolName],
          output: part.error,
          errorMode: "json"
        });
        content.push({
          type: "tool-result",
          toolCallId: part.toolCallId,
          toolName: part.toolName,
          output,
          providerOptions: part.providerMetadata
        });
        break;
      }
      case "tool-approval-request":
        content.push({
          type: "tool-approval-request",
          approvalId: part.approvalId,
          toolCallId: part.toolCall.toolCallId
        });
        break;
    }
  }
  if (content.length > 0) {
    responseMessages.push({
      role: "assistant",
      content
    });
  }
  const toolResultContent = [];
  for (const part of inputContent) {
    if (!(part.type === "tool-result" || part.type === "tool-error") || part.providerExecuted) {
      continue;
    }
    const output = await createToolModelOutput({
      toolCallId: part.toolCallId,
      input: part.input,
      tool: tools == null ? void 0 : tools[part.toolName],
      output: part.type === "tool-result" ? part.output : part.error,
      errorMode: part.type === "tool-error" ? "text" : "none"
    });
    toolResultContent.push({
      type: "tool-result",
      toolCallId: part.toolCallId,
      toolName: part.toolName,
      output,
      ...part.providerMetadata != null ? { providerOptions: part.providerMetadata } : {}
    });
  }
  if (toolResultContent.length > 0) {
    responseMessages.push({
      role: "tool",
      content: toolResultContent
    });
  }
  return responseMessages;
}
function mergeAbortSignals(...signals) {
  const validSignals = signals.filter(
    (signal) => signal != null
  );
  if (validSignals.length === 0) {
    return void 0;
  }
  if (validSignals.length === 1) {
    return validSignals[0];
  }
  const controller = new AbortController();
  for (const signal of validSignals) {
    if (signal.aborted) {
      controller.abort(signal.reason);
      return controller.signal;
    }
    signal.addEventListener(
      "abort",
      () => {
        controller.abort(signal.reason);
      },
      { once: true }
    );
  }
  return controller.signal;
}
async function generateText({
  model: modelArg,
  tools,
  toolChoice,
  system,
  prompt,
  messages,
  maxRetries: maxRetriesArg,
  abortSignal,
  timeout,
  headers,
  stopWhen = stepCountIs(1),
  experimental_output,
  output = experimental_output,
  experimental_telemetry: telemetry,
  providerOptions,
  experimental_activeTools,
  activeTools = experimental_activeTools,
  experimental_prepareStep,
  prepareStep = experimental_prepareStep,
  experimental_repairToolCall: repairToolCall,
  experimental_download: download2,
  experimental_context,
  experimental_include: include,
  _internal: { generateId: generateId22 = originalGenerateId } = {},
  experimental_onStart: onStart,
  experimental_onStepStart: onStepStart,
  experimental_onToolCallStart: onToolCallStart,
  experimental_onToolCallFinish: onToolCallFinish,
  onStepFinish,
  onFinish,
  ...settings
}) {
  const model = resolveLanguageModel(modelArg);
  const createGlobalTelemetry = getGlobalTelemetryIntegration();
  const stopConditions = asArray(stopWhen);
  const totalTimeoutMs = getTotalTimeoutMs(timeout);
  const stepTimeoutMs = getStepTimeoutMs(timeout);
  const stepAbortController = stepTimeoutMs != null ? new AbortController() : void 0;
  const mergedAbortSignal = mergeAbortSignals(
    abortSignal,
    totalTimeoutMs != null ? AbortSignal.timeout(totalTimeoutMs) : void 0,
    stepAbortController == null ? void 0 : stepAbortController.signal
  );
  const { maxRetries, retry } = prepareRetries({
    maxRetries: maxRetriesArg,
    abortSignal: mergedAbortSignal
  });
  const callSettings = prepareCallSettings(settings);
  const headersWithUserAgent = withUserAgentSuffix(
    headers != null ? headers : {},
    `ai/${VERSION15}`
  );
  const baseTelemetryAttributes = getBaseTelemetryAttributes({
    model,
    telemetry,
    headers: headersWithUserAgent,
    settings: { ...callSettings, maxRetries }
  });
  const modelInfo = { provider: model.provider, modelId: model.modelId };
  const initialPrompt = await standardizePrompt({
    system,
    prompt,
    messages
  });
  const globalTelemetry = createGlobalTelemetry(telemetry == null ? void 0 : telemetry.integrations);
  await notify({
    event: {
      model: modelInfo,
      system,
      prompt,
      messages,
      tools,
      toolChoice,
      activeTools,
      maxOutputTokens: callSettings.maxOutputTokens,
      temperature: callSettings.temperature,
      topP: callSettings.topP,
      topK: callSettings.topK,
      presencePenalty: callSettings.presencePenalty,
      frequencyPenalty: callSettings.frequencyPenalty,
      stopSequences: callSettings.stopSequences,
      seed: callSettings.seed,
      maxRetries,
      timeout,
      headers,
      providerOptions,
      stopWhen,
      output,
      abortSignal,
      include,
      functionId: telemetry == null ? void 0 : telemetry.functionId,
      metadata: telemetry == null ? void 0 : telemetry.metadata,
      experimental_context
    },
    callbacks: [
      onStart,
      globalTelemetry.onStart
    ]
  });
  const tracer = getTracer(telemetry);
  try {
    return await recordSpan({
      name: "ai.generateText",
      attributes: selectTelemetryAttributes({
        telemetry,
        attributes: {
          ...assembleOperationName({
            operationId: "ai.generateText",
            telemetry
          }),
          ...baseTelemetryAttributes,
          // model:
          "ai.model.provider": model.provider,
          "ai.model.id": model.modelId,
          // specific settings that only make sense on the outer level:
          "ai.prompt": {
            input: () => JSON.stringify({ system, prompt, messages })
          }
        }
      }),
      tracer,
      fn: async (span) => {
        var _a212, _b27, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
        const initialMessages = initialPrompt.messages;
        const responseMessages = [];
        const { approvedToolApprovals, deniedToolApprovals } = collectToolApprovals({ messages: initialMessages });
        const localApprovedToolApprovals = approvedToolApprovals.filter(
          (toolApproval) => !toolApproval.toolCall.providerExecuted
        );
        if (deniedToolApprovals.length > 0 || localApprovedToolApprovals.length > 0) {
          const toolOutputs = await executeTools({
            toolCalls: localApprovedToolApprovals.map(
              (toolApproval) => toolApproval.toolCall
            ),
            tools,
            tracer,
            telemetry,
            messages: initialMessages,
            abortSignal: mergedAbortSignal,
            experimental_context,
            stepNumber: 0,
            model: modelInfo,
            onToolCallStart: [
              onToolCallStart,
              globalTelemetry.onToolCallStart
            ],
            onToolCallFinish: [
              onToolCallFinish,
              globalTelemetry.onToolCallFinish
            ]
          });
          const toolContent = [];
          for (const output2 of toolOutputs) {
            const modelOutput = await createToolModelOutput({
              toolCallId: output2.toolCallId,
              input: output2.input,
              tool: tools == null ? void 0 : tools[output2.toolName],
              output: output2.type === "tool-result" ? output2.output : output2.error,
              errorMode: output2.type === "tool-error" ? "text" : "none"
            });
            toolContent.push({
              type: "tool-result",
              toolCallId: output2.toolCallId,
              toolName: output2.toolName,
              output: modelOutput
            });
          }
          for (const toolApproval of deniedToolApprovals) {
            toolContent.push({
              type: "tool-result",
              toolCallId: toolApproval.toolCall.toolCallId,
              toolName: toolApproval.toolCall.toolName,
              output: {
                type: "execution-denied",
                reason: toolApproval.approvalResponse.reason,
                // For provider-executed tools, include approvalId so provider can correlate
                ...toolApproval.toolCall.providerExecuted && {
                  providerOptions: {
                    openai: {
                      approvalId: toolApproval.approvalResponse.approvalId
                    }
                  }
                }
              }
            });
          }
          responseMessages.push({
            role: "tool",
            content: toolContent
          });
        }
        const providerExecutedToolApprovals = [
          ...approvedToolApprovals,
          ...deniedToolApprovals
        ].filter((toolApproval) => toolApproval.toolCall.providerExecuted);
        if (providerExecutedToolApprovals.length > 0) {
          responseMessages.push({
            role: "tool",
            content: providerExecutedToolApprovals.map(
              (toolApproval) => ({
                type: "tool-approval-response",
                approvalId: toolApproval.approvalResponse.approvalId,
                approved: toolApproval.approvalResponse.approved,
                reason: toolApproval.approvalResponse.reason,
                providerExecuted: true
              })
            )
          });
        }
        const callSettings2 = prepareCallSettings(settings);
        let currentModelResponse;
        let clientToolCalls = [];
        let clientToolOutputs = [];
        const steps = [];
        const pendingDeferredToolCalls = /* @__PURE__ */ new Map();
        do {
          const stepTimeoutId = stepTimeoutMs != null ? setTimeout(() => stepAbortController.abort(), stepTimeoutMs) : void 0;
          try {
            const stepInputMessages = [...initialMessages, ...responseMessages];
            const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
              model,
              steps,
              stepNumber: steps.length,
              messages: stepInputMessages,
              experimental_context
            }));
            const stepModel = resolveLanguageModel(
              (_a212 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a212 : model
            );
            const stepModelInfo = {
              provider: stepModel.provider,
              modelId: stepModel.modelId
            };
            const promptMessages = await convertToLanguageModelPrompt({
              prompt: {
                system: (_b27 = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _b27 : initialPrompt.system,
                messages: (_c = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _c : stepInputMessages
              },
              supportedUrls: await stepModel.supportedUrls,
              download: download2
            });
            experimental_context = (_d = prepareStepResult == null ? void 0 : prepareStepResult.experimental_context) != null ? _d : experimental_context;
            const stepActiveTools = (_e = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _e : activeTools;
            const { toolChoice: stepToolChoice, tools: stepTools } = await prepareToolsAndToolChoice({
              tools,
              toolChoice: (_f = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _f : toolChoice,
              activeTools: stepActiveTools
            });
            const stepMessages = (_g = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _g : stepInputMessages;
            const stepSystem = (_h = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _h : initialPrompt.system;
            const stepProviderOptions = mergeObjects(
              providerOptions,
              prepareStepResult == null ? void 0 : prepareStepResult.providerOptions
            );
            await notify({
              event: {
                stepNumber: steps.length,
                model: stepModelInfo,
                system: stepSystem,
                messages: stepMessages,
                tools,
                toolChoice: stepToolChoice,
                activeTools: stepActiveTools,
                steps: [...steps],
                providerOptions: stepProviderOptions,
                timeout,
                headers,
                stopWhen,
                output,
                abortSignal,
                include,
                functionId: telemetry == null ? void 0 : telemetry.functionId,
                metadata: telemetry == null ? void 0 : telemetry.metadata,
                experimental_context
              },
              callbacks: [
                onStepStart,
                globalTelemetry.onStepStart
              ]
            });
            currentModelResponse = await retry(
              () => {
                var _a222;
                return recordSpan({
                  name: "ai.generateText.doGenerate",
                  attributes: selectTelemetryAttributes({
                    telemetry,
                    attributes: {
                      ...assembleOperationName({
                        operationId: "ai.generateText.doGenerate",
                        telemetry
                      }),
                      ...baseTelemetryAttributes,
                      // model:
                      "ai.model.provider": stepModel.provider,
                      "ai.model.id": stepModel.modelId,
                      // prompt:
                      "ai.prompt.messages": {
                        input: () => stringifyForTelemetry(promptMessages)
                      },
                      "ai.prompt.tools": {
                        // convert the language model level tools:
                        input: () => stepTools == null ? void 0 : stepTools.map((tool22) => JSON.stringify(tool22))
                      },
                      "ai.prompt.toolChoice": {
                        input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
                      },
                      // standardized gen-ai llm span attributes:
                      "gen_ai.system": stepModel.provider,
                      "gen_ai.request.model": stepModel.modelId,
                      "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
                      "gen_ai.request.max_tokens": settings.maxOutputTokens,
                      "gen_ai.request.presence_penalty": settings.presencePenalty,
                      "gen_ai.request.stop_sequences": settings.stopSequences,
                      "gen_ai.request.temperature": (_a222 = settings.temperature) != null ? _a222 : void 0,
                      "gen_ai.request.top_k": settings.topK,
                      "gen_ai.request.top_p": settings.topP
                    }
                  }),
                  tracer,
                  fn: async (span2) => {
                    var _a232, _b28, _c2, _d2, _e2, _f2, _g2, _h2;
                    const result = await stepModel.doGenerate({
                      ...callSettings2,
                      tools: stepTools,
                      toolChoice: stepToolChoice,
                      responseFormat: await (output == null ? void 0 : output.responseFormat),
                      prompt: promptMessages,
                      providerOptions: stepProviderOptions,
                      abortSignal: mergedAbortSignal,
                      headers: headersWithUserAgent
                    });
                    const responseData = {
                      id: (_b28 = (_a232 = result.response) == null ? void 0 : _a232.id) != null ? _b28 : generateId22(),
                      timestamp: (_d2 = (_c2 = result.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : /* @__PURE__ */ new Date(),
                      modelId: (_f2 = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f2 : stepModel.modelId,
                      headers: (_g2 = result.response) == null ? void 0 : _g2.headers,
                      body: (_h2 = result.response) == null ? void 0 : _h2.body
                    };
                    const usage = asLanguageModelUsage(result.usage);
                    span2.setAttributes(
                      await selectTelemetryAttributes({
                        telemetry,
                        attributes: {
                          "ai.response.finishReason": result.finishReason.unified,
                          "ai.response.text": {
                            output: () => extractTextContent(result.content)
                          },
                          "ai.response.reasoning": {
                            output: () => extractReasoningContent(result.content)
                          },
                          "ai.response.toolCalls": {
                            output: () => {
                              const toolCalls = asToolCalls(result.content);
                              return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
                            }
                          },
                          "ai.response.id": responseData.id,
                          "ai.response.model": responseData.modelId,
                          "ai.response.timestamp": responseData.timestamp.toISOString(),
                          "ai.response.providerMetadata": JSON.stringify(
                            result.providerMetadata
                          ),
                          "ai.usage.inputTokens": result.usage.inputTokens.total,
                          "ai.usage.inputTokenDetails.noCacheTokens": result.usage.inputTokens.noCache,
                          "ai.usage.inputTokenDetails.cacheReadTokens": result.usage.inputTokens.cacheRead,
                          "ai.usage.inputTokenDetails.cacheWriteTokens": result.usage.inputTokens.cacheWrite,
                          "ai.usage.outputTokens": result.usage.outputTokens.total,
                          "ai.usage.outputTokenDetails.textTokens": result.usage.outputTokens.text,
                          "ai.usage.outputTokenDetails.reasoningTokens": result.usage.outputTokens.reasoning,
                          "ai.usage.totalTokens": usage.totalTokens,
                          "ai.usage.reasoningTokens": result.usage.outputTokens.reasoning,
                          "ai.usage.cachedInputTokens": result.usage.inputTokens.cacheRead,
                          // standardized gen-ai llm span attributes:
                          "gen_ai.response.finish_reasons": [
                            result.finishReason.unified
                          ],
                          "gen_ai.response.id": responseData.id,
                          "gen_ai.response.model": responseData.modelId,
                          "gen_ai.usage.input_tokens": result.usage.inputTokens.total,
                          "gen_ai.usage.output_tokens": result.usage.outputTokens.total
                        }
                      })
                    );
                    return { ...result, response: responseData };
                  }
                });
              }
            );
            const stepToolCalls = await Promise.all(
              currentModelResponse.content.filter(
                (part) => part.type === "tool-call"
              ).map(
                (toolCall) => parseToolCall({
                  toolCall,
                  tools,
                  repairToolCall,
                  system,
                  messages: stepInputMessages
                })
              )
            );
            const toolApprovalRequests = {};
            for (const toolCall of stepToolCalls) {
              if (toolCall.invalid) {
                continue;
              }
              const tool22 = tools == null ? void 0 : tools[toolCall.toolName];
              if (tool22 == null) {
                continue;
              }
              if ((tool22 == null ? void 0 : tool22.onInputAvailable) != null) {
                await tool22.onInputAvailable({
                  input: toolCall.input,
                  toolCallId: toolCall.toolCallId,
                  messages: stepInputMessages,
                  abortSignal: mergedAbortSignal,
                  experimental_context
                });
              }
              if (await isApprovalNeeded({
                tool: tool22,
                toolCall,
                messages: stepInputMessages,
                experimental_context
              })) {
                toolApprovalRequests[toolCall.toolCallId] = {
                  type: "tool-approval-request",
                  approvalId: generateId22(),
                  toolCall
                };
              }
            }
            const invalidToolCalls = stepToolCalls.filter(
              (toolCall) => toolCall.invalid && toolCall.dynamic
            );
            clientToolOutputs = [];
            for (const toolCall of invalidToolCalls) {
              clientToolOutputs.push({
                type: "tool-error",
                toolCallId: toolCall.toolCallId,
                toolName: toolCall.toolName,
                input: toolCall.input,
                error: getErrorMessage2(toolCall.error),
                dynamic: true
              });
            }
            clientToolCalls = stepToolCalls.filter(
              (toolCall) => !toolCall.providerExecuted
            );
            if (tools != null) {
              clientToolOutputs.push(
                ...await executeTools({
                  toolCalls: clientToolCalls.filter(
                    (toolCall) => !toolCall.invalid && toolApprovalRequests[toolCall.toolCallId] == null
                  ),
                  tools,
                  tracer,
                  telemetry,
                  messages: stepInputMessages,
                  abortSignal: mergedAbortSignal,
                  experimental_context,
                  stepNumber: steps.length,
                  model: stepModelInfo,
                  onToolCallStart: [
                    onToolCallStart,
                    globalTelemetry.onToolCallStart
                  ],
                  onToolCallFinish: [
                    onToolCallFinish,
                    globalTelemetry.onToolCallFinish
                  ]
                })
              );
            }
            for (const toolCall of stepToolCalls) {
              if (!toolCall.providerExecuted)
                continue;
              const tool22 = tools == null ? void 0 : tools[toolCall.toolName];
              if ((tool22 == null ? void 0 : tool22.type) === "provider" && tool22.supportsDeferredResults) {
                const hasResultInResponse = currentModelResponse.content.some(
                  (part) => part.type === "tool-result" && part.toolCallId === toolCall.toolCallId
                );
                if (!hasResultInResponse) {
                  pendingDeferredToolCalls.set(toolCall.toolCallId, {
                    toolName: toolCall.toolName
                  });
                }
              }
            }
            for (const part of currentModelResponse.content) {
              if (part.type === "tool-result") {
                pendingDeferredToolCalls.delete(part.toolCallId);
              }
            }
            const stepContent = asContent({
              content: currentModelResponse.content,
              toolCalls: stepToolCalls,
              toolOutputs: clientToolOutputs,
              toolApprovalRequests: Object.values(toolApprovalRequests),
              tools
            });
            responseMessages.push(
              ...await toResponseMessages({
                content: stepContent,
                tools
              })
            );
            const stepRequest = ((_i = include == null ? void 0 : include.requestBody) != null ? _i : true) ? (_j = currentModelResponse.request) != null ? _j : {} : { ...currentModelResponse.request, body: void 0 };
            const stepResponse = {
              ...currentModelResponse.response,
              // deep clone msgs to avoid mutating past messages in multi-step:
              messages: structuredClone(responseMessages),
              // Conditionally include response body:
              body: ((_k = include == null ? void 0 : include.responseBody) != null ? _k : true) ? (_l = currentModelResponse.response) == null ? void 0 : _l.body : void 0
            };
            const stepNumber = steps.length;
            const currentStepResult = new DefaultStepResult({
              stepNumber,
              model: stepModelInfo,
              functionId: telemetry == null ? void 0 : telemetry.functionId,
              metadata: telemetry == null ? void 0 : telemetry.metadata,
              experimental_context,
              content: stepContent,
              finishReason: currentModelResponse.finishReason.unified,
              rawFinishReason: currentModelResponse.finishReason.raw,
              usage: asLanguageModelUsage(currentModelResponse.usage),
              warnings: currentModelResponse.warnings,
              providerMetadata: currentModelResponse.providerMetadata,
              request: stepRequest,
              response: stepResponse
            });
            logWarnings({
              warnings: (_m = currentModelResponse.warnings) != null ? _m : [],
              provider: stepModelInfo.provider,
              model: stepModelInfo.modelId
            });
            steps.push(currentStepResult);
            await notify({
              event: currentStepResult,
              callbacks: [onStepFinish, globalTelemetry.onStepFinish]
            });
          } finally {
            if (stepTimeoutId != null) {
              clearTimeout(stepTimeoutId);
            }
          }
        } while (
          // Continue if:
          // 1. There are client tool calls that have all been executed, OR
          // 2. There are pending deferred results from provider-executed tools
          (clientToolCalls.length > 0 && clientToolOutputs.length === clientToolCalls.length || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
          !await isStopConditionMet({ stopConditions, steps })
        );
        span.setAttributes(
          await selectTelemetryAttributes({
            telemetry,
            attributes: {
              "ai.response.finishReason": currentModelResponse.finishReason.unified,
              "ai.response.text": {
                output: () => extractTextContent(currentModelResponse.content)
              },
              "ai.response.reasoning": {
                output: () => extractReasoningContent(currentModelResponse.content)
              },
              "ai.response.toolCalls": {
                output: () => {
                  const toolCalls = asToolCalls(currentModelResponse.content);
                  return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
                }
              },
              "ai.response.providerMetadata": JSON.stringify(
                currentModelResponse.providerMetadata
              )
            }
          })
        );
        const lastStep = steps[steps.length - 1];
        const totalUsage = steps.reduce(
          (totalUsage2, step) => {
            return addLanguageModelUsage(totalUsage2, step.usage);
          },
          {
            inputTokens: void 0,
            outputTokens: void 0,
            totalTokens: void 0,
            reasoningTokens: void 0,
            cachedInputTokens: void 0
          }
        );
        span.setAttributes(
          await selectTelemetryAttributes({
            telemetry,
            attributes: {
              "ai.usage.inputTokens": totalUsage.inputTokens,
              "ai.usage.inputTokenDetails.noCacheTokens": (_n = totalUsage.inputTokenDetails) == null ? void 0 : _n.noCacheTokens,
              "ai.usage.inputTokenDetails.cacheReadTokens": (_o = totalUsage.inputTokenDetails) == null ? void 0 : _o.cacheReadTokens,
              "ai.usage.inputTokenDetails.cacheWriteTokens": (_p = totalUsage.inputTokenDetails) == null ? void 0 : _p.cacheWriteTokens,
              "ai.usage.outputTokens": totalUsage.outputTokens,
              "ai.usage.outputTokenDetails.textTokens": (_q = totalUsage.outputTokenDetails) == null ? void 0 : _q.textTokens,
              "ai.usage.outputTokenDetails.reasoningTokens": (_r = totalUsage.outputTokenDetails) == null ? void 0 : _r.reasoningTokens,
              "ai.usage.totalTokens": totalUsage.totalTokens,
              "ai.usage.reasoningTokens": (_s = totalUsage.outputTokenDetails) == null ? void 0 : _s.reasoningTokens,
              "ai.usage.cachedInputTokens": (_t = totalUsage.inputTokenDetails) == null ? void 0 : _t.cacheReadTokens
            }
          })
        );
        await notify({
          event: {
            stepNumber: lastStep.stepNumber,
            model: lastStep.model,
            functionId: lastStep.functionId,
            metadata: lastStep.metadata,
            experimental_context: lastStep.experimental_context,
            finishReason: lastStep.finishReason,
            rawFinishReason: lastStep.rawFinishReason,
            usage: lastStep.usage,
            content: lastStep.content,
            text: lastStep.text,
            reasoningText: lastStep.reasoningText,
            reasoning: lastStep.reasoning,
            files: lastStep.files,
            sources: lastStep.sources,
            toolCalls: lastStep.toolCalls,
            staticToolCalls: lastStep.staticToolCalls,
            dynamicToolCalls: lastStep.dynamicToolCalls,
            toolResults: lastStep.toolResults,
            staticToolResults: lastStep.staticToolResults,
            dynamicToolResults: lastStep.dynamicToolResults,
            request: lastStep.request,
            response: lastStep.response,
            warnings: lastStep.warnings,
            providerMetadata: lastStep.providerMetadata,
            steps,
            totalUsage
          },
          callbacks: [
            onFinish,
            globalTelemetry.onFinish
          ]
        });
        let resolvedOutput;
        if (lastStep.finishReason === "stop") {
          const outputSpecification = output != null ? output : text();
          resolvedOutput = await outputSpecification.parseCompleteOutput(
            { text: lastStep.text },
            {
              response: lastStep.response,
              usage: lastStep.usage,
              finishReason: lastStep.finishReason
            }
          );
        }
        return new DefaultGenerateTextResult({
          steps,
          totalUsage,
          output: resolvedOutput
        });
      }
    });
  } catch (error73) {
    throw wrapGatewayError(error73);
  }
}
async function executeTools({
  toolCalls,
  tools,
  tracer,
  telemetry,
  messages,
  abortSignal,
  experimental_context,
  stepNumber,
  model,
  onToolCallStart,
  onToolCallFinish
}) {
  const toolOutputs = await Promise.all(
    toolCalls.map(
      async (toolCall) => executeToolCall({
        toolCall,
        tools,
        tracer,
        telemetry,
        messages,
        abortSignal,
        experimental_context,
        stepNumber,
        model,
        onToolCallStart,
        onToolCallFinish
      })
    )
  );
  return toolOutputs.filter(
    (output) => output != null
  );
}
function asToolCalls(content) {
  const parts = content.filter(
    (part) => part.type === "tool-call"
  );
  if (parts.length === 0) {
    return void 0;
  }
  return parts.map((toolCall) => ({
    toolCallId: toolCall.toolCallId,
    toolName: toolCall.toolName,
    input: toolCall.input
  }));
}
function asContent({
  content,
  toolCalls,
  toolOutputs,
  toolApprovalRequests,
  tools
}) {
  const contentParts = [];
  for (const part of content) {
    switch (part.type) {
      case "text":
      case "reasoning":
      case "source":
        contentParts.push(part);
        break;
      case "file": {
        contentParts.push({
          type: "file",
          file: new DefaultGeneratedFile(part),
          ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
        });
        break;
      }
      case "tool-call": {
        contentParts.push(
          toolCalls.find((toolCall) => toolCall.toolCallId === part.toolCallId)
        );
        break;
      }
      case "tool-result": {
        const toolCall = toolCalls.find(
          (toolCall2) => toolCall2.toolCallId === part.toolCallId
        );
        if (toolCall == null) {
          const tool22 = tools == null ? void 0 : tools[part.toolName];
          const supportsDeferredResults = (tool22 == null ? void 0 : tool22.type) === "provider" && tool22.supportsDeferredResults;
          if (!supportsDeferredResults) {
            throw new Error(`Tool call ${part.toolCallId} not found.`);
          }
          if (part.isError) {
            contentParts.push({
              type: "tool-error",
              toolCallId: part.toolCallId,
              toolName: part.toolName,
              input: void 0,
              error: part.result,
              providerExecuted: true,
              dynamic: part.dynamic,
              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
            });
          } else {
            contentParts.push({
              type: "tool-result",
              toolCallId: part.toolCallId,
              toolName: part.toolName,
              input: void 0,
              output: part.result,
              providerExecuted: true,
              dynamic: part.dynamic,
              ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
            });
          }
          break;
        }
        if (part.isError) {
          contentParts.push({
            type: "tool-error",
            toolCallId: part.toolCallId,
            toolName: part.toolName,
            input: toolCall.input,
            error: part.result,
            providerExecuted: true,
            dynamic: toolCall.dynamic,
            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
          });
        } else {
          contentParts.push({
            type: "tool-result",
            toolCallId: part.toolCallId,
            toolName: part.toolName,
            input: toolCall.input,
            output: part.result,
            providerExecuted: true,
            dynamic: toolCall.dynamic,
            ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
          });
        }
        break;
      }
      case "tool-approval-request": {
        const toolCall = toolCalls.find(
          (toolCall2) => toolCall2.toolCallId === part.toolCallId
        );
        if (toolCall == null) {
          throw new ToolCallNotFoundForApprovalError({
            toolCallId: part.toolCallId,
            approvalId: part.approvalId
          });
        }
        contentParts.push({
          type: "tool-approval-request",
          approvalId: part.approvalId,
          toolCall
        });
        break;
      }
    }
  }
  return [...contentParts, ...toolOutputs, ...toolApprovalRequests];
}
function prepareHeaders(headers, defaultHeaders) {
  const responseHeaders = new Headers(headers != null ? headers : {});
  for (const [key, value] of Object.entries(defaultHeaders)) {
    if (!responseHeaders.has(key)) {
      responseHeaders.set(key, value);
    }
  }
  return responseHeaders;
}
function createTextStreamResponse({
  status,
  statusText,
  headers,
  textStream
}) {
  return new Response(textStream.pipeThrough(new TextEncoderStream()), {
    status: status != null ? status : 200,
    statusText,
    headers: prepareHeaders(headers, {
      "content-type": "text/plain; charset=utf-8"
    })
  });
}
function writeToServerResponse({
  response,
  status,
  statusText,
  headers,
  stream: stream4
}) {
  const statusCode = status != null ? status : 200;
  if (statusText !== void 0) {
    response.writeHead(statusCode, statusText, headers);
  } else {
    response.writeHead(statusCode, headers);
  }
  const reader = stream4.getReader();
  const read = async () => {
    try {
      while (true) {
        const { done, value } = await reader.read();
        if (done)
          break;
        const canContinue = response.write(value);
        if (!canContinue) {
          await new Promise((resolve3) => {
            response.once("drain", resolve3);
          });
        }
      }
    } catch (error73) {
      throw error73;
    } finally {
      response.end();
    }
  };
  read();
}
function pipeTextStreamToResponse({
  response,
  status,
  statusText,
  headers,
  textStream
}) {
  writeToServerResponse({
    response,
    status,
    statusText,
    headers: Object.fromEntries(
      prepareHeaders(headers, {
        "content-type": "text/plain; charset=utf-8"
      }).entries()
    ),
    stream: textStream.pipeThrough(new TextEncoderStream())
  });
}
function createUIMessageStreamResponse({
  status,
  statusText,
  headers,
  stream: stream4,
  consumeSseStream
}) {
  let sseStream = stream4.pipeThrough(new JsonToSseTransformStream());
  if (consumeSseStream) {
    const [stream1, stream22] = sseStream.tee();
    sseStream = stream1;
    consumeSseStream({ stream: stream22 });
  }
  return new Response(sseStream.pipeThrough(new TextEncoderStream()), {
    status,
    statusText,
    headers: prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS)
  });
}
function getResponseUIMessageId({
  originalMessages,
  responseMessageId
}) {
  if (originalMessages == null) {
    return void 0;
  }
  const lastMessage = originalMessages[originalMessages.length - 1];
  return (lastMessage == null ? void 0 : lastMessage.role) === "assistant" ? lastMessage.id : typeof responseMessageId === "function" ? responseMessageId() : responseMessageId;
}
function isDataUIMessageChunk(chunk) {
  return chunk.type.startsWith("data-");
}
function isStaticToolUIPart(part) {
  return part.type.startsWith("tool-");
}
function isDynamicToolUIPart(part) {
  return part.type === "dynamic-tool";
}
function isToolUIPart(part) {
  return isStaticToolUIPart(part) || isDynamicToolUIPart(part);
}
function getStaticToolName(part) {
  return part.type.split("-").slice(1).join("-");
}
function createStreamingUIMessageState({
  lastMessage,
  messageId
}) {
  return {
    message: (lastMessage == null ? void 0 : lastMessage.role) === "assistant" ? lastMessage : {
      id: messageId,
      metadata: void 0,
      role: "assistant",
      parts: []
    },
    activeTextParts: {},
    activeReasoningParts: {},
    partialToolCalls: {}
  };
}
function processUIMessageStream({
  stream: stream4,
  messageMetadataSchema,
  dataPartSchemas,
  runUpdateMessageJob,
  onError,
  onToolCall,
  onData
}) {
  return stream4.pipeThrough(
    new TransformStream({
      async transform(chunk, controller) {
        await runUpdateMessageJob(async ({ state, write }) => {
          var _a212, _b27, _c, _d;
          function getToolInvocation(toolCallId) {
            const toolInvocations = state.message.parts.filter(isToolUIPart);
            const toolInvocation = toolInvocations.find(
              (invocation) => invocation.toolCallId === toolCallId
            );
            if (toolInvocation == null) {
              throw new UIMessageStreamError({
                chunkType: "tool-invocation",
                chunkId: toolCallId,
                message: `No tool invocation found for tool call ID "${toolCallId}".`
              });
            }
            return toolInvocation;
          }
          function updateToolPart(options) {
            var _a222;
            const part = state.message.parts.find(
              (part2) => isStaticToolUIPart(part2) && part2.toolCallId === options.toolCallId
            );
            const anyOptions = options;
            const anyPart = part;
            if (part != null) {
              part.state = options.state;
              anyPart.input = anyOptions.input;
              anyPart.output = anyOptions.output;
              anyPart.errorText = anyOptions.errorText;
              anyPart.rawInput = anyOptions.rawInput;
              anyPart.preliminary = anyOptions.preliminary;
              if (options.title !== void 0) {
                anyPart.title = options.title;
              }
              anyPart.providerExecuted = (_a222 = anyOptions.providerExecuted) != null ? _a222 : part.providerExecuted;
              const providerMetadata = anyOptions.providerMetadata;
              if (providerMetadata != null) {
                if (options.state === "output-available" || options.state === "output-error") {
                  const resultPart = part;
                  resultPart.resultProviderMetadata = providerMetadata;
                } else {
                  part.callProviderMetadata = providerMetadata;
                }
              }
            } else {
              state.message.parts.push({
                type: `tool-${options.toolName}`,
                toolCallId: options.toolCallId,
                state: options.state,
                title: options.title,
                input: anyOptions.input,
                output: anyOptions.output,
                rawInput: anyOptions.rawInput,
                errorText: anyOptions.errorText,
                providerExecuted: anyOptions.providerExecuted,
                preliminary: anyOptions.preliminary,
                ...anyOptions.providerMetadata != null && (options.state === "output-available" || options.state === "output-error") ? { resultProviderMetadata: anyOptions.providerMetadata } : {},
                ...anyOptions.providerMetadata != null && !(options.state === "output-available" || options.state === "output-error") ? { callProviderMetadata: anyOptions.providerMetadata } : {}
              });
            }
          }
          function updateDynamicToolPart(options) {
            var _a222, _b28;
            const part = state.message.parts.find(
              (part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId
            );
            const anyOptions = options;
            const anyPart = part;
            if (part != null) {
              part.state = options.state;
              anyPart.toolName = options.toolName;
              anyPart.input = anyOptions.input;
              anyPart.output = anyOptions.output;
              anyPart.errorText = anyOptions.errorText;
              anyPart.rawInput = (_a222 = anyOptions.rawInput) != null ? _a222 : anyPart.rawInput;
              anyPart.preliminary = anyOptions.preliminary;
              if (options.title !== void 0) {
                anyPart.title = options.title;
              }
              anyPart.providerExecuted = (_b28 = anyOptions.providerExecuted) != null ? _b28 : part.providerExecuted;
              const providerMetadata = anyOptions.providerMetadata;
              if (providerMetadata != null) {
                if (options.state === "output-available" || options.state === "output-error") {
                  const resultPart = part;
                  resultPart.resultProviderMetadata = providerMetadata;
                } else {
                  part.callProviderMetadata = providerMetadata;
                }
              }
            } else {
              state.message.parts.push({
                type: "dynamic-tool",
                toolName: options.toolName,
                toolCallId: options.toolCallId,
                state: options.state,
                input: anyOptions.input,
                output: anyOptions.output,
                errorText: anyOptions.errorText,
                preliminary: anyOptions.preliminary,
                providerExecuted: anyOptions.providerExecuted,
                title: options.title,
                ...anyOptions.providerMetadata != null && (options.state === "output-available" || options.state === "output-error") ? { resultProviderMetadata: anyOptions.providerMetadata } : {},
                ...anyOptions.providerMetadata != null && !(options.state === "output-available" || options.state === "output-error") ? { callProviderMetadata: anyOptions.providerMetadata } : {}
              });
            }
          }
          async function updateMessageMetadata(metadata) {
            if (metadata != null) {
              const mergedMetadata = state.message.metadata != null ? mergeObjects(state.message.metadata, metadata) : metadata;
              if (messageMetadataSchema != null) {
                await validateTypes({
                  value: mergedMetadata,
                  schema: messageMetadataSchema,
                  context: {
                    field: "message.metadata",
                    entityId: state.message.id
                  }
                });
              }
              state.message.metadata = mergedMetadata;
            }
          }
          switch (chunk.type) {
            case "text-start": {
              const textPart = {
                type: "text",
                text: "",
                providerMetadata: chunk.providerMetadata,
                state: "streaming"
              };
              state.activeTextParts[chunk.id] = textPart;
              state.message.parts.push(textPart);
              write();
              break;
            }
            case "text-delta": {
              const textPart = state.activeTextParts[chunk.id];
              if (textPart == null) {
                throw new UIMessageStreamError({
                  chunkType: "text-delta",
                  chunkId: chunk.id,
                  message: `Received text-delta for missing text part with ID "${chunk.id}". Ensure a "text-start" chunk is sent before any "text-delta" chunks.`
                });
              }
              textPart.text += chunk.delta;
              textPart.providerMetadata = (_a212 = chunk.providerMetadata) != null ? _a212 : textPart.providerMetadata;
              write();
              break;
            }
            case "text-end": {
              const textPart = state.activeTextParts[chunk.id];
              if (textPart == null) {
                throw new UIMessageStreamError({
                  chunkType: "text-end",
                  chunkId: chunk.id,
                  message: `Received text-end for missing text part with ID "${chunk.id}". Ensure a "text-start" chunk is sent before any "text-end" chunks.`
                });
              }
              textPart.state = "done";
              textPart.providerMetadata = (_b27 = chunk.providerMetadata) != null ? _b27 : textPart.providerMetadata;
              delete state.activeTextParts[chunk.id];
              write();
              break;
            }
            case "reasoning-start": {
              const reasoningPart = {
                type: "reasoning",
                text: "",
                providerMetadata: chunk.providerMetadata,
                state: "streaming"
              };
              state.activeReasoningParts[chunk.id] = reasoningPart;
              state.message.parts.push(reasoningPart);
              write();
              break;
            }
            case "reasoning-delta": {
              const reasoningPart = state.activeReasoningParts[chunk.id];
              if (reasoningPart == null) {
                throw new UIMessageStreamError({
                  chunkType: "reasoning-delta",
                  chunkId: chunk.id,
                  message: `Received reasoning-delta for missing reasoning part with ID "${chunk.id}". Ensure a "reasoning-start" chunk is sent before any "reasoning-delta" chunks.`
                });
              }
              reasoningPart.text += chunk.delta;
              reasoningPart.providerMetadata = (_c = chunk.providerMetadata) != null ? _c : reasoningPart.providerMetadata;
              write();
              break;
            }
            case "reasoning-end": {
              const reasoningPart = state.activeReasoningParts[chunk.id];
              if (reasoningPart == null) {
                throw new UIMessageStreamError({
                  chunkType: "reasoning-end",
                  chunkId: chunk.id,
                  message: `Received reasoning-end for missing reasoning part with ID "${chunk.id}". Ensure a "reasoning-start" chunk is sent before any "reasoning-end" chunks.`
                });
              }
              reasoningPart.providerMetadata = (_d = chunk.providerMetadata) != null ? _d : reasoningPart.providerMetadata;
              reasoningPart.state = "done";
              delete state.activeReasoningParts[chunk.id];
              write();
              break;
            }
            case "file": {
              state.message.parts.push({
                type: "file",
                mediaType: chunk.mediaType,
                url: chunk.url,
                ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
              });
              write();
              break;
            }
            case "source-url": {
              state.message.parts.push({
                type: "source-url",
                sourceId: chunk.sourceId,
                url: chunk.url,
                title: chunk.title,
                providerMetadata: chunk.providerMetadata
              });
              write();
              break;
            }
            case "source-document": {
              state.message.parts.push({
                type: "source-document",
                sourceId: chunk.sourceId,
                mediaType: chunk.mediaType,
                title: chunk.title,
                filename: chunk.filename,
                providerMetadata: chunk.providerMetadata
              });
              write();
              break;
            }
            case "tool-input-start": {
              const toolInvocations = state.message.parts.filter(isStaticToolUIPart);
              state.partialToolCalls[chunk.toolCallId] = {
                text: "",
                toolName: chunk.toolName,
                index: toolInvocations.length,
                dynamic: chunk.dynamic,
                title: chunk.title
              };
              if (chunk.dynamic) {
                updateDynamicToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: chunk.toolName,
                  state: "input-streaming",
                  input: void 0,
                  providerExecuted: chunk.providerExecuted,
                  title: chunk.title,
                  providerMetadata: chunk.providerMetadata
                });
              } else {
                updateToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: chunk.toolName,
                  state: "input-streaming",
                  input: void 0,
                  providerExecuted: chunk.providerExecuted,
                  title: chunk.title,
                  providerMetadata: chunk.providerMetadata
                });
              }
              write();
              break;
            }
            case "tool-input-delta": {
              const partialToolCall = state.partialToolCalls[chunk.toolCallId];
              if (partialToolCall == null) {
                throw new UIMessageStreamError({
                  chunkType: "tool-input-delta",
                  chunkId: chunk.toolCallId,
                  message: `Received tool-input-delta for missing tool call with ID "${chunk.toolCallId}". Ensure a "tool-input-start" chunk is sent before any "tool-input-delta" chunks.`
                });
              }
              partialToolCall.text += chunk.inputTextDelta;
              const { value: partialArgs } = await parsePartialJson(
                partialToolCall.text
              );
              if (partialToolCall.dynamic) {
                updateDynamicToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: partialToolCall.toolName,
                  state: "input-streaming",
                  input: partialArgs,
                  title: partialToolCall.title
                });
              } else {
                updateToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: partialToolCall.toolName,
                  state: "input-streaming",
                  input: partialArgs,
                  title: partialToolCall.title
                });
              }
              write();
              break;
            }
            case "tool-input-available": {
              if (chunk.dynamic) {
                updateDynamicToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: chunk.toolName,
                  state: "input-available",
                  input: chunk.input,
                  providerExecuted: chunk.providerExecuted,
                  providerMetadata: chunk.providerMetadata,
                  title: chunk.title
                });
              } else {
                updateToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: chunk.toolName,
                  state: "input-available",
                  input: chunk.input,
                  providerExecuted: chunk.providerExecuted,
                  providerMetadata: chunk.providerMetadata,
                  title: chunk.title
                });
              }
              write();
              if (onToolCall && !chunk.providerExecuted) {
                await onToolCall({
                  toolCall: chunk
                });
              }
              break;
            }
            case "tool-input-error": {
              const existingPart = state.message.parts.filter(isToolUIPart).find((p3) => p3.toolCallId === chunk.toolCallId);
              const isDynamic = existingPart != null ? existingPart.type === "dynamic-tool" : !!chunk.dynamic;
              if (isDynamic) {
                updateDynamicToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: chunk.toolName,
                  state: "output-error",
                  input: chunk.input,
                  errorText: chunk.errorText,
                  providerExecuted: chunk.providerExecuted,
                  providerMetadata: chunk.providerMetadata
                });
              } else {
                updateToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: chunk.toolName,
                  state: "output-error",
                  input: void 0,
                  rawInput: chunk.input,
                  errorText: chunk.errorText,
                  providerExecuted: chunk.providerExecuted,
                  providerMetadata: chunk.providerMetadata
                });
              }
              write();
              break;
            }
            case "tool-approval-request": {
              const toolInvocation = getToolInvocation(chunk.toolCallId);
              toolInvocation.state = "approval-requested";
              toolInvocation.approval = { id: chunk.approvalId };
              write();
              break;
            }
            case "tool-output-denied": {
              const toolInvocation = getToolInvocation(chunk.toolCallId);
              toolInvocation.state = "output-denied";
              write();
              break;
            }
            case "tool-output-available": {
              const toolInvocation = getToolInvocation(chunk.toolCallId);
              if (toolInvocation.type === "dynamic-tool") {
                updateDynamicToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: toolInvocation.toolName,
                  state: "output-available",
                  input: toolInvocation.input,
                  output: chunk.output,
                  preliminary: chunk.preliminary,
                  providerExecuted: chunk.providerExecuted,
                  providerMetadata: chunk.providerMetadata,
                  title: toolInvocation.title
                });
              } else {
                updateToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: getStaticToolName(toolInvocation),
                  state: "output-available",
                  input: toolInvocation.input,
                  output: chunk.output,
                  providerExecuted: chunk.providerExecuted,
                  preliminary: chunk.preliminary,
                  providerMetadata: chunk.providerMetadata,
                  title: toolInvocation.title
                });
              }
              write();
              break;
            }
            case "tool-output-error": {
              const toolInvocation = getToolInvocation(chunk.toolCallId);
              if (toolInvocation.type === "dynamic-tool") {
                updateDynamicToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: toolInvocation.toolName,
                  state: "output-error",
                  input: toolInvocation.input,
                  errorText: chunk.errorText,
                  providerExecuted: chunk.providerExecuted,
                  providerMetadata: chunk.providerMetadata,
                  title: toolInvocation.title
                });
              } else {
                updateToolPart({
                  toolCallId: chunk.toolCallId,
                  toolName: getStaticToolName(toolInvocation),
                  state: "output-error",
                  input: toolInvocation.input,
                  rawInput: toolInvocation.rawInput,
                  errorText: chunk.errorText,
                  providerExecuted: chunk.providerExecuted,
                  providerMetadata: chunk.providerMetadata,
                  title: toolInvocation.title
                });
              }
              write();
              break;
            }
            case "start-step": {
              state.message.parts.push({ type: "step-start" });
              break;
            }
            case "finish-step": {
              state.activeTextParts = {};
              state.activeReasoningParts = {};
              break;
            }
            case "start": {
              if (chunk.messageId != null) {
                state.message.id = chunk.messageId;
              }
              await updateMessageMetadata(chunk.messageMetadata);
              if (chunk.messageId != null || chunk.messageMetadata != null) {
                write();
              }
              break;
            }
            case "finish": {
              if (chunk.finishReason != null) {
                state.finishReason = chunk.finishReason;
              }
              await updateMessageMetadata(chunk.messageMetadata);
              if (chunk.messageMetadata != null) {
                write();
              }
              break;
            }
            case "message-metadata": {
              await updateMessageMetadata(chunk.messageMetadata);
              if (chunk.messageMetadata != null) {
                write();
              }
              break;
            }
            case "error": {
              onError == null ? void 0 : onError(new Error(chunk.errorText));
              break;
            }
            default: {
              if (isDataUIMessageChunk(chunk)) {
                if ((dataPartSchemas == null ? void 0 : dataPartSchemas[chunk.type]) != null) {
                  const partIdx = state.message.parts.findIndex(
                    (p3) => "id" in p3 && "data" in p3 && p3.id === chunk.id && p3.type === chunk.type
                  );
                  const actualPartIdx = partIdx >= 0 ? partIdx : state.message.parts.length;
                  await validateTypes({
                    value: chunk.data,
                    schema: dataPartSchemas[chunk.type],
                    context: {
                      field: `message.parts[${actualPartIdx}].data`,
                      entityName: chunk.type,
                      entityId: chunk.id
                    }
                  });
                }
                const dataChunk = chunk;
                if (dataChunk.transient) {
                  onData == null ? void 0 : onData(dataChunk);
                  break;
                }
                const existingUIPart = dataChunk.id != null ? state.message.parts.find(
                  (chunkArg) => dataChunk.type === chunkArg.type && dataChunk.id === chunkArg.id
                ) : void 0;
                if (existingUIPart != null) {
                  existingUIPart.data = dataChunk.data;
                } else {
                  state.message.parts.push(dataChunk);
                }
                onData == null ? void 0 : onData(dataChunk);
                write();
              }
            }
          }
          controller.enqueue(chunk);
        });
      }
    })
  );
}
function handleUIMessageStreamFinish({
  messageId,
  originalMessages = [],
  onStepFinish,
  onFinish,
  onError,
  stream: stream4
}) {
  let lastMessage = originalMessages == null ? void 0 : originalMessages[originalMessages.length - 1];
  if ((lastMessage == null ? void 0 : lastMessage.role) !== "assistant") {
    lastMessage = void 0;
  } else {
    messageId = lastMessage.id;
  }
  let isAborted2 = false;
  const idInjectedStream = stream4.pipeThrough(
    new TransformStream({
      transform(chunk, controller) {
        if (chunk.type === "start") {
          const startChunk = chunk;
          if (startChunk.messageId == null && messageId != null) {
            startChunk.messageId = messageId;
          }
        }
        if (chunk.type === "abort") {
          isAborted2 = true;
        }
        controller.enqueue(chunk);
      }
    })
  );
  if (onFinish == null && onStepFinish == null) {
    return idInjectedStream;
  }
  const state = createStreamingUIMessageState({
    lastMessage: lastMessage ? structuredClone(lastMessage) : void 0,
    messageId: messageId != null ? messageId : ""
    // will be overridden by the stream
  });
  const runUpdateMessageJob = async (job) => {
    await job({ state, write: () => {
    } });
  };
  let finishCalled = false;
  const callOnFinish = async () => {
    if (finishCalled || !onFinish) {
      return;
    }
    finishCalled = true;
    const isContinuation = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
    await onFinish({
      isAborted: isAborted2,
      isContinuation,
      responseMessage: state.message,
      messages: [
        ...isContinuation ? originalMessages.slice(0, -1) : originalMessages,
        state.message
      ],
      finishReason: state.finishReason
    });
  };
  const callOnStepFinish = async () => {
    if (!onStepFinish) {
      return;
    }
    const isContinuation = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
    try {
      await onStepFinish({
        isContinuation,
        responseMessage: structuredClone(state.message),
        messages: [
          ...isContinuation ? originalMessages.slice(0, -1) : originalMessages,
          structuredClone(state.message)
        ]
      });
    } catch (error73) {
      onError(error73);
    }
  };
  return processUIMessageStream({
    stream: idInjectedStream,
    runUpdateMessageJob,
    onError
  }).pipeThrough(
    new TransformStream({
      async transform(chunk, controller) {
        if (chunk.type === "finish-step") {
          await callOnStepFinish();
        }
        controller.enqueue(chunk);
      },
      // @ts-expect-error cancel is still new and missing from types https://developer.mozilla.org/en-US/docs/Web/API/TransformStream#browser_compatibility
      async cancel() {
        await callOnFinish();
      },
      async flush() {
        await callOnFinish();
      }
    })
  );
}
function pipeUIMessageStreamToResponse({
  response,
  status,
  statusText,
  headers,
  stream: stream4,
  consumeSseStream
}) {
  let sseStream = stream4.pipeThrough(new JsonToSseTransformStream());
  if (consumeSseStream) {
    const [stream1, stream22] = sseStream.tee();
    sseStream = stream1;
    consumeSseStream({ stream: stream22 });
  }
  writeToServerResponse({
    response,
    status,
    statusText,
    headers: Object.fromEntries(
      prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS).entries()
    ),
    stream: sseStream.pipeThrough(new TextEncoderStream())
  });
}
function createAsyncIterableStream(source) {
  const stream4 = source.pipeThrough(new TransformStream());
  stream4[Symbol.asyncIterator] = function() {
    const reader = this.getReader();
    let finished = false;
    async function cleanup(cancelStream) {
      var _a212;
      if (finished)
        return;
      finished = true;
      try {
        if (cancelStream) {
          await ((_a212 = reader.cancel) == null ? void 0 : _a212.call(reader));
        }
      } finally {
        try {
          reader.releaseLock();
        } catch (e) {
        }
      }
    }
    return {
      /**
       * Reads the next chunk from the stream.
       * @returns A promise resolving to the next IteratorResult.
       */
      async next() {
        if (finished) {
          return { done: true, value: void 0 };
        }
        const { done, value } = await reader.read();
        if (done) {
          await cleanup(true);
          return { done: true, value: void 0 };
        }
        return { done: false, value };
      },
      /**
       * May be called on early exit (e.g., break from for-await) or after completion.
       * Ensures the stream is cancelled and resources are released.
       * @returns A promise resolving to a completed IteratorResult.
       */
      async return() {
        await cleanup(true);
        return { done: true, value: void 0 };
      },
      /**
       * Called on early exit with error.
       * Ensures the stream is cancelled and resources are released, then rethrows the error.
       * @param err The error to throw.
       * @returns A promise that rejects with the provided error.
       */
      async throw(err) {
        await cleanup(true);
        throw err;
      }
    };
  };
  return stream4;
}
async function consumeStream({
  stream: stream4,
  onError
}) {
  const reader = stream4.getReader();
  try {
    while (true) {
      const { done } = await reader.read();
      if (done)
        break;
    }
  } catch (error73) {
    onError == null ? void 0 : onError(error73);
  } finally {
    reader.releaseLock();
  }
}
function createResolvablePromise() {
  let resolve3;
  let reject;
  const promise3 = new Promise((res, rej) => {
    resolve3 = res;
    reject = rej;
  });
  return {
    promise: promise3,
    resolve: resolve3,
    reject
  };
}
function createStitchableStream() {
  let innerStreamReaders = [];
  let controller = null;
  let isClosed = false;
  let waitForNewStream = createResolvablePromise();
  const terminate = () => {
    isClosed = true;
    waitForNewStream.resolve();
    innerStreamReaders.forEach((reader) => reader.cancel());
    innerStreamReaders = [];
    controller == null ? void 0 : controller.close();
  };
  const processPull = async () => {
    if (isClosed && innerStreamReaders.length === 0) {
      controller == null ? void 0 : controller.close();
      return;
    }
    if (innerStreamReaders.length === 0) {
      waitForNewStream = createResolvablePromise();
      await waitForNewStream.promise;
      return processPull();
    }
    try {
      const { value, done } = await innerStreamReaders[0].read();
      if (done) {
        innerStreamReaders.shift();
        if (innerStreamReaders.length === 0 && isClosed) {
          controller == null ? void 0 : controller.close();
        } else {
          await processPull();
        }
      } else {
        controller == null ? void 0 : controller.enqueue(value);
      }
    } catch (error73) {
      controller == null ? void 0 : controller.error(error73);
      innerStreamReaders.shift();
      terminate();
    }
  };
  return {
    stream: new ReadableStream({
      start(controllerParam) {
        controller = controllerParam;
      },
      pull: processPull,
      async cancel() {
        for (const reader of innerStreamReaders) {
          await reader.cancel();
        }
        innerStreamReaders = [];
        isClosed = true;
      }
    }),
    addStream: (innerStream) => {
      if (isClosed) {
        throw new Error("Cannot add inner stream: outer stream is closed");
      }
      innerStreamReaders.push(innerStream.getReader());
      waitForNewStream.resolve();
    },
    /**
     * Gracefully close the outer stream. This will let the inner streams
     * finish processing and then close the outer stream.
     */
    close: () => {
      isClosed = true;
      waitForNewStream.resolve();
      if (innerStreamReaders.length === 0) {
        controller == null ? void 0 : controller.close();
      }
    },
    /**
     * Immediately close the outer stream. This will cancel all inner streams
     * and close the outer stream.
     */
    terminate
  };
}
function runToolsTransformation({
  tools,
  generatorStream,
  tracer,
  telemetry,
  system,
  messages,
  abortSignal,
  repairToolCall,
  experimental_context,
  generateId: generateId22,
  stepNumber,
  model,
  onToolCallStart,
  onToolCallFinish
}) {
  let toolResultsStreamController = null;
  const toolResultsStream = new ReadableStream({
    start(controller) {
      toolResultsStreamController = controller;
    }
  });
  const outstandingToolResults = /* @__PURE__ */ new Set();
  const toolInputs = /* @__PURE__ */ new Map();
  const toolCallsByToolCallId = /* @__PURE__ */ new Map();
  let canClose = false;
  let finishChunk = void 0;
  function attemptClose() {
    if (canClose && outstandingToolResults.size === 0) {
      if (finishChunk != null) {
        toolResultsStreamController.enqueue(finishChunk);
      }
      toolResultsStreamController.close();
    }
  }
  const forwardStream = new TransformStream({
    async transform(chunk, controller) {
      const chunkType = chunk.type;
      switch (chunkType) {
        case "stream-start":
        case "text-start":
        case "text-delta":
        case "text-end":
        case "reasoning-start":
        case "reasoning-delta":
        case "reasoning-end":
        case "tool-input-start":
        case "tool-input-delta":
        case "tool-input-end":
        case "source":
        case "response-metadata":
        case "error":
        case "raw": {
          controller.enqueue(chunk);
          break;
        }
        case "file": {
          controller.enqueue({
            type: "file",
            file: new DefaultGeneratedFileWithType({
              data: chunk.data,
              mediaType: chunk.mediaType
            }),
            ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
          });
          break;
        }
        case "finish": {
          finishChunk = {
            type: "finish",
            finishReason: chunk.finishReason.unified,
            rawFinishReason: chunk.finishReason.raw,
            usage: asLanguageModelUsage(chunk.usage),
            providerMetadata: chunk.providerMetadata
          };
          break;
        }
        case "tool-approval-request": {
          const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
          if (toolCall == null) {
            toolResultsStreamController.enqueue({
              type: "error",
              error: new ToolCallNotFoundForApprovalError({
                toolCallId: chunk.toolCallId,
                approvalId: chunk.approvalId
              })
            });
            break;
          }
          controller.enqueue({
            type: "tool-approval-request",
            approvalId: chunk.approvalId,
            toolCall
          });
          break;
        }
        case "tool-call": {
          try {
            const toolCall = await parseToolCall({
              toolCall: chunk,
              tools,
              repairToolCall,
              system,
              messages
            });
            toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);
            controller.enqueue(toolCall);
            if (toolCall.invalid) {
              toolResultsStreamController.enqueue({
                type: "tool-error",
                toolCallId: toolCall.toolCallId,
                toolName: toolCall.toolName,
                input: toolCall.input,
                error: getErrorMessage2(toolCall.error),
                dynamic: true,
                title: toolCall.title
              });
              break;
            }
            const tool22 = tools == null ? void 0 : tools[toolCall.toolName];
            if (tool22 == null) {
              break;
            }
            if (tool22.onInputAvailable != null) {
              await tool22.onInputAvailable({
                input: toolCall.input,
                toolCallId: toolCall.toolCallId,
                messages,
                abortSignal,
                experimental_context
              });
            }
            if (await isApprovalNeeded({
              tool: tool22,
              toolCall,
              messages,
              experimental_context
            })) {
              toolResultsStreamController.enqueue({
                type: "tool-approval-request",
                approvalId: generateId22(),
                toolCall
              });
              break;
            }
            toolInputs.set(toolCall.toolCallId, toolCall.input);
            if (tool22.execute != null && toolCall.providerExecuted !== true) {
              const toolExecutionId = generateId22();
              outstandingToolResults.add(toolExecutionId);
              executeToolCall({
                toolCall,
                tools,
                tracer,
                telemetry,
                messages,
                abortSignal,
                experimental_context,
                stepNumber,
                model,
                onToolCallStart,
                onToolCallFinish,
                onPreliminaryToolResult: (result) => {
                  toolResultsStreamController.enqueue(result);
                }
              }).then((result) => {
                toolResultsStreamController.enqueue(result);
              }).catch((error73) => {
                toolResultsStreamController.enqueue({
                  type: "error",
                  error: error73
                });
              }).finally(() => {
                outstandingToolResults.delete(toolExecutionId);
                attemptClose();
              });
            }
          } catch (error73) {
            toolResultsStreamController.enqueue({ type: "error", error: error73 });
          }
          break;
        }
        case "tool-result": {
          const toolName = chunk.toolName;
          if (chunk.isError) {
            toolResultsStreamController.enqueue({
              type: "tool-error",
              toolCallId: chunk.toolCallId,
              toolName,
              input: toolInputs.get(chunk.toolCallId),
              providerExecuted: true,
              error: chunk.result,
              dynamic: chunk.dynamic,
              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
            });
          } else {
            controller.enqueue({
              type: "tool-result",
              toolCallId: chunk.toolCallId,
              toolName,
              input: toolInputs.get(chunk.toolCallId),
              output: chunk.result,
              providerExecuted: true,
              dynamic: chunk.dynamic,
              ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
            });
          }
          break;
        }
        default: {
          const _exhaustiveCheck = chunkType;
          throw new Error(`Unhandled chunk type: ${_exhaustiveCheck}`);
        }
      }
    },
    flush() {
      canClose = true;
      attemptClose();
    }
  });
  return new ReadableStream({
    async start(controller) {
      return Promise.all([
        generatorStream.pipeThrough(forwardStream).pipeTo(
          new WritableStream({
            write(chunk) {
              controller.enqueue(chunk);
            },
            close() {
            }
          })
        ),
        toolResultsStream.pipeTo(
          new WritableStream({
            write(chunk) {
              controller.enqueue(chunk);
            },
            close() {
              controller.close();
            }
          })
        )
      ]);
    }
  });
}
function streamText({
  model,
  tools,
  toolChoice,
  system,
  prompt,
  messages,
  maxRetries,
  abortSignal,
  timeout,
  headers,
  stopWhen = stepCountIs(1),
  experimental_output,
  output = experimental_output,
  experimental_telemetry: telemetry,
  prepareStep,
  providerOptions,
  experimental_activeTools,
  activeTools = experimental_activeTools,
  experimental_repairToolCall: repairToolCall,
  experimental_transform: transform8,
  experimental_download: download2,
  includeRawChunks = false,
  onChunk,
  onError = ({ error: error73 }) => {
    console.error(error73);
  },
  onFinish,
  onAbort,
  onStepFinish,
  experimental_onStart: onStart,
  experimental_onStepStart: onStepStart,
  experimental_onToolCallStart: onToolCallStart,
  experimental_onToolCallFinish: onToolCallFinish,
  experimental_context,
  experimental_include: include,
  _internal: { now: now2 = now, generateId: generateId22 = originalGenerateId2 } = {},
  ...settings
}) {
  const totalTimeoutMs = getTotalTimeoutMs(timeout);
  const stepTimeoutMs = getStepTimeoutMs(timeout);
  const chunkTimeoutMs = getChunkTimeoutMs(timeout);
  const stepAbortController = stepTimeoutMs != null ? new AbortController() : void 0;
  const chunkAbortController = chunkTimeoutMs != null ? new AbortController() : void 0;
  return new DefaultStreamTextResult({
    model: resolveLanguageModel(model),
    telemetry,
    headers,
    settings,
    maxRetries,
    abortSignal: mergeAbortSignals(
      abortSignal,
      totalTimeoutMs != null ? AbortSignal.timeout(totalTimeoutMs) : void 0,
      stepAbortController == null ? void 0 : stepAbortController.signal,
      chunkAbortController == null ? void 0 : chunkAbortController.signal
    ),
    stepTimeoutMs,
    stepAbortController,
    chunkTimeoutMs,
    chunkAbortController,
    system,
    prompt,
    messages,
    tools,
    toolChoice,
    transforms: asArray(transform8),
    activeTools,
    repairToolCall,
    stopConditions: asArray(stopWhen),
    output,
    providerOptions,
    prepareStep,
    includeRawChunks,
    timeout,
    stopWhen,
    originalAbortSignal: abortSignal,
    onChunk,
    onError,
    onFinish,
    onAbort,
    onStepFinish,
    onStart,
    onStepStart,
    onToolCallStart,
    onToolCallFinish,
    now: now2,
    generateId: generateId22,
    experimental_context,
    download: download2,
    include
  });
}
function createOutputTransformStream(output) {
  let firstTextChunkId = void 0;
  let text2 = "";
  let textChunk = "";
  let textProviderMetadata = void 0;
  let lastPublishedJson = "";
  function publishTextChunk({
    controller,
    partialOutput = void 0
  }) {
    controller.enqueue({
      part: {
        type: "text-delta",
        id: firstTextChunkId,
        text: textChunk,
        providerMetadata: textProviderMetadata
      },
      partialOutput
    });
    textChunk = "";
  }
  return new TransformStream({
    async transform(chunk, controller) {
      var _a212;
      if (chunk.type === "finish-step" && textChunk.length > 0) {
        publishTextChunk({ controller });
      }
      if (chunk.type !== "text-delta" && chunk.type !== "text-start" && chunk.type !== "text-end") {
        controller.enqueue({ part: chunk, partialOutput: void 0 });
        return;
      }
      if (firstTextChunkId == null) {
        firstTextChunkId = chunk.id;
      } else if (chunk.id !== firstTextChunkId) {
        controller.enqueue({ part: chunk, partialOutput: void 0 });
        return;
      }
      if (chunk.type === "text-start") {
        controller.enqueue({ part: chunk, partialOutput: void 0 });
        return;
      }
      if (chunk.type === "text-end") {
        if (textChunk.length > 0) {
          publishTextChunk({ controller });
        }
        controller.enqueue({ part: chunk, partialOutput: void 0 });
        return;
      }
      text2 += chunk.text;
      textChunk += chunk.text;
      textProviderMetadata = (_a212 = chunk.providerMetadata) != null ? _a212 : textProviderMetadata;
      const result = await output.parsePartialOutput({ text: text2 });
      if (result !== void 0) {
        const currentJson = JSON.stringify(result.partial);
        if (currentJson !== lastPublishedJson) {
          publishTextChunk({ controller, partialOutput: result.partial });
          lastPublishedJson = currentJson;
        }
      }
    }
  });
}
function createDownload(options) {
  return ({ url: url4, abortSignal }) => download({ url: url4, maxBytes: options == null ? void 0 : options.maxBytes, abortSignal });
}
function getPotentialStartIndex(text2, searchedText) {
  if (searchedText.length === 0) {
    return null;
  }
  const directIndex = text2.indexOf(searchedText);
  if (directIndex !== -1) {
    return directIndex;
  }
  for (let i = text2.length - 1; i >= 0; i--) {
    const suffix = text2.substring(i);
    if (searchedText.startsWith(suffix)) {
      return i;
    }
  }
  return null;
}
function extractReasoningMiddleware({
  tagName,
  separator = "\n",
  startWithReasoning = false
}) {
  const openingTag = `<${tagName}>`;
  const closingTag = `</${tagName}>`;
  return {
    specificationVersion: "v3",
    wrapGenerate: async ({ doGenerate }) => {
      const { content, ...rest } = await doGenerate();
      const transformedContent = [];
      for (const part of content) {
        if (part.type !== "text") {
          transformedContent.push(part);
          continue;
        }
        const text2 = startWithReasoning ? openingTag + part.text : part.text;
        const regexp = new RegExp(`${openingTag}(.*?)${closingTag}`, "gs");
        const matches = Array.from(text2.matchAll(regexp));
        if (!matches.length) {
          transformedContent.push(part);
          continue;
        }
        const reasoningText = matches.map((match) => match[1]).join(separator);
        let textWithoutReasoning = text2;
        for (let i = matches.length - 1; i >= 0; i--) {
          const match = matches[i];
          const beforeMatch = textWithoutReasoning.slice(0, match.index);
          const afterMatch = textWithoutReasoning.slice(
            match.index + match[0].length
          );
          textWithoutReasoning = beforeMatch + (beforeMatch.length > 0 && afterMatch.length > 0 ? separator : "") + afterMatch;
        }
        transformedContent.push({
          type: "reasoning",
          text: reasoningText
        });
        transformedContent.push({
          type: "text",
          text: textWithoutReasoning
        });
      }
      return { content: transformedContent, ...rest };
    },
    wrapStream: async ({ doStream }) => {
      const { stream: stream4, ...rest } = await doStream();
      const reasoningExtractions = {};
      let delayedTextStart;
      return {
        stream: stream4.pipeThrough(
          new TransformStream({
            transform: (chunk, controller) => {
              if (chunk.type === "text-start") {
                delayedTextStart = chunk;
                return;
              }
              if (chunk.type === "text-end" && delayedTextStart) {
                controller.enqueue(delayedTextStart);
                delayedTextStart = void 0;
              }
              if (chunk.type !== "text-delta") {
                controller.enqueue(chunk);
                return;
              }
              if (reasoningExtractions[chunk.id] == null) {
                reasoningExtractions[chunk.id] = {
                  isFirstReasoning: true,
                  isFirstText: true,
                  afterSwitch: false,
                  isReasoning: startWithReasoning,
                  buffer: "",
                  idCounter: 0,
                  textId: chunk.id
                };
              }
              const activeExtraction = reasoningExtractions[chunk.id];
              activeExtraction.buffer += chunk.delta;
              function publish(text2) {
                if (text2.length > 0) {
                  const prefix = activeExtraction.afterSwitch && (activeExtraction.isReasoning ? !activeExtraction.isFirstReasoning : !activeExtraction.isFirstText) ? separator : "";
                  if (activeExtraction.isReasoning && (activeExtraction.afterSwitch || activeExtraction.isFirstReasoning)) {
                    controller.enqueue({
                      type: "reasoning-start",
                      id: `reasoning-${activeExtraction.idCounter}`
                    });
                  }
                  if (activeExtraction.isReasoning) {
                    controller.enqueue({
                      type: "reasoning-delta",
                      delta: prefix + text2,
                      id: `reasoning-${activeExtraction.idCounter}`
                    });
                  } else {
                    if (delayedTextStart) {
                      controller.enqueue(delayedTextStart);
                      delayedTextStart = void 0;
                    }
                    controller.enqueue({
                      type: "text-delta",
                      delta: prefix + text2,
                      id: activeExtraction.textId
                    });
                  }
                  activeExtraction.afterSwitch = false;
                  if (activeExtraction.isReasoning) {
                    activeExtraction.isFirstReasoning = false;
                  } else {
                    activeExtraction.isFirstText = false;
                  }
                }
              }
              do {
                const nextTag = activeExtraction.isReasoning ? closingTag : openingTag;
                const startIndex = getPotentialStartIndex(
                  activeExtraction.buffer,
                  nextTag
                );
                if (startIndex == null) {
                  publish(activeExtraction.buffer);
                  activeExtraction.buffer = "";
                  break;
                }
                publish(activeExtraction.buffer.slice(0, startIndex));
                const foundFullMatch = startIndex + nextTag.length <= activeExtraction.buffer.length;
                if (foundFullMatch) {
                  activeExtraction.buffer = activeExtraction.buffer.slice(
                    startIndex + nextTag.length
                  );
                  if (activeExtraction.isReasoning) {
                    if (activeExtraction.isFirstReasoning) {
                      controller.enqueue({
                        type: "reasoning-start",
                        id: `reasoning-${activeExtraction.idCounter}`
                      });
                    }
                    controller.enqueue({
                      type: "reasoning-end",
                      id: `reasoning-${activeExtraction.idCounter++}`
                    });
                  }
                  activeExtraction.isReasoning = !activeExtraction.isReasoning;
                  activeExtraction.afterSwitch = true;
                } else {
                  activeExtraction.buffer = activeExtraction.buffer.slice(startIndex);
                  break;
                }
              } while (true);
            }
          })
        ),
        ...rest
      };
    }
  };
}
var __defProp3, __export3, name26, marker27, symbol29, _a30, InvalidArgumentError5, name27, marker28, symbol210, _a210, name36, marker36, symbol36, _a36, InvalidToolApprovalError, name46, marker46, symbol46, _a46, InvalidToolInputError, name56, marker56, symbol56, _a56, ToolCallNotFoundForApprovalError, name66, marker66, symbol66, _a66, MissingToolResultsError, name76, marker76, symbol76, _a76, name85, marker86, symbol86, _a86, NoObjectGeneratedError, name95, marker95, symbol95, _a95, NoOutputGeneratedError, name105, marker105, symbol105, _a105, name115, marker115, symbol115, _a115, name125, marker125, symbol125, _a125, name135, marker135, symbol135, _a135, NoSuchToolError, name142, marker145, symbol145, _a145, ToolCallRepairError, UnsupportedModelVersionError, name152, marker152, symbol152, _a152, UIMessageStreamError, name162, marker162, symbol162, _a162, name172, marker172, symbol172, _a172, InvalidMessageRoleError, name182, marker182, symbol182, _a182, name192, marker192, symbol192, _a192, RetryError, FIRST_WARNING_INFO_MESSAGE, hasLoggedBefore, logWarnings, imageMediaTypeSignatures, stripID3, VERSION15, download, createDefaultDownloadFunction, dataContentSchema, jsonValueSchema3, providerMetadataSchema, textPartSchema, imagePartSchema, filePartSchema, reasoningPartSchema, toolCallPartSchema, outputSchema, toolResultPartSchema, toolApprovalRequestSchema, toolApprovalResponseSchema, systemModelMessageSchema, userModelMessageSchema, assistantModelMessageSchema, toolModelMessageSchema, modelMessageSchema, noopTracer, noopSpan, noopSpanContext, retryWithExponentialBackoffRespectingRetryHeaders, DefaultGeneratedFile, DefaultGeneratedFileWithType, output_exports, text, object3, array3, choice, json3, DefaultStepResult, originalGenerateId, DefaultGenerateTextResult, JsonToSseTransformStream, UI_MESSAGE_STREAM_HEADERS, uiMessageChunkSchema, originalGenerateId2, DefaultStreamTextResult, uiMessagesSchema, originalGenerateId3, originalGenerateId4, defaultDownload, wrapLanguageModel, doWrap, name202, marker202, symbol202, _a202, defaultDownload2;
var init_dist22 = __esm({
  "node_modules/ai/dist/index.mjs"() {
    "use strict";
    init_dist5();
    init_dist5();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist3();
    init_dist21();
    init_dist5();
    init_dist5();
    init_dist5();
    init_dist5();
    init_dist3();
    init_dist5();
    init_v42();
    init_dist3();
    init_dist5();
    init_dist3();
    init_dist5();
    init_v42();
    init_v42();
    init_v42();
    init_v42();
    init_v42();
    init_dist21();
    init_dist3();
    init_esm();
    init_esm();
    init_dist3();
    init_dist5();
    init_dist5();
    init_dist5();
    init_dist3();
    init_dist5();
    init_dist5();
    init_dist5();
    init_dist3();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_dist5();
    init_dist5();
    init_v42();
    init_dist5();
    init_dist5();
    __defProp3 = Object.defineProperty;
    __export3 = (target, all3) => {
      for (var name212 in all3)
        __defProp3(target, name212, { get: all3[name212], enumerable: true });
    };
    name26 = "AI_InvalidArgumentError";
    marker27 = `vercel.ai.error.${name26}`;
    symbol29 = Symbol.for(marker27);
    InvalidArgumentError5 = class extends AISDKError {
      constructor({
        parameter,
        value,
        message
      }) {
        super({
          name: name26,
          message: `Invalid argument for parameter ${parameter}: ${message}`
        });
        this[_a30] = true;
        this.parameter = parameter;
        this.value = value;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker27);
      }
    };
    _a30 = symbol29;
    name27 = "AI_InvalidStreamPartError";
    marker28 = `vercel.ai.error.${name27}`;
    symbol210 = Symbol.for(marker28);
    _a210 = symbol210;
    name36 = "AI_InvalidToolApprovalError";
    marker36 = `vercel.ai.error.${name36}`;
    symbol36 = Symbol.for(marker36);
    InvalidToolApprovalError = class extends AISDKError {
      constructor({ approvalId }) {
        super({
          name: name36,
          message: `Tool approval response references unknown approvalId: "${approvalId}". No matching tool-approval-request found in message history.`
        });
        this[_a36] = true;
        this.approvalId = approvalId;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker36);
      }
    };
    _a36 = symbol36;
    name46 = "AI_InvalidToolInputError";
    marker46 = `vercel.ai.error.${name46}`;
    symbol46 = Symbol.for(marker46);
    InvalidToolInputError = class extends AISDKError {
      constructor({
        toolInput,
        toolName,
        cause,
        message = `Invalid input for tool ${toolName}: ${getErrorMessage(cause)}`
      }) {
        super({ name: name46, message, cause });
        this[_a46] = true;
        this.toolInput = toolInput;
        this.toolName = toolName;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker46);
      }
    };
    _a46 = symbol46;
    name56 = "AI_ToolCallNotFoundForApprovalError";
    marker56 = `vercel.ai.error.${name56}`;
    symbol56 = Symbol.for(marker56);
    ToolCallNotFoundForApprovalError = class extends AISDKError {
      constructor({
        toolCallId,
        approvalId
      }) {
        super({
          name: name56,
          message: `Tool call "${toolCallId}" not found for approval request "${approvalId}".`
        });
        this[_a56] = true;
        this.toolCallId = toolCallId;
        this.approvalId = approvalId;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker56);
      }
    };
    _a56 = symbol56;
    name66 = "AI_MissingToolResultsError";
    marker66 = `vercel.ai.error.${name66}`;
    symbol66 = Symbol.for(marker66);
    MissingToolResultsError = class extends AISDKError {
      constructor({ toolCallIds }) {
        super({
          name: name66,
          message: `Tool result${toolCallIds.length > 1 ? "s are" : " is"} missing for tool call${toolCallIds.length > 1 ? "s" : ""} ${toolCallIds.join(
            ", "
          )}.`
        });
        this[_a66] = true;
        this.toolCallIds = toolCallIds;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker66);
      }
    };
    _a66 = symbol66;
    name76 = "AI_NoImageGeneratedError";
    marker76 = `vercel.ai.error.${name76}`;
    symbol76 = Symbol.for(marker76);
    _a76 = symbol76;
    name85 = "AI_NoObjectGeneratedError";
    marker86 = `vercel.ai.error.${name85}`;
    symbol86 = Symbol.for(marker86);
    NoObjectGeneratedError = class extends AISDKError {
      constructor({
        message = "No object generated.",
        cause,
        text: text2,
        response,
        usage,
        finishReason
      }) {
        super({ name: name85, message, cause });
        this[_a86] = true;
        this.text = text2;
        this.response = response;
        this.usage = usage;
        this.finishReason = finishReason;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker86);
      }
    };
    _a86 = symbol86;
    name95 = "AI_NoOutputGeneratedError";
    marker95 = `vercel.ai.error.${name95}`;
    symbol95 = Symbol.for(marker95);
    NoOutputGeneratedError = class extends AISDKError {
      // used in isInstance
      constructor({
        message = "No output generated.",
        cause
      } = {}) {
        super({ name: name95, message, cause });
        this[_a95] = true;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker95);
      }
    };
    _a95 = symbol95;
    name105 = "AI_NoSpeechGeneratedError";
    marker105 = `vercel.ai.error.${name105}`;
    symbol105 = Symbol.for(marker105);
    _a105 = symbol105;
    name115 = "AI_NoTranscriptGeneratedError";
    marker115 = `vercel.ai.error.${name115}`;
    symbol115 = Symbol.for(marker115);
    _a115 = symbol115;
    name125 = "AI_NoVideoGeneratedError";
    marker125 = `vercel.ai.error.${name125}`;
    symbol125 = Symbol.for(marker125);
    _a125 = symbol125;
    name135 = "AI_NoSuchToolError";
    marker135 = `vercel.ai.error.${name135}`;
    symbol135 = Symbol.for(marker135);
    NoSuchToolError = class extends AISDKError {
      constructor({
        toolName,
        availableTools = void 0,
        message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === void 0 ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
      }) {
        super({ name: name135, message });
        this[_a135] = true;
        this.toolName = toolName;
        this.availableTools = availableTools;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker135);
      }
    };
    _a135 = symbol135;
    name142 = "AI_ToolCallRepairError";
    marker145 = `vercel.ai.error.${name142}`;
    symbol145 = Symbol.for(marker145);
    ToolCallRepairError = class extends AISDKError {
      constructor({
        cause,
        originalError,
        message = `Error repairing tool call: ${getErrorMessage(cause)}`
      }) {
        super({ name: name142, message, cause });
        this[_a145] = true;
        this.originalError = originalError;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker145);
      }
    };
    _a145 = symbol145;
    UnsupportedModelVersionError = class extends AISDKError {
      constructor(options) {
        super({
          name: "AI_UnsupportedModelVersionError",
          message: `Unsupported model version ${options.version} for provider "${options.provider}" and model "${options.modelId}". AI SDK 5 only supports models that implement specification version "v2".`
        });
        this.version = options.version;
        this.provider = options.provider;
        this.modelId = options.modelId;
      }
    };
    name152 = "AI_UIMessageStreamError";
    marker152 = `vercel.ai.error.${name152}`;
    symbol152 = Symbol.for(marker152);
    UIMessageStreamError = class extends AISDKError {
      constructor({
        chunkType,
        chunkId,
        message
      }) {
        super({ name: name152, message });
        this[_a152] = true;
        this.chunkType = chunkType;
        this.chunkId = chunkId;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker152);
      }
    };
    _a152 = symbol152;
    name162 = "AI_InvalidDataContentError";
    marker162 = `vercel.ai.error.${name162}`;
    symbol162 = Symbol.for(marker162);
    _a162 = symbol162;
    name172 = "AI_InvalidMessageRoleError";
    marker172 = `vercel.ai.error.${name172}`;
    symbol172 = Symbol.for(marker172);
    InvalidMessageRoleError = class extends AISDKError {
      constructor({
        role,
        message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
      }) {
        super({ name: name172, message });
        this[_a172] = true;
        this.role = role;
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker172);
      }
    };
    _a172 = symbol172;
    name182 = "AI_MessageConversionError";
    marker182 = `vercel.ai.error.${name182}`;
    symbol182 = Symbol.for(marker182);
    _a182 = symbol182;
    name192 = "AI_RetryError";
    marker192 = `vercel.ai.error.${name192}`;
    symbol192 = Symbol.for(marker192);
    RetryError = class extends AISDKError {
      constructor({
        message,
        reason,
        errors
      }) {
        super({ name: name192, message });
        this[_a192] = true;
        this.reason = reason;
        this.errors = errors;
        this.lastError = errors[errors.length - 1];
      }
      static isInstance(error73) {
        return AISDKError.hasMarker(error73, marker192);
      }
    };
    _a192 = symbol192;
    FIRST_WARNING_INFO_MESSAGE = "AI SDK Warning System: To turn off warning logging, set the AI_SDK_LOG_WARNINGS global to false.";
    hasLoggedBefore = false;
    logWarnings = (options) => {
      if (options.warnings.length === 0) {
        return;
      }
      const logger3 = globalThis.AI_SDK_LOG_WARNINGS;
      if (logger3 === false) {
        return;
      }
      if (typeof logger3 === "function") {
        logger3(options);
        return;
      }
      if (!hasLoggedBefore) {
        hasLoggedBefore = true;
        console.info(FIRST_WARNING_INFO_MESSAGE);
      }
      for (const warning of options.warnings) {
        console.warn(
          formatWarning({
            warning,
            provider: options.provider,
            model: options.model
          })
        );
      }
    };
    imageMediaTypeSignatures = [
      {
        mediaType: "image/gif",
        bytesPrefix: [71, 73, 70]
        // GIF
      },
      {
        mediaType: "image/png",
        bytesPrefix: [137, 80, 78, 71]
        // PNG
      },
      {
        mediaType: "image/jpeg",
        bytesPrefix: [255, 216]
        // JPEG
      },
      {
        mediaType: "image/webp",
        bytesPrefix: [
          82,
          73,
          70,
          70,
          // "RIFF"
          null,
          null,
          null,
          null,
          // file size (variable)
          87,
          69,
          66,
          80
          // "WEBP"
        ]
      },
      {
        mediaType: "image/bmp",
        bytesPrefix: [66, 77]
      },
      {
        mediaType: "image/tiff",
        bytesPrefix: [73, 73, 42, 0]
      },
      {
        mediaType: "image/tiff",
        bytesPrefix: [77, 77, 0, 42]
      },
      {
        mediaType: "image/avif",
        bytesPrefix: [
          0,
          0,
          0,
          32,
          102,
          116,
          121,
          112,
          97,
          118,
          105,
          102
        ]
      },
      {
        mediaType: "image/heic",
        bytesPrefix: [
          0,
          0,
          0,
          32,
          102,
          116,
          121,
          112,
          104,
          101,
          105,
          99
        ]
      }
    ];
    stripID3 = (data) => {
      const bytes = typeof data === "string" ? convertBase64ToUint8Array(data) : data;
      const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
      return bytes.slice(id3Size + 10);
    };
    VERSION15 = true ? "6.0.141" : "0.0.0-test";
    download = async ({
      url: url4,
      maxBytes,
      abortSignal
    }) => {
      var _a212;
      const urlText = url4.toString();
      validateDownloadUrl(urlText);
      try {
        const response = await fetch(urlText, {
          headers: withUserAgentSuffix(
            {},
            `ai-sdk/${VERSION15}`,
            getRuntimeEnvironmentUserAgent()
          ),
          signal: abortSignal
        });
        if (response.redirected) {
          validateDownloadUrl(response.url);
        }
        if (!response.ok) {
          throw new DownloadError({
            url: urlText,
            statusCode: response.status,
            statusText: response.statusText
          });
        }
        const data = await readResponseWithSizeLimit({
          response,
          url: urlText,
          maxBytes: maxBytes != null ? maxBytes : DEFAULT_MAX_DOWNLOAD_SIZE
        });
        return {
          data,
          mediaType: (_a212 = response.headers.get("content-type")) != null ? _a212 : void 0
        };
      } catch (error73) {
        if (DownloadError.isInstance(error73)) {
          throw error73;
        }
        throw new DownloadError({ url: urlText, cause: error73 });
      }
    };
    createDefaultDownloadFunction = (download2 = download) => (requestedDownloads) => Promise.all(
      requestedDownloads.map(
        async (requestedDownload) => requestedDownload.isUrlSupportedByModel ? null : download2(requestedDownload)
      )
    );
    dataContentSchema = external_exports.union([
      external_exports.string(),
      external_exports.instanceof(Uint8Array),
      external_exports.instanceof(ArrayBuffer),
      external_exports.custom(
        // Buffer might not be available in some environments such as CloudFlare:
        (value) => {
          var _a212, _b27;
          return (_b27 = (_a212 = globalThis.Buffer) == null ? void 0 : _a212.isBuffer(value)) != null ? _b27 : false;
        },
        { message: "Must be a Buffer" }
      )
    ]);
    jsonValueSchema3 = external_exports.lazy(
      () => external_exports.union([
        external_exports.null(),
        external_exports.string(),
        external_exports.number(),
        external_exports.boolean(),
        external_exports.record(external_exports.string(), jsonValueSchema3.optional()),
        external_exports.array(jsonValueSchema3)
      ])
    );
    providerMetadataSchema = external_exports.record(
      external_exports.string(),
      external_exports.record(external_exports.string(), jsonValueSchema3.optional())
    );
    textPartSchema = external_exports.object({
      type: external_exports.literal("text"),
      text: external_exports.string(),
      providerOptions: providerMetadataSchema.optional()
    });
    imagePartSchema = external_exports.object({
      type: external_exports.literal("image"),
      image: external_exports.union([dataContentSchema, external_exports.instanceof(URL)]),
      mediaType: external_exports.string().optional(),
      providerOptions: providerMetadataSchema.optional()
    });
    filePartSchema = external_exports.object({
      type: external_exports.literal("file"),
      data: external_exports.union([dataContentSchema, external_exports.instanceof(URL)]),
      filename: external_exports.string().optional(),
      mediaType: external_exports.string(),
      providerOptions: providerMetadataSchema.optional()
    });
    reasoningPartSchema = external_exports.object({
      type: external_exports.literal("reasoning"),
      text: external_exports.string(),
      providerOptions: providerMetadataSchema.optional()
    });
    toolCallPartSchema = external_exports.object({
      type: external_exports.literal("tool-call"),
      toolCallId: external_exports.string(),
      toolName: external_exports.string(),
      input: external_exports.unknown(),
      providerOptions: providerMetadataSchema.optional(),
      providerExecuted: external_exports.boolean().optional()
    });
    outputSchema = external_exports.discriminatedUnion(
      "type",
      [
        external_exports.object({
          type: external_exports.literal("text"),
          value: external_exports.string(),
          providerOptions: providerMetadataSchema.optional()
        }),
        external_exports.object({
          type: external_exports.literal("json"),
          value: jsonValueSchema3,
          providerOptions: providerMetadataSchema.optional()
        }),
        external_exports.object({
          type: external_exports.literal("execution-denied"),
          reason: external_exports.string().optional(),
          providerOptions: providerMetadataSchema.optional()
        }),
        external_exports.object({
          type: external_exports.literal("error-text"),
          value: external_exports.string(),
          providerOptions: providerMetadataSchema.optional()
        }),
        external_exports.object({
          type: external_exports.literal("error-json"),
          value: jsonValueSchema3,
          providerOptions: providerMetadataSchema.optional()
        }),
        external_exports.object({
          type: external_exports.literal("content"),
          value: external_exports.array(
            external_exports.union([
              external_exports.object({
                type: external_exports.literal("text"),
                text: external_exports.string(),
                providerOptions: providerMetadataSchema.optional()
              }),
              external_exports.object({
                type: external_exports.literal("media"),
                data: external_exports.string(),
                mediaType: external_exports.string()
              }),
              external_exports.object({
                type: external_exports.literal("file-data"),
                data: external_exports.string(),
                mediaType: external_exports.string(),
                filename: external_exports.string().optional(),
                providerOptions: providerMetadataSchema.optional()
              }),
              external_exports.object({
                type: external_exports.literal("file-url"),
                url: external_exports.string(),
                providerOptions: providerMetadataSchema.optional()
              }),
              external_exports.object({
                type: external_exports.literal("file-id"),
                fileId: external_exports.union([external_exports.string(), external_exports.record(external_exports.string(), external_exports.string())]),
                providerOptions: providerMetadataSchema.optional()
              }),
              external_exports.object({
                type: external_exports.literal("image-data"),
                data: external_exports.string(),
                mediaType: external_exports.string(),
                providerOptions: providerMetadataSchema.optional()
              }),
              external_exports.object({
                type: external_exports.literal("image-url"),
                url: external_exports.string(),
                providerOptions: providerMetadataSchema.optional()
              }),
              external_exports.object({
                type: external_exports.literal("image-file-id"),
                fileId: external_exports.union([external_exports.string(), external_exports.record(external_exports.string(), external_exports.string())]),
                providerOptions: providerMetadataSchema.optional()
              }),
              external_exports.object({
                type: external_exports.literal("custom"),
                providerOptions: providerMetadataSchema.optional()
              })
            ])
          )
        })
      ]
    );
    toolResultPartSchema = external_exports.object({
      type: external_exports.literal("tool-result"),
      toolCallId: external_exports.string(),
      toolName: external_exports.string(),
      output: outputSchema,
      providerOptions: providerMetadataSchema.optional()
    });
    toolApprovalRequestSchema = external_exports.object({
      type: external_exports.literal("tool-approval-request"),
      approvalId: external_exports.string(),
      toolCallId: external_exports.string()
    });
    toolApprovalResponseSchema = external_exports.object({
      type: external_exports.literal("tool-approval-response"),
      approvalId: external_exports.string(),
      approved: external_exports.boolean(),
      reason: external_exports.string().optional()
    });
    systemModelMessageSchema = external_exports.object(
      {
        role: external_exports.literal("system"),
        content: external_exports.string(),
        providerOptions: providerMetadataSchema.optional()
      }
    );
    userModelMessageSchema = external_exports.object({
      role: external_exports.literal("user"),
      content: external_exports.union([
        external_exports.string(),
        external_exports.array(external_exports.union([textPartSchema, imagePartSchema, filePartSchema]))
      ]),
      providerOptions: providerMetadataSchema.optional()
    });
    assistantModelMessageSchema = external_exports.object({
      role: external_exports.literal("assistant"),
      content: external_exports.union([
        external_exports.string(),
        external_exports.array(
          external_exports.union([
            textPartSchema,
            filePartSchema,
            reasoningPartSchema,
            toolCallPartSchema,
            toolResultPartSchema,
            toolApprovalRequestSchema
          ])
        )
      ]),
      providerOptions: providerMetadataSchema.optional()
    });
    toolModelMessageSchema = external_exports.object({
      role: external_exports.literal("tool"),
      content: external_exports.array(external_exports.union([toolResultPartSchema, toolApprovalResponseSchema])),
      providerOptions: providerMetadataSchema.optional()
    });
    modelMessageSchema = external_exports.union([
      systemModelMessageSchema,
      userModelMessageSchema,
      assistantModelMessageSchema,
      toolModelMessageSchema
    ]);
    noopTracer = {
      startSpan() {
        return noopSpan;
      },
      startActiveSpan(name212, arg1, arg2, arg3) {
        if (typeof arg1 === "function") {
          return arg1(noopSpan);
        }
        if (typeof arg2 === "function") {
          return arg2(noopSpan);
        }
        if (typeof arg3 === "function") {
          return arg3(noopSpan);
        }
      }
    };
    noopSpan = {
      spanContext() {
        return noopSpanContext;
      },
      setAttribute() {
        return this;
      },
      setAttributes() {
        return this;
      },
      addEvent() {
        return this;
      },
      addLink() {
        return this;
      },
      addLinks() {
        return this;
      },
      setStatus() {
        return this;
      },
      updateName() {
        return this;
      },
      end() {
        return this;
      },
      isRecording() {
        return false;
      },
      recordException() {
        return this;
      }
    };
    noopSpanContext = {
      traceId: "",
      spanId: "",
      traceFlags: 0
    };
    retryWithExponentialBackoffRespectingRetryHeaders = ({
      maxRetries = 2,
      initialDelayInMs = 2e3,
      backoffFactor = 2,
      abortSignal
    } = {}) => async (f) => _retryWithExponentialBackoff(f, {
      maxRetries,
      delayInMs: initialDelayInMs,
      backoffFactor,
      abortSignal
    });
    DefaultGeneratedFile = class {
      constructor({
        data,
        mediaType
      }) {
        const isUint8Array = data instanceof Uint8Array;
        this.base64Data = isUint8Array ? void 0 : data;
        this.uint8ArrayData = isUint8Array ? data : void 0;
        this.mediaType = mediaType;
      }
      // lazy conversion with caching to avoid unnecessary conversion overhead:
      get base64() {
        if (this.base64Data == null) {
          this.base64Data = convertUint8ArrayToBase64(this.uint8ArrayData);
        }
        return this.base64Data;
      }
      // lazy conversion with caching to avoid unnecessary conversion overhead:
      get uint8Array() {
        if (this.uint8ArrayData == null) {
          this.uint8ArrayData = convertBase64ToUint8Array(this.base64Data);
        }
        return this.uint8ArrayData;
      }
    };
    DefaultGeneratedFileWithType = class extends DefaultGeneratedFile {
      constructor(options) {
        super(options);
        this.type = "file";
      }
    };
    output_exports = {};
    __export3(output_exports, {
      array: () => array3,
      choice: () => choice,
      json: () => json3,
      object: () => object3,
      text: () => text
    });
    text = () => ({
      name: "text",
      responseFormat: Promise.resolve({ type: "text" }),
      async parseCompleteOutput({ text: text2 }) {
        return text2;
      },
      async parsePartialOutput({ text: text2 }) {
        return { partial: text2 };
      },
      createElementStreamTransform() {
        return void 0;
      }
    });
    object3 = ({
      schema: inputSchema,
      name: name212,
      description
    }) => {
      const schema = asSchema(inputSchema);
      return {
        name: "object",
        responseFormat: resolve(schema.jsonSchema).then((jsonSchema22) => ({
          type: "json",
          schema: jsonSchema22,
          ...name212 != null && { name: name212 },
          ...description != null && { description }
        })),
        async parseCompleteOutput({ text: text2 }, context2) {
          const parseResult = await safeParseJSON({ text: text2 });
          if (!parseResult.success) {
            throw new NoObjectGeneratedError({
              message: "No object generated: could not parse the response.",
              cause: parseResult.error,
              text: text2,
              response: context2.response,
              usage: context2.usage,
              finishReason: context2.finishReason
            });
          }
          const validationResult = await safeValidateTypes({
            value: parseResult.value,
            schema
          });
          if (!validationResult.success) {
            throw new NoObjectGeneratedError({
              message: "No object generated: response did not match schema.",
              cause: validationResult.error,
              text: text2,
              response: context2.response,
              usage: context2.usage,
              finishReason: context2.finishReason
            });
          }
          return validationResult.value;
        },
        async parsePartialOutput({ text: text2 }) {
          const result = await parsePartialJson(text2);
          switch (result.state) {
            case "failed-parse":
            case "undefined-input": {
              return void 0;
            }
            case "repaired-parse":
            case "successful-parse": {
              return {
                // Note: currently no validation of partial results:
                partial: result.value
              };
            }
          }
        },
        createElementStreamTransform() {
          return void 0;
        }
      };
    };
    array3 = ({
      element: inputElementSchema,
      name: name212,
      description
    }) => {
      const elementSchema = asSchema(inputElementSchema);
      return {
        name: "array",
        // JSON schema that describes an array of elements:
        responseFormat: resolve(elementSchema.jsonSchema).then((jsonSchema22) => {
          const { $schema, ...itemSchema } = jsonSchema22;
          return {
            type: "json",
            schema: {
              $schema: "http://json-schema.org/draft-07/schema#",
              type: "object",
              properties: {
                elements: { type: "array", items: itemSchema }
              },
              required: ["elements"],
              additionalProperties: false
            },
            ...name212 != null && { name: name212 },
            ...description != null && { description }
          };
        }),
        async parseCompleteOutput({ text: text2 }, context2) {
          const parseResult = await safeParseJSON({ text: text2 });
          if (!parseResult.success) {
            throw new NoObjectGeneratedError({
              message: "No object generated: could not parse the response.",
              cause: parseResult.error,
              text: text2,
              response: context2.response,
              usage: context2.usage,
              finishReason: context2.finishReason
            });
          }
          const outerValue = parseResult.value;
          if (outerValue == null || typeof outerValue !== "object" || !("elements" in outerValue) || !Array.isArray(outerValue.elements)) {
            throw new NoObjectGeneratedError({
              message: "No object generated: response did not match schema.",
              cause: new TypeValidationError({
                value: outerValue,
                cause: "response must be an object with an elements array"
              }),
              text: text2,
              response: context2.response,
              usage: context2.usage,
              finishReason: context2.finishReason
            });
          }
          for (const element of outerValue.elements) {
            const validationResult = await safeValidateTypes({
              value: element,
              schema: elementSchema
            });
            if (!validationResult.success) {
              throw new NoObjectGeneratedError({
                message: "No object generated: response did not match schema.",
                cause: validationResult.error,
                text: text2,
                response: context2.response,
                usage: context2.usage,
                finishReason: context2.finishReason
              });
            }
          }
          return outerValue.elements;
        },
        async parsePartialOutput({ text: text2 }) {
          const result = await parsePartialJson(text2);
          switch (result.state) {
            case "failed-parse":
            case "undefined-input": {
              return void 0;
            }
            case "repaired-parse":
            case "successful-parse": {
              const outerValue = result.value;
              if (outerValue == null || typeof outerValue !== "object" || !("elements" in outerValue) || !Array.isArray(outerValue.elements)) {
                return void 0;
              }
              const rawElements = result.state === "repaired-parse" && outerValue.elements.length > 0 ? outerValue.elements.slice(0, -1) : outerValue.elements;
              const parsedElements = [];
              for (const rawElement of rawElements) {
                const validationResult = await safeValidateTypes({
                  value: rawElement,
                  schema: elementSchema
                });
                if (validationResult.success) {
                  parsedElements.push(validationResult.value);
                }
              }
              return { partial: parsedElements };
            }
          }
        },
        createElementStreamTransform() {
          let publishedElements = 0;
          return new TransformStream({
            transform({ partialOutput }, controller) {
              if (partialOutput != null) {
                for (; publishedElements < partialOutput.length; publishedElements++) {
                  controller.enqueue(partialOutput[publishedElements]);
                }
              }
            }
          });
        }
      };
    };
    choice = ({
      options: choiceOptions,
      name: name212,
      description
    }) => {
      return {
        name: "choice",
        // JSON schema that describes an enumeration:
        responseFormat: Promise.resolve({
          type: "json",
          schema: {
            $schema: "http://json-schema.org/draft-07/schema#",
            type: "object",
            properties: {
              result: { type: "string", enum: choiceOptions }
            },
            required: ["result"],
            additionalProperties: false
          },
          ...name212 != null && { name: name212 },
          ...description != null && { description }
        }),
        async parseCompleteOutput({ text: text2 }, context2) {
          const parseResult = await safeParseJSON({ text: text2 });
          if (!parseResult.success) {
            throw new NoObjectGeneratedError({
              message: "No object generated: could not parse the response.",
              cause: parseResult.error,
              text: text2,
              response: context2.response,
              usage: context2.usage,
              finishReason: context2.finishReason
            });
          }
          const outerValue = parseResult.value;
          if (outerValue == null || typeof outerValue !== "object" || !("result" in outerValue) || typeof outerValue.result !== "string" || !choiceOptions.includes(outerValue.result)) {
            throw new NoObjectGeneratedError({
              message: "No object generated: response did not match schema.",
              cause: new TypeValidationError({
                value: outerValue,
                cause: "response must be an object that contains a choice value."
              }),
              text: text2,
              response: context2.response,
              usage: context2.usage,
              finishReason: context2.finishReason
            });
          }
          return outerValue.result;
        },
        async parsePartialOutput({ text: text2 }) {
          const result = await parsePartialJson(text2);
          switch (result.state) {
            case "failed-parse":
            case "undefined-input": {
              return void 0;
            }
            case "repaired-parse":
            case "successful-parse": {
              const outerValue = result.value;
              if (outerValue == null || typeof outerValue !== "object" || !("result" in outerValue) || typeof outerValue.result !== "string") {
                return void 0;
              }
              const potentialMatches = choiceOptions.filter(
                (choiceOption) => choiceOption.startsWith(outerValue.result)
              );
              if (result.state === "successful-parse") {
                return potentialMatches.includes(outerValue.result) ? { partial: outerValue.result } : void 0;
              } else {
                return potentialMatches.length === 1 ? { partial: potentialMatches[0] } : void 0;
              }
            }
          }
        },
        createElementStreamTransform() {
          return void 0;
        }
      };
    };
    json3 = ({
      name: name212,
      description
    } = {}) => {
      return {
        name: "json",
        responseFormat: Promise.resolve({
          type: "json",
          ...name212 != null && { name: name212 },
          ...description != null && { description }
        }),
        async parseCompleteOutput({ text: text2 }, context2) {
          const parseResult = await safeParseJSON({ text: text2 });
          if (!parseResult.success) {
            throw new NoObjectGeneratedError({
              message: "No object generated: could not parse the response.",
              cause: parseResult.error,
              text: text2,
              response: context2.response,
              usage: context2.usage,
              finishReason: context2.finishReason
            });
          }
          return parseResult.value;
        },
        async parsePartialOutput({ text: text2 }) {
          const result = await parsePartialJson(text2);
          switch (result.state) {
            case "failed-parse":
            case "undefined-input": {
              return void 0;
            }
            case "repaired-parse":
            case "successful-parse": {
              return result.value === void 0 ? void 0 : { partial: result.value };
            }
          }
        },
        createElementStreamTransform() {
          return void 0;
        }
      };
    };
    DefaultStepResult = class {
      constructor({
        stepNumber,
        model,
        functionId,
        metadata,
        experimental_context,
        content,
        finishReason,
        rawFinishReason,
        usage,
        warnings,
        request,
        response,
        providerMetadata
      }) {
        this.stepNumber = stepNumber;
        this.model = model;
        this.functionId = functionId;
        this.metadata = metadata;
        this.experimental_context = experimental_context;
        this.content = content;
        this.finishReason = finishReason;
        this.rawFinishReason = rawFinishReason;
        this.usage = usage;
        this.warnings = warnings;
        this.request = request;
        this.response = response;
        this.providerMetadata = providerMetadata;
      }
      get text() {
        return this.content.filter((part) => part.type === "text").map((part) => part.text).join("");
      }
      get reasoning() {
        return this.content.filter((part) => part.type === "reasoning");
      }
      get reasoningText() {
        return this.reasoning.length === 0 ? void 0 : this.reasoning.map((part) => part.text).join("");
      }
      get files() {
        return this.content.filter((part) => part.type === "file").map((part) => part.file);
      }
      get sources() {
        return this.content.filter((part) => part.type === "source");
      }
      get toolCalls() {
        return this.content.filter((part) => part.type === "tool-call");
      }
      get staticToolCalls() {
        return this.toolCalls.filter(
          (toolCall) => toolCall.dynamic !== true
        );
      }
      get dynamicToolCalls() {
        return this.toolCalls.filter(
          (toolCall) => toolCall.dynamic === true
        );
      }
      get toolResults() {
        return this.content.filter((part) => part.type === "tool-result");
      }
      get staticToolResults() {
        return this.toolResults.filter(
          (toolResult) => toolResult.dynamic !== true
        );
      }
      get dynamicToolResults() {
        return this.toolResults.filter(
          (toolResult) => toolResult.dynamic === true
        );
      }
    };
    originalGenerateId = createIdGenerator({
      prefix: "aitxt",
      size: 24
    });
    DefaultGenerateTextResult = class {
      constructor(options) {
        this.steps = options.steps;
        this._output = options.output;
        this.totalUsage = options.totalUsage;
      }
      get finalStep() {
        return this.steps[this.steps.length - 1];
      }
      get content() {
        return this.finalStep.content;
      }
      get text() {
        return this.finalStep.text;
      }
      get files() {
        return this.finalStep.files;
      }
      get reasoningText() {
        return this.finalStep.reasoningText;
      }
      get reasoning() {
        return this.finalStep.reasoning;
      }
      get toolCalls() {
        return this.finalStep.toolCalls;
      }
      get staticToolCalls() {
        return this.finalStep.staticToolCalls;
      }
      get dynamicToolCalls() {
        return this.finalStep.dynamicToolCalls;
      }
      get toolResults() {
        return this.finalStep.toolResults;
      }
      get staticToolResults() {
        return this.finalStep.staticToolResults;
      }
      get dynamicToolResults() {
        return this.finalStep.dynamicToolResults;
      }
      get sources() {
        return this.finalStep.sources;
      }
      get finishReason() {
        return this.finalStep.finishReason;
      }
      get rawFinishReason() {
        return this.finalStep.rawFinishReason;
      }
      get warnings() {
        return this.finalStep.warnings;
      }
      get providerMetadata() {
        return this.finalStep.providerMetadata;
      }
      get response() {
        return this.finalStep.response;
      }
      get request() {
        return this.finalStep.request;
      }
      get usage() {
        return this.finalStep.usage;
      }
      get experimental_output() {
        return this.output;
      }
      get output() {
        if (this._output == null) {
          throw new NoOutputGeneratedError();
        }
        return this._output;
      }
    };
    JsonToSseTransformStream = class extends TransformStream {
      constructor() {
        super({
          transform(part, controller) {
            controller.enqueue(`data: ${JSON.stringify(part)}

`);
          },
          flush(controller) {
            controller.enqueue("data: [DONE]\n\n");
          }
        });
      }
    };
    UI_MESSAGE_STREAM_HEADERS = {
      "content-type": "text/event-stream",
      "cache-control": "no-cache",
      connection: "keep-alive",
      "x-vercel-ai-ui-message-stream": "v1",
      "x-accel-buffering": "no"
      // disable nginx buffering
    };
    uiMessageChunkSchema = lazySchema(
      () => zodSchema(
        external_exports.union([
          external_exports.strictObject({
            type: external_exports.literal("text-start"),
            id: external_exports.string(),
            providerMetadata: providerMetadataSchema.optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("text-delta"),
            id: external_exports.string(),
            delta: external_exports.string(),
            providerMetadata: providerMetadataSchema.optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("text-end"),
            id: external_exports.string(),
            providerMetadata: providerMetadataSchema.optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("error"),
            errorText: external_exports.string()
          }),
          external_exports.strictObject({
            type: external_exports.literal("tool-input-start"),
            toolCallId: external_exports.string(),
            toolName: external_exports.string(),
            providerExecuted: external_exports.boolean().optional(),
            providerMetadata: providerMetadataSchema.optional(),
            dynamic: external_exports.boolean().optional(),
            title: external_exports.string().optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("tool-input-delta"),
            toolCallId: external_exports.string(),
            inputTextDelta: external_exports.string()
          }),
          external_exports.strictObject({
            type: external_exports.literal("tool-input-available"),
            toolCallId: external_exports.string(),
            toolName: external_exports.string(),
            input: external_exports.unknown(),
            providerExecuted: external_exports.boolean().optional(),
            providerMetadata: providerMetadataSchema.optional(),
            dynamic: external_exports.boolean().optional(),
            title: external_exports.string().optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("tool-input-error"),
            toolCallId: external_exports.string(),
            toolName: external_exports.string(),
            input: external_exports.unknown(),
            providerExecuted: external_exports.boolean().optional(),
            providerMetadata: providerMetadataSchema.optional(),
            dynamic: external_exports.boolean().optional(),
            errorText: external_exports.string(),
            title: external_exports.string().optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("tool-approval-request"),
            approvalId: external_exports.string(),
            toolCallId: external_exports.string()
          }),
          external_exports.strictObject({
            type: external_exports.literal("tool-output-available"),
            toolCallId: external_exports.string(),
            output: external_exports.unknown(),
            providerExecuted: external_exports.boolean().optional(),
            providerMetadata: providerMetadataSchema.optional(),
            dynamic: external_exports.boolean().optional(),
            preliminary: external_exports.boolean().optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("tool-output-error"),
            toolCallId: external_exports.string(),
            errorText: external_exports.string(),
            providerExecuted: external_exports.boolean().optional(),
            providerMetadata: providerMetadataSchema.optional(),
            dynamic: external_exports.boolean().optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("tool-output-denied"),
            toolCallId: external_exports.string()
          }),
          external_exports.strictObject({
            type: external_exports.literal("reasoning-start"),
            id: external_exports.string(),
            providerMetadata: providerMetadataSchema.optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("reasoning-delta"),
            id: external_exports.string(),
            delta: external_exports.string(),
            providerMetadata: providerMetadataSchema.optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("reasoning-end"),
            id: external_exports.string(),
            providerMetadata: providerMetadataSchema.optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("source-url"),
            sourceId: external_exports.string(),
            url: external_exports.string(),
            title: external_exports.string().optional(),
            providerMetadata: providerMetadataSchema.optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("source-document"),
            sourceId: external_exports.string(),
            mediaType: external_exports.string(),
            title: external_exports.string(),
            filename: external_exports.string().optional(),
            providerMetadata: providerMetadataSchema.optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("file"),
            url: external_exports.string(),
            mediaType: external_exports.string(),
            providerMetadata: providerMetadataSchema.optional()
          }),
          external_exports.strictObject({
            type: external_exports.custom(
              (value) => typeof value === "string" && value.startsWith("data-"),
              { message: 'Type must start with "data-"' }
            ),
            id: external_exports.string().optional(),
            data: external_exports.unknown(),
            transient: external_exports.boolean().optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("start-step")
          }),
          external_exports.strictObject({
            type: external_exports.literal("finish-step")
          }),
          external_exports.strictObject({
            type: external_exports.literal("start"),
            messageId: external_exports.string().optional(),
            messageMetadata: external_exports.unknown().optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("finish"),
            finishReason: external_exports.enum([
              "stop",
              "length",
              "content-filter",
              "tool-calls",
              "error",
              "other"
            ]).optional(),
            messageMetadata: external_exports.unknown().optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("abort"),
            reason: external_exports.string().optional()
          }),
          external_exports.strictObject({
            type: external_exports.literal("message-metadata"),
            messageMetadata: external_exports.unknown()
          })
        ])
      )
    );
    originalGenerateId2 = createIdGenerator({
      prefix: "aitxt",
      size: 24
    });
    DefaultStreamTextResult = class {
      constructor({
        model,
        telemetry,
        headers,
        settings,
        maxRetries: maxRetriesArg,
        abortSignal,
        stepTimeoutMs,
        stepAbortController,
        chunkTimeoutMs,
        chunkAbortController,
        system,
        prompt,
        messages,
        tools,
        toolChoice,
        transforms,
        activeTools,
        repairToolCall,
        stopConditions,
        output,
        providerOptions,
        prepareStep,
        includeRawChunks,
        now: now2,
        generateId: generateId22,
        timeout,
        stopWhen,
        originalAbortSignal,
        onChunk,
        onError,
        onFinish,
        onAbort,
        onStepFinish,
        onStart,
        onStepStart,
        onToolCallStart,
        onToolCallFinish,
        experimental_context,
        download: download2,
        include
      }) {
        this._totalUsage = new DelayedPromise();
        this._finishReason = new DelayedPromise();
        this._rawFinishReason = new DelayedPromise();
        this._steps = new DelayedPromise();
        this.outputSpecification = output;
        this.includeRawChunks = includeRawChunks;
        this.tools = tools;
        const createGlobalTelemetry = getGlobalTelemetryIntegration();
        const globalTelemetry = createGlobalTelemetry(telemetry == null ? void 0 : telemetry.integrations);
        let stepFinish;
        let recordedContent = [];
        const recordedResponseMessages = [];
        let recordedFinishReason = void 0;
        let recordedRawFinishReason = void 0;
        let recordedTotalUsage = void 0;
        let recordedRequest = {};
        let recordedWarnings = [];
        const recordedSteps = [];
        const pendingDeferredToolCalls = /* @__PURE__ */ new Map();
        let rootSpan;
        let activeTextContent = {};
        let activeReasoningContent = {};
        const eventProcessor = new TransformStream({
          async transform(chunk, controller) {
            var _a212, _b27, _c, _d;
            controller.enqueue(chunk);
            const { part } = chunk;
            if (part.type === "text-delta" || part.type === "reasoning-delta" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-input-start" || part.type === "tool-input-delta" || part.type === "raw") {
              await (onChunk == null ? void 0 : onChunk({ chunk: part }));
            }
            if (part.type === "error") {
              await onError({ error: wrapGatewayError(part.error) });
            }
            if (part.type === "text-start") {
              activeTextContent[part.id] = {
                type: "text",
                text: "",
                providerMetadata: part.providerMetadata
              };
              recordedContent.push(activeTextContent[part.id]);
            }
            if (part.type === "text-delta") {
              const activeText = activeTextContent[part.id];
              if (activeText == null) {
                controller.enqueue({
                  part: {
                    type: "error",
                    error: `text part ${part.id} not found`
                  },
                  partialOutput: void 0
                });
                return;
              }
              activeText.text += part.text;
              activeText.providerMetadata = (_a212 = part.providerMetadata) != null ? _a212 : activeText.providerMetadata;
            }
            if (part.type === "text-end") {
              const activeText = activeTextContent[part.id];
              if (activeText == null) {
                controller.enqueue({
                  part: {
                    type: "error",
                    error: `text part ${part.id} not found`
                  },
                  partialOutput: void 0
                });
                return;
              }
              activeText.providerMetadata = (_b27 = part.providerMetadata) != null ? _b27 : activeText.providerMetadata;
              delete activeTextContent[part.id];
            }
            if (part.type === "reasoning-start") {
              activeReasoningContent[part.id] = {
                type: "reasoning",
                text: "",
                providerMetadata: part.providerMetadata
              };
              recordedContent.push(activeReasoningContent[part.id]);
            }
            if (part.type === "reasoning-delta") {
              const activeReasoning = activeReasoningContent[part.id];
              if (activeReasoning == null) {
                controller.enqueue({
                  part: {
                    type: "error",
                    error: `reasoning part ${part.id} not found`
                  },
                  partialOutput: void 0
                });
                return;
              }
              activeReasoning.text += part.text;
              activeReasoning.providerMetadata = (_c = part.providerMetadata) != null ? _c : activeReasoning.providerMetadata;
            }
            if (part.type === "reasoning-end") {
              const activeReasoning = activeReasoningContent[part.id];
              if (activeReasoning == null) {
                controller.enqueue({
                  part: {
                    type: "error",
                    error: `reasoning part ${part.id} not found`
                  },
                  partialOutput: void 0
                });
                return;
              }
              activeReasoning.providerMetadata = (_d = part.providerMetadata) != null ? _d : activeReasoning.providerMetadata;
              delete activeReasoningContent[part.id];
            }
            if (part.type === "file") {
              recordedContent.push({
                type: "file",
                file: part.file,
                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
              });
            }
            if (part.type === "source") {
              recordedContent.push(part);
            }
            if (part.type === "tool-call") {
              recordedContent.push(part);
            }
            if (part.type === "tool-result" && !part.preliminary) {
              recordedContent.push(part);
            }
            if (part.type === "tool-approval-request") {
              recordedContent.push(part);
            }
            if (part.type === "tool-error") {
              recordedContent.push(part);
            }
            if (part.type === "start-step") {
              recordedContent = [];
              activeReasoningContent = {};
              activeTextContent = {};
              recordedRequest = part.request;
              recordedWarnings = part.warnings;
            }
            if (part.type === "finish-step") {
              const stepMessages = await toResponseMessages({
                content: recordedContent,
                tools
              });
              const currentStepResult = new DefaultStepResult({
                stepNumber: recordedSteps.length,
                model: modelInfo,
                ...callbackTelemetryProps,
                experimental_context,
                content: recordedContent,
                finishReason: part.finishReason,
                rawFinishReason: part.rawFinishReason,
                usage: part.usage,
                warnings: recordedWarnings,
                request: recordedRequest,
                response: {
                  ...part.response,
                  messages: [...recordedResponseMessages, ...stepMessages]
                },
                providerMetadata: part.providerMetadata
              });
              await notify({
                event: currentStepResult,
                callbacks: [onStepFinish, globalTelemetry.onStepFinish]
              });
              logWarnings({
                warnings: recordedWarnings,
                provider: modelInfo.provider,
                model: modelInfo.modelId
              });
              recordedSteps.push(currentStepResult);
              recordedResponseMessages.push(...stepMessages);
              stepFinish.resolve();
            }
            if (part.type === "finish") {
              recordedTotalUsage = part.totalUsage;
              recordedFinishReason = part.finishReason;
              recordedRawFinishReason = part.rawFinishReason;
            }
          },
          async flush(controller) {
            var _a212, _b27, _c, _d, _e, _f, _g;
            try {
              if (recordedSteps.length === 0) {
                const error73 = (abortSignal == null ? void 0 : abortSignal.aborted) ? abortSignal.reason : new NoOutputGeneratedError({
                  message: "No output generated. Check the stream for errors."
                });
                self2._finishReason.reject(error73);
                self2._rawFinishReason.reject(error73);
                self2._totalUsage.reject(error73);
                self2._steps.reject(error73);
                return;
              }
              const finishReason = recordedFinishReason != null ? recordedFinishReason : "other";
              const totalUsage = recordedTotalUsage != null ? recordedTotalUsage : createNullLanguageModelUsage();
              self2._finishReason.resolve(finishReason);
              self2._rawFinishReason.resolve(recordedRawFinishReason);
              self2._totalUsage.resolve(totalUsage);
              self2._steps.resolve(recordedSteps);
              const finalStep = recordedSteps[recordedSteps.length - 1];
              await notify({
                event: {
                  stepNumber: finalStep.stepNumber,
                  model: finalStep.model,
                  functionId: finalStep.functionId,
                  metadata: finalStep.metadata,
                  experimental_context: finalStep.experimental_context,
                  finishReason: finalStep.finishReason,
                  rawFinishReason: finalStep.rawFinishReason,
                  totalUsage,
                  usage: finalStep.usage,
                  content: finalStep.content,
                  text: finalStep.text,
                  reasoningText: finalStep.reasoningText,
                  reasoning: finalStep.reasoning,
                  files: finalStep.files,
                  sources: finalStep.sources,
                  toolCalls: finalStep.toolCalls,
                  staticToolCalls: finalStep.staticToolCalls,
                  dynamicToolCalls: finalStep.dynamicToolCalls,
                  toolResults: finalStep.toolResults,
                  staticToolResults: finalStep.staticToolResults,
                  dynamicToolResults: finalStep.dynamicToolResults,
                  request: finalStep.request,
                  response: finalStep.response,
                  warnings: finalStep.warnings,
                  providerMetadata: finalStep.providerMetadata,
                  steps: recordedSteps
                },
                callbacks: [
                  onFinish,
                  globalTelemetry.onFinish
                ]
              });
              rootSpan.setAttributes(
                await selectTelemetryAttributes({
                  telemetry,
                  attributes: {
                    "ai.response.finishReason": finishReason,
                    "ai.response.text": { output: () => finalStep.text },
                    "ai.response.reasoning": {
                      output: () => finalStep.reasoningText
                    },
                    "ai.response.toolCalls": {
                      output: () => {
                        var _a222;
                        return ((_a222 = finalStep.toolCalls) == null ? void 0 : _a222.length) ? JSON.stringify(finalStep.toolCalls) : void 0;
                      }
                    },
                    "ai.response.providerMetadata": JSON.stringify(
                      finalStep.providerMetadata
                    ),
                    "ai.usage.inputTokens": totalUsage.inputTokens,
                    "ai.usage.inputTokenDetails.noCacheTokens": (_a212 = totalUsage.inputTokenDetails) == null ? void 0 : _a212.noCacheTokens,
                    "ai.usage.inputTokenDetails.cacheReadTokens": (_b27 = totalUsage.inputTokenDetails) == null ? void 0 : _b27.cacheReadTokens,
                    "ai.usage.inputTokenDetails.cacheWriteTokens": (_c = totalUsage.inputTokenDetails) == null ? void 0 : _c.cacheWriteTokens,
                    "ai.usage.outputTokens": totalUsage.outputTokens,
                    "ai.usage.outputTokenDetails.textTokens": (_d = totalUsage.outputTokenDetails) == null ? void 0 : _d.textTokens,
                    "ai.usage.outputTokenDetails.reasoningTokens": (_e = totalUsage.outputTokenDetails) == null ? void 0 : _e.reasoningTokens,
                    "ai.usage.totalTokens": totalUsage.totalTokens,
                    "ai.usage.reasoningTokens": (_f = totalUsage.outputTokenDetails) == null ? void 0 : _f.reasoningTokens,
                    "ai.usage.cachedInputTokens": (_g = totalUsage.inputTokenDetails) == null ? void 0 : _g.cacheReadTokens
                  }
                })
              );
            } catch (error73) {
              controller.error(error73);
            } finally {
              rootSpan.end();
            }
          }
        });
        const stitchableStream = createStitchableStream();
        this.addStream = stitchableStream.addStream;
        this.closeStream = stitchableStream.close;
        const reader = stitchableStream.stream.getReader();
        let stream4 = new ReadableStream({
          async start(controller) {
            controller.enqueue({ type: "start" });
          },
          async pull(controller) {
            function abort() {
              onAbort == null ? void 0 : onAbort({ steps: recordedSteps });
              controller.enqueue({
                type: "abort",
                // The `reason` is usually of type DOMException, but it can also be of any type,
                // so we use getErrorMessage for serialization because it is already designed to accept values of the unknown type.
                // See: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/reason
                ...(abortSignal == null ? void 0 : abortSignal.reason) !== void 0 ? { reason: getErrorMessage(abortSignal.reason) } : {}
              });
              controller.close();
            }
            try {
              const { done, value } = await reader.read();
              if (done) {
                controller.close();
                return;
              }
              if (abortSignal == null ? void 0 : abortSignal.aborted) {
                abort();
                return;
              }
              controller.enqueue(value);
            } catch (error73) {
              if (isAbortError(error73) && (abortSignal == null ? void 0 : abortSignal.aborted)) {
                abort();
              } else {
                controller.error(error73);
              }
            }
          },
          cancel(reason) {
            return stitchableStream.stream.cancel(reason);
          }
        });
        for (const transform8 of transforms) {
          stream4 = stream4.pipeThrough(
            transform8({
              tools,
              stopStream() {
                stitchableStream.terminate();
              }
            })
          );
        }
        this.baseStream = stream4.pipeThrough(createOutputTransformStream(output != null ? output : text())).pipeThrough(eventProcessor);
        const { maxRetries, retry } = prepareRetries({
          maxRetries: maxRetriesArg,
          abortSignal
        });
        const tracer = getTracer(telemetry);
        const callSettings = prepareCallSettings(settings);
        const baseTelemetryAttributes = getBaseTelemetryAttributes({
          model,
          telemetry,
          headers,
          settings: { ...callSettings, maxRetries }
        });
        const self2 = this;
        const modelInfo = { provider: model.provider, modelId: model.modelId };
        const callbackTelemetryProps = {
          functionId: telemetry == null ? void 0 : telemetry.functionId,
          metadata: telemetry == null ? void 0 : telemetry.metadata
        };
        recordSpan({
          name: "ai.streamText",
          attributes: selectTelemetryAttributes({
            telemetry,
            attributes: {
              ...assembleOperationName({ operationId: "ai.streamText", telemetry }),
              ...baseTelemetryAttributes,
              // specific settings that only make sense on the outer level:
              "ai.prompt": {
                input: () => JSON.stringify({ system, prompt, messages })
              }
            }
          }),
          tracer,
          endWhenDone: false,
          fn: async (rootSpanArg) => {
            rootSpan = rootSpanArg;
            const initialPrompt = await standardizePrompt({
              system,
              prompt,
              messages
            });
            await notify({
              event: {
                model: modelInfo,
                system,
                prompt,
                messages,
                tools,
                toolChoice,
                activeTools,
                maxOutputTokens: callSettings.maxOutputTokens,
                temperature: callSettings.temperature,
                topP: callSettings.topP,
                topK: callSettings.topK,
                presencePenalty: callSettings.presencePenalty,
                frequencyPenalty: callSettings.frequencyPenalty,
                stopSequences: callSettings.stopSequences,
                seed: callSettings.seed,
                maxRetries,
                timeout,
                headers,
                providerOptions,
                stopWhen,
                output,
                abortSignal: originalAbortSignal,
                include,
                ...callbackTelemetryProps,
                experimental_context
              },
              callbacks: [
                onStart,
                globalTelemetry.onStart
              ]
            });
            const initialMessages = initialPrompt.messages;
            const initialResponseMessages = [];
            const { approvedToolApprovals, deniedToolApprovals } = collectToolApprovals({ messages: initialMessages });
            if (deniedToolApprovals.length > 0 || approvedToolApprovals.length > 0) {
              const providerExecutedToolApprovals = [
                ...approvedToolApprovals,
                ...deniedToolApprovals
              ].filter((toolApproval) => toolApproval.toolCall.providerExecuted);
              const localApprovedToolApprovals = approvedToolApprovals.filter(
                (toolApproval) => !toolApproval.toolCall.providerExecuted
              );
              const localDeniedToolApprovals = deniedToolApprovals.filter(
                (toolApproval) => !toolApproval.toolCall.providerExecuted
              );
              const deniedProviderExecutedToolApprovals = deniedToolApprovals.filter(
                (toolApproval) => toolApproval.toolCall.providerExecuted
              );
              let toolExecutionStepStreamController;
              const toolExecutionStepStream = new ReadableStream({
                start(controller) {
                  toolExecutionStepStreamController = controller;
                }
              });
              self2.addStream(toolExecutionStepStream);
              try {
                for (const toolApproval of [
                  ...localDeniedToolApprovals,
                  ...deniedProviderExecutedToolApprovals
                ]) {
                  toolExecutionStepStreamController == null ? void 0 : toolExecutionStepStreamController.enqueue({
                    type: "tool-output-denied",
                    toolCallId: toolApproval.toolCall.toolCallId,
                    toolName: toolApproval.toolCall.toolName
                  });
                }
                const toolOutputs = [];
                await Promise.all(
                  localApprovedToolApprovals.map(async (toolApproval) => {
                    const result = await executeToolCall({
                      toolCall: toolApproval.toolCall,
                      tools,
                      tracer,
                      telemetry,
                      messages: initialMessages,
                      abortSignal,
                      experimental_context,
                      stepNumber: recordedSteps.length,
                      model: modelInfo,
                      onToolCallStart: [
                        onToolCallStart,
                        globalTelemetry.onToolCallStart
                      ],
                      onToolCallFinish: [
                        onToolCallFinish,
                        globalTelemetry.onToolCallFinish
                      ],
                      onPreliminaryToolResult: (result2) => {
                        toolExecutionStepStreamController == null ? void 0 : toolExecutionStepStreamController.enqueue(result2);
                      }
                    });
                    if (result != null) {
                      toolExecutionStepStreamController == null ? void 0 : toolExecutionStepStreamController.enqueue(result);
                      toolOutputs.push(result);
                    }
                  })
                );
                if (providerExecutedToolApprovals.length > 0) {
                  initialResponseMessages.push({
                    role: "tool",
                    content: providerExecutedToolApprovals.map(
                      (toolApproval) => ({
                        type: "tool-approval-response",
                        approvalId: toolApproval.approvalResponse.approvalId,
                        approved: toolApproval.approvalResponse.approved,
                        reason: toolApproval.approvalResponse.reason,
                        providerExecuted: true
                      })
                    )
                  });
                }
                if (toolOutputs.length > 0 || localDeniedToolApprovals.length > 0) {
                  const localToolContent = [];
                  for (const output2 of toolOutputs) {
                    localToolContent.push({
                      type: "tool-result",
                      toolCallId: output2.toolCallId,
                      toolName: output2.toolName,
                      output: await createToolModelOutput({
                        toolCallId: output2.toolCallId,
                        input: output2.input,
                        tool: tools == null ? void 0 : tools[output2.toolName],
                        output: output2.type === "tool-result" ? output2.output : output2.error,
                        errorMode: output2.type === "tool-error" ? "text" : "none"
                      })
                    });
                  }
                  for (const toolApproval of localDeniedToolApprovals) {
                    localToolContent.push({
                      type: "tool-result",
                      toolCallId: toolApproval.toolCall.toolCallId,
                      toolName: toolApproval.toolCall.toolName,
                      output: {
                        type: "execution-denied",
                        reason: toolApproval.approvalResponse.reason
                      }
                    });
                  }
                  initialResponseMessages.push({
                    role: "tool",
                    content: localToolContent
                  });
                }
              } finally {
                toolExecutionStepStreamController == null ? void 0 : toolExecutionStepStreamController.close();
              }
            }
            recordedResponseMessages.push(...initialResponseMessages);
            async function streamStep({
              currentStep,
              responseMessages,
              usage
            }) {
              var _a212, _b27, _c, _d, _e, _f, _g, _h, _i;
              const includeRawChunks2 = self2.includeRawChunks;
              const stepTimeoutId = stepTimeoutMs != null ? setTimeout(() => stepAbortController.abort(), stepTimeoutMs) : void 0;
              let chunkTimeoutId = void 0;
              function resetChunkTimeout() {
                if (chunkTimeoutMs != null) {
                  if (chunkTimeoutId != null) {
                    clearTimeout(chunkTimeoutId);
                  }
                  chunkTimeoutId = setTimeout(
                    () => chunkAbortController.abort(),
                    chunkTimeoutMs
                  );
                }
              }
              function clearChunkTimeout() {
                if (chunkTimeoutId != null) {
                  clearTimeout(chunkTimeoutId);
                  chunkTimeoutId = void 0;
                }
              }
              function clearStepTimeout() {
                if (stepTimeoutId != null) {
                  clearTimeout(stepTimeoutId);
                }
              }
              try {
                stepFinish = new DelayedPromise();
                const stepInputMessages = [...initialMessages, ...responseMessages];
                const prepareStepResult = await (prepareStep == null ? void 0 : prepareStep({
                  model,
                  steps: recordedSteps,
                  stepNumber: recordedSteps.length,
                  messages: stepInputMessages,
                  experimental_context
                }));
                const stepModel = resolveLanguageModel(
                  (_a212 = prepareStepResult == null ? void 0 : prepareStepResult.model) != null ? _a212 : model
                );
                const stepModelInfo = {
                  provider: stepModel.provider,
                  modelId: stepModel.modelId
                };
                const promptMessages = await convertToLanguageModelPrompt({
                  prompt: {
                    system: (_b27 = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _b27 : initialPrompt.system,
                    messages: (_c = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _c : stepInputMessages
                  },
                  supportedUrls: await stepModel.supportedUrls,
                  download: download2
                });
                const stepActiveTools = (_d = prepareStepResult == null ? void 0 : prepareStepResult.activeTools) != null ? _d : activeTools;
                const { toolChoice: stepToolChoice, tools: stepTools } = await prepareToolsAndToolChoice({
                  tools,
                  toolChoice: (_e = prepareStepResult == null ? void 0 : prepareStepResult.toolChoice) != null ? _e : toolChoice,
                  activeTools: stepActiveTools
                });
                experimental_context = (_f = prepareStepResult == null ? void 0 : prepareStepResult.experimental_context) != null ? _f : experimental_context;
                const stepMessages = (_g = prepareStepResult == null ? void 0 : prepareStepResult.messages) != null ? _g : stepInputMessages;
                const stepSystem = (_h = prepareStepResult == null ? void 0 : prepareStepResult.system) != null ? _h : initialPrompt.system;
                const stepProviderOptions = mergeObjects(
                  providerOptions,
                  prepareStepResult == null ? void 0 : prepareStepResult.providerOptions
                );
                await notify({
                  event: {
                    stepNumber: recordedSteps.length,
                    model: stepModelInfo,
                    system: stepSystem,
                    messages: stepMessages,
                    tools,
                    toolChoice: stepToolChoice,
                    activeTools: stepActiveTools,
                    steps: [...recordedSteps],
                    providerOptions: stepProviderOptions,
                    timeout,
                    headers,
                    stopWhen,
                    output,
                    abortSignal: originalAbortSignal,
                    include,
                    ...callbackTelemetryProps,
                    experimental_context
                  },
                  callbacks: [
                    onStepStart,
                    globalTelemetry.onStepStart
                  ]
                });
                const {
                  result: { stream: stream22, response, request },
                  doStreamSpan,
                  startTimestampMs
                } = await retry(
                  () => recordSpan({
                    name: "ai.streamText.doStream",
                    attributes: selectTelemetryAttributes({
                      telemetry,
                      attributes: {
                        ...assembleOperationName({
                          operationId: "ai.streamText.doStream",
                          telemetry
                        }),
                        ...baseTelemetryAttributes,
                        // model:
                        "ai.model.provider": stepModel.provider,
                        "ai.model.id": stepModel.modelId,
                        // prompt:
                        "ai.prompt.messages": {
                          input: () => stringifyForTelemetry(promptMessages)
                        },
                        "ai.prompt.tools": {
                          // convert the language model level tools:
                          input: () => stepTools == null ? void 0 : stepTools.map((tool22) => JSON.stringify(tool22))
                        },
                        "ai.prompt.toolChoice": {
                          input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : void 0
                        },
                        // standardized gen-ai llm span attributes:
                        "gen_ai.system": stepModel.provider,
                        "gen_ai.request.model": stepModel.modelId,
                        "gen_ai.request.frequency_penalty": callSettings.frequencyPenalty,
                        "gen_ai.request.max_tokens": callSettings.maxOutputTokens,
                        "gen_ai.request.presence_penalty": callSettings.presencePenalty,
                        "gen_ai.request.stop_sequences": callSettings.stopSequences,
                        "gen_ai.request.temperature": callSettings.temperature,
                        "gen_ai.request.top_k": callSettings.topK,
                        "gen_ai.request.top_p": callSettings.topP
                      }
                    }),
                    tracer,
                    endWhenDone: false,
                    fn: async (doStreamSpan2) => ({
                      startTimestampMs: now2(),
                      // get before the call
                      doStreamSpan: doStreamSpan2,
                      result: await stepModel.doStream({
                        ...callSettings,
                        tools: stepTools,
                        toolChoice: stepToolChoice,
                        responseFormat: await (output == null ? void 0 : output.responseFormat),
                        prompt: promptMessages,
                        providerOptions: stepProviderOptions,
                        abortSignal,
                        headers,
                        includeRawChunks: includeRawChunks2
                      })
                    })
                  })
                );
                const streamWithToolResults = runToolsTransformation({
                  tools,
                  generatorStream: stream22,
                  tracer,
                  telemetry,
                  system,
                  messages: stepInputMessages,
                  repairToolCall,
                  abortSignal,
                  experimental_context,
                  generateId: generateId22,
                  stepNumber: recordedSteps.length,
                  model: stepModelInfo,
                  onToolCallStart: [
                    onToolCallStart,
                    globalTelemetry.onToolCallStart
                  ],
                  onToolCallFinish: [
                    onToolCallFinish,
                    globalTelemetry.onToolCallFinish
                  ]
                });
                const stepRequest = ((_i = include == null ? void 0 : include.requestBody) != null ? _i : true) ? request != null ? request : {} : { ...request, body: void 0 };
                const stepToolCalls = [];
                const stepToolOutputs = [];
                let warnings;
                const activeToolCallToolNames = {};
                let stepFinishReason = "other";
                let stepRawFinishReason = void 0;
                let stepUsage = createNullLanguageModelUsage();
                let stepProviderMetadata;
                let stepFirstChunk = true;
                let stepResponse = {
                  id: generateId22(),
                  timestamp: /* @__PURE__ */ new Date(),
                  modelId: modelInfo.modelId
                };
                let activeText = "";
                self2.addStream(
                  streamWithToolResults.pipeThrough(
                    new TransformStream({
                      async transform(chunk, controller) {
                        var _a222, _b28, _c2, _d2, _e2;
                        resetChunkTimeout();
                        if (chunk.type === "stream-start") {
                          warnings = chunk.warnings;
                          return;
                        }
                        if (stepFirstChunk) {
                          const msToFirstChunk = now2() - startTimestampMs;
                          stepFirstChunk = false;
                          doStreamSpan.addEvent("ai.stream.firstChunk", {
                            "ai.response.msToFirstChunk": msToFirstChunk
                          });
                          doStreamSpan.setAttributes({
                            "ai.response.msToFirstChunk": msToFirstChunk
                          });
                          controller.enqueue({
                            type: "start-step",
                            request: stepRequest,
                            warnings: warnings != null ? warnings : []
                          });
                        }
                        const chunkType = chunk.type;
                        switch (chunkType) {
                          case "tool-approval-request":
                          case "text-start":
                          case "text-end": {
                            controller.enqueue(chunk);
                            break;
                          }
                          case "text-delta": {
                            if (chunk.delta.length > 0) {
                              controller.enqueue({
                                type: "text-delta",
                                id: chunk.id,
                                text: chunk.delta,
                                providerMetadata: chunk.providerMetadata
                              });
                              activeText += chunk.delta;
                            }
                            break;
                          }
                          case "reasoning-start":
                          case "reasoning-end": {
                            controller.enqueue(chunk);
                            break;
                          }
                          case "reasoning-delta": {
                            controller.enqueue({
                              type: "reasoning-delta",
                              id: chunk.id,
                              text: chunk.delta,
                              providerMetadata: chunk.providerMetadata
                            });
                            break;
                          }
                          case "tool-call": {
                            controller.enqueue(chunk);
                            stepToolCalls.push(chunk);
                            break;
                          }
                          case "tool-result": {
                            controller.enqueue(chunk);
                            if (!chunk.preliminary) {
                              stepToolOutputs.push(chunk);
                            }
                            break;
                          }
                          case "tool-error": {
                            controller.enqueue(chunk);
                            stepToolOutputs.push(chunk);
                            break;
                          }
                          case "response-metadata": {
                            stepResponse = {
                              id: (_a222 = chunk.id) != null ? _a222 : stepResponse.id,
                              timestamp: (_b28 = chunk.timestamp) != null ? _b28 : stepResponse.timestamp,
                              modelId: (_c2 = chunk.modelId) != null ? _c2 : stepResponse.modelId
                            };
                            break;
                          }
                          case "finish": {
                            stepUsage = chunk.usage;
                            stepFinishReason = chunk.finishReason;
                            stepRawFinishReason = chunk.rawFinishReason;
                            stepProviderMetadata = chunk.providerMetadata;
                            const msToFinish = now2() - startTimestampMs;
                            doStreamSpan.addEvent("ai.stream.finish");
                            doStreamSpan.setAttributes({
                              "ai.response.msToFinish": msToFinish,
                              "ai.response.avgOutputTokensPerSecond": 1e3 * ((_d2 = stepUsage.outputTokens) != null ? _d2 : 0) / msToFinish
                            });
                            break;
                          }
                          case "file": {
                            controller.enqueue(chunk);
                            break;
                          }
                          case "source": {
                            controller.enqueue(chunk);
                            break;
                          }
                          case "tool-input-start": {
                            activeToolCallToolNames[chunk.id] = chunk.toolName;
                            const tool22 = tools == null ? void 0 : tools[chunk.toolName];
                            if ((tool22 == null ? void 0 : tool22.onInputStart) != null) {
                              await tool22.onInputStart({
                                toolCallId: chunk.id,
                                messages: stepInputMessages,
                                abortSignal,
                                experimental_context
                              });
                            }
                            controller.enqueue({
                              ...chunk,
                              dynamic: (_e2 = chunk.dynamic) != null ? _e2 : (tool22 == null ? void 0 : tool22.type) === "dynamic",
                              title: tool22 == null ? void 0 : tool22.title
                            });
                            break;
                          }
                          case "tool-input-end": {
                            delete activeToolCallToolNames[chunk.id];
                            controller.enqueue(chunk);
                            break;
                          }
                          case "tool-input-delta": {
                            const toolName = activeToolCallToolNames[chunk.id];
                            const tool22 = tools == null ? void 0 : tools[toolName];
                            if ((tool22 == null ? void 0 : tool22.onInputDelta) != null) {
                              await tool22.onInputDelta({
                                inputTextDelta: chunk.delta,
                                toolCallId: chunk.id,
                                messages: stepInputMessages,
                                abortSignal,
                                experimental_context
                              });
                            }
                            controller.enqueue(chunk);
                            break;
                          }
                          case "error": {
                            controller.enqueue(chunk);
                            stepFinishReason = "error";
                            break;
                          }
                          case "raw": {
                            if (includeRawChunks2) {
                              controller.enqueue(chunk);
                            }
                            break;
                          }
                          default: {
                            const exhaustiveCheck = chunkType;
                            throw new Error(
                              `Unknown chunk type: ${exhaustiveCheck}`
                            );
                          }
                        }
                      },
                      // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
                      async flush(controller) {
                        var _a222, _b28, _c2, _d2, _e2, _f2, _g2;
                        const stepToolCallsJson = stepToolCalls.length > 0 ? JSON.stringify(stepToolCalls) : void 0;
                        try {
                          doStreamSpan.setAttributes(
                            await selectTelemetryAttributes({
                              telemetry,
                              attributes: {
                                "ai.response.finishReason": stepFinishReason,
                                "ai.response.toolCalls": {
                                  output: () => stepToolCallsJson
                                },
                                "ai.response.id": stepResponse.id,
                                "ai.response.model": stepResponse.modelId,
                                "ai.response.timestamp": stepResponse.timestamp.toISOString(),
                                "ai.usage.inputTokens": stepUsage.inputTokens,
                                "ai.usage.inputTokenDetails.noCacheTokens": (_a222 = stepUsage.inputTokenDetails) == null ? void 0 : _a222.noCacheTokens,
                                "ai.usage.inputTokenDetails.cacheReadTokens": (_b28 = stepUsage.inputTokenDetails) == null ? void 0 : _b28.cacheReadTokens,
                                "ai.usage.inputTokenDetails.cacheWriteTokens": (_c2 = stepUsage.inputTokenDetails) == null ? void 0 : _c2.cacheWriteTokens,
                                "ai.usage.outputTokens": stepUsage.outputTokens,
                                "ai.usage.outputTokenDetails.textTokens": (_d2 = stepUsage.outputTokenDetails) == null ? void 0 : _d2.textTokens,
                                "ai.usage.outputTokenDetails.reasoningTokens": (_e2 = stepUsage.outputTokenDetails) == null ? void 0 : _e2.reasoningTokens,
                                "ai.usage.totalTokens": stepUsage.totalTokens,
                                "ai.usage.reasoningTokens": (_f2 = stepUsage.outputTokenDetails) == null ? void 0 : _f2.reasoningTokens,
                                "ai.usage.cachedInputTokens": (_g2 = stepUsage.inputTokenDetails) == null ? void 0 : _g2.cacheReadTokens,
                                // standardized gen-ai llm span attributes:
                                "gen_ai.response.finish_reasons": [
                                  stepFinishReason
                                ],
                                "gen_ai.response.id": stepResponse.id,
                                "gen_ai.response.model": stepResponse.modelId,
                                "gen_ai.usage.input_tokens": stepUsage.inputTokens,
                                "gen_ai.usage.output_tokens": stepUsage.outputTokens
                              }
                            })
                          );
                        } catch (error73) {
                        }
                        controller.enqueue({
                          type: "finish-step",
                          finishReason: stepFinishReason,
                          rawFinishReason: stepRawFinishReason,
                          usage: stepUsage,
                          providerMetadata: stepProviderMetadata,
                          response: {
                            ...stepResponse,
                            headers: response == null ? void 0 : response.headers
                          }
                        });
                        const combinedUsage = addLanguageModelUsage(
                          usage,
                          stepUsage
                        );
                        await stepFinish.promise;
                        const processedStep = recordedSteps[recordedSteps.length - 1];
                        try {
                          doStreamSpan.setAttributes(
                            await selectTelemetryAttributes({
                              telemetry,
                              attributes: {
                                "ai.response.text": {
                                  output: () => processedStep.text
                                },
                                "ai.response.reasoning": {
                                  output: () => processedStep.reasoningText
                                },
                                "ai.response.providerMetadata": JSON.stringify(
                                  processedStep.providerMetadata
                                )
                              }
                            })
                          );
                        } catch (error73) {
                        } finally {
                          doStreamSpan.end();
                        }
                        const clientToolCalls = stepToolCalls.filter(
                          (toolCall) => toolCall.providerExecuted !== true
                        );
                        const clientToolOutputs = stepToolOutputs.filter(
                          (toolOutput) => toolOutput.providerExecuted !== true
                        );
                        for (const toolCall of stepToolCalls) {
                          if (toolCall.providerExecuted !== true)
                            continue;
                          const tool22 = tools == null ? void 0 : tools[toolCall.toolName];
                          if ((tool22 == null ? void 0 : tool22.type) === "provider" && tool22.supportsDeferredResults) {
                            const hasResultInStep = stepToolOutputs.some(
                              (output2) => (output2.type === "tool-result" || output2.type === "tool-error") && output2.toolCallId === toolCall.toolCallId
                            );
                            if (!hasResultInStep) {
                              pendingDeferredToolCalls.set(toolCall.toolCallId, {
                                toolName: toolCall.toolName
                              });
                            }
                          }
                        }
                        for (const output2 of stepToolOutputs) {
                          if (output2.type === "tool-result" || output2.type === "tool-error") {
                            pendingDeferredToolCalls.delete(output2.toolCallId);
                          }
                        }
                        clearStepTimeout();
                        clearChunkTimeout();
                        if (
                          // Continue if:
                          // 1. There are client tool calls that have all been executed, OR
                          // 2. There are pending deferred results from provider-executed tools
                          (clientToolCalls.length > 0 && clientToolOutputs.length === clientToolCalls.length || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
                          !await isStopConditionMet({
                            stopConditions,
                            steps: recordedSteps
                          })
                        ) {
                          responseMessages.push(
                            ...await toResponseMessages({
                              content: (
                                // use transformed content to create the messages for the next step:
                                recordedSteps[recordedSteps.length - 1].content
                              ),
                              tools
                            })
                          );
                          try {
                            await streamStep({
                              currentStep: currentStep + 1,
                              responseMessages,
                              usage: combinedUsage
                            });
                          } catch (error73) {
                            controller.enqueue({
                              type: "error",
                              error: error73
                            });
                            self2.closeStream();
                          }
                        } else {
                          controller.enqueue({
                            type: "finish",
                            finishReason: stepFinishReason,
                            rawFinishReason: stepRawFinishReason,
                            totalUsage: combinedUsage
                          });
                          self2.closeStream();
                        }
                      }
                    })
                  )
                );
              } finally {
                clearStepTimeout();
                clearChunkTimeout();
              }
            }
            await streamStep({
              currentStep: 0,
              responseMessages: initialResponseMessages,
              usage: createNullLanguageModelUsage()
            });
          }
        }).catch((error73) => {
          self2.addStream(
            new ReadableStream({
              start(controller) {
                controller.enqueue({ type: "error", error: error73 });
                controller.close();
              }
            })
          );
          self2.closeStream();
        });
      }
      get steps() {
        this.consumeStream();
        return this._steps.promise;
      }
      get finalStep() {
        return this.steps.then((steps) => steps[steps.length - 1]);
      }
      get content() {
        return this.finalStep.then((step) => step.content);
      }
      get warnings() {
        return this.finalStep.then((step) => step.warnings);
      }
      get providerMetadata() {
        return this.finalStep.then((step) => step.providerMetadata);
      }
      get text() {
        return this.finalStep.then((step) => step.text);
      }
      get reasoningText() {
        return this.finalStep.then((step) => step.reasoningText);
      }
      get reasoning() {
        return this.finalStep.then((step) => step.reasoning);
      }
      get sources() {
        return this.finalStep.then((step) => step.sources);
      }
      get files() {
        return this.finalStep.then((step) => step.files);
      }
      get toolCalls() {
        return this.finalStep.then((step) => step.toolCalls);
      }
      get staticToolCalls() {
        return this.finalStep.then((step) => step.staticToolCalls);
      }
      get dynamicToolCalls() {
        return this.finalStep.then((step) => step.dynamicToolCalls);
      }
      get toolResults() {
        return this.finalStep.then((step) => step.toolResults);
      }
      get staticToolResults() {
        return this.finalStep.then((step) => step.staticToolResults);
      }
      get dynamicToolResults() {
        return this.finalStep.then((step) => step.dynamicToolResults);
      }
      get usage() {
        return this.finalStep.then((step) => step.usage);
      }
      get request() {
        return this.finalStep.then((step) => step.request);
      }
      get response() {
        return this.finalStep.then((step) => step.response);
      }
      get totalUsage() {
        this.consumeStream();
        return this._totalUsage.promise;
      }
      get finishReason() {
        this.consumeStream();
        return this._finishReason.promise;
      }
      get rawFinishReason() {
        this.consumeStream();
        return this._rawFinishReason.promise;
      }
      /**
       * Split out a new stream from the original stream.
       * The original stream is replaced to allow for further splitting,
       * since we do not know how many times the stream will be split.
       *
       * Note: this leads to buffering the stream content on the server.
       * However, the LLM results are expected to be small enough to not cause issues.
       */
      teeStream() {
        const [stream1, stream22] = this.baseStream.tee();
        this.baseStream = stream22;
        return stream1;
      }
      get textStream() {
        return createAsyncIterableStream(
          this.teeStream().pipeThrough(
            new TransformStream({
              transform({ part }, controller) {
                if (part.type === "text-delta") {
                  controller.enqueue(part.text);
                }
              }
            })
          )
        );
      }
      get fullStream() {
        return createAsyncIterableStream(
          this.teeStream().pipeThrough(
            new TransformStream({
              transform({ part }, controller) {
                controller.enqueue(part);
              }
            })
          )
        );
      }
      async consumeStream(options) {
        var _a212;
        try {
          await consumeStream({
            stream: this.fullStream,
            onError: options == null ? void 0 : options.onError
          });
        } catch (error73) {
          (_a212 = options == null ? void 0 : options.onError) == null ? void 0 : _a212.call(options, error73);
        }
      }
      get experimental_partialOutputStream() {
        return this.partialOutputStream;
      }
      get partialOutputStream() {
        return createAsyncIterableStream(
          this.teeStream().pipeThrough(
            new TransformStream({
              transform({ partialOutput }, controller) {
                if (partialOutput != null) {
                  controller.enqueue(partialOutput);
                }
              }
            })
          )
        );
      }
      get elementStream() {
        var _a212, _b27, _c;
        const transform8 = (_a212 = this.outputSpecification) == null ? void 0 : _a212.createElementStreamTransform();
        if (transform8 == null) {
          throw new UnsupportedFunctionalityError({
            functionality: `element streams in ${(_c = (_b27 = this.outputSpecification) == null ? void 0 : _b27.name) != null ? _c : "text"} mode`
          });
        }
        return createAsyncIterableStream(this.teeStream().pipeThrough(transform8));
      }
      get output() {
        return this.finalStep.then((step) => {
          var _a212;
          const output = (_a212 = this.outputSpecification) != null ? _a212 : text();
          return output.parseCompleteOutput(
            { text: step.text },
            {
              response: step.response,
              usage: step.usage,
              finishReason: step.finishReason
            }
          );
        });
      }
      toUIMessageStream({
        originalMessages,
        generateMessageId,
        onFinish,
        messageMetadata,
        sendReasoning = true,
        sendSources = false,
        sendStart = true,
        sendFinish = true,
        onError = getErrorMessage
      } = {}) {
        const responseMessageId = generateMessageId != null ? getResponseUIMessageId({
          originalMessages,
          responseMessageId: generateMessageId
        }) : void 0;
        const isDynamic = (part) => {
          var _a212;
          const tool22 = (_a212 = this.tools) == null ? void 0 : _a212[part.toolName];
          if (tool22 == null) {
            return part.dynamic;
          }
          return (tool22 == null ? void 0 : tool22.type) === "dynamic" ? true : void 0;
        };
        const baseStream = this.fullStream.pipeThrough(
          new TransformStream({
            transform: async (part, controller) => {
              const messageMetadataValue = messageMetadata == null ? void 0 : messageMetadata({ part });
              const partType = part.type;
              switch (partType) {
                case "text-start": {
                  controller.enqueue({
                    type: "text-start",
                    id: part.id,
                    ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
                  });
                  break;
                }
                case "text-delta": {
                  controller.enqueue({
                    type: "text-delta",
                    id: part.id,
                    delta: part.text,
                    ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
                  });
                  break;
                }
                case "text-end": {
                  controller.enqueue({
                    type: "text-end",
                    id: part.id,
                    ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
                  });
                  break;
                }
                case "reasoning-start": {
                  controller.enqueue({
                    type: "reasoning-start",
                    id: part.id,
                    ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
                  });
                  break;
                }
                case "reasoning-delta": {
                  if (sendReasoning) {
                    controller.enqueue({
                      type: "reasoning-delta",
                      id: part.id,
                      delta: part.text,
                      ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
                    });
                  }
                  break;
                }
                case "reasoning-end": {
                  controller.enqueue({
                    type: "reasoning-end",
                    id: part.id,
                    ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
                  });
                  break;
                }
                case "file": {
                  controller.enqueue({
                    type: "file",
                    mediaType: part.file.mediaType,
                    url: `data:${part.file.mediaType};base64,${part.file.base64}`,
                    ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
                  });
                  break;
                }
                case "source": {
                  if (sendSources && part.sourceType === "url") {
                    controller.enqueue({
                      type: "source-url",
                      sourceId: part.id,
                      url: part.url,
                      title: part.title,
                      ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
                    });
                  }
                  if (sendSources && part.sourceType === "document") {
                    controller.enqueue({
                      type: "source-document",
                      sourceId: part.id,
                      mediaType: part.mediaType,
                      title: part.title,
                      filename: part.filename,
                      ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
                    });
                  }
                  break;
                }
                case "tool-input-start": {
                  const dynamic = isDynamic(part);
                  controller.enqueue({
                    type: "tool-input-start",
                    toolCallId: part.id,
                    toolName: part.toolName,
                    ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
                    ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
                    ...dynamic != null ? { dynamic } : {},
                    ...part.title != null ? { title: part.title } : {}
                  });
                  break;
                }
                case "tool-input-delta": {
                  controller.enqueue({
                    type: "tool-input-delta",
                    toolCallId: part.id,
                    inputTextDelta: part.delta
                  });
                  break;
                }
                case "tool-call": {
                  const dynamic = isDynamic(part);
                  if (part.invalid) {
                    controller.enqueue({
                      type: "tool-input-error",
                      toolCallId: part.toolCallId,
                      toolName: part.toolName,
                      input: part.input,
                      ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
                      ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
                      ...dynamic != null ? { dynamic } : {},
                      errorText: onError(part.error),
                      ...part.title != null ? { title: part.title } : {}
                    });
                  } else {
                    controller.enqueue({
                      type: "tool-input-available",
                      toolCallId: part.toolCallId,
                      toolName: part.toolName,
                      input: part.input,
                      ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
                      ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
                      ...dynamic != null ? { dynamic } : {},
                      ...part.title != null ? { title: part.title } : {}
                    });
                  }
                  break;
                }
                case "tool-approval-request": {
                  controller.enqueue({
                    type: "tool-approval-request",
                    approvalId: part.approvalId,
                    toolCallId: part.toolCall.toolCallId
                  });
                  break;
                }
                case "tool-result": {
                  const dynamic = isDynamic(part);
                  controller.enqueue({
                    type: "tool-output-available",
                    toolCallId: part.toolCallId,
                    output: part.output,
                    ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
                    ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
                    ...part.preliminary != null ? { preliminary: part.preliminary } : {},
                    ...dynamic != null ? { dynamic } : {}
                  });
                  break;
                }
                case "tool-error": {
                  const dynamic = isDynamic(part);
                  controller.enqueue({
                    type: "tool-output-error",
                    toolCallId: part.toolCallId,
                    errorText: part.providerExecuted ? typeof part.error === "string" ? part.error : JSON.stringify(part.error) : onError(part.error),
                    ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
                    ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
                    ...dynamic != null ? { dynamic } : {}
                  });
                  break;
                }
                case "tool-output-denied": {
                  controller.enqueue({
                    type: "tool-output-denied",
                    toolCallId: part.toolCallId
                  });
                  break;
                }
                case "error": {
                  controller.enqueue({
                    type: "error",
                    errorText: onError(part.error)
                  });
                  break;
                }
                case "start-step": {
                  controller.enqueue({ type: "start-step" });
                  break;
                }
                case "finish-step": {
                  controller.enqueue({ type: "finish-step" });
                  break;
                }
                case "start": {
                  if (sendStart) {
                    controller.enqueue({
                      type: "start",
                      ...messageMetadataValue != null ? { messageMetadata: messageMetadataValue } : {},
                      ...responseMessageId != null ? { messageId: responseMessageId } : {}
                    });
                  }
                  break;
                }
                case "finish": {
                  if (sendFinish) {
                    controller.enqueue({
                      type: "finish",
                      finishReason: part.finishReason,
                      ...messageMetadataValue != null ? { messageMetadata: messageMetadataValue } : {}
                    });
                  }
                  break;
                }
                case "abort": {
                  controller.enqueue(part);
                  break;
                }
                case "tool-input-end": {
                  break;
                }
                case "raw": {
                  break;
                }
                default: {
                  const exhaustiveCheck = partType;
                  throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
                }
              }
              if (messageMetadataValue != null && partType !== "start" && partType !== "finish") {
                controller.enqueue({
                  type: "message-metadata",
                  messageMetadata: messageMetadataValue
                });
              }
            }
          })
        );
        return createAsyncIterableStream(
          handleUIMessageStreamFinish({
            stream: baseStream,
            messageId: responseMessageId != null ? responseMessageId : generateMessageId == null ? void 0 : generateMessageId(),
            originalMessages,
            onFinish,
            onError
          })
        );
      }
      pipeUIMessageStreamToResponse(response, {
        originalMessages,
        generateMessageId,
        onFinish,
        messageMetadata,
        sendReasoning,
        sendSources,
        sendFinish,
        sendStart,
        onError,
        ...init
      } = {}) {
        pipeUIMessageStreamToResponse({
          response,
          stream: this.toUIMessageStream({
            originalMessages,
            generateMessageId,
            onFinish,
            messageMetadata,
            sendReasoning,
            sendSources,
            sendFinish,
            sendStart,
            onError
          }),
          ...init
        });
      }
      pipeTextStreamToResponse(response, init) {
        pipeTextStreamToResponse({
          response,
          textStream: this.textStream,
          ...init
        });
      }
      toUIMessageStreamResponse({
        originalMessages,
        generateMessageId,
        onFinish,
        messageMetadata,
        sendReasoning,
        sendSources,
        sendFinish,
        sendStart,
        onError,
        ...init
      } = {}) {
        return createUIMessageStreamResponse({
          stream: this.toUIMessageStream({
            originalMessages,
            generateMessageId,
            onFinish,
            messageMetadata,
            sendReasoning,
            sendSources,
            sendFinish,
            sendStart,
            onError
          }),
          ...init
        });
      }
      toTextStreamResponse(init) {
        return createTextStreamResponse({
          textStream: this.textStream,
          ...init
        });
      }
    };
    uiMessagesSchema = lazySchema(
      () => zodSchema(
        external_exports.array(
          external_exports.object({
            id: external_exports.string(),
            role: external_exports.enum(["system", "user", "assistant"]),
            metadata: external_exports.unknown().optional(),
            parts: external_exports.array(
              external_exports.union([
                external_exports.object({
                  type: external_exports.literal("text"),
                  text: external_exports.string(),
                  state: external_exports.enum(["streaming", "done"]).optional(),
                  providerMetadata: providerMetadataSchema.optional()
                }),
                external_exports.object({
                  type: external_exports.literal("reasoning"),
                  text: external_exports.string(),
                  state: external_exports.enum(["streaming", "done"]).optional(),
                  providerMetadata: providerMetadataSchema.optional()
                }),
                external_exports.object({
                  type: external_exports.literal("source-url"),
                  sourceId: external_exports.string(),
                  url: external_exports.string(),
                  title: external_exports.string().optional(),
                  providerMetadata: providerMetadataSchema.optional()
                }),
                external_exports.object({
                  type: external_exports.literal("source-document"),
                  sourceId: external_exports.string(),
                  mediaType: external_exports.string(),
                  title: external_exports.string(),
                  filename: external_exports.string().optional(),
                  providerMetadata: providerMetadataSchema.optional()
                }),
                external_exports.object({
                  type: external_exports.literal("file"),
                  mediaType: external_exports.string(),
                  filename: external_exports.string().optional(),
                  url: external_exports.string(),
                  providerMetadata: providerMetadataSchema.optional()
                }),
                external_exports.object({
                  type: external_exports.literal("step-start")
                }),
                external_exports.object({
                  type: external_exports.string().startsWith("data-"),
                  id: external_exports.string().optional(),
                  data: external_exports.unknown()
                }),
                external_exports.object({
                  type: external_exports.literal("dynamic-tool"),
                  toolName: external_exports.string(),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("input-streaming"),
                  input: external_exports.unknown().optional(),
                  providerExecuted: external_exports.boolean().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  approval: external_exports.never().optional()
                }),
                external_exports.object({
                  type: external_exports.literal("dynamic-tool"),
                  toolName: external_exports.string(),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("input-available"),
                  input: external_exports.unknown(),
                  providerExecuted: external_exports.boolean().optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.never().optional()
                }),
                external_exports.object({
                  type: external_exports.literal("dynamic-tool"),
                  toolName: external_exports.string(),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("approval-requested"),
                  input: external_exports.unknown(),
                  providerExecuted: external_exports.boolean().optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.never().optional(),
                    reason: external_exports.never().optional()
                  })
                }),
                external_exports.object({
                  type: external_exports.literal("dynamic-tool"),
                  toolName: external_exports.string(),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("approval-responded"),
                  input: external_exports.unknown(),
                  providerExecuted: external_exports.boolean().optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.boolean(),
                    reason: external_exports.string().optional()
                  })
                }),
                external_exports.object({
                  type: external_exports.literal("dynamic-tool"),
                  toolName: external_exports.string(),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("output-available"),
                  input: external_exports.unknown(),
                  providerExecuted: external_exports.boolean().optional(),
                  output: external_exports.unknown(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  resultProviderMetadata: providerMetadataSchema.optional(),
                  preliminary: external_exports.boolean().optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.literal(true),
                    reason: external_exports.string().optional()
                  }).optional()
                }),
                external_exports.object({
                  type: external_exports.literal("dynamic-tool"),
                  toolName: external_exports.string(),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("output-error"),
                  input: external_exports.unknown(),
                  rawInput: external_exports.unknown().optional(),
                  providerExecuted: external_exports.boolean().optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.string(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  resultProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.literal(true),
                    reason: external_exports.string().optional()
                  }).optional()
                }),
                external_exports.object({
                  type: external_exports.literal("dynamic-tool"),
                  toolName: external_exports.string(),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("output-denied"),
                  input: external_exports.unknown(),
                  providerExecuted: external_exports.boolean().optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.literal(false),
                    reason: external_exports.string().optional()
                  })
                }),
                external_exports.object({
                  type: external_exports.string().startsWith("tool-"),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("input-streaming"),
                  providerExecuted: external_exports.boolean().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  input: external_exports.unknown().optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  approval: external_exports.never().optional()
                }),
                external_exports.object({
                  type: external_exports.string().startsWith("tool-"),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("input-available"),
                  providerExecuted: external_exports.boolean().optional(),
                  input: external_exports.unknown(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.never().optional()
                }),
                external_exports.object({
                  type: external_exports.string().startsWith("tool-"),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("approval-requested"),
                  input: external_exports.unknown(),
                  providerExecuted: external_exports.boolean().optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.never().optional(),
                    reason: external_exports.never().optional()
                  })
                }),
                external_exports.object({
                  type: external_exports.string().startsWith("tool-"),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("approval-responded"),
                  input: external_exports.unknown(),
                  providerExecuted: external_exports.boolean().optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.boolean(),
                    reason: external_exports.string().optional()
                  })
                }),
                external_exports.object({
                  type: external_exports.string().startsWith("tool-"),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("output-available"),
                  providerExecuted: external_exports.boolean().optional(),
                  input: external_exports.unknown(),
                  output: external_exports.unknown(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  resultProviderMetadata: providerMetadataSchema.optional(),
                  preliminary: external_exports.boolean().optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.literal(true),
                    reason: external_exports.string().optional()
                  }).optional()
                }),
                external_exports.object({
                  type: external_exports.string().startsWith("tool-"),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("output-error"),
                  providerExecuted: external_exports.boolean().optional(),
                  input: external_exports.unknown(),
                  rawInput: external_exports.unknown().optional(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.string(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  resultProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.literal(true),
                    reason: external_exports.string().optional()
                  }).optional()
                }),
                external_exports.object({
                  type: external_exports.string().startsWith("tool-"),
                  toolCallId: external_exports.string(),
                  state: external_exports.literal("output-denied"),
                  providerExecuted: external_exports.boolean().optional(),
                  input: external_exports.unknown(),
                  output: external_exports.never().optional(),
                  errorText: external_exports.never().optional(),
                  callProviderMetadata: providerMetadataSchema.optional(),
                  approval: external_exports.object({
                    id: external_exports.string(),
                    approved: external_exports.literal(false),
                    reason: external_exports.string().optional()
                  })
                })
              ])
            ).nonempty("Message must contain at least one part")
          })
        ).nonempty("Messages array must not be empty")
      )
    );
    originalGenerateId3 = createIdGenerator({ prefix: "aiobj", size: 24 });
    originalGenerateId4 = createIdGenerator({ prefix: "aiobj", size: 24 });
    defaultDownload = createDownload();
    wrapLanguageModel = ({
      model,
      middleware: middlewareArg,
      modelId,
      providerId
    }) => {
      return [...asArray(middlewareArg)].reverse().reduce((wrappedModel, middleware) => {
        return doWrap({ model: wrappedModel, middleware, modelId, providerId });
      }, model);
    };
    doWrap = ({
      model,
      middleware: {
        transformParams,
        wrapGenerate,
        wrapStream,
        overrideProvider,
        overrideModelId,
        overrideSupportedUrls
      },
      modelId,
      providerId
    }) => {
      var _a212, _b27, _c;
      async function doTransform({
        params,
        type
      }) {
        return transformParams ? await transformParams({ params, type, model }) : params;
      }
      return {
        specificationVersion: "v3",
        provider: (_a212 = providerId != null ? providerId : overrideProvider == null ? void 0 : overrideProvider({ model })) != null ? _a212 : model.provider,
        modelId: (_b27 = modelId != null ? modelId : overrideModelId == null ? void 0 : overrideModelId({ model })) != null ? _b27 : model.modelId,
        supportedUrls: (_c = overrideSupportedUrls == null ? void 0 : overrideSupportedUrls({ model })) != null ? _c : model.supportedUrls,
        async doGenerate(params) {
          const transformedParams = await doTransform({ params, type: "generate" });
          const doGenerate = async () => model.doGenerate(transformedParams);
          const doStream = async () => model.doStream(transformedParams);
          return wrapGenerate ? wrapGenerate({
            doGenerate,
            doStream,
            params: transformedParams,
            model
          }) : doGenerate();
        },
        async doStream(params) {
          const transformedParams = await doTransform({ params, type: "stream" });
          const doGenerate = async () => model.doGenerate(transformedParams);
          const doStream = async () => model.doStream(transformedParams);
          return wrapStream ? wrapStream({ doGenerate, doStream, params: transformedParams, model }) : doStream();
        }
      };
    };
    name202 = "AI_NoSuchProviderError";
    marker202 = `vercel.ai.error.${name202}`;
    symbol202 = Symbol.for(marker202);
    _a202 = symbol202;
    defaultDownload2 = createDownload();
  }
});

// node_modules/@ai-sdk/devtools/dist/index.js
var import_node_path3, import_node_fs, DB_DIR, DB_PATH, DEVTOOLS_PORT, notifyServer, notifyServerAsync, ensureGitignore, readDb, writeDb, dbCache, getDb, saveDb, createRun, createStep, updateStepResult, generateId5, activeSteps, signalHandlersRegistered, registerSignalHandlers, generateRunId, devToolsMiddleware;
var init_dist23 = __esm({
  "node_modules/@ai-sdk/devtools/dist/index.js"() {
    "use strict";
    import_node_path3 = __toESM(require("node:path"), 1);
    import_node_fs = __toESM(require("node:fs"), 1);
    DB_DIR = import_node_path3.default.join(process.cwd(), ".devtools");
    DB_PATH = import_node_path3.default.join(DB_DIR, "generations.json");
    DEVTOOLS_PORT = process.env.AI_SDK_DEVTOOLS_PORT ? parseInt(process.env.AI_SDK_DEVTOOLS_PORT) : 4983;
    notifyServer = (event) => {
      notifyServerAsync(event);
    };
    notifyServerAsync = async (event) => {
      try {
        await fetch(`http://localhost:${DEVTOOLS_PORT}/api/notify`, {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({ event, timestamp: Date.now() })
        });
      } catch {
      }
    };
    ensureGitignore = () => {
      const gitignorePath = import_node_path3.default.join(process.cwd(), ".gitignore");
      if (!import_node_fs.default.existsSync(gitignorePath)) {
        return;
      }
      const content = import_node_fs.default.readFileSync(gitignorePath, "utf-8");
      const lines = content.split("\n");
      const alreadyIgnored = lines.some(
        (line) => line.trim() === ".devtools" || line.trim() === ".devtools/"
      );
      if (!alreadyIgnored) {
        const newContent = content.endsWith("\n") ? `${content}.devtools
` : `${content}
.devtools
`;
        import_node_fs.default.writeFileSync(gitignorePath, newContent);
      }
    };
    readDb = () => {
      try {
        if (import_node_fs.default.existsSync(DB_PATH)) {
          const content = import_node_fs.default.readFileSync(DB_PATH, "utf-8");
          return JSON.parse(content);
        }
      } catch {
      }
      return { runs: [], steps: [] };
    };
    writeDb = (db2) => {
      const isFirstRun = !import_node_fs.default.existsSync(DB_DIR);
      if (isFirstRun) {
        import_node_fs.default.mkdirSync(DB_DIR, { recursive: true });
        ensureGitignore();
      }
      import_node_fs.default.writeFileSync(DB_PATH, JSON.stringify(db2, null, 2));
    };
    dbCache = null;
    getDb = () => {
      if (!dbCache) {
        dbCache = readDb();
      }
      return dbCache;
    };
    saveDb = (db2) => {
      dbCache = db2;
      writeDb(db2);
    };
    createRun = async (id) => {
      const db2 = getDb();
      const started_at = (/* @__PURE__ */ new Date()).toISOString();
      const existing = db2.runs.find((r) => r.id === id);
      if (existing) {
        return existing;
      }
      const run = { id, started_at };
      db2.runs.push(run);
      saveDb(db2);
      notifyServer("run");
      return run;
    };
    createStep = async (step) => {
      const db2 = getDb();
      const newStep = {
        ...step,
        duration_ms: null,
        output: null,
        usage: null,
        error: null,
        raw_request: null,
        raw_response: null,
        raw_chunks: null
      };
      db2.steps.push(newStep);
      saveDb(db2);
      notifyServer("step");
    };
    updateStepResult = async (stepId, result) => {
      const db2 = getDb();
      const step = db2.steps.find((s) => s.id === stepId);
      if (step) {
        step.duration_ms = result.duration_ms;
        step.output = result.output;
        step.usage = result.usage;
        step.error = result.error;
        step.raw_request = result.raw_request ?? null;
        step.raw_response = result.raw_response ?? null;
        step.raw_chunks = result.raw_chunks ?? null;
        saveDb(db2);
        notifyServer("step-update");
      }
    };
    generateId5 = () => crypto.randomUUID();
    activeSteps = /* @__PURE__ */ new Map();
    signalHandlersRegistered = false;
    registerSignalHandlers = () => {
      if (signalHandlersRegistered) return;
      signalHandlersRegistered = true;
      const cleanup = async () => {
        if (activeSteps.size === 0) return;
        const promises6 = Array.from(activeSteps.entries()).map(
          async ([stepId, data]) => {
            const durationMs = Date.now() - data.startTime;
            await updateStepResult(stepId, {
              duration_ms: durationMs,
              output: JSON.stringify(data.collectedOutput),
              usage: null,
              error: "Request aborted",
              raw_request: data.request && typeof data.request === "object" && "body" in data.request ? JSON.stringify(data.request.body) : null,
              raw_response: JSON.stringify(data.fullStreamChunks),
              raw_chunks: JSON.stringify(data.rawChunks)
            });
          }
        );
        await Promise.all(promises6);
        await notifyServerAsync("step-update");
      };
      process.on("SIGINT", () => {
        cleanup().then(() => process.exit(130));
      });
      process.on("SIGTERM", () => {
        cleanup().then(() => process.exit(143));
      });
    };
    generateRunId = () => {
      const now2 = /* @__PURE__ */ new Date();
      const timestamp = now2.toISOString().replace(/[-:T.Z]/g, "").slice(0, 17);
      const uniqueId = crypto.randomUUID().slice(0, 8);
      return `${timestamp}-${uniqueId}`;
    };
    devToolsMiddleware = () => {
      if (process.env.NODE_ENV === "production") {
        throw new Error(
          "@ai-sdk/devtools should not be used in production. Remove devToolsMiddleware from your model configuration for production builds."
        );
      }
      registerSignalHandlers();
      const runId = generateRunId();
      let runCreated = false;
      let stepCounter = 0;
      const ensureRunCreated = async () => {
        if (!runCreated) {
          await createRun(runId);
          runCreated = true;
        }
      };
      const getNextStepNumber = () => {
        stepCounter++;
        return stepCounter;
      };
      return {
        specificationVersion: "v3",
        wrapGenerate: async ({ doGenerate, params, model }) => {
          const startTime = Date.now();
          const stepId = generateId5();
          const stepNumber = getNextStepNumber();
          await ensureRunCreated();
          await createStep({
            id: stepId,
            run_id: runId,
            step_number: stepNumber,
            type: "generate",
            model_id: model.modelId,
            // @ts-expect-error broken type
            provider: model.config?.provider,
            started_at: (/* @__PURE__ */ new Date()).toISOString(),
            input: JSON.stringify({
              prompt: params.prompt,
              tools: params.tools,
              toolChoice: params.toolChoice,
              maxOutputTokens: params.maxOutputTokens,
              temperature: params.temperature,
              topP: params.topP,
              topK: params.topK,
              presencePenalty: params.presencePenalty,
              frequencyPenalty: params.frequencyPenalty,
              seed: params.seed,
              responseFormat: params.responseFormat
            }),
            provider_options: params.providerOptions ? JSON.stringify(params.providerOptions) : null
          });
          try {
            const result = await doGenerate();
            const durationMs = Date.now() - startTime;
            await updateStepResult(stepId, {
              duration_ms: durationMs,
              output: JSON.stringify({
                content: result.content,
                finishReason: result.finishReason,
                response: result.response
              }),
              usage: result.usage ? JSON.stringify(result.usage) : null,
              error: null,
              raw_request: result.request?.body ? JSON.stringify(result.request.body) : null,
              raw_response: result.response?.body ? JSON.stringify(result.response.body) : null
            });
            return result;
          } catch (error73) {
            const durationMs = Date.now() - startTime;
            await updateStepResult(stepId, {
              duration_ms: durationMs,
              output: null,
              usage: null,
              error: error73 instanceof Error ? error73.message : String(error73),
              raw_request: null,
              raw_response: null
            });
            throw error73;
          }
        },
        wrapStream: async ({ doStream, params, model }) => {
          const startTime = Date.now();
          const stepId = generateId5();
          const stepNumber = getNextStepNumber();
          await ensureRunCreated();
          const userRequestedRawChunks = params.includeRawChunks === true;
          params.includeRawChunks = true;
          await createStep({
            id: stepId,
            run_id: runId,
            step_number: stepNumber,
            type: "stream",
            model_id: model.modelId,
            // @ts-expect-error broken type
            provider: model.config?.provider,
            started_at: (/* @__PURE__ */ new Date()).toISOString(),
            input: JSON.stringify({
              prompt: params.prompt,
              tools: params.tools,
              toolChoice: params.toolChoice,
              maxOutputTokens: params.maxOutputTokens,
              temperature: params.temperature,
              topP: params.topP,
              topK: params.topK,
              presencePenalty: params.presencePenalty,
              frequencyPenalty: params.frequencyPenalty,
              seed: params.seed,
              responseFormat: params.responseFormat
            }),
            provider_options: params.providerOptions ? JSON.stringify(params.providerOptions) : null
          });
          try {
            const { stream: stream4, request, response, ...rest } = await doStream();
            const collectedOutput = {
              textParts: [],
              reasoningParts: [],
              toolCalls: []
            };
            const currentText = /* @__PURE__ */ new Map();
            const currentReasoning = /* @__PURE__ */ new Map();
            const fullStreamChunks = [];
            const rawChunks = [];
            activeSteps.set(stepId, {
              startTime,
              collectedOutput,
              request,
              fullStreamChunks,
              rawChunks
            });
            const transformStream = new TransformStream({
              transform(chunk, controller) {
                if (chunk.type === "raw") {
                  rawChunks.push(chunk.rawValue);
                  if (userRequestedRawChunks) {
                    controller.enqueue(chunk);
                  }
                  return;
                }
                fullStreamChunks.push(chunk);
                switch (chunk.type) {
                  case "text-start":
                    currentText.set(chunk.id, "");
                    break;
                  case "text-delta":
                    currentText.set(
                      chunk.id,
                      (currentText.get(chunk.id) ?? "") + chunk.delta
                    );
                    break;
                  case "text-end":
                    collectedOutput.textParts.push({
                      id: chunk.id,
                      text: currentText.get(chunk.id) ?? ""
                    });
                    break;
                  case "reasoning-start":
                    currentReasoning.set(chunk.id, "");
                    break;
                  case "reasoning-delta":
                    currentReasoning.set(
                      chunk.id,
                      (currentReasoning.get(chunk.id) ?? "") + chunk.delta
                    );
                    break;
                  case "reasoning-end":
                    collectedOutput.reasoningParts.push({
                      id: chunk.id,
                      text: currentReasoning.get(chunk.id) ?? ""
                    });
                    break;
                  case "tool-call":
                    collectedOutput.toolCalls.push(chunk);
                    break;
                  case "finish":
                    collectedOutput.finishReason = chunk.finishReason;
                    collectedOutput.usage = chunk.usage;
                    break;
                }
                controller.enqueue(chunk);
              },
              async flush() {
                activeSteps.delete(stepId);
                const durationMs = Date.now() - startTime;
                await updateStepResult(stepId, {
                  duration_ms: durationMs,
                  output: JSON.stringify(collectedOutput),
                  usage: collectedOutput.usage ? JSON.stringify(collectedOutput.usage) : null,
                  error: null,
                  raw_request: request?.body ? JSON.stringify(request.body) : null,
                  raw_response: JSON.stringify(fullStreamChunks),
                  raw_chunks: JSON.stringify(rawChunks)
                });
              },
              // @ts-expect-error - cancel is valid per WHATWG Streams spec but missing from TS types
              async cancel() {
                activeSteps.delete(stepId);
                const durationMs = Date.now() - startTime;
                await updateStepResult(stepId, {
                  duration_ms: durationMs,
                  output: JSON.stringify(collectedOutput),
                  usage: collectedOutput.usage ? JSON.stringify(collectedOutput.usage) : null,
                  error: "Request aborted",
                  raw_request: request?.body ? JSON.stringify(request.body) : null,
                  raw_response: JSON.stringify(fullStreamChunks),
                  raw_chunks: JSON.stringify(rawChunks)
                });
              }
            });
            return {
              stream: stream4.pipeThrough(transformStream),
              request,
              response,
              ...rest
            };
          } catch (error73) {
            activeSteps.delete(stepId);
            const durationMs = Date.now() - startTime;
            await updateStepResult(stepId, {
              duration_ms: durationMs,
              output: null,
              usage: null,
              error: error73 instanceof Error ? error73.message : String(error73),
              raw_request: null,
              raw_response: null,
              raw_chunks: null
            });
            throw error73;
          }
        }
      };
    };
  }
});

// src/utils/ai.ts
async function resolveModelName(value) {
  if (AiTypeValues.includes(value)) {
    const agentUseMode = await getUserSettingValue("agentUseMode");
    if (agentUseMode == "1") {
      const agentDeployData2 = await getAgentDeployForUser(value);
      if (!agentDeployData2?.modelName) throw new Error(`\u9AD8\u7EA7\u914D\u7F6E\u6A21\u5F0F\u4E0B\uFF0C\u672A\u627E\u5230\u5BF9\u5E94\u7684\u6A21\u578B\u914D\u7F6E ${value}`);
      return agentDeployData2?.modelName;
    }
    if (agentUseMode == "0") {
      const [mainly] = value.split(/:(.+)/);
      const mainlyData = await getAgentDeployForUser(mainly);
      if (!mainlyData?.modelName) throw new Error(`\u7B80\u6613\u914D\u7F6E\u6A21\u5F0F\u4E0B\uFF0C\u672A\u627E\u5230\u90E8\u7F72\u914D\u7F6E ${value}`);
      return mainlyData?.modelName;
    }
    const agentDeployData = await getAgentDeployForUser(value);
    let modelName = null;
    if (!agentDeployData?.modelName) {
      const [mainly] = agentDeployData.key.split(/:(.+)/);
      const mainlyData = await getAgentDeployForUser(mainly);
      if (!mainlyData?.modelName) throw new Error(`\u672A\u627E\u5230\u90E8\u7F72\u914D\u7F6E ${value}`);
      modelName = mainlyData.modelName;
    }
    modelName = agentDeployData?.modelName || modelName;
    return modelName;
  }
  return value;
}
async function getModelConfig(value) {
  if (AiTypeValues.includes(value)) {
    const agentUseMode = await getUserSettingValue("agentUseMode");
    if (agentUseMode == "1") {
      const agentDeployData2 = await getAgentDeployForUser(value);
      if (!agentDeployData2?.modelName) throw new Error(`\u9AD8\u7EA7\u914D\u7F6E\u6A21\u5F0F\u4E0B\uFF0C\u672A\u627E\u5230\u5BF9\u5E94\u7684\u6A21\u578B\u914D\u7F6E ${value}`);
      return agentDeployData2;
    }
    if (agentUseMode == "0") {
      const [mainly] = value.split(/:(.+)/);
      const mainlyData = await getAgentDeployForUser(mainly);
      if (!mainlyData?.modelName) throw new Error(`\u7B80\u6613\u914D\u7F6E\u6A21\u5F0F\u4E0B\uFF0C\u672A\u627E\u5230\u90E8\u7F72\u914D\u7F6E ${value}`);
      return mainlyData;
    }
    const agentDeployData = await getAgentDeployForUser(value);
    if (!agentDeployData?.modelName) {
      const [mainly] = agentDeployData.key.split(/:(.+)/);
      const mainlyData = await getAgentDeployForUser(mainly);
      if (!mainlyData?.modelName) throw new Error(`\u672A\u627E\u5230\u90E8\u7F72\u914D\u7F6E ${value}`);
      return mainlyData;
    }
    return agentDeployData;
  }
  return null;
}
async function getVendorTemplateFn(fnName, modelName) {
  const [id, name28] = modelName.split(/:(.+)/);
  const vendorConfigData = await getVendorConfigForUser(id);
  if (!vendorConfigData) throw new Error(`\u672A\u627E\u5230\u4F9B\u5E94\u5546\u914D\u7F6E id=${id}`);
  const modelList = await utils_default.vendor.getModelList(id);
  const selectedModel = modelList.find((i) => i.modelName == name28);
  if (!selectedModel) throw new Error(`\u672A\u627E\u5230\u6A21\u578B ${name28} id=${id}`);
  const code = utils_default.vendor.getCode(id);
  const jsCode = (0, import_sucrase2.transform)(code, { transforms: ["typescript"] }).code;
  const running = utils_default.vm(jsCode);
  if (running.vendor) {
    Object.assign(running.vendor.inputValues, parseJson(vendorConfigData.inputValues, {}));
    running.vendor.models = modelList;
  }
  const fn = running[fnName];
  if (!fn) throw new Error(`\u672A\u627E\u5230\u4F9B\u5E94\u5546\u914D\u7F6E\u4E2D\u7684\u51FD\u6570 ${fnName} id=${id}`);
  if (fnName == "textRequest")
    return (think, thinkLevel = 0) => {
      const effectiveThink = think ?? !!selectedModel.think;
      return fn(selectedModel, effectiveThink, thinkLevel);
    };
  else return (input) => fn(input, selectedModel);
}
async function withTaskRecord(modelKey, taskClass, describe4, relatedObjects, projectId, fn) {
  const modelName = await resolveModelName(modelKey);
  const [_, model] = modelName.split(/:(.+)/);
  const taskRecord2 = await utils_default.task(projectId, taskClass, model, { describe: describe4, content: relatedObjects });
  try {
    const result = await fn(modelName, false, 0);
    taskRecord2(1);
    return result;
  } catch (e) {
    taskRecord2(-1, utils_default.error(e).message);
    throw new Error(utils_default.error(e).message);
  }
}
async function urlToBase642(url4, retries = 3, delay2 = 1e3) {
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      const res = await axios_default.get(url4, { responseType: "arraybuffer" });
      const base644 = Buffer.from(res.data).toString("base64");
      return `${base644}`;
    } catch (e) {
      if (attempt === retries) throw e;
      await new Promise((resolve3) => setTimeout(resolve3, delay2 * attempt));
    }
  }
  throw new Error("urlToBase64 failed");
}
function referenceList2imageBase642(id, input) {
  const version3 = utils_default.vendor.getVendor(id).version;
  if (!version3 || isNaN(parseFloat(version3)) || parseFloat(version3) < 2) {
    input.imageBase64 = input.referenceList.map((item) => item.base64);
    return input;
  }
  return input;
}
var import_sucrase2, AiTypeValues, AiText, AiImage, AiVideo, AiAudio, ai_default;
var init_ai = __esm({
  "src/utils/ai.ts"() {
    "use strict";
    init_dist22();
    init_dist23();
    init_axios2();
    import_sucrase2 = __toESM(require_dist5());
    init_utils3();
    init_userConfig();
    AiTypeValues = [
      "scriptAgent",
      "productionAgent",
      "universalAi",
      "scriptAgent:decisionAgent",
      "scriptAgent:supervisionAgent",
      "scriptAgent:storySkeletonAgent",
      "scriptAgent:adaptationStrategyAgent",
      "scriptAgent:scriptAgent",
      "productionAgent:decisionAgent",
      "productionAgent:supervisionAgent",
      "productionAgent:deriveAssetsAgent",
      "productionAgent:generateAssetsAgent",
      "productionAgent:directorPlanAgent",
      "productionAgent:storyboardGenAgent",
      "productionAgent:storyboardPanelAgent",
      "productionAgent:storyboardTableAgent",
      "universalAi"
    ];
    AiText = class {
      AiType;
      think;
      thinkLevel;
      constructor(AiType, think, thinkLevel = 0) {
        this.AiType = AiType;
        this.think = think;
        this.thinkLevel = thinkLevel;
      }
      async resolveModel(middleware) {
        const switchAiDevTool = await getUserSettingValue("switchAiDevTool");
        const modelName = await resolveModelName(this.AiType);
        const sdkFn = await getVendorTemplateFn("textRequest", modelName);
        const baseModel = await sdkFn(this.think, this.thinkLevel);
        const mws = [
          ...switchAiDevTool === "1" ? [devToolsMiddleware()] : [],
          ...middleware ? Array.isArray(middleware) ? middleware : [middleware] : []
        ];
        return mws.length > 0 ? wrapLanguageModel({ model: baseModel, middleware: mws.length === 1 ? mws[0] : mws }) : baseModel;
      }
      async invoke(input) {
        const config3 = await getModelConfig(this.AiType);
        return generateText({
          ...input.tools && { stopWhen: stepCountIs(Object.keys(input.tools).length * 50) },
          ...input,
          model: await this.resolveModel(),
          ...config3?.temperature && { temperature: config3.temperature },
          ...config3?.maxOutputTokens && { maxOutputTokens: config3.maxOutputTokens }
        });
      }
      async stream(input) {
        const config3 = await getModelConfig(this.AiType);
        return streamText({
          ...input.tools && { stopWhen: stepCountIs(Object.keys(input.tools).length * 50) },
          ...input,
          model: await this.resolveModel(extractReasoningMiddleware({ tagName: "reasoning_content", separator: "\n" })),
          ...config3?.temperature && { temperature: config3.temperature },
          ...config3?.maxOutputTokens && { maxOutputTokens: config3.maxOutputTokens }
        });
      }
    };
    AiImage = class {
      key;
      result = "";
      constructor(key) {
        this.key = key;
      }
      async run(input, taskRecord2) {
        const modelName = await resolveModelName(this.key);
        const exec2 = async (mn) => {
          const fn = await getVendorTemplateFn("imageRequest", mn);
          await referenceList2imageBase642(mn.split(/:(.+)/)[0], input);
          this.result = await fn(input);
          if (this.result.startsWith("http")) this.result = await urlToBase642(this.result);
          return this;
        };
        if (taskRecord2) {
          await withTaskRecord(this.key, taskRecord2.taskClass, taskRecord2.describe, taskRecord2.relatedObjects, taskRecord2.projectId, exec2);
          return this;
        }
        await exec2(modelName);
        return this;
      }
      async save(path33) {
        await utils_default.oss.writeFile(path33, this.result);
        return this;
      }
    };
    AiVideo = class {
      key;
      result = "";
      constructor(key) {
        this.key = key;
      }
      async run(input, taskRecord2) {
        const modelName = await resolveModelName(this.key);
        try {
          const exec2 = async (mn) => {
            const fn = await getVendorTemplateFn("videoRequest", mn);
            await referenceList2imageBase642(mn.split(/:(.+)/)[0], input);
            this.result = await fn(input);
            if (this.result.startsWith("http")) this.result = await urlToBase642(this.result);
          };
          if (taskRecord2) {
            await withTaskRecord(this.key, taskRecord2.taskClass, taskRecord2.describe, taskRecord2.relatedObjects, taskRecord2.projectId, exec2);
            return this;
          }
          await exec2(modelName);
          return this;
        } catch (e) {
          throw e;
        }
      }
      async save(path33) {
        await utils_default.oss.writeFile(path33, this.result);
        return this;
      }
    };
    AiAudio = class {
      key;
      result = "";
      constructor(key) {
        this.key = key;
      }
      async run(input, taskRecord2) {
        const modelName = await resolveModelName(this.key);
        const exec2 = async (mn) => {
          try {
            const fn = await getVendorTemplateFn("ttsRequest", mn);
            await referenceList2imageBase642(mn.split(/:(.+)/)[0], input);
            this.result = await fn(input);
            if (this.result.startsWith("http")) this.result = await urlToBase642(this.result);
            return this;
          } catch (e) {
          }
        };
        if (taskRecord2) {
          return withTaskRecord(this.key, taskRecord2.taskClass, taskRecord2.describe, taskRecord2.relatedObjects, taskRecord2.projectId, exec2);
        }
        return await exec2(modelName);
      }
      async save(path33) {
        await utils_default.oss.writeFile(path33, this.result);
        return this;
      }
    };
    ai_default = {
      Text: (AiType, think, thinkLevel) => new AiText(AiType, think, thinkLevel),
      Image: (key) => new AiImage(key),
      Video: (key) => new AiVideo(key),
      Audio: (key) => new AiAudio(key)
    };
  }
});

// src/utils/getPrompts.ts
async function getPrompts(type) {
  if (type == "event") {
    return `
# \u4E8B\u4EF6\u63D0\u53D6\u6307\u4EE4

\u4F60\u662F\u5C0F\u8BF4\u6587\u672C\u5206\u6790\u52A9\u624B\u3002\u7528\u6237\u6BCF\u6B21\u63D0\u4F9B\u4E00\u4E2A\u7AE0\u8282\u7684\u539F\u6587\uFF0C\u4F60\u63D0\u53D6\u8BE5\u7AE0\u7684\u7ED3\u6784\u5316\u4E8B\u4EF6\u4FE1\u606F\u3002

## \u26A0\uFE0F \u8F93\u51FA\u7EA6\u675F\uFF08\u6700\u9AD8\u4F18\u5148\u7EA7\uFF0C\u8FDD\u53CD\u4EFB\u4F55\u4E00\u6761\u5373\u4E3A\u5931\u8D25\uFF09

1. \u4F60\u7684**\u5B8C\u6574\u56DE\u590D**\u53EA\u6709\u4E00\u884C\uFF0C\u4EE5 \`|\` \u5F00\u5934\u3001\u4EE5 \`|\` \u7ED3\u5C3E\uFF0C\u6070\u597D 7 \u4E2A\u5B57\u6BB5
2. \u56DE\u590D\u7684**\u7B2C\u4E00\u4E2A\u5B57\u7B26**\u5FC5\u987B\u662F \`|\`\uFF0C**\u6700\u540E\u4E00\u4E2A\u5B57\u7B26**\u5FC5\u987B\u662F \`|\`
3. \`|\` \u4E4B\u524D\u4E0D\u8BB8\u6709\u4EFB\u4F55\u5B57\u7B26\u2014\u2014\u6CA1\u6709\u5F15\u5BFC\u8BED\u3001\u6CA1\u6709\u89E3\u91CA\u3001\u6CA1\u6709"\u6839\u636E\u2026\u2026"\u3001\u6CA1\u6709"\u4EE5\u4E0B\u662F\u2026\u2026"
4. \`|\` \u4E4B\u540E\u4E0D\u8BB8\u6709\u4EFB\u4F55\u5B57\u7B26\u2014\u2014\u6CA1\u6709\u603B\u7ED3\u3001\u6CA1\u6709\u63D0\u53D6\u8BF4\u660E\u3001\u6CA1\u6709\u6539\u7F16\u5EFA\u8BAE
5. \u4E0D\u8F93\u51FA\u8868\u5934\u884C\u3001\u5206\u9694\u7EBF\u3001Markdown \u6807\u9898\u3001emoji\u3001\u4EE3\u7801\u5757\u6807\u8BB0

## \u8F93\u51FA\u683C\u5F0F

\`\`\`
| \u7B2CX\u7AE0 {\u7AE0\u8282\u6807\u9898} | {\u6D89\u53CA\u89D2\u8272} | {\u6838\u5FC3\u4E8B\u4EF6} | {\u4E3B\u7EBF\u5173\u7CFB} | {\u4FE1\u606F\u5BC6\u5EA6} | {\u9884\u4F30\u96C6\u957F} | {\u60C5\u7EEA\u5F3A\u5EA6} |
\`\`\`

### \u5B57\u6BB5\u89C4\u8303

| \u5B57\u6BB5 | \u683C\u5F0F\u8981\u6C42 | \u793A\u4F8B |
|------|----------|------|
| \u7AE0\u8282 | \`\u7B2CX\u7AE0 {\u7AE0\u8282\u6807\u9898}\` | \`\u7B2C1\u7AE0 \u804C\u4E1A\u5371\u673A\u4E0E\u8BB8\u613F\` |
| \u6D89\u53CA\u89D2\u8272 | \u6709\u5B9E\u9645\u620F\u4EFD\u7684\u89D2\u8272\uFF0C\u987F\u53F7\u5206\u9694 | \`\u6797\u9038\u3001\u767D\u6709\u5BB9\` |
| \u6838\u5FC3\u4E8B\u4EF6 | 30-60\u5B57\uFF0C\u5FC5\u987B\u542B\u52A8\u4F5C+\u7ED3\u679C | \`\u6797\u9038\u56E0\u89E3\u5BC6\u98CE\u6F6E\u4E8B\u4E1A\u5D29\u584C\uFF0C\u9893\u5E9F\u4E2D\u8BB8\u613F\u89E6\u53D1\u9B54\u6CD5\u7CFB\u7EDF\u7ED1\u5B9A\` |
| \u4E3B\u7EBF\u5173\u7CFB | **\u5FC5\u987B**\u4E3A \`\u5F3A/\u4E2D/\u5F31\uFF083-8\u5B57\u7406\u7531\uFF09\` | \`\u5F3A\uFF08\u52A8\u673A\u5EFA\u7ACB+\u7CFB\u7EDF\u6FC0\u6D3B\uFF09\` |
| \u4FE1\u606F\u5BC6\u5EA6 | \`\u9AD8\` / \`\u4E2D\` / \`\u4F4E\` | \`\u9AD8\` |
| \u9884\u4F30\u96C6\u957F | **\u5FC5\u987B**\u4E3A \`X\u79D2\`\uFF0C\u7981\u6B62\u7528\u5206\u949F | \`50\u79D2\` |
| \u60C5\u7EEA\u5F3A\u5EA6 | \u6587\u5B57\u6807\u7B7E\uFF0C\`+\` \u8FDE\u63A5\uFF0C\u7981\u6B62\u661F\u7EA7/\u6570\u5B57 | \`\u8F6C\u6298+\u60AC\u7591\` |

**\u4E3B\u7EBF\u5173\u7CFB\u5224\u5B9A**\uFF1A\u5F3A\uFF1D\u76F4\u63A5\u63A8\u52A8\u4E3B\u89D2\u5F27\u7EBF\uFF1B\u4E2D\uFF1D\u8865\u5145\u4E16\u754C\u89C2/\u4EBA\u7269\u5173\u7CFB/\u4F0F\u7B14\uFF1B\u5F31\uFF1D\u8FC7\u6E21/\u6C14\u6C1B\u3002

**\u9884\u4F30\u96C6\u957F\u53C2\u8003**\uFF1A\u9AD8\u5BC6\u5EA6+\u9AD8\u60C5\u7EEA\u219245-60\u79D2\uFF1B\u4E2D\u219235-45\u79D2\uFF1B\u4F4E\u219225-35\u79D2\u3002

**\u53EF\u7528\u60C5\u7EEA\u6807\u7B7E**\uFF1A\`\u51B2\u7A81\`\u3001\`\u6050\u6016\`\u3001\`\u60C5\u611F\`\u3001\`\u8F6C\u6298\`\u3001\`\u9AD8\u6F6E\`\u3001\`\u5E73\u94FA\`\u3001\`\u559C\u5267\`\u3001\`\u60AC\u7591\`\u3001\`\u60C5\u611F\u5D29\u6E83\`\u3002

## \u8F93\u51FA\u793A\u4F8B

\u4EE5\u4E0B\u4E24\u4E2A\u793A\u4F8B\u5C55\u793A\u7684\u662F**\u5B8C\u6574\u56DE\u590D**\u2014\u2014\u9664\u8FD9\u4E00\u884C\u5916\u6CA1\u6709\u4EFB\u4F55\u5176\u4ED6\u5185\u5BB9\uFF1A

\`\`\`
| \u7B2C1\u7AE0 \u804C\u4E1A\u5371\u673A\u4E0E\u8BB8\u613F | \u6797\u9038 | \u804C\u4E1A\u9B54\u672F\u5E08\u6797\u9038\u56E0\u89E3\u5BC6\u6253\u5047\u98CE\u6F6E\u5BFC\u81F4\u4E8B\u4E1A\u5D29\u584C\uFF0C\u9893\u5E9F\u4E2D\u611F\u6168"\u5982\u679C\u4F1A\u9B54\u6CD5\u5C31\u597D\u4E86"\uFF0C\u610F\u5916\u89E6\u53D1\u795E\u5947\u9B54\u6CD5\u7CFB\u7EDF\u7ED1\u5B9A | \u5F3A\uFF08\u4E3B\u89D2\u52A8\u673A\u5EFA\u7ACB+\u7CFB\u7EDF\u6FC0\u6D3B\uFF09 | \u9AD8 | 50\u79D2 | \u8F6C\u6298+\u60AC\u7591 |
\`\`\`
\`\`\`
| \u7B2C12\u7AE0 \u5C71\u95F4\u5C0F\u61A9 | \u51CC\u7384\u3001\u82CF\u665A\u537F | \u51CC\u7384\u4E0E\u82CF\u665A\u537F\u5728\u5C71\u95F4\u6B47\u811A\uFF0C\u82CF\u665A\u537F\u56DE\u5FC6\u5E7C\u65F6\u5F80\u4E8B\uFF0C\u4E24\u4EBA\u5173\u7CFB\u7565\u6709\u7F13\u548C\u4F46\u672A\u5B9E\u8D28\u63A8\u8FDB | \u5F31\uFF08\u6C14\u6C1B\u8FC7\u6E21\uFF09 | \u4F4E | 25\u79D2 | \u5E73\u94FA+\u60C5\u611F |
\`\`\`

## \u63D0\u53D6\u89C4\u5219

- \u5FE0\u4E8E\u539F\u6587\uFF0C\u4E0D\u63A8\u6D4B\u3001\u4E0D\u8111\u8865\u3001\u4E0D\u52A0\u5165\u539F\u6587\u672A\u51FA\u73B0\u7684\u60C5\u8282
- \u89D2\u8272\u4F7F\u7528\u6587\u4E2D\u4E3B\u8981\u79F0\u547C\uFF0C\u4FDD\u6301\u4E00\u81F4
- \u591A\u6761\u5E73\u884C\u4E8B\u4EF6\u7EBF\u65F6\uFF0C\u9009\u5BF9\u4E3B\u89D2\u5F71\u54CD\u6700\u5927\u7684\u4E00\u6761\uFF0C\u5176\u4F59\u7B80\u8981\u5E26\u8FC7
- \u5BF9\u8BDD\u5BC6\u96C6\u7AE0\u8282\uFF0C\u5173\u6CE8\u5BF9\u8BDD\u63A8\u52A8\u4E86\u4EC0\u4E48\u7ED3\u679C\uFF0C\u800C\u975E\u590D\u8FF0\u5BF9\u8BDD\u5185\u5BB9
`;
  }
}
var init_getPrompts = __esm({
  "src/utils/getPrompts.ts"() {
    "use strict";
  }
});

// src/utils/getArtPrompt.ts
function getArtPrompt(styleName, source, fileName) {
  const baseDir = getPath_default(["skills", source, styleName]);
  if (!import_fs4.default.existsSync(baseDir)) {
    return "";
  }
  const prefixFile = findFileRecursive(baseDir, "prefix.md");
  const prefixContent = prefixFile ? import_fs4.default.readFileSync(prefixFile, "utf-8") : "";
  const target = fileName.endsWith(".md") ? fileName : `${fileName}.md`;
  const found = findFileRecursive(baseDir, target);
  if (!found) {
    return prefixContent;
  }
  const fileContent = import_fs4.default.readFileSync(found, "utf-8");
  return prefixContent ? `${prefixContent}
${fileContent}` : fileContent;
}
function findFileRecursive(dir, targetName) {
  const entries = import_fs4.default.readdirSync(dir, { withFileTypes: true });
  for (const entry of entries) {
    const fullPath = import_path6.default.join(dir, entry.name);
    if (entry.isFile() && entry.name === targetName) {
      return fullPath;
    }
    if (entry.isDirectory()) {
      const found = findFileRecursive(fullPath, targetName);
      if (found) return found;
    }
  }
  return null;
}
var import_fs4, import_path6;
var init_getArtPrompt = __esm({
  "src/utils/getArtPrompt.ts"() {
    "use strict";
    import_fs4 = __toESM(require("fs"));
    import_path6 = __toESM(require("path"));
    init_getPath();
  }
});

// src/utils/replaceUrl.ts
function replaceUrl(url4) {
  if (typeof url4 !== "string" || !url4.trim()) return "";
  let cleanedPath = "";
  try {
    const pathname = new URL(url4).pathname;
    cleanedPath = pathname.replace(/^\/oss/, "").replace(/^\/smallImage/, "");
  } catch (e) {
    cleanedPath = url4;
  }
  const normalized = import_node_path4.default.posix.normalize(cleanedPath);
  if (normalized.startsWith("../") || normalized === "..") {
    return "";
  }
  return normalized.replace(/^\/+/, "");
}
var import_node_path4;
var init_replaceUrl = __esm({
  "src/utils/replaceUrl.ts"() {
    "use strict";
    import_node_path4 = __toESM(require("node:path"));
  }
});

// src/utils/writeVersion.ts
var import_path7, import_fs5, APP_VERSION, writeVersion_default, getVersion;
var init_writeVersion = __esm({
  "src/utils/writeVersion.ts"() {
    "use strict";
    import_path7 = __toESM(require("path"));
    import_fs5 = __toESM(require("fs"));
    init_getPath();
    APP_VERSION = (() => {
      if (true) {
        return "1.1.7";
      }
      const pkgPath = import_path7.default.resolve(process.cwd(), "package.json");
      const pkg = JSON.parse(import_fs5.default.readFileSync(pkgPath, "utf8"));
      return pkg.version;
    })();
    writeVersion_default = async (version3) => {
      const versionFile = import_path7.default.join(getPath_default(), "version.txt");
      if (!import_fs5.default.existsSync(versionFile)) {
        import_fs5.default.mkdirSync(import_path7.default.dirname(versionFile), { recursive: true });
      }
      await import_fs5.default.promises.writeFile(versionFile, version3 ?? APP_VERSION, "utf8");
    };
    getVersion = async () => {
      const versionFile = import_path7.default.join(getPath_default(), "version.txt");
      if (import_fs5.default.existsSync(versionFile)) {
        return import_fs5.default.readFileSync(versionFile, "utf8");
      }
      if (!import_fs5.default.existsSync(versionFile)) {
        import_fs5.default.mkdirSync(import_path7.default.dirname(versionFile), { recursive: true });
      }
      await import_fs5.default.promises.writeFile(versionFile, APP_VERSION, "utf8");
      return APP_VERSION;
    };
  }
});

// src/utils/vendor.ts
var vendor_exports = {};
__export(vendor_exports, {
  getCode: () => getCode,
  getModelList: () => getModelList,
  getVendor: () => getVendor,
  writeCode: () => writeCode
});
function writeCode(id, tsCode) {
  const rootDir = utils_default.getPath("vendor");
  import_fs6.default.mkdirSync(rootDir, { recursive: true });
  if (import_fs6.default.existsSync(import_path8.default.join(rootDir, `${id}.ts`))) {
    import_fs6.default.writeFileSync(import_path8.default.join(rootDir, `${id}.ts`), tsCode);
  }
  import_fs6.default.writeFileSync(import_path8.default.join(rootDir, `${id}.ts`), tsCode);
}
function getCode(id) {
  const rootDir = utils_default.getPath("vendor");
  const targetFile = import_path8.default.join(rootDir, `${id}.ts`);
  if (!import_fs6.default.existsSync(targetFile)) return "";
  return import_fs6.default.readFileSync(targetFile, "utf-8");
}
async function getModelList(id) {
  const config3 = await getVendorConfigForUser(id);
  if (!config3) return [];
  const code = getCode(id);
  const jsCode = (0, import_sucrase3.transform)(code, { transforms: ["typescript"] }).code;
  const vendorData2 = utils_default.vm(jsCode);
  if (!vendorData2 || !vendorData2.vendor || !vendorData2.vendor.models) return [];
  const combined = [...JSON.parse(JSON.stringify(vendorData2.vendor.models)), ...parseJson(config3.models, [])];
  const map3 = /* @__PURE__ */ new Map();
  for (const m of combined) {
    map3.set(m.modelName, m);
  }
  return [...map3.values()];
}
function getVendor(id) {
  const code = getCode(id);
  const jsCode = (0, import_sucrase3.transform)(code, { transforms: ["typescript"] }).code;
  const vendorData2 = utils_default.vm(jsCode);
  return vendorData2.vendor;
}
var import_sucrase3, import_fs6, import_path8;
var init_vendor2 = __esm({
  "src/utils/vendor.ts"() {
    "use strict";
    import_sucrase3 = __toESM(require_dist5());
    import_fs6 = __toESM(require("fs"));
    import_path8 = __toESM(require("path"));
    init_utils3();
    init_userConfig();
  }
});

// src/utils.ts
var utils_default;
var init_utils3 = __esm({
  "src/utils.ts"() {
    "use strict";
    init_db();
    init_oss();
    init_getConfig();
    init_dist_node();
    init_error();
    init_cleanNovel();
    init_getPath();
    init_vm();
    init_taskRecord();
    init_ai();
    init_getPrompts();
    init_getArtPrompt();
    init_replaceUrl();
    init_writeVersion();
    init_vendor2();
    utils_default = {
      db: db_default,
      oss: oss_default,
      getConfig,
      uuid: v4_default,
      error: error_default,
      cleanNovel: cleanNovel_default,
      vm: runCode,
      getPath: getPath_default,
      Ai: ai_default,
      task: taskRecord,
      getPrompts,
      getArtPrompt,
      replaceUrl,
      writeVersion: writeVersion_default,
      vendor: vendor_exports
    };
  }
});

// src/lib/auth.ts
function getCurrentUser(req) {
  const user = req.user;
  const id = Number(user?.id);
  if (!Number.isFinite(id)) throw new Error("\u672A\u767B\u5F55");
  return {
    id,
    name: String(user?.name ?? "")
  };
}
async function getTokenKey() {
  const tokenData = await db_default("o_setting").where("key", "tokenKey").first();
  return tokenData?.value ?? null;
}
function createAuthToken(user, secret) {
  return import_jsonwebtoken2.default.sign({ id: user.id, name: user.name }, secret, { expiresIn: "180Days" });
}
function normalizeBearerToken(rawToken) {
  const token = Array.isArray(rawToken) ? rawToken[0] : rawToken;
  return (token || "").replace("Bearer ", "");
}
async function verifyAuthToken(rawToken) {
  const secret = await getTokenKey();
  if (!secret) return null;
  const token = normalizeBearerToken(rawToken);
  if (!token) return null;
  try {
    const decoded = import_jsonwebtoken2.default.verify(token, secret);
    const id = Number(decoded.id);
    if (!Number.isFinite(id)) return null;
    return {
      id,
      name: String(decoded.name ?? "")
    };
  } catch {
    return null;
  }
}
function publicUser(user) {
  return {
    id: Number(user.id),
    name: user.name ?? "",
    phone: user.phone ?? ""
  };
}
async function assertProjectAccess(projectId, userId) {
  if (!Number.isFinite(projectId) || !Number.isFinite(userId)) return false;
  const project = await db_default("o_project").where({ id: projectId, userId }).select("id").first();
  return Boolean(project);
}
var import_jsonwebtoken2;
var init_auth = __esm({
  "src/lib/auth.ts"() {
    "use strict";
    import_jsonwebtoken2 = __toESM(require_jsonwebtoken());
    init_db();
  }
});

// src/lib/responseFormat.ts
function success3(data = null, message = "\u6210\u529F") {
  return {
    code: 200,
    data,
    message
  };
}
function error50(message = "", data = null) {
  return {
    code: 400,
    data,
    message
  };
}
var init_responseFormat = __esm({
  "src/lib/responseFormat.ts"() {
    "use strict";
  }
});

// node_modules/zod/locales/index.js
var init_locales2 = __esm({
  "node_modules/zod/locales/index.js"() {
    "use strict";
    init_locales();
  }
});

// src/middleware/middleware.ts
function validateFields(shape, source = "body") {
  const schema = external_exports.object(shape);
  return (req, res, next) => {
    const data = req[source];
    const parseResult = schema.safeParse(data);
    if (!parseResult.success) {
      const errors = parseResult.error.issues.map((issue3) => `\u5B57\u6BB5 ${issue3.path.join(".")} ${issue3.message}`);
      console.error(errors);
      return res.status(400).json(error50("\u53C2\u6570\u9519\u8BEF", errors));
    }
    next();
  };
}
var init_middleware = __esm({
  "src/middleware/middleware.ts"() {
    "use strict";
    init_zod();
    init_responseFormat();
    init_locales2();
    external_exports.config(zh_CN_default());
  }
});

// src/routes/agents/clearMemory.ts
var import_express, router, clearMemory_default;
var init_clearMemory = __esm({
  "src/routes/agents/clearMemory.ts"() {
    "use strict";
    import_express = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router = import_express.default.Router();
    clearMemory_default = router.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        episodesId: external_exports.number().optional(),
        agentType: external_exports.enum(["scriptAgent", "productionAgent"]),
        type: external_exports.enum(["message", "summary", "all"]).optional()
      }),
      async (req, res) => {
        const { projectId, episodesId, agentType, type = "all" } = req.body;
        const isolationKey = `${projectId}:${agentType}${episodesId ? `:${episodesId}` : ""}`;
        if (type === "all") {
          await utils_default.db("memories").where({ isolationKey }).del();
        } else if (type === "message") {
          await utils_default.db("memories").where({ isolationKey, type: "message" }).del();
          await utils_default.db("memories").where({ isolationKey, type: "summary" }).del();
        } else {
          await utils_default.db("memories").where({ isolationKey, type: "message", summarized: 1 }).update({ summarized: 0 });
          await utils_default.db("memories").where({ isolationKey, type: "summary" }).del();
        }
        res.status(200).send(success3(null));
      }
    );
  }
});

// src/routes/agents/getMemory.ts
function normalizeRole(role) {
  return role?.startsWith("assistant") ? "assistant" : "user";
}
var import_express2, router2, getMemory_default;
var init_getMemory = __esm({
  "src/routes/agents/getMemory.ts"() {
    "use strict";
    import_express2 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router2 = import_express2.default.Router();
    getMemory_default = router2.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        agentType: external_exports.enum(["scriptAgent", "productionAgent"]),
        episodesId: external_exports.number().optional()
      }),
      async (req, res) => {
        const { projectId, agentType, episodesId } = req.body;
        const isolationKey = `${projectId}:${agentType}${episodesId ? `:${episodesId}` : ""}`;
        const rows = await utils_default.db("memories").where({ isolationKey, type: "message" }).orderBy("createTime", "asc").select("id", "role", "name", "content", "createTime");
        const history = rows.map((row) => ({
          id: row.id,
          role: normalizeRole(row.role),
          name: row.name ?? void 0,
          status: "complete",
          datetime: new Date(row.createTime).toISOString(),
          content: [{ type: "markdown", status: "complete", data: row.content }],
          createTime: row.createTime
        }));
        res.status(200).send(success3(history));
      }
    );
  }
});

// src/routes/artStyle/addArtStyle.ts
var import_express3, router3, addArtStyle_default;
var init_addArtStyle = __esm({
  "src/routes/artStyle/addArtStyle.ts"() {
    "use strict";
    import_express3 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_dist_node();
    init_responseFormat();
    init_middleware();
    router3 = import_express3.default.Router();
    addArtStyle_default = router3.post(
      "/",
      validateFields({
        name: external_exports.string(),
        fileUrl: external_exports.string(),
        prompt: external_exports.string()
      }),
      async (req, res) => {
        const { name: name28, fileUrl, prompt } = req.body;
        const imagePath = `/artStyle/${v4_default()}.jpg`;
        const matches = fileUrl.match(/^data:image\/\w+;base64,(.+)$/);
        const realBase64 = matches ? matches[1] : fileUrl;
        await utils_default.oss.writeFile(imagePath, Buffer.from(realBase64, "base64"));
        await utils_default.db("o_artStyle").insert({
          name: name28,
          fileUrl: imagePath,
          label: name28,
          prompt
        });
        res.status(200).send(success3("\u827A\u672F\u98CE\u683C\u6DFB\u52A0\u6210\u529F"));
      }
    );
  }
});

// src/routes/artStyle/editArtStyle.ts
var import_express4, router4, editArtStyle_default;
var init_editArtStyle = __esm({
  "src/routes/artStyle/editArtStyle.ts"() {
    "use strict";
    import_express4 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_dist_node();
    init_responseFormat();
    init_middleware();
    router4 = import_express4.default.Router();
    editArtStyle_default = router4.post(
      "/",
      validateFields({
        id: external_exports.number(),
        name: external_exports.string(),
        fileUrl: external_exports.string(),
        prompt: external_exports.string()
      }),
      async (req, res) => {
        const { id, name: name28, fileUrl, prompt } = req.body;
        const imagePath = `/artStyle/${v4_default()}.jpg`;
        const matches = fileUrl.match(/^data:image\/\w+;base64,(.+)$/);
        const realBase64 = matches ? matches[1] : fileUrl;
        await utils_default.oss.writeFile(imagePath, Buffer.from(realBase64, "base64"));
        await utils_default.db("o_artStyle").update({
          name: name28,
          fileUrl: imagePath,
          label: name28,
          prompt
        }).where("id", id);
        res.status(200).send(success3("\u827A\u672F\u98CE\u683C\u7F16\u8F91\u6210\u529F"));
      }
    );
  }
});

// src/routes/artStyle/extractStylePrompt.ts
var import_express5, router5, extractStylePrompt_default;
var init_extractStylePrompt = __esm({
  "src/routes/artStyle/extractStylePrompt.ts"() {
    "use strict";
    import_express5 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router5 = import_express5.default.Router();
    extractStylePrompt_default = router5.post(
      "/",
      validateFields({
        images: external_exports.array(external_exports.string())
      }),
      async (req, res) => {
        const { images } = req.body;
        try {
          const resText = await utils_default.Ai.Text("universalAi").invoke({
            system: '\u8BF7\u6839\u636E\u4EE5\u4E0B\u56FE\u7247\u6570\u636E\uFF0C\u63D0\u53D6\u51FA\u56FE\u7247\u7684\u753B\u98CE\u63D0\u793A\u8BCD\uFF0C\u7528\u4E8E\u751F\u6210\u56FE\u7247\u65F6\u6307\u5B9A\u98CE\u683C\uFF0C\u8981\u6C42\u7B80\u6D01\u4E14\u5177\u6709\u827A\u672F\u6027,\u53EA\u9700\u8981\u753B\u98CE\u63D0\u793A\u8BCD\uFF0C\u4E0D\u9700\u8981\u5176\u4ED6\u5185\u5BB9\uFF1A"\u6BD4\u5982\uFF1A`(\u753B\u98CE\uFF1A2D\u52A8\u6F2B\u98CE\u683C,2d animation style)`,`(\u753B\u98CE\uFF1A\u7167\u7247\u7EA7\u771F\u4EBA\u8D85\u5199\u5B9E,photorealistic, lifelike, ultra detailed)`\uFF0C`(\u753B\u98CE\uFF1A3D\u56FD\u521B,Chinese 3D animation style)`\u7B49,\u5982\u679C\u56FE\u7247\u98CE\u683C\u65E0\u6CD5\u63CF\u8FF0\uFF0C\u53EF\u4EE5\u8FD4\u56DE`\u65E0\u6CD5\u63CF\u8FF0`,\u591A\u5F20\u56FE\u7247\u65F6\uFF0C\u53EA\u8F93\u51FA\u4E00\u4E2A\u7EFC\u5408\u7684\u753B\u98CE\u63D0\u793A\u8BCD\uFF0C\u8981\u6C42\u5305\u542B\u6240\u6709\u56FE\u7247\u7684\u5171\u540C\u98CE\u683C\u7279\u5F81\uFF0C\u8F93\u51FA\u683C\u5F0F\u5FC5\u987B\u4E25\u683C\u6309\u7167\u793A\u4F8B\u4E2D\u7684\u683C\u5F0F\uFF0C\u5FC5\u987B\u5305\u542B`\u753B\u98CE`\u4E8C\u5B57\uFF0C\u4E14\u5FC5\u987B\u4F7F\u7528\u62EC\u53F7\u62EC\u8D77\u6765\uFF0C\u62EC\u53F7\u5185\u5FC5\u987B\u5305\u542B\u4E2D\u6587\u548C\u82F1\u6587\u7684\u753B\u98CE\u63CF\u8FF0\uFF0C\u5E76\u7528\u9017\u53F7\u5206\u9694\uFF0C\u82F1\u6587\u90E8\u5206\u9700\u8981\u7FFB\u8BD1\u6210\u5730\u9053\u7684\u82F1\u6587\u63D0\u793A\u8BCD',
            messages: [
              {
                role: "user",
                content: [
                  ...images.map((image) => ({
                    type: "image",
                    image
                  }))
                ]
              }
            ]
          });
          res.status(200).send(success3(resText.text));
        } catch (e) {
          const err = utils_default.error(e);
          res.status(500).send({ message: err.message });
        }
      }
    );
  }
});

// src/routes/artStyle/getArtStyle.ts
var import_express6, router6, getArtStyle_default;
var init_getArtStyle = __esm({
  "src/routes/artStyle/getArtStyle.ts"() {
    "use strict";
    import_express6 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    router6 = import_express6.default.Router();
    getArtStyle_default = router6.post("/", async (req, res) => {
      const list2 = await utils_default.db("o_artStyle").select("*");
      const data = await Promise.all(
        list2.map(async (item) => {
          const fileUrl = await utils_default.oss.getSmallImageUrl(item.fileUrl);
          return { ...item, fileUrl };
        })
      );
      res.status(200).send(success3(data));
    });
  }
});

// src/routes/assets/addAssets.ts
var import_express7, router7, addAssets_default;
var init_addAssets = __esm({
  "src/routes/assets/addAssets.ts"() {
    "use strict";
    import_express7 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router7 = import_express7.default.Router();
    addAssets_default = router7.post(
      "/",
      validateFields({
        name: external_exports.string(),
        describe: external_exports.string(),
        type: external_exports.string(),
        projectId: external_exports.number(),
        remark: external_exports.string().optional().nullable(),
        prompt: external_exports.string().optional().nullable()
      }),
      async (req, res) => {
        const { name: name28, describe: describe4, type, projectId, remark, prompt } = req.body;
        await utils_default.db("o_assets").insert({
          name: name28,
          describe: describe4,
          type,
          projectId,
          remark,
          prompt,
          startTime: Date.now()
        });
        res.status(200).send(success3({ message: "\u65B0\u589E\u8D44\u4EA7\u6210\u529F" }));
      }
    );
  }
});

// src/routes/assets/addAudioAssets.ts
var import_express8, router8, addAudioAssets_default;
var init_addAudioAssets = __esm({
  "src/routes/assets/addAudioAssets.ts"() {
    "use strict";
    import_express8 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router8 = import_express8.default.Router();
    addAudioAssets_default = router8.post(
      "/",
      validateFields({
        name: external_exports.string(),
        describe: external_exports.string(),
        projectId: external_exports.number(),
        assetsItem: external_exports.array(
          external_exports.object({
            base64: external_exports.string(),
            prompt: external_exports.string(),
            describe: external_exports.string(),
            name: external_exports.string()
          })
        )
      }),
      async (req, res) => {
        const { name: name28, describe: describe4, projectId, assetsItem } = req.body;
        await Promise.all(
          assetsItem.map(async (i) => {
            if (i.base64) {
              const mimeMatch = i.base64.match(/^data:audio\/([^;]+);base64,/);
              const mimeExt = mimeMatch ? mimeMatch[1] : "mp3";
              const mimeToExt = {
                mpeg: "mp3",
                "x-wav": "wav",
                "x-aiff": "aiff",
                "x-m4a": "m4a",
                "x-flac": "flac"
              };
              const ext = mimeToExt[mimeExt] ?? mimeExt;
              const savePath = `/${projectId}/assets/audio/${utils_default.uuid()}.${ext}`;
              const base64Data = i.base64.replace(/^data:[^;]+;base64,/, "");
              await utils_default.oss.writeFile(savePath, base64Data);
              i.src = savePath;
            }
          })
        );
        const [id] = await utils_default.db("o_assets").insert({
          name: name28,
          describe: describe4,
          type: "audio",
          projectId,
          startTime: Date.now()
        });
        for (const item of assetsItem) {
          const [assetsId] = await utils_default.db("o_assets").insert({
            prompt: item.prompt,
            assetsId: id,
            type: "audio",
            describe: item.describe,
            name: item.name,
            projectId,
            startTime: Date.now()
          });
          const [imageId] = await utils_default.db("o_image").insert({
            filePath: item.src,
            type: "audio",
            assetsId,
            state: "\u5DF2\u5B8C\u6210"
          });
          await utils_default.db("o_assets").where("id", assetsId).update({
            imageId
          });
        }
        res.status(200).send(success3({ message: "\u65B0\u589E\u8D44\u4EA7\u6210\u529F" }));
      }
    );
  }
});

// src/routes/assets/batchDelete.ts
var import_express9, router9, batchDelete_default;
var init_batchDelete = __esm({
  "src/routes/assets/batchDelete.ts"() {
    "use strict";
    import_express9 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router9 = import_express9.default.Router();
    batchDelete_default = router9.post(
      "/",
      validateFields({
        id: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { id } = req.body;
        await utils_default.db("o_assets").whereIn("id", id).delete();
        res.status(200).send(success3({ message: "\u5220\u9664\u8D44\u4EA7\u6210\u529F" }));
      }
    );
  }
});

// src/routes/assets/batchGenerationData.ts
var import_express10, router10, batchGenerationData_default;
var init_batchGenerationData = __esm({
  "src/routes/assets/batchGenerationData.ts"() {
    "use strict";
    import_express10 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router10 = import_express10.default.Router();
    batchGenerationData_default = router10.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        type: external_exports.string(),
        name: external_exports.string().optional(),
        page: external_exports.number(),
        limit: external_exports.number()
      }),
      async (req, res) => {
        const { projectId, type, name: name28, page = 1, limit = 10 } = req.body;
        const offset = (page - 1) * limit;
        let query = utils_default.db("o_assets").select("*").where("projectId", projectId).andWhere("type", type);
        if (name28) {
          query = query.andWhere("name", "like", `%${name28}%`);
        }
        const parentAssets = await query.offset(offset).limit(limit);
        const totalQuery = await utils_default.db("o_assets").where("projectId", projectId).andWhere("type", type).andWhere((qb) => {
          if (name28) {
            qb.andWhere("name", "like", `%${name28}%`);
          }
        }).count("* as total").first();
        res.status(200).send(success3({ data: parentAssets, total: totalQuery?.total }));
      }
    );
  }
});

// src/routes/assets/delAssets.ts
var import_express11, router11, delAssets_default;
var init_delAssets = __esm({
  "src/routes/assets/delAssets.ts"() {
    "use strict";
    import_express11 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router11 = import_express11.default.Router();
    delAssets_default = router11.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        const assetsData = await utils_default.db("o_image").where("assetsId", id);
        await Promise.all(
          assetsData.map(
            (i) => i.filePath ? utils_default.oss.deleteFile(i.filePath).catch((e) => {
              if (e?.code !== "ENOENT") throw e;
            }) : Promise.resolve()
          )
        );
        const imageIds = assetsData.map((i) => i.id).filter(Boolean);
        if (imageIds.length > 0) {
          await utils_default.db("o_assets").whereIn("imageId", imageIds).update({ imageId: null });
        }
        await utils_default.db("o_image").where({ assetsId: id }).delete();
        await utils_default.db("o_assets").where({ id }).delete();
        await utils_default.db("o_assets").where("assetsId", id).delete();
        res.status(200).send(success3({ message: "\u5220\u9664\u8D44\u4EA7\u6210\u529F" }));
      }
    );
  }
});

// src/routes/assets/delImage.ts
var import_express12, router12, delImage_default;
var init_delImage = __esm({
  "src/routes/assets/delImage.ts"() {
    "use strict";
    import_express12 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router12 = import_express12.default.Router();
    delImage_default = router12.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        await utils_default.db("o_assets").where({ imageId: id }).update({
          imageId: null
        });
        await utils_default.db("o_image").where({ id }).delete();
        const assetsData = await utils_default.db("o_image").where("id", id);
        await Promise.all(assetsData.map((i) => i.filePath && utils_default.oss.deleteFile(i.filePath)));
        res.status(200).send(success3({ message: "\u8D44\u4EA7\u56FE\u7247\u5220\u9664\u6210\u529F" }));
      }
    );
  }
});

// src/routes/assets/getAssetsApi.ts
async function filterTypeGetFileUrl(url4, type) {
  if (type == "role" || type == "tool" || type == "scene") {
    return await utils_default.oss.getSmallImageUrl(url4);
  } else {
    return await utils_default.oss.getFileUrl(url4);
  }
}
var import_express13, router13, getAssetsApi_default;
var init_getAssetsApi = __esm({
  "src/routes/assets/getAssetsApi.ts"() {
    "use strict";
    import_express13 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router13 = import_express13.default.Router();
    getAssetsApi_default = router13.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        type: external_exports.string(),
        name: external_exports.string().optional(),
        page: external_exports.number(),
        limit: external_exports.number()
      }),
      async (req, res) => {
        const { projectId, type, name: name28, page = 1, limit = 10 } = req.body;
        const offset = (page - 1) * limit;
        let query = utils_default.db("o_assets").leftJoin("o_image", "o_assets.imageId", "o_image.id").select("o_assets.*", "o_image.filePath", "o_image.state").where("o_assets.projectId", projectId).andWhere("o_assets.type", type);
        if (name28) {
          query = query.andWhere("name", "like", `%${name28}%`);
        }
        const parentAssets = await query.where("o_assets.assetsId", null).offset(offset).limit(limit);
        let childQuery = utils_default.db("o_assets").leftJoin("o_image", "o_assets.imageId", "o_image.id").select("o_assets.*", "o_image.filePath", "o_image.state", "o_image.errorReason").where("o_assets.projectId", projectId).andWhere("o_assets.type", type).whereNotNull("o_assets.assetsId");
        if (name28) {
          childQuery = childQuery.andWhere("o_assets.name", "like", `%${name28}%`);
        }
        const childAssets = await childQuery;
        const childAssetsWithSrc = await Promise.all(
          childAssets.map(async (child) => ({
            ...child,
            src: child.filePath && await filterTypeGetFileUrl(child.filePath, child.type)
          }))
        );
        const result = await Promise.all(
          parentAssets.map(async (parent) => ({
            ...parent,
            sonAssets: childAssetsWithSrc.filter((child) => child.assetsId === parent.id),
            src: parent.filePath && await filterTypeGetFileUrl(parent.filePath, parent.type),
            ...parent.type == "audio" ? { sex: parent.describe?.split("|")[0], describe: parent.describe?.split("|")[1] } : {}
          }))
        );
        const totalQuery = await utils_default.db("o_assets").where("projectId", projectId).andWhere("type", type).andWhere("assetsId", null).andWhere((qb) => {
          if (name28) {
            qb.andWhere("name", "like", `%${name28}%`);
          }
        }).count("* as total").first();
        res.status(200).send(success3({ data: result, total: totalQuery?.total }));
      }
    );
  }
});

// src/routes/assets/getImage.ts
var import_express14, router14, getImage_default;
var init_getImage = __esm({
  "src/routes/assets/getImage.ts"() {
    "use strict";
    import_express14 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_zod();
    init_middleware();
    router14 = import_express14.default.Router();
    getImage_default = router14.post(
      "/",
      validateFields({
        assetsId: external_exports.number()
      }),
      async (req, res) => {
        const { assetsId } = req.body;
        const assets = await utils_default.db("o_assets").where("id", assetsId).select("id", "imageId", "type").first();
        const rawTempAssets = await utils_default.db("o_image").where("assetsId", assetsId).select("id", "filePath", "assetsId", "type", "state");
        const tempAssets = await Promise.all(
          rawTempAssets.map(async (item) => ({
            ...item,
            filePath: item.filePath ? await utils_default.oss.getSmallImageUrl(item.filePath) : "",
            selected: assets?.imageId != null && Number(item.id) === Number(assets.imageId)
          }))
        );
        const data = {
          id: assets.id,
          imageId: assets.imageId ?? null,
          tempAssets
        };
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/assets/getMaterialData.ts
var import_express15, router15, getMaterialData_default;
var init_getMaterialData = __esm({
  "src/routes/assets/getMaterialData.ts"() {
    "use strict";
    import_express15 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router15 = import_express15.default.Router();
    getMaterialData_default = router15.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        scriptId: external_exports.number().optional()
      }),
      async (req, res) => {
        const { projectId, scriptId } = req.body;
        const list2 = await utils_default.db("o_assets").leftJoin("o_image", "o_assets.id", "=", "o_image.assetsId").where("o_assets.type", "clip").andWhere("o_assets.projectId", projectId).select("*");
        const data = await Promise.all(
          list2.map(async (item) => ({
            ...item,
            filePath: item.filePath ? await utils_default.oss.getFileUrl(item.filePath) : ""
          }))
        );
        const ending = await utils_default.oss.getFileUrl("/ending.mp4", "assets");
        data.push({
          id: 0,
          name: "AirFlow\u7247\u5C3E",
          filePath: ending,
          type: "clip"
        });
        const trackRows = await utils_default.db("o_videoTrack").where("o_videoTrack.scriptId", scriptId).andWhere("o_videoTrack.projectId", projectId).select("o_videoTrack.id as trackId", "o_videoTrack.videoId");
        const video = await Promise.all(
          trackRows.map(async (track) => {
            const videoItems = await utils_default.db("o_video").where("o_video.videoTrackId", track.trackId).andWhere("o_video.state", "\u751F\u6210\u6210\u529F").select("*");
            const videoList = await Promise.all(
              videoItems.map(async (v) => ({
                id: v.id,
                filePath: v.filePath ? await utils_default.oss.getFileUrl(v.filePath) : "",
                videoTrackId: v.videoTrackId
              }))
            );
            return {
              id: track.trackId,
              videoId: track.videoId,
              video: videoList
            };
          })
        ).then((tracks) => tracks.filter((track) => track.video.length > 0));
        res.status(200).send(success3({ data, video }));
      }
    );
  }
});

// src/routes/assets/pollingImageAssets.ts
var import_express16, router16, pollingImageAssets_default;
var init_pollingImageAssets = __esm({
  "src/routes/assets/pollingImageAssets.ts"() {
    "use strict";
    import_express16 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router16 = import_express16.default.Router();
    pollingImageAssets_default = router16.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        const data = await utils_default.db("o_assets").leftJoin("o_image", "o_assets.imageId", "o_image.id").whereIn("o_assets.id", ids).whereNot("o_image.state", "\u751F\u6210\u4E2D").select("o_image.state", "o_assets.id", "o_image.filePath");
        const result = await Promise.all(
          data.map(async (item) => ({
            ...item,
            filePath: item.filePath ? await utils_default.oss.getSmallImageUrl(item.filePath) : null
          }))
        );
        res.status(200).send(success3(result));
      }
    );
  }
});

// src/routes/assets/pollingPromptAssets.ts
var import_express17, router17, pollingPromptAssets_default;
var init_pollingPromptAssets = __esm({
  "src/routes/assets/pollingPromptAssets.ts"() {
    "use strict";
    import_express17 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router17 = import_express17.default.Router();
    pollingPromptAssets_default = router17.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        const data = await utils_default.db("o_assets").whereIn("id", ids).whereNot("promptState", "\u751F\u6210\u4E2D").select("*");
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/assets/saveAssets.ts
var import_express18, router18, saveAssets_default;
var init_saveAssets = __esm({
  "src/routes/assets/saveAssets.ts"() {
    "use strict";
    import_express18 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_dist_node();
    init_responseFormat();
    init_middleware();
    router18 = import_express18.default.Router();
    saveAssets_default = router18.post(
      "/",
      validateFields({
        id: external_exports.number(),
        projectId: external_exports.number(),
        base64: external_exports.string().optional().nullable(),
        type: external_exports.enum(["role", "scene", "tool"]),
        prompt: external_exports.string().optional().nullable(),
        imageId: external_exports.number().optional().nullable()
      }),
      async (req, res) => {
        const { id, base64: base644, type, prompt, projectId, imageId } = req.body;
        if (base644) {
          const matches = base644.match(/^data:image\/\w+;base64,(.+)$/);
          const realBase64 = matches ? matches[1] : base644;
          const savePath = `/${projectId}/${type}/${v4_default()}.png`;
          await utils_default.oss.writeFile(savePath, Buffer.from(realBase64, "base64"));
          const [idData] = await utils_default.db("o_image").insert({
            assetsId: id,
            filePath: savePath,
            type,
            state: "\u5DF2\u5B8C\u6210"
          });
          await utils_default.db("o_assets").where("id", id).update({
            prompt: prompt ?? "",
            imageId: idData
          });
        } else {
          await utils_default.db("o_assets").where("id", id).update({
            prompt: prompt ?? "",
            imageId
          });
        }
        res.status(200).send(success3({ message: "\u4FDD\u5B58\u8D44\u4EA7\u56FE\u7247\u6210\u529F" }));
      }
    );
  }
});

// src/routes/assets/updateAssets.ts
var import_express19, router19, updateAssets_default;
var init_updateAssets = __esm({
  "src/routes/assets/updateAssets.ts"() {
    "use strict";
    import_express19 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router19 = import_express19.default.Router();
    updateAssets_default = router19.post(
      "/",
      validateFields({
        id: external_exports.number(),
        name: external_exports.string(),
        describe: external_exports.string(),
        remark: external_exports.string().optional().nullable(),
        prompt: external_exports.string().optional().nullable()
      }),
      async (req, res) => {
        const { id, name: name28, describe: describe4, remark, prompt } = req.body;
        await utils_default.db("o_assets").where({ id }).update({
          name: name28,
          describe: describe4,
          remark,
          prompt
        });
        res.status(200).send(success3({ message: "\u66F4\u65B0\u8D44\u4EA7\u6210\u529F" }));
      }
    );
  }
});

// src/routes/assets/updateAudioAssets.ts
var import_express20, router20, updateAudioAssets_default;
var init_updateAudioAssets = __esm({
  "src/routes/assets/updateAudioAssets.ts"() {
    "use strict";
    import_express20 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router20 = import_express20.default.Router();
    updateAudioAssets_default = router20.post(
      "/",
      validateFields({
        id: external_exports.number(),
        name: external_exports.string(),
        describe: external_exports.string(),
        projectId: external_exports.number(),
        assetsItem: external_exports.array(
          external_exports.object({
            src: external_exports.string().optional(),
            id: external_exports.number().optional(),
            base64: external_exports.string().optional(),
            prompt: external_exports.string(),
            describe: external_exports.string(),
            name: external_exports.string()
          })
        )
      }),
      async (req, res) => {
        const { id, name: name28, describe: describe4, projectId, assetsItem } = req.body;
        await Promise.all(
          assetsItem.map(async (i) => {
            if (i.src) {
              i.src = utils_default.replaceUrl(i.src);
            }
            if (i.base64) {
              const mimeMatch = i.base64.match(/^data:audio\/([^;]+);base64,/);
              const mimeExt = mimeMatch ? mimeMatch[1] : "mp3";
              const mimeToExt = {
                mpeg: "mp3",
                "x-wav": "wav",
                "x-aiff": "aiff",
                "x-m4a": "m4a",
                "x-flac": "flac"
              };
              const ext = mimeToExt[mimeExt] ?? mimeExt;
              const savePath = `/${projectId}/assets/audio/${utils_default.uuid()}.${ext}`;
              const base64Data = i.base64.replace(/^data:[^;]+;base64,/, "");
              await utils_default.oss.writeFile(savePath, base64Data);
              i.src = savePath;
            }
          })
        );
        await utils_default.db("o_assets").where("id", id).update({
          name: name28,
          describe: describe4
        });
        const existingItems = await utils_default.db("o_assets").where("assetsId", id).select("id");
        const existingIds = existingItems.map((i) => i.id);
        const incomingIds = assetsItem.filter((i) => i.id).map((i) => i.id);
        const toDeleteIds = existingIds.filter((eid) => !incomingIds.includes(eid));
        if (toDeleteIds.length > 0) {
          const deleteItems = await utils_default.db("o_assets").whereIn("id", toDeleteIds).select("imageId");
          const deleteImageIds = deleteItems.map((i) => i.imageId).filter(Boolean);
          await utils_default.db("o_assets").whereIn("id", toDeleteIds).update({ imageId: null });
          if (deleteImageIds.length > 0) {
            await utils_default.db("o_image").whereIn("id", deleteImageIds).delete();
          }
          await utils_default.db("o_assets").whereIn("id", toDeleteIds).delete();
        }
        for (const item of assetsItem) {
          if (item.id) {
            await utils_default.db("o_assets").where("id", item.id).update({
              prompt: item.prompt,
              describe: item.describe,
              name: item.name
            });
            const itemData = await utils_default.db("o_assets").where("id", item.id).select("imageId").first();
            await utils_default.db("o_image").where("id", itemData?.imageId).update({
              filePath: item.src
            });
          } else {
            const [assetsId] = await utils_default.db("o_assets").insert({
              prompt: item.prompt,
              assetsId: id,
              type: "audio",
              projectId,
              describe: item.describe,
              name: item.name,
              startTime: Date.now()
            });
            const [imageId] = await utils_default.db("o_image").insert({
              filePath: item.src,
              type: "audio",
              assetsId,
              state: "\u5DF2\u5B8C\u6210"
            });
            await utils_default.db("o_assets").where("id", assetsId).update({
              imageId
            });
          }
        }
        res.status(200).send(success3({ message: "\u65B0\u589E\u8D44\u4EA7\u6210\u529F" }));
      }
    );
  }
});

// src/routes/assets/uploadClip.ts
function getExtFromBase64(base64Data) {
  const mime = base64Data.match(/^data:([^;]+);base64,/)?.[1] ?? "";
  const mimeMap = {
    // 图片
    "image/jpeg": "jpeg",
    "image/jpg": "jpg",
    "image/png": "png",
    // 音频
    "audio/mpeg": "mp3",
    "audio/mp3": "mp3",
    "audio/wav": "wav",
    // 视频
    "video/mp4": "mp4",
    "video/webm": "webm"
  };
  return mimeMap[mime] ?? "bin";
}
var import_express21, router21, uploadClip_default;
var init_uploadClip = __esm({
  "src/routes/assets/uploadClip.ts"() {
    "use strict";
    import_express21 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_middleware();
    init_zod();
    init_dist_node();
    router21 = import_express21.default.Router();
    uploadClip_default = router21.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        base64Data: external_exports.string(),
        type: external_exports.string().optional().default("clip"),
        name: external_exports.string()
      }),
      async (req, res) => {
        const { base64Data, projectId, type = "clip", name: name28 } = req.body;
        const ext = getExtFromBase64(base64Data);
        const savePath = `/${projectId}/assets/${v4_default()}.${ext}`;
        await utils_default.oss.writeFile(savePath, Buffer.from(base64Data.match(/base64,([A-Za-z0-9+/=]+)/)[1] ?? "", "base64"));
        const [id] = await utils_default.db("o_assets").insert({
          type,
          projectId,
          name: name28,
          startTime: Date.now()
        });
        const [imageId] = await utils_default.db("o_image").insert({
          filePath: savePath,
          type,
          assetsId: id,
          state: "\u5DF2\u5B8C\u6210"
        });
        await utils_default.db("o_assets").where("id", id).update({
          imageId
        });
        res.status(200).send(success3("\u4E0A\u4F20\u6210\u529F"));
      }
    );
  }
});

// node_modules/yocto-queue/index.js
var Node, Queue;
var init_yocto_queue = __esm({
  "node_modules/yocto-queue/index.js"() {
    "use strict";
    Node = class {
      value;
      next;
      constructor(value) {
        this.value = value;
      }
    };
    Queue = class {
      #head;
      #tail;
      #size;
      constructor() {
        this.clear();
      }
      enqueue(value) {
        const node = new Node(value);
        if (this.#head) {
          this.#tail.next = node;
          this.#tail = node;
        } else {
          this.#head = node;
          this.#tail = node;
        }
        this.#size++;
      }
      dequeue() {
        const current = this.#head;
        if (!current) {
          return;
        }
        this.#head = this.#head.next;
        this.#size--;
        if (!this.#head) {
          this.#tail = void 0;
        }
        return current.value;
      }
      peek() {
        if (!this.#head) {
          return;
        }
        return this.#head.value;
      }
      clear() {
        this.#head = void 0;
        this.#tail = void 0;
        this.#size = 0;
      }
      get size() {
        return this.#size;
      }
      *[Symbol.iterator]() {
        let current = this.#head;
        while (current) {
          yield current.value;
          current = current.next;
        }
      }
      *drain() {
        while (this.#head) {
          yield this.dequeue();
        }
      }
    };
  }
});

// node_modules/p-limit/index.js
function pLimit(concurrency) {
  let rejectOnClear = false;
  if (typeof concurrency === "object") {
    ({ concurrency, rejectOnClear = false } = concurrency);
  }
  validateConcurrency(concurrency);
  if (typeof rejectOnClear !== "boolean") {
    throw new TypeError("Expected `rejectOnClear` to be a boolean");
  }
  const queue = new Queue();
  let activeCount = 0;
  const resumeNext = () => {
    if (activeCount < concurrency && queue.size > 0) {
      activeCount++;
      queue.dequeue().run();
    }
  };
  const next = () => {
    activeCount--;
    resumeNext();
  };
  const run = async (function_, resolve3, arguments_) => {
    const result = (async () => function_(...arguments_))();
    resolve3(result);
    try {
      await result;
    } catch {
    }
    next();
  };
  const enqueue = (function_, resolve3, reject, arguments_) => {
    const queueItem = { reject };
    new Promise((internalResolve) => {
      queueItem.run = internalResolve;
      queue.enqueue(queueItem);
    }).then(run.bind(void 0, function_, resolve3, arguments_));
    if (activeCount < concurrency) {
      resumeNext();
    }
  };
  const generator = (function_, ...arguments_) => new Promise((resolve3, reject) => {
    enqueue(function_, resolve3, reject, arguments_);
  });
  Object.defineProperties(generator, {
    activeCount: {
      get: () => activeCount
    },
    pendingCount: {
      get: () => queue.size
    },
    clearQueue: {
      value() {
        if (!rejectOnClear) {
          queue.clear();
          return;
        }
        const abortError = AbortSignal.abort().reason;
        while (queue.size > 0) {
          queue.dequeue().reject(abortError);
        }
      }
    },
    concurrency: {
      get: () => concurrency,
      set(newConcurrency) {
        validateConcurrency(newConcurrency);
        concurrency = newConcurrency;
        queueMicrotask(() => {
          while (activeCount < concurrency && queue.size > 0) {
            resumeNext();
          }
        });
      }
    },
    map: {
      async value(iterable, function_) {
        const promises6 = Array.from(iterable, (value, index) => this(function_, value, index));
        return Promise.all(promises6);
      }
    }
  });
  return generator;
}
function validateConcurrency(concurrency) {
  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
  }
}
var init_p_limit = __esm({
  "node_modules/p-limit/index.js"() {
    "use strict";
    init_yocto_queue();
  }
});

// src/routes/assetsGenerate/batchGenerateImageAssets.ts
function buildPrompt(cfg, artStyle, name28, prompt) {
  return `
    \u8BF7\u6839\u636E\u4EE5\u4E0B\u53C2\u6570\u751F\u6210${cfg.promptTitle}\uFF1A

    **\u57FA\u7840\u53C2\u6570\uFF1A**
    - \u753B\u98CE\u98CE\u683C: ${artStyle || "\u672A\u6307\u5B9A"}

    **${cfg.label}\u8BBE\u5B9A\uFF1A**
    - \u540D\u79F0:${name28},
    - \u63D0\u793A\u8BCD:${prompt},

    \u8BF7\u4E25\u683C\u6309\u7167\u7CFB\u7EDF\u89C4\u8303\u751F\u6210${cfg.promptEnd}\u3002
  `;
}
var import_express22, router22, assetTypeConfig, requestSchema, batchGenerateImageAssets_default;
var init_batchGenerateImageAssets = __esm({
  "src/routes/assetsGenerate/batchGenerateImageAssets.ts"() {
    "use strict";
    import_express22 = __toESM(require_express2());
    init_p_limit();
    init_utils3();
    init_zod();
    init_dist_node();
    init_responseFormat();
    init_middleware();
    router22 = import_express22.default.Router();
    assetTypeConfig = {
      role: {
        label: "\u89D2\u8272",
        taskClass: "\u89D2\u8272\u56FE\u751F\u6210",
        dir: "role",
        promptTitle: "\u89D2\u8272\u6807\u51C6\u56DB\u89C6\u56FE",
        promptEnd: "\u4EBA\u7269\u89D2\u8272\u56DB\u89C6\u56FE"
      },
      scene: {
        label: "\u573A\u666F",
        taskClass: "\u573A\u666F\u56FE\u751F\u6210",
        dir: "scene",
        promptTitle: "\u6807\u51C6\u573A\u666F\u56FE",
        promptEnd: "\u6807\u51C6\u573A\u666F\u56FE"
      },
      tool: {
        label: "\u9053\u5177",
        taskClass: "\u9053\u5177\u56FE\u751F\u6210",
        dir: "props",
        promptTitle: "\u6807\u51C6\u9053\u5177\u56FE",
        promptEnd: "\u6807\u51C6\u9053\u5177\u56FE"
      }
    };
    requestSchema = {
      projectId: external_exports.number(),
      model: external_exports.string(),
      resolution: external_exports.string(),
      concurrentCount: external_exports.number().int().min(1).optional(),
      items: external_exports.array(
        external_exports.object({
          id: external_exports.number(),
          type: external_exports.enum(["role", "scene", "tool", "storyboard"]),
          name: external_exports.string(),
          prompt: external_exports.string(),
          base64: external_exports.string().optional().nullable()
        })
      )
    };
    batchGenerateImageAssets_default = router22.post("/", validateFields(requestSchema), async (req, res) => {
      const { projectId, model, resolution, concurrentCount, items } = req.body;
      const project = await utils_default.db("o_project").where("id", projectId).select("artStyle", "type", "intro").first();
      if (!project) return res.status(500).send(error50("\u9879\u76EE\u4E3A\u7A7A"));
      const totalNovelId = [];
      for (const item of items) {
        const [imageId] = await utils_default.db("o_image").insert({
          type: item.type,
          state: "\u751F\u6210\u4E2D",
          assetsId: item.id
        });
        await utils_default.db("o_assets").where("id", item.id).update({ imageId });
        totalNovelId.push(imageId);
      }
      const limit = pLimit(concurrentCount ?? 1);
      const tasks = items.map(
        (item, index) => limit(async () => {
          const imageId = totalNovelId[index];
          const data = await utils_default.db("o_image").where("id", imageId).select("state").first();
          if (data?.state === "\u751F\u6210\u5931\u8D25") {
            return;
          }
          const cfg = assetTypeConfig[item.type];
          if (!cfg) return;
          await utils_default.db("o_assets").where("id", item.id).update({ imageId });
          const imagePath = `/${projectId}/${cfg.dir}/${v4_default()}.jpg`;
          const userPrompt = buildPrompt(cfg, project.artStyle ?? "", item.name, item.prompt);
          const describe4 = `\u751F\u6210${cfg.label}\u56FE\uFF0C\u540D\u79F0\uFF1A${item.name}\uFF0C\u63D0\u793A\u8BCD\uFF1A${item.prompt}`;
          const relatedObjects = { id: item.id, projectId, type: cfg.label };
          try {
            const aiImage = utils_default.Ai.Image(model);
            await aiImage.run(
              {
                prompt: userPrompt,
                referenceList: item.base64 ? [{ base64: item.base64, type: "image" }] : [],
                size: resolution,
                aspectRatio: "16:9"
              },
              {
                taskClass: cfg.taskClass,
                describe: describe4,
                projectId,
                relatedObjects: JSON.stringify(relatedObjects)
              }
            );
            aiImage.save(imagePath);
            const imageData = await utils_default.db("o_image").where("id", imageId).select("*").first();
            if (!imageData) return res.status(500).send("\u8D44\u4EA7\u5DF2\u88AB\u5220\u9664");
            if (!imageData) return;
            if (imageData.state === "\u751F\u6210\u5931\u8D25") return;
            await utils_default.db("o_image").where("id", imageId).update({
              state: "\u5DF2\u5B8C\u6210",
              filePath: imagePath,
              type: item.type,
              model: model.split(/:(.+)/)[1],
              resolution
            });
            await utils_default.db("o_assets").where("id", item.id).update({ imageId });
          } catch (e) {
            await utils_default.db("o_image").where("id", imageId).update({ state: "\u751F\u6210\u5931\u8D25", errorReason: utils_default.error(e).message });
          }
        })
      );
      Promise.all(tasks).catch(() => {
      });
      return res.status(200).send(success3({ total: items.length }));
    });
  }
});

// src/routes/assetsGenerate/batchPolishAssetsPrompt.ts
var import_express23, router23, batchPolishAssetsPrompt_default;
var init_batchPolishAssetsPrompt = __esm({
  "src/routes/assetsGenerate/batchPolishAssetsPrompt.ts"() {
    "use strict";
    import_express23 = __toESM(require_express2());
    init_utils3();
    init_p_limit();
    init_zod();
    init_responseFormat();
    init_middleware();
    router23 = import_express23.default.Router();
    batchPolishAssetsPrompt_default = router23.post(
      "/",
      validateFields({
        items: array(
          object({
            assetsId: number2(),
            type: string2(),
            name: string2(),
            describe: string2()
          })
        ),
        projectId: number2(),
        concurrentCount: number2().int().min(1).optional(),
        otherTextPrompt: string2()
      }),
      async (req, res) => {
        const { projectId, items, concurrentCount, otherTextPrompt } = req.body;
        const project = await utils_default.db("o_project").where("id", projectId).select("artStyle", "type", "intro").first();
        if (!project) return res.status(500).send(success3({ message: "\u9879\u76EE\u4E3A\u7A7A" }));
        const assetsIds = items.map((item) => item.assetsId);
        const assetsDataList = await utils_default.db("o_assets").whereIn("id", assetsIds).select("id", "assetsId");
        if (!assetsDataList || assetsDataList.length === 0) return res.status(500).send(error50("\u8D44\u4EA7\u4E0D\u5B58\u5728"));
        const assetsDataMap = new Map(assetsDataList.map((a) => [a.id, a]));
        await utils_default.db("o_assets").whereIn("id", assetsIds).update({ promptState: "\u751F\u6210\u4E2D" });
        const getTypeConfig = (isDerivative) => ({
          role: {
            promptKey: "role-polish",
            itemType: "characters",
            label: "\u89D2\u8272\u6807\u51C6\u56DB\u89C6\u56FE",
            nameLabel: "\u89D2\u8272",
            visualManual: isDerivative ? "art_character_derivative" : "art_character"
          },
          scene: {
            promptKey: "scene-polish",
            itemType: "scenes",
            label: "\u573A\u666F\u56FE",
            nameLabel: "\u573A\u666F",
            visualManual: isDerivative ? "art_scene_derivative" : "art_scene"
          },
          tool: {
            promptKey: "tool-polish",
            itemType: "props",
            label: "\u9053\u5177\u56FE",
            nameLabel: "\u9053\u5177",
            visualManual: isDerivative ? "art_prop_derivative" : "art_prop"
          }
        });
        const limit = pLimit(concurrentCount ?? 1);
        const tasks = items.map(
          (item) => limit(async () => {
            const assetData = assetsDataMap.get(item.assetsId);
            if (!assetData) return;
            const typeConfig = getTypeConfig(!!assetData.assetsId);
            const config3 = typeConfig[item.type];
            if (!config3) return;
            const visualManual = await utils_default.getArtPrompt(project.artStyle, "art_skills", config3.visualManual);
            if (!visualManual) {
              await utils_default.db("o_assets").where("id", item.assetsId).update({ promptState: "\u751F\u6210\u5931\u8D25", promptErrorReason: "\u89C6\u89C9\u624B\u518C\u672A\u5B9A\u4E49" });
              return;
            }
            const systemPrompt = visualManual;
            try {
              const { _output } = await utils_default.Ai.Text("universalAi").invoke({
                system: systemPrompt + "\n" + otherTextPrompt,
                messages: [
                  {
                    role: "user",
                    content: `
                    **\u57FA\u7840\u53C2\u6570\uFF1A**
      **${config3.nameLabel}\u8BBE\u5B9A\uFF1A**
      - ${config3.nameLabel}\u540D\u79F0:${item.name},
      - ${config3.nameLabel}\u63CF\u8FF0:${item.describe},`
                  }
                ]
              });
              if (!_output) {
                await utils_default.db("o_assets").where("id", item.assetsId).update({ promptState: "\u751F\u6210\u5931\u8D25" });
                return;
              }
              await utils_default.db("o_assets").where("id", item.assetsId).update({ prompt: _output, promptState: "\u5DF2\u5B8C\u6210" });
            } catch (e) {
              await utils_default.db("o_assets").where("id", item.assetsId).update({ promptState: "\u5931\u8D25", promptErrorReason: utils_default.error(e).message });
            }
          })
        );
        Promise.all(tasks).catch((err) => {
          res.status(500).send(error50(err));
        });
        return res.status(200).send(success3({ total: items.length }));
      }
    );
  }
});

// src/routes/assetsGenerate/cancelGenerate.ts
var import_express24, router24, cancelGenerate_default;
var init_cancelGenerate = __esm({
  "src/routes/assetsGenerate/cancelGenerate.ts"() {
    "use strict";
    import_express24 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router24 = import_express24.default.Router();
    cancelGenerate_default = router24.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        await utils_default.db("o_image").where("id", id).update({
          state: "\u751F\u6210\u5931\u8D25"
        });
        res.status(200).send(success3({ message: "\u53D6\u6D88\u6210\u529F" }));
      }
    );
  }
});

// src/routes/assetsGenerate/generateAssets.ts
function buildPrompt2(cfg, artStyle, name28, prompt) {
  return `
    \u8BF7\u6839\u636E\u4EE5\u4E0B\u53C2\u6570\u751F\u6210${cfg.promptTitle}\uFF1A

    **\u57FA\u7840\u53C2\u6570\uFF1A**
    - \u753B\u98CE\u98CE\u683C: ${artStyle || "\u672A\u6307\u5B9A"}

    **${cfg.label}\u8BBE\u5B9A\uFF1A**
    - \u540D\u79F0:${name28},
    - \u63D0\u793A\u8BCD:${prompt},

    \u8BF7\u4E25\u683C\u6309\u7167\u7CFB\u7EDF\u89C4\u8303\u751F\u6210${cfg.promptEnd}\u3002
  `;
}
var import_express25, router25, assetTypeConfig2, requestSchema2, generateAssets_default;
var init_generateAssets = __esm({
  "src/routes/assetsGenerate/generateAssets.ts"() {
    "use strict";
    import_express25 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_dist_node();
    init_responseFormat();
    init_middleware();
    router25 = import_express25.default.Router();
    assetTypeConfig2 = {
      role: {
        label: "\u89D2\u8272",
        taskClass: "\u89D2\u8272\u56FE\u751F\u6210",
        dir: "role",
        promptTitle: "\u89D2\u8272\u6807\u51C6\u56DB\u89C6\u56FE",
        promptEnd: "\u4EBA\u7269\u89D2\u8272\u56DB\u89C6\u56FE"
      },
      scene: {
        label: "\u573A\u666F",
        taskClass: "\u573A\u666F\u56FE\u751F\u6210",
        dir: "scene",
        promptTitle: "\u6807\u51C6\u573A\u666F\u56FE",
        promptEnd: "\u6807\u51C6\u573A\u666F\u56FE"
      },
      tool: {
        label: "\u9053\u5177",
        taskClass: "\u9053\u5177\u56FE\u751F\u6210",
        dir: "props",
        promptTitle: "\u6807\u51C6\u9053\u5177\u56FE",
        promptEnd: "\u6807\u51C6\u9053\u5177\u56FE"
      }
    };
    requestSchema2 = {
      projectId: external_exports.number(),
      model: external_exports.string(),
      resolution: external_exports.string(),
      id: external_exports.number(),
      type: external_exports.enum(["role", "scene", "tool", "storyboard"]),
      name: external_exports.string(),
      prompt: external_exports.string(),
      base64: external_exports.string().optional().nullable()
    };
    generateAssets_default = router25.post("/", validateFields(requestSchema2), async (req, res) => {
      const { projectId, model, resolution, id, type, name: name28, prompt, base64: base644 } = req.body;
      const project = await utils_default.db("o_project").where("id", projectId).select("artStyle", "type", "intro").first();
      if (!project) return res.status(500).send(success3({ message: "\u9879\u76EE\u4E3A\u7A7A" }));
      const cfg = assetTypeConfig2[type];
      if (!cfg) return res.status(400).send(error50("\u4E0D\u652F\u6301\u7684\u7C7B\u578B"));
      const [imageId] = await utils_default.db("o_image").insert({
        type,
        state: "\u751F\u6210\u4E2D",
        assetsId: id,
        model: model.split(/:(.+)/)[1],
        resolution
      });
      await utils_default.db("o_assets").where("id", id).update({ imageId });
      const imagePath = `/${projectId}/${cfg.dir}/${v4_default()}.jpg`;
      const userPrompt = buildPrompt2(cfg, project.artStyle, name28, prompt);
      const describe4 = `\u751F\u6210${cfg.label}\u56FE\uFF0C\u540D\u79F0\uFF1A${name28}\uFF0C\u63D0\u793A\u8BCD\uFF1A${prompt}`;
      const relatedObjects = { id, projectId, type: cfg.label };
      try {
        const aiImage = utils_default.Ai.Image(model);
        await aiImage.run(
          {
            prompt: userPrompt,
            referenceList: base644 ? [{ type: "image", base64: base644 }] : [],
            size: resolution,
            aspectRatio: "16:9"
          },
          {
            taskClass: cfg.taskClass,
            describe: describe4,
            projectId,
            relatedObjects: JSON.stringify(relatedObjects)
          }
        );
        aiImage.save(imagePath);
        const imageData = await utils_default.db("o_image").where("id", imageId).select("*").first();
        if (!imageData) return res.status(500).send("\u8D44\u4EA7\u5DF2\u88AB\u5220\u9664");
        if (imageData.state === "\u751F\u6210\u5931\u8D25") return;
        await utils_default.db("o_image").where("id", imageId).update({
          state: "\u5DF2\u5B8C\u6210",
          filePath: imagePath,
          type,
          model: model.split(/:(.+)/)[1],
          resolution
        });
        const path33 = await utils_default.oss.getSmallImageUrl(imagePath);
        await utils_default.db("o_assets").where("id", id).update({ imageId });
        return res.status(200).send(success3({ path: path33, assetsId: id }));
      } catch (e) {
        await utils_default.db("o_image").where("id", imageId).update({ state: "\u751F\u6210\u5931\u8D25", errorReason: utils_default.error(e).message });
        return res.status(400).send(error50(utils_default.error(e).message || "\u56FE\u7247\u751F\u6210\u5931\u8D25"));
      }
    });
  }
});

// src/routes/assetsGenerate/polishAssetsPrompt.ts
var import_express26, router26, polishAssetsPrompt_default;
var init_polishAssetsPrompt = __esm({
  "src/routes/assetsGenerate/polishAssetsPrompt.ts"() {
    "use strict";
    import_express26 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router26 = import_express26.default.Router();
    polishAssetsPrompt_default = router26.post(
      "/",
      validateFields({
        assetsId: number2(),
        projectId: number2(),
        type: string2(),
        name: string2(),
        describe: string2()
      }),
      async (req, res) => {
        const { assetsId, projectId, type, name: name28, describe: describe4 } = req.body;
        const project = await utils_default.db("o_project").where("id", projectId).select("artStyle", "type", "intro").first();
        if (!project) return res.status(500).send(success3({ message: "\u9879\u76EE\u4E3A\u7A7A" }));
        await utils_default.db("o_assets").where("id", assetsId).update({ promptState: "\u751F\u6210\u4E2D" });
        const assetsData = await utils_default.db("o_assets").where("id", assetsId).select("assetsId").first();
        if (!assetsData) return { code: 500, message: "\u8D44\u4EA7\u4E0D\u5B58\u5728" };
        const typeConfig = {
          role: {
            promptKey: "role-polish",
            itemType: "characters",
            label: "\u89D2\u8272\u6807\u51C6\u56DB\u89C6\u56FE",
            nameLabel: "\u89D2\u8272",
            visualManual: assetsData.assetsId ? "art_character_derivative" : "art_character"
          },
          scene: {
            promptKey: "scene-polish",
            itemType: "scenes",
            label: "\u573A\u666F\u56FE",
            nameLabel: "\u573A\u666F",
            visualManual: assetsData.assetsId ? "art_scene_derivative" : "art_scene"
          },
          tool: {
            promptKey: "tool-polish",
            itemType: "props",
            label: "\u9053\u5177\u56FE",
            nameLabel: "\u9053\u5177",
            visualManual: assetsData.assetsId ? "art_prop_derivative" : "art_prop"
          }
        };
        const config3 = typeConfig[type];
        if (!config3) return res.status(500).send(error50("\u4E0D\u652F\u6301\u7684\u7C7B\u578B"));
        if (!config3.visualManual) return res.status(500).send(error50("\u89C6\u89C9\u624B\u518C\u672A\u5B9A\u4E49"));
        const visualManual = await utils_default.getArtPrompt(project.artStyle, "art_skills", config3.visualManual);
        if (!visualManual) return res.status(500).send(error50("\u89C6\u89C9\u624B\u518C\u672A\u5B9A\u4E49"));
        const systemPrompt = visualManual;
        try {
          const { _output } = await utils_default.Ai.Text("universalAi").invoke({
            system: systemPrompt,
            messages: [
              {
                role: "user",
                content: `**\u57FA\u7840\u53C2\u6570\uFF1A**
      **${config3.nameLabel}\u8BBE\u5B9A\uFF1A**
      - ${config3.nameLabel}\u540D\u79F0:${name28},
      - ${config3.nameLabel}\u63CF\u8FF0:${describe4},`
              }
            ]
          });
          if (!_output) return res.status(500).send("\u5931\u8D25");
          await utils_default.db("o_assets").where("id", assetsId).update({ prompt: _output, promptState: "\u5DF2\u5B8C\u6210" });
          res.status(200).send(success3({ prompt: _output, assetsId }));
        } catch (e) {
          await utils_default.db("o_assets").where("id", assetsId).update({ promptState: "\u5931\u8D25", promptErrorReason: utils_default.error(e).message });
          return res.status(500).send(error50(e?.data?.error?.message ?? e?.message ?? "\u751F\u6210\u5931\u8D25"));
        }
      }
    );
  }
});

// src/routes/common/getBigImage.ts
var import_express27, router27, getBigImage_default;
var init_getBigImage = __esm({
  "src/routes/common/getBigImage.ts"() {
    "use strict";
    import_express27 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_zod();
    init_middleware();
    router27 = import_express27.default.Router();
    getBigImage_default = router27.post(
      "/",
      validateFields({
        url: external_exports.string()
      }),
      async (req, res) => {
        let { url: url4 } = req.body;
        if (url4.startsWith("/oss/")) {
          url4 = utils_default.replaceUrl(url4).replace("/smallImage", "");
        }
        const bigImageUrl = await utils_default.oss.getFileUrl(utils_default.replaceUrl(url4));
        res.status(200).send(success3(bigImageUrl));
      }
    );
  }
});

// src/routes/cornerScape/batchBindAudio.ts
var import_express28, router28, batchBindAudio_default;
var init_batchBindAudio = __esm({
  "src/routes/cornerScape/batchBindAudio.ts"() {
    "use strict";
    import_express28 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    init_dist22();
    init_userConfig();
    router28 = import_express28.default.Router();
    batchBindAudio_default = router28.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        assetsIds: external_exports.array(external_exports.number()),
        concurrentCount: external_exports.number().min(1).optional()
      }),
      async (req, res) => {
        const { projectId, assetsIds, concurrentCount } = req.body;
        const assetsData = await utils_default.db("o_assets").whereIn("id", assetsIds).andWhere("projectId", projectId).select("id", "name", "describe", "type");
        const audioData = await utils_default.db("o_assets").where("type", "audio").whereNull("assetsId").andWhere("projectId", projectId).select("id", "name", "describe");
        if (!audioData.length) return res.status(400).send(error50("\u6682\u65E0\u8BBE\u7F6E\u97F3\u9891\uFF0C\u8BF7\u5148\u524D\u5F80\u8D44\u4EA7\u4E2D\u5FC3\u4E0A\u4F20\u97F3\u9891"));
        const batchSize = concurrentCount ?? 1;
        async function processAsset(asset) {
          try {
            const resultTool = tool({
              description: "\u5339\u914D\u5B8C\u6210\u540E\u5FC5\u987B\u8C03\u7528\u6B64\u5DE5\u5177\u63D0\u4EA4\u7ED3\u679C",
              inputSchema: jsonSchema(
                external_exports.object({
                  audioId: external_exports.number().nullable().optional().describe("\u4E0E\u8BE5\u8D44\u4EA7\u5339\u914D\u7684\u97F3\u9891ID\u5217\u8868\uFF0C\u82E5\u65E0\u5408\u9002\u5339\u914D\u5219\u8FD4\u56DE\u7A7A\u6570\u7EC4")
                }).toJSONSchema()
              ),
              execute: async (result) => {
                await utils_default.db("o_assetsRole2Audio").where("assetsRoleId", asset.id).delete();
                if (result?.audioId) await utils_default.db("o_assetsRole2Audio").insert({ assetsRoleId: asset.id, assetsAudioId: result.audioId });
                await utils_default.db("o_assets").where("id", asset.id).update("audioBindState", "\u5DF2\u5B8C\u6210");
                return "\u65E0\u9700\u56DE\u590D\u7528\u6237\u4EFB\u4F55\u5185\u5BB9";
              }
            });
            const audioList = audioData.map((i) => `- ID:${i.id} | \u540D\u79F0:${i.name} | \u63CF\u8FF0:${i.describe ?? "\u65E0"}`).join("\n");
            const promptData = await getPromptForUser("audioBindPrompt");
            const audioBindPrompt = promptData?.data ?? void 0;
            const { text: text2 } = await utils_default.Ai.Text("universalAi").invoke({
              messages: [
                {
                  role: "system",
                  content: `
              ${audioBindPrompt}
              `
                },
                {
                  role: "user",
                  content: `
                ## \u5019\u9009\u97F3\u9891\u5217\u8868
                ${audioList}
                ## \u5F85\u5339\u914D\u8D44\u4EA7
                - ID:${asset.id} | \u540D\u79F0:${asset.name} | \u63CF\u8FF0:${asset.describe ?? "\u65E0"} | \u7C7B\u578B\uFF1A${asset.type}
                \u8BF7\u4ECE\u5019\u9009\u97F3\u9891\u5217\u8868\u4E2D\u4E3A\u8BE5\u8D44\u4EA7\u9009\u51FA\u6765\u4E00\u4E2A\u6700\u7B26\u5408\u8BE5\u89D2\u8272\u8BBE\u5B9A\u7684\u97F3\u8272\uFF0C\u5E76\u8C03\u7528 resultTool \u63D0\u4EA4\u7ED3\u679C\u3002
           `
                }
              ],
              tools: { resultTool }
            });
          } catch (e) {
            await utils_default.db("o_assets").where("id", asset.id).update("audioBindState", "\u751F\u6210\u5931\u8D25");
            console.error(`[bindAudio] \u8D44\u4EA7 ${asset.id} \u5904\u7406\u5931\u8D25:`, e);
          }
        }
        async function runWithConcurrency() {
          for (let i = 0; i < assetsData.length; i += batchSize) {
            const batch = assetsData.slice(i, i + batchSize);
            await Promise.all(batch.map((asset) => processAsset(asset)));
          }
        }
        await utils_default.db("o_assets").whereIn(
          "id",
          assetsData.map((i) => i.id)
        ).update("audioBindState", "\u751F\u6210\u4E2D");
        runWithConcurrency();
        res.status(200).send(success3());
      }
    );
  }
});

// src/routes/cornerScape/getAllAssets.ts
var import_express29, router29, getAllAssets_default;
var init_getAllAssets = __esm({
  "src/routes/cornerScape/getAllAssets.ts"() {
    "use strict";
    import_express29 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router29 = import_express29.default.Router();
    getAllAssets_default = router29.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        type: external_exports.array(external_exports.string()).optional()
      }),
      async (req, res) => {
        const { projectId, type } = req.body;
        const data = await utils_default.db("o_assets").leftJoin("o_image", "o_assets.imageId", "o_image.id").select(
          "o_assets.*",
          "o_image.filePath",
          "o_image.state",
          "o_image.model",
          "o_image.resolution",
          "o_image.errorReason",
          "o_image.id as imageId"
        ).where("o_assets.projectId", projectId).andWhere("o_assets.type", "<>", "clip").andWhere("o_assets.type", "<>", "audio").andWhere("o_assets.assetsId", null).modify((qb) => {
          if (type && type.length > 0) qb.whereIn("o_assets.type", type);
        }).orderByRaw(`CASE o_assets.type WHEN 'role' THEN 1 WHEN 'scene' THEN 2 WHEN 'tool' THEN 3 ELSE 4 END`);
        const assets2AudioData = await utils_default.db("o_assetsRole2Audio").leftJoin("o_assets", "o_assets.id", "o_assetsRole2Audio.assetsAudioId").whereIn(
          "o_assetsRole2Audio.assetsRoleId",
          data.map((i) => i.id)
        ).select("o_assets.id", "o_assets.name", "o_assetsRole2Audio.assetsRoleId");
        const repleAssets = {};
        assets2AudioData.forEach((item) => {
          if (!repleAssets[item.assetsRoleId]) repleAssets[item.assetsRoleId] = [item];
          else repleAssets[item.assetsRoleId].push(item);
        });
        const result = await Promise.all(
          data.map(async (parent) => {
            const historyImages = await utils_default.db("o_image").where("assetsId", parent.id).andWhere("state", "\u5DF2\u5B8C\u6210").select("id", "filePath");
            const historyImagesWithUrl = await Promise.all(
              historyImages.map(async (img) => ({
                id: img.id,
                filePath: img.filePath && await utils_default.oss.getSmallImageUrl(img.filePath)
              }))
            );
            return {
              ...parent,
              filePath: parent.filePath && await utils_default.oss.getSmallImageUrl(parent.filePath),
              historyImages: historyImagesWithUrl,
              relepedAudio: repleAssets[parent.id] ?? []
            };
          })
        );
        res.status(200).send(success3(result));
      }
    );
  }
});

// src/routes/cornerScape/pollingAudio.ts
var import_express30, router30, pollingAudio_default;
var init_pollingAudio = __esm({
  "src/routes/cornerScape/pollingAudio.ts"() {
    "use strict";
    import_express30 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router30 = import_express30.default.Router();
    pollingAudio_default = router30.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        const data = await utils_default.db("o_assets").whereIn("id", ids).whereNot("audioBindState", "\u751F\u6210\u4E2D").select("*");
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/cornerScape/updateAssetsAudio.ts
var import_express31, router31, updateAssetsAudio_default;
var init_updateAssetsAudio = __esm({
  "src/routes/cornerScape/updateAssetsAudio.ts"() {
    "use strict";
    import_express31 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router31 = import_express31.default.Router();
    updateAssetsAudio_default = router31.post(
      "/",
      validateFields({
        assetsId: external_exports.number(),
        audioIds: external_exports.array(external_exports.number()).optional()
      }),
      async (req, res) => {
        const { assetsId, audioIds } = req.body;
        if (audioIds && audioIds.length > 1) return res.status(400).send(error50("\u4EC5\u53EF\u7ED1\u5B9A\u4E00\u4E2A\u97F3\u8272"));
        await utils_default.db("o_assetsRole2Audio").where("assetsRoleId", assetsId).delete();
        if (audioIds && audioIds.length) {
          await utils_default.db("o_assetsRole2Audio").insert({ assetsRoleId: assetsId, assetsAudioId: audioIds[0] });
        }
        res.status(200).send(success3({ message: "\u66F4\u65B0\u97F3\u9891\u6210\u529F" }));
      }
    );
  }
});

// src/routes/general/generalStatistics.ts
var import_express32, router32, generalStatistics_default;
var init_generalStatistics = __esm({
  "src/routes/general/generalStatistics.ts"() {
    "use strict";
    import_express32 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router32 = import_express32.default.Router();
    generalStatistics_default = router32.post(
      "/",
      validateFields({
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { projectId } = req.body;
        const scripts = await utils_default.db("o_script").where("projectId", projectId).select("id");
        const scriptIds = scripts.map((item) => item.id);
        const roleCount = await utils_default.db("o_assets").where("projectId", projectId).where("type", "\u89D2\u8272").count("* as total").first();
        const scriptCount = await utils_default.db("o_script").where("projectId", projectId).count("* as total").first();
        const videoCount = await utils_default.db("o_video").whereIn("scriptId", scriptIds).count("* as total").first();
        const storyboardCount = await utils_default.db("o_assets").whereIn("scriptId", scriptIds).where("type", "\u5206\u955C").count("* as total").first();
        const data = {
          roleCount: roleCount?.total || 0,
          scriptCount: scriptCount?.total || 0,
          videoCount: videoCount?.total || 0,
          storyboardCount: storyboardCount?.total || 0
        };
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/general/getSingleProject.ts
var import_express33, router33, getSingleProject_default;
var init_getSingleProject = __esm({
  "src/routes/general/getSingleProject.ts"() {
    "use strict";
    import_express33 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router33 = import_express33.default.Router();
    getSingleProject_default = router33.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        const data = await utils_default.db("o_project").where("id", id).select("*");
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/general/updateProject.ts
var import_express34, router34, updateProject_default;
var init_updateProject = __esm({
  "src/routes/general/updateProject.ts"() {
    "use strict";
    import_express34 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router34 = import_express34.default.Router();
    updateProject_default = router34.post(
      "/",
      validateFields({
        id: external_exports.number(),
        intro: external_exports.string().optional().nullable(),
        type: external_exports.string().optional().nullable(),
        artStyle: external_exports.string().optional().nullable(),
        videoRatio: external_exports.string().optional().nullable(),
        projectType: external_exports.string().optional().nullable()
      }),
      async (req, res) => {
        const { id, intro, type, artStyle, videoRatio, projectType } = req.body;
        await utils_default.db("o_project").where("id", id).update({
          intro,
          type,
          artStyle,
          videoRatio,
          projectType
        });
        res.status(200).send(success3({ message: "\u4FEE\u6539\u6210\u529F" }));
      }
    );
  }
});

// src/routes/login/login.ts
var import_express35, router35, login_default;
var init_login = __esm({
  "src/routes/login/login.ts"() {
    "use strict";
    import_express35 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_middleware();
    init_zod();
    init_auth();
    init_password();
    router35 = import_express35.default.Router();
    login_default = router35.post(
      "/",
      validateFields({
        username: external_exports.string(),
        password: external_exports.string()
      }),
      async (req, res) => {
        const username = String(req.body.username || "").trim();
        const password = String(req.body.password || "");
        const data = await utils_default.db("o_user").where("name", "=", username).orWhere("phone", username).first();
        if (!data) return res.status(400).send(error50("\u767B\u5F55\u5931\u8D25"));
        const validPassword = await verifyPassword(password, data.password);
        if (validPassword) {
          const tokenKey = await getTokenKey();
          if (!tokenKey) return res.status(400).send(error50("\u672A\u627E\u5230tokenKey"));
          if (!isHashedPassword(data.password)) {
            await utils_default.db("o_user").where("id", data.id).update({ password: await hashPassword(password) });
          }
          const user = publicUser(data);
          const token = createAuthToken(user, tokenKey);
          return res.status(200).send(success3({ token: "Bearer " + token, ...user }, "\u767B\u5F55\u6210\u529F"));
        } else {
          return res.status(400).send(error50("\u7528\u6237\u540D\u6216\u5BC6\u7801\u9519\u8BEF"));
        }
      }
    );
  }
});

// src/routes/login/me.ts
var import_express36, router36, me_default;
var init_me = __esm({
  "src/routes/login/me.ts"() {
    "use strict";
    import_express36 = __toESM(require_express2());
    init_utils3();
    init_auth();
    init_responseFormat();
    router36 = import_express36.default.Router();
    me_default = router36.get("/", async (req, res) => {
      const authUser = getCurrentUser(req);
      const user = await utils_default.db("o_user").where("id", authUser.id).select("id", "name").first();
      if (!user) return res.status(401).send(error50("\u7528\u6237\u4E0D\u5B58\u5728"));
      return res.status(200).send(success3(publicUser(user)));
    });
  }
});

// src/lib/smsCode.ts
function createSmsCodeError(message) {
  const error73 = new Error(message);
  error73.status = 400;
  return error73;
}
function createNumericCode() {
  return String(Math.floor(1e5 + Math.random() * 9e5));
}
async function assertCanSendSmsCode(phone, purpose) {
  const latest = await utils_default.db("o_smsCode").where({ phone, purpose, used: 0 }).orderBy("createTime", "desc").first();
  if (latest?.sentAt && Date.now() - latest.sentAt < RESEND_INTERVAL_MS) {
    const waitSeconds = Math.ceil((RESEND_INTERVAL_MS - (Date.now() - latest.sentAt)) / 1e3);
    throw createSmsCodeError(`\u9A8C\u8BC1\u7801\u53D1\u9001\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7 ${waitSeconds} \u79D2\u540E\u518D\u8BD5`);
  }
}
async function saveSmsCode(phone, purpose, code) {
  await utils_default.db("o_smsCode").insert({
    id: Date.now(),
    phone,
    purpose,
    codeHash: await hashPassword(code),
    expiresAt: Date.now() + EXPIRES_IN_MS,
    used: 0,
    attempts: 0,
    createTime: Date.now(),
    sentAt: Date.now()
  });
}
async function verifySmsCode(phone, purpose, code) {
  const record3 = await utils_default.db("o_smsCode").where({ phone, purpose, used: 0 }).orderBy("createTime", "desc").first();
  if (!record3) throw createSmsCodeError("\u9A8C\u8BC1\u7801\u4E0D\u5B58\u5728\u6216\u5DF2\u5931\u6548");
  if ((record3.attempts ?? 0) >= MAX_ATTEMPTS) throw createSmsCodeError("\u9A8C\u8BC1\u7801\u5C1D\u8BD5\u6B21\u6570\u8FC7\u591A\uFF0C\u8BF7\u91CD\u65B0\u83B7\u53D6");
  if ((record3.expiresAt ?? 0) < Date.now()) throw createSmsCodeError("\u9A8C\u8BC1\u7801\u5DF2\u8FC7\u671F");
  await utils_default.db("o_smsCode").where("id", record3.id).update({ attempts: (record3.attempts ?? 0) + 1 });
  const matched = await verifyPassword(code, record3.codeHash);
  if (!matched) throw createSmsCodeError("\u9A8C\u8BC1\u7801\u9519\u8BEF");
  await utils_default.db("o_smsCode").where("id", record3.id).update({ used: 1 });
}
var EXPIRES_IN_MS, RESEND_INTERVAL_MS, MAX_ATTEMPTS;
var init_smsCode = __esm({
  "src/lib/smsCode.ts"() {
    "use strict";
    init_utils3();
    init_password();
    EXPIRES_IN_MS = 5 * 60 * 1e3;
    RESEND_INTERVAL_MS = 60 * 1e3;
    MAX_ATTEMPTS = 5;
  }
});

// src/lib/sms.ts
function percentEncode(value) {
  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
}
function getSmsConfig() {
  return {
    accessKeyId: process.env.SMS_ACCESS_KEY_ID || process.env.ALIBABA_CLOUD_ACCESS_KEY_ID || "",
    accessKeySecret: process.env.SMS_ACCESS_KEY_SECRET || process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET || "",
    signName: process.env.SMS_SIGN_NAME || "",
    templateCode: process.env.SMS_TEMPLATE_CODE || "",
    region: process.env.SMS_REGION || "cn-hangzhou"
  };
}
function signQuery(params, accessKeySecret) {
  const canonicalizedQuery = Object.keys(params).sort().map((key) => `${percentEncode(key)}=${percentEncode(params[key])}`).join("&");
  const stringToSign = `GET&${percentEncode("/")}&${percentEncode(canonicalizedQuery)}`;
  return import_crypto5.default.createHmac("sha1", `${accessKeySecret}&`).update(stringToSign).digest("base64");
}
function maskPhone(phone) {
  return phone.replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2");
}
function isValidMainlandPhone(phone) {
  return /^1[3-9]\d{9}$/.test(phone);
}
async function sendSmsCode(phone, code) {
  const config3 = getSmsConfig();
  if (!config3.accessKeyId || !config3.accessKeySecret || !config3.signName || !config3.templateCode) {
    throw new Error("\u77ED\u4FE1\u670D\u52A1\u672A\u914D\u7F6E");
  }
  const params = {
    AccessKeyId: config3.accessKeyId,
    Action: "SendSms",
    Format: "JSON",
    PhoneNumbers: phone,
    RegionId: config3.region,
    SignatureMethod: "HMAC-SHA1",
    SignatureNonce: import_crypto5.default.randomUUID(),
    SignatureVersion: "1.0",
    SignName: config3.signName,
    TemplateCode: config3.templateCode,
    TemplateParam: JSON.stringify({ code }),
    Timestamp: (/* @__PURE__ */ new Date()).toISOString(),
    Version: "2017-05-25"
  };
  const signature = signQuery(params, config3.accessKeySecret);
  const query = Object.entries({ ...params, Signature: signature }).map(([key, value]) => `${percentEncode(key)}=${percentEncode(value)}`).join("&");
  const { data } = await axios_default.get(`${endpoint}?${query}`, { timeout: 1e4 });
  if (data?.Code !== "OK") {
    throw new Error(data?.Message || data?.Code || "\u77ED\u4FE1\u53D1\u9001\u5931\u8D25");
  }
  return data;
}
var import_crypto5, endpoint;
var init_sms = __esm({
  "src/lib/sms.ts"() {
    "use strict";
    init_axios2();
    import_crypto5 = __toESM(require("crypto"));
    endpoint = "https://dysmsapi.aliyuncs.com/";
  }
});

// src/routes/login/register.ts
var import_express37, router37, register_default;
var init_register = __esm({
  "src/routes/login/register.ts"() {
    "use strict";
    import_express37 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_auth();
    init_password();
    init_smsCode();
    init_sms();
    init_middleware();
    router37 = import_express37.default.Router();
    register_default = router37.post(
      "/",
      validateFields({
        username: external_exports.string().min(2).max(32),
        phone: external_exports.string(),
        code: external_exports.string(),
        password: external_exports.string().min(6).max(64)
      }),
      async (req, res) => {
        const username = String(req.body.username || "").trim();
        const phone = String(req.body.phone || "").trim();
        const code = String(req.body.code || "").trim();
        const password = String(req.body.password || "");
        if (username.length < 2 || username.length > 32) {
          return res.status(400).send(error50("\u7528\u6237\u540D\u957F\u5EA6\u9700\u4E3A 2-32 \u4F4D"));
        }
        if (!/^[a-zA-Z0-9_\-\u4e00-\u9fa5]+$/.test(username)) {
          return res.status(400).send(error50("\u7528\u6237\u540D\u53EA\u80FD\u5305\u542B\u4E2D\u6587\u3001\u82F1\u6587\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u6A2A\u7EBF"));
        }
        if (!isValidMainlandPhone(phone)) return res.status(400).send(error50("\u624B\u673A\u53F7\u683C\u5F0F\u4E0D\u6B63\u786E"));
        const exists = await utils_default.db("o_user").where("name", username).first();
        if (exists) return res.status(400).send(error50("\u7528\u6237\u540D\u5DF2\u5B58\u5728"));
        const phoneExists = await utils_default.db("o_user").where("phone", phone).first();
        if (phoneExists) return res.status(400).send(error50("\u624B\u673A\u53F7\u5DF2\u6CE8\u518C"));
        const tokenKey = await getTokenKey();
        if (!tokenKey) return res.status(400).send(error50("\u672A\u627E\u5230tokenKey"));
        await verifySmsCode(phone, "register", code);
        const id = Date.now();
        await utils_default.db("o_user").insert({
          id,
          name: username,
          phone,
          password: await hashPassword(password)
        });
        const user = publicUser({ id, name: username, phone });
        const token = createAuthToken(user, tokenKey);
        return res.status(200).send(success3({ token: "Bearer " + token, ...user }, "\u6CE8\u518C\u6210\u529F"));
      }
    );
  }
});

// src/routes/login/resetPassword.ts
var import_express38, router38, resetPassword_default;
var init_resetPassword = __esm({
  "src/routes/login/resetPassword.ts"() {
    "use strict";
    import_express38 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_password();
    init_smsCode();
    init_sms();
    init_middleware();
    router38 = import_express38.default.Router();
    resetPassword_default = router38.post(
      "/",
      validateFields({
        phone: external_exports.string(),
        code: external_exports.string(),
        password: external_exports.string().min(6).max(64)
      }),
      async (req, res) => {
        const phone = String(req.body.phone || "").trim();
        const code = String(req.body.code || "").trim();
        const password = String(req.body.password || "");
        if (!isValidMainlandPhone(phone)) return res.status(400).send(error50("\u624B\u673A\u53F7\u683C\u5F0F\u4E0D\u6B63\u786E"));
        const user = await utils_default.db("o_user").where("phone", phone).first();
        if (!user) return res.status(400).send(error50("\u8BE5\u624B\u673A\u53F7\u5C1A\u672A\u6CE8\u518C"));
        await verifySmsCode(phone, "resetPassword", code);
        await utils_default.db("o_user").where("id", user.id).update({
          password: await hashPassword(password)
        });
        return res.status(200).send(success3(null, "\u5BC6\u7801\u5DF2\u91CD\u7F6E"));
      }
    );
  }
});

// src/routes/login/sendSmsCode.ts
var import_express39, router39, sendSmsCode_default;
var init_sendSmsCode = __esm({
  "src/routes/login/sendSmsCode.ts"() {
    "use strict";
    import_express39 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_smsCode();
    init_sms();
    init_middleware();
    router39 = import_express39.default.Router();
    sendSmsCode_default = router39.post(
      "/",
      validateFields({
        phone: external_exports.string(),
        purpose: external_exports.enum(["register", "resetPassword"])
      }),
      async (req, res) => {
        const phone = String(req.body.phone || "").trim();
        const purpose = req.body.purpose;
        if (!isValidMainlandPhone(phone)) return res.status(400).send(error50("\u624B\u673A\u53F7\u683C\u5F0F\u4E0D\u6B63\u786E"));
        const user = await utils_default.db("o_user").where("phone", phone).first();
        if (purpose === "register" && user) return res.status(400).send(error50("\u624B\u673A\u53F7\u5DF2\u6CE8\u518C"));
        if (purpose === "resetPassword" && !user) return res.status(400).send(error50("\u8BE5\u624B\u673A\u53F7\u5C1A\u672A\u6CE8\u518C"));
        await assertCanSendSmsCode(phone, purpose);
        const code = createNumericCode();
        await sendSmsCode(phone, code);
        await saveSmsCode(phone, purpose, code);
        return res.status(200).send(success3({ phone: maskPhone(phone), expiresIn: 300 }, "\u9A8C\u8BC1\u7801\u5DF2\u53D1\u9001"));
      }
    );
  }
});

// src/routes/modelSelect/getModelDetail.ts
var import_express40, router40, getModelDetail_default;
var init_getModelDetail = __esm({
  "src/routes/modelSelect/getModelDetail.ts"() {
    "use strict";
    import_express40 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router40 = import_express40.default.Router();
    getModelDetail_default = router40.post(
      "/",
      validateFields({
        modelId: external_exports.string()
      }),
      async (req, res) => {
        const { modelId } = req.body;
        const [id, name28] = modelId.split(/:(.+)/);
        const models = await utils_default.vendor.getModelList(id);
        const findData = models.find((i) => i.modelName == name28);
        res.status(200).send(success3(findData));
      }
    );
  }
});

// src/routes/modelSelect/getModelList.ts
var import_express41, router41, getModelList_default;
var init_getModelList = __esm({
  "src/routes/modelSelect/getModelList.ts"() {
    "use strict";
    import_express41 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    init_userConfig();
    router41 = import_express41.default.Router();
    getModelList_default = router41.post(
      "/",
      validateFields({
        type: external_exports.enum(["text", "image", "video", "all"])
      }),
      async (req, res) => {
        const { type } = req.body;
        const userId = requireRequestUserId(req);
        const vendorIds = await getEnabledVendorIdsForUser(userId);
        if (!vendorIds.length) {
          return res.status(404).send({ error: "\u6A21\u578B\u672A\u627E\u5230" });
        }
        const modelList = await Promise.all(vendorIds.map((id) => utils_default.vendor.getModelList(id)));
        const result = await Promise.all(
          vendorIds.map(async (id, index) => {
            const vendorData2 = await utils_default.vendor.getVendor(id);
            const models = modelList[index];
            const filtered = type === "all" ? models.filter((item) => item.type !== "video") : models.filter((item) => item.type === type);
            return filtered.map((item) => ({
              id,
              label: item.name,
              value: item.modelName,
              type: item.type,
              name: vendorData2.name
            }));
          })
        );
        res.status(200).send(success3(result.flat()));
      }
    );
  }
});

// src/routes/novel/addNovel.ts
var import_express42, router42, addNovel_default;
var init_addNovel = __esm({
  "src/routes/novel/addNovel.ts"() {
    "use strict";
    import_express42 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router42 = import_express42.default.Router();
    addNovel_default = router42.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        data: external_exports.array(
          external_exports.object({
            index: external_exports.number(),
            reel: external_exports.string(),
            chapter: external_exports.string(),
            chapterData: external_exports.string()
          })
        )
      }),
      async (req, res) => {
        const { projectId, data } = req.body;
        const totalNovelId = [];
        const getLastChapterIndex = await utils_default.db("o_novel").where("projectId", projectId).select("chapterIndex").orderBy("chapterIndex", "desc").first();
        let lastChapterIndex = 0;
        if (getLastChapterIndex) {
          lastChapterIndex = getLastChapterIndex.chapterIndex;
        }
        for (const item of data) {
          const [id] = await utils_default.db("o_novel").insert({
            projectId,
            chapterIndex: ++lastChapterIndex,
            reel: item.reel,
            chapter: item.chapter,
            chapterData: item.chapterData,
            createTime: Date.now(),
            eventState: 0
          });
          totalNovelId.push(id);
        }
        const chapterAllList = await utils_default.db("o_novel").where("projectId", projectId).whereIn("id", totalNovelId);
        const novelClass = new utils_default.cleanNovel();
        novelClass.emitter.on("item", async (item) => {
          await utils_default.db("o_novel").where("id", item.id).update({ event: item.event, eventState: item.event ? 1 : -1, errorReason: item?.errReason ?? null });
        });
        novelClass.start(chapterAllList, projectId);
        res.status(200).send(success3({ message: "\u65B0\u589E\u539F\u6587\u6210\u529F" }));
      }
    );
  }
});

// src/routes/novel/batchDeleteNovel.ts
var import_express43, router43, batchDeleteNovel_default;
var init_batchDeleteNovel = __esm({
  "src/routes/novel/batchDeleteNovel.ts"() {
    "use strict";
    import_express43 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router43 = import_express43.default.Router();
    batchDeleteNovel_default = router43.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        if (!ids.length) {
          return res.status(400).send(error50("\u8BF7\u5148\u9009\u62E9\u9700\u8981\u5220\u9664\u7684\u5185\u5BB9"));
        }
        const chapterData = await utils_default.db("o_eventChapter").whereIn("novelId", ids);
        await utils_default.db("o_eventChapter").whereIn("novelId", ids).delete();
        const eventIds = chapterData.map((i) => i.id);
        if (eventIds.length) await utils_default.db("o_event").whereIn("id", eventIds).delete();
        await utils_default.db("o_novel").whereIn("id", ids).del();
        res.status(200).send(success3({ message: "\u5220\u9664\u539F\u6587\u6210\u529F" }));
      }
    );
  }
});

// src/routes/novel/delNovel.ts
var import_express44, router44, delNovel_default;
var init_delNovel = __esm({
  "src/routes/novel/delNovel.ts"() {
    "use strict";
    import_express44 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router44 = import_express44.default.Router();
    delNovel_default = router44.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        const chapterData = await utils_default.db("o_eventChapter").where("novelId", id);
        await utils_default.db("o_eventChapter").where("novelId", id).delete();
        const eventIds = chapterData.map((i) => i.id);
        if (eventIds.length) await utils_default.db("o_event").whereIn("id", eventIds).delete();
        await utils_default.db("o_novel").where("id", id).del();
        res.status(200).send(success3({ message: "\u5220\u9664\u539F\u6587\u6210\u529F" }));
      }
    );
  }
});

// src/routes/novel/event/batchDeleteEvent.ts
var import_express45, router45, batchDeleteEvent_default;
var init_batchDeleteEvent = __esm({
  "src/routes/novel/event/batchDeleteEvent.ts"() {
    "use strict";
    import_express45 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router45 = import_express45.default.Router();
    batchDeleteEvent_default = router45.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        await utils_default.db("o_event").whereIn("id", ids).del();
        await utils_default.db("o_eventChapter").whereIn("eventId", ids).del();
        res.status(200).send(success3({ message: "\u5220\u9664\u4E8B\u4EF6\u6210\u529F" }));
      }
    );
  }
});

// src/routes/novel/event/deletEvent.ts
var import_express46, router46, deletEvent_default;
var init_deletEvent = __esm({
  "src/routes/novel/event/deletEvent.ts"() {
    "use strict";
    import_express46 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router46 = import_express46.default.Router();
    deletEvent_default = router46.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        await utils_default.db("o_event").where("id", id).del();
        await utils_default.db("o_eventChapter").where("eventId", id).del();
        res.status(200).send(success3({ message: "\u5220\u9664\u4E8B\u4EF6\u6210\u529F" }));
      }
    );
  }
});

// src/routes/novel/event/generateEvents.ts
var import_express47, router47, generateEvents_default;
var init_generateEvents = __esm({
  "src/routes/novel/event/generateEvents.ts"() {
    "use strict";
    import_express47 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router47 = import_express47.default.Router();
    generateEvents_default = router47.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        novelIds: external_exports.array(external_exports.number()),
        concurrentCount: external_exports.number().min(1).optional()
      }),
      async (req, res) => {
        const { projectId, novelIds, concurrentCount = 5 } = req.body;
        const [allChapters, novel] = await Promise.all([
          utils_default.db("o_novel").where("projectId", projectId).whereIn("id", novelIds),
          Promise.resolve(new utils_default.cleanNovel(concurrentCount))
        ]);
        if (allChapters.length === 0) {
          return res.status(400).send(success3("\u6CA1\u6709\u5BF9\u5E94\u7AE0\u8282"));
        }
        await utils_default.db("o_novel").where("projectId", projectId).whereIn("id", novelIds).update({ eventState: 0, event: null });
        novel.emitter.on("item", async (item) => {
          await utils_default.db("o_novel").where("id", item.id).update({ event: item.event, eventState: item.event ? 1 : -1, errorReason: item?.errorReason ?? null });
        });
        novel.start(allChapters, projectId);
        return res.status(200).send(success3("\u751F\u6210\u4E8B\u4EF6\u6210\u529F"));
      }
    );
  }
});

// src/routes/novel/event/getEvent.ts
var import_express48, router48, getEvent_default;
var init_getEvent = __esm({
  "src/routes/novel/event/getEvent.ts"() {
    "use strict";
    import_express48 = __toESM(require_express2());
    init_utils3();
    init_db();
    init_zod();
    init_responseFormat();
    init_middleware();
    router48 = import_express48.default.Router();
    getEvent_default = router48.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        page: external_exports.number(),
        limit: external_exports.number(),
        search: external_exports.string().optional()
      }),
      async (req, res) => {
        const { projectId, page, limit, search } = req.body;
        const offset = (page - 1) * limit;
        const baseQuery = utils_default.db("o_event as e").join("o_eventChapter as ec", "ec.eventId", "e.id").join("o_novel as n", "n.id", "ec.novelId").where("n.projectId", projectId);
        if (search) {
          baseQuery.where("e.name", "like", `%${search}%`);
        }
        const [{ total }] = await baseQuery.clone().countDistinct("e.id as total");
        if (!Number(total)) {
          return res.status(200).send(success3({ list: [], total: 0 }));
        }
        const rows = await baseQuery.clone().select("e.id", "e.name as eventName", "e.detail", "e.createTime", db.raw("GROUP_CONCAT(n.chapterIndex) as chapterIndexes")).groupBy("e.id").limit(limit).offset(offset);
        const list2 = rows.map((e) => ({
          id: e.id,
          eventName: e.eventName,
          detail: e.detail,
          createTime: e.createTime,
          chapters: e.chapterIndexes ? e.chapterIndexes.split(",").map(Number) : []
        }));
        res.status(200).send(success3({ list: list2, total: Number(total) }));
      }
    );
  }
});

// src/routes/novel/getNovel.ts
var import_express49, router49, getNovel_default;
var init_getNovel = __esm({
  "src/routes/novel/getNovel.ts"() {
    "use strict";
    import_express49 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router49 = import_express49.default.Router();
    getNovel_default = router49.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        page: external_exports.number(),
        limit: external_exports.number(),
        search: external_exports.string().optional()
      }),
      async (req, res) => {
        const { projectId, page, limit, search } = req.body;
        const offset = (page - 1) * limit;
        const data = await utils_default.db("o_novel").where("projectId", projectId).select("id", "chapterIndex as index", "reel", "chapter", "chapterData", "event", "eventState", "errorReason").andWhere((qb) => {
          if (search) {
            qb.where("chapter", "like", `%${search}%`);
          }
        }).orderBy("chapterIndex", "asc").limit(limit).offset(offset);
        const totalQuery = await utils_default.db("o_novel").where("projectId", projectId).andWhere((qb) => {
          if (search) {
            qb.where("chapter", "like", `%${search}%`);
          }
        }).count("* as total").first();
        res.status(200).send(success3({ data, total: totalQuery.total }));
      }
    );
  }
});

// src/routes/novel/getNovelData.ts
var import_express50, router50, getNovelData_default;
var init_getNovelData = __esm({
  "src/routes/novel/getNovelData.ts"() {
    "use strict";
    import_express50 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router50 = import_express50.default.Router();
    getNovelData_default = router50.post(
      "/",
      validateFields({
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { projectId } = req.body;
        const data = await utils_default.db("o_novel").where("projectId", projectId).select("*");
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/novel/getNovelEventState.ts
var import_express51, router51, getNovelEventState_default;
var init_getNovelEventState = __esm({
  "src/routes/novel/getNovelEventState.ts"() {
    "use strict";
    import_express51 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router51 = import_express51.default.Router();
    getNovelEventState_default = router51.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        const data = await utils_default.db("o_novel").whereIn("id", ids).whereNot("eventState", 0).select("id", "event", "eventState", "errorReason");
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/novel/getNovelIndex.ts
var import_express52, router52, getNovelIndex_default;
var init_getNovelIndex = __esm({
  "src/routes/novel/getNovelIndex.ts"() {
    "use strict";
    import_express52 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router52 = import_express52.default.Router();
    getNovelIndex_default = router52.post(
      "/",
      validateFields({
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { projectId } = req.body;
        const data = await utils_default.db("o_novel").where("projectId", projectId).select("id", "chapterIndex as index", "chapter").orderBy("chapterIndex", "asc");
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/novel/updateNovel.ts
var import_express53, router53, updateNovel_default;
var init_updateNovel = __esm({
  "src/routes/novel/updateNovel.ts"() {
    "use strict";
    import_express53 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router53 = import_express53.default.Router();
    updateNovel_default = router53.post(
      "/",
      validateFields({
        id: external_exports.number(),
        index: external_exports.union([external_exports.number(), external_exports.string()]),
        reel: external_exports.string(),
        chapter: external_exports.string(),
        chapterData: external_exports.string(),
        event: external_exports.string()
      }),
      async (req, res) => {
        const { id, index, reel, chapter, chapterData, event } = req.body;
        await utils_default.db("o_novel").where("id", id).update({
          chapterIndex: index,
          reel,
          chapter,
          chapterData,
          event
        });
        res.status(200).send(success3({ message: "\u66F4\u65B0\u539F\u6587\u6210\u529F" }));
      }
    );
  }
});

// src/routes/other/deleteAllData.ts
var import_express54, router54, deleteAllData_default;
var init_deleteAllData = __esm({
  "src/routes/other/deleteAllData.ts"() {
    "use strict";
    import_express54 = __toESM(require_express2());
    init_initDB();
    init_db();
    init_responseFormat();
    router54 = import_express54.default.Router();
    deleteAllData_default = router54.post(
      "/",
      async (req, res) => {
        await initDB_default(db, true);
        res.status(200).send(success3({ message: "\u6E05\u7A7A\u6570\u636E\u8868\u6210\u529F" }));
      }
    );
  }
});

// src/routes/other/getVersion.ts
var import_express55, router55, getVersion_default;
var init_getVersion = __esm({
  "src/routes/other/getVersion.ts"() {
    "use strict";
    import_express55 = __toESM(require_express2());
    init_responseFormat();
    init_writeVersion();
    router55 = import_express55.default.Router();
    getVersion_default = router55.get("/", async (req, res) => {
      const version3 = await getVersion();
      res.status(200).send(success3(version3));
    });
  }
});

// src/routes/production/assets/batchGenerateAssetsImage.ts
var import_express56, router56, batchGenerateAssetsImage_default;
var init_batchGenerateAssetsImage = __esm({
  "src/routes/production/assets/batchGenerateAssetsImage.ts"() {
    "use strict";
    import_express56 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router56 = import_express56.default.Router();
    batchGenerateAssetsImage_default = router56.post(
      "/",
      validateFields({
        assetIds: external_exports.array(external_exports.number()),
        projectId: external_exports.number(),
        scriptId: external_exports.number(),
        concurrentCount: external_exports.number().min(1).optional()
      }),
      async (req, res) => {
        const { assetIds, projectId, scriptId, concurrentCount = 5 } = req.body;
        const projectSettingData = await utils_default.db("o_project").where("id", projectId).select("imageModel", "imageQuality", "artStyle").first();
        const assetsDataArr = await utils_default.db("o_assets").whereIn("id", assetIds).select("id", "describe", "name", "type", "assetsId");
        const parentIds = assetsDataArr.map((item) => item.assetsId).filter((id) => id !== null);
        const parentAssetsData = await utils_default.db("o_assets").leftJoin("o_image", "o_assets.imageId", "o_image.id").whereIn("o_assets.id", parentIds).select("o_assets.id", "o_image.filePath", "o_assets.describe");
        assetsDataArr.forEach((i) => {
          const parent = parentAssetsData.find((item) => item.id === i.assetsId);
          if (parent) {
            i.parentDescribe = parent.describe;
          }
        });
        const imageUrlRecord = {};
        parentAssetsData.forEach((item) => {
          if (item.filePath) imageUrlRecord[item.id] = item.filePath;
        });
        const rolePrompt = utils_default.getArtPrompt(projectSettingData.artStyle, "art_skills", "art_character_derivative");
        const toolPrompt = utils_default.getArtPrompt(projectSettingData.artStyle, "art_skills", "art_prop_derivative");
        const scenePrompt = utils_default.getArtPrompt(projectSettingData.artStyle, "art_skills", "art_scene_derivative");
        const promptRecord = {
          role: {
            prompt: rolePrompt
          },
          tool: {
            prompt: toolPrompt
          },
          scene: {
            prompt: scenePrompt
          }
        };
        const imageIdMap = {};
        for (const item of assetsDataArr) {
          const [imageId] = await utils_default.db("o_image").insert({
            assetsId: item.id,
            type: item.type,
            state: "\u751F\u6210\u4E2D",
            resolution: projectSettingData?.imageQuality,
            model: projectSettingData?.imageModel
          });
          imageIdMap[item.id] = imageId;
          await utils_default.db("o_assets").where("id", item.id).update({ imageId });
        }
        const imageData = [];
        res.status(200).send(success3("\u5F00\u59CB\u751F\u6210\u8D44\u4EA7\u56FE\u7247"));
        const generateSingleAsset = async (item) => {
          const imageId = imageIdMap[item.id];
          const typeConfig = promptRecord[item.type] || promptRecord["role"];
          const { text: text2 } = await utils_default.Ai.Text("universalAi").invoke({
            system: `${typeConfig.prompt}`,
            messages: [
              {
                role: "user",
                content: `
            \u7236\u7EA7\u8D44\u4EA7\u63CF\u8FF0: ${item.parentDescribe || "\u65E0\u8BE6\u7EC6\u63CF\u8FF0"}
            \u5F53\u524D\u8D44\u4EA7\u63CF\u8FF0: ${item.describe || "\u65E0\u8BE6\u7EC6\u63CF\u8FF0"}`
              }
            ]
          });
          await utils_default.db("o_assets").where("id", item.id).update({ prompt: text2 });
          const imageBase64 = imageUrlRecord[item.assetsId] ? await utils_default.oss.getImageBase64(imageUrlRecord[item.assetsId]) : null;
          try {
            const repeloadObj = {
              prompt: text2,
              size: projectSettingData?.imageQuality,
              aspectRatio: "16:9"
            };
            const imageCls = await utils_default.Ai.Image(projectSettingData?.imageModel).run(
              {
                referenceList: imageBase64 ? [{ type: "image", base64: imageBase64 }] : [],
                ...repeloadObj
              },
              {
                taskClass: "\u751F\u6210\u56FE\u7247",
                describe: "\u8D44\u4EA7\u56FE\u7247\u751F\u6210",
                relatedObjects: JSON.stringify(repeloadObj),
                projectId
              }
            );
            const savePath = `/${projectId}/assets/${scriptId}/${item.type}/${utils_default.uuid()}.jpg`;
            await imageCls.save(savePath);
            await utils_default.db("o_image").where({ id: imageId }).update({ state: "\u5DF2\u5B8C\u6210", filePath: savePath });
            return {
              id: item.id,
              state: "\u5DF2\u5B8C\u6210",
              src: await utils_default.oss.getSmallImageUrl(savePath)
            };
          } catch (e) {
            await utils_default.db("o_image").where({ id: imageId }).update({ state: "\u751F\u6210\u5931\u8D25", errorReason: utils_default.error(e).message });
            return {
              id: item.id,
              state: "\u751F\u6210\u5931\u8D25",
              src: ""
            };
          }
        };
        for (let i = 0; i < assetsDataArr.length; i += concurrentCount) {
          const batch = assetsDataArr.slice(i, i + concurrentCount);
          const batchResults = await Promise.all(batch.map(generateSingleAsset));
          imageData.push(...batchResults);
        }
      }
    );
  }
});

// src/routes/production/assets/deleteAssetsDireve.ts
var import_express57, router57, deleteAssetsDireve_default;
var init_deleteAssetsDireve = __esm({
  "src/routes/production/assets/deleteAssetsDireve.ts"() {
    "use strict";
    import_express57 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router57 = import_express57.default.Router();
    deleteAssetsDireve_default = router57.post(
      "/",
      validateFields({
        id: external_exports.number(),
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { id, projectId } = req.body;
        const assetsFirstData = await utils_default.db("o_assets").where("id", id).first();
        if (!assetsFirstData) {
          return res.status(404).send({ error: "\u8D44\u6E90\u672A\u627E\u5230" });
        }
        if (assetsFirstData?.flowId) await utils_default.db("o_imageFlow").where("id", assetsFirstData?.flowId).delete();
        await utils_default.db("o_assets").where("id", id).delete();
        await utils_default.db("o_assets2Storyboard").where("assetId", id).delete();
        res.status(200).send(success3({ message: "\u89C6\u9891\u5220\u9664\u6210\u529F" }));
      }
    );
  }
});

// src/routes/production/assets/pollingImage.ts
var import_express58, router58, pollingImage_default;
var init_pollingImage = __esm({
  "src/routes/production/assets/pollingImage.ts"() {
    "use strict";
    import_express58 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router58 = import_express58.default.Router();
    pollingImage_default = router58.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        const data = await utils_default.db("o_assets").leftJoin("o_image", "o_assets.imageId", "o_image.id").whereIn("o_assets.id", ids).whereNot("o_image.state", "\u751F\u6210\u4E2D").select("o_image.state", "o_assets.id", "o_image.filePath", "o_image.errorReason", "o_assets.prompt");
        const result = await Promise.all(
          data.map(async (item) => ({
            ...item,
            src: item.filePath ? await utils_default.oss.getSmallImageUrl(item.filePath) : null
          }))
        );
        res.status(200).send(success3(result));
      }
    );
  }
});

// src/routes/production/assets/updateAssetsUrl.ts
var import_express59, router59, updateAssetsUrl_default;
var init_updateAssetsUrl = __esm({
  "src/routes/production/assets/updateAssetsUrl.ts"() {
    "use strict";
    import_express59 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router59 = import_express59.default.Router();
    updateAssetsUrl_default = router59.post(
      "/",
      validateFields({
        id: external_exports.number(),
        url: external_exports.string(),
        flowId: external_exports.number()
      }),
      async (req, res) => {
        const { id, url: url4, flowId } = req.body;
        const [imageId] = await utils_default.db("o_image").insert({
          filePath: utils_default.replaceUrl(url4),
          state: "\u5DF2\u5B8C\u6210",
          assetsId: id
        });
        await utils_default.db("o_assets").where({ id }).update({ flowId, imageId });
        res.status(200).send(success3({ message: "\u66F4\u65B0\u63D0\u793A\u8BCD\u6210\u529F" }));
      }
    );
  }
});

// src/routes/production/editImage/generateFlowImage.ts
async function urlToBase643(imageUrl) {
  if (imageUrl.startsWith("/oss/")) {
    return await utils_default.oss.getImageBase64(utils_default.replaceUrl(imageUrl).replace("/smallImage", ""));
  }
  imageUrl = await utils_default.oss.getFileUrl(utils_default.replaceUrl(imageUrl));
  const response = await axios_default.get(imageUrl, { responseType: "arraybuffer" });
  const contentType = response.headers["content-type"] || "image/png";
  const base644 = Buffer.from(response.data, "binary").toString("base64");
  return `data:${contentType};base64,${base644}`;
}
var import_express60, router60, generateFlowImage_default;
var init_generateFlowImage = __esm({
  "src/routes/production/editImage/generateFlowImage.ts"() {
    "use strict";
    import_express60 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    init_axios2();
    router60 = import_express60.default.Router();
    generateFlowImage_default = router60.post(
      "/",
      validateFields({
        model: external_exports.string(),
        references: external_exports.array(external_exports.string()).optional(),
        quality: external_exports.string(),
        ratio: external_exports.string(),
        prompt: external_exports.string(),
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { model, references = [], quality, ratio, prompt, projectId } = req.body;
        try {
          const imageClass = await utils_default.Ai.Image(model).run(
            {
              prompt,
              referenceList: await (async () => {
                const list2 = [];
                for (const url5 of references) {
                  list2.push({ type: "image", base64: await urlToBase643(url5) });
                }
                return list2;
              })(),
              size: quality,
              aspectRatio: ratio
            },
            {
              taskClass: "\u5DE5\u4F5C\u6D41\u56FE\u7247\u751F\u6210",
              describe: "\u5DE5\u4F5C\u6D41\u56FE\u7247\u751F\u6210",
              relatedObjects: JSON.stringify(req.body),
              projectId
            }
          );
          const savePath = `${projectId}/workFlow/${utils_default.uuid()}.jpg`;
          await imageClass.save(savePath);
          const url4 = await utils_default.oss.getSmallImageUrl(savePath);
          return res.status(200).send(success3({ url: url4 }));
        } catch (e) {
          res.status(400).send(error50(utils_default.error(e).message));
        }
      }
    );
  }
});

// src/routes/production/editImage/getImageDefaultModle.ts
var import_express61, router61, getImageDefaultModle_default;
var init_getImageDefaultModle = __esm({
  "src/routes/production/editImage/getImageDefaultModle.ts"() {
    "use strict";
    import_express61 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router61 = import_express61.default.Router();
    getImageDefaultModle_default = router61.post(
      "/",
      validateFields({
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { projectId } = req.body;
        const imageFlowData = await utils_default.db("o_project").where("id", projectId).select("imageModel", "imageQuality").first();
        return res.status(200).send(success3(imageFlowData));
      }
    );
  }
});

// src/routes/production/editImage/getImageFlow.ts
var import_express62, router62, getImageFlow_default;
var init_getImageFlow = __esm({
  "src/routes/production/editImage/getImageFlow.ts"() {
    "use strict";
    import_express62 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router62 = import_express62.default.Router();
    getImageFlow_default = router62.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id, type } = req.body;
        const imageFlowData = await utils_default.db("o_imageFlow").where("id", id).first();
        if (imageFlowData?.flowData) {
          const parseFlow = JSON.parse(imageFlowData.flowData);
          await Promise.all(
            parseFlow.nodes.map(async (node) => {
              if (node.type === "upload") {
                node.data.image = node.data.image ? await utils_default.oss.getSmallImageUrl(node.data.image) : "";
              } else if (node.type === "generated") {
                node.data.generatedImage = node.data.generatedImage ? await utils_default.oss.getSmallImageUrl(node.data.generatedImage) : "";
                node.data.references = await Promise.all(node.data.references.map(async (item) => {
                  return {
                    image: await utils_default.oss.getSmallImageUrl(item.image)
                  };
                }));
              }
            })
          );
          return res.status(200).send(success3({ ...parseFlow, id: imageFlowData.id }));
        }
        return res.status(200).send(success3(null));
      }
    );
  }
});

// src/routes/production/editImage/saveImageFlow.ts
var import_express63, router63, saveImageFlow_default;
var init_saveImageFlow = __esm({
  "src/routes/production/editImage/saveImageFlow.ts"() {
    "use strict";
    import_express63 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router63 = import_express63.default.Router();
    saveImageFlow_default = router63.post(
      "/",
      validateFields({
        edges: external_exports.any(),
        nodes: external_exports.any()
      }),
      async (req, res) => {
        const { edges, nodes } = req.body;
        nodes.forEach((node) => {
          if (node.type == "upload") {
            node.data.image = node.data.image ? utils_default.replaceUrl(node.data.image) : "";
          }
          if (node.type == "generated") {
            node.data.generatedImage = node.data.generatedImage ? utils_default.replaceUrl(node.data.generatedImage) : "";
            node.data.references.forEach((item) => {
              item.image = item.image ? utils_default.replaceUrl(item.image) : "";
            });
          }
        });
        const [insertFlowId] = await utils_default.db("o_imageFlow").insert({
          flowData: JSON.stringify({ edges, nodes })
        });
        return res.status(200).send(success3({ id: insertFlowId }));
      }
    );
  }
});

// src/routes/production/editImage/updateImageFlow.ts
var import_express64, router64, updateImageFlow_default;
var init_updateImageFlow = __esm({
  "src/routes/production/editImage/updateImageFlow.ts"() {
    "use strict";
    import_express64 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router64 = import_express64.default.Router();
    updateImageFlow_default = router64.post(
      "/",
      validateFields({
        edges: external_exports.any(),
        nodes: external_exports.any(),
        flowId: external_exports.number()
      }),
      async (req, res) => {
        const { edges, nodes, flowId } = req.body;
        nodes.forEach((node) => {
          if (node.type == "upload") {
            node.data.image = node.data.image ? utils_default.replaceUrl(node.data.image) : "";
          }
          if (node.type == "generated") {
            node.data.generatedImage = node.data.generatedImage ? utils_default.replaceUrl(node.data.generatedImage) : "";
            node.data.references.forEach((item) => {
              item.image = item.image ? utils_default.replaceUrl(item.image) : "";
            });
          }
        });
        await utils_default.db("o_imageFlow").where("id", flowId).update({
          flowData: JSON.stringify({ edges, nodes })
        });
        return res.status(200).send(success3());
      }
    );
  }
});

// src/routes/production/editImage/uploadImage.ts
var import_express65, router65, uploadImage_default;
var init_uploadImage = __esm({
  "src/routes/production/editImage/uploadImage.ts"() {
    "use strict";
    import_express65 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_middleware();
    init_zod();
    init_dist_node();
    router65 = import_express65.default.Router();
    uploadImage_default = router65.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        scriptId: external_exports.number(),
        base64Data: external_exports.string()
      }),
      async (req, res) => {
        const { base64Data, projectId, scriptId } = req.body;
        function getExtFromBase642(base64Data2) {
          const mime = base64Data2.match(/^data:([^;]+);base64,/)?.[1] ?? "";
          const mimeMap = {
            // 图片
            "image/jpeg": "jpeg",
            "image/jpg": "jpg",
            "image/png": "png",
            // 音频
            "audio/mpeg": "mp3",
            "audio/mp3": "mp3",
            "audio/wav": "wav",
            // 视频
            "video/mp4": "mp4",
            "video/webm": "webm"
          };
          return mimeMap[mime] ?? "bin";
        }
        const ext = getExtFromBase642(base64Data);
        if (!["jpeg", "jpg", "png"].includes(ext)) {
          return res.status(400).send(error50("\u4E0D\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B"));
        }
        const savePath = `/${projectId}/imageFlow/${scriptId}/${v4_default()}.${ext}`;
        await utils_default.oss.writeFile(savePath, Buffer.from(base64Data.match(/base64,([A-Za-z0-9+/=]+)/)[1] ?? "", "base64"));
        const url4 = await utils_default.oss.getSmallImageUrl(savePath);
        res.status(200).send(success3(url4));
      }
    );
  }
});

// src/routes/production/getFlowData.ts
var import_express66, router66, getFlowData_default;
var init_getFlowData = __esm({
  "src/routes/production/getFlowData.ts"() {
    "use strict";
    import_express66 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router66 = import_express66.default.Router();
    getFlowData_default = router66.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        episodesId: external_exports.number()
      }),
      async (req, res) => {
        const { projectId, episodesId } = req.body;
        const sqlData = await utils_default.db("o_agentWorkData").where("projectId", String(projectId)).andWhere("episodesId", String(episodesId)).select("data").first();
        const scriptData = await utils_default.db("o_script").where("projectId", projectId).where("id", episodesId).first();
        const scriptAssets = await utils_default.db("o_scriptAssets").where("scriptId", episodesId);
        const assetIds = scriptAssets.map((i) => i.assetId);
        const assetsData = await utils_default.db("o_assets").leftJoin("o_image", "o_assets.imageId", "o_image.id").select("o_assets.*", "o_image.filePath", "o_image.state", "o_image.errorReason").where("o_assets.id", "in", assetIds).andWhere("o_assets.assetsId", null).where("o_assets.projectId", projectId);
        let childAssetsData = await utils_default.db("o_assets").leftJoin("o_image", "o_assets.imageId", "o_image.id").select("o_assets.*", "o_image.filePath", "o_image.state", "o_image.errorReason").where("o_assets.projectId", projectId).where("o_assets.assetsId", "in", assetIds).whereNotNull("o_assets.assetsId");
        if (!sqlData) {
          const flowData = {
            script: scriptData?.content ?? "",
            scriptPlan: "",
            assets: await Promise.all(
              assetsData.map(async (item) => ({
                id: item.id,
                name: item.name ?? "",
                type: item.type ?? "",
                prompt: item.prompt ?? "",
                desc: item.describe ?? "",
                src: item.filePath && await utils_default.oss.getSmallImageUrl(item.filePath),
                derive: await Promise.all(
                  childAssetsData.filter((child) => child.assetsId === item.id).map(async (child) => ({
                    id: child.id,
                    assetsId: item.id,
                    name: child.name ?? "",
                    type: child.type,
                    prompt: child.prompt,
                    desc: child.describe ?? "",
                    src: child.filePath && await utils_default.oss.getSmallImageUrl(child.filePath),
                    state: child.state ?? "\u672A\u751F\u6210"
                    //todo：矫正状态值
                  }))
                )
              }))
            ),
            storyboardTable: "",
            storyboard: [],
            //todo：矫正workbench数据
            //@ts-ignore
            workbench: {
              videoList: []
            }
            // //todo：矫正封面数据
            // poster: {
            //   items: [],
            // },
          };
          return res.status(200).send(success3(flowData));
        } else {
          try {
            const storyboardData = await utils_default.db("o_storyboard").where("scriptId", episodesId);
            await Promise.all(
              storyboardData.map(async (i) => {
                if (i.filePath) {
                  try {
                    i.filePath = await utils_default.oss.getSmallImageUrl(i.filePath);
                  } catch {
                    i.filePath = "";
                  }
                } else {
                  i.filePath = "";
                }
              })
            );
            const storyboardIds = storyboardData.map((i) => i.id);
            const assetsIds = await utils_default.db("o_assets2Storyboard").whereIn("storyboardId", storyboardIds).orderBy("rowid");
            const assets2StoryboardMap = {};
            assetsIds.forEach((i) => {
              if (!assets2StoryboardMap[i.storyboardId]) {
                assets2StoryboardMap[i.storyboardId] = [];
              }
              assets2StoryboardMap[i.storyboardId].push(i.assetId);
            });
            const flowData = JSON.parse(sqlData.data ?? "{}");
            flowData.assets = await Promise.all(
              assetsData.map(async (item) => ({
                id: item.id,
                name: item.name ?? "",
                type: item.type ?? "",
                prompt: item.prompt ?? "",
                desc: item.describe ?? "",
                src: item.filePath && await utils_default.oss.getSmallImageUrl(item.filePath),
                flowId: item.flowId,
                derive: await Promise.all(
                  childAssetsData.filter((child) => child.assetsId === item.id).map(async (child) => ({
                    id: child.id,
                    assetsId: item.id,
                    name: child.name ?? "",
                    prompt: child.prompt,
                    type: child.type,
                    desc: child.describe ?? "",
                    src: child.filePath && await utils_default.oss.getSmallImageUrl(child.filePath),
                    state: child.state ?? "\u672A\u751F\u6210",
                    errorReason: child?.errorReason ?? "",
                    flowId: child.flowId
                  }))
                )
              }))
            );
            flowData.storyboard = storyboardData.map((i) => ({
              id: i.id,
              index: i.index,
              duration: i.duration ? +i.duration : 0,
              prompt: i.prompt,
              associateAssetsIds: assets2StoryboardMap[i.id] ?? [],
              src: i.filePath,
              state: i.state,
              videoDesc: i.videoDesc,
              shouldGenerateImage: i.shouldGenerateImage,
              reason: i?.reason ?? "",
              flowId: i.flowId
            })).sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
            res.status(200).send(success3(flowData));
          } catch (err) {
            res.status(400).send(error50());
          }
        }
      }
    );
  }
});

// src/routes/production/getStoryboardData.ts
var import_express67, router67, getStoryboardData_default;
var init_getStoryboardData = __esm({
  "src/routes/production/getStoryboardData.ts"() {
    "use strict";
    import_express67 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router67 = import_express67.default.Router();
    getStoryboardData_default = router67.post(
      "/",
      validateFields({
        scriptId: external_exports.number()
      }),
      async (req, res) => {
        const { scriptId } = req.body;
        const storyboardData = await utils_default.db("o_storyboard").where({ scriptId }).orderBy("index", "asc");
        const data = await Promise.all(
          storyboardData.map(async (i) => {
            return {
              ...i,
              filePath: i.filePath ? await utils_default.oss.getSmallImageUrl(i.filePath) : ""
            };
          })
        );
        const storyboardIds = storyboardData.map((s) => s.id);
        const storyboardConfigs = await utils_default.db("o_assets2Storyboard").leftJoin("o_assets", "o_assets2Storyboard.assetId", "o_assets.id").leftJoin("o_image", "o_assets.imageId", "o_image.id").whereIn("o_assets2Storyboard.storyboardId", storyboardIds).select("o_assets2Storyboard.storyboardId", "o_assets.id as assetId", "o_assets.name", "o_assets.type", "o_image.filePath as avatar");
        const storyboardCharactersMap = storyboardConfigs.reduce((acc, cur) => {
          const storyboardId = cur.storyboardId;
          if (!acc[storyboardId]) {
            acc[storyboardId] = [];
          }
          const character = {
            name: cur.name ?? "",
            type: cur.type ?? ""
          };
          if (cur.avatar) {
            character.avatar = cur.avatar;
          }
          acc[storyboardId].push(character);
          return acc;
        }, {});
        const result = await Promise.all(
          data.map(async (item) => {
            const characters = storyboardCharactersMap[item.id] ?? [];
            const charactersWithUrl = await Promise.all(
              characters.map(async (c) => {
                if (c.avatar) {
                  return { ...c, avatar: await utils_default.oss.getSmallImageUrl(c.avatar) };
                }
                return c;
              })
            );
            return {
              id: String(item.id),
              createTime: item.createTime ?? void 0,
              duration: item.duration ? Number(item.duration) : void 0,
              filePath: item.filePath || void 0,
              prompt: item.prompt ?? void 0,
              scriptId: item.scriptId ?? void 0,
              characters: charactersWithUrl
            };
          })
        );
        res.status(200).send(success3(result));
      }
    );
  }
});

// src/routes/production/saveFlowData.ts
var import_express68, router68, saveFlowData_default;
var init_saveFlowData = __esm({
  "src/routes/production/saveFlowData.ts"() {
    "use strict";
    import_express68 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router68 = import_express68.default.Router();
    saveFlowData_default = router68.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        episodesId: external_exports.number(),
        data: external_exports.any()
      }),
      async (req, res) => {
        const {
          data,
          projectId,
          episodesId
        } = req.body;
        const sqlData = await utils_default.db("o_agentWorkData").where("projectId", String(projectId)).andWhere("episodesId", String(episodesId)).first();
        const filterDatas = data.storyboard.filter((i) => !i.id);
        if (data.storyboard && data.storyboard.length && !filterDatas.length) {
          try {
            await Promise.all(
              data.storyboard.filter((i) => i.id).map(async (i, index) => {
                await utils_default.db("o_storyboard").where("id", i.id).update({
                  index
                });
              })
            );
          } catch (error73) {
            console.error("\u66F4\u65B0\u5206\u955C\u6392\u5E8F\u5931\u8D25", error73);
          }
        }
        if (!sqlData) {
          await utils_default.db("o_agentWorkData").insert({
            projectId,
            episodesId,
            key: "productionAgent",
            data: JSON.stringify(data)
          });
        } else {
          await utils_default.db("o_agentWorkData").where("projectId", String(projectId)).where("key", "productionAgent").andWhere("episodesId", String(episodesId)).update({
            data: JSON.stringify(data)
          });
        }
        return res.status(200).send(success3());
      }
    );
  }
});

// src/routes/production/storyboard/addStoryboard.ts
var import_express69, router69, addStoryboard_default;
var init_addStoryboard = __esm({
  "src/routes/production/storyboard/addStoryboard.ts"() {
    "use strict";
    import_express69 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router69 = import_express69.default.Router();
    addStoryboard_default = router69.post(
      "/",
      validateFields({
        prompt: external_exports.string(),
        duration: external_exports.number(),
        state: external_exports.string(),
        videoDesc: external_exports.string(),
        shouldGenerateImage: external_exports.number(),
        src: external_exports.string().nullable(),
        scriptId: external_exports.number(),
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { prompt, duration: duration4, state, src, scriptId, projectId, videoDesc, shouldGenerateImage } = req.body;
        const trackId = Date.now();
        await utils_default.db("o_videoTrack").insert({
          id: trackId,
          scriptId,
          projectId
        });
        const [id] = await utils_default.db("o_storyboard").insert({
          prompt,
          duration: duration4,
          state,
          filePath: utils_default.replaceUrl(src),
          trackId,
          videoDesc,
          shouldGenerateImage: src ? 1 : 0,
          scriptId,
          projectId
        });
        return res.status(200).send(success3({ id }));
      }
    );
  }
});

// src/routes/production/storyboard/batchAddStoryboardInfo.ts
var import_express70, router70, batchAddStoryboardInfo_default;
var init_batchAddStoryboardInfo = __esm({
  "src/routes/production/storyboard/batchAddStoryboardInfo.ts"() {
    "use strict";
    import_express70 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router70 = import_express70.default.Router();
    batchAddStoryboardInfo_default = router70.post(
      "/",
      validateFields({
        data: external_exports.array(
          external_exports.object({
            prompt: external_exports.string(),
            duration: external_exports.number(),
            track: external_exports.string(),
            state: external_exports.string(),
            src: external_exports.string().nullable(),
            videoDesc: external_exports.string(),
            shouldGenerateImage: external_exports.number(),
            associateAssetsIds: external_exports.array(external_exports.number())
          })
        ),
        scriptId: external_exports.number(),
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { data, scriptId, projectId } = req.body;
        if (!data.length) return res.status(400).send({ success: false, message: "\u6570\u636E\u4E0D\u80FD\u4E3A\u7A7A" });
        for (const item of data) {
          const [id] = await utils_default.db("o_storyboard").insert({
            prompt: item.prompt,
            duration: String(item.duration),
            state: item.state,
            scriptId,
            projectId,
            track: item.track,
            videoDesc: item.videoDesc,
            shouldGenerateImage: item.shouldGenerateImage,
            createTime: Date.now()
          });
          if (item.associateAssetsIds?.length) {
            await utils_default.db("o_assets2Storyboard").insert(
              item.associateAssetsIds.map((assetId) => ({
                assetId,
                storyboardId: id
              }))
            );
          }
          item.id = id;
        }
        const lastStoryboard = await utils_default.db("o_storyboard").where("scriptId", scriptId);
        if (!lastStoryboard || !lastStoryboard.length) return res.status(400).send(error50("\u672A\u67E5\u5230\u5206\u955C\u6570\u636E"));
        const storyboardGroupByTrack = {};
        lastStoryboard.forEach((item) => {
          if (!storyboardGroupByTrack[item.track]) {
            storyboardGroupByTrack[item.track] = [];
          }
          storyboardGroupByTrack[item.track].push(item.id);
        });
        for (const track in storyboardGroupByTrack) {
          const storyboardIds = storyboardGroupByTrack[track] ?? [];
          const trackDuration = lastStoryboard.filter((item) => item.track == track).reduce((sum, item) => sum + Number(item.duration), 0);
          const existingStoryboard = await utils_default.db("o_storyboard").where({ scriptId, track }).whereNotNull("trackId").first();
          let trackId;
          if (existingStoryboard?.trackId) {
            trackId = existingStoryboard.trackId;
            await utils_default.db("o_videoTrack").where("id", trackId).update({ duration: trackDuration });
          } else {
            const newTrackId = Date.now();
            await utils_default.db("o_videoTrack").insert({
              id: newTrackId,
              scriptId,
              projectId,
              duration: trackDuration
            });
            trackId = newTrackId;
          }
          await utils_default.db("o_storyboard").whereIn("id", storyboardIds).update({ trackId });
        }
        const storyboardData = await Promise.all(
          lastStoryboard.map(async (i) => {
            return {
              associateAssetsIds: await utils_default.db("o_assets2Storyboard").where("storyboardId", i.id).orderBy("rowid").select("assetId").pluck("assetId"),
              src: i.filePath ? await utils_default.oss.getSmallImageUrl(i.filePath) : "",
              id: i.id,
              trackId: i.trackId,
              prompt: i.prompt,
              duration: Number(i.duration),
              state: i.state,
              scriptId: i.scriptId,
              reason: i.reason,
              videoDesc: i.videoDesc
            };
          })
        );
        return res.status(200).send(success3(storyboardData));
      }
    );
  }
});

// src/routes/production/storyboard/batchDelete.ts
var import_express71, router71, batchDelete_default2;
var init_batchDelete2 = __esm({
  "src/routes/production/storyboard/batchDelete.ts"() {
    "use strict";
    import_express71 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router71 = import_express71.default.Router();
    batchDelete_default2 = router71.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number()),
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { ids, projectId } = req.body;
        if (!ids.length) return res.status(400).send(error50("\u8BF7\u5148\u9009\u62E9\u5206\u955C"));
        const storyboardDataList = await utils_default.db("o_storyboard").whereIn("id", ids).where("projectId", projectId).select("id", "track", "trackId", "flowId");
        if (!storyboardDataList.length) return res.status(400).send(error50("\u5F53\u524D\u9009\u62E9\u5206\u955C\u4E0D\u5B58\u5728"));
        const flowIds = storyboardDataList.map((i) => i.flowId);
        const storyBoardIds = storyboardDataList.map((i) => i.id);
        if (flowIds.length)
          await utils_default.db("o_imageFlow").whereIn("id", flowIds).delete();
        await utils_default.db("o_storyboard").whereIn("id", storyBoardIds).delete();
        await utils_default.db("o_assets2Storyboard").whereIn("storyboardId", storyBoardIds).delete();
        res.status(200).send(success3({ message: "\u89C6\u9891\u5220\u9664\u6210\u529F" }));
      }
    );
  }
});

// src/routes/production/storyboard/batchGenerateImage.ts
async function getAssetsImageBase64(imageIds) {
  if (!imageIds.length) return [];
  const imagePaths = await utils_default.db("o_image").whereIn("o_image.id", imageIds).select("o_image.id", "o_image.filePath");
  const id2Path = /* @__PURE__ */ new Map();
  for (const row of imagePaths) {
    id2Path.set(row.id, row.filePath);
  }
  const imageUrls = await Promise.all(
    imageIds.map(async (id) => {
      const filePath = id2Path.get(id);
      if (filePath) {
        try {
          return await utils_default.oss.getImageBase64(filePath);
        } catch {
          return null;
        }
      }
      return null;
    })
  );
  return imageUrls.filter(Boolean).map((url4) => ({ type: "image", base64: url4 }));
}
var import_express72, router72, batchGenerateImage_default;
var init_batchGenerateImage = __esm({
  "src/routes/production/storyboard/batchGenerateImage.ts"() {
    "use strict";
    import_express72 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router72 = import_express72.default.Router();
    batchGenerateImage_default = router72.post(
      "/",
      validateFields({
        storyboardIds: external_exports.array(external_exports.number()),
        projectId: external_exports.number(),
        scriptId: external_exports.number(),
        concurrentCount: external_exports.number().min(1).optional(),
        compulsory: external_exports.boolean().optional()
      }),
      async (req, res) => {
        const {
          storyboardIds,
          projectId,
          scriptId,
          concurrentCount = 5,
          compulsory = false
        } = req.body;
        if (!storyboardIds || storyboardIds.length === 0) return res.status(400).send(error50("storyboardIds\u4E0D\u80FD\u4E3A\u7A7A"));
        let finalStoryboardIds = storyboardIds || [];
        const storyboardData = await utils_default.db("o_storyboard").where("scriptId", scriptId).where("projectId", projectId).whereIn("id", finalStoryboardIds);
        if (!storyboardData.length) return res.status(500).send(error50("\u672A\u67E5\u5230\u5206\u955C\u6570\u636E"));
        const storyIds = storyboardData.map((i) => i.id);
        if (compulsory) {
          await utils_default.db("o_storyboard").whereIn("id", storyIds).where("scriptId", scriptId).update({ state: "\u751F\u6210\u4E2D", shouldGenerateImage: 1 });
        } else {
          await utils_default.db("o_storyboard").whereIn("id", storyIds).where("scriptId", scriptId).where("shouldGenerateImage", 0).update({ state: "\u672A\u751F\u6210" });
          await utils_default.db("o_storyboard").whereIn("id", storyIds).where("scriptId", scriptId).where("shouldGenerateImage", 1).update({ state: "\u751F\u6210\u4E2D" });
        }
        const projectSettingData = await utils_default.db("o_project").where("id", projectId).select("imageModel", "imageQuality", "artStyle", "videoRatio").first();
        const assets2StoryboardRows = await utils_default.db("o_assets2Storyboard").whereIn("storyboardId", storyIds).orderBy("rowid").select("storyboardId", "assetId");
        const allAssetIds = [...new Set(assets2StoryboardRows.map((r) => r.assetId))];
        const assetImageMap = {};
        if (allAssetIds.length > 0) {
          const assetRows = await utils_default.db("o_assets").whereIn("id", allAssetIds).select("id", "imageId");
          assetRows.forEach((row) => {
            assetImageMap[row.id] = row.imageId;
          });
        }
        const assetRecord = {};
        assets2StoryboardRows.forEach((item) => {
          if (!assetRecord[item.storyboardId]) {
            assetRecord[item.storyboardId] = [];
          }
          const imageId = assetImageMap[item.assetId];
          if (imageId != null) {
            assetRecord[item.storyboardId].push(imageId);
          }
        });
        const realStoryData = await utils_default.db("o_storyboard").where("scriptId", scriptId).where("projectId", projectId).whereIn("id", storyIds);
        res.status(200).send(
          success3(
            realStoryData.map((i) => ({
              id: i.id,
              prompt: i.prompt,
              associateAssetsIds: assetRecord[i.id],
              src: null,
              state: i.state,
              videoDesc: i.videoDesc,
              shouldGenerateImage: i.shouldGenerateImage
            }))
          )
        );
        const generateTask = async (item) => {
          const repeloadObj = {
            prompt: item.prompt,
            size: projectSettingData?.imageQuality,
            aspectRatio: projectSettingData?.videoRatio
          };
          try {
            const imageCls = await utils_default.Ai.Image(projectSettingData?.imageModel).run(
              {
                referenceList: await getAssetsImageBase64(assetRecord[item.id] || []),
                ...repeloadObj
              },
              {
                taskClass: "\u751F\u6210\u5206\u955C\u56FE\u7247",
                describe: "\u5206\u955C\u56FE\u7247\u751F\u6210",
                relatedObjects: JSON.stringify(repeloadObj),
                projectId
              }
            );
            const savePath = `/${projectId}/assets/${scriptId}/${utils_default.uuid()}.jpg`;
            await imageCls.save(savePath);
            await utils_default.db("o_storyboard").where("id", item.id).update({
              filePath: savePath,
              state: "\u5DF2\u5B8C\u6210"
            });
          } catch (e) {
            utils_default.db("o_storyboard").where("id", item.id).update({
              filePath: "",
              reason: utils_default.error(e).message,
              state: "\u751F\u6210\u5931\u8D25"
            });
          }
        };
        let generateList = [];
        if (compulsory) {
          generateList = storyboardData;
        } else {
          generateList = storyboardData.filter((item) => item.shouldGenerateImage !== 0);
        }
        for (let i = 0; i < generateList.length; i += concurrentCount) {
          const batch = generateList.slice(i, i + concurrentCount);
          await Promise.all(batch.map(generateTask));
        }
      }
    );
  }
});

// src/routes/production/storyboard/downPreviewImage.ts
var import_express73, import_sharp3, router73, downPreviewImage_default;
var init_downPreviewImage = __esm({
  "src/routes/production/storyboard/downPreviewImage.ts"() {
    "use strict";
    import_express73 = __toESM(require_express2());
    init_utils3();
    init_zod();
    import_sharp3 = __toESM(require("sharp"));
    init_middleware();
    router73 = import_express73.default.Router();
    downPreviewImage_default = router73.post(
      "/",
      validateFields({
        storyboardIds: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { storyboardIds } = req.body;
        const storyboardImage = await utils_default.db("o_storyboard").whereIn("id", storyboardIds).select("id", "filePath");
        const filePathMap = {};
        storyboardImage.forEach((i) => {
          filePathMap[i.id] = i.filePath || "";
        });
        const orderedFilePaths = storyboardIds.map((id) => filePathMap[id]);
        const loaded = await Promise.all(
          orderedFilePaths.map(async (filePath) => {
            if (!filePath) return null;
            const buffer = await utils_default.oss.getFile(filePath);
            const metadata = await (0, import_sharp3.default)(buffer).metadata();
            return { buffer, width: metadata.width || 0, height: metadata.height || 0 };
          })
        );
        const validImages = loaded.filter((img) => img !== null && img.width > 0 && img.height > 0);
        if (validImages.length === 0) {
          res.status(204).end();
          return;
        }
        const cols = Math.min(5, validImages.length);
        const rows = Math.ceil(validImages.length / cols);
        const colWidths = Array(cols).fill(0);
        const rowHeights = Array(rows).fill(0);
        validImages.forEach((img, idx) => {
          const c = idx % cols;
          const r = Math.floor(idx / cols);
          colWidths[c] = Math.max(colWidths[c], img.width);
          rowHeights[r] = Math.max(rowHeights[r], img.height);
        });
        const canvasWidth = colWidths.reduce((a, b) => a + b, 0);
        const canvasHeight = rowHeights.reduce((a, b) => a + b, 0);
        const compositeInputs = [];
        for (let i = 0; i < validImages.length; i++) {
          const img = validImages[i];
          const c = i % cols;
          const r = Math.floor(i / cols);
          const x = colWidths.slice(0, c).reduce((a, b) => a + b, 0);
          const y = rowHeights.slice(0, r).reduce((a, b) => a + b, 0);
          compositeInputs.push({
            input: img.buffer,
            left: x,
            top: y
          });
          const label = `S${String(i + 1).padStart(2, "0")}`;
          const fontSize = Math.max(14, Math.min(img.width, img.height) * 0.06);
          const padding = Math.round(fontSize * 0.4);
          const textWidth = Math.round(label.length * fontSize * 0.65);
          const bgW = textWidth + padding * 2;
          const bgH = Math.round(fontSize) + padding * 2;
          const labelSvg = Buffer.from(
            `<svg xmlns="http://www.w3.org/2000/svg" width="${bgW}" height="${bgH}">
          <rect x="0" y="0" width="${bgW}" height="${bgH}" rx="4" ry="4" fill="rgba(0,0,0,0.55)"/>
          <text x="${padding}" y="${padding + fontSize * 0.85}" font-family="Arial, sans-serif" font-weight="bold" font-size="${fontSize}" fill="#fff">${label}</text>
        </svg>`
          );
          compositeInputs.push({
            input: labelSvg,
            left: x + 4,
            top: y + 4
          });
        }
        const resultBuffer = await (0, import_sharp3.default)({
          create: {
            width: canvasWidth,
            height: canvasHeight,
            channels: 4,
            background: { r: 255, g: 255, b: 255, alpha: 1 }
          }
        }).composite(compositeInputs).png({ compressionLevel: 3 }).toBuffer();
        res.setHeader("Content-Type", "image/png");
        res.setHeader("Content-Disposition", "attachment; filename=storyboard-preview.png");
        res.setHeader("Content-Length", resultBuffer.length);
        res.status(200).send(resultBuffer);
      }
    );
  }
});

// src/routes/production/storyboard/editStoryboardInfo.ts
var import_express74, router74, editStoryboardInfo_default;
var init_editStoryboardInfo = __esm({
  "src/routes/production/storyboard/editStoryboardInfo.ts"() {
    "use strict";
    import_express74 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router74 = import_express74.default.Router();
    editStoryboardInfo_default = router74.post(
      "/",
      validateFields({
        id: external_exports.number(),
        prompt: external_exports.string(),
        videoDesc: external_exports.string()
      }),
      async (req, res) => {
        const { id, prompt, videoDesc } = req.body;
        await utils_default.db("o_storyboard").where({ id }).update({
          prompt,
          videoDesc
        });
        res.status(200).send(success3({ message: "\u66F4\u65B0\u63D0\u793A\u8BCD\u6210\u529F" }));
      }
    );
  }
});

// src/routes/production/storyboard/getStoryboardData.ts
var import_express75, router75, getStoryboardData_default2;
var init_getStoryboardData2 = __esm({
  "src/routes/production/storyboard/getStoryboardData.ts"() {
    "use strict";
    import_express75 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router75 = import_express75.default.Router();
    getStoryboardData_default2 = router75.post(
      "/",
      validateFields({
        scriptId: external_exports.number(),
        page: external_exports.number(),
        limit: external_exports.number(),
        name: external_exports.string().optional().nullable()
      }),
      async (req, res) => {
        const { scriptId, page, limit, name: name28 } = req.body;
        const offset = (page - 1) * limit;
        const storyboardData = await utils_default.db("o_storyboard").where({ scriptId }).modify((qb) => {
          if (name28) {
            qb.andWhere("title", "like", `%${name28}%`);
          }
        }).offset(offset).limit(limit);
        const data = await Promise.all(
          storyboardData.map(async (i) => {
            return {
              id: i.id,
              prompt: i.prompt,
              state: i.state,
              src: i.filePath ? await utils_default.oss.getSmallImageUrl(i.filePath) : ""
            };
          })
        );
        const totalQuery = await utils_default.db("o_storyboard").where({ scriptId }).modify((qb) => {
          if (name28) {
            qb.andWhere("title", "like", `%${name28}%`);
          }
        }).count("* as total").first();
        res.status(200).send(success3({ data, total: totalQuery?.total }));
      }
    );
  }
});

// src/routes/production/storyboard/pollingImage.ts
var import_express76, router76, pollingImage_default2;
var init_pollingImage2 = __esm({
  "src/routes/production/storyboard/pollingImage.ts"() {
    "use strict";
    import_express76 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router76 = import_express76.default.Router();
    pollingImage_default2 = router76.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        const data = await utils_default.db("o_storyboard").whereIn("id", ids).whereNot("state", "\u751F\u6210\u4E2D").select("id", "state", "reason", "filePath", "prompt");
        const result = await Promise.all(
          data.map(async (item) => ({
            ...item,
            src: item.filePath ? await utils_default.oss.getSmallImageUrl(item.filePath) : null
          }))
        );
        res.status(200).send(success3(result));
      }
    );
  }
});

// src/routes/production/storyboard/previewImage.ts
var import_express77, import_sharp4, router77, previewImage_default;
var init_previewImage = __esm({
  "src/routes/production/storyboard/previewImage.ts"() {
    "use strict";
    import_express77 = __toESM(require_express2());
    init_utils3();
    init_zod();
    import_sharp4 = __toESM(require("sharp"));
    init_responseFormat();
    init_middleware();
    router77 = import_express77.default.Router();
    previewImage_default = router77.post(
      "/",
      validateFields({
        storyboardIds: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { storyboardIds } = req.body;
        const storyboardImage = await utils_default.db("o_storyboard").whereIn("id", storyboardIds).select("id", "filePath");
        const filePathMap = {};
        storyboardImage.forEach((i) => {
          filePathMap[i.id] = i.filePath || "";
        });
        const orderedFilePaths = storyboardIds.map((id) => filePathMap[id]);
        const loaded = await Promise.all(
          orderedFilePaths.map(async (filePath) => {
            if (!filePath) return null;
            const buffer = await utils_default.oss.getFile(filePath);
            const metadata = await (0, import_sharp4.default)(buffer).metadata();
            return { buffer, width: metadata.width || 0, height: metadata.height || 0 };
          })
        );
        const validImages = loaded.filter((img) => img !== null && img.width > 0 && img.height > 0);
        if (validImages.length === 0) {
          return res.status(200).send(success3(null));
        }
        const maxThumbWidth = 512;
        const resizedImages = await Promise.all(
          validImages.map(async (img) => {
            if (img.width <= maxThumbWidth) {
              return img;
            }
            const scale = maxThumbWidth / img.width;
            const newWidth = maxThumbWidth;
            const newHeight = Math.round(img.height * scale);
            const buffer = await (0, import_sharp4.default)(img.buffer).resize(newWidth, newHeight).toBuffer();
            return { buffer, width: newWidth, height: newHeight };
          })
        );
        const cols = Math.min(5, resizedImages.length);
        const rows = Math.ceil(resizedImages.length / cols);
        const colWidths = Array(cols).fill(0);
        const rowHeights = Array(rows).fill(0);
        resizedImages.forEach((img, idx) => {
          const c = idx % cols;
          const r = Math.floor(idx / cols);
          colWidths[c] = Math.max(colWidths[c], img.width);
          rowHeights[r] = Math.max(rowHeights[r], img.height);
        });
        const canvasWidth = colWidths.reduce((a, b) => a + b, 0);
        const canvasHeight = rowHeights.reduce((a, b) => a + b, 0);
        const compositeInputs = [];
        for (let i = 0; i < resizedImages.length; i++) {
          const img = resizedImages[i];
          const c = i % cols;
          const r = Math.floor(i / cols);
          const x = colWidths.slice(0, c).reduce((a, b) => a + b, 0);
          const y = rowHeights.slice(0, r).reduce((a, b) => a + b, 0);
          compositeInputs.push({
            input: img.buffer,
            left: x,
            top: y
          });
          const label = `S${String(i + 1).padStart(2, "0")}`;
          const fontSize = Math.max(14, Math.min(img.width, img.height) * 0.06);
          const padding = Math.round(fontSize * 0.4);
          const textWidth = Math.round(label.length * fontSize * 0.65);
          const bgW = textWidth + padding * 2;
          const bgH = Math.round(fontSize) + padding * 2;
          const labelSvg = Buffer.from(
            `<svg xmlns="http://www.w3.org/2000/svg" width="${bgW}" height="${bgH}">
          <rect x="0" y="0" width="${bgW}" height="${bgH}" rx="4" ry="4" fill="rgba(0,0,0,0.55)"/>
          <text x="${padding}" y="${padding + fontSize * 0.85}" font-family="Arial, sans-serif" font-weight="bold" font-size="${fontSize}" fill="#fff">${label}</text>
        </svg>`
          );
          compositeInputs.push({
            input: labelSvg,
            left: x + 4,
            top: y + 4
          });
        }
        const resultBuffer = await (0, import_sharp4.default)({
          create: {
            width: canvasWidth,
            height: canvasHeight,
            channels: 4,
            background: { r: 255, g: 255, b: 255, alpha: 1 }
          }
        }).composite(compositeInputs).jpeg({ quality: 80 }).toBuffer();
        const base644 = resultBuffer.toString("base64");
        const dataUrl = `data:image/jpeg;base64,${base644}`;
        return res.status(200).send(success3(dataUrl));
      }
    );
  }
});

// src/routes/production/storyboard/removeFrame.ts
var import_express78, router78, removeFrame_default;
var init_removeFrame = __esm({
  "src/routes/production/storyboard/removeFrame.ts"() {
    "use strict";
    import_express78 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router78 = import_express78.default.Router();
    removeFrame_default = router78.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        const storyboardData = await utils_default.db("o_storyboard").where("id", id).select("id", "track", "trackId", "flowId").first();
        if (!storyboardData) return res.status(400).send(error50("\u672A\u627E\u5230\u8BE5\u5206\u955C"));
        if (storyboardData?.flowId) await utils_default.db("o_imageFlow").where("id", storyboardData?.flowId).delete();
        const trackData = await utils_default.db("o_storyboard").where("track", storyboardData.track).select("id");
        if (trackData.length == 1) await utils_default.db("o_videoTrack").where("id", storyboardData.trackId).delete();
        await utils_default.db("o_storyboard").where("id", id).delete();
        await utils_default.db("o_assets2Storyboard").where("storyboardId", id).delete();
        res.status(200).send(success3({ message: "\u89C6\u9891\u5220\u9664\u6210\u529F" }));
      }
    );
  }
});

// src/routes/production/storyboard/updateStoryboardUrl.ts
var import_express79, router79, updateStoryboardUrl_default;
var init_updateStoryboardUrl = __esm({
  "src/routes/production/storyboard/updateStoryboardUrl.ts"() {
    "use strict";
    import_express79 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router79 = import_express79.default.Router();
    updateStoryboardUrl_default = router79.post(
      "/",
      validateFields({
        id: external_exports.number(),
        url: external_exports.string(),
        flowId: external_exports.number()
      }),
      async (req, res) => {
        const { id, url: url4, flowId } = req.body;
        await utils_default.db("o_storyboard").where({ id }).update({
          filePath: utils_default.replaceUrl(url4),
          flowId,
          state: "\u5DF2\u5B8C\u6210",
          shouldGenerateImage: url4 ? 1 : 0
        });
        res.status(200).send(success3({ message: "\u66F4\u65B0\u5206\u955C\u6210\u529F" }));
      }
    );
  }
});

// src/routes/production/workbench/addTrack.ts
var import_express80, router80, addTrack_default;
var init_addTrack = __esm({
  "src/routes/production/workbench/addTrack.ts"() {
    "use strict";
    import_express80 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router80 = import_express80.default.Router();
    addTrack_default = router80.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        scriptId: external_exports.number(),
        duration: external_exports.number().optional()
      }),
      async (req, res) => {
        const { projectId, scriptId, duration: duration4 } = req.body;
        const data = await utils_default.db("o_project").where("id", projectId).first();
        const video = data?.videoModel?.split(":");
        const vemdor = await utils_default.vendor.getModelList(video?.[0]);
        const trackId = Date.now();
        await utils_default.db("o_videoTrack").insert({
          id: trackId,
          projectId,
          scriptId,
          duration: duration4
        });
        res.status(200).send(success3(trackId));
      }
    );
  }
});

// src/routes/production/workbench/batchGeneratePrompt.ts
var import_express81, router81, batchGeneratePrompt_default;
var init_batchGeneratePrompt = __esm({
  "src/routes/production/workbench/batchGeneratePrompt.ts"() {
    "use strict";
    import_express81 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    init_userConfig();
    router81 = import_express81.default.Router();
    batchGeneratePrompt_default = router81.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        trackData: external_exports.array(
          external_exports.object({
            trackId: external_exports.number(),
            info: external_exports.array(
              external_exports.object({
                id: external_exports.number(),
                sources: external_exports.string()
              })
            )
          })
        ),
        model: external_exports.string()
      }),
      async (req, res) => {
        const { trackId, projectId, info, model } = req.body;
        const userId = requireRequestUserId(req);
        const images = await Promise.all(
          info.map(async (item) => {
            if (item.sources === "storyboard") {
              const storyboard2 = await utils_default.db("o_storyboard").where("o_storyboard.id", item.id).select("videoDesc", "prompt", "track", "duration", "shouldGenerateImage").first();
              const assetRows = await utils_default.db("o_assets2Storyboard").where("storyboardId", item.id).orderBy("rowid").select("assetId");
              const associateAssetsIds = assetRows.map((row) => row.assetId);
              return {
                ...storyboard2,
                associateAssetsIds,
                _type: "storyboard"
                // 标记类型，便于后续区分
              };
            }
            if (item.sources === "assets") {
              const assetsData = await utils_default.db("o_assets").leftJoin("o_image", "o_image.id", "o_assets.imageId").where("o_assets.id", item.id).select("o_assets.id", "o_assets.type", "o_assets.name", "o_image.filePath").first();
              return {
                ...assetsData,
                _type: "assets"
                // 标记类型
              };
            }
          })
        );
        const assets = [];
        const storyboard = [];
        for (const item of images) {
          if (!item) continue;
          if (item._type === "assets")
            assets.push({
              id: item.id,
              type: item.type,
              name: item.name,
              filePath: item.filePath
            });
          if (item._type === "storyboard")
            storyboard.push({
              videoDesc: item.videoDesc,
              prompt: item.prompt,
              track: item.track,
              duration: item.duration,
              associateAssetsIds: item.associateAssetsIds,
              shouldGenerateImage: item.shouldGenerateImage
            });
        }
        const [id, modelData] = model.split(/:(.+)/);
        const projectData = await utils_default.db("o_project").select("*").where({ id: projectId }).first();
        const videoPrompt = await getPromptForUser("videoPromptGeneration", userId);
        const videoPromptGeneration = videoPrompt?.data ?? void 0;
        const artStyle = projectData?.artStyle || "\u65E0";
        const visualManual = utils_default.getArtPrompt(artStyle, "art_skills", "art_storyboard_video");
        const content = `
          **\u6A21\u578B\u540D\u79F0**\uFF1A${modelData},
          **\u8D44\u4EA7\u4FE1\u606F**\uFF08\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177\u3001\u97F3\u9891):${assets.filter((i) => i.filePath).map((i) => `[${i.id},${i.type},${i.name}]`).join("\uFF0C")},
          **\u5206\u955C\u4FE1\u606F**\uFF1A${storyboard.map(
          (i) => `<storyboardItem
  videoDesc='${i.videoDesc}'
  duration='${i.duration}'
></storyboardItem>`
        )},
          `;
        try {
          const { text: text2 } = await utils_default.Ai.Text("universalAi").invoke({
            system: videoPromptGeneration,
            messages: [
              {
                role: "assistant",
                content: `${visualManual}`
              },
              {
                role: "user",
                content
              }
            ]
          });
          await utils_default.db("o_videoTrack").where({ id: trackId }).update({
            prompt: text2
          });
          res.status(200).send(success3(text2));
        } catch (e) {
          res.status(400).send(error50(utils_default.error(e).message));
        }
      }
    );
  }
});

// src/routes/production/workbench/batchGenerateVideo.ts
var import_express82, router82, batchGenerateVideo_default;
var init_batchGenerateVideo = __esm({
  "src/routes/production/workbench/batchGenerateVideo.ts"() {
    "use strict";
    import_express82 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_dist_node();
    init_responseFormat();
    init_middleware();
    router82 = import_express82.default.Router();
    batchGenerateVideo_default = router82.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        scriptId: external_exports.number(),
        trackData: external_exports.array(
          external_exports.object({
            uploadData: external_exports.array(
              external_exports.object({
                id: external_exports.number(),
                sources: external_exports.string()
              })
            ),
            trackId: external_exports.number(),
            prompt: external_exports.string(),
            duration: external_exports.number()
          })
        ),
        model: external_exports.string(),
        mode: external_exports.string(),
        resolution: external_exports.string(),
        audio: external_exports.boolean().optional()
      }),
      async (req, res) => {
        const { scriptId, projectId, trackData, model, resolution, audio, mode } = req.body;
        let modeData = [];
        if (Array.isArray(mode)) {
        } else if (typeof mode === "string" && mode.startsWith('["') && mode.endsWith('"]')) {
          try {
            modeData = JSON.parse(mode);
          } catch (e) {
          }
        }
        const ratio = await utils_default.db("o_project").select("videoRatio").where("id", projectId).first();
        const tasks = await Promise.all(
          trackData.map(async (track) => {
            const { uploadData, trackId, prompt, duration: duration4 } = track;
            const images = await Promise.all(
              uploadData.map(async (item) => {
                if (item.sources === "storyboard") {
                  const filePath = await utils_default.db("o_storyboard").where("id", item.id).select("filePath").first();
                  return { path: filePath?.filePath, sources: "storyBoard" };
                }
                if (item.sources === "assets") {
                  const filePath = await utils_default.db("o_assets").where("o_assets.id", item.id).leftJoin("o_image", "o_assets.imageId", "o_image.id").select("o_image.filePath", "o_image.type").first();
                  return { path: filePath?.filePath, sources: filePath.type };
                }
              })
            );
            const videoPath = `/${projectId}/video/${v4_default()}.mp4`;
            const [videoId] = await utils_default.db("o_video").insert({
              filePath: videoPath,
              time: Date.now(),
              state: "\u751F\u6210\u4E2D",
              scriptId,
              projectId,
              videoTrackId: trackId
            });
            return { videoId, videoPath, prompt, duration: duration4, images, trackId };
          })
        );
        res.status(200).send(success3(tasks.map((t) => ({ videoId: t.videoId, trackId: t.trackId }))));
        for (const { videoId, videoPath, prompt, duration: duration4, images } of tasks) {
          const base644 = await Promise.all(
            images.map(async (item) => {
              if (!item) return null;
              return { base64: await utils_default.oss.getImageBase64(item.path), type: item.sources == "audio" ? "audio" : "image" };
            })
          );
          const relatedObjects = { projectId, videoId, scriptId, type: "\u89C6\u9891" };
          const aiVideo = utils_default.Ai.Video(model);
          aiVideo.run(
            {
              prompt,
              referenceList: base644.filter(Boolean),
              mode: modeData.length > 0 ? modeData : mode,
              duration: duration4,
              aspectRatio: ratio?.videoRatio || "16:9",
              resolution,
              audio
            },
            {
              projectId,
              taskClass: "\u89C6\u9891\u751F\u6210",
              describe: "\u6839\u636E\u63D0\u793A\u8BCD\u751F\u6210\u89C6\u9891",
              relatedObjects: JSON.stringify(relatedObjects)
            }
          ).then(async () => await aiVideo.save(videoPath)).then(async () => await utils_default.db("o_video").where("id", videoId).update({ state: "\u751F\u6210\u6210\u529F" })).catch(async (error73) => {
            await utils_default.db("o_video").where("id", videoId).update({
              state: "\u751F\u6210\u5931\u8D25",
              errorReason: utils_default.error(error73).message
            });
          });
        }
      }
    );
  }
});

// src/routes/production/workbench/checkVideoStateList.ts
var import_express83, router83, checkVideoStateList_default;
var init_checkVideoStateList = __esm({
  "src/routes/production/workbench/checkVideoStateList.ts"() {
    "use strict";
    import_express83 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router83 = import_express83.default.Router();
    checkVideoStateList_default = router83.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        scriptId: external_exports.number(),
        videoIds: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { projectId, scriptId, videoIds } = req.body;
        const videoList = await utils_default.db("o_video").whereIn("id", videoIds).whereIn("state", ["\u751F\u6210\u6210\u529F", "\u751F\u6210\u5931\u8D25"]).select("id", "state", "errorReason", "filePath");
        res.status(200).send(
          success3(
            await Promise.all(
              videoList.map(async (s) => ({
                ...s,
                src: s.filePath ? await utils_default.oss.getFileUrl(s.filePath) : ""
              }))
            )
          )
        );
      }
    );
  }
});

// src/routes/production/workbench/deleteTrack.ts
var import_express84, router84, deleteTrack_default;
var init_deleteTrack = __esm({
  "src/routes/production/workbench/deleteTrack.ts"() {
    "use strict";
    import_express84 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router84 = import_express84.default.Router();
    deleteTrack_default = router84.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        await utils_default.db("o_videoTrack").where("id", id).delete();
        await utils_default.db("o_storyboard").where("trackId", id).update({
          trackId: null
        });
        res.status(200).send(success3({ message: "\u89C6\u9891\u6BB5\u5220\u9664\u6210\u529F" }));
      }
    );
  }
});

// src/routes/production/workbench/delVideo.ts
var import_express85, router85, delVideo_default;
var init_delVideo = __esm({
  "src/routes/production/workbench/delVideo.ts"() {
    "use strict";
    import_express85 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router85 = import_express85.default.Router();
    delVideo_default = router85.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        await utils_default.db("o_video").where("id", id).delete();
        await utils_default.db("o_videoTrack").where("videoId", id).update({
          videoId: null
        });
        res.status(200).send(success3({ message: "\u89C6\u9891\u5220\u9664\u6210\u529F" }));
      }
    );
  }
});

// src/routes/production/workbench/generateVideo.ts
var import_express86, router86, generateVideo_default;
var init_generateVideo = __esm({
  "src/routes/production/workbench/generateVideo.ts"() {
    "use strict";
    import_express86 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_dist_node();
    init_responseFormat();
    init_middleware();
    router86 = import_express86.default.Router();
    generateVideo_default = router86.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        scriptId: external_exports.number(),
        uploadData: external_exports.array(
          external_exports.object({
            id: external_exports.number(),
            sources: external_exports.string()
          })
        ),
        prompt: external_exports.string(),
        model: external_exports.string(),
        mode: external_exports.string(),
        resolution: external_exports.string(),
        duration: external_exports.number(),
        audio: external_exports.boolean().optional(),
        trackId: external_exports.number()
      }),
      async (req, res) => {
        const { scriptId, projectId, prompt, uploadData, model, duration: duration4, resolution, audio, mode, trackId } = req.body;
        let modeData = [];
        if (Array.isArray(mode)) {
        } else if (typeof mode === "string" && mode.startsWith('["') && mode.endsWith('"]')) {
          try {
            modeData = JSON.parse(mode);
          } catch (e) {
          }
        }
        const ratio = await utils_default.db("o_project").select("videoRatio").where("id", projectId).first();
        const videoPath = `/${projectId}/video/${v4_default()}.mp4`;
        const images = await Promise.all(
          uploadData.map(async (item) => {
            if (item.sources === "storyboard") {
              const filePath = await utils_default.db("o_storyboard").where("id", item.id).select("filePath").first();
              return { path: filePath?.filePath, sources: "storyBoard" };
            }
            if (item.sources === "assets") {
              const filePath = await utils_default.db("o_assets").where("o_assets.id", item.id).leftJoin("o_image", "o_assets.imageId", "o_image.id").select("o_image.filePath", "o_image.type").first();
              return { path: filePath?.filePath, sources: filePath.type };
            }
          })
        );
        const base644 = await Promise.all(
          images.map(async (item) => {
            if (!item) return null;
            return { base64: await utils_default.oss.getImageBase64(item.path), type: item.sources == "audio" ? "audio" : "image" };
          })
        );
        const [videoId] = await utils_default.db("o_video").insert({
          filePath: videoPath,
          time: Date.now(),
          state: "\u751F\u6210\u4E2D",
          scriptId,
          projectId,
          videoTrackId: trackId
        });
        res.status(200).send(success3(videoId));
        const relatedObjects = {
          projectId,
          videoId,
          scriptId,
          type: "\u89C6\u9891"
        };
        const aiVideo = utils_default.Ai.Video(model);
        aiVideo.run(
          {
            prompt,
            referenceList: base644.filter(Boolean),
            mode: modeData.length > 0 ? modeData : mode,
            duration: duration4,
            aspectRatio: ratio?.videoRatio || "16:9",
            resolution,
            audio
          },
          {
            projectId,
            taskClass: "\u89C6\u9891\u751F\u6210",
            describe: "\u6839\u636E\u63D0\u793A\u8BCD\u751F\u6210\u89C6\u9891",
            relatedObjects: JSON.stringify(relatedObjects)
          }
        ).then(async () => await aiVideo.save(videoPath)).then(async () => await utils_default.db("o_video").where("id", videoId).update({ state: "\u751F\u6210\u6210\u529F" })).catch(async (error73) => {
          await utils_default.db("o_video").where("id", videoId).update({
            state: "\u751F\u6210\u5931\u8D25",
            errorReason: utils_default.error(error73).message
          });
        });
      }
    );
  }
});

// src/lib/userStorage.ts
function getUserStoragePath(userId, parts = []) {
  return import_path12.default.join(getPath_default(["users", String(userId)]), ...parts);
}
function getUserModelPromptRoot(userId) {
  return getUserStoragePath(userId, ["modelPrompt"]);
}
var import_path12;
var init_userStorage = __esm({
  "src/lib/userStorage.ts"() {
    "use strict";
    import_path12 = __toESM(require("path"));
    init_getPath();
  }
});

// src/routes/production/workbench/generateVideoPrompt.ts
var import_express87, import_promises4, import_path13, router87, generateVideoPrompt_default;
var init_generateVideoPrompt = __esm({
  "src/routes/production/workbench/generateVideoPrompt.ts"() {
    "use strict";
    import_express87 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    import_promises4 = __toESM(require("fs/promises"));
    import_path13 = __toESM(require("path"));
    init_userConfig();
    init_userStorage();
    router87 = import_express87.default.Router();
    generateVideoPrompt_default = router87.post(
      "/",
      validateFields({
        trackId: external_exports.number(),
        projectId: external_exports.number(),
        info: external_exports.array(
          external_exports.object({
            id: external_exports.number(),
            sources: external_exports.string()
          })
        ),
        model: external_exports.string(),
        mode: external_exports.string()
      }),
      async (req, res) => {
        const { trackId, projectId, info, model, mode } = req.body;
        const userId = requireRequestUserId(req);
        const images = await Promise.all(
          info.map(async (item) => {
            if (item.sources === "storyboard") {
              const storyboard2 = await utils_default.db("o_storyboard").where("o_storyboard.id", item.id).select("videoDesc", "prompt", "track", "duration", "shouldGenerateImage").first();
              const assetRows = await utils_default.db("o_assets2Storyboard").where("storyboardId", item.id).orderBy("rowid").select("assetId");
              const associateAssetsIds = assetRows.map((row) => row.assetId);
              return {
                ...storyboard2,
                associateAssetsIds,
                _type: "storyboard"
                // 标记类型，便于后续区分
              };
            }
            if (item.sources === "assets") {
              const assetsData = await utils_default.db("o_assets").leftJoin("o_image", "o_image.id", "o_assets.imageId").where("o_assets.id", item.id).select("o_assets.id", "o_assets.type", "o_assets.name", "o_image.filePath").first();
              return {
                ...assetsData,
                _type: "assets"
                // 标记类型
              };
            }
          })
        );
        const assets = [];
        const storyboard = [];
        for (const item of images) {
          if (!item) continue;
          if (item._type === "assets")
            assets.push({
              id: item.id,
              type: item.type,
              name: item.name,
              filePath: item.filePath
            });
          if (item._type === "storyboard")
            storyboard.push({
              videoDesc: item.videoDesc,
              prompt: item.prompt,
              track: item.track,
              duration: item.duration,
              associateAssetsIds: item.associateAssetsIds,
              shouldGenerateImage: item.shouldGenerateImage
            });
        }
        const assetsNotAudioIds = assets.filter((i) => i.type == "audio").map((i) => i.id);
        const assets2Audio = await utils_default.db("o_assets").whereIn("o_assets.id", assetsNotAudioIds).join("o_assetsRole2Audio", "o_assetsRole2Audio.assetsAudioId", "o_assets.assetsId").select("o_assets.assetsId", "o_assets.id", "o_assetsRole2Audio.assetsAudioId", "o_assetsRole2Audio.assetsRoleId");
        const assetsAudioRecord = {};
        assets2Audio.forEach((i) => {
          assetsAudioRecord[i.assetsRoleId] = i.id;
        });
        const [id, modelData] = model.split(/:(.+)/);
        const projectData = await utils_default.db("o_project").select("*").where({ id: projectId }).first();
        const videoPrompt = await getPromptForUser("videoPromptGeneration", userId);
        let videoPromptGeneration = "";
        const modelPromptData = await getModelPromptBindingForUser(id, modelData, userId);
        if (modelPromptData) {
          const modelPromptRoot = modelPromptData.scope === "user" ? getUserModelPromptRoot(userId) : utils_default.getPath(["modelPrompt"]);
          try {
            const fullPath = import_path13.default.join(modelPromptRoot, modelPromptData?.path);
            const content2 = await import_promises4.default.readFile(fullPath, "utf-8");
            videoPromptGeneration = content2 ?? "";
          } catch {
          }
        }
        if (!videoPromptGeneration) {
          const modelPromptRoot = utils_default.getPath(["modelPrompt"]);
          const videoPromptDir = import_path13.default.join(modelPromptRoot, "video");
          const modelLower = (modelData ?? "").toLowerCase();
          let fileName = null;
          if (modelLower.includes("wan") && modelLower.includes("2.6")) {
            fileName = "wan2.6Single-imageFirstFrameMode.md";
          } else if (/seedance.*2[.\-]0/i.test(modelData)) {
            fileName = "seedance2Multi-parameterMode.md";
          } else if (mode === "startEndRequired" || mode === "endFrameOptional" || mode === "startFrameOptional") {
            fileName = "universalFirstAndLastFrameMode.md";
          } else if (typeof mode === "string" && mode.startsWith('["') && mode.endsWith('"]')) {
            fileName = "universalMulti-parameterMode.md";
          }
          if (fileName) {
            try {
              const fullPath = import_path13.default.join(videoPromptDir, fileName);
              videoPromptGeneration = await import_promises4.default.readFile(fullPath, "utf-8");
            } catch {
            }
          }
        }
        if (!videoPromptGeneration) {
          videoPromptGeneration = videoPrompt?.data ?? void 0;
        }
        const artStyle = projectData?.artStyle || "\u65E0";
        console.log("%c Line:158 \u{1F362}", "background:#ffdd4d", assets);
        const visualManual = utils_default.getArtPrompt(artStyle, "art_skills", "art_storyboard_video");
        const content = `
          **\u6A21\u578B\u540D\u79F0**\uFF1A${modelData},

          **\u8D44\u4EA7\u4FE1\u606F**\uFF08\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177\u3001\u97F3\u9891):${assets.filter((i) => i.filePath).map((i) => `[${i.id},${i.type},${i.name} ${assetsAudioRecord[i.id] ? `audio:${assetsAudioRecord[i.id]}` : ""} ] `).join("\uFF0C")},
          **\u5206\u955C\u4FE1\u606F**\uFF1A${storyboard.map(
          (i) => `<storyboardItem
  videoDesc='${i.videoDesc}'
  duration='${i.duration}'
></storyboardItem>`
        )},
          `;
        console.log("%c Line:156 \u{1F36C} content", "background:#4fff4B", content);
        try {
          const { text: text2 } = await utils_default.Ai.Text("universalAi").invoke({
            system: videoPromptGeneration,
            messages: [
              {
                role: "assistant",
                content: `${visualManual}`
              },
              {
                role: "user",
                content
              }
            ]
          });
          await utils_default.db("o_videoTrack").where({ id: trackId }).update({
            prompt: text2
          });
          res.status(200).send(success3(text2));
        } catch (e) {
          res.status(400).send(error50(utils_default.error(e).message));
        }
      }
    );
  }
});

// src/routes/production/workbench/getAudioBindAssetsList.ts
var import_express88, router88, getAudioBindAssetsList_default;
var init_getAudioBindAssetsList = __esm({
  "src/routes/production/workbench/getAudioBindAssetsList.ts"() {
    "use strict";
    import_express88 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router88 = import_express88.default.Router();
    getAudioBindAssetsList_default = router88.post(
      "/",
      validateFields({
        assetsIds: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { assetsIds } = req.body;
        const assets2AudioData = await utils_default.db("o_assetsRole2Audio").whereIn("assetsRoleId", assetsIds).select("assetsAudioId", "assetsRoleId");
        if (assets2AudioData.length) {
          const assetsData = await utils_default.db("o_assets").leftJoin("o_image", "o_image.id", "o_assets.imageId").whereIn("o_assets.assetsId", assets2AudioData.map((i) => i.assetsAudioId)).select("o_assets.id", "o_image.filePath", "o_assets.prompt", "o_assets.assetsId");
          await Promise.all(
            assetsData.map(async (i) => {
              i.filePath && (i.src = await utils_default.oss.getFileUrl(i.filePath));
            })
          );
          return res.status(200).send(
            success3(
              assetsData.map((i) => ({
                fileType: "audio",
                sources: "assets",
                src: i.src,
                id: i.id,
                prompt: i.prompt
              }))
            )
          );
        }
        res.status(200).send(success3());
      }
    );
  }
});

// src/routes/production/workbench/getFileUrl.ts
var import_express89, router89, getFileUrl_default;
var init_getFileUrl = __esm({
  "src/routes/production/workbench/getFileUrl.ts"() {
    "use strict";
    import_express89 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router89 = import_express89.default.Router();
    getFileUrl_default = router89.post(
      "/",
      validateFields({
        items: external_exports.array(external_exports.object({
          id: external_exports.number(),
          sources: external_exports.string()
        }))
      }),
      async (req, res) => {
        const { items } = req.body;
        const result = {};
        const storyboardIds = items.filter((item) => item.sources == "storyboard").map((item) => item.id);
        const totalFilePaths = [];
        if (storyboardIds.length) {
          const storyBoardPaths = await utils_default.db("o_storyboard").whereIn("id", storyboardIds).select("id", "filePath");
          totalFilePaths.push(...storyBoardPaths.map((i) => ({ id: i.id, filePath: i.filePath, sources: "storyboard" })));
        }
        const assetsIds = items.filter((item) => item.sources == "assets").map((item) => item.id);
        if (assetsIds.length) {
          const assetsPaths = await utils_default.db("o_assets").leftJoin("o_image", "o_image.id", "o_assets.imageId").whereIn("o_assets.id", assetsIds).select("o_assets.id", "o_image.filePath");
          totalFilePaths.push(...assetsPaths.map((i) => ({ id: i.id, filePath: i.filePath, sources: "assets" })));
        }
        await Promise.all(
          totalFilePaths.map(async (item) => {
            result[`${item.id}:${item.sources}`] = item.filePath ? await utils_default.oss.getSmallImageUrl(item.filePath) : "";
          })
        );
        res.status(200).send(success3({ data: result }));
      }
    );
  }
});

// src/routes/production/workbench/getGenerateData.ts
var import_express90, router90, getGenerateData_default;
var init_getGenerateData = __esm({
  "src/routes/production/workbench/getGenerateData.ts"() {
    "use strict";
    import_express90 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router90 = import_express90.default.Router();
    getGenerateData_default = router90.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        scriptId: external_exports.number()
      }),
      async (req, res) => {
        const { projectId, scriptId } = req.body;
        const projectData = await utils_default.db("o_project").where("id", projectId).select("id", "videoModel", "mode").first();
        if (!projectData?.videoModel) {
          return res.status(400).json(success3("\u9879\u76EE\u672A\u914D\u7F6E\u89C6\u9891\u6A21\u578B"));
        }
        let videoMode = "";
        try {
          videoMode = JSON.parse(projectData?.mode ?? "");
        } catch (e) {
          videoMode = projectData?.mode ?? "";
        }
        const isRef = Array.isArray(videoMode) ? true : false;
        const storyboardList = await utils_default.db("o_storyboard").where({ scriptId, projectId }).orderBy("index", "asc");
        await Promise.all(
          storyboardList.map(async (i) => {
            i.filePath = i.filePath ? await utils_default.oss.getSmallImageUrl(i.filePath) : "";
          })
        );
        const storyboardTrackRecord = {};
        storyboardList.forEach((i) => {
          if (storyboardTrackRecord[i.trackId]) {
            storyboardTrackRecord[i.trackId].push({
              src: i.filePath,
              fileType: "image",
              sources: "storyboard",
              ...i.prompt != null ? { prompt: i.videoDesc } : {},
              ...i.id != null ? { id: i.id } : {},
              index: i.index
            });
          } else {
            storyboardTrackRecord[i.trackId] = [
              {
                src: i.filePath,
                fileType: "image",
                sources: "storyboard",
                ...i.prompt != null ? { prompt: i.videoDesc } : {},
                ...i.id != null ? { id: i.id } : {},
                index: i.index
              }
            ];
          }
        });
        const otherDataMap = {};
        const audioReferenceCount = (() => {
          if (!Array.isArray(videoMode)) return 0;
          const item = videoMode.find((v) => v.toLowerCase().startsWith("audioreference:"));
          if (!item) return 0;
          const num = parseInt(item.split(":")[1], 10);
          return isNaN(num) ? 0 : num;
        })();
        if (isRef) {
          const storyIds = storyboardList.map((s) => s.id);
          const assetDatas = await utils_default.db("o_assets2Storyboard").leftJoin("o_assets", "o_assets2Storyboard.assetId", "o_assets.id").leftJoin("o_image", "o_image.id", "o_assets.imageId").whereIn("o_assets2Storyboard.storyboardId", storyIds).select("o_assets.*", "o_image.filePath", "o_assets2Storyboard.storyboardId");
          const queryAudioIds = [...assetDatas.map((i) => i.id), ...assetDatas.map((i) => i.assetsId)].filter(Boolean);
          const assets2AudioData = await utils_default.db("o_assetsRole2Audio").leftJoin("o_assets", "o_assets.assetsId", "o_assetsRole2Audio.assetsAudioId").leftJoin("o_image", "o_image.id", "o_assets.imageId").whereIn("o_assetsRole2Audio.assetsRoleId", queryAudioIds).select(
            "o_assets.id",
            "o_assets.name",
            "o_assetsRole2Audio.assetsRoleId",
            "o_assets.describe",
            "o_assets.type",
            "o_assets.prompt",
            "o_image.filePath"
          );
          const audioRecord = {};
          await Promise.all(
            assets2AudioData.map(async (i) => {
              if (!audioRecord[i.assetsRoleId]) audioRecord[i.assetsRoleId] = [];
              audioRecord[i.assetsRoleId].push({
                id: i.id,
                name: i.name,
                describe: i.describe,
                type: i.type,
                fileType: "audio",
                sources: "assets",
                prompt: i.prompt,
                src: i.filePath ? await utils_default.oss.getFileUrl(i.filePath) : ""
              });
            })
          );
          await Promise.all(
            assetDatas.map(async (i) => {
              const item = {
                id: i.id,
                name: i.name,
                describe: i.describe,
                type: i.type,
                fileType: "image",
                sources: "assets",
                src: i.filePath ? await utils_default.oss.getSmallImageUrl(i.filePath) : ""
              };
              const sid = i.storyboardId;
              if (!otherDataMap[sid]) otherDataMap[sid] = [];
              otherDataMap[sid].push(item);
              if (audioRecord[i.id]) otherDataMap[sid].push(...audioRecord[i.id]);
              if (audioRecord[i.assetsId]) otherDataMap[sid].push(...audioRecord[i.assetsId]);
            })
          );
        }
        const trackData = await utils_default.db("o_videoTrack").where({ projectId, scriptId });
        const videoList = await utils_default.db("o_video").whereIn(
          "videoTrackId",
          trackData.map((t) => t.id)
        );
        const trackList = [];
        const trackIdMap = [...new Set(trackData.map((t) => t.id))];
        for (const trackId of trackIdMap) {
          const item = trackData.find((t) => t.id === trackId);
          trackList.push({
            id: trackId,
            duration: item?.duration ?? 0,
            prompt: item?.prompt || "",
            state: item?.state ?? "\u672A\u751F\u6210",
            reason: item?.reason ?? "",
            selectVideoId: Number(item?.videoId),
            medias: (() => {
              const storyboardMedias = storyboardTrackRecord[trackId] ?? [];
              const assetMedias = storyboardMedias.flatMap((s) => otherDataMap[s.id] ?? []);
              const seenAssetIds = /* @__PURE__ */ new Set();
              const uniqueAssets = assetMedias.filter((a) => {
                if (seenAssetIds.has(a.id)) return false;
                seenAssetIds.add(a.id);
                return true;
              });
              const audioCountMap = {};
              const filteredAssets = uniqueAssets.filter((a) => {
                if (a.fileType !== "audio" || audioReferenceCount === 0) return true;
                const key = String(a.id);
                audioCountMap[key] = (audioCountMap[key] ?? 0) + 1;
                const totalAudio = Object.values(audioCountMap).reduce((s, n) => s + n, 0);
                return totalAudio <= audioReferenceCount;
              });
              const hasImageAssetData = filteredAssets.filter((i) => i.src);
              const notHasImageAssetData = filteredAssets.filter((i) => !i.src);
              return [...hasImageAssetData, ...storyboardMedias, ...notHasImageAssetData];
            })(),
            videoList: await Promise.all(
              videoList.filter((v) => v.videoTrackId === trackId).map(async (v) => ({
                id: v.id,
                src: v.filePath ? await utils_default.oss.getFileUrl(v.filePath) : "",
                state: v.state === "\u5DF2\u5B8C\u6210" ? "\u5DF2\u5B8C\u6210" : v.state === "\u751F\u6210\u4E2D" ? "\u751F\u6210\u4E2D" : v.state === "\u751F\u6210\u5931\u8D25" ? "\u751F\u6210\u5931\u8D25" : "\u672A\u751F\u6210",
                errorReason: v?.errorReason ?? ""
              }))
            )
          });
        }
        res.status(200).send(
          success3({
            storyboardList: await Promise.all(
              storyboardList.map(async (s) => ({
                ...s,
                src: s.filePath
              }))
            ),
            trackList
          })
        );
      }
    );
  }
});

// src/routes/production/workbench/getVideoList.ts
var import_express91, router91, getVideoList_default;
var init_getVideoList = __esm({
  "src/routes/production/workbench/getVideoList.ts"() {
    "use strict";
    import_express91 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router91 = import_express91.default.Router();
    getVideoList_default = router91.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        scriptId: external_exports.number()
      }),
      async (req, res) => {
        const { projectId, scriptId } = req.body;
        const storyboardList = await utils_default.db("o_storyboard").where({ scriptId, projectId }).orderBy("index", "asc");
        const videoList = await utils_default.db("o_video").whereIn(
          "videoTrackId",
          storyboardList.map((s) => s.trackId)
        );
        res.status(200).send(
          success3(
            await Promise.all(
              videoList.map(async (s) => ({
                ...s,
                src: s.filePath ? await utils_default.oss.getSmallImageUrl(s.filePath) : ""
              }))
            )
          )
        );
      }
    );
  }
});

// src/routes/production/workbench/selectVideo.ts
var import_express92, router92, selectVideo_default;
var init_selectVideo = __esm({
  "src/routes/production/workbench/selectVideo.ts"() {
    "use strict";
    import_express92 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router92 = import_express92.default.Router();
    selectVideo_default = router92.post(
      "/",
      validateFields({
        trackId: external_exports.number(),
        videoId: external_exports.number()
      }),
      async (req, res) => {
        const { trackId, videoId } = req.body;
        await utils_default.db("o_videoTrack").where("id", trackId).update({
          videoId
        });
        res.status(200).send(success3({ message: "\u89C6\u9891\u9009\u62E9\u6210\u529F" }));
      }
    );
  }
});

// src/routes/production/workbench/updateVideoDuration.ts
var import_express93, router93, updateVideoDuration_default;
var init_updateVideoDuration = __esm({
  "src/routes/production/workbench/updateVideoDuration.ts"() {
    "use strict";
    import_express93 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router93 = import_express93.default.Router();
    updateVideoDuration_default = router93.post(
      "/",
      validateFields({
        id: external_exports.number(),
        duration: external_exports.number().optional()
      }),
      async (req, res) => {
        const { id, duration: duration4 } = req.body;
        await utils_default.db("o_videoTrack").where("id", id).update({
          duration: duration4
        });
        res.status(200).send(success3("\u66F4\u65B0\u6210\u529F"));
      }
    );
  }
});

// src/routes/production/workbench/updateVideoPrompt.ts
var import_express94, router94, updateVideoPrompt_default;
var init_updateVideoPrompt = __esm({
  "src/routes/production/workbench/updateVideoPrompt.ts"() {
    "use strict";
    import_express94 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router94 = import_express94.default.Router();
    updateVideoPrompt_default = router94.post(
      "/",
      validateFields({
        id: external_exports.number(),
        prompt: external_exports.string().optional()
      }),
      async (req, res) => {
        const { id, prompt, duration: duration4 } = req.body;
        await utils_default.db("o_videoTrack").where("id", id).update({
          prompt
        });
        res.status(200).send(success3("\u66F4\u65B0\u6210\u529F"));
      }
    );
  }
});

// src/routes/project/addDirectorManual.ts
var import_express95, import_fs7, import_path14, router95, addDirectorManual_default;
var init_addDirectorManual = __esm({
  "src/routes/project/addDirectorManual.ts"() {
    "use strict";
    import_express95 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    import_fs7 = __toESM(require("fs"));
    import_path14 = __toESM(require("path"));
    init_middleware();
    init_zod();
    router95 = import_express95.default.Router();
    addDirectorManual_default = router95.post(
      "/",
      validateFields({
        name: external_exports.string(),
        images: external_exports.array(external_exports.string()),
        directorManual: external_exports.string(),
        data: external_exports.array(
          external_exports.object({
            label: external_exports.string(),
            value: external_exports.string(),
            data: external_exports.string()
          })
        )
      }),
      async (req, res) => {
        try {
          const { name: name28, images, data, directorManual } = req.body;
          if (name28.includes("/") || name28.includes("\\") || name28 === "." || name28 === ".." || /^\d+$/.test(name28)) {
            res.status(400).send(error50("\u540D\u79F0\u4E0D\u80FD\u5305\u542B\u8DEF\u5F84\u5206\u9694\u7B26\u6216\u4E3A\u7EAF\u6570\u5B57"));
            return;
          }
          const mainPath = utils_default.getPath(["skills", "story_skills", directorManual]);
          if (import_fs7.default.existsSync(mainPath)) {
            return res.status(400).send(error50("\u8BF7\u52FF\u586B\u5199\u91CD\u590D\u540D\u79F0\u7684\u89C6\u89C9\u624B\u518C"));
          }
          const DATA_MAP3 = [
            { value: "README" },
            { value: "director_planning_narrative", subDir: "driector_skills" },
            { value: "director_storyboard_table_narrative", subDir: "driector_skills" }
          ];
          const SUB_DIR_MAP = new Map(DATA_MAP3.map(({ value, subDir }) => [value, subDir ?? ""]));
          const VALID_KEYS = new Set(DATA_MAP3.map(({ value }) => value));
          for (const item of data) {
            if (!VALID_KEYS.has(item.value)) continue;
            const subDir = SUB_DIR_MAP.get(item.value);
            const dirArr = subDir ? [mainPath, subDir] : [mainPath];
            const filePath = utils_default.getPath([...dirArr, `${item.value}.md`]);
            const fileDir = import_path14.default.dirname(filePath);
            if (!import_fs7.default.existsSync(fileDir)) {
              import_fs7.default.mkdirSync(fileDir, { recursive: true });
            }
            import_fs7.default.writeFileSync(filePath, item.data, "utf-8");
          }
          const imagesDir = import_path14.default.join(mainPath, "images");
          let existingFiles = [];
          try {
            const allFiles = import_fs7.default.readdirSync(imagesDir);
            existingFiles = allFiles.filter((f) => /\.(png|jpe?g|gif|webp|svg)$/i.test(f));
          } catch {
          }
          const retainedFileNames = new Set(images.filter((item) => item.startsWith("http")).map((url4) => import_path14.default.basename(new URL(url4).pathname)));
          for (const file3 of existingFiles) {
            if (!retainedFileNames.has(file3)) {
              const filePath = import_path14.default.join(imagesDir, file3);
              if (import_fs7.default.existsSync(filePath)) import_fs7.default.unlinkSync(filePath);
            }
          }
          if (!import_fs7.default.existsSync(imagesDir)) {
            import_fs7.default.mkdirSync(imagesDir, { recursive: true });
          }
          for (const item of images) {
            if (!item.startsWith("http")) {
              const fileName = `${utils_default.uuid()}.jpg`;
              const targetPath = import_path14.default.join(imagesDir, fileName);
              const buffer = Buffer.from(item.replace(/^data:[^;]+;base64,/, ""), "base64");
              import_fs7.default.writeFileSync(targetPath, buffer);
            }
          }
          res.status(200).send(success3());
        } catch (err) {
          res.status(500).send({ error: String(err) });
        }
      }
    );
  }
});

// src/routes/project/addProject.ts
var import_express96, router96, addProject_default;
var init_addProject = __esm({
  "src/routes/project/addProject.ts"() {
    "use strict";
    import_express96 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    init_auth();
    router96 = import_express96.default.Router();
    addProject_default = router96.post(
      "/",
      validateFields({
        projectType: external_exports.string(),
        name: external_exports.string(),
        intro: external_exports.string(),
        type: external_exports.string(),
        artStyle: external_exports.string(),
        directorManual: external_exports.string(),
        videoRatio: external_exports.string(),
        imageModel: external_exports.string(),
        videoModel: external_exports.string(),
        imageQuality: external_exports.string(),
        mode: external_exports.string()
      }),
      async (req, res) => {
        const { projectType, name: name28, intro, type, directorManual, artStyle, videoRatio, imageModel, videoModel, imageQuality, mode } = req.body;
        const user = getCurrentUser(req);
        await utils_default.db("o_project").insert({
          id: Date.now(),
          projectType,
          name: name28,
          intro,
          type,
          artStyle,
          videoRatio,
          directorManual,
          userId: user.id,
          imageModel,
          videoModel,
          createTime: Date.now(),
          imageQuality,
          mode
        });
        res.status(200).send(success3({ message: "\u65B0\u589E\u9879\u76EE\u6210\u529F" }));
      }
    );
  }
});

// src/routes/project/addVisualManual.ts
var import_express97, import_fs8, import_path15, router97, addVisualManual_default;
var init_addVisualManual = __esm({
  "src/routes/project/addVisualManual.ts"() {
    "use strict";
    import_express97 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    import_fs8 = __toESM(require("fs"));
    import_path15 = __toESM(require("path"));
    init_middleware();
    init_zod();
    router97 = import_express97.default.Router();
    addVisualManual_default = router97.post(
      "/",
      validateFields({
        name: external_exports.string(),
        images: external_exports.array(external_exports.string()),
        stylePath: external_exports.string(),
        data: external_exports.array(
          external_exports.object({
            label: external_exports.string(),
            value: external_exports.string(),
            data: external_exports.string()
          })
        )
      }),
      async (req, res) => {
        try {
          const { name: name28, images, data, stylePath } = req.body;
          if (name28.includes("/") || name28.includes("\\") || name28 === "." || name28 === ".." || /^\d+$/.test(name28)) {
            res.status(400).send(error50("\u540D\u79F0\u4E0D\u80FD\u5305\u542B\u8DEF\u5F84\u5206\u9694\u7B26\u6216\u4E3A\u7EAF\u6570\u5B57"));
            return;
          }
          const mainPath = utils_default.getPath(["skills", "art_skills", stylePath]);
          if (import_fs8.default.existsSync(mainPath)) {
            return res.status(400).send(error50("\u8BF7\u52FF\u586B\u5199\u91CD\u590D\u540D\u79F0\u7684\u89C6\u89C9\u624B\u518C"));
          }
          const DATA_MAP3 = [
            { value: "README" },
            { value: "prefix" },
            { value: "art_character", subDir: "art_prompt" },
            { value: "art_character_derivative", subDir: "art_prompt" },
            { value: "art_prop", subDir: "art_prompt" },
            { value: "art_prop_derivative", subDir: "art_prompt" },
            { value: "art_scene", subDir: "art_prompt" },
            { value: "art_scene_derivative", subDir: "art_prompt" },
            { value: "director_storyboard", subDir: "driector_skills" },
            { value: "art_storyboard_video", subDir: "art_prompt" },
            { value: "director_planning_style", subDir: "driector_skills" },
            { value: "director_storyboard_table_style", subDir: "driector_skills" }
          ];
          const SUB_DIR_MAP = new Map(DATA_MAP3.map(({ value, subDir }) => [value, subDir ?? ""]));
          const VALID_KEYS = new Set(DATA_MAP3.map(({ value }) => value));
          for (const item of data) {
            if (!VALID_KEYS.has(item.value)) continue;
            const subDir = SUB_DIR_MAP.get(item.value);
            const dirArr = subDir ? [mainPath, subDir] : [mainPath];
            const filePath = utils_default.getPath([...dirArr, `${item.value}.md`]);
            const fileDir = import_path15.default.dirname(filePath);
            if (!import_fs8.default.existsSync(fileDir)) {
              import_fs8.default.mkdirSync(fileDir, { recursive: true });
            }
            import_fs8.default.writeFileSync(filePath, item.data, "utf-8");
          }
          const imagesDir = import_path15.default.join(mainPath, "images");
          let existingFiles = [];
          try {
            const allFiles = import_fs8.default.readdirSync(imagesDir);
            existingFiles = allFiles.filter((f) => /\.(png|jpe?g|gif|webp|svg)$/i.test(f));
          } catch {
          }
          const retainedFileNames = new Set(images.filter((item) => item.startsWith("http")).map((url4) => import_path15.default.basename(new URL(url4).pathname)));
          for (const file3 of existingFiles) {
            if (!retainedFileNames.has(file3)) {
              const filePath = import_path15.default.join(imagesDir, file3);
              if (import_fs8.default.existsSync(filePath)) import_fs8.default.unlinkSync(filePath);
            }
          }
          if (!import_fs8.default.existsSync(imagesDir)) {
            import_fs8.default.mkdirSync(imagesDir, { recursive: true });
          }
          for (const item of images) {
            if (!item.startsWith("http")) {
              const fileName = `${utils_default.uuid()}.jpg`;
              const targetPath = import_path15.default.join(imagesDir, fileName);
              const buffer = Buffer.from(item.replace(/^data:[^;]+;base64,/, ""), "base64");
              import_fs8.default.writeFileSync(targetPath, buffer);
            }
          }
          res.status(200).send(success3());
        } catch (err) {
          res.status(500).send({ error: String(err) });
        }
      }
    );
  }
});

// src/routes/project/deleteDirectorManual.ts
var import_express98, import_promises5, router98, deleteDirectorManual_default;
var init_deleteDirectorManual = __esm({
  "src/routes/project/deleteDirectorManual.ts"() {
    "use strict";
    import_express98 = __toESM(require_express2());
    init_utils3();
    import_promises5 = __toESM(require("node:fs/promises"));
    init_zod();
    init_responseFormat();
    init_middleware();
    router98 = import_express98.default.Router();
    deleteDirectorManual_default = router98.post(
      "/",
      validateFields({
        name: external_exports.string()
      }),
      async (req, res) => {
        try {
          const { name: name28 } = req.body;
          if (name28.includes("/") || name28.includes("\\") || name28 === "." || name28 === ".." || /^\d+$/.test(name28)) {
            res.status(400).send(error50("\u540D\u79F0\u4E0D\u80FD\u5305\u542B\u8DEF\u5F84\u5206\u9694\u7B26\u6216\u4E3A\u7EAF\u6570\u5B57"));
            return;
          }
          const artPromptsDir = utils_default.getPath(["skills", "story_skills", name28]);
          try {
            const stat = await import_promises5.default.stat(artPromptsDir);
            if (!stat.isDirectory()) {
              throw new Error(`${artPromptsDir} \u4E0D\u662F\u6587\u4EF6\u5939`);
            }
            await import_promises5.default.rm(artPromptsDir, { recursive: true, force: true });
          } catch (e) {
            console.error("[\u5220\u9664\u89C6\u89C9\u624B\u518C] \u5220\u9664\u5931\u8D25:", artPromptsDir, e);
          }
          res.status(200).send(success3({ message: "\u5220\u9664\u6210\u529F" }));
        } catch (err) {
          res.status(500).send(error50(utils_default.error(err).message || "\u5220\u9664\u5931\u8D25"));
        }
      }
    );
  }
});

// src/routes/project/deleteVisualManual.ts
var import_express99, import_promises6, router99, deleteVisualManual_default;
var init_deleteVisualManual = __esm({
  "src/routes/project/deleteVisualManual.ts"() {
    "use strict";
    import_express99 = __toESM(require_express2());
    init_utils3();
    import_promises6 = __toESM(require("node:fs/promises"));
    init_zod();
    init_responseFormat();
    init_middleware();
    router99 = import_express99.default.Router();
    deleteVisualManual_default = router99.post(
      "/",
      validateFields({
        name: external_exports.string()
      }),
      async (req, res) => {
        try {
          const { name: name28 } = req.body;
          if (name28.includes("/") || name28.includes("\\") || name28 === "." || name28 === ".." || /^\d+$/.test(name28)) {
            res.status(400).send(error50("\u540D\u79F0\u4E0D\u80FD\u5305\u542B\u8DEF\u5F84\u5206\u9694\u7B26\u6216\u4E3A\u7EAF\u6570\u5B57"));
            return;
          }
          const artPromptsDir = utils_default.getPath(["skills", "art_skills", name28]);
          try {
            const stat = await import_promises6.default.stat(artPromptsDir);
            if (!stat.isDirectory()) {
              throw new Error(`${artPromptsDir} \u4E0D\u662F\u6587\u4EF6\u5939`);
            }
            await import_promises6.default.rm(artPromptsDir, { recursive: true, force: true });
          } catch (e) {
            console.error("[\u5220\u9664\u89C6\u89C9\u624B\u518C] \u5220\u9664\u5931\u8D25:", artPromptsDir, e);
          }
          res.status(200).send(success3({ message: "\u5220\u9664\u6210\u529F" }));
        } catch (err) {
          res.status(500).send(error50(utils_default.error(err).message || "\u5220\u9664\u5931\u8D25"));
        }
      }
    );
  }
});

// src/routes/project/delProject.ts
var import_express100, router100, delProject_default;
var init_delProject = __esm({
  "src/routes/project/delProject.ts"() {
    "use strict";
    import_express100 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router100 = import_express100.default.Router();
    delProject_default = router100.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        await utils_default.db("o_project").where("id", id).delete();
        await utils_default.db("o_agentWorkData").where("projectId", id).delete();
        await utils_default.db("o_novel").where("projectId", id).delete();
        const scriptData = await utils_default.db("o_script").where("projectId", id).select("id");
        const scriptIds = scriptData.map((item) => item.id);
        if (scriptIds.length > 0) {
          await utils_default.db("o_scriptAssets").whereIn("scriptId", scriptIds).delete();
        }
        await utils_default.db("o_script").where("projectId", id).delete();
        await utils_default.db("o_tasks").where("projectId", id).delete();
        const storyboardData = await utils_default.db("o_storyboard").where("projectId", id).select("id");
        const storyboardIds = storyboardData.map((item) => item.id);
        if (storyboardIds.length > 0) {
          await utils_default.db("o_assets2Storyboard").whereIn("storyboardId", storyboardIds).delete();
        }
        await utils_default.db("o_storyboard").where("projectId", id).delete();
        const assetsData = await utils_default.db("o_assets").where("projectId", id).select("id");
        const assetsIds = assetsData.map((item) => item.id);
        if (assetsIds.length > 0) {
          await utils_default.db("o_assets").whereIn("id", assetsIds).update({ imageId: null });
          await utils_default.db("o_image").whereIn("assetsId", assetsIds).delete();
        }
        await utils_default.db("o_assets").where("projectId", id).delete();
        await utils_default.db("o_videoTrack").where("projectId", id).delete();
        await utils_default.db("o_video").where("projectId", id).delete();
        await utils_default.db("memories").where("isolationKey", "like", `${id}:%`).delete();
        try {
          await utils_default.oss.deleteDirectory(`${id}/`);
          console.log(`\u9879\u76EE ${id} \u7684OSS\u6587\u4EF6\u5939\u5220\u9664\u6210\u529F`);
        } catch (error73) {
          console.log(`\u9879\u76EE ${id} \u6CA1\u6709\u5BF9\u5E94\u7684OSS\u6587\u4EF6\u5939\uFF0C\u8DF3\u8FC7\u5220\u9664`);
        }
        res.status(200).send(success3({ message: "\u5220\u9664\u9879\u76EE\u6210\u529F" }));
      }
    );
  }
});

// src/routes/project/editDirectorlManual.ts
var import_express101, import_fs9, import_path16, router101, editDirectorlManual_default;
var init_editDirectorlManual = __esm({
  "src/routes/project/editDirectorlManual.ts"() {
    "use strict";
    import_express101 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    import_fs9 = __toESM(require("fs"));
    import_path16 = __toESM(require("path"));
    init_middleware();
    init_zod();
    router101 = import_express101.default.Router();
    editDirectorlManual_default = router101.post(
      "/",
      validateFields({
        name: external_exports.string(),
        directorManual: external_exports.string(),
        images: external_exports.array(external_exports.string()),
        data: external_exports.array(
          external_exports.object({
            label: external_exports.string(),
            value: external_exports.string(),
            data: external_exports.string()
          })
        )
      }),
      async (req, res) => {
        try {
          const { name: name28, directorManual, images, data } = req.body;
          if (name28.includes("/") || name28.includes("\\") || name28 === "." || name28 === ".." || /^\d+$/.test(name28)) {
            res.status(400).send(error50("\u540D\u79F0\u4E0D\u80FD\u5305\u542B\u8DEF\u5F84\u5206\u9694\u7B26\u6216\u4E3A\u7EAF\u6570\u5B57"));
            return;
          }
          const mainPath = utils_default.getPath(["skills", "story_skills", directorManual]);
          if (!import_fs9.default.existsSync(mainPath)) {
            return res.status(400).send(error50("\u5BFC\u6F14\u624B\u518C\u4E0D\u5B58\u5728"));
          }
          const DATA_MAP3 = [
            { value: "README" },
            { value: "director_planning_narrative", subDir: "driector_skills" },
            { value: "director_storyboard_table_narrative", subDir: "driector_skills" }
          ];
          const SUB_DIR_MAP = new Map(DATA_MAP3.map(({ value, subDir }) => [value, subDir ?? ""]));
          const VALID_KEYS = new Set(DATA_MAP3.map(({ value }) => value));
          for (const item of data) {
            if (!VALID_KEYS.has(item.value)) continue;
            const subDir = SUB_DIR_MAP.get(item.value);
            const dirArr = subDir ? [mainPath, subDir] : [mainPath];
            const filePath = utils_default.getPath([...dirArr, `${item.value}.md`]);
            const fileDir = import_path16.default.dirname(filePath);
            if (!import_fs9.default.existsSync(fileDir)) {
              import_fs9.default.mkdirSync(fileDir, { recursive: true });
            }
            const content = item.value === "README" ? `${name28}
${item.data}` : item.data;
            import_fs9.default.writeFileSync(filePath, content, "utf-8");
          }
          const imagesDir = import_path16.default.join(mainPath, "images");
          let existingFiles = [];
          try {
            const allFiles = import_fs9.default.readdirSync(imagesDir);
            existingFiles = allFiles.filter((f) => /\.(png|jpe?g|gif|webp|svg)$/i.test(f));
          } catch {
          }
          const retainedFileNames = new Set(images.filter((item) => item.startsWith("http")).map((url4) => import_path16.default.basename(new URL(url4).pathname)));
          for (const file3 of existingFiles) {
            if (!retainedFileNames.has(file3)) {
              const filePath = import_path16.default.join(imagesDir, file3);
              if (import_fs9.default.existsSync(filePath)) import_fs9.default.unlinkSync(filePath);
            }
          }
          if (!import_fs9.default.existsSync(imagesDir)) {
            import_fs9.default.mkdirSync(imagesDir, { recursive: true });
          }
          for (const item of images) {
            if (!item.startsWith("http")) {
              const fileName = `${utils_default.uuid()}.jpg`;
              const targetPath = import_path16.default.join(imagesDir, fileName);
              const buffer = Buffer.from(item.replace(/^data:[^;]+;base64,/, ""), "base64");
              import_fs9.default.writeFileSync(targetPath, buffer);
            }
          }
          res.status(200).send(success3());
        } catch (err) {
          res.status(500).send({ error: String(err) });
        }
      }
    );
  }
});

// src/routes/project/editProject.ts
var import_express102, router102, editProject_default;
var init_editProject = __esm({
  "src/routes/project/editProject.ts"() {
    "use strict";
    import_express102 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router102 = import_express102.default.Router();
    editProject_default = router102.post(
      "/",
      validateFields({
        id: external_exports.number(),
        name: external_exports.string(),
        intro: external_exports.string(),
        type: external_exports.string(),
        artStyle: external_exports.string(),
        directorManual: external_exports.string(),
        videoRatio: external_exports.string(),
        imageModel: external_exports.string(),
        videoModel: external_exports.string(),
        projectType: external_exports.string(),
        imageQuality: external_exports.string(),
        mode: external_exports.string()
      }),
      async (req, res) => {
        const { id, name: name28, intro, type, artStyle, videoRatio, directorManual, imageModel, videoModel, imageQuality, projectType, mode } = req.body;
        await utils_default.db("o_project").where("id", id).update({
          name: name28,
          intro,
          type,
          artStyle,
          videoRatio,
          directorManual,
          imageModel,
          videoModel,
          imageQuality,
          projectType,
          mode
        });
        res.status(200).send(success3({ message: "\u7F16\u8F91\u9879\u76EE\u6210\u529F" }));
      }
    );
  }
});

// src/routes/project/editVisualManual.ts
var import_express103, import_fs10, import_path17, router103, editVisualManual_default;
var init_editVisualManual = __esm({
  "src/routes/project/editVisualManual.ts"() {
    "use strict";
    import_express103 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    import_fs10 = __toESM(require("fs"));
    import_path17 = __toESM(require("path"));
    init_middleware();
    init_zod();
    router103 = import_express103.default.Router();
    editVisualManual_default = router103.post(
      "/",
      validateFields({
        name: external_exports.string(),
        stylePath: external_exports.string(),
        images: external_exports.array(external_exports.string()),
        data: external_exports.array(
          external_exports.object({
            label: external_exports.string(),
            value: external_exports.string(),
            data: external_exports.string()
          })
        )
      }),
      async (req, res) => {
        try {
          const { name: name28, stylePath, images, data } = req.body;
          if (name28.includes("/") || name28.includes("\\") || name28 === "." || name28 === ".." || /^\d+$/.test(name28)) {
            res.status(400).send(error50("\u540D\u79F0\u4E0D\u80FD\u5305\u542B\u8DEF\u5F84\u5206\u9694\u7B26\u6216\u4E3A\u7EAF\u6570\u5B57"));
            return;
          }
          const mainPath = utils_default.getPath(["skills", "art_skills", stylePath]);
          if (!import_fs10.default.existsSync(mainPath)) {
            return res.status(400).send(error50("\u89C6\u89C9\u624B\u518C\u4E0D\u5B58\u5728"));
          }
          const DATA_MAP3 = [
            { value: "README" },
            { value: "prefix" },
            { value: "art_character", subDir: "art_prompt" },
            { value: "art_character_derivative", subDir: "art_prompt" },
            { value: "art_prop", subDir: "art_prompt" },
            { value: "art_prop_derivative", subDir: "art_prompt" },
            { value: "art_scene", subDir: "art_prompt" },
            { value: "art_scene_derivative", subDir: "art_prompt" },
            { value: "director_storyboard", subDir: "driector_skills" },
            { value: "art_storyboard_video", subDir: "art_prompt" },
            { value: "director_planning_style", subDir: "driector_skills" },
            { value: "director_storyboard_table_style", subDir: "driector_skills" }
          ];
          const SUB_DIR_MAP = new Map(DATA_MAP3.map(({ value, subDir }) => [value, subDir ?? ""]));
          const VALID_KEYS = new Set(DATA_MAP3.map(({ value }) => value));
          for (const item of data) {
            if (!VALID_KEYS.has(item.value)) continue;
            const subDir = SUB_DIR_MAP.get(item.value);
            const dirArr = subDir ? [mainPath, subDir] : [mainPath];
            const filePath = utils_default.getPath([...dirArr, `${item.value}.md`]);
            const fileDir = import_path17.default.dirname(filePath);
            if (!import_fs10.default.existsSync(fileDir)) {
              import_fs10.default.mkdirSync(fileDir, { recursive: true });
            }
            const content = item.value === "README" ? `${name28}
${item.data}` : item.data;
            import_fs10.default.writeFileSync(filePath, content, "utf-8");
          }
          const imagesDir = import_path17.default.join(mainPath, "images");
          let existingFiles = [];
          try {
            const allFiles = import_fs10.default.readdirSync(imagesDir);
            existingFiles = allFiles.filter((f) => /\.(png|jpe?g|gif|webp|svg)$/i.test(f));
          } catch {
          }
          const retainedFileNames = new Set(images.filter((item) => item.startsWith("http")).map((url4) => import_path17.default.basename(new URL(url4).pathname)));
          for (const file3 of existingFiles) {
            if (!retainedFileNames.has(file3)) {
              const filePath = import_path17.default.join(imagesDir, file3);
              if (import_fs10.default.existsSync(filePath)) import_fs10.default.unlinkSync(filePath);
            }
          }
          if (!import_fs10.default.existsSync(imagesDir)) {
            import_fs10.default.mkdirSync(imagesDir, { recursive: true });
          }
          for (const item of images) {
            if (!item.startsWith("http")) {
              const fileName = `${utils_default.uuid()}.jpg`;
              const targetPath = import_path17.default.join(imagesDir, fileName);
              const buffer = Buffer.from(item.replace(/^data:[^;]+;base64,/, ""), "base64");
              import_fs10.default.writeFileSync(targetPath, buffer);
            }
          }
          res.status(200).send(success3());
        } catch (err) {
          res.status(500).send({ error: String(err) });
        }
      }
    );
  }
});

// src/routes/project/getModelDetails.ts
var import_express104, router104, getModelDetails_default;
var init_getModelDetails = __esm({
  "src/routes/project/getModelDetails.ts"() {
    "use strict";
    import_express104 = __toESM(require_express2());
    init_responseFormat();
    init_utils3();
    init_zod();
    init_middleware();
    init_userConfig();
    router104 = import_express104.default.Router();
    getModelDetails_default = router104.post(
      "/",
      validateFields({
        key: external_exports.enum(["scriptAgent", "productionAgent"])
      }),
      async (req, res) => {
        const { key } = req.body;
        const userId = requireRequestUserId(req);
        const data = await getAgentDeployForUser(key, userId);
        const [id, modelName] = data ? data.modelName.split(/:(.+)/) : [];
        const models = await utils_default.vendor.getModelList(id);
        const model = models.find((m) => m.modelName === modelName);
        if (!model) return res.status(400).send(error50("\u672A\u627E\u5230\u6A21\u578B"));
        res.status(200).send(success3(model));
      }
    );
  }
});

// src/routes/project/getProject.ts
var import_express105, router105, getProject_default;
var init_getProject = __esm({
  "src/routes/project/getProject.ts"() {
    "use strict";
    import_express105 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_auth();
    router105 = import_express105.default.Router();
    getProject_default = router105.post("/", async (req, res) => {
      const user = getCurrentUser(req);
      const data = await utils_default.db("o_project").where("userId", user.id).select("*").orderBy("createTime", "desc");
      res.status(200).send(success3(data));
    });
  }
});

// src/routes/project/getSingleProject.ts
var import_express106, router106, getSingleProject_default2;
var init_getSingleProject2 = __esm({
  "src/routes/project/getSingleProject.ts"() {
    "use strict";
    import_express106 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router106 = import_express106.default.Router();
    getSingleProject_default2 = router106.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id } = req.body;
        const data = await utils_default.db("o_project").where("id", id).select("*");
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/project/getVisualManual.ts
function readMd(filePath) {
  try {
    return import_fs11.default.readFileSync(filePath, "utf-8");
  } catch {
    return "";
  }
}
async function readAllImages(imagesDir) {
  try {
    const ossPath = utils_default.getPath(import_path18.default.join("skills", "art_skills", imagesDir, "images"));
    const files = import_fs11.default.readdirSync(ossPath);
    const images = files.filter((f) => /\.(png|jpe?g|gif|webp|svg)$/i.test(f)).map((f) => import_path18.default.join("art_skills", imagesDir, "images", f));
    if (images.length) {
      return Promise.all(images.map(async (i) => await utils_default.oss.getFileUrl(i, "skills")));
    } else {
      return [];
    }
  } catch {
    return [];
  }
}
var import_express107, import_fs11, import_path18, router107, DATA_MAP, getVisualManual_default;
var init_getVisualManual = __esm({
  "src/routes/project/getVisualManual.ts"() {
    "use strict";
    import_express107 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    import_fs11 = __toESM(require("fs"));
    import_path18 = __toESM(require("path"));
    router107 = import_express107.default.Router();
    DATA_MAP = [
      { label: "README", value: "README" },
      { label: "\u524D\u7F00", value: "prefix" },
      { label: "\u89D2\u8272", value: "art_character", subDir: "art_prompt" },
      { label: "\u89D2\u8272\u884D\u751F", value: "art_character_derivative", subDir: "art_prompt" },
      { label: "\u9053\u5177", value: "art_prop", subDir: "art_prompt" },
      { label: "\u9053\u5177\u884D\u751F", value: "art_prop_derivative", subDir: "art_prompt" },
      { label: "\u573A\u666F", value: "art_scene", subDir: "art_prompt" },
      { label: "\u573A\u666F\u884D\u751F", value: "art_scene_derivative", subDir: "art_prompt" },
      { label: "\u5206\u955C", value: "director_storyboard", subDir: "driector_skills" },
      { label: "\u5206\u955C\u89C6\u9891", value: "art_storyboard_video", subDir: "art_prompt" },
      { label: "\u6280\u6CD5-\u5BFC\u6F14\u89C4\u5212", value: "director_planning_style", subDir: "driector_skills" },
      { label: "\u6280\u6CD5-\u5206\u955C\u8868\u8BBE\u8BA1", value: "director_storyboard_table_style", subDir: "driector_skills" }
    ];
    getVisualManual_default = router107.post("/", async (req, res) => {
      try {
        const artPromptsDir = utils_default.getPath(["skills", "art_skills"]);
        const styleDirs = import_fs11.default.readdirSync(artPromptsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
        const result = await Promise.all(
          styleDirs.map(async (styleName) => {
            const styleDir = import_path18.default.join(artPromptsDir, styleName);
            const images = await readAllImages(styleName);
            const readmePath = import_path18.default.join(styleDir, "README.md");
            const readmeContent = import_fs11.default.readFileSync(readmePath, "utf-8");
            const firstLine = readmeContent.split("\n")[0].replace(/--/g, "");
            const data = DATA_MAP.map(({ label, value, subDir }) => {
              let mdPath;
              if (subDir) {
                mdPath = import_path18.default.join(styleDir, subDir, `${value}.md`);
              } else {
                mdPath = import_path18.default.join(styleDir, `${value}.md`);
              }
              return {
                label,
                value,
                data: readMd(mdPath)
              };
            });
            return {
              name: firstLine,
              image: images,
              stylePath: styleName,
              data
            };
          })
        );
        res.status(200).send(success3(result));
      } catch (err) {
        res.status(500).send({ error: String(err) });
      }
    });
  }
});

// src/routes/project/queryDirectorManual.ts
function readMd2(filePath) {
  try {
    return import_fs12.default.readFileSync(filePath, "utf-8");
  } catch {
    return "";
  }
}
async function readAllImages2(imagesDir) {
  try {
    const ossPath = utils_default.getPath(import_path19.default.join("skills", "story_skills", imagesDir, "images"));
    const files = import_fs12.default.readdirSync(ossPath);
    const images = files.filter((f) => /\.(png|jpe?g|gif|webp|svg)$/i.test(f)).map((f) => import_path19.default.join("story_skills", imagesDir, "images", f));
    if (images.length) {
      return Promise.all(images.map(async (i) => await utils_default.oss.getFileUrl(i, "skills")));
    } else {
      return [];
    }
  } catch {
    return [];
  }
}
var import_express108, import_fs12, import_path19, router108, DATA_MAP2, queryDirectorManual_default;
var init_queryDirectorManual = __esm({
  "src/routes/project/queryDirectorManual.ts"() {
    "use strict";
    import_express108 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    import_fs12 = __toESM(require("fs"));
    import_path19 = __toESM(require("path"));
    router108 = import_express108.default.Router();
    DATA_MAP2 = [
      { label: "README", value: "README" },
      { label: "\u5BFC\u6F14\u89C4\u5212", value: "director_planning_narrative", subDir: "driector_skills" },
      { label: "\u5206\u955C\u8868", value: "director_storyboard_table_narrative", subDir: "driector_skills" }
    ];
    queryDirectorManual_default = router108.post("/", async (req, res) => {
      try {
        const artPromptsDir = utils_default.getPath(["skills", "story_skills"]);
        const styleDirs = import_fs12.default.readdirSync(artPromptsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
        const result = await Promise.all(
          styleDirs.map(async (directorManual) => {
            const styleDir = import_path19.default.join(artPromptsDir, directorManual);
            const images = await readAllImages2(directorManual);
            const readmePath = import_path19.default.join(styleDir, "README.md");
            const readmeContent = import_fs12.default.readFileSync(readmePath, "utf-8");
            const firstLine = readmeContent.split("\n")[0].replace(/--/g, "");
            const data = DATA_MAP2.map(({ label, value, subDir }) => {
              let mdPath;
              if (subDir) {
                mdPath = import_path19.default.join(styleDir, subDir, `${value}.md`);
              } else {
                mdPath = import_path19.default.join(styleDir, `${value}.md`);
              }
              return {
                label,
                value,
                data: readMd2(mdPath)
              };
            });
            return {
              name: firstLine,
              image: images,
              directorManual,
              data
            };
          })
        );
        res.status(200).send(success3(result));
      } catch (err) {
        res.status(500).send({ error: String(err) });
      }
    });
  }
});

// src/routes/project/visualManual.ts
var import_express109, import_fs13, import_path20, router109, visualManual_default;
var init_visualManual = __esm({
  "src/routes/project/visualManual.ts"() {
    "use strict";
    import_express109 = __toESM(require_express2());
    init_zod();
    init_responseFormat();
    init_middleware();
    init_getPath();
    import_fs13 = __toESM(require("fs"));
    import_path20 = __toESM(require("path"));
    router109 = import_express109.default.Router();
    visualManual_default = router109.post(
      "/",
      validateFields({
        type: external_exports.string()
      }),
      async (req, res) => {
        const { type } = req.body;
        const basePath = getPath_default(["skills", "art_skills", "chinese_sweet_romance"]);
        const findFile = (dir, target) => {
          const entries = import_fs13.default.readdirSync(dir, { withFileTypes: true });
          for (const entry of entries) {
            const fullPath = import_path20.default.join(dir, entry.name);
            if (entry.isDirectory()) {
              const found = findFile(fullPath, target);
              if (found) return found;
            } else if (entry.isFile() && entry.name === target) {
              return fullPath;
            }
          }
          return null;
        };
        const filePath = findFile(basePath, `${type}.md`);
        if (!filePath) {
          res.status(404).json({ error: `\u672A\u627E\u5230\u5BF9\u5E94\u7684\u6587\u4EF6: ${type}.md` });
          return;
        }
        const content = import_fs13.default.readFileSync(filePath, "utf-8");
        res.status(200).send(success3(content));
      }
    );
  }
});

// src/routes/script/addScript.ts
var import_express110, router110, addScript_default;
var init_addScript = __esm({
  "src/routes/script/addScript.ts"() {
    "use strict";
    import_express110 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router110 = import_express110.default.Router();
    addScript_default = router110.post(
      "/",
      validateFields({
        name: external_exports.string(),
        content: external_exports.string(),
        projectId: external_exports.number(),
        assets: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { name: name28, content, projectId, assets } = req.body;
        const [scriptId] = await utils_default.db("o_script").insert({
          name: name28,
          content,
          projectId,
          createTime: Date.now()
        });
        if (assets.length) {
          const assetsData = await utils_default.db("o_assets").whereIn("id", assets).select();
          if (assetsData.length) {
            const assetsIds = assetsData.map((item) => item.id);
            const insertData = assetsIds.map((i) => {
              return {
                scriptId,
                assetId: i
              };
            });
            await utils_default.db("o_scriptAssets").insert(insertData);
          }
        }
        res.status(200).send(success3({ message: "\u6DFB\u52A0\u5267\u672C\u6210\u529F" }));
      }
    );
  }
});

// src/routes/script/batchAddScript.ts
var import_express111, router111, batchAddScript_default;
var init_batchAddScript = __esm({
  "src/routes/script/batchAddScript.ts"() {
    "use strict";
    import_express111 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router111 = import_express111.default.Router();
    batchAddScript_default = router111.post(
      "/",
      validateFields({
        data: external_exports.array(
          external_exports.object({
            scriptName: external_exports.string(),
            scriptData: external_exports.string()
          })
        ),
        projectId: external_exports.number()
      }),
      async (req, res) => {
        const { data, projectId } = req.body;
        await utils_default.db("o_script").insert(
          data.map((i) => {
            return {
              name: i.scriptName,
              content: i.scriptData,
              projectId,
              createTime: Date.now()
            };
          })
        );
        res.status(200).send(success3({ message: "\u6DFB\u52A0\u5267\u672C\u6210\u529F" }));
      }
    );
  }
});

// src/routes/script/delScript.ts
var import_express112, router112, delScript_default;
var init_delScript = __esm({
  "src/routes/script/delScript.ts"() {
    "use strict";
    import_express112 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router112 = import_express112.default.Router();
    delScript_default = router112.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        const scriptData = await utils_default.db("o_script").whereIn("id", ids);
        if (scriptData && scriptData.length) {
          const scriptProjectId = new Set(scriptData.map((item) => item.projectId));
          await utils_default.db("o_agentWorkData").whereIn("projectId", Array.from(scriptProjectId)).whereIn("episodesId", ids).delete();
        }
        const storyboardData = await utils_default.db("o_storyboard").whereIn("scriptId", ids);
        if (storyboardData.length) {
          await Promise.all(
            storyboardData.map(async (item) => {
              try {
                item.filePath && await utils_default.oss.deleteFile(item.filePath);
              } catch (e) {
              }
            })
          );
          const storyboardIds = storyboardData.map((item) => item.id);
          await utils_default.db("o_assets2Storyboard").whereIn("storyboardId", storyboardIds).delete();
        }
        await utils_default.db("o_scriptAssets").whereIn("scriptId", ids).delete();
        await utils_default.db("o_script").whereIn("id", ids).delete();
        await utils_default.db("o_storyboard").whereIn("scriptId", ids).delete();
        await utils_default.db("o_video").whereIn("scriptId", ids).delete();
        res.status(200).send(success3({ message: "\u5220\u9664\u5267\u672C\u6210\u529F" }));
      }
    );
  }
});

// node_modules/compressing/lib/utils.js
var require_utils13 = __commonJS({
  "node_modules/compressing/lib/utils.js"(exports2) {
    "use strict";
    var fs34 = require("fs");
    var path33 = require("path");
    var { pipeline: pump } = require("stream");
    function isPathWithinParent(childPath, parentPath) {
      const normalizedChild = path33.resolve(childPath);
      const normalizedParent = path33.resolve(parentPath);
      const parentWithSep = normalizedParent.endsWith(path33.sep) ? normalizedParent : normalizedParent + path33.sep;
      return normalizedChild === normalizedParent || normalizedChild.startsWith(parentWithSep);
    }
    exports2.sourceType = (source) => {
      if (!source) return void 0;
      if (source instanceof Buffer) return "buffer";
      if (typeof source._read === "function" || typeof source._transform === "function") return "stream";
      if (typeof source !== "string") {
        const err = new Error("Type is not supported, must be a file path, file buffer, or a readable stream");
        err.name = "IlligalSourceError";
        throw err;
      }
      return "file";
    };
    function destType(dest) {
      if (typeof dest._write === "function" || typeof dest._transform === "function") return "stream";
      if (typeof dest !== "string") {
        const err = new Error("Type is not supported, must be a file path, or a writable stream");
        err.name = "IlligalDestinationError";
        throw err;
      }
      return "path";
    }
    exports2.destType = destType;
    var illigalEntryError = new Error("Type is not supported, must be a file path, directory path, file buffer, or a readable stream");
    illigalEntryError.name = "IlligalEntryError";
    exports2.entryType = (entry) => {
      if (!entry) return;
      if (entry instanceof Buffer) return "buffer";
      if (typeof entry._read === "function" || typeof entry._transform === "function") return "stream";
      if (typeof entry !== "string") throw illigalEntryError;
      return "fileOrDir";
    };
    exports2.clone = (obj) => {
      const newObj = {};
      for (const i in obj) {
        newObj[i] = obj[i];
      }
      return newObj;
    };
    exports2.makeFileProcessFn = (StreamClass) => {
      return (source, dest, opts) => {
        opts = opts || {};
        opts.source = source;
        const destStream = destType(dest) === "path" ? fs34.createWriteStream(dest) : dest;
        const compressStream = new StreamClass(opts);
        return safePipe([compressStream, destStream]);
      };
    };
    exports2.makeCompressDirFn = (StreamClass) => {
      return (dir, dest, opts) => {
        const destStream = destType(dest) === "path" ? fs34.createWriteStream(dest) : dest;
        const compressStream = new StreamClass();
        compressStream.addEntry(dir, opts);
        return safePipe([compressStream, destStream]);
      };
    };
    exports2.makeUncompressFn = (StreamClass) => {
      return (source, destDir, opts) => {
        opts = opts || {};
        opts.source = source;
        if (!source) {
          const error73 = new Error("Type is not supported, must be a file path, file buffer, or a readable stream");
          error73.name = "IlligalSourceError";
          throw error73;
        }
        if (destType(destDir) !== "path") {
          const error73 = new Error("uncompress destination must be a directory");
          error73.name = "IlligalDestError";
          throw error73;
        }
        const strip = opts.strip ? Number(opts.strip) : 0;
        delete opts.strip;
        return new Promise((resolve3, reject) => {
          fs34.mkdir(destDir, { recursive: true }, (err) => {
            if (err) return reject(err);
            const resolvedDestDir = path33.resolve(destDir);
            let entryCount = 0;
            let successCount = 0;
            let isFinish = false;
            function done() {
              if (isFinish && entryCount === successCount) resolve3();
            }
            new StreamClass(opts).on("finish", () => {
              isFinish = true;
              done();
            }).on("error", reject).on("entry", (header, stream4, next) => {
              stream4.on("end", next);
              const destFilePath = path33.join(resolvedDestDir, stripFileName(strip, header.name, header.type));
              const resolvedDestPath = path33.resolve(destFilePath);
              if (!isPathWithinParent(resolvedDestPath, resolvedDestDir)) {
                console.warn(`[compressing] Skipping entry with path traversal: "${header.name}" -> "${resolvedDestPath}"`);
                stream4.resume();
                return;
              }
              if (header.type === "file") {
                const dir = path33.dirname(destFilePath);
                fs34.mkdir(dir, { recursive: true }, (err2) => {
                  if (err2) return reject(err2);
                  entryCount++;
                  pump(stream4, fs34.createWriteStream(destFilePath, { mode: opts.mode || header.mode }), (err3) => {
                    if (err3) return reject(err3);
                    successCount++;
                    done();
                  });
                });
              } else if (header.type === "symlink") {
                const dir = path33.dirname(destFilePath);
                const target = path33.resolve(dir, header.linkname);
                if (!isPathWithinParent(target, resolvedDestDir)) {
                  console.warn(`[compressing] Skipping symlink "${header.name}": target "${target}" escapes extraction directory`);
                  stream4.resume();
                  return;
                }
                entryCount++;
                fs34.mkdir(dir, { recursive: true }, (err2) => {
                  if (err2) return reject(err2);
                  const relativeTarget = path33.relative(dir, target);
                  fs34.symlink(relativeTarget, destFilePath, (err3) => {
                    if (err3) return reject(err3);
                    successCount++;
                    stream4.resume();
                  });
                });
              } else {
                fs34.mkdir(destFilePath, { recursive: true }, (err2) => {
                  if (err2) return reject(err2);
                  stream4.resume();
                });
              }
            });
          });
        });
      };
    };
    exports2.streamToBuffer = (stream4) => {
      return new Promise((resolve3, reject) => {
        const chunks = [];
        stream4.on("readable", () => {
          let chunk;
          while (chunk = stream4.read()) chunks.push(chunk);
        }).on("end", () => resolve3(Buffer.concat(chunks))).on("error", (err) => reject(err));
      });
    };
    function safePipe(streams) {
      return new Promise((resolve3, reject) => {
        pump(streams[0], streams[1], (err) => {
          if (err) return reject(err);
          resolve3();
        });
      });
    }
    exports2.safePipe = safePipe;
    function normalizePath(fileName) {
      fileName = path33.normalize(fileName);
      if (process.platform === "win32") fileName = fileName.replace(/\\+/g, "/");
      return fileName;
    }
    function stripFileName(strip, fileName, type) {
      if (Buffer.isBuffer(fileName)) fileName = fileName.toString();
      if (fileName.indexOf("\\") !== -1) fileName = fileName.replace(/\\+/g, "/");
      if (fileName[0] === "/") fileName = fileName.replace(/^\/+/, "");
      if (fileName) {
        fileName = normalizePath(fileName);
      }
      let s = fileName.split("/");
      if (s.indexOf("..") !== -1) {
        fileName = fileName.replace(/(\.\.\/)+/, "");
        if (type === "directory" && fileName && fileName[fileName.length - 1] !== "/") {
          fileName += "/";
        }
        s = fileName.split("/");
      }
      strip = Math.min(strip, s.length - 1);
      return s.slice(strip).join("/") || "/";
    }
    exports2.stripFileName = stripFileName;
  }
});

// node_modules/buffer-crc32/index.js
var require_buffer_crc32 = __commonJS({
  "node_modules/buffer-crc32/index.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require("buffer").Buffer;
    var CRC_TABLE = [
      0,
      1996959894,
      3993919788,
      2567524794,
      124634137,
      1886057615,
      3915621685,
      2657392035,
      249268274,
      2044508324,
      3772115230,
      2547177864,
      162941995,
      2125561021,
      3887607047,
      2428444049,
      498536548,
      1789927666,
      4089016648,
      2227061214,
      450548861,
      1843258603,
      4107580753,
      2211677639,
      325883990,
      1684777152,
      4251122042,
      2321926636,
      335633487,
      1661365465,
      4195302755,
      2366115317,
      997073096,
      1281953886,
      3579855332,
      2724688242,
      1006888145,
      1258607687,
      3524101629,
      2768942443,
      901097722,
      1119000684,
      3686517206,
      2898065728,
      853044451,
      1172266101,
      3705015759,
      2882616665,
      651767980,
      1373503546,
      3369554304,
      3218104598,
      565507253,
      1454621731,
      3485111705,
      3099436303,
      671266974,
      1594198024,
      3322730930,
      2970347812,
      795835527,
      1483230225,
      3244367275,
      3060149565,
      1994146192,
      31158534,
      2563907772,
      4023717930,
      1907459465,
      112637215,
      2680153253,
      3904427059,
      2013776290,
      251722036,
      2517215374,
      3775830040,
      2137656763,
      141376813,
      2439277719,
      3865271297,
      1802195444,
      476864866,
      2238001368,
      4066508878,
      1812370925,
      453092731,
      2181625025,
      4111451223,
      1706088902,
      314042704,
      2344532202,
      4240017532,
      1658658271,
      366619977,
      2362670323,
      4224994405,
      1303535960,
      984961486,
      2747007092,
      3569037538,
      1256170817,
      1037604311,
      2765210733,
      3554079995,
      1131014506,
      879679996,
      2909243462,
      3663771856,
      1141124467,
      855842277,
      2852801631,
      3708648649,
      1342533948,
      654459306,
      3188396048,
      3373015174,
      1466479909,
      544179635,
      3110523913,
      3462522015,
      1591671054,
      702138776,
      2966460450,
      3352799412,
      1504918807,
      783551873,
      3082640443,
      3233442989,
      3988292384,
      2596254646,
      62317068,
      1957810842,
      3939845945,
      2647816111,
      81470997,
      1943803523,
      3814918930,
      2489596804,
      225274430,
      2053790376,
      3826175755,
      2466906013,
      167816743,
      2097651377,
      4027552580,
      2265490386,
      503444072,
      1762050814,
      4150417245,
      2154129355,
      426522225,
      1852507879,
      4275313526,
      2312317920,
      282753626,
      1742555852,
      4189708143,
      2394877945,
      397917763,
      1622183637,
      3604390888,
      2714866558,
      953729732,
      1340076626,
      3518719985,
      2797360999,
      1068828381,
      1219638859,
      3624741850,
      2936675148,
      906185462,
      1090812512,
      3747672003,
      2825379669,
      829329135,
      1181335161,
      3412177804,
      3160834842,
      628085408,
      1382605366,
      3423369109,
      3138078467,
      570562233,
      1426400815,
      3317316542,
      2998733608,
      733239954,
      1555261956,
      3268935591,
      3050360625,
      752459403,
      1541320221,
      2607071920,
      3965973030,
      1969922972,
      40735498,
      2617837225,
      3943577151,
      1913087877,
      83908371,
      2512341634,
      3803740692,
      2075208622,
      213261112,
      2463272603,
      3855990285,
      2094854071,
      198958881,
      2262029012,
      4057260610,
      1759359992,
      534414190,
      2176718541,
      4139329115,
      1873836001,
      414664567,
      2282248934,
      4279200368,
      1711684554,
      285281116,
      2405801727,
      4167216745,
      1634467795,
      376229701,
      2685067896,
      3608007406,
      1308918612,
      956543938,
      2808555105,
      3495958263,
      1231636301,
      1047427035,
      2932959818,
      3654703836,
      1088359270,
      936918e3,
      2847714899,
      3736837829,
      1202900863,
      817233897,
      3183342108,
      3401237130,
      1404277552,
      615818150,
      3134207493,
      3453421203,
      1423857449,
      601450431,
      3009837614,
      3294710456,
      1567103746,
      711928724,
      3020668471,
      3272380065,
      1510334235,
      755167117
    ];
    if (typeof Int32Array !== "undefined") {
      CRC_TABLE = new Int32Array(CRC_TABLE);
    }
    function ensureBuffer(input) {
      if (Buffer3.isBuffer(input)) {
        return input;
      }
      var hasNewBufferAPI = typeof Buffer3.alloc === "function" && typeof Buffer3.from === "function";
      if (typeof input === "number") {
        return hasNewBufferAPI ? Buffer3.alloc(input) : new Buffer3(input);
      } else if (typeof input === "string") {
        return hasNewBufferAPI ? Buffer3.from(input) : new Buffer3(input);
      } else {
        throw new Error("input must be buffer, number, or string, received " + typeof input);
      }
    }
    function bufferizeInt(num) {
      var tmp = ensureBuffer(4);
      tmp.writeInt32BE(num, 0);
      return tmp;
    }
    function _crc32(buf, previous) {
      buf = ensureBuffer(buf);
      if (Buffer3.isBuffer(previous)) {
        previous = previous.readUInt32BE(0);
      }
      var crc = ~~previous ^ -1;
      for (var n = 0; n < buf.length; n++) {
        crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8;
      }
      return crc ^ -1;
    }
    function crc32() {
      return bufferizeInt(_crc32.apply(null, arguments));
    }
    crc32.signed = function() {
      return _crc32.apply(null, arguments);
    };
    crc32.unsigned = function() {
      return _crc32.apply(null, arguments) >>> 0;
    };
    module2.exports = crc32;
  }
});

// node_modules/yazl/index.js
var require_yazl = __commonJS({
  "node_modules/yazl/index.js"(exports2) {
    "use strict";
    var fs34 = require("fs");
    var Transform = require("stream").Transform;
    var PassThrough = require("stream").PassThrough;
    var zlib2 = require("zlib");
    var util4 = require("util");
    var EventEmitter3 = require("events").EventEmitter;
    var crc32 = require_buffer_crc32();
    exports2.ZipFile = ZipFile;
    exports2.dateToDosDateTime = dateToDosDateTime;
    util4.inherits(ZipFile, EventEmitter3);
    function ZipFile() {
      this.outputStream = new PassThrough();
      this.entries = [];
      this.outputStreamCursor = 0;
      this.ended = false;
      this.allDone = false;
      this.forceZip64Eocd = false;
    }
    ZipFile.prototype.addFile = function(realPath, metadataPath, options) {
      var self2 = this;
      metadataPath = validateMetadataPath(metadataPath, false);
      if (options == null) options = {};
      var entry = new Entry(metadataPath, false, options);
      self2.entries.push(entry);
      fs34.stat(realPath, function(err, stats) {
        if (err) return self2.emit("error", err);
        if (!stats.isFile()) return self2.emit("error", new Error("not a file: " + realPath));
        entry.uncompressedSize = stats.size;
        if (options.mtime == null) entry.setLastModDate(stats.mtime);
        if (options.mode == null) entry.setFileAttributesMode(stats.mode);
        entry.setFileDataPumpFunction(function() {
          var readStream2 = fs34.createReadStream(realPath);
          entry.state = Entry.FILE_DATA_IN_PROGRESS;
          readStream2.on("error", function(err2) {
            self2.emit("error", err2);
          });
          pumpFileDataReadStream(self2, entry, readStream2);
        });
        pumpEntries(self2);
      });
    };
    ZipFile.prototype.addReadStream = function(readStream2, metadataPath, options) {
      var self2 = this;
      metadataPath = validateMetadataPath(metadataPath, false);
      if (options == null) options = {};
      var entry = new Entry(metadataPath, false, options);
      self2.entries.push(entry);
      entry.setFileDataPumpFunction(function() {
        entry.state = Entry.FILE_DATA_IN_PROGRESS;
        pumpFileDataReadStream(self2, entry, readStream2);
      });
      pumpEntries(self2);
    };
    ZipFile.prototype.addBuffer = function(buffer, metadataPath, options) {
      var self2 = this;
      metadataPath = validateMetadataPath(metadataPath, false);
      if (buffer.length > 1073741823) throw new Error("buffer too large: " + buffer.length + " > 1073741823");
      if (options == null) options = {};
      if (options.size != null) throw new Error("options.size not allowed");
      var entry = new Entry(metadataPath, false, options);
      entry.uncompressedSize = buffer.length;
      entry.crc32 = crc32.unsigned(buffer);
      entry.crcAndFileSizeKnown = true;
      self2.entries.push(entry);
      if (!entry.compress) {
        setCompressedBuffer(buffer);
      } else {
        zlib2.deflateRaw(buffer, function(err, compressedBuffer) {
          setCompressedBuffer(compressedBuffer);
        });
      }
      function setCompressedBuffer(compressedBuffer) {
        entry.compressedSize = compressedBuffer.length;
        entry.setFileDataPumpFunction(function() {
          writeToOutputStream(self2, compressedBuffer);
          writeToOutputStream(self2, entry.getDataDescriptor());
          entry.state = Entry.FILE_DATA_DONE;
          setImmediate(function() {
            pumpEntries(self2);
          });
        });
        pumpEntries(self2);
      }
    };
    ZipFile.prototype.addEmptyDirectory = function(metadataPath, options) {
      var self2 = this;
      metadataPath = validateMetadataPath(metadataPath, true);
      if (options == null) options = {};
      if (options.size != null) throw new Error("options.size not allowed");
      if (options.compress != null) throw new Error("options.compress not allowed");
      var entry = new Entry(metadataPath, true, options);
      self2.entries.push(entry);
      entry.setFileDataPumpFunction(function() {
        writeToOutputStream(self2, entry.getDataDescriptor());
        entry.state = Entry.FILE_DATA_DONE;
        pumpEntries(self2);
      });
      pumpEntries(self2);
    };
    var eocdrSignatureBuffer = bufferFrom([80, 75, 5, 6]);
    ZipFile.prototype.end = function(options, finalSizeCallback) {
      if (typeof options === "function") {
        finalSizeCallback = options;
        options = null;
      }
      if (options == null) options = {};
      if (this.ended) return;
      this.ended = true;
      this.finalSizeCallback = finalSizeCallback;
      this.forceZip64Eocd = !!options.forceZip64Format;
      if (options.comment) {
        if (typeof options.comment === "string") {
          this.comment = encodeCp437(options.comment);
        } else {
          this.comment = options.comment;
        }
        if (this.comment.length > 65535) throw new Error("comment is too large");
        if (bufferIncludes(this.comment, eocdrSignatureBuffer)) throw new Error("comment contains end of central directory record signature");
      } else {
        this.comment = EMPTY_BUFFER;
      }
      pumpEntries(this);
    };
    function writeToOutputStream(self2, buffer) {
      self2.outputStream.write(buffer);
      self2.outputStreamCursor += buffer.length;
    }
    function pumpFileDataReadStream(self2, entry, readStream2) {
      var crc32Watcher = new Crc32Watcher();
      var uncompressedSizeCounter = new ByteCounter();
      var compressor = entry.compress ? new zlib2.DeflateRaw() : new PassThrough();
      var compressedSizeCounter = new ByteCounter();
      readStream2.pipe(crc32Watcher).pipe(uncompressedSizeCounter).pipe(compressor).pipe(compressedSizeCounter).pipe(self2.outputStream, { end: false });
      compressedSizeCounter.on("end", function() {
        entry.crc32 = crc32Watcher.crc32;
        if (entry.uncompressedSize == null) {
          entry.uncompressedSize = uncompressedSizeCounter.byteCount;
        } else {
          if (entry.uncompressedSize !== uncompressedSizeCounter.byteCount) return self2.emit("error", new Error("file data stream has unexpected number of bytes"));
        }
        entry.compressedSize = compressedSizeCounter.byteCount;
        self2.outputStreamCursor += entry.compressedSize;
        writeToOutputStream(self2, entry.getDataDescriptor());
        entry.state = Entry.FILE_DATA_DONE;
        pumpEntries(self2);
      });
    }
    function pumpEntries(self2) {
      if (self2.allDone) return;
      if (self2.ended && self2.finalSizeCallback != null) {
        var finalSize = calculateFinalSize(self2);
        if (finalSize != null) {
          self2.finalSizeCallback(finalSize);
          self2.finalSizeCallback = null;
        }
      }
      var entry = getFirstNotDoneEntry();
      function getFirstNotDoneEntry() {
        for (var i = 0; i < self2.entries.length; i++) {
          var entry2 = self2.entries[i];
          if (entry2.state < Entry.FILE_DATA_DONE) return entry2;
        }
        return null;
      }
      if (entry != null) {
        if (entry.state < Entry.READY_TO_PUMP_FILE_DATA) return;
        if (entry.state === Entry.FILE_DATA_IN_PROGRESS) return;
        entry.relativeOffsetOfLocalHeader = self2.outputStreamCursor;
        var localFileHeader = entry.getLocalFileHeader();
        writeToOutputStream(self2, localFileHeader);
        entry.doFileDataPump();
      } else {
        if (self2.ended) {
          self2.offsetOfStartOfCentralDirectory = self2.outputStreamCursor;
          self2.entries.forEach(function(entry2) {
            var centralDirectoryRecord = entry2.getCentralDirectoryRecord();
            writeToOutputStream(self2, centralDirectoryRecord);
          });
          writeToOutputStream(self2, getEndOfCentralDirectoryRecord(self2));
          self2.outputStream.end();
          self2.allDone = true;
        }
      }
    }
    function calculateFinalSize(self2) {
      var pretendOutputCursor = 0;
      var centralDirectorySize = 0;
      for (var i = 0; i < self2.entries.length; i++) {
        var entry = self2.entries[i];
        if (entry.compress) return -1;
        if (entry.state >= Entry.READY_TO_PUMP_FILE_DATA) {
          if (entry.uncompressedSize == null) return -1;
        } else {
          if (entry.uncompressedSize == null) return null;
        }
        entry.relativeOffsetOfLocalHeader = pretendOutputCursor;
        var useZip64Format = entry.useZip64Format();
        pretendOutputCursor += LOCAL_FILE_HEADER_FIXED_SIZE + entry.utf8FileName.length;
        pretendOutputCursor += entry.uncompressedSize;
        if (!entry.crcAndFileSizeKnown) {
          if (useZip64Format) {
            pretendOutputCursor += ZIP64_DATA_DESCRIPTOR_SIZE;
          } else {
            pretendOutputCursor += DATA_DESCRIPTOR_SIZE;
          }
        }
        centralDirectorySize += CENTRAL_DIRECTORY_RECORD_FIXED_SIZE + entry.utf8FileName.length + entry.fileComment.length;
        if (useZip64Format) {
          centralDirectorySize += ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE;
        }
      }
      var endOfCentralDirectorySize = 0;
      if (self2.forceZip64Eocd || self2.entries.length >= 65535 || centralDirectorySize >= 65535 || pretendOutputCursor >= 4294967295) {
        endOfCentralDirectorySize += ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE;
      }
      endOfCentralDirectorySize += END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + self2.comment.length;
      return pretendOutputCursor + centralDirectorySize + endOfCentralDirectorySize;
    }
    var ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 56;
    var ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE = 20;
    var END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 22;
    function getEndOfCentralDirectoryRecord(self2, actuallyJustTellMeHowLongItWouldBe) {
      var needZip64Format = false;
      var normalEntriesLength = self2.entries.length;
      if (self2.forceZip64Eocd || self2.entries.length >= 65535) {
        normalEntriesLength = 65535;
        needZip64Format = true;
      }
      var sizeOfCentralDirectory = self2.outputStreamCursor - self2.offsetOfStartOfCentralDirectory;
      var normalSizeOfCentralDirectory = sizeOfCentralDirectory;
      if (self2.forceZip64Eocd || sizeOfCentralDirectory >= 4294967295) {
        normalSizeOfCentralDirectory = 4294967295;
        needZip64Format = true;
      }
      var normalOffsetOfStartOfCentralDirectory = self2.offsetOfStartOfCentralDirectory;
      if (self2.forceZip64Eocd || self2.offsetOfStartOfCentralDirectory >= 4294967295) {
        normalOffsetOfStartOfCentralDirectory = 4294967295;
        needZip64Format = true;
      }
      if (actuallyJustTellMeHowLongItWouldBe) {
        if (needZip64Format) {
          return ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE + END_OF_CENTRAL_DIRECTORY_RECORD_SIZE;
        } else {
          return END_OF_CENTRAL_DIRECTORY_RECORD_SIZE;
        }
      }
      var eocdrBuffer = bufferAlloc(END_OF_CENTRAL_DIRECTORY_RECORD_SIZE + self2.comment.length);
      eocdrBuffer.writeUInt32LE(101010256, 0);
      eocdrBuffer.writeUInt16LE(0, 4);
      eocdrBuffer.writeUInt16LE(0, 6);
      eocdrBuffer.writeUInt16LE(normalEntriesLength, 8);
      eocdrBuffer.writeUInt16LE(normalEntriesLength, 10);
      eocdrBuffer.writeUInt32LE(normalSizeOfCentralDirectory, 12);
      eocdrBuffer.writeUInt32LE(normalOffsetOfStartOfCentralDirectory, 16);
      eocdrBuffer.writeUInt16LE(self2.comment.length, 20);
      self2.comment.copy(eocdrBuffer, 22);
      if (!needZip64Format) return eocdrBuffer;
      var zip64EocdrBuffer = bufferAlloc(ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE);
      zip64EocdrBuffer.writeUInt32LE(101075792, 0);
      writeUInt64LE(zip64EocdrBuffer, ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE - 12, 4);
      zip64EocdrBuffer.writeUInt16LE(VERSION_MADE_BY, 12);
      zip64EocdrBuffer.writeUInt16LE(VERSION_NEEDED_TO_EXTRACT_ZIP64, 14);
      zip64EocdrBuffer.writeUInt32LE(0, 16);
      zip64EocdrBuffer.writeUInt32LE(0, 20);
      writeUInt64LE(zip64EocdrBuffer, self2.entries.length, 24);
      writeUInt64LE(zip64EocdrBuffer, self2.entries.length, 32);
      writeUInt64LE(zip64EocdrBuffer, sizeOfCentralDirectory, 40);
      writeUInt64LE(zip64EocdrBuffer, self2.offsetOfStartOfCentralDirectory, 48);
      var zip64EocdlBuffer = bufferAlloc(ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIZE);
      zip64EocdlBuffer.writeUInt32LE(117853008, 0);
      zip64EocdlBuffer.writeUInt32LE(0, 4);
      writeUInt64LE(zip64EocdlBuffer, self2.outputStreamCursor, 8);
      zip64EocdlBuffer.writeUInt32LE(1, 16);
      return Buffer.concat([
        zip64EocdrBuffer,
        zip64EocdlBuffer,
        eocdrBuffer
      ]);
    }
    function validateMetadataPath(metadataPath, isDirectory) {
      if (metadataPath === "") throw new Error("empty metadataPath");
      metadataPath = metadataPath.replace(/\\/g, "/");
      if (/^[a-zA-Z]:/.test(metadataPath) || /^\//.test(metadataPath)) throw new Error("absolute path: " + metadataPath);
      if (metadataPath.split("/").indexOf("..") !== -1) throw new Error("invalid relative path: " + metadataPath);
      var looksLikeDirectory = /\/$/.test(metadataPath);
      if (isDirectory) {
        if (!looksLikeDirectory) metadataPath += "/";
      } else {
        if (looksLikeDirectory) throw new Error("file path cannot end with '/': " + metadataPath);
      }
      return metadataPath;
    }
    var EMPTY_BUFFER = bufferAlloc(0);
    function Entry(metadataPath, isDirectory, options) {
      this.utf8FileName = bufferFrom(metadataPath);
      if (this.utf8FileName.length > 65535) throw new Error("utf8 file name too long. " + utf8FileName.length + " > 65535");
      this.isDirectory = isDirectory;
      this.state = Entry.WAITING_FOR_METADATA;
      this.setLastModDate(options.mtime != null ? options.mtime : /* @__PURE__ */ new Date());
      if (options.mode != null) {
        this.setFileAttributesMode(options.mode);
      } else {
        this.setFileAttributesMode(isDirectory ? 16893 : 33204);
      }
      if (isDirectory) {
        this.crcAndFileSizeKnown = true;
        this.crc32 = 0;
        this.uncompressedSize = 0;
        this.compressedSize = 0;
      } else {
        this.crcAndFileSizeKnown = false;
        this.crc32 = null;
        this.uncompressedSize = null;
        this.compressedSize = null;
        if (options.size != null) this.uncompressedSize = options.size;
      }
      if (isDirectory) {
        this.compress = false;
      } else {
        this.compress = true;
        if (options.compress != null) this.compress = !!options.compress;
      }
      this.forceZip64Format = !!options.forceZip64Format;
      if (options.fileComment) {
        if (typeof options.fileComment === "string") {
          this.fileComment = bufferFrom(options.fileComment, "utf-8");
        } else {
          this.fileComment = options.fileComment;
        }
        if (this.fileComment.length > 65535) throw new Error("fileComment is too large");
      } else {
        this.fileComment = EMPTY_BUFFER;
      }
    }
    Entry.WAITING_FOR_METADATA = 0;
    Entry.READY_TO_PUMP_FILE_DATA = 1;
    Entry.FILE_DATA_IN_PROGRESS = 2;
    Entry.FILE_DATA_DONE = 3;
    Entry.prototype.setLastModDate = function(date6) {
      var dosDateTime = dateToDosDateTime(date6);
      this.lastModFileTime = dosDateTime.time;
      this.lastModFileDate = dosDateTime.date;
    };
    Entry.prototype.setFileAttributesMode = function(mode) {
      if ((mode & 65535) !== mode) throw new Error("invalid mode. expected: 0 <= " + mode + " <= 65535");
      this.externalFileAttributes = mode << 16 >>> 0;
    };
    Entry.prototype.setFileDataPumpFunction = function(doFileDataPump) {
      this.doFileDataPump = doFileDataPump;
      this.state = Entry.READY_TO_PUMP_FILE_DATA;
    };
    Entry.prototype.useZip64Format = function() {
      return this.forceZip64Format || this.uncompressedSize != null && this.uncompressedSize > 4294967294 || this.compressedSize != null && this.compressedSize > 4294967294 || this.relativeOffsetOfLocalHeader != null && this.relativeOffsetOfLocalHeader > 4294967294;
    };
    var LOCAL_FILE_HEADER_FIXED_SIZE = 30;
    var VERSION_NEEDED_TO_EXTRACT_UTF8 = 20;
    var VERSION_NEEDED_TO_EXTRACT_ZIP64 = 45;
    var VERSION_MADE_BY = 3 << 8 | 63;
    var FILE_NAME_IS_UTF8 = 1 << 11;
    var UNKNOWN_CRC32_AND_FILE_SIZES = 1 << 3;
    Entry.prototype.getLocalFileHeader = function() {
      var crc322 = 0;
      var compressedSize = 0;
      var uncompressedSize = 0;
      if (this.crcAndFileSizeKnown) {
        crc322 = this.crc32;
        compressedSize = this.compressedSize;
        uncompressedSize = this.uncompressedSize;
      }
      var fixedSizeStuff = bufferAlloc(LOCAL_FILE_HEADER_FIXED_SIZE);
      var generalPurposeBitFlag = FILE_NAME_IS_UTF8;
      if (!this.crcAndFileSizeKnown) generalPurposeBitFlag |= UNKNOWN_CRC32_AND_FILE_SIZES;
      fixedSizeStuff.writeUInt32LE(67324752, 0);
      fixedSizeStuff.writeUInt16LE(VERSION_NEEDED_TO_EXTRACT_UTF8, 4);
      fixedSizeStuff.writeUInt16LE(generalPurposeBitFlag, 6);
      fixedSizeStuff.writeUInt16LE(this.getCompressionMethod(), 8);
      fixedSizeStuff.writeUInt16LE(this.lastModFileTime, 10);
      fixedSizeStuff.writeUInt16LE(this.lastModFileDate, 12);
      fixedSizeStuff.writeUInt32LE(crc322, 14);
      fixedSizeStuff.writeUInt32LE(compressedSize, 18);
      fixedSizeStuff.writeUInt32LE(uncompressedSize, 22);
      fixedSizeStuff.writeUInt16LE(this.utf8FileName.length, 26);
      fixedSizeStuff.writeUInt16LE(0, 28);
      return Buffer.concat([
        fixedSizeStuff,
        // file name (variable size)
        this.utf8FileName
        // extra field (variable size)
        // no extra fields
      ]);
    };
    var DATA_DESCRIPTOR_SIZE = 16;
    var ZIP64_DATA_DESCRIPTOR_SIZE = 24;
    Entry.prototype.getDataDescriptor = function() {
      if (this.crcAndFileSizeKnown) {
        return EMPTY_BUFFER;
      }
      if (!this.useZip64Format()) {
        var buffer = bufferAlloc(DATA_DESCRIPTOR_SIZE);
        buffer.writeUInt32LE(134695760, 0);
        buffer.writeUInt32LE(this.crc32, 4);
        buffer.writeUInt32LE(this.compressedSize, 8);
        buffer.writeUInt32LE(this.uncompressedSize, 12);
        return buffer;
      } else {
        var buffer = bufferAlloc(ZIP64_DATA_DESCRIPTOR_SIZE);
        buffer.writeUInt32LE(134695760, 0);
        buffer.writeUInt32LE(this.crc32, 4);
        writeUInt64LE(buffer, this.compressedSize, 8);
        writeUInt64LE(buffer, this.uncompressedSize, 16);
        return buffer;
      }
    };
    var CENTRAL_DIRECTORY_RECORD_FIXED_SIZE = 46;
    var ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE = 28;
    Entry.prototype.getCentralDirectoryRecord = function() {
      var fixedSizeStuff = bufferAlloc(CENTRAL_DIRECTORY_RECORD_FIXED_SIZE);
      var generalPurposeBitFlag = FILE_NAME_IS_UTF8;
      if (!this.crcAndFileSizeKnown) generalPurposeBitFlag |= UNKNOWN_CRC32_AND_FILE_SIZES;
      var normalCompressedSize = this.compressedSize;
      var normalUncompressedSize = this.uncompressedSize;
      var normalRelativeOffsetOfLocalHeader = this.relativeOffsetOfLocalHeader;
      var versionNeededToExtract;
      var zeiefBuffer;
      if (this.useZip64Format()) {
        normalCompressedSize = 4294967295;
        normalUncompressedSize = 4294967295;
        normalRelativeOffsetOfLocalHeader = 4294967295;
        versionNeededToExtract = VERSION_NEEDED_TO_EXTRACT_ZIP64;
        zeiefBuffer = bufferAlloc(ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE);
        zeiefBuffer.writeUInt16LE(1, 0);
        zeiefBuffer.writeUInt16LE(ZIP64_EXTENDED_INFORMATION_EXTRA_FIELD_SIZE - 4, 2);
        writeUInt64LE(zeiefBuffer, this.uncompressedSize, 4);
        writeUInt64LE(zeiefBuffer, this.compressedSize, 12);
        writeUInt64LE(zeiefBuffer, this.relativeOffsetOfLocalHeader, 20);
      } else {
        versionNeededToExtract = VERSION_NEEDED_TO_EXTRACT_UTF8;
        zeiefBuffer = EMPTY_BUFFER;
      }
      fixedSizeStuff.writeUInt32LE(33639248, 0);
      fixedSizeStuff.writeUInt16LE(VERSION_MADE_BY, 4);
      fixedSizeStuff.writeUInt16LE(versionNeededToExtract, 6);
      fixedSizeStuff.writeUInt16LE(generalPurposeBitFlag, 8);
      fixedSizeStuff.writeUInt16LE(this.getCompressionMethod(), 10);
      fixedSizeStuff.writeUInt16LE(this.lastModFileTime, 12);
      fixedSizeStuff.writeUInt16LE(this.lastModFileDate, 14);
      fixedSizeStuff.writeUInt32LE(this.crc32, 16);
      fixedSizeStuff.writeUInt32LE(normalCompressedSize, 20);
      fixedSizeStuff.writeUInt32LE(normalUncompressedSize, 24);
      fixedSizeStuff.writeUInt16LE(this.utf8FileName.length, 28);
      fixedSizeStuff.writeUInt16LE(zeiefBuffer.length, 30);
      fixedSizeStuff.writeUInt16LE(this.fileComment.length, 32);
      fixedSizeStuff.writeUInt16LE(0, 34);
      fixedSizeStuff.writeUInt16LE(0, 36);
      fixedSizeStuff.writeUInt32LE(this.externalFileAttributes, 38);
      fixedSizeStuff.writeUInt32LE(normalRelativeOffsetOfLocalHeader, 42);
      return Buffer.concat([
        fixedSizeStuff,
        // file name (variable size)
        this.utf8FileName,
        // extra field (variable size)
        zeiefBuffer,
        // file comment (variable size)
        this.fileComment
      ]);
    };
    Entry.prototype.getCompressionMethod = function() {
      var NO_COMPRESSION = 0;
      var DEFLATE_COMPRESSION = 8;
      return this.compress ? DEFLATE_COMPRESSION : NO_COMPRESSION;
    };
    function dateToDosDateTime(jsDate) {
      var date6 = 0;
      date6 |= jsDate.getDate() & 31;
      date6 |= (jsDate.getMonth() + 1 & 15) << 5;
      date6 |= (jsDate.getFullYear() - 1980 & 127) << 9;
      var time4 = 0;
      time4 |= Math.floor(jsDate.getSeconds() / 2);
      time4 |= (jsDate.getMinutes() & 63) << 5;
      time4 |= (jsDate.getHours() & 31) << 11;
      return { date: date6, time: time4 };
    }
    function writeUInt64LE(buffer, n, offset) {
      var high = Math.floor(n / 4294967296);
      var low = n % 4294967296;
      buffer.writeUInt32LE(low, offset);
      buffer.writeUInt32LE(high, offset + 4);
    }
    util4.inherits(ByteCounter, Transform);
    function ByteCounter(options) {
      Transform.call(this, options);
      this.byteCount = 0;
    }
    ByteCounter.prototype._transform = function(chunk, encoding, cb) {
      this.byteCount += chunk.length;
      cb(null, chunk);
    };
    util4.inherits(Crc32Watcher, Transform);
    function Crc32Watcher(options) {
      Transform.call(this, options);
      this.crc32 = 0;
    }
    Crc32Watcher.prototype._transform = function(chunk, encoding, cb) {
      this.crc32 = crc32.unsigned(chunk, this.crc32);
      cb(null, chunk);
    };
    var cp437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\xB6\xA7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
    if (cp437.length !== 256) throw new Error("assertion failure");
    var reverseCp437 = null;
    function encodeCp437(string5) {
      if (/^[\x20-\x7e]*$/.test(string5)) {
        return bufferFrom(string5, "utf-8");
      }
      if (reverseCp437 == null) {
        reverseCp437 = {};
        for (var i = 0; i < cp437.length; i++) {
          reverseCp437[cp437[i]] = i;
        }
      }
      var result = bufferAlloc(string5.length);
      for (var i = 0; i < string5.length; i++) {
        var b = reverseCp437[string5[i]];
        if (b == null) throw new Error("character not encodable in CP437: " + JSON.stringify(string5[i]));
        result[i] = b;
      }
      return result;
    }
    function bufferAlloc(size) {
      bufferAlloc = modern;
      try {
        return bufferAlloc(size);
      } catch (e) {
        bufferAlloc = legacy;
        return bufferAlloc(size);
      }
      function modern(size2) {
        return Buffer.allocUnsafe(size2);
      }
      function legacy(size2) {
        return new Buffer(size2);
      }
    }
    function bufferFrom(something, encoding) {
      bufferFrom = modern;
      try {
        return bufferFrom(something, encoding);
      } catch (e) {
        bufferFrom = legacy;
        return bufferFrom(something, encoding);
      }
      function modern(something2, encoding2) {
        return Buffer.from(something2, encoding2);
      }
      function legacy(something2, encoding2) {
        return new Buffer(something2, encoding2);
      }
    }
    function bufferIncludes(buffer, content) {
      bufferIncludes = modern;
      try {
        return bufferIncludes(buffer, content);
      } catch (e) {
        bufferIncludes = legacy;
        return bufferIncludes(buffer, content);
      }
      function modern(buffer2, content2) {
        return buffer2.includes(content2);
      }
      function legacy(buffer2, content2) {
        for (var i = 0; i <= buffer2.length - content2.length; i++) {
          for (var j = 0; ; j++) {
            if (j === content2.length) return true;
            if (buffer2[i + j] !== content2[j]) break;
          }
        }
        return false;
      }
    }
  }
});

// node_modules/process-nextick-args/index.js
var require_process_nextick_args = __commonJS({
  "node_modules/process-nextick-args/index.js"(exports2, module2) {
    "use strict";
    if (typeof process === "undefined" || !process.version || process.version.indexOf("v0.") === 0 || process.version.indexOf("v1.") === 0 && process.version.indexOf("v1.8.") !== 0) {
      module2.exports = { nextTick };
    } else {
      module2.exports = process;
    }
    function nextTick(fn, arg1, arg2, arg3) {
      if (typeof fn !== "function") {
        throw new TypeError('"callback" argument must be a function');
      }
      var len = arguments.length;
      var args, i;
      switch (len) {
        case 0:
        case 1:
          return process.nextTick(fn);
        case 2:
          return process.nextTick(function afterTickOne() {
            fn.call(null, arg1);
          });
        case 3:
          return process.nextTick(function afterTickTwo() {
            fn.call(null, arg1, arg2);
          });
        case 4:
          return process.nextTick(function afterTickThree() {
            fn.call(null, arg1, arg2, arg3);
          });
        default:
          args = new Array(len - 1);
          i = 0;
          while (i < args.length) {
            args[i++] = arguments[i];
          }
          return process.nextTick(function afterTick() {
            fn.apply(null, args);
          });
      }
    }
  }
});

// node_modules/tar-stream/node_modules/isarray/index.js
var require_isarray = __commonJS({
  "node_modules/tar-stream/node_modules/isarray/index.js"(exports2, module2) {
    "use strict";
    var toString4 = {}.toString;
    module2.exports = Array.isArray || function(arr) {
      return toString4.call(arr) == "[object Array]";
    };
  }
});

// node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/stream.js
var require_stream8 = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/stream.js"(exports2, module2) {
    "use strict";
    module2.exports = require("stream");
  }
});

// node_modules/tar-stream/node_modules/readable-stream/node_modules/safe-buffer/index.js
var require_safe_buffer3 = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/node_modules/safe-buffer/index.js"(exports2, module2) {
    "use strict";
    var buffer = require("buffer");
    var Buffer3 = buffer.Buffer;
    function copyProps(src, dst) {
      for (var key in src) {
        dst[key] = src[key];
      }
    }
    if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow) {
      module2.exports = buffer;
    } else {
      copyProps(buffer, exports2);
      exports2.Buffer = SafeBuffer;
    }
    function SafeBuffer(arg, encodingOrOffset, length) {
      return Buffer3(arg, encodingOrOffset, length);
    }
    copyProps(Buffer3, SafeBuffer);
    SafeBuffer.from = function(arg, encodingOrOffset, length) {
      if (typeof arg === "number") {
        throw new TypeError("Argument must not be a number");
      }
      return Buffer3(arg, encodingOrOffset, length);
    };
    SafeBuffer.alloc = function(size, fill, encoding) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      var buf = Buffer3(size);
      if (fill !== void 0) {
        if (typeof encoding === "string") {
          buf.fill(fill, encoding);
        } else {
          buf.fill(fill);
        }
      } else {
        buf.fill(0);
      }
      return buf;
    };
    SafeBuffer.allocUnsafe = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return Buffer3(size);
    };
    SafeBuffer.allocUnsafeSlow = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return buffer.SlowBuffer(size);
    };
  }
});

// node_modules/core-util-is/lib/util.js
var require_util6 = __commonJS({
  "node_modules/core-util-is/lib/util.js"(exports2) {
    "use strict";
    function isArray3(arg) {
      if (Array.isArray) {
        return Array.isArray(arg);
      }
      return objectToString2(arg) === "[object Array]";
    }
    exports2.isArray = isArray3;
    function isBoolean2(arg) {
      return typeof arg === "boolean";
    }
    exports2.isBoolean = isBoolean2;
    function isNull(arg) {
      return arg === null;
    }
    exports2.isNull = isNull;
    function isNullOrUndefined(arg) {
      return arg == null;
    }
    exports2.isNullOrUndefined = isNullOrUndefined;
    function isNumber2(arg) {
      return typeof arg === "number";
    }
    exports2.isNumber = isNumber2;
    function isString2(arg) {
      return typeof arg === "string";
    }
    exports2.isString = isString2;
    function isSymbol2(arg) {
      return typeof arg === "symbol";
    }
    exports2.isSymbol = isSymbol2;
    function isUndefined2(arg) {
      return arg === void 0;
    }
    exports2.isUndefined = isUndefined2;
    function isRegExp2(re2) {
      return objectToString2(re2) === "[object RegExp]";
    }
    exports2.isRegExp = isRegExp2;
    function isObject5(arg) {
      return typeof arg === "object" && arg !== null;
    }
    exports2.isObject = isObject5;
    function isDate2(d) {
      return objectToString2(d) === "[object Date]";
    }
    exports2.isDate = isDate2;
    function isError(e) {
      return objectToString2(e) === "[object Error]" || e instanceof Error;
    }
    exports2.isError = isError;
    function isFunction4(arg) {
      return typeof arg === "function";
    }
    exports2.isFunction = isFunction4;
    function isPrimitive(arg) {
      return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
      typeof arg === "undefined";
    }
    exports2.isPrimitive = isPrimitive;
    exports2.isBuffer = require("buffer").Buffer.isBuffer;
    function objectToString2(o) {
      return Object.prototype.toString.call(o);
    }
  }
});

// node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/BufferList.js
var require_BufferList = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/BufferList.js"(exports2, module2) {
    "use strict";
    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    var Buffer3 = require_safe_buffer3().Buffer;
    var util4 = require("util");
    function copyBuffer(src, target, offset) {
      src.copy(target, offset);
    }
    module2.exports = (function() {
      function BufferList() {
        _classCallCheck(this, BufferList);
        this.head = null;
        this.tail = null;
        this.length = 0;
      }
      BufferList.prototype.push = function push(v) {
        var entry = { data: v, next: null };
        if (this.length > 0) this.tail.next = entry;
        else this.head = entry;
        this.tail = entry;
        ++this.length;
      };
      BufferList.prototype.unshift = function unshift(v) {
        var entry = { data: v, next: this.head };
        if (this.length === 0) this.tail = entry;
        this.head = entry;
        ++this.length;
      };
      BufferList.prototype.shift = function shift() {
        if (this.length === 0) return;
        var ret = this.head.data;
        if (this.length === 1) this.head = this.tail = null;
        else this.head = this.head.next;
        --this.length;
        return ret;
      };
      BufferList.prototype.clear = function clear() {
        this.head = this.tail = null;
        this.length = 0;
      };
      BufferList.prototype.join = function join2(s) {
        if (this.length === 0) return "";
        var p3 = this.head;
        var ret = "" + p3.data;
        while (p3 = p3.next) {
          ret += s + p3.data;
        }
        return ret;
      };
      BufferList.prototype.concat = function concat(n) {
        if (this.length === 0) return Buffer3.alloc(0);
        var ret = Buffer3.allocUnsafe(n >>> 0);
        var p3 = this.head;
        var i = 0;
        while (p3) {
          copyBuffer(p3.data, ret, i);
          i += p3.data.length;
          p3 = p3.next;
        }
        return ret;
      };
      return BufferList;
    })();
    if (util4 && util4.inspect && util4.inspect.custom) {
      module2.exports.prototype[util4.inspect.custom] = function() {
        var obj = util4.inspect({ length: this.length });
        return this.constructor.name + " " + obj;
      };
    }
  }
});

// node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/destroy.js
var require_destroy = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports2, module2) {
    "use strict";
    var pna = require_process_nextick_args();
    function destroy(err, cb) {
      var _this = this;
      var readableDestroyed = this._readableState && this._readableState.destroyed;
      var writableDestroyed = this._writableState && this._writableState.destroyed;
      if (readableDestroyed || writableDestroyed) {
        if (cb) {
          cb(err);
        } else if (err) {
          if (!this._writableState) {
            pna.nextTick(emitErrorNT, this, err);
          } else if (!this._writableState.errorEmitted) {
            this._writableState.errorEmitted = true;
            pna.nextTick(emitErrorNT, this, err);
          }
        }
        return this;
      }
      if (this._readableState) {
        this._readableState.destroyed = true;
      }
      if (this._writableState) {
        this._writableState.destroyed = true;
      }
      this._destroy(err || null, function(err2) {
        if (!cb && err2) {
          if (!_this._writableState) {
            pna.nextTick(emitErrorNT, _this, err2);
          } else if (!_this._writableState.errorEmitted) {
            _this._writableState.errorEmitted = true;
            pna.nextTick(emitErrorNT, _this, err2);
          }
        } else if (cb) {
          cb(err2);
        }
      });
      return this;
    }
    function undestroy() {
      if (this._readableState) {
        this._readableState.destroyed = false;
        this._readableState.reading = false;
        this._readableState.ended = false;
        this._readableState.endEmitted = false;
      }
      if (this._writableState) {
        this._writableState.destroyed = false;
        this._writableState.ended = false;
        this._writableState.ending = false;
        this._writableState.finalCalled = false;
        this._writableState.prefinished = false;
        this._writableState.finished = false;
        this._writableState.errorEmitted = false;
      }
    }
    function emitErrorNT(self2, err) {
      self2.emit("error", err);
    }
    module2.exports = {
      destroy,
      undestroy
    };
  }
});

// node_modules/util-deprecate/node.js
var require_node4 = __commonJS({
  "node_modules/util-deprecate/node.js"(exports2, module2) {
    "use strict";
    module2.exports = require("util").deprecate;
  }
});

// node_modules/tar-stream/node_modules/readable-stream/lib/_stream_writable.js
var require_stream_writable = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/lib/_stream_writable.js"(exports2, module2) {
    "use strict";
    var pna = require_process_nextick_args();
    module2.exports = Writable;
    function CorkedRequest(state) {
      var _this = this;
      this.next = null;
      this.entry = null;
      this.finish = function() {
        onCorkedFinish(_this, state);
      };
    }
    var asyncWrite = !process.browser && ["v0.10", "v0.9."].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
    var Duplex;
    Writable.WritableState = WritableState;
    var util4 = Object.create(require_util6());
    util4.inherits = require_inherits();
    var internalUtil = {
      deprecate: require_node4()
    };
    var Stream = require_stream8();
    var Buffer3 = require_safe_buffer3().Buffer;
    var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
    };
    function _uint8ArrayToBuffer(chunk) {
      return Buffer3.from(chunk);
    }
    function _isUint8Array(obj) {
      return Buffer3.isBuffer(obj) || obj instanceof OurUint8Array;
    }
    var destroyImpl = require_destroy();
    util4.inherits(Writable, Stream);
    function nop() {
    }
    function WritableState(options, stream4) {
      Duplex = Duplex || require_stream_duplex();
      options = options || {};
      var isDuplex = stream4 instanceof Duplex;
      this.objectMode = !!options.objectMode;
      if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
      var hwm = options.highWaterMark;
      var writableHwm = options.writableHighWaterMark;
      var defaultHwm = this.objectMode ? 16 : 16 * 1024;
      if (hwm || hwm === 0) this.highWaterMark = hwm;
      else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;
      else this.highWaterMark = defaultHwm;
      this.highWaterMark = Math.floor(this.highWaterMark);
      this.finalCalled = false;
      this.needDrain = false;
      this.ending = false;
      this.ended = false;
      this.finished = false;
      this.destroyed = false;
      var noDecode = options.decodeStrings === false;
      this.decodeStrings = !noDecode;
      this.defaultEncoding = options.defaultEncoding || "utf8";
      this.length = 0;
      this.writing = false;
      this.corked = 0;
      this.sync = true;
      this.bufferProcessing = false;
      this.onwrite = function(er) {
        onwrite(stream4, er);
      };
      this.writecb = null;
      this.writelen = 0;
      this.bufferedRequest = null;
      this.lastBufferedRequest = null;
      this.pendingcb = 0;
      this.prefinished = false;
      this.errorEmitted = false;
      this.bufferedRequestCount = 0;
      this.corkedRequestsFree = new CorkedRequest(this);
    }
    WritableState.prototype.getBuffer = function getBuffer() {
      var current = this.bufferedRequest;
      var out = [];
      while (current) {
        out.push(current);
        current = current.next;
      }
      return out;
    };
    (function() {
      try {
        Object.defineProperty(WritableState.prototype, "buffer", {
          get: internalUtil.deprecate(function() {
            return this.getBuffer();
          }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
        });
      } catch (_) {
      }
    })();
    var realHasInstance;
    if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
      realHasInstance = Function.prototype[Symbol.hasInstance];
      Object.defineProperty(Writable, Symbol.hasInstance, {
        value: function(object4) {
          if (realHasInstance.call(this, object4)) return true;
          if (this !== Writable) return false;
          return object4 && object4._writableState instanceof WritableState;
        }
      });
    } else {
      realHasInstance = function(object4) {
        return object4 instanceof this;
      };
    }
    function Writable(options) {
      Duplex = Duplex || require_stream_duplex();
      if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
        return new Writable(options);
      }
      this._writableState = new WritableState(options, this);
      this.writable = true;
      if (options) {
        if (typeof options.write === "function") this._write = options.write;
        if (typeof options.writev === "function") this._writev = options.writev;
        if (typeof options.destroy === "function") this._destroy = options.destroy;
        if (typeof options.final === "function") this._final = options.final;
      }
      Stream.call(this);
    }
    Writable.prototype.pipe = function() {
      this.emit("error", new Error("Cannot pipe, not readable"));
    };
    function writeAfterEnd(stream4, cb) {
      var er = new Error("write after end");
      stream4.emit("error", er);
      pna.nextTick(cb, er);
    }
    function validChunk(stream4, state, chunk, cb) {
      var valid = true;
      var er = false;
      if (chunk === null) {
        er = new TypeError("May not write null values to stream");
      } else if (typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
        er = new TypeError("Invalid non-string/buffer chunk");
      }
      if (er) {
        stream4.emit("error", er);
        pna.nextTick(cb, er);
        valid = false;
      }
      return valid;
    }
    Writable.prototype.write = function(chunk, encoding, cb) {
      var state = this._writableState;
      var ret = false;
      var isBuf = !state.objectMode && _isUint8Array(chunk);
      if (isBuf && !Buffer3.isBuffer(chunk)) {
        chunk = _uint8ArrayToBuffer(chunk);
      }
      if (typeof encoding === "function") {
        cb = encoding;
        encoding = null;
      }
      if (isBuf) encoding = "buffer";
      else if (!encoding) encoding = state.defaultEncoding;
      if (typeof cb !== "function") cb = nop;
      if (state.ended) writeAfterEnd(this, cb);
      else if (isBuf || validChunk(this, state, chunk, cb)) {
        state.pendingcb++;
        ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
      }
      return ret;
    };
    Writable.prototype.cork = function() {
      var state = this._writableState;
      state.corked++;
    };
    Writable.prototype.uncork = function() {
      var state = this._writableState;
      if (state.corked) {
        state.corked--;
        if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
      }
    };
    Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
      if (typeof encoding === "string") encoding = encoding.toLowerCase();
      if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new TypeError("Unknown encoding: " + encoding);
      this._writableState.defaultEncoding = encoding;
      return this;
    };
    function decodeChunk(state, chunk, encoding) {
      if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
        chunk = Buffer3.from(chunk, encoding);
      }
      return chunk;
    }
    Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
      // making it explicit this property is not enumerable
      // because otherwise some prototype manipulation in
      // userland will fail
      enumerable: false,
      get: function() {
        return this._writableState.highWaterMark;
      }
    });
    function writeOrBuffer(stream4, state, isBuf, chunk, encoding, cb) {
      if (!isBuf) {
        var newChunk = decodeChunk(state, chunk, encoding);
        if (chunk !== newChunk) {
          isBuf = true;
          encoding = "buffer";
          chunk = newChunk;
        }
      }
      var len = state.objectMode ? 1 : chunk.length;
      state.length += len;
      var ret = state.length < state.highWaterMark;
      if (!ret) state.needDrain = true;
      if (state.writing || state.corked) {
        var last = state.lastBufferedRequest;
        state.lastBufferedRequest = {
          chunk,
          encoding,
          isBuf,
          callback: cb,
          next: null
        };
        if (last) {
          last.next = state.lastBufferedRequest;
        } else {
          state.bufferedRequest = state.lastBufferedRequest;
        }
        state.bufferedRequestCount += 1;
      } else {
        doWrite(stream4, state, false, len, chunk, encoding, cb);
      }
      return ret;
    }
    function doWrite(stream4, state, writev, len, chunk, encoding, cb) {
      state.writelen = len;
      state.writecb = cb;
      state.writing = true;
      state.sync = true;
      if (writev) stream4._writev(chunk, state.onwrite);
      else stream4._write(chunk, encoding, state.onwrite);
      state.sync = false;
    }
    function onwriteError(stream4, state, sync, er, cb) {
      --state.pendingcb;
      if (sync) {
        pna.nextTick(cb, er);
        pna.nextTick(finishMaybe, stream4, state);
        stream4._writableState.errorEmitted = true;
        stream4.emit("error", er);
      } else {
        cb(er);
        stream4._writableState.errorEmitted = true;
        stream4.emit("error", er);
        finishMaybe(stream4, state);
      }
    }
    function onwriteStateUpdate(state) {
      state.writing = false;
      state.writecb = null;
      state.length -= state.writelen;
      state.writelen = 0;
    }
    function onwrite(stream4, er) {
      var state = stream4._writableState;
      var sync = state.sync;
      var cb = state.writecb;
      onwriteStateUpdate(state);
      if (er) onwriteError(stream4, state, sync, er, cb);
      else {
        var finished = needFinish(state);
        if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
          clearBuffer(stream4, state);
        }
        if (sync) {
          asyncWrite(afterWrite, stream4, state, finished, cb);
        } else {
          afterWrite(stream4, state, finished, cb);
        }
      }
    }
    function afterWrite(stream4, state, finished, cb) {
      if (!finished) onwriteDrain(stream4, state);
      state.pendingcb--;
      cb();
      finishMaybe(stream4, state);
    }
    function onwriteDrain(stream4, state) {
      if (state.length === 0 && state.needDrain) {
        state.needDrain = false;
        stream4.emit("drain");
      }
    }
    function clearBuffer(stream4, state) {
      state.bufferProcessing = true;
      var entry = state.bufferedRequest;
      if (stream4._writev && entry && entry.next) {
        var l = state.bufferedRequestCount;
        var buffer = new Array(l);
        var holder = state.corkedRequestsFree;
        holder.entry = entry;
        var count = 0;
        var allBuffers = true;
        while (entry) {
          buffer[count] = entry;
          if (!entry.isBuf) allBuffers = false;
          entry = entry.next;
          count += 1;
        }
        buffer.allBuffers = allBuffers;
        doWrite(stream4, state, true, state.length, buffer, "", holder.finish);
        state.pendingcb++;
        state.lastBufferedRequest = null;
        if (holder.next) {
          state.corkedRequestsFree = holder.next;
          holder.next = null;
        } else {
          state.corkedRequestsFree = new CorkedRequest(state);
        }
        state.bufferedRequestCount = 0;
      } else {
        while (entry) {
          var chunk = entry.chunk;
          var encoding = entry.encoding;
          var cb = entry.callback;
          var len = state.objectMode ? 1 : chunk.length;
          doWrite(stream4, state, false, len, chunk, encoding, cb);
          entry = entry.next;
          state.bufferedRequestCount--;
          if (state.writing) {
            break;
          }
        }
        if (entry === null) state.lastBufferedRequest = null;
      }
      state.bufferedRequest = entry;
      state.bufferProcessing = false;
    }
    Writable.prototype._write = function(chunk, encoding, cb) {
      cb(new Error("_write() is not implemented"));
    };
    Writable.prototype._writev = null;
    Writable.prototype.end = function(chunk, encoding, cb) {
      var state = this._writableState;
      if (typeof chunk === "function") {
        cb = chunk;
        chunk = null;
        encoding = null;
      } else if (typeof encoding === "function") {
        cb = encoding;
        encoding = null;
      }
      if (chunk !== null && chunk !== void 0) this.write(chunk, encoding);
      if (state.corked) {
        state.corked = 1;
        this.uncork();
      }
      if (!state.ending) endWritable(this, state, cb);
    };
    function needFinish(state) {
      return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
    }
    function callFinal(stream4, state) {
      stream4._final(function(err) {
        state.pendingcb--;
        if (err) {
          stream4.emit("error", err);
        }
        state.prefinished = true;
        stream4.emit("prefinish");
        finishMaybe(stream4, state);
      });
    }
    function prefinish(stream4, state) {
      if (!state.prefinished && !state.finalCalled) {
        if (typeof stream4._final === "function") {
          state.pendingcb++;
          state.finalCalled = true;
          pna.nextTick(callFinal, stream4, state);
        } else {
          state.prefinished = true;
          stream4.emit("prefinish");
        }
      }
    }
    function finishMaybe(stream4, state) {
      var need = needFinish(state);
      if (need) {
        prefinish(stream4, state);
        if (state.pendingcb === 0) {
          state.finished = true;
          stream4.emit("finish");
        }
      }
      return need;
    }
    function endWritable(stream4, state, cb) {
      state.ending = true;
      finishMaybe(stream4, state);
      if (cb) {
        if (state.finished) pna.nextTick(cb);
        else stream4.once("finish", cb);
      }
      state.ended = true;
      stream4.writable = false;
    }
    function onCorkedFinish(corkReq, state, err) {
      var entry = corkReq.entry;
      corkReq.entry = null;
      while (entry) {
        var cb = entry.callback;
        state.pendingcb--;
        cb(err);
        entry = entry.next;
      }
      state.corkedRequestsFree.next = corkReq;
    }
    Object.defineProperty(Writable.prototype, "destroyed", {
      get: function() {
        if (this._writableState === void 0) {
          return false;
        }
        return this._writableState.destroyed;
      },
      set: function(value) {
        if (!this._writableState) {
          return;
        }
        this._writableState.destroyed = value;
      }
    });
    Writable.prototype.destroy = destroyImpl.destroy;
    Writable.prototype._undestroy = destroyImpl.undestroy;
    Writable.prototype._destroy = function(err, cb) {
      this.end();
      cb(err);
    };
  }
});

// node_modules/tar-stream/node_modules/readable-stream/lib/_stream_duplex.js
var require_stream_duplex = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/lib/_stream_duplex.js"(exports2, module2) {
    "use strict";
    var pna = require_process_nextick_args();
    var objectKeys = Object.keys || function(obj) {
      var keys3 = [];
      for (var key in obj) {
        keys3.push(key);
      }
      return keys3;
    };
    module2.exports = Duplex;
    var util4 = Object.create(require_util6());
    util4.inherits = require_inherits();
    var Readable2 = require_stream_readable();
    var Writable = require_stream_writable();
    util4.inherits(Duplex, Readable2);
    {
      keys2 = objectKeys(Writable.prototype);
      for (v = 0; v < keys2.length; v++) {
        method = keys2[v];
        if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
      }
    }
    var keys2;
    var method;
    var v;
    function Duplex(options) {
      if (!(this instanceof Duplex)) return new Duplex(options);
      Readable2.call(this, options);
      Writable.call(this, options);
      if (options && options.readable === false) this.readable = false;
      if (options && options.writable === false) this.writable = false;
      this.allowHalfOpen = true;
      if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
      this.once("end", onend);
    }
    Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
      // making it explicit this property is not enumerable
      // because otherwise some prototype manipulation in
      // userland will fail
      enumerable: false,
      get: function() {
        return this._writableState.highWaterMark;
      }
    });
    function onend() {
      if (this.allowHalfOpen || this._writableState.ended) return;
      pna.nextTick(onEndNT, this);
    }
    function onEndNT(self2) {
      self2.end();
    }
    Object.defineProperty(Duplex.prototype, "destroyed", {
      get: function() {
        if (this._readableState === void 0 || this._writableState === void 0) {
          return false;
        }
        return this._readableState.destroyed && this._writableState.destroyed;
      },
      set: function(value) {
        if (this._readableState === void 0 || this._writableState === void 0) {
          return;
        }
        this._readableState.destroyed = value;
        this._writableState.destroyed = value;
      }
    });
    Duplex.prototype._destroy = function(err, cb) {
      this.push(null);
      this.end();
      pna.nextTick(cb, err);
    };
  }
});

// node_modules/tar-stream/node_modules/string_decoder/node_modules/safe-buffer/index.js
var require_safe_buffer4 = __commonJS({
  "node_modules/tar-stream/node_modules/string_decoder/node_modules/safe-buffer/index.js"(exports2, module2) {
    "use strict";
    var buffer = require("buffer");
    var Buffer3 = buffer.Buffer;
    function copyProps(src, dst) {
      for (var key in src) {
        dst[key] = src[key];
      }
    }
    if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow) {
      module2.exports = buffer;
    } else {
      copyProps(buffer, exports2);
      exports2.Buffer = SafeBuffer;
    }
    function SafeBuffer(arg, encodingOrOffset, length) {
      return Buffer3(arg, encodingOrOffset, length);
    }
    copyProps(Buffer3, SafeBuffer);
    SafeBuffer.from = function(arg, encodingOrOffset, length) {
      if (typeof arg === "number") {
        throw new TypeError("Argument must not be a number");
      }
      return Buffer3(arg, encodingOrOffset, length);
    };
    SafeBuffer.alloc = function(size, fill, encoding) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      var buf = Buffer3(size);
      if (fill !== void 0) {
        if (typeof encoding === "string") {
          buf.fill(fill, encoding);
        } else {
          buf.fill(fill);
        }
      } else {
        buf.fill(0);
      }
      return buf;
    };
    SafeBuffer.allocUnsafe = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return Buffer3(size);
    };
    SafeBuffer.allocUnsafeSlow = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return buffer.SlowBuffer(size);
    };
  }
});

// node_modules/tar-stream/node_modules/string_decoder/lib/string_decoder.js
var require_string_decoder = __commonJS({
  "node_modules/tar-stream/node_modules/string_decoder/lib/string_decoder.js"(exports2) {
    "use strict";
    var Buffer3 = require_safe_buffer4().Buffer;
    var isEncoding = Buffer3.isEncoding || function(encoding) {
      encoding = "" + encoding;
      switch (encoding && encoding.toLowerCase()) {
        case "hex":
        case "utf8":
        case "utf-8":
        case "ascii":
        case "binary":
        case "base64":
        case "ucs2":
        case "ucs-2":
        case "utf16le":
        case "utf-16le":
        case "raw":
          return true;
        default:
          return false;
      }
    };
    function _normalizeEncoding(enc) {
      if (!enc) return "utf8";
      var retried;
      while (true) {
        switch (enc) {
          case "utf8":
          case "utf-8":
            return "utf8";
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return "utf16le";
          case "latin1":
          case "binary":
            return "latin1";
          case "base64":
          case "ascii":
          case "hex":
            return enc;
          default:
            if (retried) return;
            enc = ("" + enc).toLowerCase();
            retried = true;
        }
      }
    }
    function normalizeEncoding(enc) {
      var nenc = _normalizeEncoding(enc);
      if (typeof nenc !== "string" && (Buffer3.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
      return nenc || enc;
    }
    exports2.StringDecoder = StringDecoder;
    function StringDecoder(encoding) {
      this.encoding = normalizeEncoding(encoding);
      var nb;
      switch (this.encoding) {
        case "utf16le":
          this.text = utf16Text;
          this.end = utf16End;
          nb = 4;
          break;
        case "utf8":
          this.fillLast = utf8FillLast;
          nb = 4;
          break;
        case "base64":
          this.text = base64Text;
          this.end = base64End;
          nb = 3;
          break;
        default:
          this.write = simpleWrite;
          this.end = simpleEnd;
          return;
      }
      this.lastNeed = 0;
      this.lastTotal = 0;
      this.lastChar = Buffer3.allocUnsafe(nb);
    }
    StringDecoder.prototype.write = function(buf) {
      if (buf.length === 0) return "";
      var r;
      var i;
      if (this.lastNeed) {
        r = this.fillLast(buf);
        if (r === void 0) return "";
        i = this.lastNeed;
        this.lastNeed = 0;
      } else {
        i = 0;
      }
      if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
      return r || "";
    };
    StringDecoder.prototype.end = utf8End;
    StringDecoder.prototype.text = utf8Text;
    StringDecoder.prototype.fillLast = function(buf) {
      if (this.lastNeed <= buf.length) {
        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
      }
      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
      this.lastNeed -= buf.length;
    };
    function utf8CheckByte(byte) {
      if (byte <= 127) return 0;
      else if (byte >> 5 === 6) return 2;
      else if (byte >> 4 === 14) return 3;
      else if (byte >> 3 === 30) return 4;
      return byte >> 6 === 2 ? -1 : -2;
    }
    function utf8CheckIncomplete(self2, buf, i) {
      var j = buf.length - 1;
      if (j < i) return 0;
      var nb = utf8CheckByte(buf[j]);
      if (nb >= 0) {
        if (nb > 0) self2.lastNeed = nb - 1;
        return nb;
      }
      if (--j < i || nb === -2) return 0;
      nb = utf8CheckByte(buf[j]);
      if (nb >= 0) {
        if (nb > 0) self2.lastNeed = nb - 2;
        return nb;
      }
      if (--j < i || nb === -2) return 0;
      nb = utf8CheckByte(buf[j]);
      if (nb >= 0) {
        if (nb > 0) {
          if (nb === 2) nb = 0;
          else self2.lastNeed = nb - 3;
        }
        return nb;
      }
      return 0;
    }
    function utf8CheckExtraBytes(self2, buf, p3) {
      if ((buf[0] & 192) !== 128) {
        self2.lastNeed = 0;
        return "\uFFFD";
      }
      if (self2.lastNeed > 1 && buf.length > 1) {
        if ((buf[1] & 192) !== 128) {
          self2.lastNeed = 1;
          return "\uFFFD";
        }
        if (self2.lastNeed > 2 && buf.length > 2) {
          if ((buf[2] & 192) !== 128) {
            self2.lastNeed = 2;
            return "\uFFFD";
          }
        }
      }
    }
    function utf8FillLast(buf) {
      var p3 = this.lastTotal - this.lastNeed;
      var r = utf8CheckExtraBytes(this, buf, p3);
      if (r !== void 0) return r;
      if (this.lastNeed <= buf.length) {
        buf.copy(this.lastChar, p3, 0, this.lastNeed);
        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
      }
      buf.copy(this.lastChar, p3, 0, buf.length);
      this.lastNeed -= buf.length;
    }
    function utf8Text(buf, i) {
      var total = utf8CheckIncomplete(this, buf, i);
      if (!this.lastNeed) return buf.toString("utf8", i);
      this.lastTotal = total;
      var end = buf.length - (total - this.lastNeed);
      buf.copy(this.lastChar, 0, end);
      return buf.toString("utf8", i, end);
    }
    function utf8End(buf) {
      var r = buf && buf.length ? this.write(buf) : "";
      if (this.lastNeed) return r + "\uFFFD";
      return r;
    }
    function utf16Text(buf, i) {
      if ((buf.length - i) % 2 === 0) {
        var r = buf.toString("utf16le", i);
        if (r) {
          var c = r.charCodeAt(r.length - 1);
          if (c >= 55296 && c <= 56319) {
            this.lastNeed = 2;
            this.lastTotal = 4;
            this.lastChar[0] = buf[buf.length - 2];
            this.lastChar[1] = buf[buf.length - 1];
            return r.slice(0, -1);
          }
        }
        return r;
      }
      this.lastNeed = 1;
      this.lastTotal = 2;
      this.lastChar[0] = buf[buf.length - 1];
      return buf.toString("utf16le", i, buf.length - 1);
    }
    function utf16End(buf) {
      var r = buf && buf.length ? this.write(buf) : "";
      if (this.lastNeed) {
        var end = this.lastTotal - this.lastNeed;
        return r + this.lastChar.toString("utf16le", 0, end);
      }
      return r;
    }
    function base64Text(buf, i) {
      var n = (buf.length - i) % 3;
      if (n === 0) return buf.toString("base64", i);
      this.lastNeed = 3 - n;
      this.lastTotal = 3;
      if (n === 1) {
        this.lastChar[0] = buf[buf.length - 1];
      } else {
        this.lastChar[0] = buf[buf.length - 2];
        this.lastChar[1] = buf[buf.length - 1];
      }
      return buf.toString("base64", i, buf.length - n);
    }
    function base64End(buf) {
      var r = buf && buf.length ? this.write(buf) : "";
      if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
      return r;
    }
    function simpleWrite(buf) {
      return buf.toString(this.encoding);
    }
    function simpleEnd(buf) {
      return buf && buf.length ? this.write(buf) : "";
    }
  }
});

// node_modules/tar-stream/node_modules/readable-stream/lib/_stream_readable.js
var require_stream_readable = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/lib/_stream_readable.js"(exports2, module2) {
    "use strict";
    var pna = require_process_nextick_args();
    module2.exports = Readable2;
    var isArray3 = require_isarray();
    var Duplex;
    Readable2.ReadableState = ReadableState;
    var EE = require("events").EventEmitter;
    var EElistenerCount = function(emitter, type) {
      return emitter.listeners(type).length;
    };
    var Stream = require_stream8();
    var Buffer3 = require_safe_buffer3().Buffer;
    var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
    };
    function _uint8ArrayToBuffer(chunk) {
      return Buffer3.from(chunk);
    }
    function _isUint8Array(obj) {
      return Buffer3.isBuffer(obj) || obj instanceof OurUint8Array;
    }
    var util4 = Object.create(require_util6());
    util4.inherits = require_inherits();
    var debugUtil = require("util");
    var debug = void 0;
    if (debugUtil && debugUtil.debuglog) {
      debug = debugUtil.debuglog("stream");
    } else {
      debug = function() {
      };
    }
    var BufferList = require_BufferList();
    var destroyImpl = require_destroy();
    var StringDecoder;
    util4.inherits(Readable2, Stream);
    var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
    function prependListener(emitter, event, fn) {
      if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
      if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
      else if (isArray3(emitter._events[event])) emitter._events[event].unshift(fn);
      else emitter._events[event] = [fn, emitter._events[event]];
    }
    function ReadableState(options, stream4) {
      Duplex = Duplex || require_stream_duplex();
      options = options || {};
      var isDuplex = stream4 instanceof Duplex;
      this.objectMode = !!options.objectMode;
      if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
      var hwm = options.highWaterMark;
      var readableHwm = options.readableHighWaterMark;
      var defaultHwm = this.objectMode ? 16 : 16 * 1024;
      if (hwm || hwm === 0) this.highWaterMark = hwm;
      else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;
      else this.highWaterMark = defaultHwm;
      this.highWaterMark = Math.floor(this.highWaterMark);
      this.buffer = new BufferList();
      this.length = 0;
      this.pipes = null;
      this.pipesCount = 0;
      this.flowing = null;
      this.ended = false;
      this.endEmitted = false;
      this.reading = false;
      this.sync = true;
      this.needReadable = false;
      this.emittedReadable = false;
      this.readableListening = false;
      this.resumeScheduled = false;
      this.destroyed = false;
      this.defaultEncoding = options.defaultEncoding || "utf8";
      this.awaitDrain = 0;
      this.readingMore = false;
      this.decoder = null;
      this.encoding = null;
      if (options.encoding) {
        if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
        this.decoder = new StringDecoder(options.encoding);
        this.encoding = options.encoding;
      }
    }
    function Readable2(options) {
      Duplex = Duplex || require_stream_duplex();
      if (!(this instanceof Readable2)) return new Readable2(options);
      this._readableState = new ReadableState(options, this);
      this.readable = true;
      if (options) {
        if (typeof options.read === "function") this._read = options.read;
        if (typeof options.destroy === "function") this._destroy = options.destroy;
      }
      Stream.call(this);
    }
    Object.defineProperty(Readable2.prototype, "destroyed", {
      get: function() {
        if (this._readableState === void 0) {
          return false;
        }
        return this._readableState.destroyed;
      },
      set: function(value) {
        if (!this._readableState) {
          return;
        }
        this._readableState.destroyed = value;
      }
    });
    Readable2.prototype.destroy = destroyImpl.destroy;
    Readable2.prototype._undestroy = destroyImpl.undestroy;
    Readable2.prototype._destroy = function(err, cb) {
      this.push(null);
      cb(err);
    };
    Readable2.prototype.push = function(chunk, encoding) {
      var state = this._readableState;
      var skipChunkCheck;
      if (!state.objectMode) {
        if (typeof chunk === "string") {
          encoding = encoding || state.defaultEncoding;
          if (encoding !== state.encoding) {
            chunk = Buffer3.from(chunk, encoding);
            encoding = "";
          }
          skipChunkCheck = true;
        }
      } else {
        skipChunkCheck = true;
      }
      return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
    };
    Readable2.prototype.unshift = function(chunk) {
      return readableAddChunk(this, chunk, null, true, false);
    };
    function readableAddChunk(stream4, chunk, encoding, addToFront, skipChunkCheck) {
      var state = stream4._readableState;
      if (chunk === null) {
        state.reading = false;
        onEofChunk(stream4, state);
      } else {
        var er;
        if (!skipChunkCheck) er = chunkInvalid(state, chunk);
        if (er) {
          stream4.emit("error", er);
        } else if (state.objectMode || chunk && chunk.length > 0) {
          if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer3.prototype) {
            chunk = _uint8ArrayToBuffer(chunk);
          }
          if (addToFront) {
            if (state.endEmitted) stream4.emit("error", new Error("stream.unshift() after end event"));
            else addChunk(stream4, state, chunk, true);
          } else if (state.ended) {
            stream4.emit("error", new Error("stream.push() after EOF"));
          } else {
            state.reading = false;
            if (state.decoder && !encoding) {
              chunk = state.decoder.write(chunk);
              if (state.objectMode || chunk.length !== 0) addChunk(stream4, state, chunk, false);
              else maybeReadMore(stream4, state);
            } else {
              addChunk(stream4, state, chunk, false);
            }
          }
        } else if (!addToFront) {
          state.reading = false;
        }
      }
      return needMoreData(state);
    }
    function addChunk(stream4, state, chunk, addToFront) {
      if (state.flowing && state.length === 0 && !state.sync) {
        stream4.emit("data", chunk);
        stream4.read(0);
      } else {
        state.length += state.objectMode ? 1 : chunk.length;
        if (addToFront) state.buffer.unshift(chunk);
        else state.buffer.push(chunk);
        if (state.needReadable) emitReadable(stream4);
      }
      maybeReadMore(stream4, state);
    }
    function chunkInvalid(state, chunk) {
      var er;
      if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
        er = new TypeError("Invalid non-string/buffer chunk");
      }
      return er;
    }
    function needMoreData(state) {
      return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
    }
    Readable2.prototype.isPaused = function() {
      return this._readableState.flowing === false;
    };
    Readable2.prototype.setEncoding = function(enc) {
      if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
      this._readableState.decoder = new StringDecoder(enc);
      this._readableState.encoding = enc;
      return this;
    };
    var MAX_HWM = 8388608;
    function computeNewHighWaterMark(n) {
      if (n >= MAX_HWM) {
        n = MAX_HWM;
      } else {
        n--;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        n++;
      }
      return n;
    }
    function howMuchToRead(n, state) {
      if (n <= 0 || state.length === 0 && state.ended) return 0;
      if (state.objectMode) return 1;
      if (n !== n) {
        if (state.flowing && state.length) return state.buffer.head.data.length;
        else return state.length;
      }
      if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
      if (n <= state.length) return n;
      if (!state.ended) {
        state.needReadable = true;
        return 0;
      }
      return state.length;
    }
    Readable2.prototype.read = function(n) {
      debug("read", n);
      n = parseInt(n, 10);
      var state = this._readableState;
      var nOrig = n;
      if (n !== 0) state.emittedReadable = false;
      if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
        debug("read: emitReadable", state.length, state.ended);
        if (state.length === 0 && state.ended) endReadable(this);
        else emitReadable(this);
        return null;
      }
      n = howMuchToRead(n, state);
      if (n === 0 && state.ended) {
        if (state.length === 0) endReadable(this);
        return null;
      }
      var doRead = state.needReadable;
      debug("need readable", doRead);
      if (state.length === 0 || state.length - n < state.highWaterMark) {
        doRead = true;
        debug("length less than watermark", doRead);
      }
      if (state.ended || state.reading) {
        doRead = false;
        debug("reading or ended", doRead);
      } else if (doRead) {
        debug("do read");
        state.reading = true;
        state.sync = true;
        if (state.length === 0) state.needReadable = true;
        this._read(state.highWaterMark);
        state.sync = false;
        if (!state.reading) n = howMuchToRead(nOrig, state);
      }
      var ret;
      if (n > 0) ret = fromList(n, state);
      else ret = null;
      if (ret === null) {
        state.needReadable = true;
        n = 0;
      } else {
        state.length -= n;
      }
      if (state.length === 0) {
        if (!state.ended) state.needReadable = true;
        if (nOrig !== n && state.ended) endReadable(this);
      }
      if (ret !== null) this.emit("data", ret);
      return ret;
    };
    function onEofChunk(stream4, state) {
      if (state.ended) return;
      if (state.decoder) {
        var chunk = state.decoder.end();
        if (chunk && chunk.length) {
          state.buffer.push(chunk);
          state.length += state.objectMode ? 1 : chunk.length;
        }
      }
      state.ended = true;
      emitReadable(stream4);
    }
    function emitReadable(stream4) {
      var state = stream4._readableState;
      state.needReadable = false;
      if (!state.emittedReadable) {
        debug("emitReadable", state.flowing);
        state.emittedReadable = true;
        if (state.sync) pna.nextTick(emitReadable_, stream4);
        else emitReadable_(stream4);
      }
    }
    function emitReadable_(stream4) {
      debug("emit readable");
      stream4.emit("readable");
      flow(stream4);
    }
    function maybeReadMore(stream4, state) {
      if (!state.readingMore) {
        state.readingMore = true;
        pna.nextTick(maybeReadMore_, stream4, state);
      }
    }
    function maybeReadMore_(stream4, state) {
      var len = state.length;
      while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
        debug("maybeReadMore read 0");
        stream4.read(0);
        if (len === state.length)
          break;
        else len = state.length;
      }
      state.readingMore = false;
    }
    Readable2.prototype._read = function(n) {
      this.emit("error", new Error("_read() is not implemented"));
    };
    Readable2.prototype.pipe = function(dest, pipeOpts) {
      var src = this;
      var state = this._readableState;
      switch (state.pipesCount) {
        case 0:
          state.pipes = dest;
          break;
        case 1:
          state.pipes = [state.pipes, dest];
          break;
        default:
          state.pipes.push(dest);
          break;
      }
      state.pipesCount += 1;
      debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
      var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
      var endFn = doEnd ? onend : unpipe;
      if (state.endEmitted) pna.nextTick(endFn);
      else src.once("end", endFn);
      dest.on("unpipe", onunpipe);
      function onunpipe(readable, unpipeInfo) {
        debug("onunpipe");
        if (readable === src) {
          if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
            unpipeInfo.hasUnpiped = true;
            cleanup();
          }
        }
      }
      function onend() {
        debug("onend");
        dest.end();
      }
      var ondrain = pipeOnDrain(src);
      dest.on("drain", ondrain);
      var cleanedUp = false;
      function cleanup() {
        debug("cleanup");
        dest.removeListener("close", onclose);
        dest.removeListener("finish", onfinish);
        dest.removeListener("drain", ondrain);
        dest.removeListener("error", onerror);
        dest.removeListener("unpipe", onunpipe);
        src.removeListener("end", onend);
        src.removeListener("end", unpipe);
        src.removeListener("data", ondata);
        cleanedUp = true;
        if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
      }
      var increasedAwaitDrain = false;
      src.on("data", ondata);
      function ondata(chunk) {
        debug("ondata");
        increasedAwaitDrain = false;
        var ret = dest.write(chunk);
        if (false === ret && !increasedAwaitDrain) {
          if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
            debug("false write response, pause", state.awaitDrain);
            state.awaitDrain++;
            increasedAwaitDrain = true;
          }
          src.pause();
        }
      }
      function onerror(er) {
        debug("onerror", er);
        unpipe();
        dest.removeListener("error", onerror);
        if (EElistenerCount(dest, "error") === 0) dest.emit("error", er);
      }
      prependListener(dest, "error", onerror);
      function onclose() {
        dest.removeListener("finish", onfinish);
        unpipe();
      }
      dest.once("close", onclose);
      function onfinish() {
        debug("onfinish");
        dest.removeListener("close", onclose);
        unpipe();
      }
      dest.once("finish", onfinish);
      function unpipe() {
        debug("unpipe");
        src.unpipe(dest);
      }
      dest.emit("pipe", src);
      if (!state.flowing) {
        debug("pipe resume");
        src.resume();
      }
      return dest;
    };
    function pipeOnDrain(src) {
      return function() {
        var state = src._readableState;
        debug("pipeOnDrain", state.awaitDrain);
        if (state.awaitDrain) state.awaitDrain--;
        if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
          state.flowing = true;
          flow(src);
        }
      };
    }
    Readable2.prototype.unpipe = function(dest) {
      var state = this._readableState;
      var unpipeInfo = { hasUnpiped: false };
      if (state.pipesCount === 0) return this;
      if (state.pipesCount === 1) {
        if (dest && dest !== state.pipes) return this;
        if (!dest) dest = state.pipes;
        state.pipes = null;
        state.pipesCount = 0;
        state.flowing = false;
        if (dest) dest.emit("unpipe", this, unpipeInfo);
        return this;
      }
      if (!dest) {
        var dests = state.pipes;
        var len = state.pipesCount;
        state.pipes = null;
        state.pipesCount = 0;
        state.flowing = false;
        for (var i = 0; i < len; i++) {
          dests[i].emit("unpipe", this, { hasUnpiped: false });
        }
        return this;
      }
      var index = indexOf(state.pipes, dest);
      if (index === -1) return this;
      state.pipes.splice(index, 1);
      state.pipesCount -= 1;
      if (state.pipesCount === 1) state.pipes = state.pipes[0];
      dest.emit("unpipe", this, unpipeInfo);
      return this;
    };
    Readable2.prototype.on = function(ev, fn) {
      var res = Stream.prototype.on.call(this, ev, fn);
      if (ev === "data") {
        if (this._readableState.flowing !== false) this.resume();
      } else if (ev === "readable") {
        var state = this._readableState;
        if (!state.endEmitted && !state.readableListening) {
          state.readableListening = state.needReadable = true;
          state.emittedReadable = false;
          if (!state.reading) {
            pna.nextTick(nReadingNextTick, this);
          } else if (state.length) {
            emitReadable(this);
          }
        }
      }
      return res;
    };
    Readable2.prototype.addListener = Readable2.prototype.on;
    function nReadingNextTick(self2) {
      debug("readable nexttick read 0");
      self2.read(0);
    }
    Readable2.prototype.resume = function() {
      var state = this._readableState;
      if (!state.flowing) {
        debug("resume");
        state.flowing = true;
        resume(this, state);
      }
      return this;
    };
    function resume(stream4, state) {
      if (!state.resumeScheduled) {
        state.resumeScheduled = true;
        pna.nextTick(resume_, stream4, state);
      }
    }
    function resume_(stream4, state) {
      if (!state.reading) {
        debug("resume read 0");
        stream4.read(0);
      }
      state.resumeScheduled = false;
      state.awaitDrain = 0;
      stream4.emit("resume");
      flow(stream4);
      if (state.flowing && !state.reading) stream4.read(0);
    }
    Readable2.prototype.pause = function() {
      debug("call pause flowing=%j", this._readableState.flowing);
      if (false !== this._readableState.flowing) {
        debug("pause");
        this._readableState.flowing = false;
        this.emit("pause");
      }
      return this;
    };
    function flow(stream4) {
      var state = stream4._readableState;
      debug("flow", state.flowing);
      while (state.flowing && stream4.read() !== null) {
      }
    }
    Readable2.prototype.wrap = function(stream4) {
      var _this = this;
      var state = this._readableState;
      var paused = false;
      stream4.on("end", function() {
        debug("wrapped end");
        if (state.decoder && !state.ended) {
          var chunk = state.decoder.end();
          if (chunk && chunk.length) _this.push(chunk);
        }
        _this.push(null);
      });
      stream4.on("data", function(chunk) {
        debug("wrapped data");
        if (state.decoder) chunk = state.decoder.write(chunk);
        if (state.objectMode && (chunk === null || chunk === void 0)) return;
        else if (!state.objectMode && (!chunk || !chunk.length)) return;
        var ret = _this.push(chunk);
        if (!ret) {
          paused = true;
          stream4.pause();
        }
      });
      for (var i in stream4) {
        if (this[i] === void 0 && typeof stream4[i] === "function") {
          this[i] = /* @__PURE__ */ (function(method) {
            return function() {
              return stream4[method].apply(stream4, arguments);
            };
          })(i);
        }
      }
      for (var n = 0; n < kProxyEvents.length; n++) {
        stream4.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
      }
      this._read = function(n2) {
        debug("wrapped _read", n2);
        if (paused) {
          paused = false;
          stream4.resume();
        }
      };
      return this;
    };
    Object.defineProperty(Readable2.prototype, "readableHighWaterMark", {
      // making it explicit this property is not enumerable
      // because otherwise some prototype manipulation in
      // userland will fail
      enumerable: false,
      get: function() {
        return this._readableState.highWaterMark;
      }
    });
    Readable2._fromList = fromList;
    function fromList(n, state) {
      if (state.length === 0) return null;
      var ret;
      if (state.objectMode) ret = state.buffer.shift();
      else if (!n || n >= state.length) {
        if (state.decoder) ret = state.buffer.join("");
        else if (state.buffer.length === 1) ret = state.buffer.head.data;
        else ret = state.buffer.concat(state.length);
        state.buffer.clear();
      } else {
        ret = fromListPartial(n, state.buffer, state.decoder);
      }
      return ret;
    }
    function fromListPartial(n, list2, hasStrings) {
      var ret;
      if (n < list2.head.data.length) {
        ret = list2.head.data.slice(0, n);
        list2.head.data = list2.head.data.slice(n);
      } else if (n === list2.head.data.length) {
        ret = list2.shift();
      } else {
        ret = hasStrings ? copyFromBufferString(n, list2) : copyFromBuffer(n, list2);
      }
      return ret;
    }
    function copyFromBufferString(n, list2) {
      var p3 = list2.head;
      var c = 1;
      var ret = p3.data;
      n -= ret.length;
      while (p3 = p3.next) {
        var str = p3.data;
        var nb = n > str.length ? str.length : n;
        if (nb === str.length) ret += str;
        else ret += str.slice(0, n);
        n -= nb;
        if (n === 0) {
          if (nb === str.length) {
            ++c;
            if (p3.next) list2.head = p3.next;
            else list2.head = list2.tail = null;
          } else {
            list2.head = p3;
            p3.data = str.slice(nb);
          }
          break;
        }
        ++c;
      }
      list2.length -= c;
      return ret;
    }
    function copyFromBuffer(n, list2) {
      var ret = Buffer3.allocUnsafe(n);
      var p3 = list2.head;
      var c = 1;
      p3.data.copy(ret);
      n -= p3.data.length;
      while (p3 = p3.next) {
        var buf = p3.data;
        var nb = n > buf.length ? buf.length : n;
        buf.copy(ret, ret.length - n, 0, nb);
        n -= nb;
        if (n === 0) {
          if (nb === buf.length) {
            ++c;
            if (p3.next) list2.head = p3.next;
            else list2.head = list2.tail = null;
          } else {
            list2.head = p3;
            p3.data = buf.slice(nb);
          }
          break;
        }
        ++c;
      }
      list2.length -= c;
      return ret;
    }
    function endReadable(stream4) {
      var state = stream4._readableState;
      if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
      if (!state.endEmitted) {
        state.ended = true;
        pna.nextTick(endReadableNT, state, stream4);
      }
    }
    function endReadableNT(state, stream4) {
      if (!state.endEmitted && state.length === 0) {
        state.endEmitted = true;
        stream4.readable = false;
        stream4.emit("end");
      }
    }
    function indexOf(xs, x) {
      for (var i = 0, l = xs.length; i < l; i++) {
        if (xs[i] === x) return i;
      }
      return -1;
    }
  }
});

// node_modules/tar-stream/node_modules/readable-stream/lib/_stream_transform.js
var require_stream_transform = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/lib/_stream_transform.js"(exports2, module2) {
    "use strict";
    module2.exports = Transform;
    var Duplex = require_stream_duplex();
    var util4 = Object.create(require_util6());
    util4.inherits = require_inherits();
    util4.inherits(Transform, Duplex);
    function afterTransform(er, data) {
      var ts = this._transformState;
      ts.transforming = false;
      var cb = ts.writecb;
      if (!cb) {
        return this.emit("error", new Error("write callback called multiple times"));
      }
      ts.writechunk = null;
      ts.writecb = null;
      if (data != null)
        this.push(data);
      cb(er);
      var rs = this._readableState;
      rs.reading = false;
      if (rs.needReadable || rs.length < rs.highWaterMark) {
        this._read(rs.highWaterMark);
      }
    }
    function Transform(options) {
      if (!(this instanceof Transform)) return new Transform(options);
      Duplex.call(this, options);
      this._transformState = {
        afterTransform: afterTransform.bind(this),
        needTransform: false,
        transforming: false,
        writecb: null,
        writechunk: null,
        writeencoding: null
      };
      this._readableState.needReadable = true;
      this._readableState.sync = false;
      if (options) {
        if (typeof options.transform === "function") this._transform = options.transform;
        if (typeof options.flush === "function") this._flush = options.flush;
      }
      this.on("prefinish", prefinish);
    }
    function prefinish() {
      var _this = this;
      if (typeof this._flush === "function") {
        this._flush(function(er, data) {
          done(_this, er, data);
        });
      } else {
        done(this, null, null);
      }
    }
    Transform.prototype.push = function(chunk, encoding) {
      this._transformState.needTransform = false;
      return Duplex.prototype.push.call(this, chunk, encoding);
    };
    Transform.prototype._transform = function(chunk, encoding, cb) {
      throw new Error("_transform() is not implemented");
    };
    Transform.prototype._write = function(chunk, encoding, cb) {
      var ts = this._transformState;
      ts.writecb = cb;
      ts.writechunk = chunk;
      ts.writeencoding = encoding;
      if (!ts.transforming) {
        var rs = this._readableState;
        if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
      }
    };
    Transform.prototype._read = function(n) {
      var ts = this._transformState;
      if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
        ts.transforming = true;
        this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
      } else {
        ts.needTransform = true;
      }
    };
    Transform.prototype._destroy = function(err, cb) {
      var _this2 = this;
      Duplex.prototype._destroy.call(this, err, function(err2) {
        cb(err2);
        _this2.emit("close");
      });
    };
    function done(stream4, er, data) {
      if (er) return stream4.emit("error", er);
      if (data != null)
        stream4.push(data);
      if (stream4._writableState.length) throw new Error("Calling transform done when ws.length != 0");
      if (stream4._transformState.transforming) throw new Error("Calling transform done when still transforming");
      return stream4.push(null);
    }
  }
});

// node_modules/tar-stream/node_modules/readable-stream/lib/_stream_passthrough.js
var require_stream_passthrough = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/lib/_stream_passthrough.js"(exports2, module2) {
    "use strict";
    module2.exports = PassThrough;
    var Transform = require_stream_transform();
    var util4 = Object.create(require_util6());
    util4.inherits = require_inherits();
    util4.inherits(PassThrough, Transform);
    function PassThrough(options) {
      if (!(this instanceof PassThrough)) return new PassThrough(options);
      Transform.call(this, options);
    }
    PassThrough.prototype._transform = function(chunk, encoding, cb) {
      cb(null, chunk);
    };
  }
});

// node_modules/tar-stream/node_modules/readable-stream/readable.js
var require_readable = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/readable.js"(exports2, module2) {
    "use strict";
    var Stream = require("stream");
    if (process.env.READABLE_STREAM === "disable" && Stream) {
      module2.exports = Stream;
      exports2 = module2.exports = Stream.Readable;
      exports2.Readable = Stream.Readable;
      exports2.Writable = Stream.Writable;
      exports2.Duplex = Stream.Duplex;
      exports2.Transform = Stream.Transform;
      exports2.PassThrough = Stream.PassThrough;
      exports2.Stream = Stream;
    } else {
      exports2 = module2.exports = require_stream_readable();
      exports2.Stream = Stream || exports2;
      exports2.Readable = exports2;
      exports2.Writable = require_stream_writable();
      exports2.Duplex = require_stream_duplex();
      exports2.Transform = require_stream_transform();
      exports2.PassThrough = require_stream_passthrough();
    }
  }
});

// node_modules/tar-stream/node_modules/readable-stream/duplex.js
var require_duplex = __commonJS({
  "node_modules/tar-stream/node_modules/readable-stream/duplex.js"(exports2, module2) {
    "use strict";
    module2.exports = require_readable().Duplex;
  }
});

// node_modules/tar-stream/node_modules/bl/bl.js
var require_bl = __commonJS({
  "node_modules/tar-stream/node_modules/bl/bl.js"(exports2, module2) {
    "use strict";
    var DuplexStream = require_duplex();
    var util4 = require("util");
    var Buffer3 = require_safe_buffer2().Buffer;
    function BufferList(callback) {
      if (!(this instanceof BufferList))
        return new BufferList(callback);
      this._bufs = [];
      this.length = 0;
      if (typeof callback == "function") {
        this._callback = callback;
        var piper = function piper2(err) {
          if (this._callback) {
            this._callback(err);
            this._callback = null;
          }
        }.bind(this);
        this.on("pipe", function onPipe(src) {
          src.on("error", piper);
        });
        this.on("unpipe", function onUnpipe(src) {
          src.removeListener("error", piper);
        });
      } else {
        this.append(callback);
      }
      DuplexStream.call(this);
    }
    util4.inherits(BufferList, DuplexStream);
    BufferList.prototype._offset = function _offset(offset) {
      var tot = 0, i = 0, _t;
      if (offset === 0) return [0, 0];
      for (; i < this._bufs.length; i++) {
        _t = tot + this._bufs[i].length;
        if (offset < _t || i == this._bufs.length - 1)
          return [i, offset - tot];
        tot = _t;
      }
    };
    BufferList.prototype.append = function append2(buf) {
      var i = 0;
      if (Buffer3.isBuffer(buf)) {
        this._appendBuffer(buf);
      } else if (Array.isArray(buf)) {
        for (; i < buf.length; i++)
          this.append(buf[i]);
      } else if (buf instanceof BufferList) {
        for (; i < buf._bufs.length; i++)
          this.append(buf._bufs[i]);
      } else if (buf != null) {
        if (typeof buf == "number")
          buf = buf.toString();
        this._appendBuffer(Buffer3.from(buf));
      }
      return this;
    };
    BufferList.prototype._appendBuffer = function appendBuffer(buf) {
      this._bufs.push(buf);
      this.length += buf.length;
    };
    BufferList.prototype._write = function _write(buf, encoding, callback) {
      this._appendBuffer(buf);
      if (typeof callback == "function")
        callback();
    };
    BufferList.prototype._read = function _read(size) {
      if (!this.length)
        return this.push(null);
      size = Math.min(size, this.length);
      this.push(this.slice(0, size));
      this.consume(size);
    };
    BufferList.prototype.end = function end(chunk) {
      DuplexStream.prototype.end.call(this, chunk);
      if (this._callback) {
        this._callback(null, this.slice());
        this._callback = null;
      }
    };
    BufferList.prototype.get = function get2(index) {
      return this.slice(index, index + 1)[0];
    };
    BufferList.prototype.slice = function slice(start, end) {
      if (typeof start == "number" && start < 0)
        start += this.length;
      if (typeof end == "number" && end < 0)
        end += this.length;
      return this.copy(null, 0, start, end);
    };
    BufferList.prototype.copy = function copy(dst, dstStart, srcStart, srcEnd) {
      if (typeof srcStart != "number" || srcStart < 0)
        srcStart = 0;
      if (typeof srcEnd != "number" || srcEnd > this.length)
        srcEnd = this.length;
      if (srcStart >= this.length)
        return dst || Buffer3.alloc(0);
      if (srcEnd <= 0)
        return dst || Buffer3.alloc(0);
      var copy2 = !!dst, off = this._offset(srcStart), len = srcEnd - srcStart, bytes = len, bufoff = copy2 && dstStart || 0, start = off[1], l, i;
      if (srcStart === 0 && srcEnd == this.length) {
        if (!copy2) {
          return this._bufs.length === 1 ? this._bufs[0] : Buffer3.concat(this._bufs, this.length);
        }
        for (i = 0; i < this._bufs.length; i++) {
          this._bufs[i].copy(dst, bufoff);
          bufoff += this._bufs[i].length;
        }
        return dst;
      }
      if (bytes <= this._bufs[off[0]].length - start) {
        return copy2 ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes) : this._bufs[off[0]].slice(start, start + bytes);
      }
      if (!copy2)
        dst = Buffer3.allocUnsafe(len);
      for (i = off[0]; i < this._bufs.length; i++) {
        l = this._bufs[i].length - start;
        if (bytes > l) {
          this._bufs[i].copy(dst, bufoff, start);
          bufoff += l;
        } else {
          this._bufs[i].copy(dst, bufoff, start, start + bytes);
          bufoff += l;
          break;
        }
        bytes -= l;
        if (start)
          start = 0;
      }
      if (dst.length > bufoff) return dst.slice(0, bufoff);
      return dst;
    };
    BufferList.prototype.shallowSlice = function shallowSlice(start, end) {
      start = start || 0;
      end = end || this.length;
      if (start < 0)
        start += this.length;
      if (end < 0)
        end += this.length;
      var startOffset = this._offset(start), endOffset = this._offset(end), buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1);
      if (endOffset[1] == 0)
        buffers.pop();
      else
        buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1]);
      if (startOffset[1] != 0)
        buffers[0] = buffers[0].slice(startOffset[1]);
      return new BufferList(buffers);
    };
    BufferList.prototype.toString = function toString4(encoding, start, end) {
      return this.slice(start, end).toString(encoding);
    };
    BufferList.prototype.consume = function consume(bytes) {
      bytes = Math.trunc(bytes);
      if (Number.isNaN(bytes) || bytes <= 0) return this;
      while (this._bufs.length) {
        if (bytes >= this._bufs[0].length) {
          bytes -= this._bufs[0].length;
          this.length -= this._bufs[0].length;
          this._bufs.shift();
        } else {
          this._bufs[0] = this._bufs[0].slice(bytes);
          this.length -= bytes;
          break;
        }
      }
      return this;
    };
    BufferList.prototype.duplicate = function duplicate() {
      var i = 0, copy = new BufferList();
      for (; i < this._bufs.length; i++)
        copy.append(this._bufs[i]);
      return copy;
    };
    BufferList.prototype.destroy = function destroy() {
      this._bufs.length = 0;
      this.length = 0;
      this.push(null);
    };
    (function() {
      var methods = {
        "readDoubleBE": 8,
        "readDoubleLE": 8,
        "readFloatBE": 4,
        "readFloatLE": 4,
        "readInt32BE": 4,
        "readInt32LE": 4,
        "readUInt32BE": 4,
        "readUInt32LE": 4,
        "readInt16BE": 2,
        "readInt16LE": 2,
        "readUInt16BE": 2,
        "readUInt16LE": 2,
        "readInt8": 1,
        "readUInt8": 1
      };
      for (var m in methods) {
        (function(m2) {
          BufferList.prototype[m2] = function(offset) {
            return this.slice(offset, offset + methods[m2])[m2](0);
          };
        })(m);
      }
    })();
    module2.exports = BufferList;
  }
});

// node_modules/xtend/immutable.js
var require_immutable = __commonJS({
  "node_modules/xtend/immutable.js"(exports2, module2) {
    "use strict";
    module2.exports = extend4;
    var hasOwnProperty11 = Object.prototype.hasOwnProperty;
    function extend4() {
      var target = {};
      for (var i = 0; i < arguments.length; i++) {
        var source = arguments[i];
        for (var key in source) {
          if (hasOwnProperty11.call(source, key)) {
            target[key] = source[key];
          }
        }
      }
      return target;
    }
  }
});

// node_modules/isarray/index.js
var require_isarray2 = __commonJS({
  "node_modules/isarray/index.js"(exports2, module2) {
    "use strict";
    var toString4 = {}.toString;
    module2.exports = Array.isArray || function(arr) {
      return toString4.call(arr) == "[object Array]";
    };
  }
});

// node_modules/is-callable/index.js
var require_is_callable = __commonJS({
  "node_modules/is-callable/index.js"(exports2, module2) {
    "use strict";
    var fnToStr = Function.prototype.toString;
    var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
    var badArrayLike;
    var isCallableMarker;
    if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") {
      try {
        badArrayLike = Object.defineProperty({}, "length", {
          get: function() {
            throw isCallableMarker;
          }
        });
        isCallableMarker = {};
        reflectApply(function() {
          throw 42;
        }, null, badArrayLike);
      } catch (_) {
        if (_ !== isCallableMarker) {
          reflectApply = null;
        }
      }
    } else {
      reflectApply = null;
    }
    var constructorRegex = /^\s*class\b/;
    var isES6ClassFn = function isES6ClassFunction(value) {
      try {
        var fnStr = fnToStr.call(value);
        return constructorRegex.test(fnStr);
      } catch (e) {
        return false;
      }
    };
    var tryFunctionObject = function tryFunctionToStr(value) {
      try {
        if (isES6ClassFn(value)) {
          return false;
        }
        fnToStr.call(value);
        return true;
      } catch (e) {
        return false;
      }
    };
    var toStr = Object.prototype.toString;
    var objectClass = "[object Object]";
    var fnClass = "[object Function]";
    var genClass = "[object GeneratorFunction]";
    var ddaClass = "[object HTMLAllCollection]";
    var ddaClass2 = "[object HTML document.all class]";
    var ddaClass3 = "[object HTMLCollection]";
    var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
    var isIE68 = !(0 in [,]);
    var isDDA = function isDocumentDotAll() {
      return false;
    };
    if (typeof document === "object") {
      all3 = document.all;
      if (toStr.call(all3) === toStr.call(document.all)) {
        isDDA = function isDocumentDotAll(value) {
          if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
            try {
              var str = toStr.call(value);
              return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
            } catch (e) {
            }
          }
          return false;
        };
      }
    }
    var all3;
    module2.exports = reflectApply ? function isCallable(value) {
      if (isDDA(value)) {
        return true;
      }
      if (!value) {
        return false;
      }
      if (typeof value !== "function" && typeof value !== "object") {
        return false;
      }
      try {
        reflectApply(value, null, badArrayLike);
      } catch (e) {
        if (e !== isCallableMarker) {
          return false;
        }
      }
      return !isES6ClassFn(value) && tryFunctionObject(value);
    } : function isCallable(value) {
      if (isDDA(value)) {
        return true;
      }
      if (!value) {
        return false;
      }
      if (typeof value !== "function" && typeof value !== "object") {
        return false;
      }
      if (hasToStringTag) {
        return tryFunctionObject(value);
      }
      if (isES6ClassFn(value)) {
        return false;
      }
      var strClass = toStr.call(value);
      if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
        return false;
      }
      return tryFunctionObject(value);
    };
  }
});

// node_modules/for-each/index.js
var require_for_each = __commonJS({
  "node_modules/for-each/index.js"(exports2, module2) {
    "use strict";
    var isCallable = require_is_callable();
    var toStr = Object.prototype.toString;
    var hasOwnProperty11 = Object.prototype.hasOwnProperty;
    var forEachArray = function forEachArray2(array4, iterator2, receiver) {
      for (var i = 0, len = array4.length; i < len; i++) {
        if (hasOwnProperty11.call(array4, i)) {
          if (receiver == null) {
            iterator2(array4[i], i, array4);
          } else {
            iterator2.call(receiver, array4[i], i, array4);
          }
        }
      }
    };
    var forEachString = function forEachString2(string5, iterator2, receiver) {
      for (var i = 0, len = string5.length; i < len; i++) {
        if (receiver == null) {
          iterator2(string5.charAt(i), i, string5);
        } else {
          iterator2.call(receiver, string5.charAt(i), i, string5);
        }
      }
    };
    var forEachObject = function forEachObject2(object4, iterator2, receiver) {
      for (var k in object4) {
        if (hasOwnProperty11.call(object4, k)) {
          if (receiver == null) {
            iterator2(object4[k], k, object4);
          } else {
            iterator2.call(receiver, object4[k], k, object4);
          }
        }
      }
    };
    function isArray3(x) {
      return toStr.call(x) === "[object Array]";
    }
    module2.exports = function forEach2(list2, iterator2, thisArg) {
      if (!isCallable(iterator2)) {
        throw new TypeError("iterator must be a function");
      }
      var receiver;
      if (arguments.length >= 3) {
        receiver = thisArg;
      }
      if (isArray3(list2)) {
        forEachArray(list2, iterator2, receiver);
      } else if (typeof list2 === "string") {
        forEachString(list2, iterator2, receiver);
      } else {
        forEachObject(list2, iterator2, receiver);
      }
    };
  }
});

// node_modules/possible-typed-array-names/index.js
var require_possible_typed_array_names = __commonJS({
  "node_modules/possible-typed-array-names/index.js"(exports2, module2) {
    "use strict";
    module2.exports = [
      "Float16Array",
      "Float32Array",
      "Float64Array",
      "Int8Array",
      "Int16Array",
      "Int32Array",
      "Uint8Array",
      "Uint8ClampedArray",
      "Uint16Array",
      "Uint32Array",
      "BigInt64Array",
      "BigUint64Array"
    ];
  }
});

// node_modules/available-typed-arrays/index.js
var require_available_typed_arrays = __commonJS({
  "node_modules/available-typed-arrays/index.js"(exports2, module2) {
    "use strict";
    var possibleNames = require_possible_typed_array_names();
    var g = typeof globalThis === "undefined" ? global : globalThis;
    module2.exports = function availableTypedArrays() {
      var out = [];
      for (var i = 0; i < possibleNames.length; i++) {
        if (typeof g[possibleNames[i]] === "function") {
          out[out.length] = possibleNames[i];
        }
      }
      return out;
    };
  }
});

// node_modules/define-data-property/index.js
var require_define_data_property = __commonJS({
  "node_modules/define-data-property/index.js"(exports2, module2) {
    "use strict";
    var $defineProperty = require_es_define_property();
    var $SyntaxError = require_syntax();
    var $TypeError = require_type();
    var gopd = require_gopd();
    module2.exports = function defineDataProperty(obj, property2, value) {
      if (!obj || typeof obj !== "object" && typeof obj !== "function") {
        throw new $TypeError("`obj` must be an object or a function`");
      }
      if (typeof property2 !== "string" && typeof property2 !== "symbol") {
        throw new $TypeError("`property` must be a string or a symbol`");
      }
      if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
        throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
      }
      if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
        throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
      }
      if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
        throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
      }
      if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
        throw new $TypeError("`loose`, if provided, must be a boolean");
      }
      var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
      var nonWritable = arguments.length > 4 ? arguments[4] : null;
      var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
      var loose = arguments.length > 6 ? arguments[6] : false;
      var desc = !!gopd && gopd(obj, property2);
      if ($defineProperty) {
        $defineProperty(obj, property2, {
          configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
          enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
          value,
          writable: nonWritable === null && desc ? desc.writable : !nonWritable
        });
      } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
        obj[property2] = value;
      } else {
        throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
      }
    };
  }
});

// node_modules/has-property-descriptors/index.js
var require_has_property_descriptors = __commonJS({
  "node_modules/has-property-descriptors/index.js"(exports2, module2) {
    "use strict";
    var $defineProperty = require_es_define_property();
    var hasPropertyDescriptors = function hasPropertyDescriptors2() {
      return !!$defineProperty;
    };
    hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
      if (!$defineProperty) {
        return null;
      }
      try {
        return $defineProperty([], "length", { value: 1 }).length !== 1;
      } catch (e) {
        return true;
      }
    };
    module2.exports = hasPropertyDescriptors;
  }
});

// node_modules/set-function-length/index.js
var require_set_function_length = __commonJS({
  "node_modules/set-function-length/index.js"(exports2, module2) {
    "use strict";
    var GetIntrinsic = require_get_intrinsic();
    var define2 = require_define_data_property();
    var hasDescriptors = require_has_property_descriptors()();
    var gOPD = require_gopd();
    var $TypeError = require_type();
    var $floor = GetIntrinsic("%Math.floor%");
    module2.exports = function setFunctionLength(fn, length) {
      if (typeof fn !== "function") {
        throw new $TypeError("`fn` is not a function");
      }
      if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) {
        throw new $TypeError("`length` must be a positive 32-bit integer");
      }
      var loose = arguments.length > 2 && !!arguments[2];
      var functionLengthIsConfigurable = true;
      var functionLengthIsWritable = true;
      if ("length" in fn && gOPD) {
        var desc = gOPD(fn, "length");
        if (desc && !desc.configurable) {
          functionLengthIsConfigurable = false;
        }
        if (desc && !desc.writable) {
          functionLengthIsWritable = false;
        }
      }
      if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
        if (hasDescriptors) {
          define2(
            /** @type {Parameters<define>[0]} */
            fn,
            "length",
            length,
            true,
            true
          );
        } else {
          define2(
            /** @type {Parameters<define>[0]} */
            fn,
            "length",
            length
          );
        }
      }
      return fn;
    };
  }
});

// node_modules/call-bind-apply-helpers/applyBind.js
var require_applyBind = __commonJS({
  "node_modules/call-bind-apply-helpers/applyBind.js"(exports2, module2) {
    "use strict";
    var bind2 = require_function_bind();
    var $apply = require_functionApply();
    var actualApply = require_actualApply();
    module2.exports = function applyBind() {
      return actualApply(bind2, $apply, arguments);
    };
  }
});

// node_modules/call-bind/index.js
var require_call_bind = __commonJS({
  "node_modules/call-bind/index.js"(exports2, module2) {
    "use strict";
    var setFunctionLength = require_set_function_length();
    var $defineProperty = require_es_define_property();
    var callBindBasic = require_call_bind_apply_helpers();
    var applyBind = require_applyBind();
    module2.exports = function callBind(originalFunction) {
      var func = callBindBasic(arguments);
      var adjustedLength = originalFunction.length - (arguments.length - 1);
      return setFunctionLength(
        func,
        1 + (adjustedLength > 0 ? adjustedLength : 0),
        true
      );
    };
    if ($defineProperty) {
      $defineProperty(module2.exports, "apply", { value: applyBind });
    } else {
      module2.exports.apply = applyBind;
    }
  }
});

// node_modules/which-typed-array/index.js
var require_which_typed_array = __commonJS({
  "node_modules/which-typed-array/index.js"(exports2, module2) {
    "use strict";
    var forEach2 = require_for_each();
    var availableTypedArrays = require_available_typed_arrays();
    var callBind = require_call_bind();
    var callBound = require_call_bound();
    var gOPD = require_gopd();
    var getProto = require_get_proto();
    var $toString = callBound("Object.prototype.toString");
    var hasToStringTag = require_shams2()();
    var g = typeof globalThis === "undefined" ? global : globalThis;
    var typedArrays = availableTypedArrays();
    var $slice = callBound("String.prototype.slice");
    var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array4, value) {
      for (var i = 0; i < array4.length; i += 1) {
        if (array4[i] === value) {
          return i;
        }
      }
      return -1;
    };
    var cache = { __proto__: null };
    if (hasToStringTag && gOPD && getProto) {
      forEach2(typedArrays, function(typedArray) {
        var arr = new g[typedArray]();
        if (Symbol.toStringTag in arr && getProto) {
          var proto = getProto(arr);
          var descriptor = gOPD(proto, Symbol.toStringTag);
          if (!descriptor && proto) {
            var superProto = getProto(proto);
            descriptor = gOPD(superProto, Symbol.toStringTag);
          }
          if (descriptor && descriptor.get) {
            var bound = callBind(descriptor.get);
            cache[
              /** @type {`$${import('.').TypedArrayName}`} */
              "$" + typedArray
            ] = bound;
          }
        }
      });
    } else {
      forEach2(typedArrays, function(typedArray) {
        var arr = new g[typedArray]();
        var fn = arr.slice || arr.set;
        if (fn) {
          var bound = (
            /** @type {import('./types').BoundSlice | import('./types').BoundSet} */
            // @ts-expect-error TODO FIXME
            callBind(fn)
          );
          cache[
            /** @type {`$${import('.').TypedArrayName}`} */
            "$" + typedArray
          ] = bound;
        }
      });
    }
    var tryTypedArrays = function tryAllTypedArrays(value) {
      var found = false;
      forEach2(
        /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
        cache,
        /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
        function(getter, typedArray) {
          if (!found) {
            try {
              if ("$" + getter(value) === typedArray) {
                found = /** @type {import('.').TypedArrayName} */
                $slice(typedArray, 1);
              }
            } catch (e) {
            }
          }
        }
      );
      return found;
    };
    var trySlices = function tryAllSlices(value) {
      var found = false;
      forEach2(
        /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
        cache,
        /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
        function(getter, name28) {
          if (!found) {
            try {
              getter(value);
              found = /** @type {import('.').TypedArrayName} */
              $slice(name28, 1);
            } catch (e) {
            }
          }
        }
      );
      return found;
    };
    module2.exports = function whichTypedArray(value) {
      if (!value || typeof value !== "object") {
        return false;
      }
      if (!hasToStringTag) {
        var tag = $slice($toString(value), 8, -1);
        if ($indexOf(typedArrays, tag) > -1) {
          return tag;
        }
        if (tag !== "Object") {
          return false;
        }
        return trySlices(value);
      }
      if (!gOPD) {
        return null;
      }
      return tryTypedArrays(value);
    };
  }
});

// node_modules/is-typed-array/index.js
var require_is_typed_array = __commonJS({
  "node_modules/is-typed-array/index.js"(exports2, module2) {
    "use strict";
    var whichTypedArray = require_which_typed_array();
    module2.exports = function isTypedArray3(value) {
      return !!whichTypedArray(value);
    };
  }
});

// node_modules/typed-array-buffer/index.js
var require_typed_array_buffer = __commonJS({
  "node_modules/typed-array-buffer/index.js"(exports2, module2) {
    "use strict";
    var $TypeError = require_type();
    var callBound = require_call_bound();
    var $typedArrayBuffer = callBound("TypedArray.prototype.buffer", true);
    var isTypedArray3 = require_is_typed_array();
    module2.exports = $typedArrayBuffer || function typedArrayBuffer(x) {
      if (!isTypedArray3(x)) {
        throw new $TypeError("Not a Typed Array");
      }
      return x.buffer;
    };
  }
});

// node_modules/to-buffer/index.js
var require_to_buffer = __commonJS({
  "node_modules/to-buffer/index.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safe_buffer2().Buffer;
    var isArray3 = require_isarray2();
    var typedArrayBuffer = require_typed_array_buffer();
    var isView = ArrayBuffer.isView || function isView2(obj) {
      try {
        typedArrayBuffer(obj);
        return true;
      } catch (e) {
        return false;
      }
    };
    var useUint8Array = typeof Uint8Array !== "undefined";
    var useArrayBuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
    var useFromArrayBuffer = useArrayBuffer && (Buffer3.prototype instanceof Uint8Array || Buffer3.TYPED_ARRAY_SUPPORT);
    module2.exports = function toBuffer(data, encoding) {
      if (Buffer3.isBuffer(data)) {
        if (data.constructor && !("isBuffer" in data)) {
          return Buffer3.from(data);
        }
        return data;
      }
      if (typeof data === "string") {
        return Buffer3.from(data, encoding);
      }
      if (useArrayBuffer && isView(data)) {
        if (data.byteLength === 0) {
          return Buffer3.alloc(0);
        }
        if (useFromArrayBuffer) {
          var res = Buffer3.from(data.buffer, data.byteOffset, data.byteLength);
          if (res.byteLength === data.byteLength) {
            return res;
          }
        }
        var uint8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
        var result = Buffer3.from(uint8);
        if (result.length === data.byteLength) {
          return result;
        }
      }
      if (useUint8Array && data instanceof Uint8Array) {
        return Buffer3.from(data);
      }
      var isArr = isArray3(data);
      if (isArr) {
        for (var i = 0; i < data.length; i += 1) {
          var x = data[i];
          if (typeof x !== "number" || x < 0 || x > 255 || ~~x !== x) {
            throw new RangeError("Array items must be numbers in the range 0-255.");
          }
        }
      }
      if (isArr || Buffer3.isBuffer(data) && data.constructor && typeof data.constructor.isBuffer === "function" && data.constructor.isBuffer(data)) {
        return Buffer3.from(data);
      }
      throw new TypeError('The "data" argument must be a string, an Array, a Buffer, a Uint8Array, or a DataView.');
    };
  }
});

// node_modules/buffer-fill/index.js
var require_buffer_fill = __commonJS({
  "node_modules/buffer-fill/index.js"(exports2, module2) {
    "use strict";
    var hasFullSupport = (function() {
      try {
        if (!Buffer.isEncoding("latin1")) {
          return false;
        }
        var buf = Buffer.alloc ? Buffer.alloc(4) : new Buffer(4);
        buf.fill("ab", "ucs2");
        return buf.toString("hex") === "61006200";
      } catch (_) {
        return false;
      }
    })();
    function isSingleByte(val) {
      return val.length === 1 && val.charCodeAt(0) < 256;
    }
    function fillWithNumber(buffer, val, start, end) {
      if (start < 0 || end > buffer.length) {
        throw new RangeError("Out of range index");
      }
      start = start >>> 0;
      end = end === void 0 ? buffer.length : end >>> 0;
      if (end > start) {
        buffer.fill(val, start, end);
      }
      return buffer;
    }
    function fillWithBuffer(buffer, val, start, end) {
      if (start < 0 || end > buffer.length) {
        throw new RangeError("Out of range index");
      }
      if (end <= start) {
        return buffer;
      }
      start = start >>> 0;
      end = end === void 0 ? buffer.length : end >>> 0;
      var pos = start;
      var len = val.length;
      while (pos <= end - len) {
        val.copy(buffer, pos);
        pos += len;
      }
      if (pos !== end) {
        val.copy(buffer, pos, 0, end - pos);
      }
      return buffer;
    }
    function fill(buffer, val, start, end, encoding) {
      if (hasFullSupport) {
        return buffer.fill(val, start, end, encoding);
      }
      if (typeof val === "number") {
        return fillWithNumber(buffer, val, start, end);
      }
      if (typeof val === "string") {
        if (typeof start === "string") {
          encoding = start;
          start = 0;
          end = buffer.length;
        } else if (typeof end === "string") {
          encoding = end;
          end = buffer.length;
        }
        if (encoding !== void 0 && typeof encoding !== "string") {
          throw new TypeError("encoding must be a string");
        }
        if (encoding === "latin1") {
          encoding = "binary";
        }
        if (typeof encoding === "string" && !Buffer.isEncoding(encoding)) {
          throw new TypeError("Unknown encoding: " + encoding);
        }
        if (val === "") {
          return fillWithNumber(buffer, 0, start, end);
        }
        if (isSingleByte(val)) {
          return fillWithNumber(buffer, val.charCodeAt(0), start, end);
        }
        val = new Buffer(val, encoding);
      }
      if (Buffer.isBuffer(val)) {
        return fillWithBuffer(buffer, val, start, end);
      }
      return fillWithNumber(buffer, 0, start, end);
    }
    module2.exports = fill;
  }
});

// node_modules/buffer-alloc-unsafe/index.js
var require_buffer_alloc_unsafe = __commonJS({
  "node_modules/buffer-alloc-unsafe/index.js"(exports2, module2) {
    "use strict";
    function allocUnsafe(size) {
      if (typeof size !== "number") {
        throw new TypeError('"size" argument must be a number');
      }
      if (size < 0) {
        throw new RangeError('"size" argument must not be negative');
      }
      if (Buffer.allocUnsafe) {
        return Buffer.allocUnsafe(size);
      } else {
        return new Buffer(size);
      }
    }
    module2.exports = allocUnsafe;
  }
});

// node_modules/buffer-alloc/index.js
var require_buffer_alloc = __commonJS({
  "node_modules/buffer-alloc/index.js"(exports2, module2) {
    "use strict";
    var bufferFill = require_buffer_fill();
    var allocUnsafe = require_buffer_alloc_unsafe();
    module2.exports = function alloc(size, fill, encoding) {
      if (typeof size !== "number") {
        throw new TypeError('"size" argument must be a number');
      }
      if (size < 0) {
        throw new RangeError('"size" argument must not be negative');
      }
      if (Buffer.alloc) {
        return Buffer.alloc(size, fill, encoding);
      }
      var buffer = allocUnsafe(size);
      if (size === 0) {
        return buffer;
      }
      if (fill === void 0) {
        return bufferFill(buffer, 0);
      }
      if (typeof encoding !== "string") {
        encoding = void 0;
      }
      return bufferFill(buffer, fill, encoding);
    };
  }
});

// node_modules/tar-stream/headers.js
var require_headers = __commonJS({
  "node_modules/tar-stream/headers.js"(exports2) {
    "use strict";
    var toBuffer = require_to_buffer();
    var alloc = require_buffer_alloc();
    var ZEROS = "0000000000000000000";
    var SEVENS = "7777777777777777777";
    var ZERO_OFFSET = "0".charCodeAt(0);
    var USTAR = "ustar\x0000";
    var MASK = parseInt("7777", 8);
    var clamp = function(index, len, defaultValue) {
      if (typeof index !== "number") return defaultValue;
      index = ~~index;
      if (index >= len) return len;
      if (index >= 0) return index;
      index += len;
      if (index >= 0) return index;
      return 0;
    };
    var toType = function(flag) {
      switch (flag) {
        case 0:
          return "file";
        case 1:
          return "link";
        case 2:
          return "symlink";
        case 3:
          return "character-device";
        case 4:
          return "block-device";
        case 5:
          return "directory";
        case 6:
          return "fifo";
        case 7:
          return "contiguous-file";
        case 72:
          return "pax-header";
        case 55:
          return "pax-global-header";
        case 27:
          return "gnu-long-link-path";
        case 28:
        case 30:
          return "gnu-long-path";
      }
      return null;
    };
    var toTypeflag = function(flag) {
      switch (flag) {
        case "file":
          return 0;
        case "link":
          return 1;
        case "symlink":
          return 2;
        case "character-device":
          return 3;
        case "block-device":
          return 4;
        case "directory":
          return 5;
        case "fifo":
          return 6;
        case "contiguous-file":
          return 7;
        case "pax-header":
          return 72;
      }
      return 0;
    };
    var indexOf = function(block, num, offset, end) {
      for (; offset < end; offset++) {
        if (block[offset] === num) return offset;
      }
      return end;
    };
    var cksum = function(block) {
      var sum = 8 * 32;
      for (var i = 0; i < 148; i++) sum += block[i];
      for (var j = 156; j < 512; j++) sum += block[j];
      return sum;
    };
    var encodeOct = function(val, n) {
      val = val.toString(8);
      if (val.length > n) return SEVENS.slice(0, n) + " ";
      else return ZEROS.slice(0, n - val.length) + val + " ";
    };
    function parse256(buf) {
      var positive;
      if (buf[0] === 128) positive = true;
      else if (buf[0] === 255) positive = false;
      else return null;
      var zero = false;
      var tuple3 = [];
      for (var i = buf.length - 1; i > 0; i--) {
        var byte = buf[i];
        if (positive) tuple3.push(byte);
        else if (zero && byte === 0) tuple3.push(0);
        else if (zero) {
          zero = false;
          tuple3.push(256 - byte);
        } else tuple3.push(255 - byte);
      }
      var sum = 0;
      var l = tuple3.length;
      for (i = 0; i < l; i++) {
        sum += tuple3[i] * Math.pow(256, i);
      }
      return positive ? sum : -1 * sum;
    }
    var decodeOct = function(val, offset, length) {
      val = val.slice(offset, offset + length);
      offset = 0;
      if (val[offset] & 128) {
        return parse256(val);
      } else {
        while (offset < val.length && val[offset] === 32) offset++;
        var end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length);
        while (offset < end && val[offset] === 0) offset++;
        if (end === offset) return 0;
        return parseInt(val.slice(offset, end).toString(), 8);
      }
    };
    var decodeStr = function(val, offset, length, encoding) {
      return val.slice(offset, indexOf(val, 0, offset, offset + length)).toString(encoding);
    };
    var addLength = function(str) {
      var len = Buffer.byteLength(str);
      var digits = Math.floor(Math.log(len) / Math.log(10)) + 1;
      if (len + digits >= Math.pow(10, digits)) digits++;
      return len + digits + str;
    };
    exports2.decodeLongPath = function(buf, encoding) {
      return decodeStr(buf, 0, buf.length, encoding);
    };
    exports2.encodePax = function(opts) {
      var result = "";
      if (opts.name) result += addLength(" path=" + opts.name + "\n");
      if (opts.linkname) result += addLength(" linkpath=" + opts.linkname + "\n");
      var pax = opts.pax;
      if (pax) {
        for (var key in pax) {
          result += addLength(" " + key + "=" + pax[key] + "\n");
        }
      }
      return toBuffer(result);
    };
    exports2.decodePax = function(buf) {
      var result = {};
      while (buf.length) {
        var i = 0;
        while (i < buf.length && buf[i] !== 32) i++;
        var len = parseInt(buf.slice(0, i).toString(), 10);
        if (!len) return result;
        var b = buf.slice(i + 1, len - 1).toString();
        var keyIndex = b.indexOf("=");
        if (keyIndex === -1) return result;
        result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1);
        buf = buf.slice(len);
      }
      return result;
    };
    exports2.encode = function(opts) {
      var buf = alloc(512);
      var name28 = opts.name;
      var prefix = "";
      if (opts.typeflag === 5 && name28[name28.length - 1] !== "/") name28 += "/";
      if (Buffer.byteLength(name28) !== name28.length) return null;
      while (Buffer.byteLength(name28) > 100) {
        var i = name28.indexOf("/");
        if (i === -1) return null;
        prefix += prefix ? "/" + name28.slice(0, i) : name28.slice(0, i);
        name28 = name28.slice(i + 1);
      }
      if (Buffer.byteLength(name28) > 100 || Buffer.byteLength(prefix) > 155) return null;
      if (opts.linkname && Buffer.byteLength(opts.linkname) > 100) return null;
      buf.write(name28);
      buf.write(encodeOct(opts.mode & MASK, 6), 100);
      buf.write(encodeOct(opts.uid, 6), 108);
      buf.write(encodeOct(opts.gid, 6), 116);
      buf.write(encodeOct(opts.size, 11), 124);
      buf.write(encodeOct(opts.mtime.getTime() / 1e3 | 0, 11), 136);
      buf[156] = ZERO_OFFSET + toTypeflag(opts.type);
      if (opts.linkname) buf.write(opts.linkname, 157);
      buf.write(USTAR, 257);
      if (opts.uname) buf.write(opts.uname, 265);
      if (opts.gname) buf.write(opts.gname, 297);
      buf.write(encodeOct(opts.devmajor || 0, 6), 329);
      buf.write(encodeOct(opts.devminor || 0, 6), 337);
      if (prefix) buf.write(prefix, 345);
      buf.write(encodeOct(cksum(buf), 6), 148);
      return buf;
    };
    exports2.decode = function(buf, filenameEncoding) {
      var typeflag = buf[156] === 0 ? 0 : buf[156] - ZERO_OFFSET;
      var name28 = decodeStr(buf, 0, 100, filenameEncoding);
      var mode = decodeOct(buf, 100, 8);
      var uid = decodeOct(buf, 108, 8);
      var gid = decodeOct(buf, 116, 8);
      var size = decodeOct(buf, 124, 12);
      var mtime = decodeOct(buf, 136, 12);
      var type = toType(typeflag);
      var linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding);
      var uname = decodeStr(buf, 265, 32);
      var gname = decodeStr(buf, 297, 32);
      var devmajor = decodeOct(buf, 329, 8);
      var devminor = decodeOct(buf, 337, 8);
      if (buf[345]) name28 = decodeStr(buf, 345, 155, filenameEncoding) + "/" + name28;
      if (typeflag === 0 && name28 && name28[name28.length - 1] === "/") typeflag = 5;
      var c = cksum(buf);
      if (c === 8 * 32) return null;
      if (c !== decodeOct(buf, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
      return {
        name: name28,
        mode,
        uid,
        gid,
        size,
        mtime: new Date(1e3 * mtime),
        type,
        linkname,
        uname,
        gname,
        devmajor,
        devminor
      };
    };
  }
});

// node_modules/tar-stream/extract.js
var require_extract = __commonJS({
  "node_modules/tar-stream/extract.js"(exports2, module2) {
    "use strict";
    var util4 = require("util");
    var bl = require_bl();
    var xtend = require_immutable();
    var headers = require_headers();
    var Writable = require_readable().Writable;
    var PassThrough = require_readable().PassThrough;
    var noop4 = function() {
    };
    var overflow = function(size) {
      size &= 511;
      return size && 512 - size;
    };
    var emptyStream = function(self2, offset) {
      var s = new Source(self2, offset);
      s.end();
      return s;
    };
    var mixinPax = function(header, pax) {
      if (pax.path) header.name = pax.path;
      if (pax.linkpath) header.linkname = pax.linkpath;
      if (pax.size) header.size = parseInt(pax.size, 10);
      header.pax = pax;
      return header;
    };
    var Source = function(self2, offset) {
      this._parent = self2;
      this.offset = offset;
      PassThrough.call(this);
    };
    util4.inherits(Source, PassThrough);
    Source.prototype.destroy = function(err) {
      this._parent.destroy(err);
    };
    var Extract = function(opts) {
      if (!(this instanceof Extract)) return new Extract(opts);
      Writable.call(this, opts);
      opts = opts || {};
      this._offset = 0;
      this._buffer = bl();
      this._missing = 0;
      this._partial = false;
      this._onparse = noop4;
      this._header = null;
      this._stream = null;
      this._overflow = null;
      this._cb = null;
      this._locked = false;
      this._destroyed = false;
      this._pax = null;
      this._paxGlobal = null;
      this._gnuLongPath = null;
      this._gnuLongLinkPath = null;
      var self2 = this;
      var b = self2._buffer;
      var oncontinue = function() {
        self2._continue();
      };
      var onunlock = function(err) {
        self2._locked = false;
        if (err) return self2.destroy(err);
        if (!self2._stream) oncontinue();
      };
      var onstreamend = function() {
        self2._stream = null;
        var drain = overflow(self2._header.size);
        if (drain) self2._parse(drain, ondrain);
        else self2._parse(512, onheader);
        if (!self2._locked) oncontinue();
      };
      var ondrain = function() {
        self2._buffer.consume(overflow(self2._header.size));
        self2._parse(512, onheader);
        oncontinue();
      };
      var onpaxglobalheader = function() {
        var size = self2._header.size;
        self2._paxGlobal = headers.decodePax(b.slice(0, size));
        b.consume(size);
        onstreamend();
      };
      var onpaxheader = function() {
        var size = self2._header.size;
        self2._pax = headers.decodePax(b.slice(0, size));
        if (self2._paxGlobal) self2._pax = xtend(self2._paxGlobal, self2._pax);
        b.consume(size);
        onstreamend();
      };
      var ongnulongpath = function() {
        var size = self2._header.size;
        this._gnuLongPath = headers.decodeLongPath(b.slice(0, size), opts.filenameEncoding);
        b.consume(size);
        onstreamend();
      };
      var ongnulonglinkpath = function() {
        var size = self2._header.size;
        this._gnuLongLinkPath = headers.decodeLongPath(b.slice(0, size), opts.filenameEncoding);
        b.consume(size);
        onstreamend();
      };
      var onheader = function() {
        var offset = self2._offset;
        var header;
        try {
          header = self2._header = headers.decode(b.slice(0, 512), opts.filenameEncoding);
        } catch (err) {
          self2.emit("error", err);
        }
        b.consume(512);
        if (!header) {
          self2._parse(512, onheader);
          oncontinue();
          return;
        }
        if (header.type === "gnu-long-path") {
          self2._parse(header.size, ongnulongpath);
          oncontinue();
          return;
        }
        if (header.type === "gnu-long-link-path") {
          self2._parse(header.size, ongnulonglinkpath);
          oncontinue();
          return;
        }
        if (header.type === "pax-global-header") {
          self2._parse(header.size, onpaxglobalheader);
          oncontinue();
          return;
        }
        if (header.type === "pax-header") {
          self2._parse(header.size, onpaxheader);
          oncontinue();
          return;
        }
        if (self2._gnuLongPath) {
          header.name = self2._gnuLongPath;
          self2._gnuLongPath = null;
        }
        if (self2._gnuLongLinkPath) {
          header.linkname = self2._gnuLongLinkPath;
          self2._gnuLongLinkPath = null;
        }
        if (self2._pax) {
          self2._header = header = mixinPax(header, self2._pax);
          self2._pax = null;
        }
        self2._locked = true;
        if (!header.size || header.type === "directory") {
          self2._parse(512, onheader);
          self2.emit("entry", header, emptyStream(self2, offset), onunlock);
          return;
        }
        self2._stream = new Source(self2, offset);
        self2.emit("entry", header, self2._stream, onunlock);
        self2._parse(header.size, onstreamend);
        oncontinue();
      };
      this._onheader = onheader;
      this._parse(512, onheader);
    };
    util4.inherits(Extract, Writable);
    Extract.prototype.destroy = function(err) {
      if (this._destroyed) return;
      this._destroyed = true;
      if (err) this.emit("error", err);
      this.emit("close");
      if (this._stream) this._stream.emit("close");
    };
    Extract.prototype._parse = function(size, onparse) {
      if (this._destroyed) return;
      this._offset += size;
      this._missing = size;
      if (onparse === this._onheader) this._partial = false;
      this._onparse = onparse;
    };
    Extract.prototype._continue = function() {
      if (this._destroyed) return;
      var cb = this._cb;
      this._cb = noop4;
      if (this._overflow) this._write(this._overflow, void 0, cb);
      else cb();
    };
    Extract.prototype._write = function(data, enc, cb) {
      if (this._destroyed) return;
      var s = this._stream;
      var b = this._buffer;
      var missing = this._missing;
      if (data.length) this._partial = true;
      if (data.length < missing) {
        this._missing -= data.length;
        this._overflow = null;
        if (s) return s.write(data, cb);
        b.append(data);
        return cb();
      }
      this._cb = cb;
      this._missing = 0;
      var overflow2 = null;
      if (data.length > missing) {
        overflow2 = data.slice(missing);
        data = data.slice(0, missing);
      }
      if (s) s.end(data);
      else b.append(data);
      this._overflow = overflow2;
      this._onparse();
    };
    Extract.prototype._final = function(cb) {
      if (this._partial) return this.destroy(new Error("Unexpected end of data"));
      cb();
    };
    module2.exports = Extract;
  }
});

// node_modules/fs-constants/index.js
var require_fs_constants = __commonJS({
  "node_modules/fs-constants/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require("fs").constants || require("constants");
  }
});

// node_modules/end-of-stream/index.js
var require_end_of_stream = __commonJS({
  "node_modules/end-of-stream/index.js"(exports2, module2) {
    "use strict";
    var once = require_once();
    var noop4 = function() {
    };
    var qnt = global.Bare ? queueMicrotask : process.nextTick.bind(process);
    var isRequest2 = function(stream4) {
      return stream4.setHeader && typeof stream4.abort === "function";
    };
    var isChildProcess = function(stream4) {
      return stream4.stdio && Array.isArray(stream4.stdio) && stream4.stdio.length === 3;
    };
    var eos = function(stream4, opts, callback) {
      if (typeof opts === "function") return eos(stream4, null, opts);
      if (!opts) opts = {};
      callback = once(callback || noop4);
      var ws = stream4._writableState;
      var rs = stream4._readableState;
      var readable = opts.readable || opts.readable !== false && stream4.readable;
      var writable = opts.writable || opts.writable !== false && stream4.writable;
      var cancelled = false;
      var onlegacyfinish = function() {
        if (!stream4.writable) onfinish();
      };
      var onfinish = function() {
        writable = false;
        if (!readable) callback.call(stream4);
      };
      var onend = function() {
        readable = false;
        if (!writable) callback.call(stream4);
      };
      var onexit = function(exitCode) {
        callback.call(stream4, exitCode ? new Error("exited with error code: " + exitCode) : null);
      };
      var onerror = function(err) {
        callback.call(stream4, err);
      };
      var onclose = function() {
        qnt(onclosenexttick);
      };
      var onclosenexttick = function() {
        if (cancelled) return;
        if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream4, new Error("premature close"));
        if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream4, new Error("premature close"));
      };
      var onrequest = function() {
        stream4.req.on("finish", onfinish);
      };
      if (isRequest2(stream4)) {
        stream4.on("complete", onfinish);
        stream4.on("abort", onclose);
        if (stream4.req) onrequest();
        else stream4.on("request", onrequest);
      } else if (writable && !ws) {
        stream4.on("end", onlegacyfinish);
        stream4.on("close", onlegacyfinish);
      }
      if (isChildProcess(stream4)) stream4.on("exit", onexit);
      stream4.on("end", onend);
      stream4.on("finish", onfinish);
      if (opts.error !== false) stream4.on("error", onerror);
      stream4.on("close", onclose);
      return function() {
        cancelled = true;
        stream4.removeListener("complete", onfinish);
        stream4.removeListener("abort", onclose);
        stream4.removeListener("request", onrequest);
        if (stream4.req) stream4.req.removeListener("finish", onfinish);
        stream4.removeListener("end", onlegacyfinish);
        stream4.removeListener("close", onlegacyfinish);
        stream4.removeListener("finish", onfinish);
        stream4.removeListener("exit", onexit);
        stream4.removeListener("end", onend);
        stream4.removeListener("error", onerror);
        stream4.removeListener("close", onclose);
      };
    };
    module2.exports = eos;
  }
});

// node_modules/tar-stream/pack.js
var require_pack = __commonJS({
  "node_modules/tar-stream/pack.js"(exports2, module2) {
    "use strict";
    var constants = require_fs_constants();
    var eos = require_end_of_stream();
    var util4 = require("util");
    var alloc = require_buffer_alloc();
    var toBuffer = require_to_buffer();
    var Readable2 = require_readable().Readable;
    var Writable = require_readable().Writable;
    var StringDecoder = require("string_decoder").StringDecoder;
    var headers = require_headers();
    var DMODE = parseInt("755", 8);
    var FMODE = parseInt("644", 8);
    var END_OF_TAR = alloc(1024);
    var noop4 = function() {
    };
    var overflow = function(self2, size) {
      size &= 511;
      if (size) self2.push(END_OF_TAR.slice(0, 512 - size));
    };
    function modeToType(mode) {
      switch (mode & constants.S_IFMT) {
        case constants.S_IFBLK:
          return "block-device";
        case constants.S_IFCHR:
          return "character-device";
        case constants.S_IFDIR:
          return "directory";
        case constants.S_IFIFO:
          return "fifo";
        case constants.S_IFLNK:
          return "symlink";
      }
      return "file";
    }
    var Sink = function(to) {
      Writable.call(this);
      this.written = 0;
      this._to = to;
      this._destroyed = false;
    };
    util4.inherits(Sink, Writable);
    Sink.prototype._write = function(data, enc, cb) {
      this.written += data.length;
      if (this._to.push(data)) return cb();
      this._to._drain = cb;
    };
    Sink.prototype.destroy = function() {
      if (this._destroyed) return;
      this._destroyed = true;
      this.emit("close");
    };
    var LinkSink = function() {
      Writable.call(this);
      this.linkname = "";
      this._decoder = new StringDecoder("utf-8");
      this._destroyed = false;
    };
    util4.inherits(LinkSink, Writable);
    LinkSink.prototype._write = function(data, enc, cb) {
      this.linkname += this._decoder.write(data);
      cb();
    };
    LinkSink.prototype.destroy = function() {
      if (this._destroyed) return;
      this._destroyed = true;
      this.emit("close");
    };
    var Void = function() {
      Writable.call(this);
      this._destroyed = false;
    };
    util4.inherits(Void, Writable);
    Void.prototype._write = function(data, enc, cb) {
      cb(new Error("No body allowed for this entry"));
    };
    Void.prototype.destroy = function() {
      if (this._destroyed) return;
      this._destroyed = true;
      this.emit("close");
    };
    var Pack = function(opts) {
      if (!(this instanceof Pack)) return new Pack(opts);
      Readable2.call(this, opts);
      this._drain = noop4;
      this._finalized = false;
      this._finalizing = false;
      this._destroyed = false;
      this._stream = null;
    };
    util4.inherits(Pack, Readable2);
    Pack.prototype.entry = function(header, buffer, callback) {
      if (this._stream) throw new Error("already piping an entry");
      if (this._finalized || this._destroyed) return;
      if (typeof buffer === "function") {
        callback = buffer;
        buffer = null;
      }
      if (!callback) callback = noop4;
      var self2 = this;
      if (!header.size || header.type === "symlink") header.size = 0;
      if (!header.type) header.type = modeToType(header.mode);
      if (!header.mode) header.mode = header.type === "directory" ? DMODE : FMODE;
      if (!header.uid) header.uid = 0;
      if (!header.gid) header.gid = 0;
      if (!header.mtime) header.mtime = /* @__PURE__ */ new Date();
      if (typeof buffer === "string") buffer = toBuffer(buffer);
      if (Buffer.isBuffer(buffer)) {
        header.size = buffer.length;
        this._encode(header);
        this.push(buffer);
        overflow(self2, header.size);
        process.nextTick(callback);
        return new Void();
      }
      if (header.type === "symlink" && !header.linkname) {
        var linkSink = new LinkSink();
        eos(linkSink, function(err) {
          if (err) {
            self2.destroy();
            return callback(err);
          }
          header.linkname = linkSink.linkname;
          self2._encode(header);
          callback();
        });
        return linkSink;
      }
      this._encode(header);
      if (header.type !== "file" && header.type !== "contiguous-file") {
        process.nextTick(callback);
        return new Void();
      }
      var sink = new Sink(this);
      this._stream = sink;
      eos(sink, function(err) {
        self2._stream = null;
        if (err) {
          self2.destroy();
          return callback(err);
        }
        if (sink.written !== header.size) {
          self2.destroy();
          return callback(new Error("size mismatch"));
        }
        overflow(self2, header.size);
        if (self2._finalizing) self2.finalize();
        callback();
      });
      return sink;
    };
    Pack.prototype.finalize = function() {
      if (this._stream) {
        this._finalizing = true;
        return;
      }
      if (this._finalized) return;
      this._finalized = true;
      this.push(END_OF_TAR);
      this.push(null);
    };
    Pack.prototype.destroy = function(err) {
      if (this._destroyed) return;
      this._destroyed = true;
      if (err) this.emit("error", err);
      this.emit("close");
      if (this._stream && this._stream.destroy) this._stream.destroy();
    };
    Pack.prototype._encode = function(header) {
      if (!header.pax) {
        var buf = headers.encode(header);
        if (buf) {
          this.push(buf);
          return;
        }
      }
      this._encodePax(header);
    };
    Pack.prototype._encodePax = function(header) {
      var paxHeader = headers.encodePax({
        name: header.name,
        linkname: header.linkname,
        pax: header.pax
      });
      var newHeader = {
        name: "PaxHeader",
        mode: header.mode,
        uid: header.uid,
        gid: header.gid,
        size: paxHeader.length,
        mtime: header.mtime,
        type: "pax-header",
        linkname: header.linkname && "PaxHeader",
        uname: header.uname,
        gname: header.gname,
        devmajor: header.devmajor,
        devminor: header.devminor
      };
      this.push(headers.encode(newHeader));
      this.push(paxHeader);
      overflow(this, paxHeader.length);
      newHeader.size = header.size;
      newHeader.type = header.type;
      this.push(headers.encode(newHeader));
    };
    Pack.prototype._read = function(n) {
      var drain = this._drain;
      this._drain = noop4;
      drain();
    };
    module2.exports = Pack;
  }
});

// node_modules/tar-stream/index.js
var require_tar_stream = __commonJS({
  "node_modules/tar-stream/index.js"(exports2) {
    "use strict";
    exports2.extract = require_extract();
    exports2.pack = require_pack();
  }
});

// node_modules/compressing/lib/base_stream.js
var require_base_stream = __commonJS({
  "node_modules/compressing/lib/base_stream.js"(exports2, module2) {
    "use strict";
    var stream4 = require("stream");
    var BaseStream = class extends stream4.Readable {
      addEntry() {
        throw new Error(".addEntry not implemented in sub class!");
      }
      _read() {
      }
      emit(event, data) {
        if (event === "error") {
          const error73 = data;
          if (error73.name === "Error") {
            error73.name = this.constructor.name + "Error";
          }
        }
        super.emit(event, data);
      }
    };
    module2.exports = BaseStream;
  }
});

// node_modules/compressing/lib/tar/stream.js
var require_stream9 = __commonJS({
  "node_modules/compressing/lib/tar/stream.js"(exports2, module2) {
    "use strict";
    var fs34 = require("fs");
    var path33 = require("path");
    var stream4 = require("stream");
    var tar = require_tar_stream();
    var utils = require_utils13();
    var BaseStream = require_base_stream();
    var TarStream = class extends BaseStream {
      constructor(opts) {
        super(opts);
        this._waitingEntries = [];
        this._processing = false;
        this._init(opts);
      }
      _init() {
        const pack = this._pack = tar.pack();
        pack.on("end", () => this.push(null));
        pack.on("data", (chunk) => this.push(chunk));
        pack.on("error", (err) => this.emit("error", err));
      }
      addEntry(entry, opts) {
        if (this._processing) {
          return this._waitingEntries.push([entry, opts]);
        }
        opts = opts || {};
        this._processing = true;
        const entryType = utils.entryType(entry);
        if (!entryType) return;
        if (entryType === "fileOrDir") {
          this._addFileOrDirEntry(entry, opts);
        } else if (entryType === "buffer") {
          this._addBufferEntry(entry, opts);
        } else {
          this._addStreamEntry(entry, opts);
        }
      }
      _addFileOrDirEntry(entry, opts) {
        fs34.stat(entry, (err, stat) => {
          if (err) return this.emit("error", err);
          if (stat.isDirectory()) return this._addDirEntry(entry, opts);
          if (stat.isFile()) return this._addFileEntry(entry, opts);
          const illigalEntryError = new Error("Type is not supported, must be a file path, directory path, file buffer, or a readable stream");
          illigalEntryError.name = "IlligalEntryError";
          this.emit("error", illigalEntryError);
        });
      }
      _addFileEntry(entry, opts) {
        fs34.stat(entry, (err, stat) => {
          if (err) return this.emit("error", err);
          const entryStream = this._pack.entry({ name: opts.relativePath || path33.basename(entry), size: stat.size, mode: stat.mode & 511 }, this._onEntryFinish.bind(this));
          const stream5 = fs34.createReadStream(entry, opts.fs);
          stream5.on("error", (err2) => this.emit("error", err2));
          stream5.pipe(entryStream);
        });
      }
      _addDirEntry(entry, opts) {
        fs34.readdir(entry, (err, files) => {
          if (err) return this.emit("error", err);
          const relativePath = opts.relativePath || "";
          files.forEach((fileOrDir) => {
            const newOpts = utils.clone(opts);
            if (opts.ignoreBase) {
              newOpts.relativePath = path33.posix.join(relativePath, fileOrDir);
            } else {
              newOpts.relativePath = path33.posix.join(relativePath, path33.basename(entry), fileOrDir);
            }
            newOpts.ignoreBase = true;
            this.addEntry(path33.posix.join(entry, fileOrDir), newOpts);
          });
          this._onEntryFinish();
        });
      }
      _addBufferEntry(entry, opts) {
        if (!opts.relativePath) return this.emit("error", "opts.relativePath is required if entry is a buffer");
        this._pack.entry({ name: opts.relativePath }, entry, this._onEntryFinish.bind(this));
      }
      _addStreamEntry(entry, opts) {
        entry.on("error", (err) => this.emit("error", err));
        if (!opts.relativePath) return this.emit("error", new Error("opts.relativePath is required"));
        if (opts.size) {
          const entryStream = this._pack.entry({ name: opts.relativePath, size: opts.size }, this._onEntryFinish.bind(this));
          entry.pipe(entryStream);
        } else {
          if (!opts.suppressSizeWarning) {
            console.warn("You should specify the size of streamming data by opts.size to prevent all streaming data from loading into memory. If you are sure about memory cost, pass opts.suppressSizeWarning: true to suppress this warning");
          }
          const buf = [];
          const collectStream = new stream4.Writable({
            write(chunk, _, callback) {
              buf.push(chunk);
              callback();
            }
          });
          collectStream.on("error", (err) => this.emit("error", err));
          collectStream.on("finish", () => {
            this._pack.entry({ name: opts.relativePath }, Buffer.concat(buf), this._onEntryFinish.bind(this));
          });
          entry.pipe(collectStream);
        }
      }
      _read() {
      }
      _onEntryFinish(err) {
        if (err) return this.emit("error", err);
        this._processing = false;
        const waitingEntry = this._waitingEntries.shift();
        if (waitingEntry) {
          this.addEntry.apply(this, waitingEntry);
        } else {
          this._finalize();
        }
      }
      _finalize() {
        this._pack.finalize();
      }
    };
    module2.exports = TarStream;
  }
});

// node_modules/compressing/lib/zip/stream.js
var require_stream10 = __commonJS({
  "node_modules/compressing/lib/zip/stream.js"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var yazl = require_yazl();
    var TarStream = require_stream9();
    var ZipStream = class extends TarStream {
      _init() {
        const zipfile = this._zipfile = new yazl.ZipFile();
        const stream4 = zipfile.outputStream;
        stream4.on("end", () => this.push(null));
        stream4.on("data", (chunk) => this.push(chunk));
        stream4.on("error", (err) => this.emit("error", err));
      }
      _addFileEntry(entry, opts) {
        this._zipfile.addFile(entry, opts.relativePath || path33.basename(entry), opts);
        this._onEntryFinish();
      }
      _addBufferEntry(entry, opts) {
        if (!opts.relativePath) return this.emit("error", new Error("opts.relativePath is required if entry is a buffer"));
        this._zipfile.addBuffer(entry, opts.relativePath, opts);
        this._onEntryFinish();
      }
      _addStreamEntry(entry, opts) {
        if (!opts.relativePath) return this.emit("error", new Error("opts.relativePath is required if entry is a stream"));
        entry.on("error", (err) => this.emit("error", err));
        this._zipfile.addReadStream(entry, opts.relativePath, opts);
        this._onEntryFinish();
      }
      _finalize() {
        this._zipfile.end();
      }
    };
    module2.exports = ZipStream;
  }
});

// node_modules/get-ready/index.js
var require_get_ready = __commonJS({
  "node_modules/get-ready/index.js"(exports2, module2) {
    "use strict";
    function ready(flagOrFunction) {
      this._ready = !!this._ready;
      this._readyCallbacks = this._readyCallbacks || [];
      if (arguments.length === 0) {
        return new Promise(function(resolve3) {
          if (this._ready) {
            return resolve3();
          }
          this._readyCallbacks.push(resolve3);
        }.bind(this));
      } else if (typeof flagOrFunction === "function") {
        this._readyCallbacks.push(flagOrFunction);
      } else {
        this._ready = !!flagOrFunction;
      }
      if (this._ready) {
        this._readyCallbacks.splice(0, Infinity).forEach(function(callback) {
          process.nextTick(callback);
        });
      }
    }
    function mixin(object4) {
      object4.ready = ready;
    }
    module2.exports = mixin;
    module2.exports.mixin = mixin;
  }
});

// node_modules/compressing/lib/zip/file_stream.js
var require_file_stream = __commonJS({
  "node_modules/compressing/lib/zip/file_stream.js"(exports2, module2) {
    "use strict";
    var path33 = require("path");
    var yazl = require_yazl();
    var assert3 = require("assert");
    var stream4 = require("stream");
    var utils = require_utils13();
    var ready = require_get_ready();
    var ZipFileStream = class extends stream4.Transform {
      constructor(opts) {
        super(opts);
        const sourceType = utils.sourceType(opts.source);
        const zipfile = new yazl.ZipFile();
        const zipStream = zipfile.outputStream;
        zipStream.on("data", (data) => this.push(data));
        zipStream.on("end", () => this.ready(true));
        zipfile.on("error", (err) => this.emit("error", err));
        if (sourceType !== "file") {
          assert3(opts.relativePath, "opts.relativePath is required when compressing a buffer, or a stream");
        }
        if (sourceType) {
          this.end();
        }
        if (sourceType === "file") {
          zipfile.addFile(opts.source, opts.relativePath || path33.basename(opts.source), opts.yazl);
        } else if (sourceType === "buffer") {
          zipfile.addBuffer(opts.source, opts.relativePath, opts.yazl);
        } else if (sourceType === "stream") {
          zipfile.addReadStream(opts.source, opts.relativePath, opts.yazl);
        } else {
          const passThrough = this._passThrough = new stream4.PassThrough();
          this.on("finish", () => passThrough.end());
          zipfile.addReadStream(passThrough, opts.relativePath, opts.yazl);
        }
        zipfile.end(opts.yazl);
      }
      _transform(chunk, encoding, callback) {
        if (this._passThrough) {
          this._passThrough.write(chunk, encoding, callback);
        }
      }
      _flush(callback) {
        this.ready(callback);
      }
    };
    ready.mixin(ZipFileStream.prototype);
    module2.exports = ZipFileStream;
  }
});

// node_modules/pend/index.js
var require_pend = __commonJS({
  "node_modules/pend/index.js"(exports2, module2) {
    "use strict";
    module2.exports = Pend;
    function Pend() {
      this.pending = 0;
      this.max = Infinity;
      this.listeners = [];
      this.waiting = [];
      this.error = null;
    }
    Pend.prototype.go = function(fn) {
      if (this.pending < this.max) {
        pendGo(this, fn);
      } else {
        this.waiting.push(fn);
      }
    };
    Pend.prototype.wait = function(cb) {
      if (this.pending === 0) {
        cb(this.error);
      } else {
        this.listeners.push(cb);
      }
    };
    Pend.prototype.hold = function() {
      return pendHold(this);
    };
    function pendHold(self2) {
      self2.pending += 1;
      var called = false;
      return onCb;
      function onCb(err) {
        if (called) throw new Error("callback called twice");
        called = true;
        self2.error = self2.error || err;
        self2.pending -= 1;
        if (self2.waiting.length > 0 && self2.pending < self2.max) {
          pendGo(self2, self2.waiting.shift());
        } else if (self2.pending === 0) {
          var listeners = self2.listeners;
          self2.listeners = [];
          listeners.forEach(cbListener);
        }
      }
      function cbListener(listener) {
        listener(self2.error);
      }
    }
    function pendGo(self2, fn) {
      fn(pendHold(self2));
    }
  }
});

// node_modules/fd-slicer2/index.js
var require_fd_slicer2 = __commonJS({
  "node_modules/fd-slicer2/index.js"(exports2) {
    "use strict";
    var fs34 = require("fs");
    var { Readable: Readable2, Writable, PassThrough } = require("stream");
    var Pend = require_pend();
    var { EventEmitter: EventEmitter3 } = require("events");
    var FdSlicer = class extends EventEmitter3 {
      constructor(fd, options = {}) {
        super();
        this.fd = fd;
        this.pend = new Pend();
        this.pend.max = 1;
        this.refCount = 0;
        this.autoClose = !!options.autoClose;
      }
      read(buffer, offset, length, position, callback) {
        this.pend.go((cb) => {
          fs34.read(this.fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
            cb();
            callback(err, bytesRead, buffer2);
          });
        });
      }
      write(buffer, offset, length, position, callback) {
        this.pend.go((cb) => {
          fs34.write(this.fd, buffer, offset, length, position, (err, written, buffer2) => {
            cb();
            callback(err, written, buffer2);
          });
        });
      }
      createReadStream(options) {
        return new ReadStream(this, options);
      }
      createWriteStream(options) {
        return new WriteStream(this, options);
      }
      ref() {
        this.refCount += 1;
      }
      unref() {
        this.refCount -= 1;
        if (this.refCount > 0) return;
        if (this.refCount < 0) throw new Error("invalid unref");
        if (this.autoClose) {
          fs34.close(this.fd, (err) => {
            if (err) {
              this.emit("error", err);
            } else {
              this.emit("close");
            }
          });
        }
      }
    };
    var ReadStream = class extends Readable2 {
      constructor(context2, options = {}) {
        super(options);
        this.context = context2;
        this.context.ref();
        this.start = options.start || 0;
        this.endOffset = options.end;
        this.pos = this.start;
        this.destroyed = false;
      }
      _read(n) {
        if (this.destroyed) return;
        let toRead = Math.min(this._readableState.highWaterMark, n);
        if (this.endOffset != null) {
          toRead = Math.min(toRead, this.endOffset - this.pos);
        }
        if (toRead <= 0) {
          this.destroyed = true;
          this.push(null);
          this.context.unref();
          return;
        }
        this.context.pend.go((cb) => {
          if (this.destroyed) return cb();
          const buffer = Buffer.alloc(toRead);
          fs34.read(this.context.fd, buffer, 0, toRead, this.pos, (err, bytesRead) => {
            if (err) {
              this.destroy(err);
            } else if (bytesRead === 0) {
              this.destroyed = true;
              this.push(null);
              this.context.unref();
            } else {
              this.pos += bytesRead;
              this.push(buffer.slice(0, bytesRead));
            }
            cb();
          });
        });
      }
      destroy(err) {
        if (this.destroyed) return;
        err = err || new Error("stream destroyed");
        this.destroyed = true;
        this.emit("error", err);
        this.context.unref();
      }
    };
    var WriteStream = class extends Writable {
      constructor(context2, options = {}) {
        super(options);
        this.context = context2;
        this.context.ref();
        this.start = options.start || 0;
        this.endOffset = options.end == null ? Infinity : +options.end;
        this.bytesWritten = 0;
        this.pos = this.start;
        this.destroyed = false;
        this.on("finish", this.destroy.bind(this));
      }
      _write(buffer, _encoding, callback) {
        if (this.destroyed) return;
        if (this.pos + buffer.length > this.endOffset) {
          const err = new Error("maximum file length exceeded");
          err.code = "ETOOBIG";
          this.destroy();
          callback(err);
          return;
        }
        this.context.pend.go((cb) => {
          if (this.destroyed) return cb();
          fs34.write(this.context.fd, buffer, 0, buffer.length, this.pos, (err, bytes) => {
            if (err) {
              this.destroy();
              cb();
              callback(err);
            } else {
              this.bytesWritten += bytes;
              this.pos += bytes;
              this.emit("progress");
              cb();
              callback();
            }
          });
        });
      }
      destroy() {
        if (this.destroyed) return;
        this.destroyed = true;
        this.context.unref();
      }
    };
    var { MAX_SAFE_INTEGER: MAX_SAFE_INTEGER3 } = Number;
    var BufferSlicer = class extends EventEmitter3 {
      constructor(buffer, options) {
        super();
        options = options || {};
        this.refCount = 0;
        this.buffer = buffer;
        this.maxChunkSize = options.maxChunkSize || MAX_SAFE_INTEGER3;
      }
      read(buffer, offset, length, position, callback) {
        const end = position + length;
        const delta = end - this.buffer.length;
        const written = delta > 0 ? delta : length;
        this.buffer.copy(buffer, offset, position, end);
        setImmediate(() => {
          callback(null, written);
        });
      }
      write(buffer, offset, length, position, callback) {
        buffer.copy(this.buffer, position, offset, offset + length);
        setImmediate(() => {
          callback(null, length, buffer);
        });
      }
      createReadStream(options = {}) {
        const readStream2 = new PassThrough(options);
        readStream2.destroyed = false;
        readStream2.start = options.start || 0;
        readStream2.endOffset = options.end;
        readStream2.pos = readStream2.endOffset || this.buffer.length;
        const entireSlice = this.buffer.slice(readStream2.start, readStream2.pos);
        let offset = 0;
        while (true) {
          const nextOffset = offset + this.maxChunkSize;
          if (nextOffset >= entireSlice.length) {
            if (offset < entireSlice.length) {
              readStream2.write(entireSlice.slice(offset, entireSlice.length));
            }
            break;
          }
          readStream2.write(entireSlice.slice(offset, nextOffset));
          offset = nextOffset;
        }
        readStream2.end();
        readStream2.destroy = () => {
          readStream2.destroyed = true;
        };
        return readStream2;
      }
      createWriteStream(options) {
        const bufferSlicer = this;
        options = options || {};
        const writeStream = new Writable(options);
        writeStream.start = options.start || 0;
        writeStream.endOffset = options.end == null ? this.buffer.length : +options.end;
        writeStream.bytesWritten = 0;
        writeStream.pos = writeStream.start;
        writeStream.destroyed = false;
        writeStream._write = (buffer, encoding, callback) => {
          if (writeStream.destroyed) return;
          const end = writeStream.pos + buffer.length;
          if (end > writeStream.endOffset) {
            const err = new Error("maximum file length exceeded");
            err.code = "ETOOBIG";
            writeStream.destroyed = true;
            callback(err);
            return;
          }
          buffer.copy(bufferSlicer.buffer, writeStream.pos, 0, buffer.length);
          writeStream.bytesWritten += buffer.length;
          writeStream.pos = end;
          writeStream.emit("progress");
          callback();
        };
        writeStream.destroy = () => {
          writeStream.destroyed = true;
        };
        return writeStream;
      }
      ref() {
        this.refCount += 1;
      }
      unref() {
        this.refCount -= 1;
        if (this.refCount < 0) {
          throw new Error("invalid unref");
        }
      }
    };
    function createFromBuffer(buffer, options) {
      return new BufferSlicer(buffer, options);
    }
    function createFromFd(fd, options) {
      return new FdSlicer(fd, options);
    }
    exports2.createFromBuffer = createFromBuffer;
    exports2.createFromFd = createFromFd;
    exports2.BufferSlicer = BufferSlicer;
    exports2.FdSlicer = FdSlicer;
  }
});

// node_modules/@eggjs/yauzl/index.js
var require_yauzl = __commonJS({
  "node_modules/@eggjs/yauzl/index.js"(exports2) {
    "use strict";
    var fs34 = require("fs");
    var zlib2 = require("zlib");
    var fd_slicer = require_fd_slicer2();
    var crc32 = require_buffer_crc32();
    var util4 = require("util");
    var EventEmitter3 = require("events").EventEmitter;
    var Transform = require("stream").Transform;
    var PassThrough = require("stream").PassThrough;
    var Writable = require("stream").Writable;
    exports2.open = open;
    exports2.fromFd = fromFd;
    exports2.fromBuffer = fromBuffer;
    exports2.fromRandomAccessReader = fromRandomAccessReader;
    exports2.dosDateTimeToDate = dosDateTimeToDate;
    exports2.validateFileName = validateFileName;
    exports2.ZipFile = ZipFile;
    exports2.Entry = Entry;
    exports2.RandomAccessReader = RandomAccessReader;
    function open(path33, options, callback) {
      if (typeof options === "function") {
        callback = options;
        options = null;
      }
      if (options == null) options = {};
      if (options.autoClose == null) options.autoClose = true;
      if (options.lazyEntries == null) options.lazyEntries = false;
      if (options.decodeStrings == null) options.decodeStrings = true;
      if (options.validateEntrySizes == null) options.validateEntrySizes = true;
      if (options.strictFileNames == null) options.strictFileNames = false;
      if (callback == null) callback = defaultCallback;
      fs34.open(path33, "r", function(err, fd) {
        if (err) return callback(err);
        fromFd(fd, options, function(err2, zipfile) {
          if (err2) fs34.close(fd, defaultCallback);
          callback(err2, zipfile);
        });
      });
    }
    function fromFd(fd, options, callback) {
      if (typeof options === "function") {
        callback = options;
        options = null;
      }
      if (options == null) options = {};
      if (options.autoClose == null) options.autoClose = false;
      if (options.lazyEntries == null) options.lazyEntries = false;
      if (options.decodeStrings == null) options.decodeStrings = true;
      if (options.validateEntrySizes == null) options.validateEntrySizes = true;
      if (options.strictFileNames == null) options.strictFileNames = false;
      if (callback == null) callback = defaultCallback;
      fs34.fstat(fd, function(err, stats) {
        if (err) return callback(err);
        var reader = fd_slicer.createFromFd(fd, { autoClose: true });
        fromRandomAccessReader(reader, stats.size, options, callback);
      });
    }
    function fromBuffer(buffer, options, callback) {
      if (typeof options === "function") {
        callback = options;
        options = null;
      }
      if (options == null) options = {};
      options.autoClose = false;
      if (options.lazyEntries == null) options.lazyEntries = false;
      if (options.decodeStrings == null) options.decodeStrings = true;
      if (options.validateEntrySizes == null) options.validateEntrySizes = true;
      if (options.strictFileNames == null) options.strictFileNames = false;
      var reader = fd_slicer.createFromBuffer(buffer, { maxChunkSize: 65536 });
      fromRandomAccessReader(reader, buffer.length, options, callback);
    }
    function fromRandomAccessReader(reader, totalSize, options, callback) {
      if (typeof options === "function") {
        callback = options;
        options = null;
      }
      if (options == null) options = {};
      if (options.autoClose == null) options.autoClose = true;
      if (options.lazyEntries == null) options.lazyEntries = false;
      if (options.decodeStrings == null) options.decodeStrings = true;
      var decodeStrings = !!options.decodeStrings;
      if (options.validateEntrySizes == null) options.validateEntrySizes = true;
      if (options.strictFileNames == null) options.strictFileNames = false;
      if (callback == null) callback = defaultCallback;
      if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number");
      if (totalSize > Number.MAX_SAFE_INTEGER) {
        throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
      }
      reader.ref();
      var eocdrWithoutCommentSize = 22;
      var maxCommentSize = 65535;
      var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, totalSize);
      var buffer = newBuffer(bufferSize);
      var bufferReadStart = totalSize - buffer.length;
      readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
        if (err) return callback(err);
        for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) {
          if (buffer.readUInt32LE(i) !== 101010256) continue;
          var eocdrBuffer = buffer.slice(i);
          var diskNumber = eocdrBuffer.readUInt16LE(4);
          if (diskNumber !== 0) {
            return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
          }
          var entryCount = eocdrBuffer.readUInt16LE(10);
          var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
          var commentLength = eocdrBuffer.readUInt16LE(20);
          var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
          if (commentLength !== expectedCommentLength) {
            return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength));
          }
          var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false) : eocdrBuffer.slice(22);
          if (!(entryCount === 65535 || centralDirectoryOffset === 4294967295)) {
            return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
          }
          var zip64EocdlBuffer = newBuffer(20);
          var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length;
          readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err2) {
            if (err2) return callback(err2);
            if (zip64EocdlBuffer.readUInt32LE(0) !== 117853008) {
              return callback(new Error("invalid zip64 end of central directory locator signature"));
            }
            var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
            var zip64EocdrBuffer = newBuffer(56);
            readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err3) {
              if (err3) return callback(err3);
              if (zip64EocdrBuffer.readUInt32LE(0) !== 101075792) {
                return callback(new Error("invalid zip64 end of central directory record signature"));
              }
              entryCount = readUInt64LE(zip64EocdrBuffer, 32);
              centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
              return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
            });
          });
          return;
        }
        callback(new Error("end of central directory record signature not found"));
      });
    }
    util4.inherits(ZipFile, EventEmitter3);
    function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
      var self2 = this;
      EventEmitter3.call(self2);
      self2.reader = reader;
      self2.reader.on("error", function(err) {
        emitError(self2, err);
      });
      self2.reader.once("close", function() {
        self2.emit("close");
      });
      self2.readEntryCursor = centralDirectoryOffset;
      self2.fileSize = fileSize;
      self2.entryCount = entryCount;
      self2.comment = comment;
      self2.entriesRead = 0;
      self2.autoClose = !!autoClose;
      self2.lazyEntries = !!lazyEntries;
      self2.decodeStrings = !!decodeStrings;
      self2.validateEntrySizes = !!validateEntrySizes;
      self2.strictFileNames = !!strictFileNames;
      self2.isOpen = true;
      self2.emittedError = false;
      if (!self2.lazyEntries) self2._readEntry();
    }
    ZipFile.prototype.close = function() {
      if (!this.isOpen) return;
      this.isOpen = false;
      this.reader.unref();
    };
    function emitErrorAndAutoClose(self2, err) {
      if (self2.autoClose) self2.close();
      emitError(self2, err);
    }
    function emitError(self2, err) {
      if (self2.emittedError) return;
      self2.emittedError = true;
      self2.emit("error", err);
    }
    ZipFile.prototype.readEntry = function() {
      if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true");
      this._readEntry();
    };
    ZipFile.prototype._readEntry = function() {
      var self2 = this;
      if (self2.entryCount === self2.entriesRead) {
        setImmediate(function() {
          if (self2.autoClose) self2.close();
          if (self2.emittedError) return;
          self2.emit("end");
        });
        return;
      }
      if (self2.emittedError) return;
      var buffer = newBuffer(46);
      readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err) {
        if (err) return emitErrorAndAutoClose(self2, err);
        if (self2.emittedError) return;
        var entry = new Entry();
        var signature = buffer.readUInt32LE(0);
        if (signature !== 33639248) return emitErrorAndAutoClose(self2, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
        entry.versionMadeBy = buffer.readUInt16LE(4);
        entry.versionNeededToExtract = buffer.readUInt16LE(6);
        entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
        entry.compressionMethod = buffer.readUInt16LE(10);
        entry.lastModFileTime = buffer.readUInt16LE(12);
        entry.lastModFileDate = buffer.readUInt16LE(14);
        entry.crc32 = buffer.readUInt32LE(16);
        entry.compressedSize = buffer.readUInt32LE(20);
        entry.uncompressedSize = buffer.readUInt32LE(24);
        entry.fileNameLength = buffer.readUInt16LE(28);
        entry.extraFieldLength = buffer.readUInt16LE(30);
        entry.fileCommentLength = buffer.readUInt16LE(32);
        entry.internalFileAttributes = buffer.readUInt16LE(36);
        entry.externalFileAttributes = buffer.readUInt32LE(38);
        entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
        if (entry.generalPurposeBitFlag & 64) return emitErrorAndAutoClose(self2, new Error("strong encryption is not supported"));
        self2.readEntryCursor += 46;
        buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
        readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err2) {
          if (err2) return emitErrorAndAutoClose(self2, err2);
          if (self2.emittedError) return;
          var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0;
          entry.fileName = self2.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8) : buffer.slice(0, entry.fileNameLength);
          var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
          var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart);
          entry.extraFields = [];
          var i = 0;
          while (i < extraFieldBuffer.length - 3) {
            var headerId = extraFieldBuffer.readUInt16LE(i + 0);
            var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
            var dataStart = i + 4;
            var dataEnd = dataStart + dataSize;
            if (dataEnd > extraFieldBuffer.length) return emitErrorAndAutoClose(self2, new Error("extra field length exceeds extra field buffer size"));
            var dataBuffer = newBuffer(dataSize);
            extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd);
            entry.extraFields.push({
              id: headerId,
              data: dataBuffer
            });
            i = dataEnd;
          }
          entry.fileComment = self2.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8) : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
          entry.comment = entry.fileComment;
          self2.readEntryCursor += buffer.length;
          self2.entriesRead += 1;
          if (entry.uncompressedSize === 4294967295 || entry.compressedSize === 4294967295 || entry.relativeOffsetOfLocalHeader === 4294967295) {
            var zip64EiefBuffer = null;
            for (var i = 0; i < entry.extraFields.length; i++) {
              var extraField = entry.extraFields[i];
              if (extraField.id === 1) {
                zip64EiefBuffer = extraField.data;
                break;
              }
            }
            if (zip64EiefBuffer == null) {
              return emitErrorAndAutoClose(self2, new Error("expected zip64 extended information extra field"));
            }
            var index = 0;
            if (entry.uncompressedSize === 4294967295) {
              if (index + 8 > zip64EiefBuffer.length) {
                return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include uncompressed size"));
              }
              entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
              index += 8;
            }
            if (entry.compressedSize === 4294967295) {
              if (index + 8 > zip64EiefBuffer.length) {
                return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include compressed size"));
              }
              entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
              index += 8;
            }
            if (entry.relativeOffsetOfLocalHeader === 4294967295) {
              if (index + 8 > zip64EiefBuffer.length) {
                return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include relative header offset"));
              }
              entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
              index += 8;
            }
          }
          if (self2.decodeStrings) {
            for (var i = 0; i < entry.extraFields.length; i++) {
              var extraField = entry.extraFields[i];
              if (extraField.id === 28789) {
                if (extraField.data.length < 6) {
                  continue;
                }
                if (extraField.data.readUInt8(0) !== 1) {
                  continue;
                }
                var oldNameCrc32 = extraField.data.readUInt32LE(1);
                if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) {
                  continue;
                }
                entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true);
                break;
              }
            }
          }
          if (self2.validateEntrySizes && entry.compressionMethod === 0) {
            var expectedCompressedSize = entry.uncompressedSize;
            if (entry.isEncrypted()) {
              expectedCompressedSize += 12;
            }
            if (entry.compressedSize !== expectedCompressedSize) {
              var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
              return emitErrorAndAutoClose(self2, new Error(msg));
            }
          }
          if (self2.decodeStrings) {
            if (!self2.strictFileNames) {
              entry.fileName = entry.fileName.replace(/\\/g, "/");
            }
            var errorMessage = validateFileName(entry.fileName, self2.validateFileNameOptions);
            if (errorMessage != null) return emitErrorAndAutoClose(self2, new Error(errorMessage));
          }
          self2.emit("entry", entry);
          if (!self2.lazyEntries) self2._readEntry();
        });
      });
    };
    ZipFile.prototype.openReadStream = function(entry, options, callback) {
      var self2 = this;
      var relativeStart = 0;
      var relativeEnd = entry.compressedSize;
      if (callback == null) {
        callback = options;
        options = {};
      } else {
        if (options.decrypt != null) {
          if (!entry.isEncrypted()) {
            throw new Error("options.decrypt can only be specified for encrypted entries");
          }
          if (options.decrypt !== false) throw new Error("invalid options.decrypt value: " + options.decrypt);
          if (entry.isCompressed()) {
            if (options.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false");
          }
        }
        if (options.decompress != null) {
          if (!entry.isCompressed()) {
            throw new Error("options.decompress can only be specified for compressed entries");
          }
          if (!(options.decompress === false || options.decompress === true)) {
            throw new Error("invalid options.decompress value: " + options.decompress);
          }
        }
        if (options.start != null || options.end != null) {
          if (entry.isCompressed() && options.decompress !== false) {
            throw new Error("start/end range not allowed for compressed entry without options.decompress === false");
          }
          if (entry.isEncrypted() && options.decrypt !== false) {
            throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
          }
        }
        if (options.start != null) {
          relativeStart = options.start;
          if (relativeStart < 0) throw new Error("options.start < 0");
          if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize");
        }
        if (options.end != null) {
          relativeEnd = options.end;
          if (relativeEnd < 0) throw new Error("options.end < 0");
          if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize");
          if (relativeEnd < relativeStart) throw new Error("options.end < options.start");
        }
      }
      if (!self2.isOpen) return callback(new Error("closed"));
      if (entry.isEncrypted()) {
        if (options.decrypt !== false) return callback(new Error("entry is encrypted, and options.decrypt !== false"));
      }
      self2.reader.ref();
      var buffer = newBuffer(30);
      readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
        try {
          if (err) return callback(err);
          var signature = buffer.readUInt32LE(0);
          if (signature !== 67324752) {
            return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
          }
          var fileNameLength = buffer.readUInt16LE(26);
          var extraFieldLength = buffer.readUInt16LE(28);
          var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
          var decompress;
          if (entry.compressionMethod === 0) {
            decompress = false;
          } else if (entry.compressionMethod === 8) {
            decompress = options.decompress != null ? options.decompress : true;
          } else {
            return callback(new Error("unsupported compression method: " + entry.compressionMethod));
          }
          var fileDataStart = localFileHeaderEnd;
          var fileDataEnd = fileDataStart + entry.compressedSize;
          if (entry.compressedSize !== 0) {
            if (fileDataEnd > self2.fileSize) {
              return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self2.fileSize));
            }
          }
          var readStream2 = self2.reader.createReadStream({
            start: fileDataStart + relativeStart,
            end: fileDataStart + relativeEnd
          });
          var endpointStream = readStream2;
          if (decompress) {
            var destroyed = false;
            var inflateFilter = zlib2.createInflateRaw();
            readStream2.on("error", function(err2) {
              setImmediate(function() {
                if (!destroyed) inflateFilter.emit("error", err2);
              });
            });
            readStream2.pipe(inflateFilter);
            if (self2.validateEntrySizes) {
              endpointStream = new AssertByteCountStream(entry.uncompressedSize);
              inflateFilter.on("error", function(err2) {
                setImmediate(function() {
                  if (!destroyed) endpointStream.emit("error", err2);
                });
              });
              inflateFilter.pipe(endpointStream);
            } else {
              endpointStream = inflateFilter;
            }
            endpointStream.destroy = function() {
              destroyed = true;
              if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
              readStream2.unpipe(inflateFilter);
              readStream2.destroy();
            };
          }
          callback(null, endpointStream);
        } finally {
          self2.reader.unref();
        }
      });
    };
    function Entry() {
    }
    Entry.prototype.getLastModDate = function() {
      return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime);
    };
    Entry.prototype.isEncrypted = function() {
      return (this.generalPurposeBitFlag & 1) !== 0;
    };
    Entry.prototype.isCompressed = function() {
      return this.compressionMethod === 8;
    };
    function dosDateTimeToDate(date6, time4) {
      var day = date6 & 31;
      var month = (date6 >> 5 & 15) - 1;
      var year = (date6 >> 9 & 127) + 1980;
      var millisecond = 0;
      var second = (time4 & 31) * 2;
      var minute = time4 >> 5 & 63;
      var hour = time4 >> 11 & 31;
      return new Date(year, month, day, hour, minute, second, millisecond);
    }
    function validateFileName(fileName) {
      if (fileName.indexOf("\\") !== -1) {
        return "invalid characters in fileName: " + fileName;
      }
      if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
        return "absolute path: " + fileName;
      }
      if (fileName.split("/").indexOf("..") !== -1) {
        return "invalid relative path: " + fileName;
      }
      return null;
    }
    function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
      if (length === 0) {
        return setImmediate(function() {
          callback(null, newBuffer(0));
        });
      }
      reader.read(buffer, offset, length, position, function(err, bytesRead) {
        if (err) return callback(err);
        if (bytesRead < length) {
          return callback(new Error("unexpected EOF"));
        }
        callback();
      });
    }
    util4.inherits(AssertByteCountStream, Transform);
    function AssertByteCountStream(byteCount) {
      Transform.call(this);
      this.actualByteCount = 0;
      this.expectedByteCount = byteCount;
    }
    AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
      this.actualByteCount += chunk.length;
      if (this.actualByteCount > this.expectedByteCount) {
        var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
        return cb(new Error(msg));
      }
      cb(null, chunk);
    };
    AssertByteCountStream.prototype._flush = function(cb) {
      if (this.actualByteCount < this.expectedByteCount) {
        var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
        return cb(new Error(msg));
      }
      cb();
    };
    util4.inherits(RandomAccessReader, EventEmitter3);
    function RandomAccessReader() {
      EventEmitter3.call(this);
      this.refCount = 0;
    }
    RandomAccessReader.prototype.ref = function() {
      this.refCount += 1;
    };
    RandomAccessReader.prototype.unref = function() {
      var self2 = this;
      self2.refCount -= 1;
      if (self2.refCount > 0) return;
      if (self2.refCount < 0) throw new Error("invalid unref");
      self2.close(onCloseDone);
      function onCloseDone(err) {
        if (err) return self2.emit("error", err);
        self2.emit("close");
      }
    };
    RandomAccessReader.prototype.createReadStream = function(options) {
      var start = options.start;
      var end = options.end;
      if (start === end) {
        var emptyStream = new PassThrough();
        setImmediate(function() {
          emptyStream.end();
        });
        return emptyStream;
      }
      var stream4 = this._readStreamForRange(start, end);
      var destroyed = false;
      var refUnrefFilter = new RefUnrefFilter(this);
      stream4.on("error", function(err) {
        setImmediate(function() {
          if (!destroyed) refUnrefFilter.emit("error", err);
        });
      });
      refUnrefFilter.destroy = function() {
        stream4.unpipe(refUnrefFilter);
        refUnrefFilter.unref();
        stream4.destroy();
      };
      var byteCounter = new AssertByteCountStream(end - start);
      refUnrefFilter.on("error", function(err) {
        setImmediate(function() {
          if (!destroyed) byteCounter.emit("error", err);
        });
      });
      byteCounter.destroy = function() {
        destroyed = true;
        refUnrefFilter.unpipe(byteCounter);
        refUnrefFilter.destroy();
      };
      return stream4.pipe(refUnrefFilter).pipe(byteCounter);
    };
    RandomAccessReader.prototype._readStreamForRange = function(start, end) {
      throw new Error("not implemented");
    };
    RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
      var readStream2 = this.createReadStream({ start: position, end: position + length });
      var writeStream = new Writable();
      var written = 0;
      writeStream._write = function(chunk, encoding, cb) {
        chunk.copy(buffer, offset + written, 0, chunk.length);
        written += chunk.length;
        cb();
      };
      writeStream.on("finish", callback);
      readStream2.on("error", function(error73) {
        callback(error73);
      });
      readStream2.pipe(writeStream);
    };
    RandomAccessReader.prototype.close = function(callback) {
      setImmediate(callback);
    };
    util4.inherits(RefUnrefFilter, PassThrough);
    function RefUnrefFilter(context2) {
      PassThrough.call(this);
      this.context = context2;
      this.context.ref();
      this.unreffedYet = false;
    }
    RefUnrefFilter.prototype._flush = function(cb) {
      this.unref();
      cb();
    };
    RefUnrefFilter.prototype.unref = function(cb) {
      if (this.unreffedYet) return;
      this.unreffedYet = true;
      this.context.unref();
    };
    var cp437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\xB6\xA7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
    function decodeBuffer(buffer, start, end, isUtf8) {
      if (isUtf8) {
        return buffer.toString("utf8", start, end);
      } else {
        var result = "";
        for (var i = start; i < end; i++) {
          result += cp437[buffer[i]];
        }
        return result;
      }
    }
    function readUInt64LE(buffer, offset) {
      var lower32 = buffer.readUInt32LE(offset);
      var upper32 = buffer.readUInt32LE(offset + 4);
      return upper32 * 4294967296 + lower32;
    }
    var newBuffer;
    if (typeof Buffer.allocUnsafe === "function") {
      newBuffer = function(len) {
        return Buffer.allocUnsafe(len);
      };
    } else {
      newBuffer = function(len) {
        return new Buffer(len);
      };
    }
    function defaultCallback(err) {
      if (err) throw err;
    }
  }
});

// node_modules/compressing/lib/base_write_stream.js
var require_base_write_stream = __commonJS({
  "node_modules/compressing/lib/base_write_stream.js"(exports2, module2) {
    "use strict";
    var stream4 = require("stream");
    var UncompressBaseStream = class extends stream4.Writable {
      emit(event, data) {
        if (event === "error") {
          const error73 = data;
          if (error73.name === "Error") {
            error73.name = this.constructor.name + "Error";
          }
        }
        super.emit.apply(this, arguments);
      }
    };
    module2.exports = UncompressBaseStream;
  }
});

// node_modules/compressing/node_modules/iconv-lite/lib/bom-handling.js
var require_bom_handling2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/lib/bom-handling.js"(exports2) {
    "use strict";
    var BOMChar = "\uFEFF";
    exports2.PrependBOM = PrependBOMWrapper;
    function PrependBOMWrapper(encoder, options) {
      this.encoder = encoder;
      this.addBOM = true;
    }
    PrependBOMWrapper.prototype.write = function(str) {
      if (this.addBOM) {
        str = BOMChar + str;
        this.addBOM = false;
      }
      return this.encoder.write(str);
    };
    PrependBOMWrapper.prototype.end = function() {
      return this.encoder.end();
    };
    exports2.StripBOM = StripBOMWrapper;
    function StripBOMWrapper(decoder, options) {
      this.decoder = decoder;
      this.pass = false;
      this.options = options || {};
    }
    StripBOMWrapper.prototype.write = function(buf) {
      var res = this.decoder.write(buf);
      if (this.pass || !res)
        return res;
      if (res[0] === BOMChar) {
        res = res.slice(1);
        if (typeof this.options.stripBOM === "function")
          this.options.stripBOM();
      }
      this.pass = true;
      return res;
    };
    StripBOMWrapper.prototype.end = function() {
      return this.decoder.end();
    };
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/internal.js
var require_internal2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/internal.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    module2.exports = {
      // Encodings
      utf8: { type: "_internal", bomAware: true },
      cesu8: { type: "_internal", bomAware: true },
      unicode11utf8: "utf8",
      ucs2: { type: "_internal", bomAware: true },
      utf16le: "ucs2",
      binary: { type: "_internal" },
      base64: { type: "_internal" },
      hex: { type: "_internal" },
      // Codec.
      _internal: InternalCodec
    };
    function InternalCodec(codecOptions, iconv) {
      this.enc = codecOptions.encodingName;
      this.bomAware = codecOptions.bomAware;
      if (this.enc === "base64")
        this.encoder = InternalEncoderBase64;
      else if (this.enc === "cesu8") {
        this.enc = "utf8";
        this.encoder = InternalEncoderCesu8;
        if (Buffer3.from("eda0bdedb2a9", "hex").toString() !== "\u{1F4A9}") {
          this.decoder = InternalDecoderCesu8;
          this.defaultCharUnicode = iconv.defaultCharUnicode;
        }
      }
    }
    InternalCodec.prototype.encoder = InternalEncoder;
    InternalCodec.prototype.decoder = InternalDecoder;
    var StringDecoder = require("string_decoder").StringDecoder;
    if (!StringDecoder.prototype.end)
      StringDecoder.prototype.end = function() {
      };
    function InternalDecoder(options, codec3) {
      StringDecoder.call(this, codec3.enc);
    }
    InternalDecoder.prototype = StringDecoder.prototype;
    function InternalEncoder(options, codec3) {
      this.enc = codec3.enc;
    }
    InternalEncoder.prototype.write = function(str) {
      return Buffer3.from(str, this.enc);
    };
    InternalEncoder.prototype.end = function() {
    };
    function InternalEncoderBase64(options, codec3) {
      this.prevStr = "";
    }
    InternalEncoderBase64.prototype.write = function(str) {
      str = this.prevStr + str;
      var completeQuads = str.length - str.length % 4;
      this.prevStr = str.slice(completeQuads);
      str = str.slice(0, completeQuads);
      return Buffer3.from(str, "base64");
    };
    InternalEncoderBase64.prototype.end = function() {
      return Buffer3.from(this.prevStr, "base64");
    };
    function InternalEncoderCesu8(options, codec3) {
    }
    InternalEncoderCesu8.prototype.write = function(str) {
      var buf = Buffer3.alloc(str.length * 3), bufIdx = 0;
      for (var i = 0; i < str.length; i++) {
        var charCode = str.charCodeAt(i);
        if (charCode < 128)
          buf[bufIdx++] = charCode;
        else if (charCode < 2048) {
          buf[bufIdx++] = 192 + (charCode >>> 6);
          buf[bufIdx++] = 128 + (charCode & 63);
        } else {
          buf[bufIdx++] = 224 + (charCode >>> 12);
          buf[bufIdx++] = 128 + (charCode >>> 6 & 63);
          buf[bufIdx++] = 128 + (charCode & 63);
        }
      }
      return buf.slice(0, bufIdx);
    };
    InternalEncoderCesu8.prototype.end = function() {
    };
    function InternalDecoderCesu8(options, codec3) {
      this.acc = 0;
      this.contBytes = 0;
      this.accBytes = 0;
      this.defaultCharUnicode = codec3.defaultCharUnicode;
    }
    InternalDecoderCesu8.prototype.write = function(buf) {
      var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, res = "";
      for (var i = 0; i < buf.length; i++) {
        var curByte = buf[i];
        if ((curByte & 192) !== 128) {
          if (contBytes > 0) {
            res += this.defaultCharUnicode;
            contBytes = 0;
          }
          if (curByte < 128) {
            res += String.fromCharCode(curByte);
          } else if (curByte < 224) {
            acc = curByte & 31;
            contBytes = 1;
            accBytes = 1;
          } else if (curByte < 240) {
            acc = curByte & 15;
            contBytes = 2;
            accBytes = 1;
          } else {
            res += this.defaultCharUnicode;
          }
        } else {
          if (contBytes > 0) {
            acc = acc << 6 | curByte & 63;
            contBytes--;
            accBytes++;
            if (contBytes === 0) {
              if (accBytes === 2 && acc < 128 && acc > 0)
                res += this.defaultCharUnicode;
              else if (accBytes === 3 && acc < 2048)
                res += this.defaultCharUnicode;
              else
                res += String.fromCharCode(acc);
            }
          } else {
            res += this.defaultCharUnicode;
          }
        }
      }
      this.acc = acc;
      this.contBytes = contBytes;
      this.accBytes = accBytes;
      return res;
    };
    InternalDecoderCesu8.prototype.end = function() {
      var res = 0;
      if (this.contBytes > 0)
        res += this.defaultCharUnicode;
      return res;
    };
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/utf32.js
var require_utf322 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/utf32.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2._utf32 = Utf32Codec;
    function Utf32Codec(codecOptions, iconv) {
      this.iconv = iconv;
      this.bomAware = true;
      this.isLE = codecOptions.isLE;
    }
    exports2.utf32le = { type: "_utf32", isLE: true };
    exports2.utf32be = { type: "_utf32", isLE: false };
    exports2.ucs4le = "utf32le";
    exports2.ucs4be = "utf32be";
    Utf32Codec.prototype.encoder = Utf32Encoder;
    Utf32Codec.prototype.decoder = Utf32Decoder;
    function Utf32Encoder(options, codec3) {
      this.isLE = codec3.isLE;
      this.highSurrogate = 0;
    }
    Utf32Encoder.prototype.write = function(str) {
      var src = Buffer3.from(str, "ucs2");
      var dst = Buffer3.alloc(src.length * 2);
      var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;
      var offset = 0;
      for (var i = 0; i < src.length; i += 2) {
        var code = src.readUInt16LE(i);
        var isHighSurrogate = 55296 <= code && code < 56320;
        var isLowSurrogate = 56320 <= code && code < 57344;
        if (this.highSurrogate) {
          if (isHighSurrogate || !isLowSurrogate) {
            write32.call(dst, this.highSurrogate, offset);
            offset += 4;
          } else {
            var codepoint = (this.highSurrogate - 55296 << 10 | code - 56320) + 65536;
            write32.call(dst, codepoint, offset);
            offset += 4;
            this.highSurrogate = 0;
            continue;
          }
        }
        if (isHighSurrogate)
          this.highSurrogate = code;
        else {
          write32.call(dst, code, offset);
          offset += 4;
          this.highSurrogate = 0;
        }
      }
      if (offset < dst.length)
        dst = dst.slice(0, offset);
      return dst;
    };
    Utf32Encoder.prototype.end = function() {
      if (!this.highSurrogate)
        return;
      var buf = Buffer3.alloc(4);
      if (this.isLE)
        buf.writeUInt32LE(this.highSurrogate, 0);
      else
        buf.writeUInt32BE(this.highSurrogate, 0);
      this.highSurrogate = 0;
      return buf;
    };
    function Utf32Decoder(options, codec3) {
      this.isLE = codec3.isLE;
      this.badChar = codec3.iconv.defaultCharUnicode.charCodeAt(0);
      this.overflow = null;
    }
    Utf32Decoder.prototype.write = function(src) {
      if (src.length === 0)
        return "";
      if (this.overflow)
        src = Buffer3.concat([this.overflow, src]);
      var goodLength = src.length - src.length % 4;
      if (src.length !== goodLength) {
        this.overflow = src.slice(goodLength);
        src = src.slice(0, goodLength);
      } else
        this.overflow = null;
      var dst = Buffer3.alloc(goodLength);
      var offset = 0;
      for (var i = 0; i < goodLength; i += 4) {
        var codepoint = this.isLE ? src.readUInt32LE(i) : src.readUInt32BE(i);
        if (codepoint < 65536) {
          dst.writeUInt16LE(codepoint, offset);
          offset += 2;
        } else {
          if (codepoint > 1114111) {
            dst.writeUInt16LE(this.badChar, offset);
            offset += 2;
          } else {
            codepoint -= 65536;
            var high = 55296 | codepoint >> 10;
            var low = 56320 + (codepoint & 1023);
            dst.writeUInt16LE(high, offset);
            offset += 2;
            dst.writeUInt16LE(low, offset);
            offset += 2;
          }
        }
      }
      return dst.slice(0, offset).toString("ucs2");
    };
    Utf32Decoder.prototype.end = function() {
      this.overflow = null;
    };
    exports2.utf32 = Utf32AutoCodec;
    exports2.ucs4 = Utf32AutoCodec;
    function Utf32AutoCodec(options, iconv) {
      this.iconv = iconv;
    }
    Utf32AutoCodec.prototype.encoder = Utf32AutoEncoder;
    Utf32AutoCodec.prototype.decoder = Utf32AutoDecoder;
    function Utf32AutoEncoder(options, codec3) {
      options = options || {};
      if (options.addBOM === void 0)
        options.addBOM = true;
      this.encoder = codec3.iconv.getEncoder(options.defaultEncoding || "utf-32le", options);
    }
    Utf32AutoEncoder.prototype.write = function(str) {
      return this.encoder.write(str);
    };
    Utf32AutoEncoder.prototype.end = function() {
      return this.encoder.end();
    };
    function Utf32AutoDecoder(options, codec3) {
      this.decoder = null;
      this.initialBytes = [];
      this.initialBytesLen = 0;
      this.options = options || {};
      this.iconv = codec3.iconv;
    }
    Utf32AutoDecoder.prototype.write = function(buf) {
      if (!this.decoder) {
        this.initialBytes.push(buf);
        this.initialBytesLen += buf.length;
        if (this.initialBytesLen < 32)
          return "";
        var buf2 = Buffer3.concat(this.initialBytes), encoding = detectEncoding(buf2, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        this.initialBytes.length = this.initialBytesLen = 0;
      }
      return this.decoder.write(buf);
    };
    Utf32AutoDecoder.prototype.end = function() {
      if (!this.decoder) {
        var buf = Buffer3.concat(this.initialBytes), encoding = detectEncoding(buf, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var res = this.decoder.write(buf), trail = this.decoder.end();
        return trail ? res + trail : res;
      }
      return this.decoder.end();
    };
    function detectEncoding(buf, defaultEncoding) {
      var enc = defaultEncoding || "utf-32le";
      if (buf.length >= 4) {
        if (buf.readUInt32BE(0) === 65279)
          enc = "utf-32be";
        else if (buf.readUInt32LE(0) === 65279)
          enc = "utf-32le";
        else {
          var invalidLE = 0, invalidBE = 0;
          var asciiCharsLE = 0, asciiCharsBE = 0, _len = Math.min(buf.length - buf.length % 4, 128);
          for (var i = 0; i < _len; i += 4) {
            var b0 = buf[i], b1 = buf[i + 1], b2 = buf[i + 2], b3 = buf[i + 3];
            if (b0 !== 0 || b1 > 16) ++invalidBE;
            if (b3 !== 0 || b2 > 16) ++invalidLE;
            if (b0 === 0 && b1 === 0 && b2 === 0 && b3 !== 0) asciiCharsBE++;
            if (b0 !== 0 && b1 === 0 && b2 === 0 && b3 === 0) asciiCharsLE++;
          }
          if (invalidBE < invalidLE)
            enc = "utf-32be";
          else if (invalidLE < invalidBE)
            enc = "utf-32le";
          if (asciiCharsBE > asciiCharsLE)
            enc = "utf-32be";
          else if (asciiCharsBE < asciiCharsLE)
            enc = "utf-32le";
        }
      }
      return enc;
    }
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/utf16.js
var require_utf162 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/utf16.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2.utf16be = Utf16BECodec;
    function Utf16BECodec() {
    }
    Utf16BECodec.prototype.encoder = Utf16BEEncoder;
    Utf16BECodec.prototype.decoder = Utf16BEDecoder;
    Utf16BECodec.prototype.bomAware = true;
    function Utf16BEEncoder() {
    }
    Utf16BEEncoder.prototype.write = function(str) {
      var buf = Buffer3.from(str, "ucs2");
      for (var i = 0; i < buf.length; i += 2) {
        var tmp = buf[i];
        buf[i] = buf[i + 1];
        buf[i + 1] = tmp;
      }
      return buf;
    };
    Utf16BEEncoder.prototype.end = function() {
    };
    function Utf16BEDecoder() {
      this.overflowByte = -1;
    }
    Utf16BEDecoder.prototype.write = function(buf) {
      if (buf.length == 0)
        return "";
      var buf2 = Buffer3.alloc(buf.length + 1), i = 0, j = 0;
      if (this.overflowByte !== -1) {
        buf2[0] = buf[0];
        buf2[1] = this.overflowByte;
        i = 1;
        j = 2;
      }
      for (; i < buf.length - 1; i += 2, j += 2) {
        buf2[j] = buf[i + 1];
        buf2[j + 1] = buf[i];
      }
      this.overflowByte = i == buf.length - 1 ? buf[buf.length - 1] : -1;
      return buf2.slice(0, j).toString("ucs2");
    };
    Utf16BEDecoder.prototype.end = function() {
    };
    exports2.utf16 = Utf16Codec;
    function Utf16Codec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    Utf16Codec.prototype.encoder = Utf16Encoder;
    Utf16Codec.prototype.decoder = Utf16Decoder;
    function Utf16Encoder(options, codec3) {
      options = options || {};
      if (options.addBOM === void 0)
        options.addBOM = true;
      this.encoder = codec3.iconv.getEncoder("utf-16le", options);
    }
    Utf16Encoder.prototype.write = function(str) {
      return this.encoder.write(str);
    };
    Utf16Encoder.prototype.end = function() {
      return this.encoder.end();
    };
    function Utf16Decoder(options, codec3) {
      this.decoder = null;
      this.initialBytes = [];
      this.initialBytesLen = 0;
      this.options = options || {};
      this.iconv = codec3.iconv;
    }
    Utf16Decoder.prototype.write = function(buf) {
      if (!this.decoder) {
        this.initialBytes.push(buf);
        this.initialBytesLen += buf.length;
        if (this.initialBytesLen < 16)
          return "";
        var buf = Buffer3.concat(this.initialBytes), encoding = detectEncoding(buf, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        this.initialBytes.length = this.initialBytesLen = 0;
      }
      return this.decoder.write(buf);
    };
    Utf16Decoder.prototype.end = function() {
      if (!this.decoder) {
        var buf = Buffer3.concat(this.initialBytes), encoding = detectEncoding(buf, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var res = this.decoder.write(buf), trail = this.decoder.end();
        return trail ? res + trail : res;
      }
      return this.decoder.end();
    };
    function detectEncoding(buf, defaultEncoding) {
      var enc = defaultEncoding || "utf-16le";
      if (buf.length >= 2) {
        if (buf[0] == 254 && buf[1] == 255)
          enc = "utf-16be";
        else if (buf[0] == 255 && buf[1] == 254)
          enc = "utf-16le";
        else {
          var asciiCharsLE = 0, asciiCharsBE = 0, _len = Math.min(buf.length - buf.length % 2, 64);
          for (var i = 0; i < _len; i += 2) {
            if (buf[i] === 0 && buf[i + 1] !== 0) asciiCharsBE++;
            if (buf[i] !== 0 && buf[i + 1] === 0) asciiCharsLE++;
          }
          if (asciiCharsBE > asciiCharsLE)
            enc = "utf-16be";
          else if (asciiCharsBE < asciiCharsLE)
            enc = "utf-16le";
        }
      }
      return enc;
    }
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/utf7.js
var require_utf72 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/utf7.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2.utf7 = Utf7Codec;
    exports2.unicode11utf7 = "utf7";
    function Utf7Codec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    Utf7Codec.prototype.encoder = Utf7Encoder;
    Utf7Codec.prototype.decoder = Utf7Decoder;
    Utf7Codec.prototype.bomAware = true;
    var nonDirectChars = /[^A-Za-z0-9'\(\),-\.\/:\? \n\r\t]+/g;
    function Utf7Encoder(options, codec3) {
      this.iconv = codec3.iconv;
    }
    Utf7Encoder.prototype.write = function(str) {
      return Buffer3.from(str.replace(nonDirectChars, function(chunk) {
        return "+" + (chunk === "+" ? "" : this.iconv.encode(chunk, "utf16-be").toString("base64").replace(/=+$/, "")) + "-";
      }.bind(this)));
    };
    Utf7Encoder.prototype.end = function() {
    };
    function Utf7Decoder(options, codec3) {
      this.iconv = codec3.iconv;
      this.inBase64 = false;
      this.base64Accum = "";
    }
    var base64Regex2 = /[A-Za-z0-9\/+]/;
    var base64Chars = [];
    for (i = 0; i < 256; i++)
      base64Chars[i] = base64Regex2.test(String.fromCharCode(i));
    var i;
    var plusChar = "+".charCodeAt(0);
    var minusChar = "-".charCodeAt(0);
    var andChar = "&".charCodeAt(0);
    Utf7Decoder.prototype.write = function(buf) {
      var res = "", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;
      for (var i2 = 0; i2 < buf.length; i2++) {
        if (!inBase64) {
          if (buf[i2] == plusChar) {
            res += this.iconv.decode(buf.slice(lastI, i2), "ascii");
            lastI = i2 + 1;
            inBase64 = true;
          }
        } else {
          if (!base64Chars[buf[i2]]) {
            if (i2 == lastI && buf[i2] == minusChar) {
              res += "+";
            } else {
              var b64str = base64Accum + buf.slice(lastI, i2).toString();
              res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
            }
            if (buf[i2] != minusChar)
              i2--;
            lastI = i2 + 1;
            inBase64 = false;
            base64Accum = "";
          }
        }
      }
      if (!inBase64) {
        res += this.iconv.decode(buf.slice(lastI), "ascii");
      } else {
        var b64str = base64Accum + buf.slice(lastI).toString();
        var canBeDecoded = b64str.length - b64str.length % 8;
        base64Accum = b64str.slice(canBeDecoded);
        b64str = b64str.slice(0, canBeDecoded);
        res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
      }
      this.inBase64 = inBase64;
      this.base64Accum = base64Accum;
      return res;
    };
    Utf7Decoder.prototype.end = function() {
      var res = "";
      if (this.inBase64 && this.base64Accum.length > 0)
        res = this.iconv.decode(Buffer3.from(this.base64Accum, "base64"), "utf16-be");
      this.inBase64 = false;
      this.base64Accum = "";
      return res;
    };
    exports2.utf7imap = Utf7IMAPCodec;
    function Utf7IMAPCodec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;
    Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;
    Utf7IMAPCodec.prototype.bomAware = true;
    function Utf7IMAPEncoder(options, codec3) {
      this.iconv = codec3.iconv;
      this.inBase64 = false;
      this.base64Accum = Buffer3.alloc(6);
      this.base64AccumIdx = 0;
    }
    Utf7IMAPEncoder.prototype.write = function(str) {
      var inBase64 = this.inBase64, base64Accum = this.base64Accum, base64AccumIdx = this.base64AccumIdx, buf = Buffer3.alloc(str.length * 5 + 10), bufIdx = 0;
      for (var i2 = 0; i2 < str.length; i2++) {
        var uChar = str.charCodeAt(i2);
        if (32 <= uChar && uChar <= 126) {
          if (inBase64) {
            if (base64AccumIdx > 0) {
              bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
              base64AccumIdx = 0;
            }
            buf[bufIdx++] = minusChar;
            inBase64 = false;
          }
          if (!inBase64) {
            buf[bufIdx++] = uChar;
            if (uChar === andChar)
              buf[bufIdx++] = minusChar;
          }
        } else {
          if (!inBase64) {
            buf[bufIdx++] = andChar;
            inBase64 = true;
          }
          if (inBase64) {
            base64Accum[base64AccumIdx++] = uChar >> 8;
            base64Accum[base64AccumIdx++] = uChar & 255;
            if (base64AccumIdx == base64Accum.length) {
              bufIdx += buf.write(base64Accum.toString("base64").replace(/\//g, ","), bufIdx);
              base64AccumIdx = 0;
            }
          }
        }
      }
      this.inBase64 = inBase64;
      this.base64AccumIdx = base64AccumIdx;
      return buf.slice(0, bufIdx);
    };
    Utf7IMAPEncoder.prototype.end = function() {
      var buf = Buffer3.alloc(10), bufIdx = 0;
      if (this.inBase64) {
        if (this.base64AccumIdx > 0) {
          bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
          this.base64AccumIdx = 0;
        }
        buf[bufIdx++] = minusChar;
        this.inBase64 = false;
      }
      return buf.slice(0, bufIdx);
    };
    function Utf7IMAPDecoder(options, codec3) {
      this.iconv = codec3.iconv;
      this.inBase64 = false;
      this.base64Accum = "";
    }
    var base64IMAPChars = base64Chars.slice();
    base64IMAPChars[",".charCodeAt(0)] = true;
    Utf7IMAPDecoder.prototype.write = function(buf) {
      var res = "", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;
      for (var i2 = 0; i2 < buf.length; i2++) {
        if (!inBase64) {
          if (buf[i2] == andChar) {
            res += this.iconv.decode(buf.slice(lastI, i2), "ascii");
            lastI = i2 + 1;
            inBase64 = true;
          }
        } else {
          if (!base64IMAPChars[buf[i2]]) {
            if (i2 == lastI && buf[i2] == minusChar) {
              res += "&";
            } else {
              var b64str = base64Accum + buf.slice(lastI, i2).toString().replace(/,/g, "/");
              res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
            }
            if (buf[i2] != minusChar)
              i2--;
            lastI = i2 + 1;
            inBase64 = false;
            base64Accum = "";
          }
        }
      }
      if (!inBase64) {
        res += this.iconv.decode(buf.slice(lastI), "ascii");
      } else {
        var b64str = base64Accum + buf.slice(lastI).toString().replace(/,/g, "/");
        var canBeDecoded = b64str.length - b64str.length % 8;
        base64Accum = b64str.slice(canBeDecoded);
        b64str = b64str.slice(0, canBeDecoded);
        res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
      }
      this.inBase64 = inBase64;
      this.base64Accum = base64Accum;
      return res;
    };
    Utf7IMAPDecoder.prototype.end = function() {
      var res = "";
      if (this.inBase64 && this.base64Accum.length > 0)
        res = this.iconv.decode(Buffer3.from(this.base64Accum, "base64"), "utf16-be");
      this.inBase64 = false;
      this.base64Accum = "";
      return res;
    };
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/sbcs-codec.js
var require_sbcs_codec2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/sbcs-codec.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2._sbcs = SBCSCodec;
    function SBCSCodec(codecOptions, iconv) {
      if (!codecOptions)
        throw new Error("SBCS codec is called without the data.");
      if (!codecOptions.chars || codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256)
        throw new Error("Encoding '" + codecOptions.type + "' has incorrect 'chars' (must be of len 128 or 256)");
      if (codecOptions.chars.length === 128) {
        var asciiString = "";
        for (var i = 0; i < 128; i++)
          asciiString += String.fromCharCode(i);
        codecOptions.chars = asciiString + codecOptions.chars;
      }
      this.decodeBuf = Buffer3.from(codecOptions.chars, "ucs2");
      var encodeBuf = Buffer3.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0));
      for (var i = 0; i < codecOptions.chars.length; i++)
        encodeBuf[codecOptions.chars.charCodeAt(i)] = i;
      this.encodeBuf = encodeBuf;
    }
    SBCSCodec.prototype.encoder = SBCSEncoder;
    SBCSCodec.prototype.decoder = SBCSDecoder;
    function SBCSEncoder(options, codec3) {
      this.encodeBuf = codec3.encodeBuf;
    }
    SBCSEncoder.prototype.write = function(str) {
      var buf = Buffer3.alloc(str.length);
      for (var i = 0; i < str.length; i++)
        buf[i] = this.encodeBuf[str.charCodeAt(i)];
      return buf;
    };
    SBCSEncoder.prototype.end = function() {
    };
    function SBCSDecoder(options, codec3) {
      this.decodeBuf = codec3.decodeBuf;
    }
    SBCSDecoder.prototype.write = function(buf) {
      var decodeBuf = this.decodeBuf;
      var newBuf = Buffer3.alloc(buf.length * 2);
      var idx1 = 0, idx2 = 0;
      for (var i = 0; i < buf.length; i++) {
        idx1 = buf[i] * 2;
        idx2 = i * 2;
        newBuf[idx2] = decodeBuf[idx1];
        newBuf[idx2 + 1] = decodeBuf[idx1 + 1];
      }
      return newBuf.toString("ucs2");
    };
    SBCSDecoder.prototype.end = function() {
    };
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/sbcs-data.js
var require_sbcs_data2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/sbcs-data.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      // Not supported by iconv, not sure why.
      "10029": "maccenteuro",
      "maccenteuro": {
        "type": "_sbcs",
        "chars": "\xC4\u0100\u0101\xC9\u0104\xD6\xDC\xE1\u0105\u010C\xE4\u010D\u0106\u0107\xE9\u0179\u017A\u010E\xED\u010F\u0112\u0113\u0116\xF3\u0117\xF4\xF6\xF5\xFA\u011A\u011B\xFC\u2020\xB0\u0118\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\u0119\xA8\u2260\u0123\u012E\u012F\u012A\u2264\u2265\u012B\u0136\u2202\u2211\u0142\u013B\u013C\u013D\u013E\u0139\u013A\u0145\u0146\u0143\xAC\u221A\u0144\u0147\u2206\xAB\xBB\u2026\xA0\u0148\u0150\xD5\u0151\u014C\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\u014D\u0154\u0155\u0158\u2039\u203A\u0159\u0156\u0157\u0160\u201A\u201E\u0161\u015A\u015B\xC1\u0164\u0165\xCD\u017D\u017E\u016A\xD3\xD4\u016B\u016E\xDA\u016F\u0170\u0171\u0172\u0173\xDD\xFD\u0137\u017B\u0141\u017C\u0122\u02C7"
      },
      "808": "cp808",
      "ibm808": "cp808",
      "cp808": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0404\u0454\u0407\u0457\u040E\u045E\xB0\u2219\xB7\u221A\u2116\u20AC\u25A0\xA0"
      },
      "mik": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2514\u2534\u252C\u251C\u2500\u253C\u2563\u2551\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2510\u2591\u2592\u2593\u2502\u2524\u2116\xA7\u2557\u255D\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "cp720": {
        "type": "_sbcs",
        "chars": "\x80\x81\xE9\xE2\x84\xE0\x86\xE7\xEA\xEB\xE8\xEF\xEE\x8D\x8E\x8F\x90\u0651\u0652\xF4\xA4\u0640\xFB\xF9\u0621\u0622\u0623\u0624\xA3\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0636\u0637\u0638\u0639\u063A\u0641\xB5\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u2261\u064B\u064C\u064D\u064E\u064F\u0650\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      // Aliases of generated encodings.
      "ascii8bit": "ascii",
      "usascii": "ascii",
      "ansix34": "ascii",
      "ansix341968": "ascii",
      "ansix341986": "ascii",
      "csascii": "ascii",
      "cp367": "ascii",
      "ibm367": "ascii",
      "isoir6": "ascii",
      "iso646us": "ascii",
      "iso646irv": "ascii",
      "us": "ascii",
      "latin1": "iso88591",
      "latin2": "iso88592",
      "latin3": "iso88593",
      "latin4": "iso88594",
      "latin5": "iso88599",
      "latin6": "iso885910",
      "latin7": "iso885913",
      "latin8": "iso885914",
      "latin9": "iso885915",
      "latin10": "iso885916",
      "csisolatin1": "iso88591",
      "csisolatin2": "iso88592",
      "csisolatin3": "iso88593",
      "csisolatin4": "iso88594",
      "csisolatincyrillic": "iso88595",
      "csisolatinarabic": "iso88596",
      "csisolatingreek": "iso88597",
      "csisolatinhebrew": "iso88598",
      "csisolatin5": "iso88599",
      "csisolatin6": "iso885910",
      "l1": "iso88591",
      "l2": "iso88592",
      "l3": "iso88593",
      "l4": "iso88594",
      "l5": "iso88599",
      "l6": "iso885910",
      "l7": "iso885913",
      "l8": "iso885914",
      "l9": "iso885915",
      "l10": "iso885916",
      "isoir14": "iso646jp",
      "isoir57": "iso646cn",
      "isoir100": "iso88591",
      "isoir101": "iso88592",
      "isoir109": "iso88593",
      "isoir110": "iso88594",
      "isoir144": "iso88595",
      "isoir127": "iso88596",
      "isoir126": "iso88597",
      "isoir138": "iso88598",
      "isoir148": "iso88599",
      "isoir157": "iso885910",
      "isoir166": "tis620",
      "isoir179": "iso885913",
      "isoir199": "iso885914",
      "isoir203": "iso885915",
      "isoir226": "iso885916",
      "cp819": "iso88591",
      "ibm819": "iso88591",
      "cyrillic": "iso88595",
      "arabic": "iso88596",
      "arabic8": "iso88596",
      "ecma114": "iso88596",
      "asmo708": "iso88596",
      "greek": "iso88597",
      "greek8": "iso88597",
      "ecma118": "iso88597",
      "elot928": "iso88597",
      "hebrew": "iso88598",
      "hebrew8": "iso88598",
      "turkish": "iso88599",
      "turkish8": "iso88599",
      "thai": "iso885911",
      "thai8": "iso885911",
      "celtic": "iso885914",
      "celtic8": "iso885914",
      "isoceltic": "iso885914",
      "tis6200": "tis620",
      "tis62025291": "tis620",
      "tis62025330": "tis620",
      "10000": "macroman",
      "10006": "macgreek",
      "10007": "maccyrillic",
      "10079": "maciceland",
      "10081": "macturkish",
      "cspc8codepage437": "cp437",
      "cspc775baltic": "cp775",
      "cspc850multilingual": "cp850",
      "cspcp852": "cp852",
      "cspc862latinhebrew": "cp862",
      "cpgr": "cp869",
      "msee": "cp1250",
      "mscyrl": "cp1251",
      "msansi": "cp1252",
      "msgreek": "cp1253",
      "msturk": "cp1254",
      "mshebr": "cp1255",
      "msarab": "cp1256",
      "winbaltrim": "cp1257",
      "cp20866": "koi8r",
      "20866": "koi8r",
      "ibm878": "koi8r",
      "cskoi8r": "koi8r",
      "cp21866": "koi8u",
      "21866": "koi8u",
      "ibm1168": "koi8u",
      "strk10482002": "rk1048",
      "tcvn5712": "tcvn",
      "tcvn57121": "tcvn",
      "gb198880": "iso646cn",
      "cn": "iso646cn",
      "csiso14jisc6220ro": "iso646jp",
      "jisc62201969ro": "iso646jp",
      "jp": "iso646jp",
      "cshproman8": "hproman8",
      "r8": "hproman8",
      "roman8": "hproman8",
      "xroman8": "hproman8",
      "ibm1051": "hproman8",
      "mac": "macintosh",
      "csmacintosh": "macintosh"
    };
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/sbcs-data-generated.js
var require_sbcs_data_generated2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/sbcs-data-generated.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      "437": "cp437",
      "737": "cp737",
      "775": "cp775",
      "850": "cp850",
      "852": "cp852",
      "855": "cp855",
      "856": "cp856",
      "857": "cp857",
      "858": "cp858",
      "860": "cp860",
      "861": "cp861",
      "862": "cp862",
      "863": "cp863",
      "864": "cp864",
      "865": "cp865",
      "866": "cp866",
      "869": "cp869",
      "874": "windows874",
      "922": "cp922",
      "1046": "cp1046",
      "1124": "cp1124",
      "1125": "cp1125",
      "1129": "cp1129",
      "1133": "cp1133",
      "1161": "cp1161",
      "1162": "cp1162",
      "1163": "cp1163",
      "1250": "windows1250",
      "1251": "windows1251",
      "1252": "windows1252",
      "1253": "windows1253",
      "1254": "windows1254",
      "1255": "windows1255",
      "1256": "windows1256",
      "1257": "windows1257",
      "1258": "windows1258",
      "28591": "iso88591",
      "28592": "iso88592",
      "28593": "iso88593",
      "28594": "iso88594",
      "28595": "iso88595",
      "28596": "iso88596",
      "28597": "iso88597",
      "28598": "iso88598",
      "28599": "iso88599",
      "28600": "iso885910",
      "28601": "iso885911",
      "28603": "iso885913",
      "28604": "iso885914",
      "28605": "iso885915",
      "28606": "iso885916",
      "windows874": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\uFFFD\uFFFD\uFFFD\u2026\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "win874": "windows874",
      "cp874": "windows874",
      "windows1250": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\u0160\u2039\u015A\u0164\u017D\u0179\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0161\u203A\u015B\u0165\u017E\u017A\xA0\u02C7\u02D8\u0141\xA4\u0104\xA6\xA7\xA8\xA9\u015E\xAB\xAC\xAD\xAE\u017B\xB0\xB1\u02DB\u0142\xB4\xB5\xB6\xB7\xB8\u0105\u015F\xBB\u013D\u02DD\u013E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9"
      },
      "win1250": "windows1250",
      "cp1250": "windows1250",
      "windows1251": {
        "type": "_sbcs",
        "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u040C\u040B\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u045C\u045B\u045F\xA0\u040E\u045E\u0408\xA4\u0490\xA6\xA7\u0401\xA9\u0404\xAB\xAC\xAD\xAE\u0407\xB0\xB1\u0406\u0456\u0491\xB5\xB6\xB7\u0451\u2116\u0454\xBB\u0458\u0405\u0455\u0457\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
      },
      "win1251": "windows1251",
      "cp1251": "windows1251",
      "windows1252": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\u017D\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\u017E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "win1252": "windows1252",
      "cp1252": "windows1252",
      "windows1253": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0385\u0386\xA3\xA4\xA5\xA6\xA7\xA8\xA9\uFFFD\xAB\xAC\xAD\xAE\u2015\xB0\xB1\xB2\xB3\u0384\xB5\xB6\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD"
      },
      "win1253": "windows1253",
      "cp1253": "windows1253",
      "windows1254": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF"
      },
      "win1254": "windows1254",
      "cp1254": "windows1254",
      "windows1255": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\xA1\xA2\xA3\u20AA\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\xBF\u05B0\u05B1\u05B2\u05B3\u05B4\u05B5\u05B6\u05B7\u05B8\u05B9\u05BA\u05BB\u05BC\u05BD\u05BE\u05BF\u05C0\u05C1\u05C2\u05C3\u05F0\u05F1\u05F2\u05F3\u05F4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD"
      },
      "win1255": "windows1255",
      "cp1255": "windows1255",
      "windows1256": {
        "type": "_sbcs",
        "chars": "\u20AC\u067E\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0679\u2039\u0152\u0686\u0698\u0688\u06AF\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u06A9\u2122\u0691\u203A\u0153\u200C\u200D\u06BA\xA0\u060C\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\u06BE\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\u061B\xBB\xBC\xBD\xBE\u061F\u06C1\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\xD7\u0637\u0638\u0639\u063A\u0640\u0641\u0642\u0643\xE0\u0644\xE2\u0645\u0646\u0647\u0648\xE7\xE8\xE9\xEA\xEB\u0649\u064A\xEE\xEF\u064B\u064C\u064D\u064E\xF4\u064F\u0650\xF7\u0651\xF9\u0652\xFB\xFC\u200E\u200F\u06D2"
      },
      "win1256": "windows1256",
      "cp1256": "windows1256",
      "windows1257": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\xA8\u02C7\xB8\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\xAF\u02DB\uFFFD\xA0\uFFFD\xA2\xA3\xA4\uFFFD\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u02D9"
      },
      "win1257": "windows1257",
      "cp1257": "windows1257",
      "windows1258": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
      },
      "win1258": "windows1258",
      "cp1258": "windows1258",
      "iso88591": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "cp28591": "iso88591",
      "iso88592": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u02D8\u0141\xA4\u013D\u015A\xA7\xA8\u0160\u015E\u0164\u0179\xAD\u017D\u017B\xB0\u0105\u02DB\u0142\xB4\u013E\u015B\u02C7\xB8\u0161\u015F\u0165\u017A\u02DD\u017E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9"
      },
      "cp28592": "iso88592",
      "iso88593": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0126\u02D8\xA3\xA4\uFFFD\u0124\xA7\xA8\u0130\u015E\u011E\u0134\xAD\uFFFD\u017B\xB0\u0127\xB2\xB3\xB4\xB5\u0125\xB7\xB8\u0131\u015F\u011F\u0135\xBD\uFFFD\u017C\xC0\xC1\xC2\uFFFD\xC4\u010A\u0108\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\uFFFD\xD1\xD2\xD3\xD4\u0120\xD6\xD7\u011C\xD9\xDA\xDB\xDC\u016C\u015C\xDF\xE0\xE1\xE2\uFFFD\xE4\u010B\u0109\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\uFFFD\xF1\xF2\xF3\xF4\u0121\xF6\xF7\u011D\xF9\xFA\xFB\xFC\u016D\u015D\u02D9"
      },
      "cp28593": "iso88593",
      "iso88594": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0138\u0156\xA4\u0128\u013B\xA7\xA8\u0160\u0112\u0122\u0166\xAD\u017D\xAF\xB0\u0105\u02DB\u0157\xB4\u0129\u013C\u02C7\xB8\u0161\u0113\u0123\u0167\u014A\u017E\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\u012A\u0110\u0145\u014C\u0136\xD4\xD5\xD6\xD7\xD8\u0172\xDA\xDB\xDC\u0168\u016A\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\u012B\u0111\u0146\u014D\u0137\xF4\xF5\xF6\xF7\xF8\u0173\xFA\xFB\xFC\u0169\u016B\u02D9"
      },
      "cp28594": "iso88594",
      "iso88595": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0403\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0453\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F"
      },
      "cp28595": "iso88595",
      "iso88596": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\uFFFD\uFFFD\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u060C\xAD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u061B\uFFFD\uFFFD\uFFFD\u061F\uFFFD\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\u0638\u0639\u063A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "cp28596": "iso88596",
      "iso88597": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u2018\u2019\xA3\u20AC\u20AF\xA6\xA7\xA8\xA9\u037A\xAB\xAC\xAD\uFFFD\u2015\xB0\xB1\xB2\xB3\u0384\u0385\u0386\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD"
      },
      "cp28597": "iso88597",
      "iso88598": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2017\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD"
      },
      "cp28598": "iso88598",
      "iso88599": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF"
      },
      "cp28599": "iso88599",
      "iso885910": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0112\u0122\u012A\u0128\u0136\xA7\u013B\u0110\u0160\u0166\u017D\xAD\u016A\u014A\xB0\u0105\u0113\u0123\u012B\u0129\u0137\xB7\u013C\u0111\u0161\u0167\u017E\u2015\u016B\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\xCF\xD0\u0145\u014C\xD3\xD4\xD5\xD6\u0168\xD8\u0172\xDA\xDB\xDC\xDD\xDE\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\xEF\xF0\u0146\u014D\xF3\xF4\xF5\xF6\u0169\xF8\u0173\xFA\xFB\xFC\xFD\xFE\u0138"
      },
      "cp28600": "iso885910",
      "iso885911": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "cp28601": "iso885911",
      "iso885913": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u201D\xA2\xA3\xA4\u201E\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\u201C\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u2019"
      },
      "cp28603": "iso885913",
      "iso885914": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u1E02\u1E03\xA3\u010A\u010B\u1E0A\xA7\u1E80\xA9\u1E82\u1E0B\u1EF2\xAD\xAE\u0178\u1E1E\u1E1F\u0120\u0121\u1E40\u1E41\xB6\u1E56\u1E81\u1E57\u1E83\u1E60\u1EF3\u1E84\u1E85\u1E61\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0174\xD1\xD2\xD3\xD4\xD5\xD6\u1E6A\xD8\xD9\xDA\xDB\xDC\xDD\u0176\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0175\xF1\xF2\xF3\xF4\xF5\xF6\u1E6B\xF8\xF9\xFA\xFB\xFC\xFD\u0177\xFF"
      },
      "cp28604": "iso885914",
      "iso885915": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\u0160\xA7\u0161\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u017D\xB5\xB6\xB7\u017E\xB9\xBA\xBB\u0152\u0153\u0178\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "cp28605": "iso885915",
      "iso885916": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0105\u0141\u20AC\u201E\u0160\xA7\u0161\xA9\u0218\xAB\u0179\xAD\u017A\u017B\xB0\xB1\u010C\u0142\u017D\u201D\xB6\xB7\u017E\u010D\u0219\xBB\u0152\u0153\u0178\u017C\xC0\xC1\xC2\u0102\xC4\u0106\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0110\u0143\xD2\xD3\xD4\u0150\xD6\u015A\u0170\xD9\xDA\xDB\xDC\u0118\u021A\xDF\xE0\xE1\xE2\u0103\xE4\u0107\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0111\u0144\xF2\xF3\xF4\u0151\xF6\u015B\u0171\xF9\xFA\xFB\xFC\u0119\u021B\xFF"
      },
      "cp28606": "iso885916",
      "cp437": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm437": "cp437",
      "csibm437": "cp437",
      "cp737": {
        "type": "_sbcs",
        "chars": "\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u03C5\u03C6\u03C7\u03C8\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03C9\u03AC\u03AD\u03AE\u03CA\u03AF\u03CC\u03CD\u03CB\u03CE\u0386\u0388\u0389\u038A\u038C\u038E\u038F\xB1\u2265\u2264\u03AA\u03AB\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm737": "cp737",
      "csibm737": "cp737",
      "cp775": {
        "type": "_sbcs",
        "chars": "\u0106\xFC\xE9\u0101\xE4\u0123\xE5\u0107\u0142\u0113\u0156\u0157\u012B\u0179\xC4\xC5\xC9\xE6\xC6\u014D\xF6\u0122\xA2\u015A\u015B\xD6\xDC\xF8\xA3\xD8\xD7\xA4\u0100\u012A\xF3\u017B\u017C\u017A\u201D\xA6\xA9\xAE\xAC\xBD\xBC\u0141\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0104\u010C\u0118\u0116\u2563\u2551\u2557\u255D\u012E\u0160\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0172\u016A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u017D\u0105\u010D\u0119\u0117\u012F\u0161\u0173\u016B\u017E\u2518\u250C\u2588\u2584\u258C\u2590\u2580\xD3\xDF\u014C\u0143\xF5\xD5\xB5\u0144\u0136\u0137\u013B\u013C\u0146\u0112\u0145\u2019\xAD\xB1\u201C\xBE\xB6\xA7\xF7\u201E\xB0\u2219\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm775": "cp775",
      "csibm775": "cp775",
      "cp850": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u0131\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm850": "cp850",
      "csibm850": "cp850",
      "cp852": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\u016F\u0107\xE7\u0142\xEB\u0150\u0151\xEE\u0179\xC4\u0106\xC9\u0139\u013A\xF4\xF6\u013D\u013E\u015A\u015B\xD6\xDC\u0164\u0165\u0141\xD7\u010D\xE1\xED\xF3\xFA\u0104\u0105\u017D\u017E\u0118\u0119\xAC\u017A\u010C\u015F\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\u011A\u015E\u2563\u2551\u2557\u255D\u017B\u017C\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0102\u0103\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u0111\u0110\u010E\xCB\u010F\u0147\xCD\xCE\u011B\u2518\u250C\u2588\u2584\u0162\u016E\u2580\xD3\xDF\xD4\u0143\u0144\u0148\u0160\u0161\u0154\xDA\u0155\u0170\xFD\xDD\u0163\xB4\xAD\u02DD\u02DB\u02C7\u02D8\xA7\xF7\xB8\xB0\xA8\u02D9\u0171\u0158\u0159\u25A0\xA0"
      },
      "ibm852": "cp852",
      "csibm852": "cp852",
      "cp855": {
        "type": "_sbcs",
        "chars": "\u0452\u0402\u0453\u0403\u0451\u0401\u0454\u0404\u0455\u0405\u0456\u0406\u0457\u0407\u0458\u0408\u0459\u0409\u045A\u040A\u045B\u040B\u045C\u040C\u045E\u040E\u045F\u040F\u044E\u042E\u044A\u042A\u0430\u0410\u0431\u0411\u0446\u0426\u0434\u0414\u0435\u0415\u0444\u0424\u0433\u0413\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0445\u0425\u0438\u0418\u2563\u2551\u2557\u255D\u0439\u0419\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u043A\u041A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u043B\u041B\u043C\u041C\u043D\u041D\u043E\u041E\u043F\u2518\u250C\u2588\u2584\u041F\u044F\u2580\u042F\u0440\u0420\u0441\u0421\u0442\u0422\u0443\u0423\u0436\u0416\u0432\u0412\u044C\u042C\u2116\xAD\u044B\u042B\u0437\u0417\u0448\u0428\u044D\u042D\u0449\u0429\u0447\u0427\xA7\u25A0\xA0"
      },
      "ibm855": "cp855",
      "csibm855": "cp855",
      "cp856": {
        "type": "_sbcs",
        "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\xA3\uFFFD\xD7\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAE\xAC\xBD\xBC\uFFFD\xAB\xBB\u2591\u2592\u2593\u2502\u2524\uFFFD\uFFFD\uFFFD\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\uFFFD\uFFFD\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2518\u250C\u2588\u2584\xA6\uFFFD\u2580\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xB5\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm856": "cp856",
      "csibm856": "cp856",
      "cp857": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\u0131\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\u0130\xD6\xDC\xF8\xA3\xD8\u015E\u015F\xE1\xED\xF3\xFA\xF1\xD1\u011E\u011F\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xBA\xAA\xCA\xCB\xC8\uFFFD\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\uFFFD\xD7\xDA\xDB\xD9\xEC\xFF\xAF\xB4\xAD\xB1\uFFFD\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm857": "cp857",
      "csibm857": "cp857",
      "cp858": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u20AC\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm858": "cp858",
      "csibm858": "cp858",
      "cp860": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE3\xE0\xC1\xE7\xEA\xCA\xE8\xCD\xD4\xEC\xC3\xC2\xC9\xC0\xC8\xF4\xF5\xF2\xDA\xF9\xCC\xD5\xDC\xA2\xA3\xD9\u20A7\xD3\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xD2\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm860": "cp860",
      "csibm860": "cp860",
      "cp861": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xD0\xF0\xDE\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xFE\xFB\xDD\xFD\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xC1\xCD\xD3\xDA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm861": "cp861",
      "csibm861": "cp861",
      "cp862": {
        "type": "_sbcs",
        "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm862": "cp862",
      "csibm862": "cp862",
      "cp863": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xC2\xE0\xB6\xE7\xEA\xEB\xE8\xEF\xEE\u2017\xC0\xA7\xC9\xC8\xCA\xF4\xCB\xCF\xFB\xF9\xA4\xD4\xDC\xA2\xA3\xD9\xDB\u0192\xA6\xB4\xF3\xFA\xA8\xB8\xB3\xAF\xCE\u2310\xAC\xBD\xBC\xBE\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm863": "cp863",
      "csibm863": "cp863",
      "cp864": {
        "type": "_sbcs",
        "chars": "\0
\x07\b	\n\v\f\r\x1B !\"#$\u066A&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xB0\xB7\u2219\u221A\u2592\u2500\u2502\u253C\u2524\u252C\u251C\u2534\u2510\u250C\u2514\u2518\u03B2\u221E\u03C6\xB1\xBD\xBC\u2248\xAB\xBB\uFEF7\uFEF8\uFFFD\uFFFD\uFEFB\uFEFC\uFFFD\xA0\xAD\uFE82\xA3\xA4\uFE84\uFFFD\uFFFD\uFE8E\uFE8F\uFE95\uFE99\u060C\uFE9D\uFEA1\uFEA5\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFED1\u061B\uFEB1\uFEB5\uFEB9\u061F\xA2\uFE80\uFE81\uFE83\uFE85\uFECA\uFE8B\uFE8D\uFE91\uFE93\uFE97\uFE9B\uFE9F\uFEA3\uFEA7\uFEA9\uFEAB\uFEAD\uFEAF\uFEB3\uFEB7\uFEBB\uFEBF\uFEC1\uFEC5\uFECB\uFECF\xA6\xAC\xF7\xD7\uFEC9\u0640\uFED3\uFED7\uFEDB\uFEDF\uFEE3\uFEE7\uFEEB\uFEED\uFEEF\uFEF3\uFEBD\uFECC\uFECE\uFECD\uFEE1\uFE7D\u0651\uFEE5\uFEE9\uFEEC\uFEF0\uFEF2\uFED0\uFED5\uFEF5\uFEF6\uFEDD\uFED9\uFEF1\u25A0\uFFFD"
      },
      "ibm864": "cp864",
      "csibm864": "cp864",
      "cp865": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xA4\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm865": "cp865",
      "csibm865": "cp865",
      "cp866": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0404\u0454\u0407\u0457\u040E\u045E\xB0\u2219\xB7\u221A\u2116\xA4\u25A0\xA0"
      },
      "ibm866": "cp866",
      "csibm866": "cp866",
      "cp869": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0386\uFFFD\xB7\xAC\xA6\u2018\u2019\u0388\u2015\u0389\u038A\u03AA\u038C\uFFFD\uFFFD\u038E\u03AB\xA9\u038F\xB2\xB3\u03AC\xA3\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03CD\u0391\u0392\u0393\u0394\u0395\u0396\u0397\xBD\u0398\u0399\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u039A\u039B\u039C\u039D\u2563\u2551\u2557\u255D\u039E\u039F\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u03A0\u03A1\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u2518\u250C\u2588\u2584\u03B4\u03B5\u2580\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u0384\xAD\xB1\u03C5\u03C6\u03C7\xA7\u03C8\u0385\xB0\xA8\u03C9\u03CB\u03B0\u03CE\u25A0\xA0"
      },
      "ibm869": "cp869",
      "csibm869": "cp869",
      "cp922": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\u203E\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0160\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\u017D\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0161\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\u017E\xFF"
      },
      "ibm922": "cp922",
      "csibm922": "cp922",
      "cp1046": {
        "type": "_sbcs",
        "chars": "\uFE88\xD7\xF7\uF8F6\uF8F5\uF8F4\uF8F7\uFE71\x88\u25A0\u2502\u2500\u2510\u250C\u2514\u2518\uFE79\uFE7B\uFE7D\uFE7F\uFE77\uFE8A\uFEF0\uFEF3\uFEF2\uFECE\uFECF\uFED0\uFEF6\uFEF8\uFEFA\uFEFC\xA0\uF8FA\uF8F9\uF8F8\xA4\uF8FB\uFE8B\uFE91\uFE97\uFE9B\uFE9F\uFEA3\u060C\xAD\uFEA7\uFEB3\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFEB7\u061B\uFEBB\uFEBF\uFECA\u061F\uFECB\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\uFEC7\u0639\u063A\uFECC\uFE82\uFE84\uFE8E\uFED3\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFED7\uFEDB\uFEDF\uF8FC\uFEF5\uFEF7\uFEF9\uFEFB\uFEE3\uFEE7\uFEEC\uFEE9\uFFFD"
      },
      "ibm1046": "cp1046",
      "csibm1046": "cp1046",
      "cp1124": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0490\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0491\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F"
      },
      "ibm1124": "cp1124",
      "csibm1124": "cp1124",
      "cp1125": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0490\u0491\u0404\u0454\u0406\u0456\u0407\u0457\xB7\u221A\u2116\xA4\u25A0\xA0"
      },
      "ibm1125": "cp1125",
      "csibm1125": "cp1125",
      "cp1129": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
      },
      "ibm1129": "cp1129",
      "csibm1129": "cp1129",
      "cp1133": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E81\u0E82\u0E84\u0E87\u0E88\u0EAA\u0E8A\u0E8D\u0E94\u0E95\u0E96\u0E97\u0E99\u0E9A\u0E9B\u0E9C\u0E9D\u0E9E\u0E9F\u0EA1\u0EA2\u0EA3\u0EA5\u0EA7\u0EAB\u0EAD\u0EAE\uFFFD\uFFFD\uFFFD\u0EAF\u0EB0\u0EB2\u0EB3\u0EB4\u0EB5\u0EB6\u0EB7\u0EB8\u0EB9\u0EBC\u0EB1\u0EBB\u0EBD\uFFFD\uFFFD\uFFFD\u0EC0\u0EC1\u0EC2\u0EC3\u0EC4\u0EC8\u0EC9\u0ECA\u0ECB\u0ECC\u0ECD\u0EC6\uFFFD\u0EDC\u0EDD\u20AD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0ED0\u0ED1\u0ED2\u0ED3\u0ED4\u0ED5\u0ED6\u0ED7\u0ED8\u0ED9\uFFFD\uFFFD\xA2\xAC\xA6\uFFFD"
      },
      "ibm1133": "cp1133",
      "csibm1133": "cp1133",
      "cp1161": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E48\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\u0E49\u0E4A\u0E4B\u20AC\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\xA2\xAC\xA6\xA0"
      },
      "ibm1161": "cp1161",
      "csibm1161": "cp1161",
      "cp1162": {
        "type": "_sbcs",
        "chars": "\u20AC\x81\x82\x83\x84\u2026\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "ibm1162": "cp1162",
      "csibm1162": "cp1162",
      "cp1163": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
      },
      "ibm1163": "cp1163",
      "csibm1163": "cp1163",
      "maccroatian": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\u0160\u2122\xB4\xA8\u2260\u017D\xD8\u221E\xB1\u2264\u2265\u2206\xB5\u2202\u2211\u220F\u0161\u222B\xAA\xBA\u2126\u017E\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u0106\xAB\u010C\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u0110\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\uFFFD\xA9\u2044\xA4\u2039\u203A\xC6\xBB\u2013\xB7\u201A\u201E\u2030\xC2\u0107\xC1\u010D\xC8\xCD\xCE\xCF\xCC\xD3\xD4\u0111\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u03C0\xCB\u02DA\xB8\xCA\xE6\u02C7"
      },
      "maccyrillic": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\xA2\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u2202\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4"
      },
      "macgreek": {
        "type": "_sbcs",
        "chars": "\xC4\xB9\xB2\xC9\xB3\xD6\xDC\u0385\xE0\xE2\xE4\u0384\xA8\xE7\xE9\xE8\xEA\xEB\xA3\u2122\xEE\xEF\u2022\xBD\u2030\xF4\xF6\xA6\xAD\xF9\xFB\xFC\u2020\u0393\u0394\u0398\u039B\u039E\u03A0\xDF\xAE\xA9\u03A3\u03AA\xA7\u2260\xB0\u0387\u0391\xB1\u2264\u2265\xA5\u0392\u0395\u0396\u0397\u0399\u039A\u039C\u03A6\u03AB\u03A8\u03A9\u03AC\u039D\xAC\u039F\u03A1\u2248\u03A4\xAB\xBB\u2026\xA0\u03A5\u03A7\u0386\u0388\u0153\u2013\u2015\u201C\u201D\u2018\u2019\xF7\u0389\u038A\u038C\u038E\u03AD\u03AE\u03AF\u03CC\u038F\u03CD\u03B1\u03B2\u03C8\u03B4\u03B5\u03C6\u03B3\u03B7\u03B9\u03BE\u03BA\u03BB\u03BC\u03BD\u03BF\u03C0\u03CE\u03C1\u03C3\u03C4\u03B8\u03C9\u03C2\u03C7\u03C5\u03B6\u03CA\u03CB\u0390\u03B0\uFFFD"
      },
      "maciceland": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\xDD\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\xD0\xF0\xDE\xFE\xFD\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macroman": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macromania": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\u0102\u015E\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\u0103\u015F\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\u0162\u0163\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macthai": {
        "type": "_sbcs",
        "chars": "\xAB\xBB\u2026\uF88C\uF88F\uF892\uF895\uF898\uF88B\uF88E\uF891\uF894\uF897\u201C\u201D\uF899\uFFFD\u2022\uF884\uF889\uF885\uF886\uF887\uF888\uF88A\uF88D\uF890\uF893\uF896\u2018\u2019\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFEFF\u200B\u2013\u2014\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u2122\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\xAE\xA9\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "macturkish": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u011E\u011F\u0130\u0131\u015E\u015F\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\uFFFD\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macukraine": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\u0490\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u0491\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4"
      },
      "koi8r": {
        "type": "_sbcs",
        "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u2553\u2554\u2555\u2556\u2557\u2558\u2559\u255A\u255B\u255C\u255D\u255E\u255F\u2560\u2561\u0401\u2562\u2563\u2564\u2565\u2566\u2567\u2568\u2569\u256A\u256B\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "koi8u": {
        "type": "_sbcs",
        "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u255D\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "koi8ru": {
        "type": "_sbcs",
        "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u045E\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u040E\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "koi8t": {
        "type": "_sbcs",
        "chars": "\u049B\u0493\u201A\u0492\u201E\u2026\u2020\u2021\uFFFD\u2030\u04B3\u2039\u04B2\u04B7\u04B6\uFFFD\u049A\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u04EF\u04EE\u0451\xA4\u04E3\xA6\xA7\uFFFD\uFFFD\uFFFD\xAB\xAC\xAD\xAE\uFFFD\xB0\xB1\xB2\u0401\uFFFD\u04E2\xB6\xB7\uFFFD\u2116\uFFFD\xBB\uFFFD\uFFFD\uFFFD\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "armscii8": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\u0587\u0589)(\xBB\xAB\u2014.\u055D,-\u058A\u2026\u055C\u055B\u055E\u0531\u0561\u0532\u0562\u0533\u0563\u0534\u0564\u0535\u0565\u0536\u0566\u0537\u0567\u0538\u0568\u0539\u0569\u053A\u056A\u053B\u056B\u053C\u056C\u053D\u056D\u053E\u056E\u053F\u056F\u0540\u0570\u0541\u0571\u0542\u0572\u0543\u0573\u0544\u0574\u0545\u0575\u0546\u0576\u0547\u0577\u0548\u0578\u0549\u0579\u054A\u057A\u054B\u057B\u054C\u057C\u054D\u057D\u054E\u057E\u054F\u057F\u0550\u0580\u0551\u0581\u0552\u0582\u0553\u0583\u0554\u0584\u0555\u0585\u0556\u0586\u055A\uFFFD"
      },
      "rk1048": {
        "type": "_sbcs",
        "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u049A\u04BA\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u049B\u04BB\u045F\xA0\u04B0\u04B1\u04D8\xA4\u04E8\xA6\xA7\u0401\xA9\u0492\xAB\xAC\xAD\xAE\u04AE\xB0\xB1\u0406\u0456\u04E9\xB5\xB6\xB7\u0451\u2116\u0493\xBB\u04D9\u04A2\u04A3\u04AF\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
      },
      "tcvn": {
        "type": "_sbcs",
        "chars": "\0\xDA\u1EE4\u1EEA\u1EEC\u1EEE\x07\b	\n\v\f\r\u1EE8\u1EF0\u1EF2\u1EF6\u1EF8\xDD\u1EF4\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xC0\u1EA2\xC3\xC1\u1EA0\u1EB6\u1EAC\xC8\u1EBA\u1EBC\xC9\u1EB8\u1EC6\xCC\u1EC8\u0128\xCD\u1ECA\xD2\u1ECE\xD5\xD3\u1ECC\u1ED8\u1EDC\u1EDE\u1EE0\u1EDA\u1EE2\xD9\u1EE6\u0168\xA0\u0102\xC2\xCA\xD4\u01A0\u01AF\u0110\u0103\xE2\xEA\xF4\u01A1\u01B0\u0111\u1EB0\u0300\u0309\u0303\u0301\u0323\xE0\u1EA3\xE3\xE1\u1EA1\u1EB2\u1EB1\u1EB3\u1EB5\u1EAF\u1EB4\u1EAE\u1EA6\u1EA8\u1EAA\u1EA4\u1EC0\u1EB7\u1EA7\u1EA9\u1EAB\u1EA5\u1EAD\xE8\u1EC2\u1EBB\u1EBD\xE9\u1EB9\u1EC1\u1EC3\u1EC5\u1EBF\u1EC7\xEC\u1EC9\u1EC4\u1EBE\u1ED2\u0129\xED\u1ECB\xF2\u1ED4\u1ECF\xF5\xF3\u1ECD\u1ED3\u1ED5\u1ED7\u1ED1\u1ED9\u1EDD\u1EDF\u1EE1\u1EDB\u1EE3\xF9\u1ED6\u1EE7\u0169\xFA\u1EE5\u1EEB\u1EED\u1EEF\u1EE9\u1EF1\u1EF3\u1EF7\u1EF9\xFD\u1EF5\u1ED0"
      },
      "georgianacademy": {
        "type": "_sbcs",
        "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10EF\u10F0\u10F1\u10F2\u10F3\u10F4\u10F5\u10F6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "georgianps": {
        "type": "_sbcs",
        "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10F1\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10F2\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10F3\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10F4\u10EF\u10F0\u10F5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "pt154": {
        "type": "_sbcs",
        "chars": "\u0496\u0492\u04EE\u0493\u201E\u2026\u04B6\u04AE\u04B2\u04AF\u04A0\u04E2\u04A2\u049A\u04BA\u04B8\u0497\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u04B3\u04B7\u04A1\u04E3\u04A3\u049B\u04BB\u04B9\xA0\u040E\u045E\u0408\u04E8\u0498\u04B0\xA7\u0401\xA9\u04D8\xAB\xAC\u04EF\xAE\u049C\xB0\u04B1\u0406\u0456\u0499\u04E9\xB6\xB7\u0451\u2116\u04D9\xBB\u0458\u04AA\u04AB\u049D\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
      },
      "viscii": {
        "type": "_sbcs",
        "chars": "\0
\u1EB2\u1EB4\u1EAA\x07\b	\n\v\f\r\u1EF6\u1EF8\x1B\u1EF4 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\u1EA0\u1EAE\u1EB0\u1EB6\u1EA4\u1EA6\u1EA8\u1EAC\u1EBC\u1EB8\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EE2\u1EDA\u1EDC\u1EDE\u1ECA\u1ECE\u1ECC\u1EC8\u1EE6\u0168\u1EE4\u1EF2\xD5\u1EAF\u1EB1\u1EB7\u1EA5\u1EA7\u1EA9\u1EAD\u1EBD\u1EB9\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1ED1\u1ED3\u1ED5\u1ED7\u1EE0\u01A0\u1ED9\u1EDD\u1EDF\u1ECB\u1EF0\u1EE8\u1EEA\u1EEC\u01A1\u1EDB\u01AF\xC0\xC1\xC2\xC3\u1EA2\u0102\u1EB3\u1EB5\xC8\xC9\xCA\u1EBA\xCC\xCD\u0128\u1EF3\u0110\u1EE9\xD2\xD3\xD4\u1EA1\u1EF7\u1EEB\u1EED\xD9\xDA\u1EF9\u1EF5\xDD\u1EE1\u01B0\xE0\xE1\xE2\xE3\u1EA3\u0103\u1EEF\u1EAB\xE8\xE9\xEA\u1EBB\xEC\xED\u0129\u1EC9\u0111\u1EF1\xF2\xF3\xF4\xF5\u1ECF\u1ECD\u1EE5\xF9\xFA\u0169\u1EE7\xFD\u1EE3\u1EEE"
      },
      "iso646cn": {
        "type": "_sbcs",
        "chars": "\0
\x07\b	\n\v\f\r\x1B !\"#\xA5%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "iso646jp": {
        "type": "_sbcs",
        "chars": "\0
\x07\b	\n\v\f\r\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\xA5]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "hproman8": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xC0\xC2\xC8\xCA\xCB\xCE\xCF\xB4\u02CB\u02C6\xA8\u02DC\xD9\xDB\u20A4\xAF\xDD\xFD\xB0\xC7\xE7\xD1\xF1\xA1\xBF\xA4\xA3\xA5\xA7\u0192\xA2\xE2\xEA\xF4\xFB\xE1\xE9\xF3\xFA\xE0\xE8\xF2\xF9\xE4\xEB\xF6\xFC\xC5\xEE\xD8\xC6\xE5\xED\xF8\xE6\xC4\xEC\xD6\xDC\xC9\xEF\xDF\xD4\xC1\xC3\xE3\xD0\xF0\xCD\xCC\xD3\xD2\xD5\xF5\u0160\u0161\xDA\u0178\xFF\xDE\xFE\xB7\xB5\xB6\xBE\u2014\xBC\xBD\xAA\xBA\xAB\u25A0\xBB\xB1\uFFFD"
      },
      "macintosh": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "ascii": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "tis620": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      }
    };
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/dbcs-codec.js
var require_dbcs_codec2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/dbcs-codec.js"(exports2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    exports2._dbcs = DBCSCodec;
    var UNASSIGNED = -1;
    var GB18030_CODE = -2;
    var SEQ_START = -10;
    var NODE_START = -1e3;
    var UNASSIGNED_NODE = new Array(256);
    var DEF_CHAR = -1;
    for (i = 0; i < 256; i++)
      UNASSIGNED_NODE[i] = UNASSIGNED;
    var i;
    function DBCSCodec(codecOptions, iconv) {
      this.encodingName = codecOptions.encodingName;
      if (!codecOptions)
        throw new Error("DBCS codec is called without the data.");
      if (!codecOptions.table)
        throw new Error("Encoding '" + this.encodingName + "' has no data.");
      var mappingTable = codecOptions.table();
      this.decodeTables = [];
      this.decodeTables[0] = UNASSIGNED_NODE.slice(0);
      this.decodeTableSeq = [];
      for (var i2 = 0; i2 < mappingTable.length; i2++)
        this._addDecodeChunk(mappingTable[i2]);
      this.defaultCharUnicode = iconv.defaultCharUnicode;
      this.encodeTable = [];
      this.encodeTableSeq = [];
      var skipEncodeChars = {};
      if (codecOptions.encodeSkipVals)
        for (var i2 = 0; i2 < codecOptions.encodeSkipVals.length; i2++) {
          var val = codecOptions.encodeSkipVals[i2];
          if (typeof val === "number")
            skipEncodeChars[val] = true;
          else
            for (var j = val.from; j <= val.to; j++)
              skipEncodeChars[j] = true;
        }
      this._fillEncodeTable(0, 0, skipEncodeChars);
      if (codecOptions.encodeAdd) {
        for (var uChar in codecOptions.encodeAdd)
          if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar))
            this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]);
      }
      this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)];
      if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]["?"];
      if (this.defCharSB === UNASSIGNED) this.defCharSB = "?".charCodeAt(0);
      if (typeof codecOptions.gb18030 === "function") {
        this.gb18030 = codecOptions.gb18030();
        var thirdByteNodeIdx = this.decodeTables.length;
        var thirdByteNode = this.decodeTables[thirdByteNodeIdx] = UNASSIGNED_NODE.slice(0);
        var fourthByteNodeIdx = this.decodeTables.length;
        var fourthByteNode = this.decodeTables[fourthByteNodeIdx] = UNASSIGNED_NODE.slice(0);
        for (var i2 = 129; i2 <= 254; i2++) {
          var secondByteNodeIdx = NODE_START - this.decodeTables[0][i2];
          var secondByteNode = this.decodeTables[secondByteNodeIdx];
          for (var j = 48; j <= 57; j++)
            secondByteNode[j] = NODE_START - thirdByteNodeIdx;
        }
        for (var i2 = 129; i2 <= 254; i2++)
          thirdByteNode[i2] = NODE_START - fourthByteNodeIdx;
        for (var i2 = 48; i2 <= 57; i2++)
          fourthByteNode[i2] = GB18030_CODE;
      }
    }
    DBCSCodec.prototype.encoder = DBCSEncoder;
    DBCSCodec.prototype.decoder = DBCSDecoder;
    DBCSCodec.prototype._getDecodeTrieNode = function(addr) {
      var bytes = [];
      for (; addr > 0; addr >>= 8)
        bytes.push(addr & 255);
      if (bytes.length == 0)
        bytes.push(0);
      var node = this.decodeTables[0];
      for (var i2 = bytes.length - 1; i2 > 0; i2--) {
        var val = node[bytes[i2]];
        if (val == UNASSIGNED) {
          node[bytes[i2]] = NODE_START - this.decodeTables.length;
          this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));
        } else if (val <= NODE_START) {
          node = this.decodeTables[NODE_START - val];
        } else
          throw new Error("Overwrite byte in " + this.encodingName + ", addr: " + addr.toString(16));
      }
      return node;
    };
    DBCSCodec.prototype._addDecodeChunk = function(chunk) {
      var curAddr = parseInt(chunk[0], 16);
      var writeTable = this._getDecodeTrieNode(curAddr);
      curAddr = curAddr & 255;
      for (var k = 1; k < chunk.length; k++) {
        var part = chunk[k];
        if (typeof part === "string") {
          for (var l = 0; l < part.length; ) {
            var code = part.charCodeAt(l++);
            if (55296 <= code && code < 56320) {
              var codeTrail = part.charCodeAt(l++);
              if (56320 <= codeTrail && codeTrail < 57344)
                writeTable[curAddr++] = 65536 + (code - 55296) * 1024 + (codeTrail - 56320);
              else
                throw new Error("Incorrect surrogate pair in " + this.encodingName + " at chunk " + chunk[0]);
            } else if (4080 < code && code <= 4095) {
              var len = 4095 - code + 2;
              var seq = [];
              for (var m = 0; m < len; m++)
                seq.push(part.charCodeAt(l++));
              writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length;
              this.decodeTableSeq.push(seq);
            } else
              writeTable[curAddr++] = code;
          }
        } else if (typeof part === "number") {
          var charCode = writeTable[curAddr - 1] + 1;
          for (var l = 0; l < part; l++)
            writeTable[curAddr++] = charCode++;
        } else
          throw new Error("Incorrect type '" + typeof part + "' given in " + this.encodingName + " at chunk " + chunk[0]);
      }
      if (curAddr > 255)
        throw new Error("Incorrect chunk in " + this.encodingName + " at addr " + chunk[0] + ": too long" + curAddr);
    };
    DBCSCodec.prototype._getEncodeBucket = function(uCode) {
      var high = uCode >> 8;
      if (this.encodeTable[high] === void 0)
        this.encodeTable[high] = UNASSIGNED_NODE.slice(0);
      return this.encodeTable[high];
    };
    DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) {
      var bucket = this._getEncodeBucket(uCode);
      var low = uCode & 255;
      if (bucket[low] <= SEQ_START)
        this.encodeTableSeq[SEQ_START - bucket[low]][DEF_CHAR] = dbcsCode;
      else if (bucket[low] == UNASSIGNED)
        bucket[low] = dbcsCode;
    };
    DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) {
      var uCode = seq[0];
      var bucket = this._getEncodeBucket(uCode);
      var low = uCode & 255;
      var node;
      if (bucket[low] <= SEQ_START) {
        node = this.encodeTableSeq[SEQ_START - bucket[low]];
      } else {
        node = {};
        if (bucket[low] !== UNASSIGNED) node[DEF_CHAR] = bucket[low];
        bucket[low] = SEQ_START - this.encodeTableSeq.length;
        this.encodeTableSeq.push(node);
      }
      for (var j = 1; j < seq.length - 1; j++) {
        var oldVal = node[uCode];
        if (typeof oldVal === "object")
          node = oldVal;
        else {
          node = node[uCode] = {};
          if (oldVal !== void 0)
            node[DEF_CHAR] = oldVal;
        }
      }
      uCode = seq[seq.length - 1];
      node[uCode] = dbcsCode;
    };
    DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix, skipEncodeChars) {
      var node = this.decodeTables[nodeIdx];
      for (var i2 = 0; i2 < 256; i2++) {
        var uCode = node[i2];
        var mbCode = prefix + i2;
        if (skipEncodeChars[mbCode])
          continue;
        if (uCode >= 0)
          this._setEncodeChar(uCode, mbCode);
        else if (uCode <= NODE_START)
          this._fillEncodeTable(NODE_START - uCode, mbCode << 8, skipEncodeChars);
        else if (uCode <= SEQ_START)
          this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);
      }
    };
    function DBCSEncoder(options, codec3) {
      this.leadSurrogate = -1;
      this.seqObj = void 0;
      this.encodeTable = codec3.encodeTable;
      this.encodeTableSeq = codec3.encodeTableSeq;
      this.defaultCharSingleByte = codec3.defCharSB;
      this.gb18030 = codec3.gb18030;
    }
    DBCSEncoder.prototype.write = function(str) {
      var newBuf = Buffer3.alloc(str.length * (this.gb18030 ? 4 : 3)), leadSurrogate = this.leadSurrogate, seqObj = this.seqObj, nextChar = -1, i2 = 0, j = 0;
      while (true) {
        if (nextChar === -1) {
          if (i2 == str.length) break;
          var uCode = str.charCodeAt(i2++);
        } else {
          var uCode = nextChar;
          nextChar = -1;
        }
        if (55296 <= uCode && uCode < 57344) {
          if (uCode < 56320) {
            if (leadSurrogate === -1) {
              leadSurrogate = uCode;
              continue;
            } else {
              leadSurrogate = uCode;
              uCode = UNASSIGNED;
            }
          } else {
            if (leadSurrogate !== -1) {
              uCode = 65536 + (leadSurrogate - 55296) * 1024 + (uCode - 56320);
              leadSurrogate = -1;
            } else {
              uCode = UNASSIGNED;
            }
          }
        } else if (leadSurrogate !== -1) {
          nextChar = uCode;
          uCode = UNASSIGNED;
          leadSurrogate = -1;
        }
        var dbcsCode = UNASSIGNED;
        if (seqObj !== void 0 && uCode != UNASSIGNED) {
          var resCode = seqObj[uCode];
          if (typeof resCode === "object") {
            seqObj = resCode;
            continue;
          } else if (typeof resCode == "number") {
            dbcsCode = resCode;
          } else if (resCode == void 0) {
            resCode = seqObj[DEF_CHAR];
            if (resCode !== void 0) {
              dbcsCode = resCode;
              nextChar = uCode;
            } else {
            }
          }
          seqObj = void 0;
        } else if (uCode >= 0) {
          var subtable = this.encodeTable[uCode >> 8];
          if (subtable !== void 0)
            dbcsCode = subtable[uCode & 255];
          if (dbcsCode <= SEQ_START) {
            seqObj = this.encodeTableSeq[SEQ_START - dbcsCode];
            continue;
          }
          if (dbcsCode == UNASSIGNED && this.gb18030) {
            var idx = findIdx(this.gb18030.uChars, uCode);
            if (idx != -1) {
              var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]);
              newBuf[j++] = 129 + Math.floor(dbcsCode / 12600);
              dbcsCode = dbcsCode % 12600;
              newBuf[j++] = 48 + Math.floor(dbcsCode / 1260);
              dbcsCode = dbcsCode % 1260;
              newBuf[j++] = 129 + Math.floor(dbcsCode / 10);
              dbcsCode = dbcsCode % 10;
              newBuf[j++] = 48 + dbcsCode;
              continue;
            }
          }
        }
        if (dbcsCode === UNASSIGNED)
          dbcsCode = this.defaultCharSingleByte;
        if (dbcsCode < 256) {
          newBuf[j++] = dbcsCode;
        } else if (dbcsCode < 65536) {
          newBuf[j++] = dbcsCode >> 8;
          newBuf[j++] = dbcsCode & 255;
        } else {
          newBuf[j++] = dbcsCode >> 16;
          newBuf[j++] = dbcsCode >> 8 & 255;
          newBuf[j++] = dbcsCode & 255;
        }
      }
      this.seqObj = seqObj;
      this.leadSurrogate = leadSurrogate;
      return newBuf.slice(0, j);
    };
    DBCSEncoder.prototype.end = function() {
      if (this.leadSurrogate === -1 && this.seqObj === void 0)
        return;
      var newBuf = Buffer3.alloc(10), j = 0;
      if (this.seqObj) {
        var dbcsCode = this.seqObj[DEF_CHAR];
        if (dbcsCode !== void 0) {
          if (dbcsCode < 256) {
            newBuf[j++] = dbcsCode;
          } else {
            newBuf[j++] = dbcsCode >> 8;
            newBuf[j++] = dbcsCode & 255;
          }
        } else {
        }
        this.seqObj = void 0;
      }
      if (this.leadSurrogate !== -1) {
        newBuf[j++] = this.defaultCharSingleByte;
        this.leadSurrogate = -1;
      }
      return newBuf.slice(0, j);
    };
    DBCSEncoder.prototype.findIdx = findIdx;
    function DBCSDecoder(options, codec3) {
      this.nodeIdx = 0;
      this.prevBuf = Buffer3.alloc(0);
      this.decodeTables = codec3.decodeTables;
      this.decodeTableSeq = codec3.decodeTableSeq;
      this.defaultCharUnicode = codec3.defaultCharUnicode;
      this.gb18030 = codec3.gb18030;
    }
    DBCSDecoder.prototype.write = function(buf) {
      var newBuf = Buffer3.alloc(buf.length * 2), nodeIdx = this.nodeIdx, prevBuf = this.prevBuf, prevBufOffset = this.prevBuf.length, seqStart = -this.prevBuf.length, uCode;
      if (prevBufOffset > 0)
        prevBuf = Buffer3.concat([prevBuf, buf.slice(0, 10)]);
      for (var i2 = 0, j = 0; i2 < buf.length; i2++) {
        var curByte = i2 >= 0 ? buf[i2] : prevBuf[i2 + prevBufOffset];
        var uCode = this.decodeTables[nodeIdx][curByte];
        if (uCode >= 0) {
        } else if (uCode === UNASSIGNED) {
          i2 = seqStart;
          uCode = this.defaultCharUnicode.charCodeAt(0);
        } else if (uCode === GB18030_CODE) {
          var curSeq = seqStart >= 0 ? buf.slice(seqStart, i2 + 1) : prevBuf.slice(seqStart + prevBufOffset, i2 + 1 + prevBufOffset);
          var ptr = (curSeq[0] - 129) * 12600 + (curSeq[1] - 48) * 1260 + (curSeq[2] - 129) * 10 + (curSeq[3] - 48);
          var idx = findIdx(this.gb18030.gbChars, ptr);
          uCode = this.gb18030.uChars[idx] + ptr - this.gb18030.gbChars[idx];
        } else if (uCode <= NODE_START) {
          nodeIdx = NODE_START - uCode;
          continue;
        } else if (uCode <= SEQ_START) {
          var seq = this.decodeTableSeq[SEQ_START - uCode];
          for (var k = 0; k < seq.length - 1; k++) {
            uCode = seq[k];
            newBuf[j++] = uCode & 255;
            newBuf[j++] = uCode >> 8;
          }
          uCode = seq[seq.length - 1];
        } else
          throw new Error("iconv-lite internal error: invalid decoding table value " + uCode + " at " + nodeIdx + "/" + curByte);
        if (uCode > 65535) {
          uCode -= 65536;
          var uCodeLead = 55296 + Math.floor(uCode / 1024);
          newBuf[j++] = uCodeLead & 255;
          newBuf[j++] = uCodeLead >> 8;
          uCode = 56320 + uCode % 1024;
        }
        newBuf[j++] = uCode & 255;
        newBuf[j++] = uCode >> 8;
        nodeIdx = 0;
        seqStart = i2 + 1;
      }
      this.nodeIdx = nodeIdx;
      this.prevBuf = seqStart >= 0 ? buf.slice(seqStart) : prevBuf.slice(seqStart + prevBufOffset);
      return newBuf.slice(0, j).toString("ucs2");
    };
    DBCSDecoder.prototype.end = function() {
      var ret = "";
      while (this.prevBuf.length > 0) {
        ret += this.defaultCharUnicode;
        var buf = this.prevBuf.slice(1);
        this.prevBuf = Buffer3.alloc(0);
        this.nodeIdx = 0;
        if (buf.length > 0)
          ret += this.write(buf);
      }
      this.nodeIdx = 0;
      return ret;
    };
    function findIdx(table, val) {
      if (table[0] > val)
        return -1;
      var l = 0, r = table.length;
      while (l < r - 1) {
        var mid = l + Math.floor((r - l + 1) / 2);
        if (table[mid] <= val)
          l = mid;
        else
          r = mid;
      }
      return l;
    }
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/tables/shiftjis.json
var require_shiftjis2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/tables/shiftjis.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 128],
      ["a1", "\uFF61", 62],
      ["8140", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7"],
      ["8180", "\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"],
      ["81b8", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"],
      ["81c8", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"],
      ["81da", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"],
      ["81f0", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"],
      ["81fc", "\u25EF"],
      ["824f", "\uFF10", 9],
      ["8260", "\uFF21", 25],
      ["8281", "\uFF41", 25],
      ["829f", "\u3041", 82],
      ["8340", "\u30A1", 62],
      ["8380", "\u30E0", 22],
      ["839f", "\u0391", 16, "\u03A3", 6],
      ["83bf", "\u03B1", 16, "\u03C3", 6],
      ["8440", "\u0410", 5, "\u0401\u0416", 25],
      ["8470", "\u0430", 5, "\u0451\u0436", 7],
      ["8480", "\u043E", 17],
      ["849f", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"],
      ["8740", "\u2460", 19, "\u2160", 9],
      ["875f", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"],
      ["877e", "\u337B"],
      ["8780", "\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"],
      ["889f", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"],
      ["8940", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186"],
      ["8980", "\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"],
      ["8a40", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B"],
      ["8a80", "\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"],
      ["8b40", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551"],
      ["8b80", "\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"],
      ["8c40", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8"],
      ["8c80", "\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"],
      ["8d40", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D"],
      ["8d80", "\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"],
      ["8e40", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62"],
      ["8e80", "\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"],
      ["8f40", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3"],
      ["8f80", "\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"],
      ["9040", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8"],
      ["9080", "\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"],
      ["9140", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB"],
      ["9180", "\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"],
      ["9240", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4"],
      ["9280", "\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"],
      ["9340", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC"],
      ["9380", "\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"],
      ["9440", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885"],
      ["9480", "\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"],
      ["9540", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577"],
      ["9580", "\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"],
      ["9640", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6"],
      ["9680", "\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"],
      ["9740", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32"],
      ["9780", "\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"],
      ["9840", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"],
      ["989f", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"],
      ["9940", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED"],
      ["9980", "\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"],
      ["9a40", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638"],
      ["9a80", "\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"],
      ["9b40", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80"],
      ["9b80", "\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"],
      ["9c40", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060"],
      ["9c80", "\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"],
      ["9d40", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B"],
      ["9d80", "\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"],
      ["9e40", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E"],
      ["9e80", "\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"],
      ["9f40", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF"],
      ["9f80", "\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"],
      ["e040", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD"],
      ["e080", "\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"],
      ["e140", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF"],
      ["e180", "\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"],
      ["e240", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0"],
      ["e280", "\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"],
      ["e340", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37"],
      ["e380", "\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"],
      ["e440", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264"],
      ["e480", "\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"],
      ["e540", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC"],
      ["e580", "\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"],
      ["e640", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7"],
      ["e680", "\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"],
      ["e740", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C"],
      ["e780", "\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"],
      ["e840", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599"],
      ["e880", "\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"],
      ["e940", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43"],
      ["e980", "\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"],
      ["ea40", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF"],
      ["ea80", "\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0\u582F\u69C7\u9059\u7464\u51DC\u7199"],
      ["ed40", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F"],
      ["ed80", "\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"],
      ["ee40", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559"],
      ["ee80", "\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"],
      ["eeef", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"],
      ["f040", "\uE000", 62],
      ["f080", "\uE03F", 124],
      ["f140", "\uE0BC", 62],
      ["f180", "\uE0FB", 124],
      ["f240", "\uE178", 62],
      ["f280", "\uE1B7", 124],
      ["f340", "\uE234", 62],
      ["f380", "\uE273", 124],
      ["f440", "\uE2F0", 62],
      ["f480", "\uE32F", 124],
      ["f540", "\uE3AC", 62],
      ["f580", "\uE3EB", 124],
      ["f640", "\uE468", 62],
      ["f680", "\uE4A7", 124],
      ["f740", "\uE524", 62],
      ["f780", "\uE563", 124],
      ["f840", "\uE5E0", 62],
      ["f880", "\uE61F", 124],
      ["f940", "\uE69C"],
      ["fa40", "\u2170", 9, "\u2160", 9, "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u2235\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A"],
      ["fa80", "\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F"],
      ["fb40", "\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19"],
      ["fb80", "\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9"],
      ["fc40", "\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"]
    ];
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/tables/eucjp.json
var require_eucjp2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/tables/eucjp.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127],
      ["8ea1", "\uFF61", 62],
      ["a1a1", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7"],
      ["a2a1", "\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"],
      ["a2ba", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"],
      ["a2ca", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"],
      ["a2dc", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"],
      ["a2f2", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"],
      ["a2fe", "\u25EF"],
      ["a3b0", "\uFF10", 9],
      ["a3c1", "\uFF21", 25],
      ["a3e1", "\uFF41", 25],
      ["a4a1", "\u3041", 82],
      ["a5a1", "\u30A1", 85],
      ["a6a1", "\u0391", 16, "\u03A3", 6],
      ["a6c1", "\u03B1", 16, "\u03C3", 6],
      ["a7a1", "\u0410", 5, "\u0401\u0416", 25],
      ["a7d1", "\u0430", 5, "\u0451\u0436", 25],
      ["a8a1", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"],
      ["ada1", "\u2460", 19, "\u2160", 9],
      ["adc0", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"],
      ["addf", "\u337B\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"],
      ["b0a1", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"],
      ["b1a1", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC"],
      ["b2a1", "\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"],
      ["b3a1", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431"],
      ["b4a1", "\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"],
      ["b5a1", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC"],
      ["b6a1", "\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"],
      ["b7a1", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372"],
      ["b8a1", "\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"],
      ["b9a1", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC"],
      ["baa1", "\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"],
      ["bba1", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642"],
      ["bca1", "\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"],
      ["bda1", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F"],
      ["bea1", "\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"],
      ["bfa1", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE"],
      ["c0a1", "\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"],
      ["c1a1", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E"],
      ["c2a1", "\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"],
      ["c3a1", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5"],
      ["c4a1", "\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"],
      ["c5a1", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230"],
      ["c6a1", "\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"],
      ["c7a1", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6"],
      ["c8a1", "\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"],
      ["c9a1", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D"],
      ["caa1", "\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"],
      ["cba1", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80"],
      ["cca1", "\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"],
      ["cda1", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483"],
      ["cea1", "\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"],
      ["cfa1", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"],
      ["d0a1", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"],
      ["d1a1", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8"],
      ["d2a1", "\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"],
      ["d3a1", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709"],
      ["d4a1", "\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"],
      ["d5a1", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53"],
      ["d6a1", "\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"],
      ["d7a1", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A"],
      ["d8a1", "\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"],
      ["d9a1", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC"],
      ["daa1", "\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"],
      ["dba1", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD"],
      ["dca1", "\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"],
      ["dda1", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE"],
      ["dea1", "\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"],
      ["dfa1", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC"],
      ["e0a1", "\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"],
      ["e1a1", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670"],
      ["e2a1", "\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"],
      ["e3a1", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50"],
      ["e4a1", "\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"],
      ["e5a1", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A"],
      ["e6a1", "\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"],
      ["e7a1", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9"],
      ["e8a1", "\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"],
      ["e9a1", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759"],
      ["eaa1", "\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"],
      ["eba1", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B"],
      ["eca1", "\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"],
      ["eda1", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8"],
      ["eea1", "\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"],
      ["efa1", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E"],
      ["f0a1", "\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"],
      ["f1a1", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7"],
      ["f2a1", "\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"],
      ["f3a1", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0"],
      ["f4a1", "\u582F\u69C7\u9059\u7464\u51DC\u7199"],
      ["f9a1", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7"],
      ["faa1", "\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"],
      ["fba1", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA"],
      ["fca1", "\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"],
      ["fcf1", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"],
      ["8fa2af", "\u02D8\u02C7\xB8\u02D9\u02DD\xAF\u02DB\u02DA\uFF5E\u0384\u0385"],
      ["8fa2c2", "\xA1\xA6\xBF"],
      ["8fa2eb", "\xBA\xAA\xA9\xAE\u2122\xA4\u2116"],
      ["8fa6e1", "\u0386\u0388\u0389\u038A\u03AA"],
      ["8fa6e7", "\u038C"],
      ["8fa6e9", "\u038E\u03AB"],
      ["8fa6ec", "\u038F"],
      ["8fa6f1", "\u03AC\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03C2\u03CD\u03CB\u03B0\u03CE"],
      ["8fa7c2", "\u0402", 10, "\u040E\u040F"],
      ["8fa7f2", "\u0452", 10, "\u045E\u045F"],
      ["8fa9a1", "\xC6\u0110"],
      ["8fa9a4", "\u0126"],
      ["8fa9a6", "\u0132"],
      ["8fa9a8", "\u0141\u013F"],
      ["8fa9ab", "\u014A\xD8\u0152"],
      ["8fa9af", "\u0166\xDE"],
      ["8fa9c1", "\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0142\u0140\u0149\u014B\xF8\u0153\xDF\u0167\xFE"],
      ["8faaa1", "\xC1\xC0\xC4\xC2\u0102\u01CD\u0100\u0104\xC5\xC3\u0106\u0108\u010C\xC7\u010A\u010E\xC9\xC8\xCB\xCA\u011A\u0116\u0112\u0118"],
      ["8faaba", "\u011C\u011E\u0122\u0120\u0124\xCD\xCC\xCF\xCE\u01CF\u0130\u012A\u012E\u0128\u0134\u0136\u0139\u013D\u013B\u0143\u0147\u0145\xD1\xD3\xD2\xD6\xD4\u01D1\u0150\u014C\xD5\u0154\u0158\u0156\u015A\u015C\u0160\u015E\u0164\u0162\xDA\xD9\xDC\xDB\u016C\u01D3\u0170\u016A\u0172\u016E\u0168\u01D7\u01DB\u01D9\u01D5\u0174\xDD\u0178\u0176\u0179\u017D\u017B"],
      ["8faba1", "\xE1\xE0\xE4\xE2\u0103\u01CE\u0101\u0105\xE5\xE3\u0107\u0109\u010D\xE7\u010B\u010F\xE9\xE8\xEB\xEA\u011B\u0117\u0113\u0119\u01F5\u011D\u011F"],
      ["8fabbd", "\u0121\u0125\xED\xEC\xEF\xEE\u01D0"],
      ["8fabc5", "\u012B\u012F\u0129\u0135\u0137\u013A\u013E\u013C\u0144\u0148\u0146\xF1\xF3\xF2\xF6\xF4\u01D2\u0151\u014D\xF5\u0155\u0159\u0157\u015B\u015D\u0161\u015F\u0165\u0163\xFA\xF9\xFC\xFB\u016D\u01D4\u0171\u016B\u0173\u016F\u0169\u01D8\u01DC\u01DA\u01D6\u0175\xFD\xFF\u0177\u017A\u017E\u017C"],
      ["8fb0a1", "\u4E02\u4E04\u4E05\u4E0C\u4E12\u4E1F\u4E23\u4E24\u4E28\u4E2B\u4E2E\u4E2F\u4E30\u4E35\u4E40\u4E41\u4E44\u4E47\u4E51\u4E5A\u4E5C\u4E63\u4E68\u4E69\u4E74\u4E75\u4E79\u4E7F\u4E8D\u4E96\u4E97\u4E9D\u4EAF\u4EB9\u4EC3\u4ED0\u4EDA\u4EDB\u4EE0\u4EE1\u4EE2\u4EE8\u4EEF\u4EF1\u4EF3\u4EF5\u4EFD\u4EFE\u4EFF\u4F00\u4F02\u4F03\u4F08\u4F0B\u4F0C\u4F12\u4F15\u4F16\u4F17\u4F19\u4F2E\u4F31\u4F60\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E\u4F40\u4F42\u4F48\u4F49\u4F4B\u4F4C\u4F52\u4F54\u4F56\u4F58\u4F5F\u4F63\u4F6A\u4F6C\u4F6E\u4F71\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F7E\u4F81\u4F82\u4F84"],
      ["8fb1a1", "\u4F85\u4F89\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F94\u4F97\u4F99\u4F9A\u4F9E\u4F9F\u4FB2\u4FB7\u4FB9\u4FBB\u4FBC\u4FBD\u4FBE\u4FC0\u4FC1\u4FC5\u4FC6\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FCF\u4FD2\u4FDC\u4FE0\u4FE2\u4FF0\u4FF2\u4FFC\u4FFD\u4FFF\u5000\u5001\u5004\u5007\u500A\u500C\u500E\u5010\u5013\u5017\u5018\u501B\u501C\u501D\u501E\u5022\u5027\u502E\u5030\u5032\u5033\u5035\u5040\u5041\u5042\u5045\u5046\u504A\u504C\u504E\u5051\u5052\u5053\u5057\u5059\u505F\u5060\u5062\u5063\u5066\u5067\u506A\u506D\u5070\u5071\u503B\u5081\u5083\u5084\u5086\u508A\u508E\u508F\u5090"],
      ["8fb2a1", "\u5092\u5093\u5094\u5096\u509B\u509C\u509E", 4, "\u50AA\u50AF\u50B0\u50B9\u50BA\u50BD\u50C0\u50C3\u50C4\u50C7\u50CC\u50CE\u50D0\u50D3\u50D4\u50D8\u50DC\u50DD\u50DF\u50E2\u50E4\u50E6\u50E8\u50E9\u50EF\u50F1\u50F6\u50FA\u50FE\u5103\u5106\u5107\u5108\u510B\u510C\u510D\u510E\u50F2\u5110\u5117\u5119\u511B\u511C\u511D\u511E\u5123\u5127\u5128\u512C\u512D\u512F\u5131\u5133\u5134\u5135\u5138\u5139\u5142\u514A\u514F\u5153\u5155\u5157\u5158\u515F\u5164\u5166\u517E\u5183\u5184\u518B\u518E\u5198\u519D\u51A1\u51A3\u51AD\u51B8\u51BA\u51BC\u51BE\u51BF\u51C2"],
      ["8fb3a1", "\u51C8\u51CF\u51D1\u51D2\u51D3\u51D5\u51D8\u51DE\u51E2\u51E5\u51EE\u51F2\u51F3\u51F4\u51F7\u5201\u5202\u5205\u5212\u5213\u5215\u5216\u5218\u5222\u5228\u5231\u5232\u5235\u523C\u5245\u5249\u5255\u5257\u5258\u525A\u525C\u525F\u5260\u5261\u5266\u526E\u5277\u5278\u5279\u5280\u5282\u5285\u528A\u528C\u5293\u5295\u5296\u5297\u5298\u529A\u529C\u52A4\u52A5\u52A6\u52A7\u52AF\u52B0\u52B6\u52B7\u52B8\u52BA\u52BB\u52BD\u52C0\u52C4\u52C6\u52C8\u52CC\u52CF\u52D1\u52D4\u52D6\u52DB\u52DC\u52E1\u52E5\u52E8\u52E9\u52EA\u52EC\u52F0\u52F1\u52F4\u52F6\u52F7\u5300\u5303\u530A\u530B"],
      ["8fb4a1", "\u530C\u5311\u5313\u5318\u531B\u531C\u531E\u531F\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u5330\u5332\u5335\u533C\u533D\u533E\u5342\u534C\u534B\u5359\u535B\u5361\u5363\u5365\u536C\u536D\u5372\u5379\u537E\u5383\u5387\u5388\u538E\u5393\u5394\u5399\u539D\u53A1\u53A4\u53AA\u53AB\u53AF\u53B2\u53B4\u53B5\u53B7\u53B8\u53BA\u53BD\u53C0\u53C5\u53CF\u53D2\u53D3\u53D5\u53DA\u53DD\u53DE\u53E0\u53E6\u53E7\u53F5\u5402\u5413\u541A\u5421\u5427\u5428\u542A\u542F\u5431\u5434\u5435\u5443\u5444\u5447\u544D\u544F\u545E\u5462\u5464\u5466\u5467\u5469\u546B\u546D\u546E\u5474\u547F"],
      ["8fb5a1", "\u5481\u5483\u5485\u5488\u5489\u548D\u5491\u5495\u5496\u549C\u549F\u54A1\u54A6\u54A7\u54A9\u54AA\u54AD\u54AE\u54B1\u54B7\u54B9\u54BA\u54BB\u54BF\u54C6\u54CA\u54CD\u54CE\u54E0\u54EA\u54EC\u54EF\u54F6\u54FC\u54FE\u54FF\u5500\u5501\u5505\u5508\u5509\u550C\u550D\u550E\u5515\u552A\u552B\u5532\u5535\u5536\u553B\u553C\u553D\u5541\u5547\u5549\u554A\u554D\u5550\u5551\u5558\u555A\u555B\u555E\u5560\u5561\u5564\u5566\u557F\u5581\u5582\u5586\u5588\u558E\u558F\u5591\u5592\u5593\u5594\u5597\u55A3\u55A4\u55AD\u55B2\u55BF\u55C1\u55C3\u55C6\u55C9\u55CB\u55CC\u55CE\u55D1\u55D2"],
      ["8fb6a1", "\u55D3\u55D7\u55D8\u55DB\u55DE\u55E2\u55E9\u55F6\u55FF\u5605\u5608\u560A\u560D", 5, "\u5619\u562C\u5630\u5633\u5635\u5637\u5639\u563B\u563C\u563D\u563F\u5640\u5641\u5643\u5644\u5646\u5649\u564B\u564D\u564F\u5654\u565E\u5660\u5661\u5662\u5663\u5666\u5669\u566D\u566F\u5671\u5672\u5675\u5684\u5685\u5688\u568B\u568C\u5695\u5699\u569A\u569D\u569E\u569F\u56A6\u56A7\u56A8\u56A9\u56AB\u56AC\u56AD\u56B1\u56B3\u56B7\u56BE\u56C5\u56C9\u56CA\u56CB\u56CF\u56D0\u56CC\u56CD\u56D9\u56DC\u56DD\u56DF\u56E1\u56E4", 4, "\u56F1\u56EB\u56ED"],
      ["8fb7a1", "\u56F6\u56F7\u5701\u5702\u5707\u570A\u570C\u5711\u5715\u571A\u571B\u571D\u5720\u5722\u5723\u5724\u5725\u5729\u572A\u572C\u572E\u572F\u5733\u5734\u573D\u573E\u573F\u5745\u5746\u574C\u574D\u5752\u5762\u5765\u5767\u5768\u576B\u576D", 4, "\u5773\u5774\u5775\u5777\u5779\u577A\u577B\u577C\u577E\u5781\u5783\u578C\u5794\u5797\u5799\u579A\u579C\u579D\u579E\u579F\u57A1\u5795\u57A7\u57A8\u57A9\u57AC\u57B8\u57BD\u57C7\u57C8\u57CC\u57CF\u57D5\u57DD\u57DE\u57E4\u57E6\u57E7\u57E9\u57ED\u57F0\u57F5\u57F6\u57F8\u57FD\u57FE\u57FF\u5803\u5804\u5808\u5809\u57E1"],
      ["8fb8a1", "\u580C\u580D\u581B\u581E\u581F\u5820\u5826\u5827\u582D\u5832\u5839\u583F\u5849\u584C\u584D\u584F\u5850\u5855\u585F\u5861\u5864\u5867\u5868\u5878\u587C\u587F\u5880\u5881\u5887\u5888\u5889\u588A\u588C\u588D\u588F\u5890\u5894\u5896\u589D\u58A0\u58A1\u58A2\u58A6\u58A9\u58B1\u58B2\u58C4\u58BC\u58C2\u58C8\u58CD\u58CE\u58D0\u58D2\u58D4\u58D6\u58DA\u58DD\u58E1\u58E2\u58E9\u58F3\u5905\u5906\u590B\u590C\u5912\u5913\u5914\u8641\u591D\u5921\u5923\u5924\u5928\u592F\u5930\u5933\u5935\u5936\u593F\u5943\u5946\u5952\u5953\u5959\u595B\u595D\u595E\u595F\u5961\u5963\u596B\u596D"],
      ["8fb9a1", "\u596F\u5972\u5975\u5976\u5979\u597B\u597C\u598B\u598C\u598E\u5992\u5995\u5997\u599F\u59A4\u59A7\u59AD\u59AE\u59AF\u59B0\u59B3\u59B7\u59BA\u59BC\u59C1\u59C3\u59C4\u59C8\u59CA\u59CD\u59D2\u59DD\u59DE\u59DF\u59E3\u59E4\u59E7\u59EE\u59EF\u59F1\u59F2\u59F4\u59F7\u5A00\u5A04\u5A0C\u5A0D\u5A0E\u5A12\u5A13\u5A1E\u5A23\u5A24\u5A27\u5A28\u5A2A\u5A2D\u5A30\u5A44\u5A45\u5A47\u5A48\u5A4C\u5A50\u5A55\u5A5E\u5A63\u5A65\u5A67\u5A6D\u5A77\u5A7A\u5A7B\u5A7E\u5A8B\u5A90\u5A93\u5A96\u5A99\u5A9C\u5A9E\u5A9F\u5AA0\u5AA2\u5AA7\u5AAC\u5AB1\u5AB2\u5AB3\u5AB5\u5AB8\u5ABA\u5ABB\u5ABF"],
      ["8fbaa1", "\u5AC4\u5AC6\u5AC8\u5ACF\u5ADA\u5ADC\u5AE0\u5AE5\u5AEA\u5AEE\u5AF5\u5AF6\u5AFD\u5B00\u5B01\u5B08\u5B17\u5B34\u5B19\u5B1B\u5B1D\u5B21\u5B25\u5B2D\u5B38\u5B41\u5B4B\u5B4C\u5B52\u5B56\u5B5E\u5B68\u5B6E\u5B6F\u5B7C\u5B7D\u5B7E\u5B7F\u5B81\u5B84\u5B86\u5B8A\u5B8E\u5B90\u5B91\u5B93\u5B94\u5B96\u5BA8\u5BA9\u5BAC\u5BAD\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBC\u5BC0\u5BC1\u5BCD\u5BCF\u5BD6", 4, "\u5BE0\u5BEF\u5BF1\u5BF4\u5BFD\u5C0C\u5C17\u5C1E\u5C1F\u5C23\u5C26\u5C29\u5C2B\u5C2C\u5C2E\u5C30\u5C32\u5C35\u5C36\u5C59\u5C5A\u5C5C\u5C62\u5C63\u5C67\u5C68\u5C69"],
      ["8fbba1", "\u5C6D\u5C70\u5C74\u5C75\u5C7A\u5C7B\u5C7C\u5C7D\u5C87\u5C88\u5C8A\u5C8F\u5C92\u5C9D\u5C9F\u5CA0\u5CA2\u5CA3\u5CA6\u5CAA\u5CB2\u5CB4\u5CB5\u5CBA\u5CC9\u5CCB\u5CD2\u5CDD\u5CD7\u5CEE\u5CF1\u5CF2\u5CF4\u5D01\u5D06\u5D0D\u5D12\u5D2B\u5D23\u5D24\u5D26\u5D27\u5D31\u5D34\u5D39\u5D3D\u5D3F\u5D42\u5D43\u5D46\u5D48\u5D55\u5D51\u5D59\u5D4A\u5D5F\u5D60\u5D61\u5D62\u5D64\u5D6A\u5D6D\u5D70\u5D79\u5D7A\u5D7E\u5D7F\u5D81\u5D83\u5D88\u5D8A\u5D92\u5D93\u5D94\u5D95\u5D99\u5D9B\u5D9F\u5DA0\u5DA7\u5DAB\u5DB0\u5DB4\u5DB8\u5DB9\u5DC3\u5DC7\u5DCB\u5DD0\u5DCE\u5DD8\u5DD9\u5DE0\u5DE4"],
      ["8fbca1", "\u5DE9\u5DF8\u5DF9\u5E00\u5E07\u5E0D\u5E12\u5E14\u5E15\u5E18\u5E1F\u5E20\u5E2E\u5E28\u5E32\u5E35\u5E3E\u5E4B\u5E50\u5E49\u5E51\u5E56\u5E58\u5E5B\u5E5C\u5E5E\u5E68\u5E6A", 4, "\u5E70\u5E80\u5E8B\u5E8E\u5EA2\u5EA4\u5EA5\u5EA8\u5EAA\u5EAC\u5EB1\u5EB3\u5EBD\u5EBE\u5EBF\u5EC6\u5ECC\u5ECB\u5ECE\u5ED1\u5ED2\u5ED4\u5ED5\u5EDC\u5EDE\u5EE5\u5EEB\u5F02\u5F06\u5F07\u5F08\u5F0E\u5F19\u5F1C\u5F1D\u5F21\u5F22\u5F23\u5F24\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F34\u5F36\u5F3B\u5F3D\u5F3F\u5F40\u5F44\u5F45\u5F47\u5F4D\u5F50\u5F54\u5F58\u5F5B\u5F60\u5F63\u5F64\u5F67"],
      ["8fbda1", "\u5F6F\u5F72\u5F74\u5F75\u5F78\u5F7A\u5F7D\u5F7E\u5F89\u5F8D\u5F8F\u5F96\u5F9C\u5F9D\u5FA2\u5FA7\u5FAB\u5FA4\u5FAC\u5FAF\u5FB0\u5FB1\u5FB8\u5FC4\u5FC7\u5FC8\u5FC9\u5FCB\u5FD0", 4, "\u5FDE\u5FE1\u5FE2\u5FE8\u5FE9\u5FEA\u5FEC\u5FED\u5FEE\u5FEF\u5FF2\u5FF3\u5FF6\u5FFA\u5FFC\u6007\u600A\u600D\u6013\u6014\u6017\u6018\u601A\u601F\u6024\u602D\u6033\u6035\u6040\u6047\u6048\u6049\u604C\u6051\u6054\u6056\u6057\u605D\u6061\u6067\u6071\u607E\u607F\u6082\u6086\u6088\u608A\u608E\u6091\u6093\u6095\u6098\u609D\u609E\u60A2\u60A4\u60A5\u60A8\u60B0\u60B1\u60B7"],
      ["8fbea1", "\u60BB\u60BE\u60C2\u60C4\u60C8\u60C9\u60CA\u60CB\u60CE\u60CF\u60D4\u60D5\u60D9\u60DB\u60DD\u60DE\u60E2\u60E5\u60F2\u60F5\u60F8\u60FC\u60FD\u6102\u6107\u610A\u610C\u6110", 4, "\u6116\u6117\u6119\u611C\u611E\u6122\u612A\u612B\u6130\u6131\u6135\u6136\u6137\u6139\u6141\u6145\u6146\u6149\u615E\u6160\u616C\u6172\u6178\u617B\u617C\u617F\u6180\u6181\u6183\u6184\u618B\u618D\u6192\u6193\u6197\u6198\u619C\u619D\u619F\u61A0\u61A5\u61A8\u61AA\u61AD\u61B8\u61B9\u61BC\u61C0\u61C1\u61C2\u61CE\u61CF\u61D5\u61DC\u61DD\u61DE\u61DF\u61E1\u61E2\u61E7\u61E9\u61E5"],
      ["8fbfa1", "\u61EC\u61ED\u61EF\u6201\u6203\u6204\u6207\u6213\u6215\u621C\u6220\u6222\u6223\u6227\u6229\u622B\u6239\u623D\u6242\u6243\u6244\u6246\u624C\u6250\u6251\u6252\u6254\u6256\u625A\u625C\u6264\u626D\u626F\u6273\u627A\u627D\u628D\u628E\u628F\u6290\u62A6\u62A8\u62B3\u62B6\u62B7\u62BA\u62BE\u62BF\u62C4\u62CE\u62D5\u62D6\u62DA\u62EA\u62F2\u62F4\u62FC\u62FD\u6303\u6304\u630A\u630B\u630D\u6310\u6313\u6316\u6318\u6329\u632A\u632D\u6335\u6336\u6339\u633C\u6341\u6342\u6343\u6344\u6346\u634A\u634B\u634E\u6352\u6353\u6354\u6358\u635B\u6365\u6366\u636C\u636D\u6371\u6374\u6375"],
      ["8fc0a1", "\u6378\u637C\u637D\u637F\u6382\u6384\u6387\u638A\u6390\u6394\u6395\u6399\u639A\u639E\u63A4\u63A6\u63AD\u63AE\u63AF\u63BD\u63C1\u63C5\u63C8\u63CE\u63D1\u63D3\u63D4\u63D5\u63DC\u63E0\u63E5\u63EA\u63EC\u63F2\u63F3\u63F5\u63F8\u63F9\u6409\u640A\u6410\u6412\u6414\u6418\u641E\u6420\u6422\u6424\u6425\u6429\u642A\u642F\u6430\u6435\u643D\u643F\u644B\u644F\u6451\u6452\u6453\u6454\u645A\u645B\u645C\u645D\u645F\u6460\u6461\u6463\u646D\u6473\u6474\u647B\u647D\u6485\u6487\u648F\u6490\u6491\u6498\u6499\u649B\u649D\u649F\u64A1\u64A3\u64A6\u64A8\u64AC\u64B3\u64BD\u64BE\u64BF"],
      ["8fc1a1", "\u64C4\u64C9\u64CA\u64CB\u64CC\u64CE\u64D0\u64D1\u64D5\u64D7\u64E4\u64E5\u64E9\u64EA\u64ED\u64F0\u64F5\u64F7\u64FB\u64FF\u6501\u6504\u6508\u6509\u650A\u650F\u6513\u6514\u6516\u6519\u651B\u651E\u651F\u6522\u6526\u6529\u652E\u6531\u653A\u653C\u653D\u6543\u6547\u6549\u6550\u6552\u6554\u655F\u6560\u6567\u656B\u657A\u657D\u6581\u6585\u658A\u6592\u6595\u6598\u659D\u65A0\u65A3\u65A6\u65AE\u65B2\u65B3\u65B4\u65BF\u65C2\u65C8\u65C9\u65CE\u65D0\u65D4\u65D6\u65D8\u65DF\u65F0\u65F2\u65F4\u65F5\u65F9\u65FE\u65FF\u6600\u6604\u6608\u6609\u660D\u6611\u6612\u6615\u6616\u661D"],
      ["8fc2a1", "\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6631\u6633\u6639\u6637\u6640\u6645\u6646\u664A\u664C\u6651\u664E\u6657\u6658\u6659\u665B\u665C\u6660\u6661\u66FB\u666A\u666B\u666C\u667E\u6673\u6675\u667F\u6677\u6678\u6679\u667B\u6680\u667C\u668B\u668C\u668D\u6690\u6692\u6699\u669A\u669B\u669C\u669F\u66A0\u66A4\u66AD\u66B1\u66B2\u66B5\u66BB\u66BF\u66C0\u66C2\u66C3\u66C8\u66CC\u66CE\u66CF\u66D4\u66DB\u66DF\u66E8\u66EB\u66EC\u66EE\u66FA\u6705\u6707\u670E\u6713\u6719\u671C\u6720\u6722\u6733\u673E\u6745\u6747\u6748\u674C\u6754\u6755\u675D"],
      ["8fc3a1", "\u6766\u676C\u676E\u6774\u6776\u677B\u6781\u6784\u678E\u678F\u6791\u6793\u6796\u6798\u6799\u679B\u67B0\u67B1\u67B2\u67B5\u67BB\u67BC\u67BD\u67F9\u67C0\u67C2\u67C3\u67C5\u67C8\u67C9\u67D2\u67D7\u67D9\u67DC\u67E1\u67E6\u67F0\u67F2\u67F6\u67F7\u6852\u6814\u6819\u681D\u681F\u6828\u6827\u682C\u682D\u682F\u6830\u6831\u6833\u683B\u683F\u6844\u6845\u684A\u684C\u6855\u6857\u6858\u685B\u686B\u686E", 4, "\u6875\u6879\u687A\u687B\u687C\u6882\u6884\u6886\u6888\u6896\u6898\u689A\u689C\u68A1\u68A3\u68A5\u68A9\u68AA\u68AE\u68B2\u68BB\u68C5\u68C8\u68CC\u68CF"],
      ["8fc4a1", "\u68D0\u68D1\u68D3\u68D6\u68D9\u68DC\u68DD\u68E5\u68E8\u68EA\u68EB\u68EC\u68ED\u68F0\u68F1\u68F5\u68F6\u68FB\u68FC\u68FD\u6906\u6909\u690A\u6910\u6911\u6913\u6916\u6917\u6931\u6933\u6935\u6938\u693B\u6942\u6945\u6949\u694E\u6957\u695B\u6963\u6964\u6965\u6966\u6968\u6969\u696C\u6970\u6971\u6972\u697A\u697B\u697F\u6980\u698D\u6992\u6996\u6998\u69A1\u69A5\u69A6\u69A8\u69AB\u69AD\u69AF\u69B7\u69B8\u69BA\u69BC\u69C5\u69C8\u69D1\u69D6\u69D7\u69E2\u69E5\u69EE\u69EF\u69F1\u69F3\u69F5\u69FE\u6A00\u6A01\u6A03\u6A0F\u6A11\u6A15\u6A1A\u6A1D\u6A20\u6A24\u6A28\u6A30\u6A32"],
      ["8fc5a1", "\u6A34\u6A37\u6A3B\u6A3E\u6A3F\u6A45\u6A46\u6A49\u6A4A\u6A4E\u6A50\u6A51\u6A52\u6A55\u6A56\u6A5B\u6A64\u6A67\u6A6A\u6A71\u6A73\u6A7E\u6A81\u6A83\u6A86\u6A87\u6A89\u6A8B\u6A91\u6A9B\u6A9D\u6A9E\u6A9F\u6AA5\u6AAB\u6AAF\u6AB0\u6AB1\u6AB4\u6ABD\u6ABE\u6ABF\u6AC6\u6AC9\u6AC8\u6ACC\u6AD0\u6AD4\u6AD5\u6AD6\u6ADC\u6ADD\u6AE4\u6AE7\u6AEC\u6AF0\u6AF1\u6AF2\u6AFC\u6AFD\u6B02\u6B03\u6B06\u6B07\u6B09\u6B0F\u6B10\u6B11\u6B17\u6B1B\u6B1E\u6B24\u6B28\u6B2B\u6B2C\u6B2F\u6B35\u6B36\u6B3B\u6B3F\u6B46\u6B4A\u6B4D\u6B52\u6B56\u6B58\u6B5D\u6B60\u6B67\u6B6B\u6B6E\u6B70\u6B75\u6B7D"],
      ["8fc6a1", "\u6B7E\u6B82\u6B85\u6B97\u6B9B\u6B9F\u6BA0\u6BA2\u6BA3\u6BA8\u6BA9\u6BAC\u6BAD\u6BAE\u6BB0\u6BB8\u6BB9\u6BBD\u6BBE\u6BC3\u6BC4\u6BC9\u6BCC\u6BD6\u6BDA\u6BE1\u6BE3\u6BE6\u6BE7\u6BEE\u6BF1\u6BF7\u6BF9\u6BFF\u6C02\u6C04\u6C05\u6C09\u6C0D\u6C0E\u6C10\u6C12\u6C19\u6C1F\u6C26\u6C27\u6C28\u6C2C\u6C2E\u6C33\u6C35\u6C36\u6C3A\u6C3B\u6C3F\u6C4A\u6C4B\u6C4D\u6C4F\u6C52\u6C54\u6C59\u6C5B\u6C5C\u6C6B\u6C6D\u6C6F\u6C74\u6C76\u6C78\u6C79\u6C7B\u6C85\u6C86\u6C87\u6C89\u6C94\u6C95\u6C97\u6C98\u6C9C\u6C9F\u6CB0\u6CB2\u6CB4\u6CC2\u6CC6\u6CCD\u6CCF\u6CD0\u6CD1\u6CD2\u6CD4\u6CD6"],
      ["8fc7a1", "\u6CDA\u6CDC\u6CE0\u6CE7\u6CE9\u6CEB\u6CEC\u6CEE\u6CF2\u6CF4\u6D04\u6D07\u6D0A\u6D0E\u6D0F\u6D11\u6D13\u6D1A\u6D26\u6D27\u6D28\u6C67\u6D2E\u6D2F\u6D31\u6D39\u6D3C\u6D3F\u6D57\u6D5E\u6D5F\u6D61\u6D65\u6D67\u6D6F\u6D70\u6D7C\u6D82\u6D87\u6D91\u6D92\u6D94\u6D96\u6D97\u6D98\u6DAA\u6DAC\u6DB4\u6DB7\u6DB9\u6DBD\u6DBF\u6DC4\u6DC8\u6DCA\u6DCE\u6DCF\u6DD6\u6DDB\u6DDD\u6DDF\u6DE0\u6DE2\u6DE5\u6DE9\u6DEF\u6DF0\u6DF4\u6DF6\u6DFC\u6E00\u6E04\u6E1E\u6E22\u6E27\u6E32\u6E36\u6E39\u6E3B\u6E3C\u6E44\u6E45\u6E48\u6E49\u6E4B\u6E4F\u6E51\u6E52\u6E53\u6E54\u6E57\u6E5C\u6E5D\u6E5E"],
      ["8fc8a1", "\u6E62\u6E63\u6E68\u6E73\u6E7B\u6E7D\u6E8D\u6E93\u6E99\u6EA0\u6EA7\u6EAD\u6EAE\u6EB1\u6EB3\u6EBB\u6EBF\u6EC0\u6EC1\u6EC3\u6EC7\u6EC8\u6ECA\u6ECD\u6ECE\u6ECF\u6EEB\u6EED\u6EEE\u6EF9\u6EFB\u6EFD\u6F04\u6F08\u6F0A\u6F0C\u6F0D\u6F16\u6F18\u6F1A\u6F1B\u6F26\u6F29\u6F2A\u6F2F\u6F30\u6F33\u6F36\u6F3B\u6F3C\u6F2D\u6F4F\u6F51\u6F52\u6F53\u6F57\u6F59\u6F5A\u6F5D\u6F5E\u6F61\u6F62\u6F68\u6F6C\u6F7D\u6F7E\u6F83\u6F87\u6F88\u6F8B\u6F8C\u6F8D\u6F90\u6F92\u6F93\u6F94\u6F96\u6F9A\u6F9F\u6FA0\u6FA5\u6FA6\u6FA7\u6FA8\u6FAE\u6FAF\u6FB0\u6FB5\u6FB6\u6FBC\u6FC5\u6FC7\u6FC8\u6FCA"],
      ["8fc9a1", "\u6FDA\u6FDE\u6FE8\u6FE9\u6FF0\u6FF5\u6FF9\u6FFC\u6FFD\u7000\u7005\u7006\u7007\u700D\u7017\u7020\u7023\u702F\u7034\u7037\u7039\u703C\u7043\u7044\u7048\u7049\u704A\u704B\u7054\u7055\u705D\u705E\u704E\u7064\u7065\u706C\u706E\u7075\u7076\u707E\u7081\u7085\u7086\u7094", 4, "\u709B\u70A4\u70AB\u70B0\u70B1\u70B4\u70B7\u70CA\u70D1\u70D3\u70D4\u70D5\u70D6\u70D8\u70DC\u70E4\u70FA\u7103", 4, "\u710B\u710C\u710F\u711E\u7120\u712B\u712D\u712F\u7130\u7131\u7138\u7141\u7145\u7146\u7147\u714A\u714B\u7150\u7152\u7157\u715A\u715C\u715E\u7160"],
      ["8fcaa1", "\u7168\u7179\u7180\u7185\u7187\u718C\u7192\u719A\u719B\u71A0\u71A2\u71AF\u71B0\u71B2\u71B3\u71BA\u71BF\u71C0\u71C1\u71C4\u71CB\u71CC\u71D3\u71D6\u71D9\u71DA\u71DC\u71F8\u71FE\u7200\u7207\u7208\u7209\u7213\u7217\u721A\u721D\u721F\u7224\u722B\u722F\u7234\u7238\u7239\u7241\u7242\u7243\u7245\u724E\u724F\u7250\u7253\u7255\u7256\u725A\u725C\u725E\u7260\u7263\u7268\u726B\u726E\u726F\u7271\u7277\u7278\u727B\u727C\u727F\u7284\u7289\u728D\u728E\u7293\u729B\u72A8\u72AD\u72AE\u72B1\u72B4\u72BE\u72C1\u72C7\u72C9\u72CC\u72D5\u72D6\u72D8\u72DF\u72E5\u72F3\u72F4\u72FA\u72FB"],
      ["8fcba1", "\u72FE\u7302\u7304\u7305\u7307\u730B\u730D\u7312\u7313\u7318\u7319\u731E\u7322\u7324\u7327\u7328\u732C\u7331\u7332\u7335\u733A\u733B\u733D\u7343\u734D\u7350\u7352\u7356\u7358\u735D\u735E\u735F\u7360\u7366\u7367\u7369\u736B\u736C\u736E\u736F\u7371\u7377\u7379\u737C\u7380\u7381\u7383\u7385\u7386\u738E\u7390\u7393\u7395\u7397\u7398\u739C\u739E\u739F\u73A0\u73A2\u73A5\u73A6\u73AA\u73AB\u73AD\u73B5\u73B7\u73B9\u73BC\u73BD\u73BF\u73C5\u73C6\u73C9\u73CB\u73CC\u73CF\u73D2\u73D3\u73D6\u73D9\u73DD\u73E1\u73E3\u73E6\u73E7\u73E9\u73F4\u73F5\u73F7\u73F9\u73FA\u73FB\u73FD"],
      ["8fcca1", "\u73FF\u7400\u7401\u7404\u7407\u740A\u7411\u741A\u741B\u7424\u7426\u7428", 9, "\u7439\u7440\u7443\u7444\u7446\u7447\u744B\u744D\u7451\u7452\u7457\u745D\u7462\u7466\u7467\u7468\u746B\u746D\u746E\u7471\u7472\u7480\u7481\u7485\u7486\u7487\u7489\u748F\u7490\u7491\u7492\u7498\u7499\u749A\u749C\u749F\u74A0\u74A1\u74A3\u74A6\u74A8\u74A9\u74AA\u74AB\u74AE\u74AF\u74B1\u74B2\u74B5\u74B9\u74BB\u74BF\u74C8\u74C9\u74CC\u74D0\u74D3\u74D8\u74DA\u74DB\u74DE\u74DF\u74E4\u74E8\u74EA\u74EB\u74EF\u74F4\u74FA\u74FB\u74FC\u74FF\u7506"],
      ["8fcda1", "\u7512\u7516\u7517\u7520\u7521\u7524\u7527\u7529\u752A\u752F\u7536\u7539\u753D\u753E\u753F\u7540\u7543\u7547\u7548\u754E\u7550\u7552\u7557\u755E\u755F\u7561\u756F\u7571\u7579", 5, "\u7581\u7585\u7590\u7592\u7593\u7595\u7599\u759C\u75A2\u75A4\u75B4\u75BA\u75BF\u75C0\u75C1\u75C4\u75C6\u75CC\u75CE\u75CF\u75D7\u75DC\u75DF\u75E0\u75E1\u75E4\u75E7\u75EC\u75EE\u75EF\u75F1\u75F9\u7600\u7602\u7603\u7604\u7607\u7608\u760A\u760C\u760F\u7612\u7613\u7615\u7616\u7619\u761B\u761C\u761D\u761E\u7623\u7625\u7626\u7629\u762D\u7632\u7633\u7635\u7638\u7639"],
      ["8fcea1", "\u763A\u763C\u764A\u7640\u7641\u7643\u7644\u7645\u7649\u764B\u7655\u7659\u765F\u7664\u7665\u766D\u766E\u766F\u7671\u7674\u7681\u7685\u768C\u768D\u7695\u769B\u769C\u769D\u769F\u76A0\u76A2", 6, "\u76AA\u76AD\u76BD\u76C1\u76C5\u76C9\u76CB\u76CC\u76CE\u76D4\u76D9\u76E0\u76E6\u76E8\u76EC\u76F0\u76F1\u76F6\u76F9\u76FC\u7700\u7706\u770A\u770E\u7712\u7714\u7715\u7717\u7719\u771A\u771C\u7722\u7728\u772D\u772E\u772F\u7734\u7735\u7736\u7739\u773D\u773E\u7742\u7745\u7746\u774A\u774D\u774E\u774F\u7752\u7756\u7757\u775C\u775E\u775F\u7760\u7762"],
      ["8fcfa1", "\u7764\u7767\u776A\u776C\u7770\u7772\u7773\u7774\u777A\u777D\u7780\u7784\u778C\u778D\u7794\u7795\u7796\u779A\u779F\u77A2\u77A7\u77AA\u77AE\u77AF\u77B1\u77B5\u77BE\u77C3\u77C9\u77D1\u77D2\u77D5\u77D9\u77DE\u77DF\u77E0\u77E4\u77E6\u77EA\u77EC\u77F0\u77F1\u77F4\u77F8\u77FB\u7805\u7806\u7809\u780D\u780E\u7811\u781D\u7821\u7822\u7823\u782D\u782E\u7830\u7835\u7837\u7843\u7844\u7847\u7848\u784C\u784E\u7852\u785C\u785E\u7860\u7861\u7863\u7864\u7868\u786A\u786E\u787A\u787E\u788A\u788F\u7894\u7898\u78A1\u789D\u789E\u789F\u78A4\u78A8\u78AC\u78AD\u78B0\u78B1\u78B2\u78B3"],
      ["8fd0a1", "\u78BB\u78BD\u78BF\u78C7\u78C8\u78C9\u78CC\u78CE\u78D2\u78D3\u78D5\u78D6\u78E4\u78DB\u78DF\u78E0\u78E1\u78E6\u78EA\u78F2\u78F3\u7900\u78F6\u78F7\u78FA\u78FB\u78FF\u7906\u790C\u7910\u791A\u791C\u791E\u791F\u7920\u7925\u7927\u7929\u792D\u7931\u7934\u7935\u793B\u793D\u793F\u7944\u7945\u7946\u794A\u794B\u794F\u7951\u7954\u7958\u795B\u795C\u7967\u7969\u796B\u7972\u7979\u797B\u797C\u797E\u798B\u798C\u7991\u7993\u7994\u7995\u7996\u7998\u799B\u799C\u79A1\u79A8\u79A9\u79AB\u79AF\u79B1\u79B4\u79B8\u79BB\u79C2\u79C4\u79C7\u79C8\u79CA\u79CF\u79D4\u79D6\u79DA\u79DD\u79DE"],
      ["8fd1a1", "\u79E0\u79E2\u79E5\u79EA\u79EB\u79ED\u79F1\u79F8\u79FC\u7A02\u7A03\u7A07\u7A09\u7A0A\u7A0C\u7A11\u7A15\u7A1B\u7A1E\u7A21\u7A27\u7A2B\u7A2D\u7A2F\u7A30\u7A34\u7A35\u7A38\u7A39\u7A3A\u7A44\u7A45\u7A47\u7A48\u7A4C\u7A55\u7A56\u7A59\u7A5C\u7A5D\u7A5F\u7A60\u7A65\u7A67\u7A6A\u7A6D\u7A75\u7A78\u7A7E\u7A80\u7A82\u7A85\u7A86\u7A8A\u7A8B\u7A90\u7A91\u7A94\u7A9E\u7AA0\u7AA3\u7AAC\u7AB3\u7AB5\u7AB9\u7ABB\u7ABC\u7AC6\u7AC9\u7ACC\u7ACE\u7AD1\u7ADB\u7AE8\u7AE9\u7AEB\u7AEC\u7AF1\u7AF4\u7AFB\u7AFD\u7AFE\u7B07\u7B14\u7B1F\u7B23\u7B27\u7B29\u7B2A\u7B2B\u7B2D\u7B2E\u7B2F\u7B30"],
      ["8fd2a1", "\u7B31\u7B34\u7B3D\u7B3F\u7B40\u7B41\u7B47\u7B4E\u7B55\u7B60\u7B64\u7B66\u7B69\u7B6A\u7B6D\u7B6F\u7B72\u7B73\u7B77\u7B84\u7B89\u7B8E\u7B90\u7B91\u7B96\u7B9B\u7B9E\u7BA0\u7BA5\u7BAC\u7BAF\u7BB0\u7BB2\u7BB5\u7BB6\u7BBA\u7BBB\u7BBC\u7BBD\u7BC2\u7BC5\u7BC8\u7BCA\u7BD4\u7BD6\u7BD7\u7BD9\u7BDA\u7BDB\u7BE8\u7BEA\u7BF2\u7BF4\u7BF5\u7BF8\u7BF9\u7BFA\u7BFC\u7BFE\u7C01\u7C02\u7C03\u7C04\u7C06\u7C09\u7C0B\u7C0C\u7C0E\u7C0F\u7C19\u7C1B\u7C20\u7C25\u7C26\u7C28\u7C2C\u7C31\u7C33\u7C34\u7C36\u7C39\u7C3A\u7C46\u7C4A\u7C55\u7C51\u7C52\u7C53\u7C59", 5],
      ["8fd3a1", "\u7C61\u7C63\u7C67\u7C69\u7C6D\u7C6E\u7C70\u7C72\u7C79\u7C7C\u7C7D\u7C86\u7C87\u7C8F\u7C94\u7C9E\u7CA0\u7CA6\u7CB0\u7CB6\u7CB7\u7CBA\u7CBB\u7CBC\u7CBF\u7CC4\u7CC7\u7CC8\u7CC9\u7CCD\u7CCF\u7CD3\u7CD4\u7CD5\u7CD7\u7CD9\u7CDA\u7CDD\u7CE6\u7CE9\u7CEB\u7CF5\u7D03\u7D07\u7D08\u7D09\u7D0F\u7D11\u7D12\u7D13\u7D16\u7D1D\u7D1E\u7D23\u7D26\u7D2A\u7D2D\u7D31\u7D3C\u7D3D\u7D3E\u7D40\u7D41\u7D47\u7D48\u7D4D\u7D51\u7D53\u7D57\u7D59\u7D5A\u7D5C\u7D5D\u7D65\u7D67\u7D6A\u7D70\u7D78\u7D7A\u7D7B\u7D7F\u7D81\u7D82\u7D83\u7D85\u7D86\u7D88\u7D8B\u7D8C\u7D8D\u7D91\u7D96\u7D97\u7D9D"],
      ["8fd4a1", "\u7D9E\u7DA6\u7DA7\u7DAA\u7DB3\u7DB6\u7DB7\u7DB9\u7DC2", 4, "\u7DCC\u7DCD\u7DCE\u7DD7\u7DD9\u7E00\u7DE2\u7DE5\u7DE6\u7DEA\u7DEB\u7DED\u7DF1\u7DF5\u7DF6\u7DF9\u7DFA\u7E08\u7E10\u7E11\u7E15\u7E17\u7E1C\u7E1D\u7E20\u7E27\u7E28\u7E2C\u7E2D\u7E2F\u7E33\u7E36\u7E3F\u7E44\u7E45\u7E47\u7E4E\u7E50\u7E52\u7E58\u7E5F\u7E61\u7E62\u7E65\u7E6B\u7E6E\u7E6F\u7E73\u7E78\u7E7E\u7E81\u7E86\u7E87\u7E8A\u7E8D\u7E91\u7E95\u7E98\u7E9A\u7E9D\u7E9E\u7F3C\u7F3B\u7F3D\u7F3E\u7F3F\u7F43\u7F44\u7F47\u7F4F\u7F52\u7F53\u7F5B\u7F5C\u7F5D\u7F61\u7F63\u7F64\u7F65\u7F66\u7F6D"],
      ["8fd5a1", "\u7F71\u7F7D\u7F7E\u7F7F\u7F80\u7F8B\u7F8D\u7F8F\u7F90\u7F91\u7F96\u7F97\u7F9C\u7FA1\u7FA2\u7FA6\u7FAA\u7FAD\u7FB4\u7FBC\u7FBF\u7FC0\u7FC3\u7FC8\u7FCE\u7FCF\u7FDB\u7FDF\u7FE3\u7FE5\u7FE8\u7FEC\u7FEE\u7FEF\u7FF2\u7FFA\u7FFD\u7FFE\u7FFF\u8007\u8008\u800A\u800D\u800E\u800F\u8011\u8013\u8014\u8016\u801D\u801E\u801F\u8020\u8024\u8026\u802C\u802E\u8030\u8034\u8035\u8037\u8039\u803A\u803C\u803E\u8040\u8044\u8060\u8064\u8066\u806D\u8071\u8075\u8081\u8088\u808E\u809C\u809E\u80A6\u80A7\u80AB\u80B8\u80B9\u80C8\u80CD\u80CF\u80D2\u80D4\u80D5\u80D7\u80D8\u80E0\u80ED\u80EE"],
      ["8fd6a1", "\u80F0\u80F2\u80F3\u80F6\u80F9\u80FA\u80FE\u8103\u810B\u8116\u8117\u8118\u811C\u811E\u8120\u8124\u8127\u812C\u8130\u8135\u813A\u813C\u8145\u8147\u814A\u814C\u8152\u8157\u8160\u8161\u8167\u8168\u8169\u816D\u816F\u8177\u8181\u8190\u8184\u8185\u8186\u818B\u818E\u8196\u8198\u819B\u819E\u81A2\u81AE\u81B2\u81B4\u81BB\u81CB\u81C3\u81C5\u81CA\u81CE\u81CF\u81D5\u81D7\u81DB\u81DD\u81DE\u81E1\u81E4\u81EB\u81EC\u81F0\u81F1\u81F2\u81F5\u81F6\u81F8\u81F9\u81FD\u81FF\u8200\u8203\u820F\u8213\u8214\u8219\u821A\u821D\u8221\u8222\u8228\u8232\u8234\u823A\u8243\u8244\u8245\u8246"],
      ["8fd7a1", "\u824B\u824E\u824F\u8251\u8256\u825C\u8260\u8263\u8267\u826D\u8274\u827B\u827D\u827F\u8280\u8281\u8283\u8284\u8287\u8289\u828A\u828E\u8291\u8294\u8296\u8298\u829A\u829B\u82A0\u82A1\u82A3\u82A4\u82A7\u82A8\u82A9\u82AA\u82AE\u82B0\u82B2\u82B4\u82B7\u82BA\u82BC\u82BE\u82BF\u82C6\u82D0\u82D5\u82DA\u82E0\u82E2\u82E4\u82E8\u82EA\u82ED\u82EF\u82F6\u82F7\u82FD\u82FE\u8300\u8301\u8307\u8308\u830A\u830B\u8354\u831B\u831D\u831E\u831F\u8321\u8322\u832C\u832D\u832E\u8330\u8333\u8337\u833A\u833C\u833D\u8342\u8343\u8344\u8347\u834D\u834E\u8351\u8355\u8356\u8357\u8370\u8378"],
      ["8fd8a1", "\u837D\u837F\u8380\u8382\u8384\u8386\u838D\u8392\u8394\u8395\u8398\u8399\u839B\u839C\u839D\u83A6\u83A7\u83A9\u83AC\u83BE\u83BF\u83C0\u83C7\u83C9\u83CF\u83D0\u83D1\u83D4\u83DD\u8353\u83E8\u83EA\u83F6\u83F8\u83F9\u83FC\u8401\u8406\u840A\u840F\u8411\u8415\u8419\u83AD\u842F\u8439\u8445\u8447\u8448\u844A\u844D\u844F\u8451\u8452\u8456\u8458\u8459\u845A\u845C\u8460\u8464\u8465\u8467\u846A\u8470\u8473\u8474\u8476\u8478\u847C\u847D\u8481\u8485\u8492\u8493\u8495\u849E\u84A6\u84A8\u84A9\u84AA\u84AF\u84B1\u84B4\u84BA\u84BD\u84BE\u84C0\u84C2\u84C7\u84C8\u84CC\u84CF\u84D3"],
      ["8fd9a1", "\u84DC\u84E7\u84EA\u84EF\u84F0\u84F1\u84F2\u84F7\u8532\u84FA\u84FB\u84FD\u8502\u8503\u8507\u850C\u850E\u8510\u851C\u851E\u8522\u8523\u8524\u8525\u8527\u852A\u852B\u852F\u8533\u8534\u8536\u853F\u8546\u854F", 4, "\u8556\u8559\u855C", 6, "\u8564\u856B\u856F\u8579\u857A\u857B\u857D\u857F\u8581\u8585\u8586\u8589\u858B\u858C\u858F\u8593\u8598\u859D\u859F\u85A0\u85A2\u85A5\u85A7\u85B4\u85B6\u85B7\u85B8\u85BC\u85BD\u85BE\u85BF\u85C2\u85C7\u85CA\u85CB\u85CE\u85AD\u85D8\u85DA\u85DF\u85E0\u85E6\u85E8\u85ED\u85F3\u85F6\u85FC"],
      ["8fdaa1", "\u85FF\u8600\u8604\u8605\u860D\u860E\u8610\u8611\u8612\u8618\u8619\u861B\u861E\u8621\u8627\u8629\u8636\u8638\u863A\u863C\u863D\u8640\u8642\u8646\u8652\u8653\u8656\u8657\u8658\u8659\u865D\u8660", 4, "\u8669\u866C\u866F\u8675\u8676\u8677\u867A\u868D\u8691\u8696\u8698\u869A\u869C\u86A1\u86A6\u86A7\u86A8\u86AD\u86B1\u86B3\u86B4\u86B5\u86B7\u86B8\u86B9\u86BF\u86C0\u86C1\u86C3\u86C5\u86D1\u86D2\u86D5\u86D7\u86DA\u86DC\u86E0\u86E3\u86E5\u86E7\u8688\u86FA\u86FC\u86FD\u8704\u8705\u8707\u870B\u870E\u870F\u8710\u8713\u8714\u8719\u871E\u871F\u8721\u8723"],
      ["8fdba1", "\u8728\u872E\u872F\u8731\u8732\u8739\u873A\u873C\u873D\u873E\u8740\u8743\u8745\u874D\u8758\u875D\u8761\u8764\u8765\u876F\u8771\u8772\u877B\u8783", 6, "\u878B\u878C\u8790\u8793\u8795\u8797\u8798\u8799\u879E\u87A0\u87A3\u87A7\u87AC\u87AD\u87AE\u87B1\u87B5\u87BE\u87BF\u87C1\u87C8\u87C9\u87CA\u87CE\u87D5\u87D6\u87D9\u87DA\u87DC\u87DF\u87E2\u87E3\u87E4\u87EA\u87EB\u87ED\u87F1\u87F3\u87F8\u87FA\u87FF\u8801\u8803\u8806\u8809\u880A\u880B\u8810\u8819\u8812\u8813\u8814\u8818\u881A\u881B\u881C\u881E\u881F\u8828\u882D\u882E\u8830\u8832\u8835"],
      ["8fdca1", "\u883A\u883C\u8841\u8843\u8845\u8848\u8849\u884A\u884B\u884E\u8851\u8855\u8856\u8858\u885A\u885C\u885F\u8860\u8864\u8869\u8871\u8879\u887B\u8880\u8898\u889A\u889B\u889C\u889F\u88A0\u88A8\u88AA\u88BA\u88BD\u88BE\u88C0\u88CA", 4, "\u88D1\u88D2\u88D3\u88DB\u88DE\u88E7\u88EF\u88F0\u88F1\u88F5\u88F7\u8901\u8906\u890D\u890E\u890F\u8915\u8916\u8918\u8919\u891A\u891C\u8920\u8926\u8927\u8928\u8930\u8931\u8932\u8935\u8939\u893A\u893E\u8940\u8942\u8945\u8946\u8949\u894F\u8952\u8957\u895A\u895B\u895C\u8961\u8962\u8963\u896B\u896E\u8970\u8973\u8975\u897A"],
      ["8fdda1", "\u897B\u897C\u897D\u8989\u898D\u8990\u8994\u8995\u899B\u899C\u899F\u89A0\u89A5\u89B0\u89B4\u89B5\u89B6\u89B7\u89BC\u89D4", 4, "\u89E5\u89E9\u89EB\u89ED\u89F1\u89F3\u89F6\u89F9\u89FD\u89FF\u8A04\u8A05\u8A07\u8A0F\u8A11\u8A12\u8A14\u8A15\u8A1E\u8A20\u8A22\u8A24\u8A26\u8A2B\u8A2C\u8A2F\u8A35\u8A37\u8A3D\u8A3E\u8A40\u8A43\u8A45\u8A47\u8A49\u8A4D\u8A4E\u8A53\u8A56\u8A57\u8A58\u8A5C\u8A5D\u8A61\u8A65\u8A67\u8A75\u8A76\u8A77\u8A79\u8A7A\u8A7B\u8A7E\u8A7F\u8A80\u8A83\u8A86\u8A8B\u8A8F\u8A90\u8A92\u8A96\u8A97\u8A99\u8A9F\u8AA7\u8AA9\u8AAE\u8AAF\u8AB3"],
      ["8fdea1", "\u8AB6\u8AB7\u8ABB\u8ABE\u8AC3\u8AC6\u8AC8\u8AC9\u8ACA\u8AD1\u8AD3\u8AD4\u8AD5\u8AD7\u8ADD\u8ADF\u8AEC\u8AF0\u8AF4\u8AF5\u8AF6\u8AFC\u8AFF\u8B05\u8B06\u8B0B\u8B11\u8B1C\u8B1E\u8B1F\u8B0A\u8B2D\u8B30\u8B37\u8B3C\u8B42", 4, "\u8B48\u8B52\u8B53\u8B54\u8B59\u8B4D\u8B5E\u8B63\u8B6D\u8B76\u8B78\u8B79\u8B7C\u8B7E\u8B81\u8B84\u8B85\u8B8B\u8B8D\u8B8F\u8B94\u8B95\u8B9C\u8B9E\u8B9F\u8C38\u8C39\u8C3D\u8C3E\u8C45\u8C47\u8C49\u8C4B\u8C4F\u8C51\u8C53\u8C54\u8C57\u8C58\u8C5B\u8C5D\u8C59\u8C63\u8C64\u8C66\u8C68\u8C69\u8C6D\u8C73\u8C75\u8C76\u8C7B\u8C7E\u8C86"],
      ["8fdfa1", "\u8C87\u8C8B\u8C90\u8C92\u8C93\u8C99\u8C9B\u8C9C\u8CA4\u8CB9\u8CBA\u8CC5\u8CC6\u8CC9\u8CCB\u8CCF\u8CD6\u8CD5\u8CD9\u8CDD\u8CE1\u8CE8\u8CEC\u8CEF\u8CF0\u8CF2\u8CF5\u8CF7\u8CF8\u8CFE\u8CFF\u8D01\u8D03\u8D09\u8D12\u8D17\u8D1B\u8D65\u8D69\u8D6C\u8D6E\u8D7F\u8D82\u8D84\u8D88\u8D8D\u8D90\u8D91\u8D95\u8D9E\u8D9F\u8DA0\u8DA6\u8DAB\u8DAC\u8DAF\u8DB2\u8DB5\u8DB7\u8DB9\u8DBB\u8DC0\u8DC5\u8DC6\u8DC7\u8DC8\u8DCA\u8DCE\u8DD1\u8DD4\u8DD5\u8DD7\u8DD9\u8DE4\u8DE5\u8DE7\u8DEC\u8DF0\u8DBC\u8DF1\u8DF2\u8DF4\u8DFD\u8E01\u8E04\u8E05\u8E06\u8E0B\u8E11\u8E14\u8E16\u8E20\u8E21\u8E22"],
      ["8fe0a1", "\u8E23\u8E26\u8E27\u8E31\u8E33\u8E36\u8E37\u8E38\u8E39\u8E3D\u8E40\u8E41\u8E4B\u8E4D\u8E4E\u8E4F\u8E54\u8E5B\u8E5C\u8E5D\u8E5E\u8E61\u8E62\u8E69\u8E6C\u8E6D\u8E6F\u8E70\u8E71\u8E79\u8E7A\u8E7B\u8E82\u8E83\u8E89\u8E90\u8E92\u8E95\u8E9A\u8E9B\u8E9D\u8E9E\u8EA2\u8EA7\u8EA9\u8EAD\u8EAE\u8EB3\u8EB5\u8EBA\u8EBB\u8EC0\u8EC1\u8EC3\u8EC4\u8EC7\u8ECF\u8ED1\u8ED4\u8EDC\u8EE8\u8EEE\u8EF0\u8EF1\u8EF7\u8EF9\u8EFA\u8EED\u8F00\u8F02\u8F07\u8F08\u8F0F\u8F10\u8F16\u8F17\u8F18\u8F1E\u8F20\u8F21\u8F23\u8F25\u8F27\u8F28\u8F2C\u8F2D\u8F2E\u8F34\u8F35\u8F36\u8F37\u8F3A\u8F40\u8F41"],
      ["8fe1a1", "\u8F43\u8F47\u8F4F\u8F51", 4, "\u8F58\u8F5D\u8F5E\u8F65\u8F9D\u8FA0\u8FA1\u8FA4\u8FA5\u8FA6\u8FB5\u8FB6\u8FB8\u8FBE\u8FC0\u8FC1\u8FC6\u8FCA\u8FCB\u8FCD\u8FD0\u8FD2\u8FD3\u8FD5\u8FE0\u8FE3\u8FE4\u8FE8\u8FEE\u8FF1\u8FF5\u8FF6\u8FFB\u8FFE\u9002\u9004\u9008\u900C\u9018\u901B\u9028\u9029\u902F\u902A\u902C\u902D\u9033\u9034\u9037\u903F\u9043\u9044\u904C\u905B\u905D\u9062\u9066\u9067\u906C\u9070\u9074\u9079\u9085\u9088\u908B\u908C\u908E\u9090\u9095\u9097\u9098\u9099\u909B\u90A0\u90A1\u90A2\u90A5\u90B0\u90B2\u90B3\u90B4\u90B6\u90BD\u90CC\u90BE\u90C3"],
      ["8fe2a1", "\u90C4\u90C5\u90C7\u90C8\u90D5\u90D7\u90D8\u90D9\u90DC\u90DD\u90DF\u90E5\u90D2\u90F6\u90EB\u90EF\u90F0\u90F4\u90FE\u90FF\u9100\u9104\u9105\u9106\u9108\u910D\u9110\u9114\u9116\u9117\u9118\u911A\u911C\u911E\u9120\u9125\u9122\u9123\u9127\u9129\u912E\u912F\u9131\u9134\u9136\u9137\u9139\u913A\u913C\u913D\u9143\u9147\u9148\u914F\u9153\u9157\u9159\u915A\u915B\u9161\u9164\u9167\u916D\u9174\u9179\u917A\u917B\u9181\u9183\u9185\u9186\u918A\u918E\u9191\u9193\u9194\u9195\u9198\u919E\u91A1\u91A6\u91A8\u91AC\u91AD\u91AE\u91B0\u91B1\u91B2\u91B3\u91B6\u91BB\u91BC\u91BD\u91BF"],
      ["8fe3a1", "\u91C2\u91C3\u91C5\u91D3\u91D4\u91D7\u91D9\u91DA\u91DE\u91E4\u91E5\u91E9\u91EA\u91EC", 5, "\u91F7\u91F9\u91FB\u91FD\u9200\u9201\u9204\u9205\u9206\u9207\u9209\u920A\u920C\u9210\u9212\u9213\u9216\u9218\u921C\u921D\u9223\u9224\u9225\u9226\u9228\u922E\u922F\u9230\u9233\u9235\u9236\u9238\u9239\u923A\u923C\u923E\u9240\u9242\u9243\u9246\u9247\u924A\u924D\u924E\u924F\u9251\u9258\u9259\u925C\u925D\u9260\u9261\u9265\u9267\u9268\u9269\u926E\u926F\u9270\u9275", 4, "\u927B\u927C\u927D\u927F\u9288\u9289\u928A\u928D\u928E\u9292\u9297"],
      ["8fe4a1", "\u9299\u929F\u92A0\u92A4\u92A5\u92A7\u92A8\u92AB\u92AF\u92B2\u92B6\u92B8\u92BA\u92BB\u92BC\u92BD\u92BF", 4, "\u92C5\u92C6\u92C7\u92C8\u92CB\u92CC\u92CD\u92CE\u92D0\u92D3\u92D5\u92D7\u92D8\u92D9\u92DC\u92DD\u92DF\u92E0\u92E1\u92E3\u92E5\u92E7\u92E8\u92EC\u92EE\u92F0\u92F9\u92FB\u92FF\u9300\u9302\u9308\u930D\u9311\u9314\u9315\u931C\u931D\u931E\u931F\u9321\u9324\u9325\u9327\u9329\u932A\u9333\u9334\u9336\u9337\u9347\u9348\u9349\u9350\u9351\u9352\u9355\u9357\u9358\u935A\u935E\u9364\u9365\u9367\u9369\u936A\u936D\u936F\u9370\u9371\u9373\u9374\u9376"],
      ["8fe5a1", "\u937A\u937D\u937F\u9380\u9381\u9382\u9388\u938A\u938B\u938D\u938F\u9392\u9395\u9398\u939B\u939E\u93A1\u93A3\u93A4\u93A6\u93A8\u93AB\u93B4\u93B5\u93B6\u93BA\u93A9\u93C1\u93C4\u93C5\u93C6\u93C7\u93C9", 4, "\u93D3\u93D9\u93DC\u93DE\u93DF\u93E2\u93E6\u93E7\u93F9\u93F7\u93F8\u93FA\u93FB\u93FD\u9401\u9402\u9404\u9408\u9409\u940D\u940E\u940F\u9415\u9416\u9417\u941F\u942E\u942F\u9431\u9432\u9433\u9434\u943B\u943F\u943D\u9443\u9445\u9448\u944A\u944C\u9455\u9459\u945C\u945F\u9461\u9463\u9468\u946B\u946D\u946E\u946F\u9471\u9472\u9484\u9483\u9578\u9579"],
      ["8fe6a1", "\u957E\u9584\u9588\u958C\u958D\u958E\u959D\u959E\u959F\u95A1\u95A6\u95A9\u95AB\u95AC\u95B4\u95B6\u95BA\u95BD\u95BF\u95C6\u95C8\u95C9\u95CB\u95D0\u95D1\u95D2\u95D3\u95D9\u95DA\u95DD\u95DE\u95DF\u95E0\u95E4\u95E6\u961D\u961E\u9622\u9624\u9625\u9626\u962C\u9631\u9633\u9637\u9638\u9639\u963A\u963C\u963D\u9641\u9652\u9654\u9656\u9657\u9658\u9661\u966E\u9674\u967B\u967C\u967E\u967F\u9681\u9682\u9683\u9684\u9689\u9691\u9696\u969A\u969D\u969F\u96A4\u96A5\u96A6\u96A9\u96AE\u96AF\u96B3\u96BA\u96CA\u96D2\u5DB2\u96D8\u96DA\u96DD\u96DE\u96DF\u96E9\u96EF\u96F1\u96FA\u9702"],
      ["8fe7a1", "\u9703\u9705\u9709\u971A\u971B\u971D\u9721\u9722\u9723\u9728\u9731\u9733\u9741\u9743\u974A\u974E\u974F\u9755\u9757\u9758\u975A\u975B\u9763\u9767\u976A\u976E\u9773\u9776\u9777\u9778\u977B\u977D\u977F\u9780\u9789\u9795\u9796\u9797\u9799\u979A\u979E\u979F\u97A2\u97AC\u97AE\u97B1\u97B2\u97B5\u97B6\u97B8\u97B9\u97BA\u97BC\u97BE\u97BF\u97C1\u97C4\u97C5\u97C7\u97C9\u97CA\u97CC\u97CD\u97CE\u97D0\u97D1\u97D4\u97D7\u97D8\u97D9\u97DD\u97DE\u97E0\u97DB\u97E1\u97E4\u97EF\u97F1\u97F4\u97F7\u97F8\u97FA\u9807\u980A\u9819\u980D\u980E\u9814\u9816\u981C\u981E\u9820\u9823\u9826"],
      ["8fe8a1", "\u982B\u982E\u982F\u9830\u9832\u9833\u9835\u9825\u983E\u9844\u9847\u984A\u9851\u9852\u9853\u9856\u9857\u9859\u985A\u9862\u9863\u9865\u9866\u986A\u986C\u98AB\u98AD\u98AE\u98B0\u98B4\u98B7\u98B8\u98BA\u98BB\u98BF\u98C2\u98C5\u98C8\u98CC\u98E1\u98E3\u98E5\u98E6\u98E7\u98EA\u98F3\u98F6\u9902\u9907\u9908\u9911\u9915\u9916\u9917\u991A\u991B\u991C\u991F\u9922\u9926\u9927\u992B\u9931", 4, "\u9939\u993A\u993B\u993C\u9940\u9941\u9946\u9947\u9948\u994D\u994E\u9954\u9958\u9959\u995B\u995C\u995E\u995F\u9960\u999B\u999D\u999F\u99A6\u99B0\u99B1\u99B2\u99B5"],
      ["8fe9a1", "\u99B9\u99BA\u99BD\u99BF\u99C3\u99C9\u99D3\u99D4\u99D9\u99DA\u99DC\u99DE\u99E7\u99EA\u99EB\u99EC\u99F0\u99F4\u99F5\u99F9\u99FD\u99FE\u9A02\u9A03\u9A04\u9A0B\u9A0C\u9A10\u9A11\u9A16\u9A1E\u9A20\u9A22\u9A23\u9A24\u9A27\u9A2D\u9A2E\u9A33\u9A35\u9A36\u9A38\u9A47\u9A41\u9A44\u9A4A\u9A4B\u9A4C\u9A4E\u9A51\u9A54\u9A56\u9A5D\u9AAA\u9AAC\u9AAE\u9AAF\u9AB2\u9AB4\u9AB5\u9AB6\u9AB9\u9ABB\u9ABE\u9ABF\u9AC1\u9AC3\u9AC6\u9AC8\u9ACE\u9AD0\u9AD2\u9AD5\u9AD6\u9AD7\u9ADB\u9ADC\u9AE0\u9AE4\u9AE5\u9AE7\u9AE9\u9AEC\u9AF2\u9AF3\u9AF5\u9AF9\u9AFA\u9AFD\u9AFF", 4],
      ["8feaa1", "\u9B04\u9B05\u9B08\u9B09\u9B0B\u9B0C\u9B0D\u9B0E\u9B10\u9B12\u9B16\u9B19\u9B1B\u9B1C\u9B20\u9B26\u9B2B\u9B2D\u9B33\u9B34\u9B35\u9B37\u9B39\u9B3A\u9B3D\u9B48\u9B4B\u9B4C\u9B55\u9B56\u9B57\u9B5B\u9B5E\u9B61\u9B63\u9B65\u9B66\u9B68\u9B6A", 4, "\u9B73\u9B75\u9B77\u9B78\u9B79\u9B7F\u9B80\u9B84\u9B85\u9B86\u9B87\u9B89\u9B8A\u9B8B\u9B8D\u9B8F\u9B90\u9B94\u9B9A\u9B9D\u9B9E\u9BA6\u9BA7\u9BA9\u9BAC\u9BB0\u9BB1\u9BB2\u9BB7\u9BB8\u9BBB\u9BBC\u9BBE\u9BBF\u9BC1\u9BC7\u9BC8\u9BCE\u9BD0\u9BD7\u9BD8\u9BDD\u9BDF\u9BE5\u9BE7\u9BEA\u9BEB\u9BEF\u9BF3\u9BF7\u9BF8"],
      ["8feba1", "\u9BF9\u9BFA\u9BFD\u9BFF\u9C00\u9C02\u9C0B\u9C0F\u9C11\u9C16\u9C18\u9C19\u9C1A\u9C1C\u9C1E\u9C22\u9C23\u9C26", 4, "\u9C31\u9C35\u9C36\u9C37\u9C3D\u9C41\u9C43\u9C44\u9C45\u9C49\u9C4A\u9C4E\u9C4F\u9C50\u9C53\u9C54\u9C56\u9C58\u9C5B\u9C5D\u9C5E\u9C5F\u9C63\u9C69\u9C6A\u9C5C\u9C6B\u9C68\u9C6E\u9C70\u9C72\u9C75\u9C77\u9C7B\u9CE6\u9CF2\u9CF7\u9CF9\u9D0B\u9D02\u9D11\u9D17\u9D18\u9D1C\u9D1D\u9D1E\u9D2F\u9D30\u9D32\u9D33\u9D34\u9D3A\u9D3C\u9D45\u9D3D\u9D42\u9D43\u9D47\u9D4A\u9D53\u9D54\u9D5F\u9D63\u9D62\u9D65\u9D69\u9D6A\u9D6B\u9D70\u9D76\u9D77\u9D7B"],
      ["8feca1", "\u9D7C\u9D7E\u9D83\u9D84\u9D86\u9D8A\u9D8D\u9D8E\u9D92\u9D93\u9D95\u9D96\u9D97\u9D98\u9DA1\u9DAA\u9DAC\u9DAE\u9DB1\u9DB5\u9DB9\u9DBC\u9DBF\u9DC3\u9DC7\u9DC9\u9DCA\u9DD4\u9DD5\u9DD6\u9DD7\u9DDA\u9DDE\u9DDF\u9DE0\u9DE5\u9DE7\u9DE9\u9DEB\u9DEE\u9DF0\u9DF3\u9DF4\u9DFE\u9E0A\u9E02\u9E07\u9E0E\u9E10\u9E11\u9E12\u9E15\u9E16\u9E19\u9E1C\u9E1D\u9E7A\u9E7B\u9E7C\u9E80\u9E82\u9E83\u9E84\u9E85\u9E87\u9E8E\u9E8F\u9E96\u9E98\u9E9B\u9E9E\u9EA4\u9EA8\u9EAC\u9EAE\u9EAF\u9EB0\u9EB3\u9EB4\u9EB5\u9EC6\u9EC8\u9ECB\u9ED5\u9EDF\u9EE4\u9EE7\u9EEC\u9EED\u9EEE\u9EF0\u9EF1\u9EF2\u9EF5"],
      ["8feda1", "\u9EF8\u9EFF\u9F02\u9F03\u9F09\u9F0F\u9F10\u9F11\u9F12\u9F14\u9F16\u9F17\u9F19\u9F1A\u9F1B\u9F1F\u9F22\u9F26\u9F2A\u9F2B\u9F2F\u9F31\u9F32\u9F34\u9F37\u9F39\u9F3A\u9F3C\u9F3D\u9F3F\u9F41\u9F43", 4, "\u9F53\u9F55\u9F56\u9F57\u9F58\u9F5A\u9F5D\u9F5E\u9F68\u9F69\u9F6D", 4, "\u9F73\u9F75\u9F7A\u9F7D\u9F8F\u9F90\u9F91\u9F92\u9F94\u9F96\u9F97\u9F9E\u9FA1\u9FA2\u9FA3\u9FA5"]
    ];
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/tables/cp936.json
var require_cp9362 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/tables/cp936.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127, "\u20AC"],
      ["8140", "\u4E02\u4E04\u4E05\u4E06\u4E0F\u4E12\u4E17\u4E1F\u4E20\u4E21\u4E23\u4E26\u4E29\u4E2E\u4E2F\u4E31\u4E33\u4E35\u4E37\u4E3C\u4E40\u4E41\u4E42\u4E44\u4E46\u4E4A\u4E51\u4E55\u4E57\u4E5A\u4E5B\u4E62\u4E63\u4E64\u4E65\u4E67\u4E68\u4E6A", 5, "\u4E72\u4E74", 9, "\u4E7F", 6, "\u4E87\u4E8A"],
      ["8180", "\u4E90\u4E96\u4E97\u4E99\u4E9C\u4E9D\u4E9E\u4EA3\u4EAA\u4EAF\u4EB0\u4EB1\u4EB4\u4EB6\u4EB7\u4EB8\u4EB9\u4EBC\u4EBD\u4EBE\u4EC8\u4ECC\u4ECF\u4ED0\u4ED2\u4EDA\u4EDB\u4EDC\u4EE0\u4EE2\u4EE6\u4EE7\u4EE9\u4EED\u4EEE\u4EEF\u4EF1\u4EF4\u4EF8\u4EF9\u4EFA\u4EFC\u4EFE\u4F00\u4F02", 6, "\u4F0B\u4F0C\u4F12", 4, "\u4F1C\u4F1D\u4F21\u4F23\u4F28\u4F29\u4F2C\u4F2D\u4F2E\u4F31\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E", 4, "\u4F44\u4F45\u4F47", 5, "\u4F52\u4F54\u4F56\u4F61\u4F62\u4F66\u4F68\u4F6A\u4F6B\u4F6D\u4F6E\u4F71\u4F72\u4F75\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F80\u4F81\u4F82\u4F85\u4F86\u4F87\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F95\u4F96\u4F98\u4F99\u4F9A\u4F9C\u4F9E\u4F9F\u4FA1\u4FA2"],
      ["8240", "\u4FA4\u4FAB\u4FAD\u4FB0", 4, "\u4FB6", 8, "\u4FC0\u4FC1\u4FC2\u4FC6\u4FC7\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FD2", 4, "\u4FD9\u4FDB\u4FE0\u4FE2\u4FE4\u4FE5\u4FE7\u4FEB\u4FEC\u4FF0\u4FF2\u4FF4\u4FF5\u4FF6\u4FF7\u4FF9\u4FFB\u4FFC\u4FFD\u4FFF", 11],
      ["8280", "\u500B\u500E\u5010\u5011\u5013\u5015\u5016\u5017\u501B\u501D\u501E\u5020\u5022\u5023\u5024\u5027\u502B\u502F", 10, "\u503B\u503D\u503F\u5040\u5041\u5042\u5044\u5045\u5046\u5049\u504A\u504B\u504D\u5050", 4, "\u5056\u5057\u5058\u5059\u505B\u505D", 7, "\u5066", 5, "\u506D", 8, "\u5078\u5079\u507A\u507C\u507D\u5081\u5082\u5083\u5084\u5086\u5087\u5089\u508A\u508B\u508C\u508E", 20, "\u50A4\u50A6\u50AA\u50AB\u50AD", 4, "\u50B3", 6, "\u50BC"],
      ["8340", "\u50BD", 17, "\u50D0", 5, "\u50D7\u50D8\u50D9\u50DB", 10, "\u50E8\u50E9\u50EA\u50EB\u50EF\u50F0\u50F1\u50F2\u50F4\u50F6", 4, "\u50FC", 9, "\u5108"],
      ["8380", "\u5109\u510A\u510C", 5, "\u5113", 13, "\u5122", 28, "\u5142\u5147\u514A\u514C\u514E\u514F\u5150\u5152\u5153\u5157\u5158\u5159\u515B\u515D", 4, "\u5163\u5164\u5166\u5167\u5169\u516A\u516F\u5172\u517A\u517E\u517F\u5183\u5184\u5186\u5187\u518A\u518B\u518E\u518F\u5190\u5191\u5193\u5194\u5198\u519A\u519D\u519E\u519F\u51A1\u51A3\u51A6", 4, "\u51AD\u51AE\u51B4\u51B8\u51B9\u51BA\u51BE\u51BF\u51C1\u51C2\u51C3\u51C5\u51C8\u51CA\u51CD\u51CE\u51D0\u51D2", 5],
      ["8440", "\u51D8\u51D9\u51DA\u51DC\u51DE\u51DF\u51E2\u51E3\u51E5", 5, "\u51EC\u51EE\u51F1\u51F2\u51F4\u51F7\u51FE\u5204\u5205\u5209\u520B\u520C\u520F\u5210\u5213\u5214\u5215\u521C\u521E\u521F\u5221\u5222\u5223\u5225\u5226\u5227\u522A\u522C\u522F\u5231\u5232\u5234\u5235\u523C\u523E\u5244", 5, "\u524B\u524E\u524F\u5252\u5253\u5255\u5257\u5258"],
      ["8480", "\u5259\u525A\u525B\u525D\u525F\u5260\u5262\u5263\u5264\u5266\u5268\u526B\u526C\u526D\u526E\u5270\u5271\u5273", 9, "\u527E\u5280\u5283", 4, "\u5289", 6, "\u5291\u5292\u5294", 6, "\u529C\u52A4\u52A5\u52A6\u52A7\u52AE\u52AF\u52B0\u52B4", 9, "\u52C0\u52C1\u52C2\u52C4\u52C5\u52C6\u52C8\u52CA\u52CC\u52CD\u52CE\u52CF\u52D1\u52D3\u52D4\u52D5\u52D7\u52D9", 5, "\u52E0\u52E1\u52E2\u52E3\u52E5", 10, "\u52F1", 7, "\u52FB\u52FC\u52FD\u5301\u5302\u5303\u5304\u5307\u5309\u530A\u530B\u530C\u530E"],
      ["8540", "\u5311\u5312\u5313\u5314\u5318\u531B\u531C\u531E\u531F\u5322\u5324\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u532F", 9, "\u533C\u533D\u5340\u5342\u5344\u5346\u534B\u534C\u534D\u5350\u5354\u5358\u5359\u535B\u535D\u5365\u5368\u536A\u536C\u536D\u5372\u5376\u5379\u537B\u537C\u537D\u537E\u5380\u5381\u5383\u5387\u5388\u538A\u538E\u538F"],
      ["8580", "\u5390", 4, "\u5396\u5397\u5399\u539B\u539C\u539E\u53A0\u53A1\u53A4\u53A7\u53AA\u53AB\u53AC\u53AD\u53AF", 6, "\u53B7\u53B8\u53B9\u53BA\u53BC\u53BD\u53BE\u53C0\u53C3", 4, "\u53CE\u53CF\u53D0\u53D2\u53D3\u53D5\u53DA\u53DC\u53DD\u53DE\u53E1\u53E2\u53E7\u53F4\u53FA\u53FE\u53FF\u5400\u5402\u5405\u5407\u540B\u5414\u5418\u5419\u541A\u541C\u5422\u5424\u5425\u542A\u5430\u5433\u5436\u5437\u543A\u543D\u543F\u5441\u5442\u5444\u5445\u5447\u5449\u544C\u544D\u544E\u544F\u5451\u545A\u545D", 4, "\u5463\u5465\u5467\u5469", 7, "\u5474\u5479\u547A\u547E\u547F\u5481\u5483\u5485\u5487\u5488\u5489\u548A\u548D\u5491\u5493\u5497\u5498\u549C\u549E\u549F\u54A0\u54A1"],
      ["8640", "\u54A2\u54A5\u54AE\u54B0\u54B2\u54B5\u54B6\u54B7\u54B9\u54BA\u54BC\u54BE\u54C3\u54C5\u54CA\u54CB\u54D6\u54D8\u54DB\u54E0", 4, "\u54EB\u54EC\u54EF\u54F0\u54F1\u54F4", 5, "\u54FB\u54FE\u5500\u5502\u5503\u5504\u5505\u5508\u550A", 4, "\u5512\u5513\u5515", 5, "\u551C\u551D\u551E\u551F\u5521\u5525\u5526"],
      ["8680", "\u5528\u5529\u552B\u552D\u5532\u5534\u5535\u5536\u5538\u5539\u553A\u553B\u553D\u5540\u5542\u5545\u5547\u5548\u554B", 4, "\u5551\u5552\u5553\u5554\u5557", 4, "\u555D\u555E\u555F\u5560\u5562\u5563\u5568\u5569\u556B\u556F", 5, "\u5579\u557A\u557D\u557F\u5585\u5586\u558C\u558D\u558E\u5590\u5592\u5593\u5595\u5596\u5597\u559A\u559B\u559E\u55A0", 6, "\u55A8", 8, "\u55B2\u55B4\u55B6\u55B8\u55BA\u55BC\u55BF", 4, "\u55C6\u55C7\u55C8\u55CA\u55CB\u55CE\u55CF\u55D0\u55D5\u55D7", 4, "\u55DE\u55E0\u55E2\u55E7\u55E9\u55ED\u55EE\u55F0\u55F1\u55F4\u55F6\u55F8", 4, "\u55FF\u5602\u5603\u5604\u5605"],
      ["8740", "\u5606\u5607\u560A\u560B\u560D\u5610", 7, "\u5619\u561A\u561C\u561D\u5620\u5621\u5622\u5625\u5626\u5628\u5629\u562A\u562B\u562E\u562F\u5630\u5633\u5635\u5637\u5638\u563A\u563C\u563D\u563E\u5640", 11, "\u564F", 4, "\u5655\u5656\u565A\u565B\u565D", 4],
      ["8780", "\u5663\u5665\u5666\u5667\u566D\u566E\u566F\u5670\u5672\u5673\u5674\u5675\u5677\u5678\u5679\u567A\u567D", 7, "\u5687", 6, "\u5690\u5691\u5692\u5694", 14, "\u56A4", 10, "\u56B0", 6, "\u56B8\u56B9\u56BA\u56BB\u56BD", 12, "\u56CB", 8, "\u56D5\u56D6\u56D8\u56D9\u56DC\u56E3\u56E5", 5, "\u56EC\u56EE\u56EF\u56F2\u56F3\u56F6\u56F7\u56F8\u56FB\u56FC\u5700\u5701\u5702\u5705\u5707\u570B", 6],
      ["8840", "\u5712", 9, "\u571D\u571E\u5720\u5721\u5722\u5724\u5725\u5726\u5727\u572B\u5731\u5732\u5734", 4, "\u573C\u573D\u573F\u5741\u5743\u5744\u5745\u5746\u5748\u5749\u574B\u5752", 4, "\u5758\u5759\u5762\u5763\u5765\u5767\u576C\u576E\u5770\u5771\u5772\u5774\u5775\u5778\u5779\u577A\u577D\u577E\u577F\u5780"],
      ["8880", "\u5781\u5787\u5788\u5789\u578A\u578D", 4, "\u5794", 6, "\u579C\u579D\u579E\u579F\u57A5\u57A8\u57AA\u57AC\u57AF\u57B0\u57B1\u57B3\u57B5\u57B6\u57B7\u57B9", 8, "\u57C4", 6, "\u57CC\u57CD\u57D0\u57D1\u57D3\u57D6\u57D7\u57DB\u57DC\u57DE\u57E1\u57E2\u57E3\u57E5", 7, "\u57EE\u57F0\u57F1\u57F2\u57F3\u57F5\u57F6\u57F7\u57FB\u57FC\u57FE\u57FF\u5801\u5803\u5804\u5805\u5808\u5809\u580A\u580C\u580E\u580F\u5810\u5812\u5813\u5814\u5816\u5817\u5818\u581A\u581B\u581C\u581D\u581F\u5822\u5823\u5825", 4, "\u582B", 4, "\u5831\u5832\u5833\u5834\u5836", 7],
      ["8940", "\u583E", 5, "\u5845", 6, "\u584E\u584F\u5850\u5852\u5853\u5855\u5856\u5857\u5859", 4, "\u585F", 5, "\u5866", 4, "\u586D", 16, "\u587F\u5882\u5884\u5886\u5887\u5888\u588A\u588B\u588C"],
      ["8980", "\u588D", 4, "\u5894", 4, "\u589B\u589C\u589D\u58A0", 7, "\u58AA", 17, "\u58BD\u58BE\u58BF\u58C0\u58C2\u58C3\u58C4\u58C6", 10, "\u58D2\u58D3\u58D4\u58D6", 13, "\u58E5", 5, "\u58ED\u58EF\u58F1\u58F2\u58F4\u58F5\u58F7\u58F8\u58FA", 7, "\u5903\u5905\u5906\u5908", 4, "\u590E\u5910\u5911\u5912\u5913\u5917\u5918\u591B\u591D\u591E\u5920\u5921\u5922\u5923\u5926\u5928\u592C\u5930\u5932\u5933\u5935\u5936\u593B"],
      ["8a40", "\u593D\u593E\u593F\u5940\u5943\u5945\u5946\u594A\u594C\u594D\u5950\u5952\u5953\u5959\u595B", 4, "\u5961\u5963\u5964\u5966", 12, "\u5975\u5977\u597A\u597B\u597C\u597E\u597F\u5980\u5985\u5989\u598B\u598C\u598E\u598F\u5990\u5991\u5994\u5995\u5998\u599A\u599B\u599C\u599D\u599F\u59A0\u59A1\u59A2\u59A6"],
      ["8a80", "\u59A7\u59AC\u59AD\u59B0\u59B1\u59B3", 5, "\u59BA\u59BC\u59BD\u59BF", 6, "\u59C7\u59C8\u59C9\u59CC\u59CD\u59CE\u59CF\u59D5\u59D6\u59D9\u59DB\u59DE", 4, "\u59E4\u59E6\u59E7\u59E9\u59EA\u59EB\u59ED", 11, "\u59FA\u59FC\u59FD\u59FE\u5A00\u5A02\u5A0A\u5A0B\u5A0D\u5A0E\u5A0F\u5A10\u5A12\u5A14\u5A15\u5A16\u5A17\u5A19\u5A1A\u5A1B\u5A1D\u5A1E\u5A21\u5A22\u5A24\u5A26\u5A27\u5A28\u5A2A", 6, "\u5A33\u5A35\u5A37", 4, "\u5A3D\u5A3E\u5A3F\u5A41", 4, "\u5A47\u5A48\u5A4B", 9, "\u5A56\u5A57\u5A58\u5A59\u5A5B", 5],
      ["8b40", "\u5A61\u5A63\u5A64\u5A65\u5A66\u5A68\u5A69\u5A6B", 8, "\u5A78\u5A79\u5A7B\u5A7C\u5A7D\u5A7E\u5A80", 17, "\u5A93", 6, "\u5A9C", 13, "\u5AAB\u5AAC"],
      ["8b80", "\u5AAD", 4, "\u5AB4\u5AB6\u5AB7\u5AB9", 4, "\u5ABF\u5AC0\u5AC3", 5, "\u5ACA\u5ACB\u5ACD", 4, "\u5AD3\u5AD5\u5AD7\u5AD9\u5ADA\u5ADB\u5ADD\u5ADE\u5ADF\u5AE2\u5AE4\u5AE5\u5AE7\u5AE8\u5AEA\u5AEC", 4, "\u5AF2", 22, "\u5B0A", 11, "\u5B18", 25, "\u5B33\u5B35\u5B36\u5B38", 7, "\u5B41", 6],
      ["8c40", "\u5B48", 7, "\u5B52\u5B56\u5B5E\u5B60\u5B61\u5B67\u5B68\u5B6B\u5B6D\u5B6E\u5B6F\u5B72\u5B74\u5B76\u5B77\u5B78\u5B79\u5B7B\u5B7C\u5B7E\u5B7F\u5B82\u5B86\u5B8A\u5B8D\u5B8E\u5B90\u5B91\u5B92\u5B94\u5B96\u5B9F\u5BA7\u5BA8\u5BA9\u5BAC\u5BAD\u5BAE\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBB\u5BBC\u5BC0\u5BC1\u5BC3\u5BC8\u5BC9\u5BCA\u5BCB\u5BCD\u5BCE\u5BCF"],
      ["8c80", "\u5BD1\u5BD4", 8, "\u5BE0\u5BE2\u5BE3\u5BE6\u5BE7\u5BE9", 4, "\u5BEF\u5BF1", 6, "\u5BFD\u5BFE\u5C00\u5C02\u5C03\u5C05\u5C07\u5C08\u5C0B\u5C0C\u5C0D\u5C0E\u5C10\u5C12\u5C13\u5C17\u5C19\u5C1B\u5C1E\u5C1F\u5C20\u5C21\u5C23\u5C26\u5C28\u5C29\u5C2A\u5C2B\u5C2D\u5C2E\u5C2F\u5C30\u5C32\u5C33\u5C35\u5C36\u5C37\u5C43\u5C44\u5C46\u5C47\u5C4C\u5C4D\u5C52\u5C53\u5C54\u5C56\u5C57\u5C58\u5C5A\u5C5B\u5C5C\u5C5D\u5C5F\u5C62\u5C64\u5C67", 6, "\u5C70\u5C72", 6, "\u5C7B\u5C7C\u5C7D\u5C7E\u5C80\u5C83", 4, "\u5C89\u5C8A\u5C8B\u5C8E\u5C8F\u5C92\u5C93\u5C95\u5C9D", 4, "\u5CA4", 4],
      ["8d40", "\u5CAA\u5CAE\u5CAF\u5CB0\u5CB2\u5CB4\u5CB6\u5CB9\u5CBA\u5CBB\u5CBC\u5CBE\u5CC0\u5CC2\u5CC3\u5CC5", 5, "\u5CCC", 5, "\u5CD3", 5, "\u5CDA", 6, "\u5CE2\u5CE3\u5CE7\u5CE9\u5CEB\u5CEC\u5CEE\u5CEF\u5CF1", 9, "\u5CFC", 4],
      ["8d80", "\u5D01\u5D04\u5D05\u5D08", 5, "\u5D0F", 4, "\u5D15\u5D17\u5D18\u5D19\u5D1A\u5D1C\u5D1D\u5D1F", 4, "\u5D25\u5D28\u5D2A\u5D2B\u5D2C\u5D2F", 4, "\u5D35", 7, "\u5D3F", 7, "\u5D48\u5D49\u5D4D", 10, "\u5D59\u5D5A\u5D5C\u5D5E", 10, "\u5D6A\u5D6D\u5D6E\u5D70\u5D71\u5D72\u5D73\u5D75", 12, "\u5D83", 21, "\u5D9A\u5D9B\u5D9C\u5D9E\u5D9F\u5DA0"],
      ["8e40", "\u5DA1", 21, "\u5DB8", 12, "\u5DC6", 6, "\u5DCE", 12, "\u5DDC\u5DDF\u5DE0\u5DE3\u5DE4\u5DEA\u5DEC\u5DED"],
      ["8e80", "\u5DF0\u5DF5\u5DF6\u5DF8", 4, "\u5DFF\u5E00\u5E04\u5E07\u5E09\u5E0A\u5E0B\u5E0D\u5E0E\u5E12\u5E13\u5E17\u5E1E", 7, "\u5E28", 4, "\u5E2F\u5E30\u5E32", 4, "\u5E39\u5E3A\u5E3E\u5E3F\u5E40\u5E41\u5E43\u5E46", 5, "\u5E4D", 6, "\u5E56", 4, "\u5E5C\u5E5D\u5E5F\u5E60\u5E63", 14, "\u5E75\u5E77\u5E79\u5E7E\u5E81\u5E82\u5E83\u5E85\u5E88\u5E89\u5E8C\u5E8D\u5E8E\u5E92\u5E98\u5E9B\u5E9D\u5EA1\u5EA2\u5EA3\u5EA4\u5EA8", 4, "\u5EAE", 4, "\u5EB4\u5EBA\u5EBB\u5EBC\u5EBD\u5EBF", 6],
      ["8f40", "\u5EC6\u5EC7\u5EC8\u5ECB", 5, "\u5ED4\u5ED5\u5ED7\u5ED8\u5ED9\u5EDA\u5EDC", 11, "\u5EE9\u5EEB", 8, "\u5EF5\u5EF8\u5EF9\u5EFB\u5EFC\u5EFD\u5F05\u5F06\u5F07\u5F09\u5F0C\u5F0D\u5F0E\u5F10\u5F12\u5F14\u5F16\u5F19\u5F1A\u5F1C\u5F1D\u5F1E\u5F21\u5F22\u5F23\u5F24"],
      ["8f80", "\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F32", 6, "\u5F3B\u5F3D\u5F3E\u5F3F\u5F41", 14, "\u5F51\u5F54\u5F59\u5F5A\u5F5B\u5F5C\u5F5E\u5F5F\u5F60\u5F63\u5F65\u5F67\u5F68\u5F6B\u5F6E\u5F6F\u5F72\u5F74\u5F75\u5F76\u5F78\u5F7A\u5F7D\u5F7E\u5F7F\u5F83\u5F86\u5F8D\u5F8E\u5F8F\u5F91\u5F93\u5F94\u5F96\u5F9A\u5F9B\u5F9D\u5F9E\u5F9F\u5FA0\u5FA2", 5, "\u5FA9\u5FAB\u5FAC\u5FAF", 5, "\u5FB6\u5FB8\u5FB9\u5FBA\u5FBB\u5FBE", 4, "\u5FC7\u5FC8\u5FCA\u5FCB\u5FCE\u5FD3\u5FD4\u5FD5\u5FDA\u5FDB\u5FDC\u5FDE\u5FDF\u5FE2\u5FE3\u5FE5\u5FE6\u5FE8\u5FE9\u5FEC\u5FEF\u5FF0\u5FF2\u5FF3\u5FF4\u5FF6\u5FF7\u5FF9\u5FFA\u5FFC\u6007"],
      ["9040", "\u6008\u6009\u600B\u600C\u6010\u6011\u6013\u6017\u6018\u601A\u601E\u601F\u6022\u6023\u6024\u602C\u602D\u602E\u6030", 4, "\u6036", 4, "\u603D\u603E\u6040\u6044", 6, "\u604C\u604E\u604F\u6051\u6053\u6054\u6056\u6057\u6058\u605B\u605C\u605E\u605F\u6060\u6061\u6065\u6066\u606E\u6071\u6072\u6074\u6075\u6077\u607E\u6080"],
      ["9080", "\u6081\u6082\u6085\u6086\u6087\u6088\u608A\u608B\u608E\u608F\u6090\u6091\u6093\u6095\u6097\u6098\u6099\u609C\u609E\u60A1\u60A2\u60A4\u60A5\u60A7\u60A9\u60AA\u60AE\u60B0\u60B3\u60B5\u60B6\u60B7\u60B9\u60BA\u60BD", 7, "\u60C7\u60C8\u60C9\u60CC", 4, "\u60D2\u60D3\u60D4\u60D6\u60D7\u60D9\u60DB\u60DE\u60E1", 4, "\u60EA\u60F1\u60F2\u60F5\u60F7\u60F8\u60FB", 4, "\u6102\u6103\u6104\u6105\u6107\u610A\u610B\u610C\u6110", 4, "\u6116\u6117\u6118\u6119\u611B\u611C\u611D\u611E\u6121\u6122\u6125\u6128\u6129\u612A\u612C", 18, "\u6140", 6],
      ["9140", "\u6147\u6149\u614B\u614D\u614F\u6150\u6152\u6153\u6154\u6156", 6, "\u615E\u615F\u6160\u6161\u6163\u6164\u6165\u6166\u6169", 6, "\u6171\u6172\u6173\u6174\u6176\u6178", 18, "\u618C\u618D\u618F", 4, "\u6195"],
      ["9180", "\u6196", 6, "\u619E", 8, "\u61AA\u61AB\u61AD", 9, "\u61B8", 5, "\u61BF\u61C0\u61C1\u61C3", 4, "\u61C9\u61CC", 4, "\u61D3\u61D5", 16, "\u61E7", 13, "\u61F6", 8, "\u6200", 5, "\u6207\u6209\u6213\u6214\u6219\u621C\u621D\u621E\u6220\u6223\u6226\u6227\u6228\u6229\u622B\u622D\u622F\u6230\u6231\u6232\u6235\u6236\u6238", 4, "\u6242\u6244\u6245\u6246\u624A"],
      ["9240", "\u624F\u6250\u6255\u6256\u6257\u6259\u625A\u625C", 6, "\u6264\u6265\u6268\u6271\u6272\u6274\u6275\u6277\u6278\u627A\u627B\u627D\u6281\u6282\u6283\u6285\u6286\u6287\u6288\u628B", 5, "\u6294\u6299\u629C\u629D\u629E\u62A3\u62A6\u62A7\u62A9\u62AA\u62AD\u62AE\u62AF\u62B0\u62B2\u62B3\u62B4\u62B6\u62B7\u62B8\u62BA\u62BE\u62C0\u62C1"],
      ["9280", "\u62C3\u62CB\u62CF\u62D1\u62D5\u62DD\u62DE\u62E0\u62E1\u62E4\u62EA\u62EB\u62F0\u62F2\u62F5\u62F8\u62F9\u62FA\u62FB\u6300\u6303\u6304\u6305\u6306\u630A\u630B\u630C\u630D\u630F\u6310\u6312\u6313\u6314\u6315\u6317\u6318\u6319\u631C\u6326\u6327\u6329\u632C\u632D\u632E\u6330\u6331\u6333", 5, "\u633B\u633C\u633E\u633F\u6340\u6341\u6344\u6347\u6348\u634A\u6351\u6352\u6353\u6354\u6356", 7, "\u6360\u6364\u6365\u6366\u6368\u636A\u636B\u636C\u636F\u6370\u6372\u6373\u6374\u6375\u6378\u6379\u637C\u637D\u637E\u637F\u6381\u6383\u6384\u6385\u6386\u638B\u638D\u6391\u6393\u6394\u6395\u6397\u6399", 6, "\u63A1\u63A4\u63A6\u63AB\u63AF\u63B1\u63B2\u63B5\u63B6\u63B9\u63BB\u63BD\u63BF\u63C0"],
      ["9340", "\u63C1\u63C2\u63C3\u63C5\u63C7\u63C8\u63CA\u63CB\u63CC\u63D1\u63D3\u63D4\u63D5\u63D7", 6, "\u63DF\u63E2\u63E4", 4, "\u63EB\u63EC\u63EE\u63EF\u63F0\u63F1\u63F3\u63F5\u63F7\u63F9\u63FA\u63FB\u63FC\u63FE\u6403\u6404\u6406", 4, "\u640D\u640E\u6411\u6412\u6415", 5, "\u641D\u641F\u6422\u6423\u6424"],
      ["9380", "\u6425\u6427\u6428\u6429\u642B\u642E", 5, "\u6435", 4, "\u643B\u643C\u643E\u6440\u6442\u6443\u6449\u644B", 6, "\u6453\u6455\u6456\u6457\u6459", 4, "\u645F", 7, "\u6468\u646A\u646B\u646C\u646E", 9, "\u647B", 6, "\u6483\u6486\u6488", 8, "\u6493\u6494\u6497\u6498\u649A\u649B\u649C\u649D\u649F", 4, "\u64A5\u64A6\u64A7\u64A8\u64AA\u64AB\u64AF\u64B1\u64B2\u64B3\u64B4\u64B6\u64B9\u64BB\u64BD\u64BE\u64BF\u64C1\u64C3\u64C4\u64C6", 6, "\u64CF\u64D1\u64D3\u64D4\u64D5\u64D6\u64D9\u64DA"],
      ["9440", "\u64DB\u64DC\u64DD\u64DF\u64E0\u64E1\u64E3\u64E5\u64E7", 24, "\u6501", 7, "\u650A", 7, "\u6513", 4, "\u6519", 8],
      ["9480", "\u6522\u6523\u6524\u6526", 4, "\u652C\u652D\u6530\u6531\u6532\u6533\u6537\u653A\u653C\u653D\u6540", 4, "\u6546\u6547\u654A\u654B\u654D\u654E\u6550\u6552\u6553\u6554\u6557\u6558\u655A\u655C\u655F\u6560\u6561\u6564\u6565\u6567\u6568\u6569\u656A\u656D\u656E\u656F\u6571\u6573\u6575\u6576\u6578", 14, "\u6588\u6589\u658A\u658D\u658E\u658F\u6592\u6594\u6595\u6596\u6598\u659A\u659D\u659E\u65A0\u65A2\u65A3\u65A6\u65A8\u65AA\u65AC\u65AE\u65B1", 7, "\u65BA\u65BB\u65BE\u65BF\u65C0\u65C2\u65C7\u65C8\u65C9\u65CA\u65CD\u65D0\u65D1\u65D3\u65D4\u65D5\u65D8", 7, "\u65E1\u65E3\u65E4\u65EA\u65EB"],
      ["9540", "\u65F2\u65F3\u65F4\u65F5\u65F8\u65F9\u65FB", 4, "\u6601\u6604\u6605\u6607\u6608\u6609\u660B\u660D\u6610\u6611\u6612\u6616\u6617\u6618\u661A\u661B\u661C\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6632\u6633\u6637", 4, "\u663D\u663F\u6640\u6642\u6644", 6, "\u664D\u664E\u6650\u6651\u6658"],
      ["9580", "\u6659\u665B\u665C\u665D\u665E\u6660\u6662\u6663\u6665\u6667\u6669", 4, "\u6671\u6672\u6673\u6675\u6678\u6679\u667B\u667C\u667D\u667F\u6680\u6681\u6683\u6685\u6686\u6688\u6689\u668A\u668B\u668D\u668E\u668F\u6690\u6692\u6693\u6694\u6695\u6698", 4, "\u669E", 8, "\u66A9", 4, "\u66AF", 4, "\u66B5\u66B6\u66B7\u66B8\u66BA\u66BB\u66BC\u66BD\u66BF", 25, "\u66DA\u66DE", 7, "\u66E7\u66E8\u66EA", 5, "\u66F1\u66F5\u66F6\u66F8\u66FA\u66FB\u66FD\u6701\u6702\u6703"],
      ["9640", "\u6704\u6705\u6706\u6707\u670C\u670E\u670F\u6711\u6712\u6713\u6716\u6718\u6719\u671A\u671C\u671E\u6720", 5, "\u6727\u6729\u672E\u6730\u6732\u6733\u6736\u6737\u6738\u6739\u673B\u673C\u673E\u673F\u6741\u6744\u6745\u6747\u674A\u674B\u674D\u6752\u6754\u6755\u6757", 4, "\u675D\u6762\u6763\u6764\u6766\u6767\u676B\u676C\u676E\u6771\u6774\u6776"],
      ["9680", "\u6778\u6779\u677A\u677B\u677D\u6780\u6782\u6783\u6785\u6786\u6788\u678A\u678C\u678D\u678E\u678F\u6791\u6792\u6793\u6794\u6796\u6799\u679B\u679F\u67A0\u67A1\u67A4\u67A6\u67A9\u67AC\u67AE\u67B1\u67B2\u67B4\u67B9", 7, "\u67C2\u67C5", 9, "\u67D5\u67D6\u67D7\u67DB\u67DF\u67E1\u67E3\u67E4\u67E6\u67E7\u67E8\u67EA\u67EB\u67ED\u67EE\u67F2\u67F5", 7, "\u67FE\u6801\u6802\u6803\u6804\u6806\u680D\u6810\u6812\u6814\u6815\u6818", 4, "\u681E\u681F\u6820\u6822", 6, "\u682B", 6, "\u6834\u6835\u6836\u683A\u683B\u683F\u6847\u684B\u684D\u684F\u6852\u6856", 5],
      ["9740", "\u685C\u685D\u685E\u685F\u686A\u686C", 7, "\u6875\u6878", 8, "\u6882\u6884\u6887", 7, "\u6890\u6891\u6892\u6894\u6895\u6896\u6898", 9, "\u68A3\u68A4\u68A5\u68A9\u68AA\u68AB\u68AC\u68AE\u68B1\u68B2\u68B4\u68B6\u68B7\u68B8"],
      ["9780", "\u68B9", 6, "\u68C1\u68C3", 5, "\u68CA\u68CC\u68CE\u68CF\u68D0\u68D1\u68D3\u68D4\u68D6\u68D7\u68D9\u68DB", 4, "\u68E1\u68E2\u68E4", 9, "\u68EF\u68F2\u68F3\u68F4\u68F6\u68F7\u68F8\u68FB\u68FD\u68FE\u68FF\u6900\u6902\u6903\u6904\u6906", 4, "\u690C\u690F\u6911\u6913", 11, "\u6921\u6922\u6923\u6925", 7, "\u692E\u692F\u6931\u6932\u6933\u6935\u6936\u6937\u6938\u693A\u693B\u693C\u693E\u6940\u6941\u6943", 16, "\u6955\u6956\u6958\u6959\u695B\u695C\u695F"],
      ["9840", "\u6961\u6962\u6964\u6965\u6967\u6968\u6969\u696A\u696C\u696D\u696F\u6970\u6972", 4, "\u697A\u697B\u697D\u697E\u697F\u6981\u6983\u6985\u698A\u698B\u698C\u698E", 5, "\u6996\u6997\u6999\u699A\u699D", 9, "\u69A9\u69AA\u69AC\u69AE\u69AF\u69B0\u69B2\u69B3\u69B5\u69B6\u69B8\u69B9\u69BA\u69BC\u69BD"],
      ["9880", "\u69BE\u69BF\u69C0\u69C2", 7, "\u69CB\u69CD\u69CF\u69D1\u69D2\u69D3\u69D5", 5, "\u69DC\u69DD\u69DE\u69E1", 11, "\u69EE\u69EF\u69F0\u69F1\u69F3", 9, "\u69FE\u6A00", 9, "\u6A0B", 11, "\u6A19", 5, "\u6A20\u6A22", 5, "\u6A29\u6A2B\u6A2C\u6A2D\u6A2E\u6A30\u6A32\u6A33\u6A34\u6A36", 6, "\u6A3F", 4, "\u6A45\u6A46\u6A48", 7, "\u6A51", 6, "\u6A5A"],
      ["9940", "\u6A5C", 4, "\u6A62\u6A63\u6A64\u6A66", 10, "\u6A72", 6, "\u6A7A\u6A7B\u6A7D\u6A7E\u6A7F\u6A81\u6A82\u6A83\u6A85", 8, "\u6A8F\u6A92", 4, "\u6A98", 7, "\u6AA1", 5],
      ["9980", "\u6AA7\u6AA8\u6AAA\u6AAD", 114, "\u6B25\u6B26\u6B28", 6],
      ["9a40", "\u6B2F\u6B30\u6B31\u6B33\u6B34\u6B35\u6B36\u6B38\u6B3B\u6B3C\u6B3D\u6B3F\u6B40\u6B41\u6B42\u6B44\u6B45\u6B48\u6B4A\u6B4B\u6B4D", 11, "\u6B5A", 7, "\u6B68\u6B69\u6B6B", 13, "\u6B7A\u6B7D\u6B7E\u6B7F\u6B80\u6B85\u6B88"],
      ["9a80", "\u6B8C\u6B8E\u6B8F\u6B90\u6B91\u6B94\u6B95\u6B97\u6B98\u6B99\u6B9C", 4, "\u6BA2", 7, "\u6BAB", 7, "\u6BB6\u6BB8", 6, "\u6BC0\u6BC3\u6BC4\u6BC6", 4, "\u6BCC\u6BCE\u6BD0\u6BD1\u6BD8\u6BDA\u6BDC", 4, "\u6BE2", 7, "\u6BEC\u6BED\u6BEE\u6BF0\u6BF1\u6BF2\u6BF4\u6BF6\u6BF7\u6BF8\u6BFA\u6BFB\u6BFC\u6BFE", 6, "\u6C08", 4, "\u6C0E\u6C12\u6C17\u6C1C\u6C1D\u6C1E\u6C20\u6C23\u6C25\u6C2B\u6C2C\u6C2D\u6C31\u6C33\u6C36\u6C37\u6C39\u6C3A\u6C3B\u6C3C\u6C3E\u6C3F\u6C43\u6C44\u6C45\u6C48\u6C4B", 4, "\u6C51\u6C52\u6C53\u6C56\u6C58"],
      ["9b40", "\u6C59\u6C5A\u6C62\u6C63\u6C65\u6C66\u6C67\u6C6B", 4, "\u6C71\u6C73\u6C75\u6C77\u6C78\u6C7A\u6C7B\u6C7C\u6C7F\u6C80\u6C84\u6C87\u6C8A\u6C8B\u6C8D\u6C8E\u6C91\u6C92\u6C95\u6C96\u6C97\u6C98\u6C9A\u6C9C\u6C9D\u6C9E\u6CA0\u6CA2\u6CA8\u6CAC\u6CAF\u6CB0\u6CB4\u6CB5\u6CB6\u6CB7\u6CBA\u6CC0\u6CC1\u6CC2\u6CC3\u6CC6\u6CC7\u6CC8\u6CCB\u6CCD\u6CCE\u6CCF\u6CD1\u6CD2\u6CD8"],
      ["9b80", "\u6CD9\u6CDA\u6CDC\u6CDD\u6CDF\u6CE4\u6CE6\u6CE7\u6CE9\u6CEC\u6CED\u6CF2\u6CF4\u6CF9\u6CFF\u6D00\u6D02\u6D03\u6D05\u6D06\u6D08\u6D09\u6D0A\u6D0D\u6D0F\u6D10\u6D11\u6D13\u6D14\u6D15\u6D16\u6D18\u6D1C\u6D1D\u6D1F", 5, "\u6D26\u6D28\u6D29\u6D2C\u6D2D\u6D2F\u6D30\u6D34\u6D36\u6D37\u6D38\u6D3A\u6D3F\u6D40\u6D42\u6D44\u6D49\u6D4C\u6D50\u6D55\u6D56\u6D57\u6D58\u6D5B\u6D5D\u6D5F\u6D61\u6D62\u6D64\u6D65\u6D67\u6D68\u6D6B\u6D6C\u6D6D\u6D70\u6D71\u6D72\u6D73\u6D75\u6D76\u6D79\u6D7A\u6D7B\u6D7D", 4, "\u6D83\u6D84\u6D86\u6D87\u6D8A\u6D8B\u6D8D\u6D8F\u6D90\u6D92\u6D96", 4, "\u6D9C\u6DA2\u6DA5\u6DAC\u6DAD\u6DB0\u6DB1\u6DB3\u6DB4\u6DB6\u6DB7\u6DB9", 5, "\u6DC1\u6DC2\u6DC3\u6DC8\u6DC9\u6DCA"],
      ["9c40", "\u6DCD\u6DCE\u6DCF\u6DD0\u6DD2\u6DD3\u6DD4\u6DD5\u6DD7\u6DDA\u6DDB\u6DDC\u6DDF\u6DE2\u6DE3\u6DE5\u6DE7\u6DE8\u6DE9\u6DEA\u6DED\u6DEF\u6DF0\u6DF2\u6DF4\u6DF5\u6DF6\u6DF8\u6DFA\u6DFD", 7, "\u6E06\u6E07\u6E08\u6E09\u6E0B\u6E0F\u6E12\u6E13\u6E15\u6E18\u6E19\u6E1B\u6E1C\u6E1E\u6E1F\u6E22\u6E26\u6E27\u6E28\u6E2A\u6E2C\u6E2E\u6E30\u6E31\u6E33\u6E35"],
      ["9c80", "\u6E36\u6E37\u6E39\u6E3B", 7, "\u6E45", 7, "\u6E4F\u6E50\u6E51\u6E52\u6E55\u6E57\u6E59\u6E5A\u6E5C\u6E5D\u6E5E\u6E60", 10, "\u6E6C\u6E6D\u6E6F", 14, "\u6E80\u6E81\u6E82\u6E84\u6E87\u6E88\u6E8A", 4, "\u6E91", 6, "\u6E99\u6E9A\u6E9B\u6E9D\u6E9E\u6EA0\u6EA1\u6EA3\u6EA4\u6EA6\u6EA8\u6EA9\u6EAB\u6EAC\u6EAD\u6EAE\u6EB0\u6EB3\u6EB5\u6EB8\u6EB9\u6EBC\u6EBE\u6EBF\u6EC0\u6EC3\u6EC4\u6EC5\u6EC6\u6EC8\u6EC9\u6ECA\u6ECC\u6ECD\u6ECE\u6ED0\u6ED2\u6ED6\u6ED8\u6ED9\u6EDB\u6EDC\u6EDD\u6EE3\u6EE7\u6EEA", 5],
      ["9d40", "\u6EF0\u6EF1\u6EF2\u6EF3\u6EF5\u6EF6\u6EF7\u6EF8\u6EFA", 7, "\u6F03\u6F04\u6F05\u6F07\u6F08\u6F0A", 4, "\u6F10\u6F11\u6F12\u6F16", 9, "\u6F21\u6F22\u6F23\u6F25\u6F26\u6F27\u6F28\u6F2C\u6F2E\u6F30\u6F32\u6F34\u6F35\u6F37", 6, "\u6F3F\u6F40\u6F41\u6F42"],
      ["9d80", "\u6F43\u6F44\u6F45\u6F48\u6F49\u6F4A\u6F4C\u6F4E", 9, "\u6F59\u6F5A\u6F5B\u6F5D\u6F5F\u6F60\u6F61\u6F63\u6F64\u6F65\u6F67", 5, "\u6F6F\u6F70\u6F71\u6F73\u6F75\u6F76\u6F77\u6F79\u6F7B\u6F7D", 6, "\u6F85\u6F86\u6F87\u6F8A\u6F8B\u6F8F", 12, "\u6F9D\u6F9E\u6F9F\u6FA0\u6FA2", 4, "\u6FA8", 10, "\u6FB4\u6FB5\u6FB7\u6FB8\u6FBA", 5, "\u6FC1\u6FC3", 5, "\u6FCA", 6, "\u6FD3", 10, "\u6FDF\u6FE2\u6FE3\u6FE4\u6FE5"],
      ["9e40", "\u6FE6", 7, "\u6FF0", 32, "\u7012", 7, "\u701C", 6, "\u7024", 6],
      ["9e80", "\u702B", 9, "\u7036\u7037\u7038\u703A", 17, "\u704D\u704E\u7050", 13, "\u705F", 11, "\u706E\u7071\u7072\u7073\u7074\u7077\u7079\u707A\u707B\u707D\u7081\u7082\u7083\u7084\u7086\u7087\u7088\u708B\u708C\u708D\u708F\u7090\u7091\u7093\u7097\u7098\u709A\u709B\u709E", 12, "\u70B0\u70B2\u70B4\u70B5\u70B6\u70BA\u70BE\u70BF\u70C4\u70C5\u70C6\u70C7\u70C9\u70CB", 12, "\u70DA"],
      ["9f40", "\u70DC\u70DD\u70DE\u70E0\u70E1\u70E2\u70E3\u70E5\u70EA\u70EE\u70F0", 6, "\u70F8\u70FA\u70FB\u70FC\u70FE", 10, "\u710B", 4, "\u7111\u7112\u7114\u7117\u711B", 10, "\u7127", 7, "\u7132\u7133\u7134"],
      ["9f80", "\u7135\u7137", 13, "\u7146\u7147\u7148\u7149\u714B\u714D\u714F", 12, "\u715D\u715F", 4, "\u7165\u7169", 4, "\u716F\u7170\u7171\u7174\u7175\u7176\u7177\u7179\u717B\u717C\u717E", 5, "\u7185", 4, "\u718B\u718C\u718D\u718E\u7190\u7191\u7192\u7193\u7195\u7196\u7197\u719A", 4, "\u71A1", 6, "\u71A9\u71AA\u71AB\u71AD", 5, "\u71B4\u71B6\u71B7\u71B8\u71BA", 8, "\u71C4", 9, "\u71CF", 4],
      ["a040", "\u71D6", 9, "\u71E1\u71E2\u71E3\u71E4\u71E6\u71E8", 5, "\u71EF", 9, "\u71FA", 11, "\u7207", 19],
      ["a080", "\u721B\u721C\u721E", 9, "\u7229\u722B\u722D\u722E\u722F\u7232\u7233\u7234\u723A\u723C\u723E\u7240", 6, "\u7249\u724A\u724B\u724E\u724F\u7250\u7251\u7253\u7254\u7255\u7257\u7258\u725A\u725C\u725E\u7260\u7263\u7264\u7265\u7268\u726A\u726B\u726C\u726D\u7270\u7271\u7273\u7274\u7276\u7277\u7278\u727B\u727C\u727D\u7282\u7283\u7285", 4, "\u728C\u728E\u7290\u7291\u7293", 11, "\u72A0", 11, "\u72AE\u72B1\u72B2\u72B3\u72B5\u72BA", 6, "\u72C5\u72C6\u72C7\u72C9\u72CA\u72CB\u72CC\u72CF\u72D1\u72D3\u72D4\u72D5\u72D6\u72D8\u72DA\u72DB"],
      ["a1a1", "\u3000\u3001\u3002\xB7\u02C9\u02C7\xA8\u3003\u3005\u2014\uFF5E\u2016\u2026\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 7, "\u3016\u3017\u3010\u3011\xB1\xD7\xF7\u2236\u2227\u2228\u2211\u220F\u222A\u2229\u2208\u2237\u221A\u22A5\u2225\u2220\u2312\u2299\u222B\u222E\u2261\u224C\u2248\u223D\u221D\u2260\u226E\u226F\u2264\u2265\u221E\u2235\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFF04\xA4\uFFE0\uFFE1\u2030\xA7\u2116\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u203B\u2192\u2190\u2191\u2193\u3013"],
      ["a2a1", "\u2170", 9],
      ["a2b1", "\u2488", 19, "\u2474", 19, "\u2460", 9],
      ["a2e5", "\u3220", 9],
      ["a2f1", "\u2160", 11],
      ["a3a1", "\uFF01\uFF02\uFF03\uFFE5\uFF05", 88, "\uFFE3"],
      ["a4a1", "\u3041", 82],
      ["a5a1", "\u30A1", 85],
      ["a6a1", "\u0391", 16, "\u03A3", 6],
      ["a6c1", "\u03B1", 16, "\u03C3", 6],
      ["a6e0", "\uFE35\uFE36\uFE39\uFE3A\uFE3F\uFE40\uFE3D\uFE3E\uFE41\uFE42\uFE43\uFE44"],
      ["a6ee", "\uFE3B\uFE3C\uFE37\uFE38\uFE31"],
      ["a6f4", "\uFE33\uFE34"],
      ["a7a1", "\u0410", 5, "\u0401\u0416", 25],
      ["a7d1", "\u0430", 5, "\u0451\u0436", 25],
      ["a840", "\u02CA\u02CB\u02D9\u2013\u2015\u2025\u2035\u2105\u2109\u2196\u2197\u2198\u2199\u2215\u221F\u2223\u2252\u2266\u2267\u22BF\u2550", 35, "\u2581", 6],
      ["a880", "\u2588", 7, "\u2593\u2594\u2595\u25BC\u25BD\u25E2\u25E3\u25E4\u25E5\u2609\u2295\u3012\u301D\u301E"],
      ["a8a1", "\u0101\xE1\u01CE\xE0\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA\u01DC\xFC\xEA\u0251"],
      ["a8bd", "\u0144\u0148"],
      ["a8c0", "\u0261"],
      ["a8c5", "\u3105", 36],
      ["a940", "\u3021", 8, "\u32A3\u338E\u338F\u339C\u339D\u339E\u33A1\u33C4\u33CE\u33D1\u33D2\u33D5\uFE30\uFFE2\uFFE4"],
      ["a959", "\u2121\u3231"],
      ["a95c", "\u2010"],
      ["a960", "\u30FC\u309B\u309C\u30FD\u30FE\u3006\u309D\u309E\uFE49", 9, "\uFE54\uFE55\uFE56\uFE57\uFE59", 8],
      ["a980", "\uFE62", 4, "\uFE68\uFE69\uFE6A\uFE6B"],
      ["a996", "\u3007"],
      ["a9a4", "\u2500", 75],
      ["aa40", "\u72DC\u72DD\u72DF\u72E2", 5, "\u72EA\u72EB\u72F5\u72F6\u72F9\u72FD\u72FE\u72FF\u7300\u7302\u7304", 5, "\u730B\u730C\u730D\u730F\u7310\u7311\u7312\u7314\u7318\u7319\u731A\u731F\u7320\u7323\u7324\u7326\u7327\u7328\u732D\u732F\u7330\u7332\u7333\u7335\u7336\u733A\u733B\u733C\u733D\u7340", 8],
      ["aa80", "\u7349\u734A\u734B\u734C\u734E\u734F\u7351\u7353\u7354\u7355\u7356\u7358", 7, "\u7361", 10, "\u736E\u7370\u7371"],
      ["ab40", "\u7372", 11, "\u737F", 4, "\u7385\u7386\u7388\u738A\u738C\u738D\u738F\u7390\u7392\u7393\u7394\u7395\u7397\u7398\u7399\u739A\u739C\u739D\u739E\u73A0\u73A1\u73A3", 5, "\u73AA\u73AC\u73AD\u73B1\u73B4\u73B5\u73B6\u73B8\u73B9\u73BC\u73BD\u73BE\u73BF\u73C1\u73C3", 4],
      ["ab80", "\u73CB\u73CC\u73CE\u73D2", 6, "\u73DA\u73DB\u73DC\u73DD\u73DF\u73E1\u73E2\u73E3\u73E4\u73E6\u73E8\u73EA\u73EB\u73EC\u73EE\u73EF\u73F0\u73F1\u73F3", 4],
      ["ac40", "\u73F8", 10, "\u7404\u7407\u7408\u740B\u740C\u740D\u740E\u7411", 8, "\u741C", 5, "\u7423\u7424\u7427\u7429\u742B\u742D\u742F\u7431\u7432\u7437", 4, "\u743D\u743E\u743F\u7440\u7442", 11],
      ["ac80", "\u744E", 6, "\u7456\u7458\u745D\u7460", 12, "\u746E\u746F\u7471", 4, "\u7478\u7479\u747A"],
      ["ad40", "\u747B\u747C\u747D\u747F\u7482\u7484\u7485\u7486\u7488\u7489\u748A\u748C\u748D\u748F\u7491", 10, "\u749D\u749F", 7, "\u74AA", 15, "\u74BB", 12],
      ["ad80", "\u74C8", 9, "\u74D3", 8, "\u74DD\u74DF\u74E1\u74E5\u74E7", 6, "\u74F0\u74F1\u74F2"],
      ["ae40", "\u74F3\u74F5\u74F8", 6, "\u7500\u7501\u7502\u7503\u7505", 7, "\u750E\u7510\u7512\u7514\u7515\u7516\u7517\u751B\u751D\u751E\u7520", 4, "\u7526\u7527\u752A\u752E\u7534\u7536\u7539\u753C\u753D\u753F\u7541\u7542\u7543\u7544\u7546\u7547\u7549\u754A\u754D\u7550\u7551\u7552\u7553\u7555\u7556\u7557\u7558"],
      ["ae80", "\u755D", 7, "\u7567\u7568\u7569\u756B", 6, "\u7573\u7575\u7576\u7577\u757A", 4, "\u7580\u7581\u7582\u7584\u7585\u7587"],
      ["af40", "\u7588\u7589\u758A\u758C\u758D\u758E\u7590\u7593\u7595\u7598\u759B\u759C\u759E\u75A2\u75A6", 4, "\u75AD\u75B6\u75B7\u75BA\u75BB\u75BF\u75C0\u75C1\u75C6\u75CB\u75CC\u75CE\u75CF\u75D0\u75D1\u75D3\u75D7\u75D9\u75DA\u75DC\u75DD\u75DF\u75E0\u75E1\u75E5\u75E9\u75EC\u75ED\u75EE\u75EF\u75F2\u75F3\u75F5\u75F6\u75F7\u75F8\u75FA\u75FB\u75FD\u75FE\u7602\u7604\u7606\u7607"],
      ["af80", "\u7608\u7609\u760B\u760D\u760E\u760F\u7611\u7612\u7613\u7614\u7616\u761A\u761C\u761D\u761E\u7621\u7623\u7627\u7628\u762C\u762E\u762F\u7631\u7632\u7636\u7637\u7639\u763A\u763B\u763D\u7641\u7642\u7644"],
      ["b040", "\u7645", 6, "\u764E", 5, "\u7655\u7657", 4, "\u765D\u765F\u7660\u7661\u7662\u7664", 6, "\u766C\u766D\u766E\u7670", 7, "\u7679\u767A\u767C\u767F\u7680\u7681\u7683\u7685\u7689\u768A\u768C\u768D\u768F\u7690\u7692\u7694\u7695\u7697\u7698\u769A\u769B"],
      ["b080", "\u769C", 7, "\u76A5", 8, "\u76AF\u76B0\u76B3\u76B5", 9, "\u76C0\u76C1\u76C3\u554A\u963F\u57C3\u6328\u54CE\u5509\u54C0\u7691\u764C\u853C\u77EE\u827E\u788D\u7231\u9698\u978D\u6C28\u5B89\u4FFA\u6309\u6697\u5CB8\u80FA\u6848\u80AE\u6602\u76CE\u51F9\u6556\u71AC\u7FF1\u8884\u50B2\u5965\u61CA\u6FB3\u82AD\u634C\u6252\u53ED\u5427\u7B06\u516B\u75A4\u5DF4\u62D4\u8DCB\u9776\u628A\u8019\u575D\u9738\u7F62\u7238\u767D\u67CF\u767E\u6446\u4F70\u8D25\u62DC\u7A17\u6591\u73ED\u642C\u6273\u822C\u9881\u677F\u7248\u626E\u62CC\u4F34\u74E3\u534A\u529E\u7ECA\u90A6\u5E2E\u6886\u699C\u8180\u7ED1\u68D2\u78C5\u868C\u9551\u508D\u8C24\u82DE\u80DE\u5305\u8912\u5265"],
      ["b140", "\u76C4\u76C7\u76C9\u76CB\u76CC\u76D3\u76D5\u76D9\u76DA\u76DC\u76DD\u76DE\u76E0", 4, "\u76E6", 7, "\u76F0\u76F3\u76F5\u76F6\u76F7\u76FA\u76FB\u76FD\u76FF\u7700\u7702\u7703\u7705\u7706\u770A\u770C\u770E", 10, "\u771B\u771C\u771D\u771E\u7721\u7723\u7724\u7725\u7727\u772A\u772B"],
      ["b180", "\u772C\u772E\u7730", 4, "\u7739\u773B\u773D\u773E\u773F\u7742\u7744\u7745\u7746\u7748", 7, "\u7752", 7, "\u775C\u8584\u96F9\u4FDD\u5821\u9971\u5B9D\u62B1\u62A5\u66B4\u8C79\u9C8D\u7206\u676F\u7891\u60B2\u5351\u5317\u8F88\u80CC\u8D1D\u94A1\u500D\u72C8\u5907\u60EB\u7119\u88AB\u5954\u82EF\u672C\u7B28\u5D29\u7EF7\u752D\u6CF5\u8E66\u8FF8\u903C\u9F3B\u6BD4\u9119\u7B14\u5F7C\u78A7\u84D6\u853D\u6BD5\u6BD9\u6BD6\u5E01\u5E87\u75F9\u95ED\u655D\u5F0A\u5FC5\u8F9F\u58C1\u81C2\u907F\u965B\u97AD\u8FB9\u7F16\u8D2C\u6241\u4FBF\u53D8\u535E\u8FA8\u8FA9\u8FAB\u904D\u6807\u5F6A\u8198\u8868\u9CD6\u618B\u522B\u762A\u5F6C\u658C\u6FD2\u6EE8\u5BBE\u6448\u5175\u51B0\u67C4\u4E19\u79C9\u997C\u70B3"],
      ["b240", "\u775D\u775E\u775F\u7760\u7764\u7767\u7769\u776A\u776D", 11, "\u777A\u777B\u777C\u7781\u7782\u7783\u7786", 5, "\u778F\u7790\u7793", 11, "\u77A1\u77A3\u77A4\u77A6\u77A8\u77AB\u77AD\u77AE\u77AF\u77B1\u77B2\u77B4\u77B6", 4],
      ["b280", "\u77BC\u77BE\u77C0", 12, "\u77CE", 8, "\u77D8\u77D9\u77DA\u77DD", 4, "\u77E4\u75C5\u5E76\u73BB\u83E0\u64AD\u62E8\u94B5\u6CE2\u535A\u52C3\u640F\u94C2\u7B94\u4F2F\u5E1B\u8236\u8116\u818A\u6E24\u6CCA\u9A73\u6355\u535C\u54FA\u8865\u57E0\u4E0D\u5E03\u6B65\u7C3F\u90E8\u6016\u64E6\u731C\u88C1\u6750\u624D\u8D22\u776C\u8E29\u91C7\u5F69\u83DC\u8521\u9910\u53C2\u8695\u6B8B\u60ED\u60E8\u707F\u82CD\u8231\u4ED3\u6CA7\u85CF\u64CD\u7CD9\u69FD\u66F9\u8349\u5395\u7B56\u4FA7\u518C\u6D4B\u5C42\u8E6D\u63D2\u53C9\u832C\u8336\u67E5\u78B4\u643D\u5BDF\u5C94\u5DEE\u8BE7\u62C6\u67F4\u8C7A\u6400\u63BA\u8749\u998B\u8C17\u7F20\u94F2\u4EA7\u9610\u98A4\u660C\u7316"],
      ["b340", "\u77E6\u77E8\u77EA\u77EF\u77F0\u77F1\u77F2\u77F4\u77F5\u77F7\u77F9\u77FA\u77FB\u77FC\u7803", 5, "\u780A\u780B\u780E\u780F\u7810\u7813\u7815\u7819\u781B\u781E\u7820\u7821\u7822\u7824\u7828\u782A\u782B\u782E\u782F\u7831\u7832\u7833\u7835\u7836\u783D\u783F\u7841\u7842\u7843\u7844\u7846\u7848\u7849\u784A\u784B\u784D\u784F\u7851\u7853\u7854\u7858\u7859\u785A"],
      ["b380", "\u785B\u785C\u785E", 11, "\u786F", 7, "\u7878\u7879\u787A\u787B\u787D", 6, "\u573A\u5C1D\u5E38\u957F\u507F\u80A0\u5382\u655E\u7545\u5531\u5021\u8D85\u6284\u949E\u671D\u5632\u6F6E\u5DE2\u5435\u7092\u8F66\u626F\u64A4\u63A3\u5F7B\u6F88\u90F4\u81E3\u8FB0\u5C18\u6668\u5FF1\u6C89\u9648\u8D81\u886C\u6491\u79F0\u57CE\u6A59\u6210\u5448\u4E58\u7A0B\u60E9\u6F84\u8BDA\u627F\u901E\u9A8B\u79E4\u5403\u75F4\u6301\u5319\u6C60\u8FDF\u5F1B\u9A70\u803B\u9F7F\u4F88\u5C3A\u8D64\u7FC5\u65A5\u70BD\u5145\u51B2\u866B\u5D07\u5BA0\u62BD\u916C\u7574\u8E0C\u7A20\u6101\u7B79\u4EC7\u7EF8\u7785\u4E11\u81ED\u521D\u51FA\u6A71\u53A8\u8E87\u9504\u96CF\u6EC1\u9664\u695A"],
      ["b440", "\u7884\u7885\u7886\u7888\u788A\u788B\u788F\u7890\u7892\u7894\u7895\u7896\u7899\u789D\u789E\u78A0\u78A2\u78A4\u78A6\u78A8", 7, "\u78B5\u78B6\u78B7\u78B8\u78BA\u78BB\u78BC\u78BD\u78BF\u78C0\u78C2\u78C3\u78C4\u78C6\u78C7\u78C8\u78CC\u78CD\u78CE\u78CF\u78D1\u78D2\u78D3\u78D6\u78D7\u78D8\u78DA", 9],
      ["b480", "\u78E4\u78E5\u78E6\u78E7\u78E9\u78EA\u78EB\u78ED", 4, "\u78F3\u78F5\u78F6\u78F8\u78F9\u78FB", 5, "\u7902\u7903\u7904\u7906", 6, "\u7840\u50A8\u77D7\u6410\u89E6\u5904\u63E3\u5DDD\u7A7F\u693D\u4F20\u8239\u5598\u4E32\u75AE\u7A97\u5E62\u5E8A\u95EF\u521B\u5439\u708A\u6376\u9524\u5782\u6625\u693F\u9187\u5507\u6DF3\u7EAF\u8822\u6233\u7EF0\u75B5\u8328\u78C1\u96CC\u8F9E\u6148\u74F7\u8BCD\u6B64\u523A\u8D50\u6B21\u806A\u8471\u56F1\u5306\u4ECE\u4E1B\u51D1\u7C97\u918B\u7C07\u4FC3\u8E7F\u7BE1\u7A9C\u6467\u5D14\u50AC\u8106\u7601\u7CB9\u6DEC\u7FE0\u6751\u5B58\u5BF8\u78CB\u64AE\u6413\u63AA\u632B\u9519\u642D\u8FBE\u7B54\u7629\u6253\u5927\u5446\u6B79\u50A3\u6234\u5E26\u6B86\u4EE3\u8D37\u888B\u5F85\u902E"],
      ["b540", "\u790D", 5, "\u7914", 9, "\u791F", 4, "\u7925", 14, "\u7935", 4, "\u793D\u793F\u7942\u7943\u7944\u7945\u7947\u794A", 8, "\u7954\u7955\u7958\u7959\u7961\u7963"],
      ["b580", "\u7964\u7966\u7969\u796A\u796B\u796C\u796E\u7970", 6, "\u7979\u797B", 4, "\u7982\u7983\u7986\u7987\u7988\u7989\u798B\u798C\u798D\u798E\u7990\u7991\u7992\u6020\u803D\u62C5\u4E39\u5355\u90F8\u63B8\u80C6\u65E6\u6C2E\u4F46\u60EE\u6DE1\u8BDE\u5F39\u86CB\u5F53\u6321\u515A\u8361\u6863\u5200\u6363\u8E48\u5012\u5C9B\u7977\u5BFC\u5230\u7A3B\u60BC\u9053\u76D7\u5FB7\u5F97\u7684\u8E6C\u706F\u767B\u7B49\u77AA\u51F3\u9093\u5824\u4F4E\u6EF4\u8FEA\u654C\u7B1B\u72C4\u6DA4\u7FDF\u5AE1\u62B5\u5E95\u5730\u8482\u7B2C\u5E1D\u5F1F\u9012\u7F14\u98A0\u6382\u6EC7\u7898\u70B9\u5178\u975B\u57AB\u7535\u4F43\u7538\u5E97\u60E6\u5960\u6DC0\u6BBF\u7889\u53FC\u96D5\u51CB\u5201\u6389\u540A\u9493\u8C03\u8DCC\u7239\u789F\u8776\u8FED\u8C0D\u53E0"],
      ["b640", "\u7993", 6, "\u799B", 11, "\u79A8", 10, "\u79B4", 4, "\u79BC\u79BF\u79C2\u79C4\u79C5\u79C7\u79C8\u79CA\u79CC\u79CE\u79CF\u79D0\u79D3\u79D4\u79D6\u79D7\u79D9", 5, "\u79E0\u79E1\u79E2\u79E5\u79E8\u79EA"],
      ["b680", "\u79EC\u79EE\u79F1", 6, "\u79F9\u79FA\u79FC\u79FE\u79FF\u7A01\u7A04\u7A05\u7A07\u7A08\u7A09\u7A0A\u7A0C\u7A0F", 4, "\u7A15\u7A16\u7A18\u7A19\u7A1B\u7A1C\u4E01\u76EF\u53EE\u9489\u9876\u9F0E\u952D\u5B9A\u8BA2\u4E22\u4E1C\u51AC\u8463\u61C2\u52A8\u680B\u4F97\u606B\u51BB\u6D1E\u515C\u6296\u6597\u9661\u8C46\u9017\u75D8\u90FD\u7763\u6BD2\u728A\u72EC\u8BFB\u5835\u7779\u8D4C\u675C\u9540\u809A\u5EA6\u6E21\u5992\u7AEF\u77ED\u953B\u6BB5\u65AD\u7F0E\u5806\u5151\u961F\u5BF9\u58A9\u5428\u8E72\u6566\u987F\u56E4\u949D\u76FE\u9041\u6387\u54C6\u591A\u593A\u579B\u8EB2\u6735\u8DFA\u8235\u5241\u60F0\u5815\u86FE\u5CE8\u9E45\u4FC4\u989D\u8BB9\u5A25\u6076\u5384\u627C\u904F\u9102\u997F\u6069\u800C\u513F\u8033\u5C14\u9975\u6D31\u4E8C"],
      ["b740", "\u7A1D\u7A1F\u7A21\u7A22\u7A24", 14, "\u7A34\u7A35\u7A36\u7A38\u7A3A\u7A3E\u7A40", 5, "\u7A47", 9, "\u7A52", 4, "\u7A58", 16],
      ["b780", "\u7A69", 6, "\u7A71\u7A72\u7A73\u7A75\u7A7B\u7A7C\u7A7D\u7A7E\u7A82\u7A85\u7A87\u7A89\u7A8A\u7A8B\u7A8C\u7A8E\u7A8F\u7A90\u7A93\u7A94\u7A99\u7A9A\u7A9B\u7A9E\u7AA1\u7AA2\u8D30\u53D1\u7F5A\u7B4F\u4F10\u4E4F\u9600\u6CD5\u73D0\u85E9\u5E06\u756A\u7FFB\u6A0A\u77FE\u9492\u7E41\u51E1\u70E6\u53CD\u8FD4\u8303\u8D29\u72AF\u996D\u6CDB\u574A\u82B3\u65B9\u80AA\u623F\u9632\u59A8\u4EFF\u8BBF\u7EBA\u653E\u83F2\u975E\u5561\u98DE\u80A5\u532A\u8BFD\u5420\u80BA\u5E9F\u6CB8\u8D39\u82AC\u915A\u5429\u6C1B\u5206\u7EB7\u575F\u711A\u6C7E\u7C89\u594B\u4EFD\u5FFF\u6124\u7CAA\u4E30\u5C01\u67AB\u8702\u5CF0\u950B\u98CE\u75AF\u70FD\u9022\u51AF\u7F1D\u8BBD\u5949\u51E4\u4F5B\u5426\u592B\u6577\u80A4\u5B75\u6276\u62C2\u8F90\u5E45\u6C1F\u7B26\u4F0F\u4FD8\u670D"],
      ["b840", "\u7AA3\u7AA4\u7AA7\u7AA9\u7AAA\u7AAB\u7AAE", 4, "\u7AB4", 10, "\u7AC0", 10, "\u7ACC", 9, "\u7AD7\u7AD8\u7ADA\u7ADB\u7ADC\u7ADD\u7AE1\u7AE2\u7AE4\u7AE7", 5, "\u7AEE\u7AF0\u7AF1\u7AF2\u7AF3"],
      ["b880", "\u7AF4", 4, "\u7AFB\u7AFC\u7AFE\u7B00\u7B01\u7B02\u7B05\u7B07\u7B09\u7B0C\u7B0D\u7B0E\u7B10\u7B12\u7B13\u7B16\u7B17\u7B18\u7B1A\u7B1C\u7B1D\u7B1F\u7B21\u7B22\u7B23\u7B27\u7B29\u7B2D\u6D6E\u6DAA\u798F\u88B1\u5F17\u752B\u629A\u8F85\u4FEF\u91DC\u65A7\u812F\u8151\u5E9C\u8150\u8D74\u526F\u8986\u8D4B\u590D\u5085\u4ED8\u961C\u7236\u8179\u8D1F\u5BCC\u8BA3\u9644\u5987\u7F1A\u5490\u5676\u560E\u8BE5\u6539\u6982\u9499\u76D6\u6E89\u5E72\u7518\u6746\u67D1\u7AFF\u809D\u8D76\u611F\u79C6\u6562\u8D63\u5188\u521A\u94A2\u7F38\u809B\u7EB2\u5C97\u6E2F\u6760\u7BD9\u768B\u9AD8\u818F\u7F94\u7CD5\u641E\u9550\u7A3F\u544A\u54E5\u6B4C\u6401\u6208\u9E3D\u80F3\u7599\u5272\u9769\u845B\u683C\u86E4\u9601\u9694\u94EC\u4E2A\u5404\u7ED9\u6839\u8DDF\u8015\u66F4\u5E9A\u7FB9"],
      ["b940", "\u7B2F\u7B30\u7B32\u7B34\u7B35\u7B36\u7B37\u7B39\u7B3B\u7B3D\u7B3F", 5, "\u7B46\u7B48\u7B4A\u7B4D\u7B4E\u7B53\u7B55\u7B57\u7B59\u7B5C\u7B5E\u7B5F\u7B61\u7B63", 10, "\u7B6F\u7B70\u7B73\u7B74\u7B76\u7B78\u7B7A\u7B7C\u7B7D\u7B7F\u7B81\u7B82\u7B83\u7B84\u7B86", 6, "\u7B8E\u7B8F"],
      ["b980", "\u7B91\u7B92\u7B93\u7B96\u7B98\u7B99\u7B9A\u7B9B\u7B9E\u7B9F\u7BA0\u7BA3\u7BA4\u7BA5\u7BAE\u7BAF\u7BB0\u7BB2\u7BB3\u7BB5\u7BB6\u7BB7\u7BB9", 7, "\u7BC2\u7BC3\u7BC4\u57C2\u803F\u6897\u5DE5\u653B\u529F\u606D\u9F9A\u4F9B\u8EAC\u516C\u5BAB\u5F13\u5DE9\u6C5E\u62F1\u8D21\u5171\u94A9\u52FE\u6C9F\u82DF\u72D7\u57A2\u6784\u8D2D\u591F\u8F9C\u83C7\u5495\u7B8D\u4F30\u6CBD\u5B64\u59D1\u9F13\u53E4\u86CA\u9AA8\u8C37\u80A1\u6545\u987E\u56FA\u96C7\u522E\u74DC\u5250\u5BE1\u6302\u8902\u4E56\u62D0\u602A\u68FA\u5173\u5B98\u51A0\u89C2\u7BA1\u9986\u7F50\u60EF\u704C\u8D2F\u5149\u5E7F\u901B\u7470\u89C4\u572D\u7845\u5F52\u9F9F\u95FA\u8F68\u9B3C\u8BE1\u7678\u6842\u67DC\u8DEA\u8D35\u523D\u8F8A\u6EDA\u68CD\u9505\u90ED\u56FD\u679C\u88F9\u8FC7\u54C8"],
      ["ba40", "\u7BC5\u7BC8\u7BC9\u7BCA\u7BCB\u7BCD\u7BCE\u7BCF\u7BD0\u7BD2\u7BD4", 4, "\u7BDB\u7BDC\u7BDE\u7BDF\u7BE0\u7BE2\u7BE3\u7BE4\u7BE7\u7BE8\u7BE9\u7BEB\u7BEC\u7BED\u7BEF\u7BF0\u7BF2", 4, "\u7BF8\u7BF9\u7BFA\u7BFB\u7BFD\u7BFF", 7, "\u7C08\u7C09\u7C0A\u7C0D\u7C0E\u7C10", 5, "\u7C17\u7C18\u7C19"],
      ["ba80", "\u7C1A", 4, "\u7C20", 5, "\u7C28\u7C29\u7C2B", 12, "\u7C39", 5, "\u7C42\u9AB8\u5B69\u6D77\u6C26\u4EA5\u5BB3\u9A87\u9163\u61A8\u90AF\u97E9\u542B\u6DB5\u5BD2\u51FD\u558A\u7F55\u7FF0\u64BC\u634D\u65F1\u61BE\u608D\u710A\u6C57\u6C49\u592F\u676D\u822A\u58D5\u568E\u8C6A\u6BEB\u90DD\u597D\u8017\u53F7\u6D69\u5475\u559D\u8377\u83CF\u6838\u79BE\u548C\u4F55\u5408\u76D2\u8C89\u9602\u6CB3\u6DB8\u8D6B\u8910\u9E64\u8D3A\u563F\u9ED1\u75D5\u5F88\u72E0\u6068\u54FC\u4EA8\u6A2A\u8861\u6052\u8F70\u54C4\u70D8\u8679\u9E3F\u6D2A\u5B8F\u5F18\u7EA2\u5589\u4FAF\u7334\u543C\u539A\u5019\u540E\u547C\u4E4E\u5FFD\u745A\u58F6\u846B\u80E1\u8774\u72D0\u7CCA\u6E56"],
      ["bb40", "\u7C43", 9, "\u7C4E", 36, "\u7C75", 5, "\u7C7E", 9],
      ["bb80", "\u7C88\u7C8A", 6, "\u7C93\u7C94\u7C96\u7C99\u7C9A\u7C9B\u7CA0\u7CA1\u7CA3\u7CA6\u7CA7\u7CA8\u7CA9\u7CAB\u7CAC\u7CAD\u7CAF\u7CB0\u7CB4", 4, "\u7CBA\u7CBB\u5F27\u864E\u552C\u62A4\u4E92\u6CAA\u6237\u82B1\u54D7\u534E\u733E\u6ED1\u753B\u5212\u5316\u8BDD\u69D0\u5F8A\u6000\u6DEE\u574F\u6B22\u73AF\u6853\u8FD8\u7F13\u6362\u60A3\u5524\u75EA\u8C62\u7115\u6DA3\u5BA6\u5E7B\u8352\u614C\u9EC4\u78FA\u8757\u7C27\u7687\u51F0\u60F6\u714C\u6643\u5E4C\u604D\u8C0E\u7070\u6325\u8F89\u5FBD\u6062\u86D4\u56DE\u6BC1\u6094\u6167\u5349\u60E0\u6666\u8D3F\u79FD\u4F1A\u70E9\u6C47\u8BB3\u8BF2\u7ED8\u8364\u660F\u5A5A\u9B42\u6D51\u6DF7\u8C41\u6D3B\u4F19\u706B\u83B7\u6216\u60D1\u970D\u8D27\u7978\u51FB\u573E\u57FA\u673A\u7578\u7A3D\u79EF\u7B95"],
      ["bc40", "\u7CBF\u7CC0\u7CC2\u7CC3\u7CC4\u7CC6\u7CC9\u7CCB\u7CCE", 6, "\u7CD8\u7CDA\u7CDB\u7CDD\u7CDE\u7CE1", 6, "\u7CE9", 5, "\u7CF0", 7, "\u7CF9\u7CFA\u7CFC", 13, "\u7D0B", 5],
      ["bc80", "\u7D11", 14, "\u7D21\u7D23\u7D24\u7D25\u7D26\u7D28\u7D29\u7D2A\u7D2C\u7D2D\u7D2E\u7D30", 6, "\u808C\u9965\u8FF9\u6FC0\u8BA5\u9E21\u59EC\u7EE9\u7F09\u5409\u6781\u68D8\u8F91\u7C4D\u96C6\u53CA\u6025\u75BE\u6C72\u5373\u5AC9\u7EA7\u6324\u51E0\u810A\u5DF1\u84DF\u6280\u5180\u5B63\u4F0E\u796D\u5242\u60B8\u6D4E\u5BC4\u5BC2\u8BA1\u8BB0\u65E2\u5FCC\u9645\u5993\u7EE7\u7EAA\u5609\u67B7\u5939\u4F73\u5BB6\u52A0\u835A\u988A\u8D3E\u7532\u94BE\u5047\u7A3C\u4EF7\u67B6\u9A7E\u5AC1\u6B7C\u76D1\u575A\u5C16\u7B3A\u95F4\u714E\u517C\u80A9\u8270\u5978\u7F04\u8327\u68C0\u67EC\u78B1\u7877\u62E3\u6361\u7B80\u4FED\u526A\u51CF\u8350\u69DB\u9274\u8DF5\u8D31\u89C1\u952E\u7BAD\u4EF6"],
      ["bd40", "\u7D37", 54, "\u7D6F", 7],
      ["bd80", "\u7D78", 32, "\u5065\u8230\u5251\u996F\u6E10\u6E85\u6DA7\u5EFA\u50F5\u59DC\u5C06\u6D46\u6C5F\u7586\u848B\u6868\u5956\u8BB2\u5320\u9171\u964D\u8549\u6912\u7901\u7126\u80F6\u4EA4\u90CA\u6D47\u9A84\u5A07\u56BC\u6405\u94F0\u77EB\u4FA5\u811A\u72E1\u89D2\u997A\u7F34\u7EDE\u527F\u6559\u9175\u8F7F\u8F83\u53EB\u7A96\u63ED\u63A5\u7686\u79F8\u8857\u9636\u622A\u52AB\u8282\u6854\u6770\u6377\u776B\u7AED\u6D01\u7ED3\u89E3\u59D0\u6212\u85C9\u82A5\u754C\u501F\u4ECB\u75A5\u8BEB\u5C4A\u5DFE\u7B4B\u65A4\u91D1\u4ECA\u6D25\u895F\u7D27\u9526\u4EC5\u8C28\u8FDB\u9773\u664B\u7981\u8FD1\u70EC\u6D78"],
      ["be40", "\u7D99", 12, "\u7DA7", 6, "\u7DAF", 42],
      ["be80", "\u7DDA", 32, "\u5C3D\u52B2\u8346\u5162\u830E\u775B\u6676\u9CB8\u4EAC\u60CA\u7CBE\u7CB3\u7ECF\u4E95\u8B66\u666F\u9888\u9759\u5883\u656C\u955C\u5F84\u75C9\u9756\u7ADF\u7ADE\u51C0\u70AF\u7A98\u63EA\u7A76\u7EA0\u7396\u97ED\u4E45\u7078\u4E5D\u9152\u53A9\u6551\u65E7\u81FC\u8205\u548E\u5C31\u759A\u97A0\u62D8\u72D9\u75BD\u5C45\u9A79\u83CA\u5C40\u5480\u77E9\u4E3E\u6CAE\u805A\u62D2\u636E\u5DE8\u5177\u8DDD\u8E1E\u952F\u4FF1\u53E5\u60E7\u70AC\u5267\u6350\u9E43\u5A1F\u5026\u7737\u5377\u7EE2\u6485\u652B\u6289\u6398\u5014\u7235\u89C9\u51B3\u8BC0\u7EDD\u5747\u83CC\u94A7\u519B\u541B\u5CFB"],
      ["bf40", "\u7DFB", 62],
      ["bf80", "\u7E3A\u7E3C", 4, "\u7E42", 4, "\u7E48", 21, "\u4FCA\u7AE3\u6D5A\u90E1\u9A8F\u5580\u5496\u5361\u54AF\u5F00\u63E9\u6977\u51EF\u6168\u520A\u582A\u52D8\u574E\u780D\u770B\u5EB7\u6177\u7CE0\u625B\u6297\u4EA2\u7095\u8003\u62F7\u70E4\u9760\u5777\u82DB\u67EF\u68F5\u78D5\u9897\u79D1\u58F3\u54B3\u53EF\u6E34\u514B\u523B\u5BA2\u8BFE\u80AF\u5543\u57A6\u6073\u5751\u542D\u7A7A\u6050\u5B54\u63A7\u62A0\u53E3\u6263\u5BC7\u67AF\u54ED\u7A9F\u82E6\u9177\u5E93\u88E4\u5938\u57AE\u630E\u8DE8\u80EF\u5757\u7B77\u4FA9\u5FEB\u5BBD\u6B3E\u5321\u7B50\u72C2\u6846\u77FF\u7736\u65F7\u51B5\u4E8F\u76D4\u5CBF\u7AA5\u8475\u594E\u9B41\u5080"],
      ["c040", "\u7E5E", 35, "\u7E83", 23, "\u7E9C\u7E9D\u7E9E"],
      ["c080", "\u7EAE\u7EB4\u7EBB\u7EBC\u7ED6\u7EE4\u7EEC\u7EF9\u7F0A\u7F10\u7F1E\u7F37\u7F39\u7F3B", 6, "\u7F43\u7F46", 9, "\u7F52\u7F53\u9988\u6127\u6E83\u5764\u6606\u6346\u56F0\u62EC\u6269\u5ED3\u9614\u5783\u62C9\u5587\u8721\u814A\u8FA3\u5566\u83B1\u6765\u8D56\u84DD\u5A6A\u680F\u62E6\u7BEE\u9611\u5170\u6F9C\u8C30\u63FD\u89C8\u61D2\u7F06\u70C2\u6EE5\u7405\u6994\u72FC\u5ECA\u90CE\u6717\u6D6A\u635E\u52B3\u7262\u8001\u4F6C\u59E5\u916A\u70D9\u6D9D\u52D2\u4E50\u96F7\u956D\u857E\u78CA\u7D2F\u5121\u5792\u64C2\u808B\u7C7B\u6CEA\u68F1\u695E\u51B7\u5398\u68A8\u7281\u9ECE\u7BF1\u72F8\u79BB\u6F13\u7406\u674E\u91CC\u9CA4\u793C\u8389\u8354\u540F\u6817\u4E3D\u5389\u52B1\u783E\u5386\u5229\u5088\u4F8B\u4FD0"],
      ["c140", "\u7F56\u7F59\u7F5B\u7F5C\u7F5D\u7F5E\u7F60\u7F63", 4, "\u7F6B\u7F6C\u7F6D\u7F6F\u7F70\u7F73\u7F75\u7F76\u7F77\u7F78\u7F7A\u7F7B\u7F7C\u7F7D\u7F7F\u7F80\u7F82", 7, "\u7F8B\u7F8D\u7F8F", 4, "\u7F95", 4, "\u7F9B\u7F9C\u7FA0\u7FA2\u7FA3\u7FA5\u7FA6\u7FA8", 6, "\u7FB1"],
      ["c180", "\u7FB3", 4, "\u7FBA\u7FBB\u7FBE\u7FC0\u7FC2\u7FC3\u7FC4\u7FC6\u7FC7\u7FC8\u7FC9\u7FCB\u7FCD\u7FCF", 4, "\u7FD6\u7FD7\u7FD9", 5, "\u7FE2\u7FE3\u75E2\u7ACB\u7C92\u6CA5\u96B6\u529B\u7483\u54E9\u4FE9\u8054\u83B2\u8FDE\u9570\u5EC9\u601C\u6D9F\u5E18\u655B\u8138\u94FE\u604B\u70BC\u7EC3\u7CAE\u51C9\u6881\u7CB1\u826F\u4E24\u8F86\u91CF\u667E\u4EAE\u8C05\u64A9\u804A\u50DA\u7597\u71CE\u5BE5\u8FBD\u6F66\u4E86\u6482\u9563\u5ED6\u6599\u5217\u88C2\u70C8\u52A3\u730E\u7433\u6797\u78F7\u9716\u4E34\u90BB\u9CDE\u6DCB\u51DB\u8D41\u541D\u62CE\u73B2\u83F1\u96F6\u9F84\u94C3\u4F36\u7F9A\u51CC\u7075\u9675\u5CAD\u9886\u53E6\u4EE4\u6E9C\u7409\u69B4\u786B\u998F\u7559\u5218\u7624\u6D41\u67F3\u516D\u9F99\u804B\u5499\u7B3C\u7ABF"],
      ["c240", "\u7FE4\u7FE7\u7FE8\u7FEA\u7FEB\u7FEC\u7FED\u7FEF\u7FF2\u7FF4", 6, "\u7FFD\u7FFE\u7FFF\u8002\u8007\u8008\u8009\u800A\u800E\u800F\u8011\u8013\u801A\u801B\u801D\u801E\u801F\u8021\u8023\u8024\u802B", 5, "\u8032\u8034\u8039\u803A\u803C\u803E\u8040\u8041\u8044\u8045\u8047\u8048\u8049\u804E\u804F\u8050\u8051\u8053\u8055\u8056\u8057"],
      ["c280", "\u8059\u805B", 13, "\u806B", 5, "\u8072", 11, "\u9686\u5784\u62E2\u9647\u697C\u5A04\u6402\u7BD3\u6F0F\u964B\u82A6\u5362\u9885\u5E90\u7089\u63B3\u5364\u864F\u9C81\u9E93\u788C\u9732\u8DEF\u8D42\u9E7F\u6F5E\u7984\u5F55\u9646\u622E\u9A74\u5415\u94DD\u4FA3\u65C5\u5C65\u5C61\u7F15\u8651\u6C2F\u5F8B\u7387\u6EE4\u7EFF\u5CE6\u631B\u5B6A\u6EE6\u5375\u4E71\u63A0\u7565\u62A1\u8F6E\u4F26\u4ED1\u6CA6\u7EB6\u8BBA\u841D\u87BA\u7F57\u903B\u9523\u7BA9\u9AA1\u88F8\u843D\u6D1B\u9A86\u7EDC\u5988\u9EBB\u739B\u7801\u8682\u9A6C\u9A82\u561B\u5417\u57CB\u4E70\u9EA6\u5356\u8FC8\u8109\u7792\u9992\u86EE\u6EE1\u8513\u66FC\u6162\u6F2B"],
      ["c340", "\u807E\u8081\u8082\u8085\u8088\u808A\u808D", 5, "\u8094\u8095\u8097\u8099\u809E\u80A3\u80A6\u80A7\u80A8\u80AC\u80B0\u80B3\u80B5\u80B6\u80B8\u80B9\u80BB\u80C5\u80C7", 4, "\u80CF", 6, "\u80D8\u80DF\u80E0\u80E2\u80E3\u80E6\u80EE\u80F5\u80F7\u80F9\u80FB\u80FE\u80FF\u8100\u8101\u8103\u8104\u8105\u8107\u8108\u810B"],
      ["c380", "\u810C\u8115\u8117\u8119\u811B\u811C\u811D\u811F", 12, "\u812D\u812E\u8130\u8133\u8134\u8135\u8137\u8139", 4, "\u813F\u8C29\u8292\u832B\u76F2\u6C13\u5FD9\u83BD\u732B\u8305\u951A\u6BDB\u77DB\u94C6\u536F\u8302\u5192\u5E3D\u8C8C\u8D38\u4E48\u73AB\u679A\u6885\u9176\u9709\u7164\u6CA1\u7709\u5A92\u9541\u6BCF\u7F8E\u6627\u5BD0\u59B9\u5A9A\u95E8\u95F7\u4EEC\u840C\u8499\u6AAC\u76DF\u9530\u731B\u68A6\u5B5F\u772F\u919A\u9761\u7CDC\u8FF7\u8C1C\u5F25\u7C73\u79D8\u89C5\u6CCC\u871C\u5BC6\u5E42\u68C9\u7720\u7EF5\u5195\u514D\u52C9\u5A29\u7F05\u9762\u82D7\u63CF\u7784\u85D0\u79D2\u6E3A\u5E99\u5999\u8511\u706D\u6C11\u62BF\u76BF\u654F\u60AF\u95FD\u660E\u879F\u9E23\u94ED\u540D\u547D\u8C2C\u6478"],
      ["c440", "\u8140", 5, "\u8147\u8149\u814D\u814E\u814F\u8152\u8156\u8157\u8158\u815B", 4, "\u8161\u8162\u8163\u8164\u8166\u8168\u816A\u816B\u816C\u816F\u8172\u8173\u8175\u8176\u8177\u8178\u8181\u8183", 4, "\u8189\u818B\u818C\u818D\u818E\u8190\u8192", 5, "\u8199\u819A\u819E", 4, "\u81A4\u81A5"],
      ["c480", "\u81A7\u81A9\u81AB", 7, "\u81B4", 5, "\u81BC\u81BD\u81BE\u81BF\u81C4\u81C5\u81C7\u81C8\u81C9\u81CB\u81CD", 6, "\u6479\u8611\u6A21\u819C\u78E8\u6469\u9B54\u62B9\u672B\u83AB\u58A8\u9ED8\u6CAB\u6F20\u5BDE\u964C\u8C0B\u725F\u67D0\u62C7\u7261\u4EA9\u59C6\u6BCD\u5893\u66AE\u5E55\u52DF\u6155\u6728\u76EE\u7766\u7267\u7A46\u62FF\u54EA\u5450\u94A0\u90A3\u5A1C\u7EB3\u6C16\u4E43\u5976\u8010\u5948\u5357\u7537\u96BE\u56CA\u6320\u8111\u607C\u95F9\u6DD6\u5462\u9981\u5185\u5AE9\u80FD\u59AE\u9713\u502A\u6CE5\u5C3C\u62DF\u4F60\u533F\u817B\u9006\u6EBA\u852B\u62C8\u5E74\u78BE\u64B5\u637B\u5FF5\u5A18\u917F\u9E1F\u5C3F\u634F\u8042\u5B7D\u556E\u954A\u954D\u6D85\u60A8\u67E0\u72DE\u51DD\u5B81"],
      ["c540", "\u81D4", 14, "\u81E4\u81E5\u81E6\u81E8\u81E9\u81EB\u81EE", 4, "\u81F5", 5, "\u81FD\u81FF\u8203\u8207", 4, "\u820E\u820F\u8211\u8213\u8215", 5, "\u821D\u8220\u8224\u8225\u8226\u8227\u8229\u822E\u8232\u823A\u823C\u823D\u823F"],
      ["c580", "\u8240\u8241\u8242\u8243\u8245\u8246\u8248\u824A\u824C\u824D\u824E\u8250", 7, "\u8259\u825B\u825C\u825D\u825E\u8260", 7, "\u8269\u62E7\u6CDE\u725B\u626D\u94AE\u7EBD\u8113\u6D53\u519C\u5F04\u5974\u52AA\u6012\u5973\u6696\u8650\u759F\u632A\u61E6\u7CEF\u8BFA\u54E6\u6B27\u9E25\u6BB4\u85D5\u5455\u5076\u6CA4\u556A\u8DB4\u722C\u5E15\u6015\u7436\u62CD\u6392\u724C\u5F98\u6E43\u6D3E\u6500\u6F58\u76D8\u78D0\u76FC\u7554\u5224\u53DB\u4E53\u5E9E\u65C1\u802A\u80D6\u629B\u5486\u5228\u70AE\u888D\u8DD1\u6CE1\u5478\u80DA\u57F9\u88F4\u8D54\u966A\u914D\u4F69\u6C9B\u55B7\u76C6\u7830\u62A8\u70F9\u6F8E\u5F6D\u84EC\u68DA\u787C\u7BF7\u81A8\u670B\u9E4F\u6367\u78B0\u576F\u7812\u9739\u6279\u62AB\u5288\u7435\u6BD7"],
      ["c640", "\u826A\u826B\u826C\u826D\u8271\u8275\u8276\u8277\u8278\u827B\u827C\u8280\u8281\u8283\u8285\u8286\u8287\u8289\u828C\u8290\u8293\u8294\u8295\u8296\u829A\u829B\u829E\u82A0\u82A2\u82A3\u82A7\u82B2\u82B5\u82B6\u82BA\u82BB\u82BC\u82BF\u82C0\u82C2\u82C3\u82C5\u82C6\u82C9\u82D0\u82D6\u82D9\u82DA\u82DD\u82E2\u82E7\u82E8\u82E9\u82EA\u82EC\u82ED\u82EE\u82F0\u82F2\u82F3\u82F5\u82F6\u82F8"],
      ["c680", "\u82FA\u82FC", 4, "\u830A\u830B\u830D\u8310\u8312\u8313\u8316\u8318\u8319\u831D", 9, "\u8329\u832A\u832E\u8330\u8332\u8337\u833B\u833D\u5564\u813E\u75B2\u76AE\u5339\u75DE\u50FB\u5C41\u8B6C\u7BC7\u504F\u7247\u9A97\u98D8\u6F02\u74E2\u7968\u6487\u77A5\u62FC\u9891\u8D2B\u54C1\u8058\u4E52\u576A\u82F9\u840D\u5E73\u51ED\u74F6\u8BC4\u5C4F\u5761\u6CFC\u9887\u5A46\u7834\u9B44\u8FEB\u7C95\u5256\u6251\u94FA\u4EC6\u8386\u8461\u83E9\u84B2\u57D4\u6734\u5703\u666E\u6D66\u8C31\u66DD\u7011\u671F\u6B3A\u6816\u621A\u59BB\u4E03\u51C4\u6F06\u67D2\u6C8F\u5176\u68CB\u5947\u6B67\u7566\u5D0E\u8110\u9F50\u65D7\u7948\u7941\u9A91\u8D77\u5C82\u4E5E\u4F01\u542F\u5951\u780C\u5668\u6C14\u8FC4\u5F03\u6C7D\u6CE3\u8BAB\u6390"],
      ["c740", "\u833E\u833F\u8341\u8342\u8344\u8345\u8348\u834A", 4, "\u8353\u8355", 4, "\u835D\u8362\u8370", 6, "\u8379\u837A\u837E", 6, "\u8387\u8388\u838A\u838B\u838C\u838D\u838F\u8390\u8391\u8394\u8395\u8396\u8397\u8399\u839A\u839D\u839F\u83A1", 6, "\u83AC\u83AD\u83AE"],
      ["c780", "\u83AF\u83B5\u83BB\u83BE\u83BF\u83C2\u83C3\u83C4\u83C6\u83C8\u83C9\u83CB\u83CD\u83CE\u83D0\u83D1\u83D2\u83D3\u83D5\u83D7\u83D9\u83DA\u83DB\u83DE\u83E2\u83E3\u83E4\u83E6\u83E7\u83E8\u83EB\u83EC\u83ED\u6070\u6D3D\u7275\u6266\u948E\u94C5\u5343\u8FC1\u7B7E\u4EDF\u8C26\u4E7E\u9ED4\u94B1\u94B3\u524D\u6F5C\u9063\u6D45\u8C34\u5811\u5D4C\u6B20\u6B49\u67AA\u545B\u8154\u7F8C\u5899\u8537\u5F3A\u62A2\u6A47\u9539\u6572\u6084\u6865\u77A7\u4E54\u4FA8\u5DE7\u9798\u64AC\u7FD8\u5CED\u4FCF\u7A8D\u5207\u8304\u4E14\u602F\u7A83\u94A6\u4FB5\u4EB2\u79E6\u7434\u52E4\u82B9\u64D2\u79BD\u5BDD\u6C81\u9752\u8F7B\u6C22\u503E\u537F\u6E05\u64CE\u6674\u6C30\u60C5\u9877\u8BF7\u5E86\u743C\u7A77\u79CB\u4E18\u90B1\u7403\u6C42\u56DA\u914B\u6CC5\u8D8B\u533A\u86C6\u66F2\u8EAF\u5C48\u9A71\u6E20"],
      ["c840", "\u83EE\u83EF\u83F3", 4, "\u83FA\u83FB\u83FC\u83FE\u83FF\u8400\u8402\u8405\u8407\u8408\u8409\u840A\u8410\u8412", 5, "\u8419\u841A\u841B\u841E", 5, "\u8429", 7, "\u8432", 5, "\u8439\u843A\u843B\u843E", 7, "\u8447\u8448\u8449"],
      ["c880", "\u844A", 6, "\u8452", 4, "\u8458\u845D\u845E\u845F\u8460\u8462\u8464", 4, "\u846A\u846E\u846F\u8470\u8472\u8474\u8477\u8479\u847B\u847C\u53D6\u5A36\u9F8B\u8DA3\u53BB\u5708\u98A7\u6743\u919B\u6CC9\u5168\u75CA\u62F3\u72AC\u5238\u529D\u7F3A\u7094\u7638\u5374\u9E4A\u69B7\u786E\u96C0\u88D9\u7FA4\u7136\u71C3\u5189\u67D3\u74E4\u58E4\u6518\u56B7\u8BA9\u9976\u6270\u7ED5\u60F9\u70ED\u58EC\u4EC1\u4EBA\u5FCD\u97E7\u4EFB\u8BA4\u5203\u598A\u7EAB\u6254\u4ECD\u65E5\u620E\u8338\u84C9\u8363\u878D\u7194\u6EB6\u5BB9\u7ED2\u5197\u63C9\u67D4\u8089\u8339\u8815\u5112\u5B7A\u5982\u8FB1\u4E73\u6C5D\u5165\u8925\u8F6F\u962E\u854A\u745E\u9510\u95F0\u6DA6\u82E5\u5F31\u6492\u6D12\u8428\u816E\u9CC3\u585E\u8D5B\u4E09\u53C1"],
      ["c940", "\u847D", 4, "\u8483\u8484\u8485\u8486\u848A\u848D\u848F", 7, "\u8498\u849A\u849B\u849D\u849E\u849F\u84A0\u84A2", 12, "\u84B0\u84B1\u84B3\u84B5\u84B6\u84B7\u84BB\u84BC\u84BE\u84C0\u84C2\u84C3\u84C5\u84C6\u84C7\u84C8\u84CB\u84CC\u84CE\u84CF\u84D2\u84D4\u84D5\u84D7"],
      ["c980", "\u84D8", 4, "\u84DE\u84E1\u84E2\u84E4\u84E7", 4, "\u84ED\u84EE\u84EF\u84F1", 10, "\u84FD\u84FE\u8500\u8501\u8502\u4F1E\u6563\u6851\u55D3\u4E27\u6414\u9A9A\u626B\u5AC2\u745F\u8272\u6DA9\u68EE\u50E7\u838E\u7802\u6740\u5239\u6C99\u7EB1\u50BB\u5565\u715E\u7B5B\u6652\u73CA\u82EB\u6749\u5C71\u5220\u717D\u886B\u95EA\u9655\u64C5\u8D61\u81B3\u5584\u6C55\u6247\u7F2E\u5892\u4F24\u5546\u8D4F\u664C\u4E0A\u5C1A\u88F3\u68A2\u634E\u7A0D\u70E7\u828D\u52FA\u97F6\u5C11\u54E8\u90B5\u7ECD\u5962\u8D4A\u86C7\u820C\u820D\u8D66\u6444\u5C04\u6151\u6D89\u793E\u8BBE\u7837\u7533\u547B\u4F38\u8EAB\u6DF1\u5A20\u7EC5\u795E\u6C88\u5BA1\u5A76\u751A\u80BE\u614E\u6E17\u58F0\u751F\u7525\u7272\u5347\u7EF3"],
      ["ca40", "\u8503", 8, "\u850D\u850E\u850F\u8510\u8512\u8514\u8515\u8516\u8518\u8519\u851B\u851C\u851D\u851E\u8520\u8522", 8, "\u852D", 9, "\u853E", 4, "\u8544\u8545\u8546\u8547\u854B", 10],
      ["ca80", "\u8557\u8558\u855A\u855B\u855C\u855D\u855F", 4, "\u8565\u8566\u8567\u8569", 8, "\u8573\u8575\u8576\u8577\u8578\u857C\u857D\u857F\u8580\u8581\u7701\u76DB\u5269\u80DC\u5723\u5E08\u5931\u72EE\u65BD\u6E7F\u8BD7\u5C38\u8671\u5341\u77F3\u62FE\u65F6\u4EC0\u98DF\u8680\u5B9E\u8BC6\u53F2\u77E2\u4F7F\u5C4E\u9A76\u59CB\u5F0F\u793A\u58EB\u4E16\u67FF\u4E8B\u62ED\u8A93\u901D\u52BF\u662F\u55DC\u566C\u9002\u4ED5\u4F8D\u91CA\u9970\u6C0F\u5E02\u6043\u5BA4\u89C6\u8BD5\u6536\u624B\u9996\u5B88\u5BFF\u6388\u552E\u53D7\u7626\u517D\u852C\u67A2\u68B3\u6B8A\u6292\u8F93\u53D4\u8212\u6DD1\u758F\u4E66\u8D4E\u5B70\u719F\u85AF\u6691\u66D9\u7F72\u8700\u9ECD\u9F20\u5C5E\u672F\u8FF0\u6811\u675F\u620D\u7AD6\u5885\u5EB6\u6570\u6F31"],
      ["cb40", "\u8582\u8583\u8586\u8588", 6, "\u8590", 10, "\u859D", 6, "\u85A5\u85A6\u85A7\u85A9\u85AB\u85AC\u85AD\u85B1", 5, "\u85B8\u85BA", 6, "\u85C2", 6, "\u85CA", 4, "\u85D1\u85D2"],
      ["cb80", "\u85D4\u85D6", 5, "\u85DD", 6, "\u85E5\u85E6\u85E7\u85E8\u85EA", 14, "\u6055\u5237\u800D\u6454\u8870\u7529\u5E05\u6813\u62F4\u971C\u53CC\u723D\u8C01\u6C34\u7761\u7A0E\u542E\u77AC\u987A\u821C\u8BF4\u7855\u6714\u70C1\u65AF\u6495\u5636\u601D\u79C1\u53F8\u4E1D\u6B7B\u8086\u5BFA\u55E3\u56DB\u4F3A\u4F3C\u9972\u5DF3\u677E\u8038\u6002\u9882\u9001\u5B8B\u8BBC\u8BF5\u641C\u8258\u64DE\u55FD\u82CF\u9165\u4FD7\u7D20\u901F\u7C9F\u50F3\u5851\u6EAF\u5BBF\u8BC9\u8083\u9178\u849C\u7B97\u867D\u968B\u968F\u7EE5\u9AD3\u788E\u5C81\u7A57\u9042\u96A7\u795F\u5B59\u635F\u7B0B\u84D1\u68AD\u5506\u7F29\u7410\u7D22\u9501\u6240\u584C\u4ED6\u5B83\u5979\u5854"],
      ["cc40", "\u85F9\u85FA\u85FC\u85FD\u85FE\u8600", 4, "\u8606", 10, "\u8612\u8613\u8614\u8615\u8617", 15, "\u8628\u862A", 13, "\u8639\u863A\u863B\u863D\u863E\u863F\u8640"],
      ["cc80", "\u8641", 11, "\u8652\u8653\u8655", 4, "\u865B\u865C\u865D\u865F\u8660\u8661\u8663", 7, "\u736D\u631E\u8E4B\u8E0F\u80CE\u82D4\u62AC\u53F0\u6CF0\u915E\u592A\u6001\u6C70\u574D\u644A\u8D2A\u762B\u6EE9\u575B\u6A80\u75F0\u6F6D\u8C2D\u8C08\u5766\u6BEF\u8892\u78B3\u63A2\u53F9\u70AD\u6C64\u5858\u642A\u5802\u68E0\u819B\u5510\u7CD6\u5018\u8EBA\u6DCC\u8D9F\u70EB\u638F\u6D9B\u6ED4\u7EE6\u8404\u6843\u9003\u6DD8\u9676\u8BA8\u5957\u7279\u85E4\u817E\u75BC\u8A8A\u68AF\u5254\u8E22\u9511\u63D0\u9898\u8E44\u557C\u4F53\u66FF\u568F\u60D5\u6D95\u5243\u5C49\u5929\u6DFB\u586B\u7530\u751C\u606C\u8214\u8146\u6311\u6761\u8FE2\u773A\u8DF3\u8D34\u94C1\u5E16\u5385\u542C\u70C3"],
      ["cd40", "\u866D\u866F\u8670\u8672", 6, "\u8683", 6, "\u868E", 4, "\u8694\u8696", 5, "\u869E", 4, "\u86A5\u86A6\u86AB\u86AD\u86AE\u86B2\u86B3\u86B7\u86B8\u86B9\u86BB", 4, "\u86C1\u86C2\u86C3\u86C5\u86C8\u86CC\u86CD\u86D2\u86D3\u86D5\u86D6\u86D7\u86DA\u86DC"],
      ["cd80", "\u86DD\u86E0\u86E1\u86E2\u86E3\u86E5\u86E6\u86E7\u86E8\u86EA\u86EB\u86EC\u86EF\u86F5\u86F6\u86F7\u86FA\u86FB\u86FC\u86FD\u86FF\u8701\u8704\u8705\u8706\u870B\u870C\u870E\u870F\u8710\u8711\u8714\u8716\u6C40\u5EF7\u505C\u4EAD\u5EAD\u633A\u8247\u901A\u6850\u916E\u77B3\u540C\u94DC\u5F64\u7AE5\u6876\u6345\u7B52\u7EDF\u75DB\u5077\u6295\u5934\u900F\u51F8\u79C3\u7A81\u56FE\u5F92\u9014\u6D82\u5C60\u571F\u5410\u5154\u6E4D\u56E2\u63A8\u9893\u817F\u8715\u892A\u9000\u541E\u5C6F\u81C0\u62D6\u6258\u8131\u9E35\u9640\u9A6E\u9A7C\u692D\u59A5\u62D3\u553E\u6316\u54C7\u86D9\u6D3C\u5A03\u74E6\u889C\u6B6A\u5916\u8C4C\u5F2F\u6E7E\u73A9\u987D\u4E38\u70F7\u5B8C\u7897\u633D\u665A\u7696\u60CB\u5B9B\u5A49\u4E07\u8155\u6C6A\u738B\u4EA1\u6789\u7F51\u5F80\u65FA\u671B\u5FD8\u5984\u5A01"],
      ["ce40", "\u8719\u871B\u871D\u871F\u8720\u8724\u8726\u8727\u8728\u872A\u872B\u872C\u872D\u872F\u8730\u8732\u8733\u8735\u8736\u8738\u8739\u873A\u873C\u873D\u8740", 6, "\u874A\u874B\u874D\u874F\u8750\u8751\u8752\u8754\u8755\u8756\u8758\u875A", 5, "\u8761\u8762\u8766", 7, "\u876F\u8771\u8772\u8773\u8775"],
      ["ce80", "\u8777\u8778\u8779\u877A\u877F\u8780\u8781\u8784\u8786\u8787\u8789\u878A\u878C\u878E", 4, "\u8794\u8795\u8796\u8798", 6, "\u87A0", 4, "\u5DCD\u5FAE\u5371\u97E6\u8FDD\u6845\u56F4\u552F\u60DF\u4E3A\u6F4D\u7EF4\u82C7\u840E\u59D4\u4F1F\u4F2A\u5C3E\u7EAC\u672A\u851A\u5473\u754F\u80C3\u5582\u9B4F\u4F4D\u6E2D\u8C13\u5C09\u6170\u536B\u761F\u6E29\u868A\u6587\u95FB\u7EB9\u543B\u7A33\u7D0A\u95EE\u55E1\u7FC1\u74EE\u631D\u8717\u6DA1\u7A9D\u6211\u65A1\u5367\u63E1\u6C83\u5DEB\u545C\u94A8\u4E4C\u6C61\u8BEC\u5C4B\u65E0\u829C\u68A7\u543E\u5434\u6BCB\u6B66\u4E94\u6342\u5348\u821E\u4F0D\u4FAE\u575E\u620A\u96FE\u6664\u7269\u52FF\u52A1\u609F\u8BEF\u6614\u7199\u6790\u897F\u7852\u77FD\u6670\u563B\u5438\u9521\u727A"],
      ["cf40", "\u87A5\u87A6\u87A7\u87A9\u87AA\u87AE\u87B0\u87B1\u87B2\u87B4\u87B6\u87B7\u87B8\u87B9\u87BB\u87BC\u87BE\u87BF\u87C1", 4, "\u87C7\u87C8\u87C9\u87CC", 4, "\u87D4", 6, "\u87DC\u87DD\u87DE\u87DF\u87E1\u87E2\u87E3\u87E4\u87E6\u87E7\u87E8\u87E9\u87EB\u87EC\u87ED\u87EF", 9],
      ["cf80", "\u87FA\u87FB\u87FC\u87FD\u87FF\u8800\u8801\u8802\u8804", 5, "\u880B", 7, "\u8814\u8817\u8818\u8819\u881A\u881C", 4, "\u8823\u7A00\u606F\u5E0C\u6089\u819D\u5915\u60DC\u7184\u70EF\u6EAA\u6C50\u7280\u6A84\u88AD\u5E2D\u4E60\u5AB3\u559C\u94E3\u6D17\u7CFB\u9699\u620F\u7EC6\u778E\u867E\u5323\u971E\u8F96\u6687\u5CE1\u4FA0\u72ED\u4E0B\u53A6\u590F\u5413\u6380\u9528\u5148\u4ED9\u9C9C\u7EA4\u54B8\u8D24\u8854\u8237\u95F2\u6D8E\u5F26\u5ACC\u663E\u9669\u73B0\u732E\u53BF\u817A\u9985\u7FA1\u5BAA\u9677\u9650\u7EBF\u76F8\u53A2\u9576\u9999\u7BB1\u8944\u6E58\u4E61\u7FD4\u7965\u8BE6\u60F3\u54CD\u4EAB\u9879\u5DF7\u6A61\u50CF\u5411\u8C61\u8427\u785D\u9704\u524A\u54EE\u56A3\u9500\u6D88\u5BB5\u6DC6\u6653"],
      ["d040", "\u8824", 13, "\u8833", 5, "\u883A\u883B\u883D\u883E\u883F\u8841\u8842\u8843\u8846", 5, "\u884E", 5, "\u8855\u8856\u8858\u885A", 6, "\u8866\u8867\u886A\u886D\u886F\u8871\u8873\u8874\u8875\u8876\u8878\u8879\u887A"],
      ["d080", "\u887B\u887C\u8880\u8883\u8886\u8887\u8889\u888A\u888C\u888E\u888F\u8890\u8891\u8893\u8894\u8895\u8897", 4, "\u889D", 4, "\u88A3\u88A5", 5, "\u5C0F\u5B5D\u6821\u8096\u5578\u7B11\u6548\u6954\u4E9B\u6B47\u874E\u978B\u534F\u631F\u643A\u90AA\u659C\u80C1\u8C10\u5199\u68B0\u5378\u87F9\u61C8\u6CC4\u6CFB\u8C22\u5C51\u85AA\u82AF\u950C\u6B23\u8F9B\u65B0\u5FFB\u5FC3\u4FE1\u8845\u661F\u8165\u7329\u60FA\u5174\u5211\u578B\u5F62\u90A2\u884C\u9192\u5E78\u674F\u6027\u59D3\u5144\u51F6\u80F8\u5308\u6C79\u96C4\u718A\u4F11\u4FEE\u7F9E\u673D\u55C5\u9508\u79C0\u8896\u7EE3\u589F\u620C\u9700\u865A\u5618\u987B\u5F90\u8BB8\u84C4\u9157\u53D9\u65ED\u5E8F\u755C\u6064\u7D6E\u5A7F\u7EEA\u7EED\u8F69\u55A7\u5BA3\u60AC\u65CB\u7384"],
      ["d140", "\u88AC\u88AE\u88AF\u88B0\u88B2", 4, "\u88B8\u88B9\u88BA\u88BB\u88BD\u88BE\u88BF\u88C0\u88C3\u88C4\u88C7\u88C8\u88CA\u88CB\u88CC\u88CD\u88CF\u88D0\u88D1\u88D3\u88D6\u88D7\u88DA", 4, "\u88E0\u88E1\u88E6\u88E7\u88E9", 6, "\u88F2\u88F5\u88F6\u88F7\u88FA\u88FB\u88FD\u88FF\u8900\u8901\u8903", 5],
      ["d180", "\u8909\u890B", 4, "\u8911\u8914", 4, "\u891C", 4, "\u8922\u8923\u8924\u8926\u8927\u8928\u8929\u892C\u892D\u892E\u892F\u8931\u8932\u8933\u8935\u8937\u9009\u7663\u7729\u7EDA\u9774\u859B\u5B66\u7A74\u96EA\u8840\u52CB\u718F\u5FAA\u65EC\u8BE2\u5BFB\u9A6F\u5DE1\u6B89\u6C5B\u8BAD\u8BAF\u900A\u8FC5\u538B\u62BC\u9E26\u9E2D\u5440\u4E2B\u82BD\u7259\u869C\u5D16\u8859\u6DAF\u96C5\u54D1\u4E9A\u8BB6\u7109\u54BD\u9609\u70DF\u6DF9\u76D0\u4E25\u7814\u8712\u5CA9\u5EF6\u8A00\u989C\u960E\u708E\u6CBF\u5944\u63A9\u773C\u884D\u6F14\u8273\u5830\u71D5\u538C\u781A\u96C1\u5501\u5F66\u7130\u5BB4\u8C1A\u9A8C\u6B83\u592E\u9E2F\u79E7\u6768\u626C\u4F6F\u75A1\u7F8A\u6D0B\u9633\u6C27\u4EF0\u75D2\u517B\u6837\u6F3E\u9080\u8170\u5996\u7476"],
      ["d240", "\u8938", 8, "\u8942\u8943\u8945", 24, "\u8960", 5, "\u8967", 19, "\u897C"],
      ["d280", "\u897D\u897E\u8980\u8982\u8984\u8985\u8987", 26, "\u6447\u5C27\u9065\u7A91\u8C23\u59DA\u54AC\u8200\u836F\u8981\u8000\u6930\u564E\u8036\u7237\u91CE\u51B6\u4E5F\u9875\u6396\u4E1A\u53F6\u66F3\u814B\u591C\u6DB2\u4E00\u58F9\u533B\u63D6\u94F1\u4F9D\u4F0A\u8863\u9890\u5937\u9057\u79FB\u4EEA\u80F0\u7591\u6C82\u5B9C\u59E8\u5F5D\u6905\u8681\u501A\u5DF2\u4E59\u77E3\u4EE5\u827A\u6291\u6613\u9091\u5C79\u4EBF\u5F79\u81C6\u9038\u8084\u75AB\u4EA6\u88D4\u610F\u6BC5\u5FC6\u4E49\u76CA\u6EA2\u8BE3\u8BAE\u8C0A\u8BD1\u5F02\u7FFC\u7FCC\u7ECE\u8335\u836B\u56E0\u6BB7\u97F3\u9634\u59FB\u541F\u94F6\u6DEB\u5BC5\u996E\u5C39\u5F15\u9690"],
      ["d340", "\u89A2", 30, "\u89C3\u89CD\u89D3\u89D4\u89D5\u89D7\u89D8\u89D9\u89DB\u89DD\u89DF\u89E0\u89E1\u89E2\u89E4\u89E7\u89E8\u89E9\u89EA\u89EC\u89ED\u89EE\u89F0\u89F1\u89F2\u89F4", 6],
      ["d380", "\u89FB", 4, "\u8A01", 5, "\u8A08", 21, "\u5370\u82F1\u6A31\u5A74\u9E70\u5E94\u7F28\u83B9\u8424\u8425\u8367\u8747\u8FCE\u8D62\u76C8\u5F71\u9896\u786C\u6620\u54DF\u62E5\u4F63\u81C3\u75C8\u5EB8\u96CD\u8E0A\u86F9\u548F\u6CF3\u6D8C\u6C38\u607F\u52C7\u7528\u5E7D\u4F18\u60A0\u5FE7\u5C24\u7531\u90AE\u94C0\u72B9\u6CB9\u6E38\u9149\u6709\u53CB\u53F3\u4F51\u91C9\u8BF1\u53C8\u5E7C\u8FC2\u6DE4\u4E8E\u76C2\u6986\u865E\u611A\u8206\u4F59\u4FDE\u903E\u9C7C\u6109\u6E1D\u6E14\u9685\u4E88\u5A31\u96E8\u4E0E\u5C7F\u79B9\u5B87\u8BED\u7FBD\u7389\u57DF\u828B\u90C1\u5401\u9047\u55BB\u5CEA\u5FA1\u6108\u6B32\u72F1\u80B2\u8A89"],
      ["d440", "\u8A1E", 31, "\u8A3F", 8, "\u8A49", 21],
      ["d480", "\u8A5F", 25, "\u8A7A", 6, "\u6D74\u5BD3\u88D5\u9884\u8C6B\u9A6D\u9E33\u6E0A\u51A4\u5143\u57A3\u8881\u539F\u63F4\u8F95\u56ED\u5458\u5706\u733F\u6E90\u7F18\u8FDC\u82D1\u613F\u6028\u9662\u66F0\u7EA6\u8D8A\u8DC3\u94A5\u5CB3\u7CA4\u6708\u60A6\u9605\u8018\u4E91\u90E7\u5300\u9668\u5141\u8FD0\u8574\u915D\u6655\u97F5\u5B55\u531D\u7838\u6742\u683D\u54C9\u707E\u5BB0\u8F7D\u518D\u5728\u54B1\u6512\u6682\u8D5E\u8D43\u810F\u846C\u906D\u7CDF\u51FF\u85FB\u67A3\u65E9\u6FA1\u86A4\u8E81\u566A\u9020\u7682\u7076\u71E5\u8D23\u62E9\u5219\u6CFD\u8D3C\u600E\u589E\u618E\u66FE\u8D60\u624E\u55B3\u6E23\u672D\u8F67"],
      ["d540", "\u8A81", 7, "\u8A8B", 7, "\u8A94", 46],
      ["d580", "\u8AC3", 32, "\u94E1\u95F8\u7728\u6805\u69A8\u548B\u4E4D\u70B8\u8BC8\u6458\u658B\u5B85\u7A84\u503A\u5BE8\u77BB\u6BE1\u8A79\u7C98\u6CBE\u76CF\u65A9\u8F97\u5D2D\u5C55\u8638\u6808\u5360\u6218\u7AD9\u6E5B\u7EFD\u6A1F\u7AE0\u5F70\u6F33\u5F20\u638C\u6DA8\u6756\u4E08\u5E10\u8D26\u4ED7\u80C0\u7634\u969C\u62DB\u662D\u627E\u6CBC\u8D75\u7167\u7F69\u5146\u8087\u53EC\u906E\u6298\u54F2\u86F0\u8F99\u8005\u9517\u8517\u8FD9\u6D59\u73CD\u659F\u771F\u7504\u7827\u81FB\u8D1E\u9488\u4FA6\u6795\u75B9\u8BCA\u9707\u632F\u9547\u9635\u84B8\u6323\u7741\u5F81\u72F0\u4E89\u6014\u6574\u62EF\u6B63\u653F"],
      ["d640", "\u8AE4", 34, "\u8B08", 27],
      ["d680", "\u8B24\u8B25\u8B27", 30, "\u5E27\u75C7\u90D1\u8BC1\u829D\u679D\u652F\u5431\u8718\u77E5\u80A2\u8102\u6C41\u4E4B\u7EC7\u804C\u76F4\u690D\u6B96\u6267\u503C\u4F84\u5740\u6307\u6B62\u8DBE\u53EA\u65E8\u7EB8\u5FD7\u631A\u63B7\u81F3\u81F4\u7F6E\u5E1C\u5CD9\u5236\u667A\u79E9\u7A1A\u8D28\u7099\u75D4\u6EDE\u6CBB\u7A92\u4E2D\u76C5\u5FE0\u949F\u8877\u7EC8\u79CD\u80BF\u91CD\u4EF2\u4F17\u821F\u5468\u5DDE\u6D32\u8BCC\u7CA5\u8F74\u8098\u5E1A\u5492\u76B1\u5B99\u663C\u9AA4\u73E0\u682A\u86DB\u6731\u732A\u8BF8\u8BDB\u9010\u7AF9\u70DB\u716E\u62C4\u77A9\u5631\u4E3B\u8457\u67F1\u52A9\u86C0\u8D2E\u94F8\u7B51"],
      ["d740", "\u8B46", 31, "\u8B67", 4, "\u8B6D", 25],
      ["d780", "\u8B87", 24, "\u8BAC\u8BB1\u8BBB\u8BC7\u8BD0\u8BEA\u8C09\u8C1E\u4F4F\u6CE8\u795D\u9A7B\u6293\u722A\u62FD\u4E13\u7816\u8F6C\u64B0\u8D5A\u7BC6\u6869\u5E84\u88C5\u5986\u649E\u58EE\u72B6\u690E\u9525\u8FFD\u8D58\u5760\u7F00\u8C06\u51C6\u6349\u62D9\u5353\u684C\u7422\u8301\u914C\u5544\u7740\u707C\u6D4A\u5179\u54A8\u8D44\u59FF\u6ECB\u6DC4\u5B5C\u7D2B\u4ED4\u7C7D\u6ED3\u5B50\u81EA\u6E0D\u5B57\u9B03\u68D5\u8E2A\u5B97\u7EFC\u603B\u7EB5\u90B9\u8D70\u594F\u63CD\u79DF\u8DB3\u5352\u65CF\u7956\u8BC5\u963B\u7EC4\u94BB\u7E82\u5634\u9189\u6700\u7F6A\u5C0A\u9075\u6628\u5DE6\u4F50\u67DE\u505A\u4F5C\u5750\u5EA7"],
      ["d840", "\u8C38", 8, "\u8C42\u8C43\u8C44\u8C45\u8C48\u8C4A\u8C4B\u8C4D", 7, "\u8C56\u8C57\u8C58\u8C59\u8C5B", 5, "\u8C63", 6, "\u8C6C", 6, "\u8C74\u8C75\u8C76\u8C77\u8C7B", 6, "\u8C83\u8C84\u8C86\u8C87"],
      ["d880", "\u8C88\u8C8B\u8C8D", 6, "\u8C95\u8C96\u8C97\u8C99", 20, "\u4E8D\u4E0C\u5140\u4E10\u5EFF\u5345\u4E15\u4E98\u4E1E\u9B32\u5B6C\u5669\u4E28\u79BA\u4E3F\u5315\u4E47\u592D\u723B\u536E\u6C10\u56DF\u80E4\u9997\u6BD3\u777E\u9F17\u4E36\u4E9F\u9F10\u4E5C\u4E69\u4E93\u8288\u5B5B\u556C\u560F\u4EC4\u538D\u539D\u53A3\u53A5\u53AE\u9765\u8D5D\u531A\u53F5\u5326\u532E\u533E\u8D5C\u5366\u5363\u5202\u5208\u520E\u522D\u5233\u523F\u5240\u524C\u525E\u5261\u525C\u84AF\u527D\u5282\u5281\u5290\u5293\u5182\u7F54\u4EBB\u4EC3\u4EC9\u4EC2\u4EE8\u4EE1\u4EEB\u4EDE\u4F1B\u4EF3\u4F22\u4F64\u4EF5\u4F25\u4F27\u4F09\u4F2B\u4F5E\u4F67\u6538\u4F5A\u4F5D"],
      ["d940", "\u8CAE", 62],
      ["d980", "\u8CED", 32, "\u4F5F\u4F57\u4F32\u4F3D\u4F76\u4F74\u4F91\u4F89\u4F83\u4F8F\u4F7E\u4F7B\u4FAA\u4F7C\u4FAC\u4F94\u4FE6\u4FE8\u4FEA\u4FC5\u4FDA\u4FE3\u4FDC\u4FD1\u4FDF\u4FF8\u5029\u504C\u4FF3\u502C\u500F\u502E\u502D\u4FFE\u501C\u500C\u5025\u5028\u507E\u5043\u5055\u5048\u504E\u506C\u507B\u50A5\u50A7\u50A9\u50BA\u50D6\u5106\u50ED\u50EC\u50E6\u50EE\u5107\u510B\u4EDD\u6C3D\u4F58\u4F65\u4FCE\u9FA0\u6C46\u7C74\u516E\u5DFD\u9EC9\u9998\u5181\u5914\u52F9\u530D\u8A07\u5310\u51EB\u5919\u5155\u4EA0\u5156\u4EB3\u886E\u88A4\u4EB5\u8114\u88D2\u7980\u5B34\u8803\u7FB8\u51AB\u51B1\u51BD\u51BC"],
      ["da40", "\u8D0E", 14, "\u8D20\u8D51\u8D52\u8D57\u8D5F\u8D65\u8D68\u8D69\u8D6A\u8D6C\u8D6E\u8D6F\u8D71\u8D72\u8D78", 8, "\u8D82\u8D83\u8D86\u8D87\u8D88\u8D89\u8D8C", 4, "\u8D92\u8D93\u8D95", 9, "\u8DA0\u8DA1"],
      ["da80", "\u8DA2\u8DA4", 12, "\u8DB2\u8DB6\u8DB7\u8DB9\u8DBB\u8DBD\u8DC0\u8DC1\u8DC2\u8DC5\u8DC7\u8DC8\u8DC9\u8DCA\u8DCD\u8DD0\u8DD2\u8DD3\u8DD4\u51C7\u5196\u51A2\u51A5\u8BA0\u8BA6\u8BA7\u8BAA\u8BB4\u8BB5\u8BB7\u8BC2\u8BC3\u8BCB\u8BCF\u8BCE\u8BD2\u8BD3\u8BD4\u8BD6\u8BD8\u8BD9\u8BDC\u8BDF\u8BE0\u8BE4\u8BE8\u8BE9\u8BEE\u8BF0\u8BF3\u8BF6\u8BF9\u8BFC\u8BFF\u8C00\u8C02\u8C04\u8C07\u8C0C\u8C0F\u8C11\u8C12\u8C14\u8C15\u8C16\u8C19\u8C1B\u8C18\u8C1D\u8C1F\u8C20\u8C21\u8C25\u8C27\u8C2A\u8C2B\u8C2E\u8C2F\u8C32\u8C33\u8C35\u8C36\u5369\u537A\u961D\u9622\u9621\u9631\u962A\u963D\u963C\u9642\u9649\u9654\u965F\u9667\u966C\u9672\u9674\u9688\u968D\u9697\u96B0\u9097\u909B\u909D\u9099\u90AC\u90A1\u90B4\u90B3\u90B6\u90BA"],
      ["db40", "\u8DD5\u8DD8\u8DD9\u8DDC\u8DE0\u8DE1\u8DE2\u8DE5\u8DE6\u8DE7\u8DE9\u8DED\u8DEE\u8DF0\u8DF1\u8DF2\u8DF4\u8DF6\u8DFC\u8DFE", 6, "\u8E06\u8E07\u8E08\u8E0B\u8E0D\u8E0E\u8E10\u8E11\u8E12\u8E13\u8E15", 7, "\u8E20\u8E21\u8E24", 4, "\u8E2B\u8E2D\u8E30\u8E32\u8E33\u8E34\u8E36\u8E37\u8E38\u8E3B\u8E3C\u8E3E"],
      ["db80", "\u8E3F\u8E43\u8E45\u8E46\u8E4C", 4, "\u8E53", 5, "\u8E5A", 11, "\u8E67\u8E68\u8E6A\u8E6B\u8E6E\u8E71\u90B8\u90B0\u90CF\u90C5\u90BE\u90D0\u90C4\u90C7\u90D3\u90E6\u90E2\u90DC\u90D7\u90DB\u90EB\u90EF\u90FE\u9104\u9122\u911E\u9123\u9131\u912F\u9139\u9143\u9146\u520D\u5942\u52A2\u52AC\u52AD\u52BE\u54FF\u52D0\u52D6\u52F0\u53DF\u71EE\u77CD\u5EF4\u51F5\u51FC\u9B2F\u53B6\u5F01\u755A\u5DEF\u574C\u57A9\u57A1\u587E\u58BC\u58C5\u58D1\u5729\u572C\u572A\u5733\u5739\u572E\u572F\u575C\u573B\u5742\u5769\u5785\u576B\u5786\u577C\u577B\u5768\u576D\u5776\u5773\u57AD\u57A4\u578C\u57B2\u57CF\u57A7\u57B4\u5793\u57A0\u57D5\u57D8\u57DA\u57D9\u57D2\u57B8\u57F4\u57EF\u57F8\u57E4\u57DD"],
      ["dc40", "\u8E73\u8E75\u8E77", 4, "\u8E7D\u8E7E\u8E80\u8E82\u8E83\u8E84\u8E86\u8E88", 6, "\u8E91\u8E92\u8E93\u8E95", 6, "\u8E9D\u8E9F", 11, "\u8EAD\u8EAE\u8EB0\u8EB1\u8EB3", 6, "\u8EBB", 7],
      ["dc80", "\u8EC3", 10, "\u8ECF", 21, "\u580B\u580D\u57FD\u57ED\u5800\u581E\u5819\u5844\u5820\u5865\u586C\u5881\u5889\u589A\u5880\u99A8\u9F19\u61FF\u8279\u827D\u827F\u828F\u828A\u82A8\u8284\u828E\u8291\u8297\u8299\u82AB\u82B8\u82BE\u82B0\u82C8\u82CA\u82E3\u8298\u82B7\u82AE\u82CB\u82CC\u82C1\u82A9\u82B4\u82A1\u82AA\u829F\u82C4\u82CE\u82A4\u82E1\u8309\u82F7\u82E4\u830F\u8307\u82DC\u82F4\u82D2\u82D8\u830C\u82FB\u82D3\u8311\u831A\u8306\u8314\u8315\u82E0\u82D5\u831C\u8351\u835B\u835C\u8308\u8392\u833C\u8334\u8331\u839B\u835E\u832F\u834F\u8347\u8343\u835F\u8340\u8317\u8360\u832D\u833A\u8333\u8366\u8365"],
      ["dd40", "\u8EE5", 62],
      ["dd80", "\u8F24", 32, "\u8368\u831B\u8369\u836C\u836A\u836D\u836E\u83B0\u8378\u83B3\u83B4\u83A0\u83AA\u8393\u839C\u8385\u837C\u83B6\u83A9\u837D\u83B8\u837B\u8398\u839E\u83A8\u83BA\u83BC\u83C1\u8401\u83E5\u83D8\u5807\u8418\u840B\u83DD\u83FD\u83D6\u841C\u8438\u8411\u8406\u83D4\u83DF\u840F\u8403\u83F8\u83F9\u83EA\u83C5\u83C0\u8426\u83F0\u83E1\u845C\u8451\u845A\u8459\u8473\u8487\u8488\u847A\u8489\u8478\u843C\u8446\u8469\u8476\u848C\u848E\u8431\u846D\u84C1\u84CD\u84D0\u84E6\u84BD\u84D3\u84CA\u84BF\u84BA\u84E0\u84A1\u84B9\u84B4\u8497\u84E5\u84E3\u850C\u750D\u8538\u84F0\u8539\u851F\u853A"],
      ["de40", "\u8F45", 32, "\u8F6A\u8F80\u8F8C\u8F92\u8F9D\u8FA0\u8FA1\u8FA2\u8FA4\u8FA5\u8FA6\u8FA7\u8FAA\u8FAC\u8FAD\u8FAE\u8FAF\u8FB2\u8FB3\u8FB4\u8FB5\u8FB7\u8FB8\u8FBA\u8FBB\u8FBC\u8FBF\u8FC0\u8FC3\u8FC6"],
      ["de80", "\u8FC9", 4, "\u8FCF\u8FD2\u8FD6\u8FD7\u8FDA\u8FE0\u8FE1\u8FE3\u8FE7\u8FEC\u8FEF\u8FF1\u8FF2\u8FF4\u8FF5\u8FF6\u8FFA\u8FFB\u8FFC\u8FFE\u8FFF\u9007\u9008\u900C\u900E\u9013\u9015\u9018\u8556\u853B\u84FF\u84FC\u8559\u8548\u8568\u8564\u855E\u857A\u77A2\u8543\u8572\u857B\u85A4\u85A8\u8587\u858F\u8579\u85AE\u859C\u8585\u85B9\u85B7\u85B0\u85D3\u85C1\u85DC\u85FF\u8627\u8605\u8629\u8616\u863C\u5EFE\u5F08\u593C\u5941\u8037\u5955\u595A\u5958\u530F\u5C22\u5C25\u5C2C\u5C34\u624C\u626A\u629F\u62BB\u62CA\u62DA\u62D7\u62EE\u6322\u62F6\u6339\u634B\u6343\u63AD\u63F6\u6371\u637A\u638E\u63B4\u636D\u63AC\u638A\u6369\u63AE\u63BC\u63F2\u63F8\u63E0\u63FF\u63C4\u63DE\u63CE\u6452\u63C6\u63BE\u6445\u6441\u640B\u641B\u6420\u640C\u6426\u6421\u645E\u6484\u646D\u6496"],
      ["df40", "\u9019\u901C\u9023\u9024\u9025\u9027", 5, "\u9030", 4, "\u9037\u9039\u903A\u903D\u903F\u9040\u9043\u9045\u9046\u9048", 4, "\u904E\u9054\u9055\u9056\u9059\u905A\u905C", 5, "\u9064\u9066\u9067\u9069\u906A\u906B\u906C\u906F", 4, "\u9076", 6, "\u907E\u9081"],
      ["df80", "\u9084\u9085\u9086\u9087\u9089\u908A\u908C", 4, "\u9092\u9094\u9096\u9098\u909A\u909C\u909E\u909F\u90A0\u90A4\u90A5\u90A7\u90A8\u90A9\u90AB\u90AD\u90B2\u90B7\u90BC\u90BD\u90BF\u90C0\u647A\u64B7\u64B8\u6499\u64BA\u64C0\u64D0\u64D7\u64E4\u64E2\u6509\u6525\u652E\u5F0B\u5FD2\u7519\u5F11\u535F\u53F1\u53FD\u53E9\u53E8\u53FB\u5412\u5416\u5406\u544B\u5452\u5453\u5454\u5456\u5443\u5421\u5457\u5459\u5423\u5432\u5482\u5494\u5477\u5471\u5464\u549A\u549B\u5484\u5476\u5466\u549D\u54D0\u54AD\u54C2\u54B4\u54D2\u54A7\u54A6\u54D3\u54D4\u5472\u54A3\u54D5\u54BB\u54BF\u54CC\u54D9\u54DA\u54DC\u54A9\u54AA\u54A4\u54DD\u54CF\u54DE\u551B\u54E7\u5520\u54FD\u5514\u54F3\u5522\u5523\u550F\u5511\u5527\u552A\u5567\u558F\u55B5\u5549\u556D\u5541\u5555\u553F\u5550\u553C"],
      ["e040", "\u90C2\u90C3\u90C6\u90C8\u90C9\u90CB\u90CC\u90CD\u90D2\u90D4\u90D5\u90D6\u90D8\u90D9\u90DA\u90DE\u90DF\u90E0\u90E3\u90E4\u90E5\u90E9\u90EA\u90EC\u90EE\u90F0\u90F1\u90F2\u90F3\u90F5\u90F6\u90F7\u90F9\u90FA\u90FB\u90FC\u90FF\u9100\u9101\u9103\u9105", 19, "\u911A\u911B\u911C"],
      ["e080", "\u911D\u911F\u9120\u9121\u9124", 10, "\u9130\u9132", 6, "\u913A", 8, "\u9144\u5537\u5556\u5575\u5576\u5577\u5533\u5530\u555C\u558B\u55D2\u5583\u55B1\u55B9\u5588\u5581\u559F\u557E\u55D6\u5591\u557B\u55DF\u55BD\u55BE\u5594\u5599\u55EA\u55F7\u55C9\u561F\u55D1\u55EB\u55EC\u55D4\u55E6\u55DD\u55C4\u55EF\u55E5\u55F2\u55F3\u55CC\u55CD\u55E8\u55F5\u55E4\u8F94\u561E\u5608\u560C\u5601\u5624\u5623\u55FE\u5600\u5627\u562D\u5658\u5639\u5657\u562C\u564D\u5662\u5659\u565C\u564C\u5654\u5686\u5664\u5671\u566B\u567B\u567C\u5685\u5693\u56AF\u56D4\u56D7\u56DD\u56E1\u56F5\u56EB\u56F9\u56FF\u5704\u570A\u5709\u571C\u5E0F\u5E19\u5E14\u5E11\u5E31\u5E3B\u5E3C"],
      ["e140", "\u9145\u9147\u9148\u9151\u9153\u9154\u9155\u9156\u9158\u9159\u915B\u915C\u915F\u9160\u9166\u9167\u9168\u916B\u916D\u9173\u917A\u917B\u917C\u9180", 4, "\u9186\u9188\u918A\u918E\u918F\u9193", 6, "\u919C", 5, "\u91A4", 5, "\u91AB\u91AC\u91B0\u91B1\u91B2\u91B3\u91B6\u91B7\u91B8\u91B9\u91BB"],
      ["e180", "\u91BC", 10, "\u91C8\u91CB\u91D0\u91D2", 9, "\u91DD", 8, "\u5E37\u5E44\u5E54\u5E5B\u5E5E\u5E61\u5C8C\u5C7A\u5C8D\u5C90\u5C96\u5C88\u5C98\u5C99\u5C91\u5C9A\u5C9C\u5CB5\u5CA2\u5CBD\u5CAC\u5CAB\u5CB1\u5CA3\u5CC1\u5CB7\u5CC4\u5CD2\u5CE4\u5CCB\u5CE5\u5D02\u5D03\u5D27\u5D26\u5D2E\u5D24\u5D1E\u5D06\u5D1B\u5D58\u5D3E\u5D34\u5D3D\u5D6C\u5D5B\u5D6F\u5D5D\u5D6B\u5D4B\u5D4A\u5D69\u5D74\u5D82\u5D99\u5D9D\u8C73\u5DB7\u5DC5\u5F73\u5F77\u5F82\u5F87\u5F89\u5F8C\u5F95\u5F99\u5F9C\u5FA8\u5FAD\u5FB5\u5FBC\u8862\u5F61\u72AD\u72B0\u72B4\u72B7\u72B8\u72C3\u72C1\u72CE\u72CD\u72D2\u72E8\u72EF\u72E9\u72F2\u72F4\u72F7\u7301\u72F3\u7303\u72FA"],
      ["e240", "\u91E6", 62],
      ["e280", "\u9225", 32, "\u72FB\u7317\u7313\u7321\u730A\u731E\u731D\u7315\u7322\u7339\u7325\u732C\u7338\u7331\u7350\u734D\u7357\u7360\u736C\u736F\u737E\u821B\u5925\u98E7\u5924\u5902\u9963\u9967", 5, "\u9974\u9977\u997D\u9980\u9984\u9987\u998A\u998D\u9990\u9991\u9993\u9994\u9995\u5E80\u5E91\u5E8B\u5E96\u5EA5\u5EA0\u5EB9\u5EB5\u5EBE\u5EB3\u8D53\u5ED2\u5ED1\u5EDB\u5EE8\u5EEA\u81BA\u5FC4\u5FC9\u5FD6\u5FCF\u6003\u5FEE\u6004\u5FE1\u5FE4\u5FFE\u6005\u6006\u5FEA\u5FED\u5FF8\u6019\u6035\u6026\u601B\u600F\u600D\u6029\u602B\u600A\u603F\u6021\u6078\u6079\u607B\u607A\u6042"],
      ["e340", "\u9246", 45, "\u9275", 16],
      ["e380", "\u9286", 7, "\u928F", 24, "\u606A\u607D\u6096\u609A\u60AD\u609D\u6083\u6092\u608C\u609B\u60EC\u60BB\u60B1\u60DD\u60D8\u60C6\u60DA\u60B4\u6120\u6126\u6115\u6123\u60F4\u6100\u610E\u612B\u614A\u6175\u61AC\u6194\u61A7\u61B7\u61D4\u61F5\u5FDD\u96B3\u95E9\u95EB\u95F1\u95F3\u95F5\u95F6\u95FC\u95FE\u9603\u9604\u9606\u9608\u960A\u960B\u960C\u960D\u960F\u9612\u9615\u9616\u9617\u9619\u961A\u4E2C\u723F\u6215\u6C35\u6C54\u6C5C\u6C4A\u6CA3\u6C85\u6C90\u6C94\u6C8C\u6C68\u6C69\u6C74\u6C76\u6C86\u6CA9\u6CD0\u6CD4\u6CAD\u6CF7\u6CF8\u6CF1\u6CD7\u6CB2\u6CE0\u6CD6\u6CFA\u6CEB\u6CEE\u6CB1\u6CD3\u6CEF\u6CFE"],
      ["e440", "\u92A8", 5, "\u92AF", 24, "\u92C9", 31],
      ["e480", "\u92E9", 32, "\u6D39\u6D27\u6D0C\u6D43\u6D48\u6D07\u6D04\u6D19\u6D0E\u6D2B\u6D4D\u6D2E\u6D35\u6D1A\u6D4F\u6D52\u6D54\u6D33\u6D91\u6D6F\u6D9E\u6DA0\u6D5E\u6D93\u6D94\u6D5C\u6D60\u6D7C\u6D63\u6E1A\u6DC7\u6DC5\u6DDE\u6E0E\u6DBF\u6DE0\u6E11\u6DE6\u6DDD\u6DD9\u6E16\u6DAB\u6E0C\u6DAE\u6E2B\u6E6E\u6E4E\u6E6B\u6EB2\u6E5F\u6E86\u6E53\u6E54\u6E32\u6E25\u6E44\u6EDF\u6EB1\u6E98\u6EE0\u6F2D\u6EE2\u6EA5\u6EA7\u6EBD\u6EBB\u6EB7\u6ED7\u6EB4\u6ECF\u6E8F\u6EC2\u6E9F\u6F62\u6F46\u6F47\u6F24\u6F15\u6EF9\u6F2F\u6F36\u6F4B\u6F74\u6F2A\u6F09\u6F29\u6F89\u6F8D\u6F8C\u6F78\u6F72\u6F7C\u6F7A\u6FD1"],
      ["e540", "\u930A", 51, "\u933F", 10],
      ["e580", "\u934A", 31, "\u936B\u6FC9\u6FA7\u6FB9\u6FB6\u6FC2\u6FE1\u6FEE\u6FDE\u6FE0\u6FEF\u701A\u7023\u701B\u7039\u7035\u704F\u705E\u5B80\u5B84\u5B95\u5B93\u5BA5\u5BB8\u752F\u9A9E\u6434\u5BE4\u5BEE\u8930\u5BF0\u8E47\u8B07\u8FB6\u8FD3\u8FD5\u8FE5\u8FEE\u8FE4\u8FE9\u8FE6\u8FF3\u8FE8\u9005\u9004\u900B\u9026\u9011\u900D\u9016\u9021\u9035\u9036\u902D\u902F\u9044\u9051\u9052\u9050\u9068\u9058\u9062\u905B\u66B9\u9074\u907D\u9082\u9088\u9083\u908B\u5F50\u5F57\u5F56\u5F58\u5C3B\u54AB\u5C50\u5C59\u5B71\u5C63\u5C66\u7FBC\u5F2A\u5F29\u5F2D\u8274\u5F3C\u9B3B\u5C6E\u5981\u5983\u598D\u59A9\u59AA\u59A3"],
      ["e640", "\u936C", 34, "\u9390", 27],
      ["e680", "\u93AC", 29, "\u93CB\u93CC\u93CD\u5997\u59CA\u59AB\u599E\u59A4\u59D2\u59B2\u59AF\u59D7\u59BE\u5A05\u5A06\u59DD\u5A08\u59E3\u59D8\u59F9\u5A0C\u5A09\u5A32\u5A34\u5A11\u5A23\u5A13\u5A40\u5A67\u5A4A\u5A55\u5A3C\u5A62\u5A75\u80EC\u5AAA\u5A9B\u5A77\u5A7A\u5ABE\u5AEB\u5AB2\u5AD2\u5AD4\u5AB8\u5AE0\u5AE3\u5AF1\u5AD6\u5AE6\u5AD8\u5ADC\u5B09\u5B17\u5B16\u5B32\u5B37\u5B40\u5C15\u5C1C\u5B5A\u5B65\u5B73\u5B51\u5B53\u5B62\u9A75\u9A77\u9A78\u9A7A\u9A7F\u9A7D\u9A80\u9A81\u9A85\u9A88\u9A8A\u9A90\u9A92\u9A93\u9A96\u9A98\u9A9B\u9A9C\u9A9D\u9A9F\u9AA0\u9AA2\u9AA3\u9AA5\u9AA7\u7E9F\u7EA1\u7EA3\u7EA5\u7EA8\u7EA9"],
      ["e740", "\u93CE", 7, "\u93D7", 54],
      ["e780", "\u940E", 32, "\u7EAD\u7EB0\u7EBE\u7EC0\u7EC1\u7EC2\u7EC9\u7ECB\u7ECC\u7ED0\u7ED4\u7ED7\u7EDB\u7EE0\u7EE1\u7EE8\u7EEB\u7EEE\u7EEF\u7EF1\u7EF2\u7F0D\u7EF6\u7EFA\u7EFB\u7EFE\u7F01\u7F02\u7F03\u7F07\u7F08\u7F0B\u7F0C\u7F0F\u7F11\u7F12\u7F17\u7F19\u7F1C\u7F1B\u7F1F\u7F21", 6, "\u7F2A\u7F2B\u7F2C\u7F2D\u7F2F", 4, "\u7F35\u5E7A\u757F\u5DDB\u753E\u9095\u738E\u7391\u73AE\u73A2\u739F\u73CF\u73C2\u73D1\u73B7\u73B3\u73C0\u73C9\u73C8\u73E5\u73D9\u987C\u740A\u73E9\u73E7\u73DE\u73BA\u73F2\u740F\u742A\u745B\u7426\u7425\u7428\u7430\u742E\u742C"],
      ["e840", "\u942F", 14, "\u943F", 43, "\u946C\u946D\u946E\u946F"],
      ["e880", "\u9470", 20, "\u9491\u9496\u9498\u94C7\u94CF\u94D3\u94D4\u94DA\u94E6\u94FB\u951C\u9520\u741B\u741A\u7441\u745C\u7457\u7455\u7459\u7477\u746D\u747E\u749C\u748E\u7480\u7481\u7487\u748B\u749E\u74A8\u74A9\u7490\u74A7\u74D2\u74BA\u97EA\u97EB\u97EC\u674C\u6753\u675E\u6748\u6769\u67A5\u6787\u676A\u6773\u6798\u67A7\u6775\u67A8\u679E\u67AD\u678B\u6777\u677C\u67F0\u6809\u67D8\u680A\u67E9\u67B0\u680C\u67D9\u67B5\u67DA\u67B3\u67DD\u6800\u67C3\u67B8\u67E2\u680E\u67C1\u67FD\u6832\u6833\u6860\u6861\u684E\u6862\u6844\u6864\u6883\u681D\u6855\u6866\u6841\u6867\u6840\u683E\u684A\u6849\u6829\u68B5\u688F\u6874\u6877\u6893\u686B\u68C2\u696E\u68FC\u691F\u6920\u68F9"],
      ["e940", "\u9527\u9533\u953D\u9543\u9548\u954B\u9555\u955A\u9560\u956E\u9574\u9575\u9577", 7, "\u9580", 42],
      ["e980", "\u95AB", 32, "\u6924\u68F0\u690B\u6901\u6957\u68E3\u6910\u6971\u6939\u6960\u6942\u695D\u6984\u696B\u6980\u6998\u6978\u6934\u69CC\u6987\u6988\u69CE\u6989\u6966\u6963\u6979\u699B\u69A7\u69BB\u69AB\u69AD\u69D4\u69B1\u69C1\u69CA\u69DF\u6995\u69E0\u698D\u69FF\u6A2F\u69ED\u6A17\u6A18\u6A65\u69F2\u6A44\u6A3E\u6AA0\u6A50\u6A5B\u6A35\u6A8E\u6A79\u6A3D\u6A28\u6A58\u6A7C\u6A91\u6A90\u6AA9\u6A97\u6AAB\u7337\u7352\u6B81\u6B82\u6B87\u6B84\u6B92\u6B93\u6B8D\u6B9A\u6B9B\u6BA1\u6BAA\u8F6B\u8F6D\u8F71\u8F72\u8F73\u8F75\u8F76\u8F78\u8F77\u8F79\u8F7A\u8F7C\u8F7E\u8F81\u8F82\u8F84\u8F87\u8F8B"],
      ["ea40", "\u95CC", 27, "\u95EC\u95FF\u9607\u9613\u9618\u961B\u961E\u9620\u9623", 6, "\u962B\u962C\u962D\u962F\u9630\u9637\u9638\u9639\u963A\u963E\u9641\u9643\u964A\u964E\u964F\u9651\u9652\u9653\u9656\u9657"],
      ["ea80", "\u9658\u9659\u965A\u965C\u965D\u965E\u9660\u9663\u9665\u9666\u966B\u966D", 4, "\u9673\u9678", 12, "\u9687\u9689\u968A\u8F8D\u8F8E\u8F8F\u8F98\u8F9A\u8ECE\u620B\u6217\u621B\u621F\u6222\u6221\u6225\u6224\u622C\u81E7\u74EF\u74F4\u74FF\u750F\u7511\u7513\u6534\u65EE\u65EF\u65F0\u660A\u6619\u6772\u6603\u6615\u6600\u7085\u66F7\u661D\u6634\u6631\u6636\u6635\u8006\u665F\u6654\u6641\u664F\u6656\u6661\u6657\u6677\u6684\u668C\u66A7\u669D\u66BE\u66DB\u66DC\u66E6\u66E9\u8D32\u8D33\u8D36\u8D3B\u8D3D\u8D40\u8D45\u8D46\u8D48\u8D49\u8D47\u8D4D\u8D55\u8D59\u89C7\u89CA\u89CB\u89CC\u89CE\u89CF\u89D0\u89D1\u726E\u729F\u725D\u7266\u726F\u727E\u727F\u7284\u728B\u728D\u728F\u7292\u6308\u6332\u63B0"],
      ["eb40", "\u968C\u968E\u9691\u9692\u9693\u9695\u9696\u969A\u969B\u969D", 9, "\u96A8", 7, "\u96B1\u96B2\u96B4\u96B5\u96B7\u96B8\u96BA\u96BB\u96BF\u96C2\u96C3\u96C8\u96CA\u96CB\u96D0\u96D1\u96D3\u96D4\u96D6", 9, "\u96E1", 6, "\u96EB"],
      ["eb80", "\u96EC\u96ED\u96EE\u96F0\u96F1\u96F2\u96F4\u96F5\u96F8\u96FA\u96FB\u96FC\u96FD\u96FF\u9702\u9703\u9705\u970A\u970B\u970C\u9710\u9711\u9712\u9714\u9715\u9717", 4, "\u971D\u971F\u9720\u643F\u64D8\u8004\u6BEA\u6BF3\u6BFD\u6BF5\u6BF9\u6C05\u6C07\u6C06\u6C0D\u6C15\u6C18\u6C19\u6C1A\u6C21\u6C29\u6C24\u6C2A\u6C32\u6535\u6555\u656B\u724D\u7252\u7256\u7230\u8662\u5216\u809F\u809C\u8093\u80BC\u670A\u80BD\u80B1\u80AB\u80AD\u80B4\u80B7\u80E7\u80E8\u80E9\u80EA\u80DB\u80C2\u80C4\u80D9\u80CD\u80D7\u6710\u80DD\u80EB\u80F1\u80F4\u80ED\u810D\u810E\u80F2\u80FC\u6715\u8112\u8C5A\u8136\u811E\u812C\u8118\u8132\u8148\u814C\u8153\u8174\u8159\u815A\u8171\u8160\u8169\u817C\u817D\u816D\u8167\u584D\u5AB5\u8188\u8182\u8191\u6ED5\u81A3\u81AA\u81CC\u6726\u81CA\u81BB"],
      ["ec40", "\u9721", 8, "\u972B\u972C\u972E\u972F\u9731\u9733", 4, "\u973A\u973B\u973C\u973D\u973F", 18, "\u9754\u9755\u9757\u9758\u975A\u975C\u975D\u975F\u9763\u9764\u9766\u9767\u9768\u976A", 7],
      ["ec80", "\u9772\u9775\u9777", 4, "\u977D", 7, "\u9786", 4, "\u978C\u978E\u978F\u9790\u9793\u9795\u9796\u9797\u9799", 4, "\u81C1\u81A6\u6B24\u6B37\u6B39\u6B43\u6B46\u6B59\u98D1\u98D2\u98D3\u98D5\u98D9\u98DA\u6BB3\u5F40\u6BC2\u89F3\u6590\u9F51\u6593\u65BC\u65C6\u65C4\u65C3\u65CC\u65CE\u65D2\u65D6\u7080\u709C\u7096\u709D\u70BB\u70C0\u70B7\u70AB\u70B1\u70E8\u70CA\u7110\u7113\u7116\u712F\u7131\u7173\u715C\u7168\u7145\u7172\u714A\u7178\u717A\u7198\u71B3\u71B5\u71A8\u71A0\u71E0\u71D4\u71E7\u71F9\u721D\u7228\u706C\u7118\u7166\u71B9\u623E\u623D\u6243\u6248\u6249\u793B\u7940\u7946\u7949\u795B\u795C\u7953\u795A\u7962\u7957\u7960\u796F\u7967\u797A\u7985\u798A\u799A\u79A7\u79B3\u5FD1\u5FD0"],
      ["ed40", "\u979E\u979F\u97A1\u97A2\u97A4", 6, "\u97AC\u97AE\u97B0\u97B1\u97B3\u97B5", 46],
      ["ed80", "\u97E4\u97E5\u97E8\u97EE", 4, "\u97F4\u97F7", 23, "\u603C\u605D\u605A\u6067\u6041\u6059\u6063\u60AB\u6106\u610D\u615D\u61A9\u619D\u61CB\u61D1\u6206\u8080\u807F\u6C93\u6CF6\u6DFC\u77F6\u77F8\u7800\u7809\u7817\u7818\u7811\u65AB\u782D\u781C\u781D\u7839\u783A\u783B\u781F\u783C\u7825\u782C\u7823\u7829\u784E\u786D\u7856\u7857\u7826\u7850\u7847\u784C\u786A\u789B\u7893\u789A\u7887\u789C\u78A1\u78A3\u78B2\u78B9\u78A5\u78D4\u78D9\u78C9\u78EC\u78F2\u7905\u78F4\u7913\u7924\u791E\u7934\u9F9B\u9EF9\u9EFB\u9EFC\u76F1\u7704\u770D\u76F9\u7707\u7708\u771A\u7722\u7719\u772D\u7726\u7735\u7738\u7750\u7751\u7747\u7743\u775A\u7768"],
      ["ee40", "\u980F", 62],
      ["ee80", "\u984E", 32, "\u7762\u7765\u777F\u778D\u777D\u7780\u778C\u7791\u779F\u77A0\u77B0\u77B5\u77BD\u753A\u7540\u754E\u754B\u7548\u755B\u7572\u7579\u7583\u7F58\u7F61\u7F5F\u8A48\u7F68\u7F74\u7F71\u7F79\u7F81\u7F7E\u76CD\u76E5\u8832\u9485\u9486\u9487\u948B\u948A\u948C\u948D\u948F\u9490\u9494\u9497\u9495\u949A\u949B\u949C\u94A3\u94A4\u94AB\u94AA\u94AD\u94AC\u94AF\u94B0\u94B2\u94B4\u94B6", 4, "\u94BC\u94BD\u94BF\u94C4\u94C8", 6, "\u94D0\u94D1\u94D2\u94D5\u94D6\u94D7\u94D9\u94D8\u94DB\u94DE\u94DF\u94E0\u94E2\u94E4\u94E5\u94E7\u94E8\u94EA"],
      ["ef40", "\u986F", 5, "\u988B\u988E\u9892\u9895\u9899\u98A3\u98A8", 37, "\u98CF\u98D0\u98D4\u98D6\u98D7\u98DB\u98DC\u98DD\u98E0", 4],
      ["ef80", "\u98E5\u98E6\u98E9", 30, "\u94E9\u94EB\u94EE\u94EF\u94F3\u94F4\u94F5\u94F7\u94F9\u94FC\u94FD\u94FF\u9503\u9502\u9506\u9507\u9509\u950A\u950D\u950E\u950F\u9512", 4, "\u9518\u951B\u951D\u951E\u951F\u9522\u952A\u952B\u9529\u952C\u9531\u9532\u9534\u9536\u9537\u9538\u953C\u953E\u953F\u9542\u9535\u9544\u9545\u9546\u9549\u954C\u954E\u954F\u9552\u9553\u9554\u9556\u9557\u9558\u9559\u955B\u955E\u955F\u955D\u9561\u9562\u9564", 8, "\u956F\u9571\u9572\u9573\u953A\u77E7\u77EC\u96C9\u79D5\u79ED\u79E3\u79EB\u7A06\u5D47\u7A03\u7A02\u7A1E\u7A14"],
      ["f040", "\u9908", 4, "\u990E\u990F\u9911", 28, "\u992F", 26],
      ["f080", "\u994A", 9, "\u9956", 12, "\u9964\u9966\u9973\u9978\u9979\u997B\u997E\u9982\u9983\u9989\u7A39\u7A37\u7A51\u9ECF\u99A5\u7A70\u7688\u768E\u7693\u7699\u76A4\u74DE\u74E0\u752C\u9E20\u9E22\u9E28", 4, "\u9E32\u9E31\u9E36\u9E38\u9E37\u9E39\u9E3A\u9E3E\u9E41\u9E42\u9E44\u9E46\u9E47\u9E48\u9E49\u9E4B\u9E4C\u9E4E\u9E51\u9E55\u9E57\u9E5A\u9E5B\u9E5C\u9E5E\u9E63\u9E66", 6, "\u9E71\u9E6D\u9E73\u7592\u7594\u7596\u75A0\u759D\u75AC\u75A3\u75B3\u75B4\u75B8\u75C4\u75B1\u75B0\u75C3\u75C2\u75D6\u75CD\u75E3\u75E8\u75E6\u75E4\u75EB\u75E7\u7603\u75F1\u75FC\u75FF\u7610\u7600\u7605\u760C\u7617\u760A\u7625\u7618\u7615\u7619"],
      ["f140", "\u998C\u998E\u999A", 10, "\u99A6\u99A7\u99A9", 47],
      ["f180", "\u99D9", 32, "\u761B\u763C\u7622\u7620\u7640\u762D\u7630\u763F\u7635\u7643\u763E\u7633\u764D\u765E\u7654\u765C\u7656\u766B\u766F\u7FCA\u7AE6\u7A78\u7A79\u7A80\u7A86\u7A88\u7A95\u7AA6\u7AA0\u7AAC\u7AA8\u7AAD\u7AB3\u8864\u8869\u8872\u887D\u887F\u8882\u88A2\u88C6\u88B7\u88BC\u88C9\u88E2\u88CE\u88E3\u88E5\u88F1\u891A\u88FC\u88E8\u88FE\u88F0\u8921\u8919\u8913\u891B\u890A\u8934\u892B\u8936\u8941\u8966\u897B\u758B\u80E5\u76B2\u76B4\u77DC\u8012\u8014\u8016\u801C\u8020\u8022\u8025\u8026\u8027\u8029\u8028\u8031\u800B\u8035\u8043\u8046\u804D\u8052\u8069\u8071\u8983\u9878\u9880\u9883"],
      ["f240", "\u99FA", 62],
      ["f280", "\u9A39", 32, "\u9889\u988C\u988D\u988F\u9894\u989A\u989B\u989E\u989F\u98A1\u98A2\u98A5\u98A6\u864D\u8654\u866C\u866E\u867F\u867A\u867C\u867B\u86A8\u868D\u868B\u86AC\u869D\u86A7\u86A3\u86AA\u8693\u86A9\u86B6\u86C4\u86B5\u86CE\u86B0\u86BA\u86B1\u86AF\u86C9\u86CF\u86B4\u86E9\u86F1\u86F2\u86ED\u86F3\u86D0\u8713\u86DE\u86F4\u86DF\u86D8\u86D1\u8703\u8707\u86F8\u8708\u870A\u870D\u8709\u8723\u873B\u871E\u8725\u872E\u871A\u873E\u8748\u8734\u8731\u8729\u8737\u873F\u8782\u8722\u877D\u877E\u877B\u8760\u8770\u874C\u876E\u878B\u8753\u8763\u877C\u8764\u8759\u8765\u8793\u87AF\u87A8\u87D2"],
      ["f340", "\u9A5A", 17, "\u9A72\u9A83\u9A89\u9A8D\u9A8E\u9A94\u9A95\u9A99\u9AA6\u9AA9", 6, "\u9AB2\u9AB3\u9AB4\u9AB5\u9AB9\u9ABB\u9ABD\u9ABE\u9ABF\u9AC3\u9AC4\u9AC6", 4, "\u9ACD\u9ACE\u9ACF\u9AD0\u9AD2\u9AD4\u9AD5\u9AD6\u9AD7\u9AD9\u9ADA\u9ADB\u9ADC"],
      ["f380", "\u9ADD\u9ADE\u9AE0\u9AE2\u9AE3\u9AE4\u9AE5\u9AE7\u9AE8\u9AE9\u9AEA\u9AEC\u9AEE\u9AF0", 8, "\u9AFA\u9AFC", 6, "\u9B04\u9B05\u9B06\u87C6\u8788\u8785\u87AD\u8797\u8783\u87AB\u87E5\u87AC\u87B5\u87B3\u87CB\u87D3\u87BD\u87D1\u87C0\u87CA\u87DB\u87EA\u87E0\u87EE\u8816\u8813\u87FE\u880A\u881B\u8821\u8839\u883C\u7F36\u7F42\u7F44\u7F45\u8210\u7AFA\u7AFD\u7B08\u7B03\u7B04\u7B15\u7B0A\u7B2B\u7B0F\u7B47\u7B38\u7B2A\u7B19\u7B2E\u7B31\u7B20\u7B25\u7B24\u7B33\u7B3E\u7B1E\u7B58\u7B5A\u7B45\u7B75\u7B4C\u7B5D\u7B60\u7B6E\u7B7B\u7B62\u7B72\u7B71\u7B90\u7BA6\u7BA7\u7BB8\u7BAC\u7B9D\u7BA8\u7B85\u7BAA\u7B9C\u7BA2\u7BAB\u7BB4\u7BD1\u7BC1\u7BCC\u7BDD\u7BDA\u7BE5\u7BE6\u7BEA\u7C0C\u7BFE\u7BFC\u7C0F\u7C16\u7C0B"],
      ["f440", "\u9B07\u9B09", 5, "\u9B10\u9B11\u9B12\u9B14", 10, "\u9B20\u9B21\u9B22\u9B24", 10, "\u9B30\u9B31\u9B33", 7, "\u9B3D\u9B3E\u9B3F\u9B40\u9B46\u9B4A\u9B4B\u9B4C\u9B4E\u9B50\u9B52\u9B53\u9B55", 5],
      ["f480", "\u9B5B", 32, "\u7C1F\u7C2A\u7C26\u7C38\u7C41\u7C40\u81FE\u8201\u8202\u8204\u81EC\u8844\u8221\u8222\u8223\u822D\u822F\u8228\u822B\u8238\u823B\u8233\u8234\u823E\u8244\u8249\u824B\u824F\u825A\u825F\u8268\u887E\u8885\u8888\u88D8\u88DF\u895E\u7F9D\u7F9F\u7FA7\u7FAF\u7FB0\u7FB2\u7C7C\u6549\u7C91\u7C9D\u7C9C\u7C9E\u7CA2\u7CB2\u7CBC\u7CBD\u7CC1\u7CC7\u7CCC\u7CCD\u7CC8\u7CC5\u7CD7\u7CE8\u826E\u66A8\u7FBF\u7FCE\u7FD5\u7FE5\u7FE1\u7FE6\u7FE9\u7FEE\u7FF3\u7CF8\u7D77\u7DA6\u7DAE\u7E47\u7E9B\u9EB8\u9EB4\u8D73\u8D84\u8D94\u8D91\u8DB1\u8D67\u8D6D\u8C47\u8C49\u914A\u9150\u914E\u914F\u9164"],
      ["f540", "\u9B7C", 62],
      ["f580", "\u9BBB", 32, "\u9162\u9161\u9170\u9169\u916F\u917D\u917E\u9172\u9174\u9179\u918C\u9185\u9190\u918D\u9191\u91A2\u91A3\u91AA\u91AD\u91AE\u91AF\u91B5\u91B4\u91BA\u8C55\u9E7E\u8DB8\u8DEB\u8E05\u8E59\u8E69\u8DB5\u8DBF\u8DBC\u8DBA\u8DC4\u8DD6\u8DD7\u8DDA\u8DDE\u8DCE\u8DCF\u8DDB\u8DC6\u8DEC\u8DF7\u8DF8\u8DE3\u8DF9\u8DFB\u8DE4\u8E09\u8DFD\u8E14\u8E1D\u8E1F\u8E2C\u8E2E\u8E23\u8E2F\u8E3A\u8E40\u8E39\u8E35\u8E3D\u8E31\u8E49\u8E41\u8E42\u8E51\u8E52\u8E4A\u8E70\u8E76\u8E7C\u8E6F\u8E74\u8E85\u8E8F\u8E94\u8E90\u8E9C\u8E9E\u8C78\u8C82\u8C8A\u8C85\u8C98\u8C94\u659B\u89D6\u89DE\u89DA\u89DC"],
      ["f640", "\u9BDC", 62],
      ["f680", "\u9C1B", 32, "\u89E5\u89EB\u89EF\u8A3E\u8B26\u9753\u96E9\u96F3\u96EF\u9706\u9701\u9708\u970F\u970E\u972A\u972D\u9730\u973E\u9F80\u9F83\u9F85", 5, "\u9F8C\u9EFE\u9F0B\u9F0D\u96B9\u96BC\u96BD\u96CE\u96D2\u77BF\u96E0\u928E\u92AE\u92C8\u933E\u936A\u93CA\u938F\u943E\u946B\u9C7F\u9C82\u9C85\u9C86\u9C87\u9C88\u7A23\u9C8B\u9C8E\u9C90\u9C91\u9C92\u9C94\u9C95\u9C9A\u9C9B\u9C9E", 5, "\u9CA5", 4, "\u9CAB\u9CAD\u9CAE\u9CB0", 7, "\u9CBA\u9CBB\u9CBC\u9CBD\u9CC4\u9CC5\u9CC6\u9CC7\u9CCA\u9CCB"],
      ["f740", "\u9C3C", 62],
      ["f780", "\u9C7B\u9C7D\u9C7E\u9C80\u9C83\u9C84\u9C89\u9C8A\u9C8C\u9C8F\u9C93\u9C96\u9C97\u9C98\u9C99\u9C9D\u9CAA\u9CAC\u9CAF\u9CB9\u9CBE", 4, "\u9CC8\u9CC9\u9CD1\u9CD2\u9CDA\u9CDB\u9CE0\u9CE1\u9CCC", 4, "\u9CD3\u9CD4\u9CD5\u9CD7\u9CD8\u9CD9\u9CDC\u9CDD\u9CDF\u9CE2\u977C\u9785\u9791\u9792\u9794\u97AF\u97AB\u97A3\u97B2\u97B4\u9AB1\u9AB0\u9AB7\u9E58\u9AB6\u9ABA\u9ABC\u9AC1\u9AC0\u9AC5\u9AC2\u9ACB\u9ACC\u9AD1\u9B45\u9B43\u9B47\u9B49\u9B48\u9B4D\u9B51\u98E8\u990D\u992E\u9955\u9954\u9ADF\u9AE1\u9AE6\u9AEF\u9AEB\u9AFB\u9AED\u9AF9\u9B08\u9B0F\u9B13\u9B1F\u9B23\u9EBD\u9EBE\u7E3B\u9E82\u9E87\u9E88\u9E8B\u9E92\u93D6\u9E9D\u9E9F\u9EDB\u9EDC\u9EDD\u9EE0\u9EDF\u9EE2\u9EE9\u9EE7\u9EE5\u9EEA\u9EEF\u9F22\u9F2C\u9F2F\u9F39\u9F37\u9F3D\u9F3E\u9F44"],
      ["f840", "\u9CE3", 62],
      ["f880", "\u9D22", 32],
      ["f940", "\u9D43", 62],
      ["f980", "\u9D82", 32],
      ["fa40", "\u9DA3", 62],
      ["fa80", "\u9DE2", 32],
      ["fb40", "\u9E03", 27, "\u9E24\u9E27\u9E2E\u9E30\u9E34\u9E3B\u9E3C\u9E40\u9E4D\u9E50\u9E52\u9E53\u9E54\u9E56\u9E59\u9E5D\u9E5F\u9E60\u9E61\u9E62\u9E65\u9E6E\u9E6F\u9E72\u9E74", 9, "\u9E80"],
      ["fb80", "\u9E81\u9E83\u9E84\u9E85\u9E86\u9E89\u9E8A\u9E8C", 5, "\u9E94", 8, "\u9E9E\u9EA0", 5, "\u9EA7\u9EA8\u9EA9\u9EAA"],
      ["fc40", "\u9EAB", 8, "\u9EB5\u9EB6\u9EB7\u9EB9\u9EBA\u9EBC\u9EBF", 4, "\u9EC5\u9EC6\u9EC7\u9EC8\u9ECA\u9ECB\u9ECC\u9ED0\u9ED2\u9ED3\u9ED5\u9ED6\u9ED7\u9ED9\u9EDA\u9EDE\u9EE1\u9EE3\u9EE4\u9EE6\u9EE8\u9EEB\u9EEC\u9EED\u9EEE\u9EF0", 8, "\u9EFA\u9EFD\u9EFF", 6],
      ["fc80", "\u9F06", 4, "\u9F0C\u9F0F\u9F11\u9F12\u9F14\u9F15\u9F16\u9F18\u9F1A", 5, "\u9F21\u9F23", 8, "\u9F2D\u9F2E\u9F30\u9F31"],
      ["fd40", "\u9F32", 4, "\u9F38\u9F3A\u9F3C\u9F3F", 4, "\u9F45", 10, "\u9F52", 38],
      ["fd80", "\u9F79", 5, "\u9F81\u9F82\u9F8D", 11, "\u9F9C\u9F9D\u9F9E\u9FA1", 4, "\uF92C\uF979\uF995\uF9E7\uF9F1"],
      ["fe40", "\uFA0C\uFA0D\uFA0E\uFA0F\uFA11\uFA13\uFA14\uFA18\uFA1F\uFA20\uFA21\uFA23\uFA24\uFA27\uFA28\uFA29"]
    ];
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/tables/gbk-added.json
var require_gbk_added2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/tables/gbk-added.json"(exports2, module2) {
    module2.exports = [
      ["a140", "\uE4C6", 62],
      ["a180", "\uE505", 32],
      ["a240", "\uE526", 62],
      ["a280", "\uE565", 32],
      ["a2ab", "\uE766", 5],
      ["a2e3", "\u20AC\uE76D"],
      ["a2ef", "\uE76E\uE76F"],
      ["a2fd", "\uE770\uE771"],
      ["a340", "\uE586", 62],
      ["a380", "\uE5C5", 31, "\u3000"],
      ["a440", "\uE5E6", 62],
      ["a480", "\uE625", 32],
      ["a4f4", "\uE772", 10],
      ["a540", "\uE646", 62],
      ["a580", "\uE685", 32],
      ["a5f7", "\uE77D", 7],
      ["a640", "\uE6A6", 62],
      ["a680", "\uE6E5", 32],
      ["a6b9", "\uE785", 7],
      ["a6d9", "\uE78D", 6],
      ["a6ec", "\uE794\uE795"],
      ["a6f3", "\uE796"],
      ["a6f6", "\uE797", 8],
      ["a740", "\uE706", 62],
      ["a780", "\uE745", 32],
      ["a7c2", "\uE7A0", 14],
      ["a7f2", "\uE7AF", 12],
      ["a896", "\uE7BC", 10],
      ["a8bc", "\uE7C7"],
      ["a8bf", "\u01F9"],
      ["a8c1", "\uE7C9\uE7CA\uE7CB\uE7CC"],
      ["a8ea", "\uE7CD", 20],
      ["a958", "\uE7E2"],
      ["a95b", "\uE7E3"],
      ["a95d", "\uE7E4\uE7E5\uE7E6"],
      ["a989", "\u303E\u2FF0", 11],
      ["a997", "\uE7F4", 12],
      ["a9f0", "\uE801", 14],
      ["aaa1", "\uE000", 93],
      ["aba1", "\uE05E", 93],
      ["aca1", "\uE0BC", 93],
      ["ada1", "\uE11A", 93],
      ["aea1", "\uE178", 93],
      ["afa1", "\uE1D6", 93],
      ["d7fa", "\uE810", 4],
      ["f8a1", "\uE234", 93],
      ["f9a1", "\uE292", 93],
      ["faa1", "\uE2F0", 93],
      ["fba1", "\uE34E", 93],
      ["fca1", "\uE3AC", 93],
      ["fda1", "\uE40A", 93],
      ["fe50", "\u2E81\uE816\uE817\uE818\u2E84\u3473\u3447\u2E88\u2E8B\uE81E\u359E\u361A\u360E\u2E8C\u2E97\u396E\u3918\uE826\u39CF\u39DF\u3A73\u39D0\uE82B\uE82C\u3B4E\u3C6E\u3CE0\u2EA7\uE831\uE832\u2EAA\u4056\u415F\u2EAE\u4337\u2EB3\u2EB6\u2EB7\uE83B\u43B1\u43AC\u2EBB\u43DD\u44D6\u4661\u464C\uE843"],
      ["fe80", "\u4723\u4729\u477C\u478D\u2ECA\u4947\u497A\u497D\u4982\u4983\u4985\u4986\u499F\u499B\u49B7\u49B6\uE854\uE855\u4CA3\u4C9F\u4CA0\u4CA1\u4C77\u4CA2\u4D13", 6, "\u4DAE\uE864\uE468", 93]
    ];
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json
var require_gb18030_ranges2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json"(exports2, module2) {
    module2.exports = { uChars: [128, 165, 169, 178, 184, 216, 226, 235, 238, 244, 248, 251, 253, 258, 276, 284, 300, 325, 329, 334, 364, 463, 465, 467, 469, 471, 473, 475, 477, 506, 594, 610, 712, 716, 730, 930, 938, 962, 970, 1026, 1104, 1106, 8209, 8215, 8218, 8222, 8231, 8241, 8244, 8246, 8252, 8365, 8452, 8454, 8458, 8471, 8482, 8556, 8570, 8596, 8602, 8713, 8720, 8722, 8726, 8731, 8737, 8740, 8742, 8748, 8751, 8760, 8766, 8777, 8781, 8787, 8802, 8808, 8816, 8854, 8858, 8870, 8896, 8979, 9322, 9372, 9548, 9588, 9616, 9622, 9634, 9652, 9662, 9672, 9676, 9680, 9702, 9735, 9738, 9793, 9795, 11906, 11909, 11913, 11917, 11928, 11944, 11947, 11951, 11956, 11960, 11964, 11979, 12284, 12292, 12312, 12319, 12330, 12351, 12436, 12447, 12535, 12543, 12586, 12842, 12850, 12964, 13200, 13215, 13218, 13253, 13263, 13267, 13270, 13384, 13428, 13727, 13839, 13851, 14617, 14703, 14801, 14816, 14964, 15183, 15471, 15585, 16471, 16736, 17208, 17325, 17330, 17374, 17623, 17997, 18018, 18212, 18218, 18301, 18318, 18760, 18811, 18814, 18820, 18823, 18844, 18848, 18872, 19576, 19620, 19738, 19887, 40870, 59244, 59336, 59367, 59413, 59417, 59423, 59431, 59437, 59443, 59452, 59460, 59478, 59493, 63789, 63866, 63894, 63976, 63986, 64016, 64018, 64021, 64025, 64034, 64037, 64042, 65074, 65093, 65107, 65112, 65127, 65132, 65375, 65510, 65536], gbChars: [0, 36, 38, 45, 50, 81, 89, 95, 96, 100, 103, 104, 105, 109, 126, 133, 148, 172, 175, 179, 208, 306, 307, 308, 309, 310, 311, 312, 313, 341, 428, 443, 544, 545, 558, 741, 742, 749, 750, 805, 819, 820, 7922, 7924, 7925, 7927, 7934, 7943, 7944, 7945, 7950, 8062, 8148, 8149, 8152, 8164, 8174, 8236, 8240, 8262, 8264, 8374, 8380, 8381, 8384, 8388, 8390, 8392, 8393, 8394, 8396, 8401, 8406, 8416, 8419, 8424, 8437, 8439, 8445, 8482, 8485, 8496, 8521, 8603, 8936, 8946, 9046, 9050, 9063, 9066, 9076, 9092, 9100, 9108, 9111, 9113, 9131, 9162, 9164, 9218, 9219, 11329, 11331, 11334, 11336, 11346, 11361, 11363, 11366, 11370, 11372, 11375, 11389, 11682, 11686, 11687, 11692, 11694, 11714, 11716, 11723, 11725, 11730, 11736, 11982, 11989, 12102, 12336, 12348, 12350, 12384, 12393, 12395, 12397, 12510, 12553, 12851, 12962, 12973, 13738, 13823, 13919, 13933, 14080, 14298, 14585, 14698, 15583, 15847, 16318, 16434, 16438, 16481, 16729, 17102, 17122, 17315, 17320, 17402, 17418, 17859, 17909, 17911, 17915, 17916, 17936, 17939, 17961, 18664, 18703, 18814, 18962, 19043, 33469, 33470, 33471, 33484, 33485, 33490, 33497, 33501, 33505, 33513, 33520, 33536, 33550, 37845, 37921, 37948, 38029, 38038, 38064, 38065, 38066, 38069, 38075, 38076, 38078, 39108, 39109, 39113, 39114, 39115, 39116, 39265, 39394, 189e3] };
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/tables/cp949.json
var require_cp9492 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/tables/cp949.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127],
      ["8141", "\uAC02\uAC03\uAC05\uAC06\uAC0B", 4, "\uAC18\uAC1E\uAC1F\uAC21\uAC22\uAC23\uAC25", 6, "\uAC2E\uAC32\uAC33\uAC34"],
      ["8161", "\uAC35\uAC36\uAC37\uAC3A\uAC3B\uAC3D\uAC3E\uAC3F\uAC41", 9, "\uAC4C\uAC4E", 5, "\uAC55"],
      ["8181", "\uAC56\uAC57\uAC59\uAC5A\uAC5B\uAC5D", 18, "\uAC72\uAC73\uAC75\uAC76\uAC79\uAC7B", 4, "\uAC82\uAC87\uAC88\uAC8D\uAC8E\uAC8F\uAC91\uAC92\uAC93\uAC95", 6, "\uAC9E\uACA2", 5, "\uACAB\uACAD\uACAE\uACB1", 6, "\uACBA\uACBE\uACBF\uACC0\uACC2\uACC3\uACC5\uACC6\uACC7\uACC9\uACCA\uACCB\uACCD", 7, "\uACD6\uACD8", 7, "\uACE2\uACE3\uACE5\uACE6\uACE9\uACEB\uACED\uACEE\uACF2\uACF4\uACF7", 4, "\uACFE\uACFF\uAD01\uAD02\uAD03\uAD05\uAD07", 4, "\uAD0E\uAD10\uAD12\uAD13"],
      ["8241", "\uAD14\uAD15\uAD16\uAD17\uAD19\uAD1A\uAD1B\uAD1D\uAD1E\uAD1F\uAD21", 7, "\uAD2A\uAD2B\uAD2E", 5],
      ["8261", "\uAD36\uAD37\uAD39\uAD3A\uAD3B\uAD3D", 6, "\uAD46\uAD48\uAD4A", 5, "\uAD51\uAD52\uAD53\uAD55\uAD56\uAD57"],
      ["8281", "\uAD59", 7, "\uAD62\uAD64", 7, "\uAD6E\uAD6F\uAD71\uAD72\uAD77\uAD78\uAD79\uAD7A\uAD7E\uAD80\uAD83", 4, "\uAD8A\uAD8B\uAD8D\uAD8E\uAD8F\uAD91", 10, "\uAD9E", 5, "\uADA5", 17, "\uADB8", 7, "\uADC2\uADC3\uADC5\uADC6\uADC7\uADC9", 6, "\uADD2\uADD4", 7, "\uADDD\uADDE\uADDF\uADE1\uADE2\uADE3\uADE5", 18],
      ["8341", "\uADFA\uADFB\uADFD\uADFE\uAE02", 5, "\uAE0A\uAE0C\uAE0E", 5, "\uAE15", 7],
      ["8361", "\uAE1D", 18, "\uAE32\uAE33\uAE35\uAE36\uAE39\uAE3B\uAE3C"],
      ["8381", "\uAE3D\uAE3E\uAE3F\uAE42\uAE44\uAE47\uAE48\uAE49\uAE4B\uAE4F\uAE51\uAE52\uAE53\uAE55\uAE57", 4, "\uAE5E\uAE62\uAE63\uAE64\uAE66\uAE67\uAE6A\uAE6B\uAE6D\uAE6E\uAE6F\uAE71", 6, "\uAE7A\uAE7E", 5, "\uAE86", 5, "\uAE8D", 46, "\uAEBF\uAEC1\uAEC2\uAEC3\uAEC5", 6, "\uAECE\uAED2", 5, "\uAEDA\uAEDB\uAEDD", 8],
      ["8441", "\uAEE6\uAEE7\uAEE9\uAEEA\uAEEC\uAEEE", 5, "\uAEF5\uAEF6\uAEF7\uAEF9\uAEFA\uAEFB\uAEFD", 8],
      ["8461", "\uAF06\uAF09\uAF0A\uAF0B\uAF0C\uAF0E\uAF0F\uAF11", 18],
      ["8481", "\uAF24", 7, "\uAF2E\uAF2F\uAF31\uAF33\uAF35", 6, "\uAF3E\uAF40\uAF44\uAF45\uAF46\uAF47\uAF4A", 5, "\uAF51", 10, "\uAF5E", 5, "\uAF66", 18, "\uAF7A", 5, "\uAF81\uAF82\uAF83\uAF85\uAF86\uAF87\uAF89", 6, "\uAF92\uAF93\uAF94\uAF96", 5, "\uAF9D", 26, "\uAFBA\uAFBB\uAFBD\uAFBE"],
      ["8541", "\uAFBF\uAFC1", 5, "\uAFCA\uAFCC\uAFCF", 4, "\uAFD5", 6, "\uAFDD", 4],
      ["8561", "\uAFE2", 5, "\uAFEA", 5, "\uAFF2\uAFF3\uAFF5\uAFF6\uAFF7\uAFF9", 6, "\uB002\uB003"],
      ["8581", "\uB005", 6, "\uB00D\uB00E\uB00F\uB011\uB012\uB013\uB015", 6, "\uB01E", 9, "\uB029", 26, "\uB046\uB047\uB049\uB04B\uB04D\uB04F\uB050\uB051\uB052\uB056\uB058\uB05A\uB05B\uB05C\uB05E", 29, "\uB07E\uB07F\uB081\uB082\uB083\uB085", 6, "\uB08E\uB090\uB092", 5, "\uB09B\uB09D\uB09E\uB0A3\uB0A4"],
      ["8641", "\uB0A5\uB0A6\uB0A7\uB0AA\uB0B0\uB0B2\uB0B6\uB0B7\uB0B9\uB0BA\uB0BB\uB0BD", 6, "\uB0C6\uB0CA", 5, "\uB0D2"],
      ["8661", "\uB0D3\uB0D5\uB0D6\uB0D7\uB0D9", 6, "\uB0E1\uB0E2\uB0E3\uB0E4\uB0E6", 10],
      ["8681", "\uB0F1", 22, "\uB10A\uB10D\uB10E\uB10F\uB111\uB114\uB115\uB116\uB117\uB11A\uB11E", 4, "\uB126\uB127\uB129\uB12A\uB12B\uB12D", 6, "\uB136\uB13A", 5, "\uB142\uB143\uB145\uB146\uB147\uB149", 6, "\uB152\uB153\uB156\uB157\uB159\uB15A\uB15B\uB15D\uB15E\uB15F\uB161", 22, "\uB17A\uB17B\uB17D\uB17E\uB17F\uB181\uB183", 4, "\uB18A\uB18C\uB18E\uB18F\uB190\uB191\uB195\uB196\uB197\uB199\uB19A\uB19B\uB19D"],
      ["8741", "\uB19E", 9, "\uB1A9", 15],
      ["8761", "\uB1B9", 18, "\uB1CD\uB1CE\uB1CF\uB1D1\uB1D2\uB1D3\uB1D5"],
      ["8781", "\uB1D6", 5, "\uB1DE\uB1E0", 7, "\uB1EA\uB1EB\uB1ED\uB1EE\uB1EF\uB1F1", 7, "\uB1FA\uB1FC\uB1FE", 5, "\uB206\uB207\uB209\uB20A\uB20D", 6, "\uB216\uB218\uB21A", 5, "\uB221", 18, "\uB235", 6, "\uB23D", 26, "\uB259\uB25A\uB25B\uB25D\uB25E\uB25F\uB261", 6, "\uB26A", 4],
      ["8841", "\uB26F", 4, "\uB276", 5, "\uB27D", 6, "\uB286\uB287\uB288\uB28A", 4],
      ["8861", "\uB28F\uB292\uB293\uB295\uB296\uB297\uB29B", 4, "\uB2A2\uB2A4\uB2A7\uB2A8\uB2A9\uB2AB\uB2AD\uB2AE\uB2AF\uB2B1\uB2B2\uB2B3\uB2B5\uB2B6\uB2B7"],
      ["8881", "\uB2B8", 15, "\uB2CA\uB2CB\uB2CD\uB2CE\uB2CF\uB2D1\uB2D3", 4, "\uB2DA\uB2DC\uB2DE\uB2DF\uB2E0\uB2E1\uB2E3\uB2E7\uB2E9\uB2EA\uB2F0\uB2F1\uB2F2\uB2F6\uB2FC\uB2FD\uB2FE\uB302\uB303\uB305\uB306\uB307\uB309", 6, "\uB312\uB316", 5, "\uB31D", 54, "\uB357\uB359\uB35A\uB35D\uB360\uB361\uB362\uB363"],
      ["8941", "\uB366\uB368\uB36A\uB36C\uB36D\uB36F\uB372\uB373\uB375\uB376\uB377\uB379", 6, "\uB382\uB386", 5, "\uB38D"],
      ["8961", "\uB38E\uB38F\uB391\uB392\uB393\uB395", 10, "\uB3A2", 5, "\uB3A9\uB3AA\uB3AB\uB3AD"],
      ["8981", "\uB3AE", 21, "\uB3C6\uB3C7\uB3C9\uB3CA\uB3CD\uB3CF\uB3D1\uB3D2\uB3D3\uB3D6\uB3D8\uB3DA\uB3DC\uB3DE\uB3DF\uB3E1\uB3E2\uB3E3\uB3E5\uB3E6\uB3E7\uB3E9", 18, "\uB3FD", 18, "\uB411", 6, "\uB419\uB41A\uB41B\uB41D\uB41E\uB41F\uB421", 6, "\uB42A\uB42C", 7, "\uB435", 15],
      ["8a41", "\uB445", 10, "\uB452\uB453\uB455\uB456\uB457\uB459", 6, "\uB462\uB464\uB466"],
      ["8a61", "\uB467", 4, "\uB46D", 18, "\uB481\uB482"],
      ["8a81", "\uB483", 4, "\uB489", 19, "\uB49E", 5, "\uB4A5\uB4A6\uB4A7\uB4A9\uB4AA\uB4AB\uB4AD", 7, "\uB4B6\uB4B8\uB4BA", 5, "\uB4C1\uB4C2\uB4C3\uB4C5\uB4C6\uB4C7\uB4C9", 6, "\uB4D1\uB4D2\uB4D3\uB4D4\uB4D6", 5, "\uB4DE\uB4DF\uB4E1\uB4E2\uB4E5\uB4E7", 4, "\uB4EE\uB4F0\uB4F2", 5, "\uB4F9", 26, "\uB516\uB517\uB519\uB51A\uB51D"],
      ["8b41", "\uB51E", 5, "\uB526\uB52B", 4, "\uB532\uB533\uB535\uB536\uB537\uB539", 6, "\uB542\uB546"],
      ["8b61", "\uB547\uB548\uB549\uB54A\uB54E\uB54F\uB551\uB552\uB553\uB555", 6, "\uB55E\uB562", 8],
      ["8b81", "\uB56B", 52, "\uB5A2\uB5A3\uB5A5\uB5A6\uB5A7\uB5A9\uB5AC\uB5AD\uB5AE\uB5AF\uB5B2\uB5B6", 4, "\uB5BE\uB5BF\uB5C1\uB5C2\uB5C3\uB5C5", 6, "\uB5CE\uB5D2", 5, "\uB5D9", 18, "\uB5ED", 18],
      ["8c41", "\uB600", 15, "\uB612\uB613\uB615\uB616\uB617\uB619", 4],
      ["8c61", "\uB61E", 6, "\uB626", 5, "\uB62D", 6, "\uB635", 5],
      ["8c81", "\uB63B", 12, "\uB649", 26, "\uB665\uB666\uB667\uB669", 50, "\uB69E\uB69F\uB6A1\uB6A2\uB6A3\uB6A5", 5, "\uB6AD\uB6AE\uB6AF\uB6B0\uB6B2", 16],
      ["8d41", "\uB6C3", 16, "\uB6D5", 8],
      ["8d61", "\uB6DE", 17, "\uB6F1\uB6F2\uB6F3\uB6F5\uB6F6\uB6F7\uB6F9\uB6FA"],
      ["8d81", "\uB6FB", 4, "\uB702\uB703\uB704\uB706", 33, "\uB72A\uB72B\uB72D\uB72E\uB731", 6, "\uB73A\uB73C", 7, "\uB745\uB746\uB747\uB749\uB74A\uB74B\uB74D", 6, "\uB756", 9, "\uB761\uB762\uB763\uB765\uB766\uB767\uB769", 6, "\uB772\uB774\uB776", 5, "\uB77E\uB77F\uB781\uB782\uB783\uB785", 6, "\uB78E\uB793\uB794\uB795\uB79A\uB79B\uB79D\uB79E"],
      ["8e41", "\uB79F\uB7A1", 6, "\uB7AA\uB7AE", 5, "\uB7B6\uB7B7\uB7B9", 8],
      ["8e61", "\uB7C2", 4, "\uB7C8\uB7CA", 19],
      ["8e81", "\uB7DE", 13, "\uB7EE\uB7EF\uB7F1\uB7F2\uB7F3\uB7F5", 6, "\uB7FE\uB802", 4, "\uB80A\uB80B\uB80D\uB80E\uB80F\uB811", 6, "\uB81A\uB81C\uB81E", 5, "\uB826\uB827\uB829\uB82A\uB82B\uB82D", 6, "\uB836\uB83A", 5, "\uB841\uB842\uB843\uB845", 11, "\uB852\uB854", 7, "\uB85E\uB85F\uB861\uB862\uB863\uB865", 6, "\uB86E\uB870\uB872", 5, "\uB879\uB87A\uB87B\uB87D", 7],
      ["8f41", "\uB885", 7, "\uB88E", 17],
      ["8f61", "\uB8A0", 7, "\uB8A9", 6, "\uB8B1\uB8B2\uB8B3\uB8B5\uB8B6\uB8B7\uB8B9", 4],
      ["8f81", "\uB8BE\uB8BF\uB8C2\uB8C4\uB8C6", 5, "\uB8CD\uB8CE\uB8CF\uB8D1\uB8D2\uB8D3\uB8D5", 7, "\uB8DE\uB8E0\uB8E2", 5, "\uB8EA\uB8EB\uB8ED\uB8EE\uB8EF\uB8F1", 6, "\uB8FA\uB8FC\uB8FE", 5, "\uB905", 18, "\uB919", 6, "\uB921", 26, "\uB93E\uB93F\uB941\uB942\uB943\uB945", 6, "\uB94D\uB94E\uB950\uB952", 5],
      ["9041", "\uB95A\uB95B\uB95D\uB95E\uB95F\uB961", 6, "\uB96A\uB96C\uB96E", 5, "\uB976\uB977\uB979\uB97A\uB97B\uB97D"],
      ["9061", "\uB97E", 5, "\uB986\uB988\uB98B\uB98C\uB98F", 15],
      ["9081", "\uB99F", 12, "\uB9AE\uB9AF\uB9B1\uB9B2\uB9B3\uB9B5", 6, "\uB9BE\uB9C0\uB9C2", 5, "\uB9CA\uB9CB\uB9CD\uB9D3", 4, "\uB9DA\uB9DC\uB9DF\uB9E0\uB9E2\uB9E6\uB9E7\uB9E9\uB9EA\uB9EB\uB9ED", 6, "\uB9F6\uB9FB", 4, "\uBA02", 5, "\uBA09", 11, "\uBA16", 33, "\uBA3A\uBA3B\uBA3D\uBA3E\uBA3F\uBA41\uBA43\uBA44\uBA45\uBA46"],
      ["9141", "\uBA47\uBA4A\uBA4C\uBA4F\uBA50\uBA51\uBA52\uBA56\uBA57\uBA59\uBA5A\uBA5B\uBA5D", 6, "\uBA66\uBA6A", 5],
      ["9161", "\uBA72\uBA73\uBA75\uBA76\uBA77\uBA79", 9, "\uBA86\uBA88\uBA89\uBA8A\uBA8B\uBA8D", 5],
      ["9181", "\uBA93", 20, "\uBAAA\uBAAD\uBAAE\uBAAF\uBAB1\uBAB3", 4, "\uBABA\uBABC\uBABE", 5, "\uBAC5\uBAC6\uBAC7\uBAC9", 14, "\uBADA", 33, "\uBAFD\uBAFE\uBAFF\uBB01\uBB02\uBB03\uBB05", 7, "\uBB0E\uBB10\uBB12", 5, "\uBB19\uBB1A\uBB1B\uBB1D\uBB1E\uBB1F\uBB21", 6],
      ["9241", "\uBB28\uBB2A\uBB2C", 7, "\uBB37\uBB39\uBB3A\uBB3F", 4, "\uBB46\uBB48\uBB4A\uBB4B\uBB4C\uBB4E\uBB51\uBB52"],
      ["9261", "\uBB53\uBB55\uBB56\uBB57\uBB59", 7, "\uBB62\uBB64", 7, "\uBB6D", 4],
      ["9281", "\uBB72", 21, "\uBB89\uBB8A\uBB8B\uBB8D\uBB8E\uBB8F\uBB91", 18, "\uBBA5\uBBA6\uBBA7\uBBA9\uBBAA\uBBAB\uBBAD", 6, "\uBBB5\uBBB6\uBBB8", 7, "\uBBC1\uBBC2\uBBC3\uBBC5\uBBC6\uBBC7\uBBC9", 6, "\uBBD1\uBBD2\uBBD4", 35, "\uBBFA\uBBFB\uBBFD\uBBFE\uBC01"],
      ["9341", "\uBC03", 4, "\uBC0A\uBC0E\uBC10\uBC12\uBC13\uBC19\uBC1A\uBC20\uBC21\uBC22\uBC23\uBC26\uBC28\uBC2A\uBC2B\uBC2C\uBC2E\uBC2F\uBC32\uBC33\uBC35"],
      ["9361", "\uBC36\uBC37\uBC39", 6, "\uBC42\uBC46\uBC47\uBC48\uBC4A\uBC4B\uBC4E\uBC4F\uBC51", 8],
      ["9381", "\uBC5A\uBC5B\uBC5C\uBC5E", 37, "\uBC86\uBC87\uBC89\uBC8A\uBC8D\uBC8F", 4, "\uBC96\uBC98\uBC9B", 4, "\uBCA2\uBCA3\uBCA5\uBCA6\uBCA9", 6, "\uBCB2\uBCB6", 5, "\uBCBE\uBCBF\uBCC1\uBCC2\uBCC3\uBCC5", 7, "\uBCCE\uBCD2\uBCD3\uBCD4\uBCD6\uBCD7\uBCD9\uBCDA\uBCDB\uBCDD", 22, "\uBCF7\uBCF9\uBCFA\uBCFB\uBCFD"],
      ["9441", "\uBCFE", 5, "\uBD06\uBD08\uBD0A", 5, "\uBD11\uBD12\uBD13\uBD15", 8],
      ["9461", "\uBD1E", 5, "\uBD25", 6, "\uBD2D", 12],
      ["9481", "\uBD3A", 5, "\uBD41", 6, "\uBD4A\uBD4B\uBD4D\uBD4E\uBD4F\uBD51", 6, "\uBD5A", 9, "\uBD65\uBD66\uBD67\uBD69", 22, "\uBD82\uBD83\uBD85\uBD86\uBD8B", 4, "\uBD92\uBD94\uBD96\uBD97\uBD98\uBD9B\uBD9D", 6, "\uBDA5", 10, "\uBDB1", 6, "\uBDB9", 24],
      ["9541", "\uBDD2\uBDD3\uBDD6\uBDD7\uBDD9\uBDDA\uBDDB\uBDDD", 11, "\uBDEA", 5, "\uBDF1"],
      ["9561", "\uBDF2\uBDF3\uBDF5\uBDF6\uBDF7\uBDF9", 6, "\uBE01\uBE02\uBE04\uBE06", 5, "\uBE0E\uBE0F\uBE11\uBE12\uBE13"],
      ["9581", "\uBE15", 6, "\uBE1E\uBE20", 35, "\uBE46\uBE47\uBE49\uBE4A\uBE4B\uBE4D\uBE4F", 4, "\uBE56\uBE58\uBE5C\uBE5D\uBE5E\uBE5F\uBE62\uBE63\uBE65\uBE66\uBE67\uBE69\uBE6B", 4, "\uBE72\uBE76", 4, "\uBE7E\uBE7F\uBE81\uBE82\uBE83\uBE85", 6, "\uBE8E\uBE92", 5, "\uBE9A", 13, "\uBEA9", 14],
      ["9641", "\uBEB8", 23, "\uBED2\uBED3"],
      ["9661", "\uBED5\uBED6\uBED9", 6, "\uBEE1\uBEE2\uBEE6", 5, "\uBEED", 8],
      ["9681", "\uBEF6", 10, "\uBF02", 5, "\uBF0A", 13, "\uBF1A\uBF1E", 33, "\uBF42\uBF43\uBF45\uBF46\uBF47\uBF49", 6, "\uBF52\uBF53\uBF54\uBF56", 44],
      ["9741", "\uBF83", 16, "\uBF95", 8],
      ["9761", "\uBF9E", 17, "\uBFB1", 7],
      ["9781", "\uBFB9", 11, "\uBFC6", 5, "\uBFCE\uBFCF\uBFD1\uBFD2\uBFD3\uBFD5", 6, "\uBFDD\uBFDE\uBFE0\uBFE2", 89, "\uC03D\uC03E\uC03F"],
      ["9841", "\uC040", 16, "\uC052", 5, "\uC059\uC05A\uC05B"],
      ["9861", "\uC05D\uC05E\uC05F\uC061", 6, "\uC06A", 15],
      ["9881", "\uC07A", 21, "\uC092\uC093\uC095\uC096\uC097\uC099", 6, "\uC0A2\uC0A4\uC0A6", 5, "\uC0AE\uC0B1\uC0B2\uC0B7", 4, "\uC0BE\uC0C2\uC0C3\uC0C4\uC0C6\uC0C7\uC0CA\uC0CB\uC0CD\uC0CE\uC0CF\uC0D1", 6, "\uC0DA\uC0DE", 5, "\uC0E6\uC0E7\uC0E9\uC0EA\uC0EB\uC0ED", 6, "\uC0F6\uC0F8\uC0FA", 5, "\uC101\uC102\uC103\uC105\uC106\uC107\uC109", 6, "\uC111\uC112\uC113\uC114\uC116", 5, "\uC121\uC122\uC125\uC128\uC129\uC12A\uC12B\uC12E"],
      ["9941", "\uC132\uC133\uC134\uC135\uC137\uC13A\uC13B\uC13D\uC13E\uC13F\uC141", 6, "\uC14A\uC14E", 5, "\uC156\uC157"],
      ["9961", "\uC159\uC15A\uC15B\uC15D", 6, "\uC166\uC16A", 5, "\uC171\uC172\uC173\uC175\uC176\uC177\uC179\uC17A\uC17B"],
      ["9981", "\uC17C", 8, "\uC186", 5, "\uC18F\uC191\uC192\uC193\uC195\uC197", 4, "\uC19E\uC1A0\uC1A2\uC1A3\uC1A4\uC1A6\uC1A7\uC1AA\uC1AB\uC1AD\uC1AE\uC1AF\uC1B1", 11, "\uC1BE", 5, "\uC1C5\uC1C6\uC1C7\uC1C9\uC1CA\uC1CB\uC1CD", 6, "\uC1D5\uC1D6\uC1D9", 6, "\uC1E1\uC1E2\uC1E3\uC1E5\uC1E6\uC1E7\uC1E9", 6, "\uC1F2\uC1F4", 7, "\uC1FE\uC1FF\uC201\uC202\uC203\uC205", 6, "\uC20E\uC210\uC212", 5, "\uC21A\uC21B\uC21D\uC21E\uC221\uC222\uC223"],
      ["9a41", "\uC224\uC225\uC226\uC227\uC22A\uC22C\uC22E\uC230\uC233\uC235", 16],
      ["9a61", "\uC246\uC247\uC249", 6, "\uC252\uC253\uC255\uC256\uC257\uC259", 6, "\uC261\uC262\uC263\uC264\uC266"],
      ["9a81", "\uC267", 4, "\uC26E\uC26F\uC271\uC272\uC273\uC275", 6, "\uC27E\uC280\uC282", 5, "\uC28A", 5, "\uC291", 6, "\uC299\uC29A\uC29C\uC29E", 5, "\uC2A6\uC2A7\uC2A9\uC2AA\uC2AB\uC2AE", 5, "\uC2B6\uC2B8\uC2BA", 33, "\uC2DE\uC2DF\uC2E1\uC2E2\uC2E5", 5, "\uC2EE\uC2F0\uC2F2\uC2F3\uC2F4\uC2F5\uC2F7\uC2FA\uC2FD\uC2FE\uC2FF\uC301", 6, "\uC30A\uC30B\uC30E\uC30F"],
      ["9b41", "\uC310\uC311\uC312\uC316\uC317\uC319\uC31A\uC31B\uC31D", 6, "\uC326\uC327\uC32A", 8],
      ["9b61", "\uC333", 17, "\uC346", 7],
      ["9b81", "\uC34E", 25, "\uC36A\uC36B\uC36D\uC36E\uC36F\uC371\uC373", 4, "\uC37A\uC37B\uC37E", 5, "\uC385\uC386\uC387\uC389\uC38A\uC38B\uC38D", 50, "\uC3C1", 22, "\uC3DA"],
      ["9c41", "\uC3DB\uC3DD\uC3DE\uC3E1\uC3E3", 4, "\uC3EA\uC3EB\uC3EC\uC3EE", 5, "\uC3F6\uC3F7\uC3F9", 5],
      ["9c61", "\uC3FF", 8, "\uC409", 6, "\uC411", 9],
      ["9c81", "\uC41B", 8, "\uC425", 6, "\uC42D\uC42E\uC42F\uC431\uC432\uC433\uC435", 6, "\uC43E", 9, "\uC449", 26, "\uC466\uC467\uC469\uC46A\uC46B\uC46D", 6, "\uC476\uC477\uC478\uC47A", 5, "\uC481", 18, "\uC495", 6, "\uC49D", 12],
      ["9d41", "\uC4AA", 13, "\uC4B9\uC4BA\uC4BB\uC4BD", 8],
      ["9d61", "\uC4C6", 25],
      ["9d81", "\uC4E0", 8, "\uC4EA", 5, "\uC4F2\uC4F3\uC4F5\uC4F6\uC4F7\uC4F9\uC4FB\uC4FC\uC4FD\uC4FE\uC502", 9, "\uC50D\uC50E\uC50F\uC511\uC512\uC513\uC515", 6, "\uC51D", 10, "\uC52A\uC52B\uC52D\uC52E\uC52F\uC531", 6, "\uC53A\uC53C\uC53E", 5, "\uC546\uC547\uC54B\uC54F\uC550\uC551\uC552\uC556\uC55A\uC55B\uC55C\uC55F\uC562\uC563\uC565\uC566\uC567\uC569", 6, "\uC572\uC576", 5, "\uC57E\uC57F\uC581\uC582\uC583\uC585\uC586\uC588\uC589\uC58A\uC58B\uC58E\uC590\uC592\uC593\uC594"],
      ["9e41", "\uC596\uC599\uC59A\uC59B\uC59D\uC59E\uC59F\uC5A1", 7, "\uC5AA", 9, "\uC5B6"],
      ["9e61", "\uC5B7\uC5BA\uC5BF", 4, "\uC5CB\uC5CD\uC5CF\uC5D2\uC5D3\uC5D5\uC5D6\uC5D7\uC5D9", 6, "\uC5E2\uC5E4\uC5E6\uC5E7"],
      ["9e81", "\uC5E8\uC5E9\uC5EA\uC5EB\uC5EF\uC5F1\uC5F2\uC5F3\uC5F5\uC5F8\uC5F9\uC5FA\uC5FB\uC602\uC603\uC604\uC609\uC60A\uC60B\uC60D\uC60E\uC60F\uC611", 6, "\uC61A\uC61D", 6, "\uC626\uC627\uC629\uC62A\uC62B\uC62F\uC631\uC632\uC636\uC638\uC63A\uC63C\uC63D\uC63E\uC63F\uC642\uC643\uC645\uC646\uC647\uC649", 6, "\uC652\uC656", 5, "\uC65E\uC65F\uC661", 10, "\uC66D\uC66E\uC670\uC672", 5, "\uC67A\uC67B\uC67D\uC67E\uC67F\uC681", 6, "\uC68A\uC68C\uC68E", 5, "\uC696\uC697\uC699\uC69A\uC69B\uC69D", 6, "\uC6A6"],
      ["9f41", "\uC6A8\uC6AA", 5, "\uC6B2\uC6B3\uC6B5\uC6B6\uC6B7\uC6BB", 4, "\uC6C2\uC6C4\uC6C6", 5, "\uC6CE"],
      ["9f61", "\uC6CF\uC6D1\uC6D2\uC6D3\uC6D5", 6, "\uC6DE\uC6DF\uC6E2", 5, "\uC6EA\uC6EB\uC6ED\uC6EE\uC6EF\uC6F1\uC6F2"],
      ["9f81", "\uC6F3", 4, "\uC6FA\uC6FB\uC6FC\uC6FE", 5, "\uC706\uC707\uC709\uC70A\uC70B\uC70D", 6, "\uC716\uC718\uC71A", 5, "\uC722\uC723\uC725\uC726\uC727\uC729", 6, "\uC732\uC734\uC736\uC738\uC739\uC73A\uC73B\uC73E\uC73F\uC741\uC742\uC743\uC745", 4, "\uC74B\uC74E\uC750\uC759\uC75A\uC75B\uC75D\uC75E\uC75F\uC761", 6, "\uC769\uC76A\uC76C", 7, "\uC776\uC777\uC779\uC77A\uC77B\uC77F\uC780\uC781\uC782\uC786\uC78B\uC78C\uC78D\uC78F\uC792\uC793\uC795\uC799\uC79B", 4, "\uC7A2\uC7A7", 4, "\uC7AE\uC7AF\uC7B1\uC7B2\uC7B3\uC7B5\uC7B6\uC7B7"],
      ["a041", "\uC7B8\uC7B9\uC7BA\uC7BB\uC7BE\uC7C2", 5, "\uC7CA\uC7CB\uC7CD\uC7CF\uC7D1", 6, "\uC7D9\uC7DA\uC7DB\uC7DC"],
      ["a061", "\uC7DE", 5, "\uC7E5\uC7E6\uC7E7\uC7E9\uC7EA\uC7EB\uC7ED", 13],
      ["a081", "\uC7FB", 4, "\uC802\uC803\uC805\uC806\uC807\uC809\uC80B", 4, "\uC812\uC814\uC817", 4, "\uC81E\uC81F\uC821\uC822\uC823\uC825", 6, "\uC82E\uC830\uC832", 5, "\uC839\uC83A\uC83B\uC83D\uC83E\uC83F\uC841", 6, "\uC84A\uC84B\uC84E", 5, "\uC855", 26, "\uC872\uC873\uC875\uC876\uC877\uC879\uC87B", 4, "\uC882\uC884\uC888\uC889\uC88A\uC88E", 5, "\uC895", 7, "\uC89E\uC8A0\uC8A2\uC8A3\uC8A4"],
      ["a141", "\uC8A5\uC8A6\uC8A7\uC8A9", 18, "\uC8BE\uC8BF\uC8C0\uC8C1"],
      ["a161", "\uC8C2\uC8C3\uC8C5\uC8C6\uC8C7\uC8C9\uC8CA\uC8CB\uC8CD", 6, "\uC8D6\uC8D8\uC8DA", 5, "\uC8E2\uC8E3\uC8E5"],
      ["a181", "\uC8E6", 14, "\uC8F6", 5, "\uC8FE\uC8FF\uC901\uC902\uC903\uC907", 4, "\uC90E\u3000\u3001\u3002\xB7\u2025\u2026\xA8\u3003\xAD\u2015\u2225\uFF3C\u223C\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 9, "\xB1\xD7\xF7\u2260\u2264\u2265\u221E\u2234\xB0\u2032\u2033\u2103\u212B\uFFE0\uFFE1\uFFE5\u2642\u2640\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\xA7\u203B\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u2192\u2190\u2191\u2193\u2194\u3013\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229\u2227\u2228\uFFE2"],
      ["a241", "\uC910\uC912", 5, "\uC919", 18],
      ["a261", "\uC92D", 6, "\uC935", 18],
      ["a281", "\uC948", 7, "\uC952\uC953\uC955\uC956\uC957\uC959", 6, "\uC962\uC964", 7, "\uC96D\uC96E\uC96F\u21D2\u21D4\u2200\u2203\xB4\uFF5E\u02C7\u02D8\u02DD\u02DA\u02D9\xB8\u02DB\xA1\xBF\u02D0\u222E\u2211\u220F\xA4\u2109\u2030\u25C1\u25C0\u25B7\u25B6\u2664\u2660\u2661\u2665\u2667\u2663\u2299\u25C8\u25A3\u25D0\u25D1\u2592\u25A4\u25A5\u25A8\u25A7\u25A6\u25A9\u2668\u260F\u260E\u261C\u261E\xB6\u2020\u2021\u2195\u2197\u2199\u2196\u2198\u266D\u2669\u266A\u266C\u327F\u321C\u2116\u33C7\u2122\u33C2\u33D8\u2121\u20AC\xAE"],
      ["a341", "\uC971\uC972\uC973\uC975", 6, "\uC97D", 10, "\uC98A\uC98B\uC98D\uC98E\uC98F"],
      ["a361", "\uC991", 6, "\uC99A\uC99C\uC99E", 16],
      ["a381", "\uC9AF", 16, "\uC9C2\uC9C3\uC9C5\uC9C6\uC9C9\uC9CB", 4, "\uC9D2\uC9D4\uC9D7\uC9D8\uC9DB\uFF01", 58, "\uFFE6\uFF3D", 32, "\uFFE3"],
      ["a441", "\uC9DE\uC9DF\uC9E1\uC9E3\uC9E5\uC9E6\uC9E8\uC9E9\uC9EA\uC9EB\uC9EE\uC9F2", 5, "\uC9FA\uC9FB\uC9FD\uC9FE\uC9FF\uCA01\uCA02\uCA03\uCA04"],
      ["a461", "\uCA05\uCA06\uCA07\uCA0A\uCA0E", 5, "\uCA15\uCA16\uCA17\uCA19", 12],
      ["a481", "\uCA26\uCA27\uCA28\uCA2A", 28, "\u3131", 93],
      ["a541", "\uCA47", 4, "\uCA4E\uCA4F\uCA51\uCA52\uCA53\uCA55", 6, "\uCA5E\uCA62", 5, "\uCA69\uCA6A"],
      ["a561", "\uCA6B", 17, "\uCA7E", 5, "\uCA85\uCA86"],
      ["a581", "\uCA87", 16, "\uCA99", 14, "\u2170", 9],
      ["a5b0", "\u2160", 9],
      ["a5c1", "\u0391", 16, "\u03A3", 6],
      ["a5e1", "\u03B1", 16, "\u03C3", 6],
      ["a641", "\uCAA8", 19, "\uCABE\uCABF\uCAC1\uCAC2\uCAC3\uCAC5"],
      ["a661", "\uCAC6", 5, "\uCACE\uCAD0\uCAD2\uCAD4\uCAD5\uCAD6\uCAD7\uCADA", 5, "\uCAE1", 6],
      ["a681", "\uCAE8\uCAE9\uCAEA\uCAEB\uCAED", 6, "\uCAF5", 18, "\uCB09\uCB0A\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542\u2512\u2511\u251A\u2519\u2516\u2515\u250E\u250D\u251E\u251F\u2521\u2522\u2526\u2527\u2529\u252A\u252D\u252E\u2531\u2532\u2535\u2536\u2539\u253A\u253D\u253E\u2540\u2541\u2543", 7],
      ["a741", "\uCB0B", 4, "\uCB11\uCB12\uCB13\uCB15\uCB16\uCB17\uCB19", 6, "\uCB22", 7],
      ["a761", "\uCB2A", 22, "\uCB42\uCB43\uCB44"],
      ["a781", "\uCB45\uCB46\uCB47\uCB4A\uCB4B\uCB4D\uCB4E\uCB4F\uCB51", 6, "\uCB5A\uCB5B\uCB5C\uCB5E", 5, "\uCB65", 7, "\u3395\u3396\u3397\u2113\u3398\u33C4\u33A3\u33A4\u33A5\u33A6\u3399", 9, "\u33CA\u338D\u338E\u338F\u33CF\u3388\u3389\u33C8\u33A7\u33A8\u33B0", 9, "\u3380", 4, "\u33BA", 5, "\u3390", 4, "\u2126\u33C0\u33C1\u338A\u338B\u338C\u33D6\u33C5\u33AD\u33AE\u33AF\u33DB\u33A9\u33AA\u33AB\u33AC\u33DD\u33D0\u33D3\u33C3\u33C9\u33DC\u33C6"],
      ["a841", "\uCB6D", 10, "\uCB7A", 14],
      ["a861", "\uCB89", 18, "\uCB9D", 6],
      ["a881", "\uCBA4", 19, "\uCBB9", 11, "\xC6\xD0\xAA\u0126"],
      ["a8a6", "\u0132"],
      ["a8a8", "\u013F\u0141\xD8\u0152\xBA\xDE\u0166\u014A"],
      ["a8b1", "\u3260", 27, "\u24D0", 25, "\u2460", 14, "\xBD\u2153\u2154\xBC\xBE\u215B\u215C\u215D\u215E"],
      ["a941", "\uCBC5", 14, "\uCBD5", 10],
      ["a961", "\uCBE0\uCBE1\uCBE2\uCBE3\uCBE5\uCBE6\uCBE8\uCBEA", 18],
      ["a981", "\uCBFD", 14, "\uCC0E\uCC0F\uCC11\uCC12\uCC13\uCC15", 6, "\uCC1E\uCC1F\uCC20\uCC23\uCC24\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0140\u0142\xF8\u0153\xDF\xFE\u0167\u014B\u0149\u3200", 27, "\u249C", 25, "\u2474", 14, "\xB9\xB2\xB3\u2074\u207F\u2081\u2082\u2083\u2084"],
      ["aa41", "\uCC25\uCC26\uCC2A\uCC2B\uCC2D\uCC2F\uCC31", 6, "\uCC3A\uCC3F", 4, "\uCC46\uCC47\uCC49\uCC4A\uCC4B\uCC4D\uCC4E"],
      ["aa61", "\uCC4F", 4, "\uCC56\uCC5A", 5, "\uCC61\uCC62\uCC63\uCC65\uCC67\uCC69", 6, "\uCC71\uCC72"],
      ["aa81", "\uCC73\uCC74\uCC76", 29, "\u3041", 82],
      ["ab41", "\uCC94\uCC95\uCC96\uCC97\uCC9A\uCC9B\uCC9D\uCC9E\uCC9F\uCCA1", 6, "\uCCAA\uCCAE", 5, "\uCCB6\uCCB7\uCCB9"],
      ["ab61", "\uCCBA\uCCBB\uCCBD", 6, "\uCCC6\uCCC8\uCCCA", 5, "\uCCD1\uCCD2\uCCD3\uCCD5", 5],
      ["ab81", "\uCCDB", 8, "\uCCE5", 6, "\uCCED\uCCEE\uCCEF\uCCF1", 12, "\u30A1", 85],
      ["ac41", "\uCCFE\uCCFF\uCD00\uCD02", 5, "\uCD0A\uCD0B\uCD0D\uCD0E\uCD0F\uCD11", 6, "\uCD1A\uCD1C\uCD1E\uCD1F\uCD20"],
      ["ac61", "\uCD21\uCD22\uCD23\uCD25\uCD26\uCD27\uCD29\uCD2A\uCD2B\uCD2D", 11, "\uCD3A", 4],
      ["ac81", "\uCD3F", 28, "\uCD5D\uCD5E\uCD5F\u0410", 5, "\u0401\u0416", 25],
      ["acd1", "\u0430", 5, "\u0451\u0436", 25],
      ["ad41", "\uCD61\uCD62\uCD63\uCD65", 6, "\uCD6E\uCD70\uCD72", 5, "\uCD79", 7],
      ["ad61", "\uCD81", 6, "\uCD89", 10, "\uCD96\uCD97\uCD99\uCD9A\uCD9B\uCD9D\uCD9E\uCD9F"],
      ["ad81", "\uCDA0\uCDA1\uCDA2\uCDA3\uCDA6\uCDA8\uCDAA", 5, "\uCDB1", 18, "\uCDC5"],
      ["ae41", "\uCDC6", 5, "\uCDCD\uCDCE\uCDCF\uCDD1", 16],
      ["ae61", "\uCDE2", 5, "\uCDE9\uCDEA\uCDEB\uCDED\uCDEE\uCDEF\uCDF1", 6, "\uCDFA\uCDFC\uCDFE", 4],
      ["ae81", "\uCE03\uCE05\uCE06\uCE07\uCE09\uCE0A\uCE0B\uCE0D", 6, "\uCE15\uCE16\uCE17\uCE18\uCE1A", 5, "\uCE22\uCE23\uCE25\uCE26\uCE27\uCE29\uCE2A\uCE2B"],
      ["af41", "\uCE2C\uCE2D\uCE2E\uCE2F\uCE32\uCE34\uCE36", 19],
      ["af61", "\uCE4A", 13, "\uCE5A\uCE5B\uCE5D\uCE5E\uCE62", 5, "\uCE6A\uCE6C"],
      ["af81", "\uCE6E", 5, "\uCE76\uCE77\uCE79\uCE7A\uCE7B\uCE7D", 6, "\uCE86\uCE88\uCE8A", 5, "\uCE92\uCE93\uCE95\uCE96\uCE97\uCE99"],
      ["b041", "\uCE9A", 5, "\uCEA2\uCEA6", 5, "\uCEAE", 12],
      ["b061", "\uCEBB", 5, "\uCEC2", 19],
      ["b081", "\uCED6", 13, "\uCEE6\uCEE7\uCEE9\uCEEA\uCEED", 6, "\uCEF6\uCEFA", 5, "\uAC00\uAC01\uAC04\uAC07\uAC08\uAC09\uAC0A\uAC10", 7, "\uAC19", 4, "\uAC20\uAC24\uAC2C\uAC2D\uAC2F\uAC30\uAC31\uAC38\uAC39\uAC3C\uAC40\uAC4B\uAC4D\uAC54\uAC58\uAC5C\uAC70\uAC71\uAC74\uAC77\uAC78\uAC7A\uAC80\uAC81\uAC83\uAC84\uAC85\uAC86\uAC89\uAC8A\uAC8B\uAC8C\uAC90\uAC94\uAC9C\uAC9D\uAC9F\uACA0\uACA1\uACA8\uACA9\uACAA\uACAC\uACAF\uACB0\uACB8\uACB9\uACBB\uACBC\uACBD\uACC1\uACC4\uACC8\uACCC\uACD5\uACD7\uACE0\uACE1\uACE4\uACE7\uACE8\uACEA\uACEC\uACEF\uACF0\uACF1\uACF3\uACF5\uACF6\uACFC\uACFD\uAD00\uAD04\uAD06"],
      ["b141", "\uCF02\uCF03\uCF05\uCF06\uCF07\uCF09", 6, "\uCF12\uCF14\uCF16", 5, "\uCF1D\uCF1E\uCF1F\uCF21\uCF22\uCF23"],
      ["b161", "\uCF25", 6, "\uCF2E\uCF32", 5, "\uCF39", 11],
      ["b181", "\uCF45", 14, "\uCF56\uCF57\uCF59\uCF5A\uCF5B\uCF5D", 6, "\uCF66\uCF68\uCF6A\uCF6B\uCF6C\uAD0C\uAD0D\uAD0F\uAD11\uAD18\uAD1C\uAD20\uAD29\uAD2C\uAD2D\uAD34\uAD35\uAD38\uAD3C\uAD44\uAD45\uAD47\uAD49\uAD50\uAD54\uAD58\uAD61\uAD63\uAD6C\uAD6D\uAD70\uAD73\uAD74\uAD75\uAD76\uAD7B\uAD7C\uAD7D\uAD7F\uAD81\uAD82\uAD88\uAD89\uAD8C\uAD90\uAD9C\uAD9D\uADA4\uADB7\uADC0\uADC1\uADC4\uADC8\uADD0\uADD1\uADD3\uADDC\uADE0\uADE4\uADF8\uADF9\uADFC\uADFF\uAE00\uAE01\uAE08\uAE09\uAE0B\uAE0D\uAE14\uAE30\uAE31\uAE34\uAE37\uAE38\uAE3A\uAE40\uAE41\uAE43\uAE45\uAE46\uAE4A\uAE4C\uAE4D\uAE4E\uAE50\uAE54\uAE56\uAE5C\uAE5D\uAE5F\uAE60\uAE61\uAE65\uAE68\uAE69\uAE6C\uAE70\uAE78"],
      ["b241", "\uCF6D\uCF6E\uCF6F\uCF72\uCF73\uCF75\uCF76\uCF77\uCF79", 6, "\uCF81\uCF82\uCF83\uCF84\uCF86", 5, "\uCF8D"],
      ["b261", "\uCF8E", 18, "\uCFA2", 5, "\uCFA9"],
      ["b281", "\uCFAA", 5, "\uCFB1", 18, "\uCFC5", 6, "\uAE79\uAE7B\uAE7C\uAE7D\uAE84\uAE85\uAE8C\uAEBC\uAEBD\uAEBE\uAEC0\uAEC4\uAECC\uAECD\uAECF\uAED0\uAED1\uAED8\uAED9\uAEDC\uAEE8\uAEEB\uAEED\uAEF4\uAEF8\uAEFC\uAF07\uAF08\uAF0D\uAF10\uAF2C\uAF2D\uAF30\uAF32\uAF34\uAF3C\uAF3D\uAF3F\uAF41\uAF42\uAF43\uAF48\uAF49\uAF50\uAF5C\uAF5D\uAF64\uAF65\uAF79\uAF80\uAF84\uAF88\uAF90\uAF91\uAF95\uAF9C\uAFB8\uAFB9\uAFBC\uAFC0\uAFC7\uAFC8\uAFC9\uAFCB\uAFCD\uAFCE\uAFD4\uAFDC\uAFE8\uAFE9\uAFF0\uAFF1\uAFF4\uAFF8\uB000\uB001\uB004\uB00C\uB010\uB014\uB01C\uB01D\uB028\uB044\uB045\uB048\uB04A\uB04C\uB04E\uB053\uB054\uB055\uB057\uB059"],
      ["b341", "\uCFCC", 19, "\uCFE2\uCFE3\uCFE5\uCFE6\uCFE7\uCFE9"],
      ["b361", "\uCFEA", 5, "\uCFF2\uCFF4\uCFF6", 5, "\uCFFD\uCFFE\uCFFF\uD001\uD002\uD003\uD005", 5],
      ["b381", "\uD00B", 5, "\uD012", 5, "\uD019", 19, "\uB05D\uB07C\uB07D\uB080\uB084\uB08C\uB08D\uB08F\uB091\uB098\uB099\uB09A\uB09C\uB09F\uB0A0\uB0A1\uB0A2\uB0A8\uB0A9\uB0AB", 4, "\uB0B1\uB0B3\uB0B4\uB0B5\uB0B8\uB0BC\uB0C4\uB0C5\uB0C7\uB0C8\uB0C9\uB0D0\uB0D1\uB0D4\uB0D8\uB0E0\uB0E5\uB108\uB109\uB10B\uB10C\uB110\uB112\uB113\uB118\uB119\uB11B\uB11C\uB11D\uB123\uB124\uB125\uB128\uB12C\uB134\uB135\uB137\uB138\uB139\uB140\uB141\uB144\uB148\uB150\uB151\uB154\uB155\uB158\uB15C\uB160\uB178\uB179\uB17C\uB180\uB182\uB188\uB189\uB18B\uB18D\uB192\uB193\uB194\uB198\uB19C\uB1A8\uB1CC\uB1D0\uB1D4\uB1DC\uB1DD"],
      ["b441", "\uD02E", 5, "\uD036\uD037\uD039\uD03A\uD03B\uD03D", 6, "\uD046\uD048\uD04A", 5],
      ["b461", "\uD051\uD052\uD053\uD055\uD056\uD057\uD059", 6, "\uD061", 10, "\uD06E\uD06F"],
      ["b481", "\uD071\uD072\uD073\uD075", 6, "\uD07E\uD07F\uD080\uD082", 18, "\uB1DF\uB1E8\uB1E9\uB1EC\uB1F0\uB1F9\uB1FB\uB1FD\uB204\uB205\uB208\uB20B\uB20C\uB214\uB215\uB217\uB219\uB220\uB234\uB23C\uB258\uB25C\uB260\uB268\uB269\uB274\uB275\uB27C\uB284\uB285\uB289\uB290\uB291\uB294\uB298\uB299\uB29A\uB2A0\uB2A1\uB2A3\uB2A5\uB2A6\uB2AA\uB2AC\uB2B0\uB2B4\uB2C8\uB2C9\uB2CC\uB2D0\uB2D2\uB2D8\uB2D9\uB2DB\uB2DD\uB2E2\uB2E4\uB2E5\uB2E6\uB2E8\uB2EB", 4, "\uB2F3\uB2F4\uB2F5\uB2F7", 4, "\uB2FF\uB300\uB301\uB304\uB308\uB310\uB311\uB313\uB314\uB315\uB31C\uB354\uB355\uB356\uB358\uB35B\uB35C\uB35E\uB35F\uB364\uB365"],
      ["b541", "\uD095", 14, "\uD0A6\uD0A7\uD0A9\uD0AA\uD0AB\uD0AD", 5],
      ["b561", "\uD0B3\uD0B6\uD0B8\uD0BA", 5, "\uD0C2\uD0C3\uD0C5\uD0C6\uD0C7\uD0CA", 5, "\uD0D2\uD0D6", 4],
      ["b581", "\uD0DB\uD0DE\uD0DF\uD0E1\uD0E2\uD0E3\uD0E5", 6, "\uD0EE\uD0F2", 5, "\uD0F9", 11, "\uB367\uB369\uB36B\uB36E\uB370\uB371\uB374\uB378\uB380\uB381\uB383\uB384\uB385\uB38C\uB390\uB394\uB3A0\uB3A1\uB3A8\uB3AC\uB3C4\uB3C5\uB3C8\uB3CB\uB3CC\uB3CE\uB3D0\uB3D4\uB3D5\uB3D7\uB3D9\uB3DB\uB3DD\uB3E0\uB3E4\uB3E8\uB3FC\uB410\uB418\uB41C\uB420\uB428\uB429\uB42B\uB434\uB450\uB451\uB454\uB458\uB460\uB461\uB463\uB465\uB46C\uB480\uB488\uB49D\uB4A4\uB4A8\uB4AC\uB4B5\uB4B7\uB4B9\uB4C0\uB4C4\uB4C8\uB4D0\uB4D5\uB4DC\uB4DD\uB4E0\uB4E3\uB4E4\uB4E6\uB4EC\uB4ED\uB4EF\uB4F1\uB4F8\uB514\uB515\uB518\uB51B\uB51C\uB524\uB525\uB527\uB528\uB529\uB52A\uB530\uB531\uB534\uB538"],
      ["b641", "\uD105", 7, "\uD10E", 17],
      ["b661", "\uD120", 15, "\uD132\uD133\uD135\uD136\uD137\uD139\uD13B\uD13C\uD13D\uD13E"],
      ["b681", "\uD13F\uD142\uD146", 5, "\uD14E\uD14F\uD151\uD152\uD153\uD155", 6, "\uD15E\uD160\uD162", 5, "\uD169\uD16A\uD16B\uD16D\uB540\uB541\uB543\uB544\uB545\uB54B\uB54C\uB54D\uB550\uB554\uB55C\uB55D\uB55F\uB560\uB561\uB5A0\uB5A1\uB5A4\uB5A8\uB5AA\uB5AB\uB5B0\uB5B1\uB5B3\uB5B4\uB5B5\uB5BB\uB5BC\uB5BD\uB5C0\uB5C4\uB5CC\uB5CD\uB5CF\uB5D0\uB5D1\uB5D8\uB5EC\uB610\uB611\uB614\uB618\uB625\uB62C\uB634\uB648\uB664\uB668\uB69C\uB69D\uB6A0\uB6A4\uB6AB\uB6AC\uB6B1\uB6D4\uB6F0\uB6F4\uB6F8\uB700\uB701\uB705\uB728\uB729\uB72C\uB72F\uB730\uB738\uB739\uB73B\uB744\uB748\uB74C\uB754\uB755\uB760\uB764\uB768\uB770\uB771\uB773\uB775\uB77C\uB77D\uB780\uB784\uB78C\uB78D\uB78F\uB790\uB791\uB792\uB796\uB797"],
      ["b741", "\uD16E", 13, "\uD17D", 6, "\uD185\uD186\uD187\uD189\uD18A"],
      ["b761", "\uD18B", 20, "\uD1A2\uD1A3\uD1A5\uD1A6\uD1A7"],
      ["b781", "\uD1A9", 6, "\uD1B2\uD1B4\uD1B6\uD1B7\uD1B8\uD1B9\uD1BB\uD1BD\uD1BE\uD1BF\uD1C1", 14, "\uB798\uB799\uB79C\uB7A0\uB7A8\uB7A9\uB7AB\uB7AC\uB7AD\uB7B4\uB7B5\uB7B8\uB7C7\uB7C9\uB7EC\uB7ED\uB7F0\uB7F4\uB7FC\uB7FD\uB7FF\uB800\uB801\uB807\uB808\uB809\uB80C\uB810\uB818\uB819\uB81B\uB81D\uB824\uB825\uB828\uB82C\uB834\uB835\uB837\uB838\uB839\uB840\uB844\uB851\uB853\uB85C\uB85D\uB860\uB864\uB86C\uB86D\uB86F\uB871\uB878\uB87C\uB88D\uB8A8\uB8B0\uB8B4\uB8B8\uB8C0\uB8C1\uB8C3\uB8C5\uB8CC\uB8D0\uB8D4\uB8DD\uB8DF\uB8E1\uB8E8\uB8E9\uB8EC\uB8F0\uB8F8\uB8F9\uB8FB\uB8FD\uB904\uB918\uB920\uB93C\uB93D\uB940\uB944\uB94C\uB94F\uB951\uB958\uB959\uB95C\uB960\uB968\uB969"],
      ["b841", "\uD1D0", 7, "\uD1D9", 17],
      ["b861", "\uD1EB", 8, "\uD1F5\uD1F6\uD1F7\uD1F9", 13],
      ["b881", "\uD208\uD20A", 5, "\uD211", 24, "\uB96B\uB96D\uB974\uB975\uB978\uB97C\uB984\uB985\uB987\uB989\uB98A\uB98D\uB98E\uB9AC\uB9AD\uB9B0\uB9B4\uB9BC\uB9BD\uB9BF\uB9C1\uB9C8\uB9C9\uB9CC\uB9CE", 4, "\uB9D8\uB9D9\uB9DB\uB9DD\uB9DE\uB9E1\uB9E3\uB9E4\uB9E5\uB9E8\uB9EC\uB9F4\uB9F5\uB9F7\uB9F8\uB9F9\uB9FA\uBA00\uBA01\uBA08\uBA15\uBA38\uBA39\uBA3C\uBA40\uBA42\uBA48\uBA49\uBA4B\uBA4D\uBA4E\uBA53\uBA54\uBA55\uBA58\uBA5C\uBA64\uBA65\uBA67\uBA68\uBA69\uBA70\uBA71\uBA74\uBA78\uBA83\uBA84\uBA85\uBA87\uBA8C\uBAA8\uBAA9\uBAAB\uBAAC\uBAB0\uBAB2\uBAB8\uBAB9\uBABB\uBABD\uBAC4\uBAC8\uBAD8\uBAD9\uBAFC"],
      ["b941", "\uD22A\uD22B\uD22E\uD22F\uD231\uD232\uD233\uD235", 6, "\uD23E\uD240\uD242", 5, "\uD249\uD24A\uD24B\uD24C"],
      ["b961", "\uD24D", 14, "\uD25D", 6, "\uD265\uD266\uD267\uD268"],
      ["b981", "\uD269", 22, "\uD282\uD283\uD285\uD286\uD287\uD289\uD28A\uD28B\uD28C\uBB00\uBB04\uBB0D\uBB0F\uBB11\uBB18\uBB1C\uBB20\uBB29\uBB2B\uBB34\uBB35\uBB36\uBB38\uBB3B\uBB3C\uBB3D\uBB3E\uBB44\uBB45\uBB47\uBB49\uBB4D\uBB4F\uBB50\uBB54\uBB58\uBB61\uBB63\uBB6C\uBB88\uBB8C\uBB90\uBBA4\uBBA8\uBBAC\uBBB4\uBBB7\uBBC0\uBBC4\uBBC8\uBBD0\uBBD3\uBBF8\uBBF9\uBBFC\uBBFF\uBC00\uBC02\uBC08\uBC09\uBC0B\uBC0C\uBC0D\uBC0F\uBC11\uBC14", 4, "\uBC1B", 4, "\uBC24\uBC25\uBC27\uBC29\uBC2D\uBC30\uBC31\uBC34\uBC38\uBC40\uBC41\uBC43\uBC44\uBC45\uBC49\uBC4C\uBC4D\uBC50\uBC5D\uBC84\uBC85\uBC88\uBC8B\uBC8C\uBC8E\uBC94\uBC95\uBC97"],
      ["ba41", "\uD28D\uD28E\uD28F\uD292\uD293\uD294\uD296", 5, "\uD29D\uD29E\uD29F\uD2A1\uD2A2\uD2A3\uD2A5", 6, "\uD2AD"],
      ["ba61", "\uD2AE\uD2AF\uD2B0\uD2B2", 5, "\uD2BA\uD2BB\uD2BD\uD2BE\uD2C1\uD2C3", 4, "\uD2CA\uD2CC", 5],
      ["ba81", "\uD2D2\uD2D3\uD2D5\uD2D6\uD2D7\uD2D9\uD2DA\uD2DB\uD2DD", 6, "\uD2E6", 9, "\uD2F2\uD2F3\uD2F5\uD2F6\uD2F7\uD2F9\uD2FA\uBC99\uBC9A\uBCA0\uBCA1\uBCA4\uBCA7\uBCA8\uBCB0\uBCB1\uBCB3\uBCB4\uBCB5\uBCBC\uBCBD\uBCC0\uBCC4\uBCCD\uBCCF\uBCD0\uBCD1\uBCD5\uBCD8\uBCDC\uBCF4\uBCF5\uBCF6\uBCF8\uBCFC\uBD04\uBD05\uBD07\uBD09\uBD10\uBD14\uBD24\uBD2C\uBD40\uBD48\uBD49\uBD4C\uBD50\uBD58\uBD59\uBD64\uBD68\uBD80\uBD81\uBD84\uBD87\uBD88\uBD89\uBD8A\uBD90\uBD91\uBD93\uBD95\uBD99\uBD9A\uBD9C\uBDA4\uBDB0\uBDB8\uBDD4\uBDD5\uBDD8\uBDDC\uBDE9\uBDF0\uBDF4\uBDF8\uBE00\uBE03\uBE05\uBE0C\uBE0D\uBE10\uBE14\uBE1C\uBE1D\uBE1F\uBE44\uBE45\uBE48\uBE4C\uBE4E\uBE54\uBE55\uBE57\uBE59\uBE5A\uBE5B\uBE60\uBE61\uBE64"],
      ["bb41", "\uD2FB", 4, "\uD302\uD304\uD306", 5, "\uD30F\uD311\uD312\uD313\uD315\uD317", 4, "\uD31E\uD322\uD323"],
      ["bb61", "\uD324\uD326\uD327\uD32A\uD32B\uD32D\uD32E\uD32F\uD331", 6, "\uD33A\uD33E", 5, "\uD346\uD347\uD348\uD349"],
      ["bb81", "\uD34A", 31, "\uBE68\uBE6A\uBE70\uBE71\uBE73\uBE74\uBE75\uBE7B\uBE7C\uBE7D\uBE80\uBE84\uBE8C\uBE8D\uBE8F\uBE90\uBE91\uBE98\uBE99\uBEA8\uBED0\uBED1\uBED4\uBED7\uBED8\uBEE0\uBEE3\uBEE4\uBEE5\uBEEC\uBF01\uBF08\uBF09\uBF18\uBF19\uBF1B\uBF1C\uBF1D\uBF40\uBF41\uBF44\uBF48\uBF50\uBF51\uBF55\uBF94\uBFB0\uBFC5\uBFCC\uBFCD\uBFD0\uBFD4\uBFDC\uBFDF\uBFE1\uC03C\uC051\uC058\uC05C\uC060\uC068\uC069\uC090\uC091\uC094\uC098\uC0A0\uC0A1\uC0A3\uC0A5\uC0AC\uC0AD\uC0AF\uC0B0\uC0B3\uC0B4\uC0B5\uC0B6\uC0BC\uC0BD\uC0BF\uC0C0\uC0C1\uC0C5\uC0C8\uC0C9\uC0CC\uC0D0\uC0D8\uC0D9\uC0DB\uC0DC\uC0DD\uC0E4"],
      ["bc41", "\uD36A", 17, "\uD37E\uD37F\uD381\uD382\uD383\uD385\uD386\uD387"],
      ["bc61", "\uD388\uD389\uD38A\uD38B\uD38E\uD392", 5, "\uD39A\uD39B\uD39D\uD39E\uD39F\uD3A1", 6, "\uD3AA\uD3AC\uD3AE"],
      ["bc81", "\uD3AF", 4, "\uD3B5\uD3B6\uD3B7\uD3B9\uD3BA\uD3BB\uD3BD", 6, "\uD3C6\uD3C7\uD3CA", 5, "\uD3D1", 5, "\uC0E5\uC0E8\uC0EC\uC0F4\uC0F5\uC0F7\uC0F9\uC100\uC104\uC108\uC110\uC115\uC11C", 4, "\uC123\uC124\uC126\uC127\uC12C\uC12D\uC12F\uC130\uC131\uC136\uC138\uC139\uC13C\uC140\uC148\uC149\uC14B\uC14C\uC14D\uC154\uC155\uC158\uC15C\uC164\uC165\uC167\uC168\uC169\uC170\uC174\uC178\uC185\uC18C\uC18D\uC18E\uC190\uC194\uC196\uC19C\uC19D\uC19F\uC1A1\uC1A5\uC1A8\uC1A9\uC1AC\uC1B0\uC1BD\uC1C4\uC1C8\uC1CC\uC1D4\uC1D7\uC1D8\uC1E0\uC1E4\uC1E8\uC1F0\uC1F1\uC1F3\uC1FC\uC1FD\uC200\uC204\uC20C\uC20D\uC20F\uC211\uC218\uC219\uC21C\uC21F\uC220\uC228\uC229\uC22B\uC22D"],
      ["bd41", "\uD3D7\uD3D9", 7, "\uD3E2\uD3E4", 7, "\uD3EE\uD3EF\uD3F1\uD3F2\uD3F3\uD3F5\uD3F6\uD3F7"],
      ["bd61", "\uD3F8\uD3F9\uD3FA\uD3FB\uD3FE\uD400\uD402", 5, "\uD409", 13],
      ["bd81", "\uD417", 5, "\uD41E", 25, "\uC22F\uC231\uC232\uC234\uC248\uC250\uC251\uC254\uC258\uC260\uC265\uC26C\uC26D\uC270\uC274\uC27C\uC27D\uC27F\uC281\uC288\uC289\uC290\uC298\uC29B\uC29D\uC2A4\uC2A5\uC2A8\uC2AC\uC2AD\uC2B4\uC2B5\uC2B7\uC2B9\uC2DC\uC2DD\uC2E0\uC2E3\uC2E4\uC2EB\uC2EC\uC2ED\uC2EF\uC2F1\uC2F6\uC2F8\uC2F9\uC2FB\uC2FC\uC300\uC308\uC309\uC30C\uC30D\uC313\uC314\uC315\uC318\uC31C\uC324\uC325\uC328\uC329\uC345\uC368\uC369\uC36C\uC370\uC372\uC378\uC379\uC37C\uC37D\uC384\uC388\uC38C\uC3C0\uC3D8\uC3D9\uC3DC\uC3DF\uC3E0\uC3E2\uC3E8\uC3E9\uC3ED\uC3F4\uC3F5\uC3F8\uC408\uC410\uC424\uC42C\uC430"],
      ["be41", "\uD438", 7, "\uD441\uD442\uD443\uD445", 14],
      ["be61", "\uD454", 7, "\uD45D\uD45E\uD45F\uD461\uD462\uD463\uD465", 7, "\uD46E\uD470\uD471\uD472"],
      ["be81", "\uD473", 4, "\uD47A\uD47B\uD47D\uD47E\uD481\uD483", 4, "\uD48A\uD48C\uD48E", 5, "\uD495", 8, "\uC434\uC43C\uC43D\uC448\uC464\uC465\uC468\uC46C\uC474\uC475\uC479\uC480\uC494\uC49C\uC4B8\uC4BC\uC4E9\uC4F0\uC4F1\uC4F4\uC4F8\uC4FA\uC4FF\uC500\uC501\uC50C\uC510\uC514\uC51C\uC528\uC529\uC52C\uC530\uC538\uC539\uC53B\uC53D\uC544\uC545\uC548\uC549\uC54A\uC54C\uC54D\uC54E\uC553\uC554\uC555\uC557\uC558\uC559\uC55D\uC55E\uC560\uC561\uC564\uC568\uC570\uC571\uC573\uC574\uC575\uC57C\uC57D\uC580\uC584\uC587\uC58C\uC58D\uC58F\uC591\uC595\uC597\uC598\uC59C\uC5A0\uC5A9\uC5B4\uC5B5\uC5B8\uC5B9\uC5BB\uC5BC\uC5BD\uC5BE\uC5C4", 6, "\uC5CC\uC5CE"],
      ["bf41", "\uD49E", 10, "\uD4AA", 14],
      ["bf61", "\uD4B9", 18, "\uD4CD\uD4CE\uD4CF\uD4D1\uD4D2\uD4D3\uD4D5"],
      ["bf81", "\uD4D6", 5, "\uD4DD\uD4DE\uD4E0", 7, "\uD4E9\uD4EA\uD4EB\uD4ED\uD4EE\uD4EF\uD4F1", 6, "\uD4F9\uD4FA\uD4FC\uC5D0\uC5D1\uC5D4\uC5D8\uC5E0\uC5E1\uC5E3\uC5E5\uC5EC\uC5ED\uC5EE\uC5F0\uC5F4\uC5F6\uC5F7\uC5FC", 5, "\uC605\uC606\uC607\uC608\uC60C\uC610\uC618\uC619\uC61B\uC61C\uC624\uC625\uC628\uC62C\uC62D\uC62E\uC630\uC633\uC634\uC635\uC637\uC639\uC63B\uC640\uC641\uC644\uC648\uC650\uC651\uC653\uC654\uC655\uC65C\uC65D\uC660\uC66C\uC66F\uC671\uC678\uC679\uC67C\uC680\uC688\uC689\uC68B\uC68D\uC694\uC695\uC698\uC69C\uC6A4\uC6A5\uC6A7\uC6A9\uC6B0\uC6B1\uC6B4\uC6B8\uC6B9\uC6BA\uC6C0\uC6C1\uC6C3\uC6C5\uC6CC\uC6CD\uC6D0\uC6D4\uC6DC\uC6DD\uC6E0\uC6E1\uC6E8"],
      ["c041", "\uD4FE", 5, "\uD505\uD506\uD507\uD509\uD50A\uD50B\uD50D", 6, "\uD516\uD518", 5],
      ["c061", "\uD51E", 25],
      ["c081", "\uD538\uD539\uD53A\uD53B\uD53E\uD53F\uD541\uD542\uD543\uD545", 6, "\uD54E\uD550\uD552", 5, "\uD55A\uD55B\uD55D\uD55E\uD55F\uD561\uD562\uD563\uC6E9\uC6EC\uC6F0\uC6F8\uC6F9\uC6FD\uC704\uC705\uC708\uC70C\uC714\uC715\uC717\uC719\uC720\uC721\uC724\uC728\uC730\uC731\uC733\uC735\uC737\uC73C\uC73D\uC740\uC744\uC74A\uC74C\uC74D\uC74F\uC751", 7, "\uC75C\uC760\uC768\uC76B\uC774\uC775\uC778\uC77C\uC77D\uC77E\uC783\uC784\uC785\uC787\uC788\uC789\uC78A\uC78E\uC790\uC791\uC794\uC796\uC797\uC798\uC79A\uC7A0\uC7A1\uC7A3\uC7A4\uC7A5\uC7A6\uC7AC\uC7AD\uC7B0\uC7B4\uC7BC\uC7BD\uC7BF\uC7C0\uC7C1\uC7C8\uC7C9\uC7CC\uC7CE\uC7D0\uC7D8\uC7DD\uC7E4\uC7E8\uC7EC\uC800\uC801\uC804\uC808\uC80A"],
      ["c141", "\uD564\uD566\uD567\uD56A\uD56C\uD56E", 5, "\uD576\uD577\uD579\uD57A\uD57B\uD57D", 6, "\uD586\uD58A\uD58B"],
      ["c161", "\uD58C\uD58D\uD58E\uD58F\uD591", 19, "\uD5A6\uD5A7"],
      ["c181", "\uD5A8", 31, "\uC810\uC811\uC813\uC815\uC816\uC81C\uC81D\uC820\uC824\uC82C\uC82D\uC82F\uC831\uC838\uC83C\uC840\uC848\uC849\uC84C\uC84D\uC854\uC870\uC871\uC874\uC878\uC87A\uC880\uC881\uC883\uC885\uC886\uC887\uC88B\uC88C\uC88D\uC894\uC89D\uC89F\uC8A1\uC8A8\uC8BC\uC8BD\uC8C4\uC8C8\uC8CC\uC8D4\uC8D5\uC8D7\uC8D9\uC8E0\uC8E1\uC8E4\uC8F5\uC8FC\uC8FD\uC900\uC904\uC905\uC906\uC90C\uC90D\uC90F\uC911\uC918\uC92C\uC934\uC950\uC951\uC954\uC958\uC960\uC961\uC963\uC96C\uC970\uC974\uC97C\uC988\uC989\uC98C\uC990\uC998\uC999\uC99B\uC99D\uC9C0\uC9C1\uC9C4\uC9C7\uC9C8\uC9CA\uC9D0\uC9D1\uC9D3"],
      ["c241", "\uD5CA\uD5CB\uD5CD\uD5CE\uD5CF\uD5D1\uD5D3", 4, "\uD5DA\uD5DC\uD5DE", 5, "\uD5E6\uD5E7\uD5E9\uD5EA\uD5EB\uD5ED\uD5EE"],
      ["c261", "\uD5EF", 4, "\uD5F6\uD5F8\uD5FA", 5, "\uD602\uD603\uD605\uD606\uD607\uD609", 6, "\uD612"],
      ["c281", "\uD616", 5, "\uD61D\uD61E\uD61F\uD621\uD622\uD623\uD625", 7, "\uD62E", 9, "\uD63A\uD63B\uC9D5\uC9D6\uC9D9\uC9DA\uC9DC\uC9DD\uC9E0\uC9E2\uC9E4\uC9E7\uC9EC\uC9ED\uC9EF\uC9F0\uC9F1\uC9F8\uC9F9\uC9FC\uCA00\uCA08\uCA09\uCA0B\uCA0C\uCA0D\uCA14\uCA18\uCA29\uCA4C\uCA4D\uCA50\uCA54\uCA5C\uCA5D\uCA5F\uCA60\uCA61\uCA68\uCA7D\uCA84\uCA98\uCABC\uCABD\uCAC0\uCAC4\uCACC\uCACD\uCACF\uCAD1\uCAD3\uCAD8\uCAD9\uCAE0\uCAEC\uCAF4\uCB08\uCB10\uCB14\uCB18\uCB20\uCB21\uCB41\uCB48\uCB49\uCB4C\uCB50\uCB58\uCB59\uCB5D\uCB64\uCB78\uCB79\uCB9C\uCBB8\uCBD4\uCBE4\uCBE7\uCBE9\uCC0C\uCC0D\uCC10\uCC14\uCC1C\uCC1D\uCC21\uCC22\uCC27\uCC28\uCC29\uCC2C\uCC2E\uCC30\uCC38\uCC39\uCC3B"],
      ["c341", "\uD63D\uD63E\uD63F\uD641\uD642\uD643\uD644\uD646\uD647\uD64A\uD64C\uD64E\uD64F\uD650\uD652\uD653\uD656\uD657\uD659\uD65A\uD65B\uD65D", 4],
      ["c361", "\uD662", 4, "\uD668\uD66A", 5, "\uD672\uD673\uD675", 11],
      ["c381", "\uD681\uD682\uD684\uD686", 5, "\uD68E\uD68F\uD691\uD692\uD693\uD695", 7, "\uD69E\uD6A0\uD6A2", 5, "\uD6A9\uD6AA\uCC3C\uCC3D\uCC3E\uCC44\uCC45\uCC48\uCC4C\uCC54\uCC55\uCC57\uCC58\uCC59\uCC60\uCC64\uCC66\uCC68\uCC70\uCC75\uCC98\uCC99\uCC9C\uCCA0\uCCA8\uCCA9\uCCAB\uCCAC\uCCAD\uCCB4\uCCB5\uCCB8\uCCBC\uCCC4\uCCC5\uCCC7\uCCC9\uCCD0\uCCD4\uCCE4\uCCEC\uCCF0\uCD01\uCD08\uCD09\uCD0C\uCD10\uCD18\uCD19\uCD1B\uCD1D\uCD24\uCD28\uCD2C\uCD39\uCD5C\uCD60\uCD64\uCD6C\uCD6D\uCD6F\uCD71\uCD78\uCD88\uCD94\uCD95\uCD98\uCD9C\uCDA4\uCDA5\uCDA7\uCDA9\uCDB0\uCDC4\uCDCC\uCDD0\uCDE8\uCDEC\uCDF0\uCDF8\uCDF9\uCDFB\uCDFD\uCE04\uCE08\uCE0C\uCE14\uCE19\uCE20\uCE21\uCE24\uCE28\uCE30\uCE31\uCE33\uCE35"],
      ["c441", "\uD6AB\uD6AD\uD6AE\uD6AF\uD6B1", 7, "\uD6BA\uD6BC", 7, "\uD6C6\uD6C7\uD6C9\uD6CA\uD6CB"],
      ["c461", "\uD6CD\uD6CE\uD6CF\uD6D0\uD6D2\uD6D3\uD6D5\uD6D6\uD6D8\uD6DA", 5, "\uD6E1\uD6E2\uD6E3\uD6E5\uD6E6\uD6E7\uD6E9", 4],
      ["c481", "\uD6EE\uD6EF\uD6F1\uD6F2\uD6F3\uD6F4\uD6F6", 5, "\uD6FE\uD6FF\uD701\uD702\uD703\uD705", 11, "\uD712\uD713\uD714\uCE58\uCE59\uCE5C\uCE5F\uCE60\uCE61\uCE68\uCE69\uCE6B\uCE6D\uCE74\uCE75\uCE78\uCE7C\uCE84\uCE85\uCE87\uCE89\uCE90\uCE91\uCE94\uCE98\uCEA0\uCEA1\uCEA3\uCEA4\uCEA5\uCEAC\uCEAD\uCEC1\uCEE4\uCEE5\uCEE8\uCEEB\uCEEC\uCEF4\uCEF5\uCEF7\uCEF8\uCEF9\uCF00\uCF01\uCF04\uCF08\uCF10\uCF11\uCF13\uCF15\uCF1C\uCF20\uCF24\uCF2C\uCF2D\uCF2F\uCF30\uCF31\uCF38\uCF54\uCF55\uCF58\uCF5C\uCF64\uCF65\uCF67\uCF69\uCF70\uCF71\uCF74\uCF78\uCF80\uCF85\uCF8C\uCFA1\uCFA8\uCFB0\uCFC4\uCFE0\uCFE1\uCFE4\uCFE8\uCFF0\uCFF1\uCFF3\uCFF5\uCFFC\uD000\uD004\uD011\uD018\uD02D\uD034\uD035\uD038\uD03C"],
      ["c541", "\uD715\uD716\uD717\uD71A\uD71B\uD71D\uD71E\uD71F\uD721", 6, "\uD72A\uD72C\uD72E", 5, "\uD736\uD737\uD739"],
      ["c561", "\uD73A\uD73B\uD73D", 6, "\uD745\uD746\uD748\uD74A", 5, "\uD752\uD753\uD755\uD75A", 4],
      ["c581", "\uD75F\uD762\uD764\uD766\uD767\uD768\uD76A\uD76B\uD76D\uD76E\uD76F\uD771\uD772\uD773\uD775", 6, "\uD77E\uD77F\uD780\uD782", 5, "\uD78A\uD78B\uD044\uD045\uD047\uD049\uD050\uD054\uD058\uD060\uD06C\uD06D\uD070\uD074\uD07C\uD07D\uD081\uD0A4\uD0A5\uD0A8\uD0AC\uD0B4\uD0B5\uD0B7\uD0B9\uD0C0\uD0C1\uD0C4\uD0C8\uD0C9\uD0D0\uD0D1\uD0D3\uD0D4\uD0D5\uD0DC\uD0DD\uD0E0\uD0E4\uD0EC\uD0ED\uD0EF\uD0F0\uD0F1\uD0F8\uD10D\uD130\uD131\uD134\uD138\uD13A\uD140\uD141\uD143\uD144\uD145\uD14C\uD14D\uD150\uD154\uD15C\uD15D\uD15F\uD161\uD168\uD16C\uD17C\uD184\uD188\uD1A0\uD1A1\uD1A4\uD1A8\uD1B0\uD1B1\uD1B3\uD1B5\uD1BA\uD1BC\uD1C0\uD1D8\uD1F4\uD1F8\uD207\uD209\uD210\uD22C\uD22D\uD230\uD234\uD23C\uD23D\uD23F\uD241\uD248\uD25C"],
      ["c641", "\uD78D\uD78E\uD78F\uD791", 6, "\uD79A\uD79C\uD79E", 5],
      ["c6a1", "\uD264\uD280\uD281\uD284\uD288\uD290\uD291\uD295\uD29C\uD2A0\uD2A4\uD2AC\uD2B1\uD2B8\uD2B9\uD2BC\uD2BF\uD2C0\uD2C2\uD2C8\uD2C9\uD2CB\uD2D4\uD2D8\uD2DC\uD2E4\uD2E5\uD2F0\uD2F1\uD2F4\uD2F8\uD300\uD301\uD303\uD305\uD30C\uD30D\uD30E\uD310\uD314\uD316\uD31C\uD31D\uD31F\uD320\uD321\uD325\uD328\uD329\uD32C\uD330\uD338\uD339\uD33B\uD33C\uD33D\uD344\uD345\uD37C\uD37D\uD380\uD384\uD38C\uD38D\uD38F\uD390\uD391\uD398\uD399\uD39C\uD3A0\uD3A8\uD3A9\uD3AB\uD3AD\uD3B4\uD3B8\uD3BC\uD3C4\uD3C5\uD3C8\uD3C9\uD3D0\uD3D8\uD3E1\uD3E3\uD3EC\uD3ED\uD3F0\uD3F4\uD3FC\uD3FD\uD3FF\uD401"],
      ["c7a1", "\uD408\uD41D\uD440\uD444\uD45C\uD460\uD464\uD46D\uD46F\uD478\uD479\uD47C\uD47F\uD480\uD482\uD488\uD489\uD48B\uD48D\uD494\uD4A9\uD4CC\uD4D0\uD4D4\uD4DC\uD4DF\uD4E8\uD4EC\uD4F0\uD4F8\uD4FB\uD4FD\uD504\uD508\uD50C\uD514\uD515\uD517\uD53C\uD53D\uD540\uD544\uD54C\uD54D\uD54F\uD551\uD558\uD559\uD55C\uD560\uD565\uD568\uD569\uD56B\uD56D\uD574\uD575\uD578\uD57C\uD584\uD585\uD587\uD588\uD589\uD590\uD5A5\uD5C8\uD5C9\uD5CC\uD5D0\uD5D2\uD5D8\uD5D9\uD5DB\uD5DD\uD5E4\uD5E5\uD5E8\uD5EC\uD5F4\uD5F5\uD5F7\uD5F9\uD600\uD601\uD604\uD608\uD610\uD611\uD613\uD614\uD615\uD61C\uD620"],
      ["c8a1", "\uD624\uD62D\uD638\uD639\uD63C\uD640\uD645\uD648\uD649\uD64B\uD64D\uD651\uD654\uD655\uD658\uD65C\uD667\uD669\uD670\uD671\uD674\uD683\uD685\uD68C\uD68D\uD690\uD694\uD69D\uD69F\uD6A1\uD6A8\uD6AC\uD6B0\uD6B9\uD6BB\uD6C4\uD6C5\uD6C8\uD6CC\uD6D1\uD6D4\uD6D7\uD6D9\uD6E0\uD6E4\uD6E8\uD6F0\uD6F5\uD6FC\uD6FD\uD700\uD704\uD711\uD718\uD719\uD71C\uD720\uD728\uD729\uD72B\uD72D\uD734\uD735\uD738\uD73C\uD744\uD747\uD749\uD750\uD751\uD754\uD756\uD757\uD758\uD759\uD760\uD761\uD763\uD765\uD769\uD76C\uD770\uD774\uD77C\uD77D\uD781\uD788\uD789\uD78C\uD790\uD798\uD799\uD79B\uD79D"],
      ["caa1", "\u4F3D\u4F73\u5047\u50F9\u52A0\u53EF\u5475\u54E5\u5609\u5AC1\u5BB6\u6687\u67B6\u67B7\u67EF\u6B4C\u73C2\u75C2\u7A3C\u82DB\u8304\u8857\u8888\u8A36\u8CC8\u8DCF\u8EFB\u8FE6\u99D5\u523B\u5374\u5404\u606A\u6164\u6BBC\u73CF\u811A\u89BA\u89D2\u95A3\u4F83\u520A\u58BE\u5978\u59E6\u5E72\u5E79\u61C7\u63C0\u6746\u67EC\u687F\u6F97\u764E\u770B\u78F5\u7A08\u7AFF\u7C21\u809D\u826E\u8271\u8AEB\u9593\u4E6B\u559D\u66F7\u6E34\u78A3\u7AED\u845B\u8910\u874E\u97A8\u52D8\u574E\u582A\u5D4C\u611F\u61BE\u6221\u6562\u67D1\u6A44\u6E1B\u7518\u75B3\u76E3\u77B0\u7D3A\u90AF\u9451\u9452\u9F95"],
      ["cba1", "\u5323\u5CAC\u7532\u80DB\u9240\u9598\u525B\u5808\u59DC\u5CA1\u5D17\u5EB7\u5F3A\u5F4A\u6177\u6C5F\u757A\u7586\u7CE0\u7D73\u7DB1\u7F8C\u8154\u8221\u8591\u8941\u8B1B\u92FC\u964D\u9C47\u4ECB\u4EF7\u500B\u51F1\u584F\u6137\u613E\u6168\u6539\u69EA\u6F11\u75A5\u7686\u76D6\u7B87\u82A5\u84CB\uF900\u93A7\u958B\u5580\u5BA2\u5751\uF901\u7CB3\u7FB9\u91B5\u5028\u53BB\u5C45\u5DE8\u62D2\u636E\u64DA\u64E7\u6E20\u70AC\u795B\u8DDD\u8E1E\uF902\u907D\u9245\u92F8\u4E7E\u4EF6\u5065\u5DFE\u5EFA\u6106\u6957\u8171\u8654\u8E47\u9375\u9A2B\u4E5E\u5091\u6770\u6840\u5109\u528D\u5292\u6AA2"],
      ["cca1", "\u77BC\u9210\u9ED4\u52AB\u602F\u8FF2\u5048\u61A9\u63ED\u64CA\u683C\u6A84\u6FC0\u8188\u89A1\u9694\u5805\u727D\u72AC\u7504\u7D79\u7E6D\u80A9\u898B\u8B74\u9063\u9D51\u6289\u6C7A\u6F54\u7D50\u7F3A\u8A23\u517C\u614A\u7B9D\u8B19\u9257\u938C\u4EAC\u4FD3\u501E\u50BE\u5106\u52C1\u52CD\u537F\u5770\u5883\u5E9A\u5F91\u6176\u61AC\u64CE\u656C\u666F\u66BB\u66F4\u6897\u6D87\u7085\u70F1\u749F\u74A5\u74CA\u75D9\u786C\u78EC\u7ADF\u7AF6\u7D45\u7D93\u8015\u803F\u811B\u8396\u8B66\u8F15\u9015\u93E1\u9803\u9838\u9A5A\u9BE8\u4FC2\u5553\u583A\u5951\u5B63\u5C46\u60B8\u6212\u6842\u68B0"],
      ["cda1", "\u68E8\u6EAA\u754C\u7678\u78CE\u7A3D\u7CFB\u7E6B\u7E7C\u8A08\u8AA1\u8C3F\u968E\u9DC4\u53E4\u53E9\u544A\u5471\u56FA\u59D1\u5B64\u5C3B\u5EAB\u62F7\u6537\u6545\u6572\u66A0\u67AF\u69C1\u6CBD\u75FC\u7690\u777E\u7A3F\u7F94\u8003\u80A1\u818F\u82E6\u82FD\u83F0\u85C1\u8831\u88B4\u8AA5\uF903\u8F9C\u932E\u96C7\u9867\u9AD8\u9F13\u54ED\u659B\u66F2\u688F\u7A40\u8C37\u9D60\u56F0\u5764\u5D11\u6606\u68B1\u68CD\u6EFE\u7428\u889E\u9BE4\u6C68\uF904\u9AA8\u4F9B\u516C\u5171\u529F\u5B54\u5DE5\u6050\u606D\u62F1\u63A7\u653B\u73D9\u7A7A\u86A3\u8CA2\u978F\u4E32\u5BE1\u6208\u679C\u74DC"],
      ["cea1", "\u79D1\u83D3\u8A87\u8AB2\u8DE8\u904E\u934B\u9846\u5ED3\u69E8\u85FF\u90ED\uF905\u51A0\u5B98\u5BEC\u6163\u68FA\u6B3E\u704C\u742F\u74D8\u7BA1\u7F50\u83C5\u89C0\u8CAB\u95DC\u9928\u522E\u605D\u62EC\u9002\u4F8A\u5149\u5321\u58D9\u5EE3\u66E0\u6D38\u709A\u72C2\u73D6\u7B50\u80F1\u945B\u5366\u639B\u7F6B\u4E56\u5080\u584A\u58DE\u602A\u6127\u62D0\u69D0\u9B41\u5B8F\u7D18\u80B1\u8F5F\u4EA4\u50D1\u54AC\u55AC\u5B0C\u5DA0\u5DE7\u652A\u654E\u6821\u6A4B\u72E1\u768E\u77EF\u7D5E\u7FF9\u81A0\u854E\u86DF\u8F03\u8F4E\u90CA\u9903\u9A55\u9BAB\u4E18\u4E45\u4E5D\u4EC7\u4FF1\u5177\u52FE"],
      ["cfa1", "\u5340\u53E3\u53E5\u548E\u5614\u5775\u57A2\u5BC7\u5D87\u5ED0\u61FC\u62D8\u6551\u67B8\u67E9\u69CB\u6B50\u6BC6\u6BEC\u6C42\u6E9D\u7078\u72D7\u7396\u7403\u77BF\u77E9\u7A76\u7D7F\u8009\u81FC\u8205\u820A\u82DF\u8862\u8B33\u8CFC\u8EC0\u9011\u90B1\u9264\u92B6\u99D2\u9A45\u9CE9\u9DD7\u9F9C\u570B\u5C40\u83CA\u97A0\u97AB\u9EB4\u541B\u7A98\u7FA4\u88D9\u8ECD\u90E1\u5800\u5C48\u6398\u7A9F\u5BAE\u5F13\u7A79\u7AAE\u828E\u8EAC\u5026\u5238\u52F8\u5377\u5708\u62F3\u6372\u6B0A\u6DC3\u7737\u53A5\u7357\u8568\u8E76\u95D5\u673A\u6AC3\u6F70\u8A6D\u8ECC\u994B\uF906\u6677\u6B78\u8CB4"],
      ["d0a1", "\u9B3C\uF907\u53EB\u572D\u594E\u63C6\u69FB\u73EA\u7845\u7ABA\u7AC5\u7CFE\u8475\u898F\u8D73\u9035\u95A8\u52FB\u5747\u7547\u7B60\u83CC\u921E\uF908\u6A58\u514B\u524B\u5287\u621F\u68D8\u6975\u9699\u50C5\u52A4\u52E4\u61C3\u65A4\u6839\u69FF\u747E\u7B4B\u82B9\u83EB\u89B2\u8B39\u8FD1\u9949\uF909\u4ECA\u5997\u64D2\u6611\u6A8E\u7434\u7981\u79BD\u82A9\u887E\u887F\u895F\uF90A\u9326\u4F0B\u53CA\u6025\u6271\u6C72\u7D1A\u7D66\u4E98\u5162\u77DC\u80AF\u4F01\u4F0E\u5176\u5180\u55DC\u5668\u573B\u57FA\u57FC\u5914\u5947\u5993\u5BC4\u5C90\u5D0E\u5DF1\u5E7E\u5FCC\u6280\u65D7\u65E3"],
      ["d1a1", "\u671E\u671F\u675E\u68CB\u68C4\u6A5F\u6B3A\u6C23\u6C7D\u6C82\u6DC7\u7398\u7426\u742A\u7482\u74A3\u7578\u757F\u7881\u78EF\u7941\u7947\u7948\u797A\u7B95\u7D00\u7DBA\u7F88\u8006\u802D\u808C\u8A18\u8B4F\u8C48\u8D77\u9321\u9324\u98E2\u9951\u9A0E\u9A0F\u9A65\u9E92\u7DCA\u4F76\u5409\u62EE\u6854\u91D1\u55AB\u513A\uF90B\uF90C\u5A1C\u61E6\uF90D\u62CF\u62FF\uF90E", 5, "\u90A3\uF914", 4, "\u8AFE\uF919\uF91A\uF91B\uF91C\u6696\uF91D\u7156\uF91E\uF91F\u96E3\uF920\u634F\u637A\u5357\uF921\u678F\u6960\u6E73\uF922\u7537\uF923\uF924\uF925"],
      ["d2a1", "\u7D0D\uF926\uF927\u8872\u56CA\u5A18\uF928", 4, "\u4E43\uF92D\u5167\u5948\u67F0\u8010\uF92E\u5973\u5E74\u649A\u79CA\u5FF5\u606C\u62C8\u637B\u5BE7\u5BD7\u52AA\uF92F\u5974\u5F29\u6012\uF930\uF931\uF932\u7459\uF933", 5, "\u99D1\uF939", 10, "\u6FC3\uF944\uF945\u81BF\u8FB2\u60F1\uF946\uF947\u8166\uF948\uF949\u5C3F\uF94A", 7, "\u5AE9\u8A25\u677B\u7D10\uF952", 5, "\u80FD\uF958\uF959\u5C3C\u6CE5\u533F\u6EBA\u591A\u8336"],
      ["d3a1", "\u4E39\u4EB6\u4F46\u55AE\u5718\u58C7\u5F56\u65B7\u65E6\u6A80\u6BB5\u6E4D\u77ED\u7AEF\u7C1E\u7DDE\u86CB\u8892\u9132\u935B\u64BB\u6FBE\u737A\u75B8\u9054\u5556\u574D\u61BA\u64D4\u66C7\u6DE1\u6E5B\u6F6D\u6FB9\u75F0\u8043\u81BD\u8541\u8983\u8AC7\u8B5A\u931F\u6C93\u7553\u7B54\u8E0F\u905D\u5510\u5802\u5858\u5E62\u6207\u649E\u68E0\u7576\u7CD6\u87B3\u9EE8\u4EE3\u5788\u576E\u5927\u5C0D\u5CB1\u5E36\u5F85\u6234\u64E1\u73B3\u81FA\u888B\u8CB8\u968A\u9EDB\u5B85\u5FB7\u60B3\u5012\u5200\u5230\u5716\u5835\u5857\u5C0E\u5C60\u5CF6\u5D8B\u5EA6\u5F92\u60BC\u6311\u6389\u6417\u6843"],
      ["d4a1", "\u68F9\u6AC2\u6DD8\u6E21\u6ED4\u6FE4\u71FE\u76DC\u7779\u79B1\u7A3B\u8404\u89A9\u8CED\u8DF3\u8E48\u9003\u9014\u9053\u90FD\u934D\u9676\u97DC\u6BD2\u7006\u7258\u72A2\u7368\u7763\u79BF\u7BE4\u7E9B\u8B80\u58A9\u60C7\u6566\u65FD\u66BE\u6C8C\u711E\u71C9\u8C5A\u9813\u4E6D\u7A81\u4EDD\u51AC\u51CD\u52D5\u540C\u61A7\u6771\u6850\u68DF\u6D1E\u6F7C\u75BC\u77B3\u7AE5\u80F4\u8463\u9285\u515C\u6597\u675C\u6793\u75D8\u7AC7\u8373\uF95A\u8C46\u9017\u982D\u5C6F\u81C0\u829A\u9041\u906F\u920D\u5F97\u5D9D\u6A59\u71C8\u767B\u7B49\u85E4\u8B04\u9127\u9A30\u5587\u61F6\uF95B\u7669\u7F85"],
      ["d5a1", "\u863F\u87BA\u88F8\u908F\uF95C\u6D1B\u70D9\u73DE\u7D61\u843D\uF95D\u916A\u99F1\uF95E\u4E82\u5375\u6B04\u6B12\u703E\u721B\u862D\u9E1E\u524C\u8FA3\u5D50\u64E5\u652C\u6B16\u6FEB\u7C43\u7E9C\u85CD\u8964\u89BD\u62C9\u81D8\u881F\u5ECA\u6717\u6D6A\u72FC\u7405\u746F\u8782\u90DE\u4F86\u5D0D\u5FA0\u840A\u51B7\u63A0\u7565\u4EAE\u5006\u5169\u51C9\u6881\u6A11\u7CAE\u7CB1\u7CE7\u826F\u8AD2\u8F1B\u91CF\u4FB6\u5137\u52F5\u5442\u5EEC\u616E\u623E\u65C5\u6ADA\u6FFE\u792A\u85DC\u8823\u95AD\u9A62\u9A6A\u9E97\u9ECE\u529B\u66C6\u6B77\u701D\u792B\u8F62\u9742\u6190\u6200\u6523\u6F23"],
      ["d6a1", "\u7149\u7489\u7DF4\u806F\u84EE\u8F26\u9023\u934A\u51BD\u5217\u52A3\u6D0C\u70C8\u88C2\u5EC9\u6582\u6BAE\u6FC2\u7C3E\u7375\u4EE4\u4F36\u56F9\uF95F\u5CBA\u5DBA\u601C\u73B2\u7B2D\u7F9A\u7FCE\u8046\u901E\u9234\u96F6\u9748\u9818\u9F61\u4F8B\u6FA7\u79AE\u91B4\u96B7\u52DE\uF960\u6488\u64C4\u6AD3\u6F5E\u7018\u7210\u76E7\u8001\u8606\u865C\u8DEF\u8F05\u9732\u9B6F\u9DFA\u9E75\u788C\u797F\u7DA0\u83C9\u9304\u9E7F\u9E93\u8AD6\u58DF\u5F04\u6727\u7027\u74CF\u7C60\u807E\u5121\u7028\u7262\u78CA\u8CC2\u8CDA\u8CF4\u96F7\u4E86\u50DA\u5BEE\u5ED6\u6599\u71CE\u7642\u77AD\u804A\u84FC"],
      ["d7a1", "\u907C\u9B27\u9F8D\u58D8\u5A41\u5C62\u6A13\u6DDA\u6F0F\u763B\u7D2F\u7E37\u851E\u8938\u93E4\u964B\u5289\u65D2\u67F3\u69B4\u6D41\u6E9C\u700F\u7409\u7460\u7559\u7624\u786B\u8B2C\u985E\u516D\u622E\u9678\u4F96\u502B\u5D19\u6DEA\u7DB8\u8F2A\u5F8B\u6144\u6817\uF961\u9686\u52D2\u808B\u51DC\u51CC\u695E\u7A1C\u7DBE\u83F1\u9675\u4FDA\u5229\u5398\u540F\u550E\u5C65\u60A7\u674E\u68A8\u6D6C\u7281\u72F8\u7406\u7483\uF962\u75E2\u7C6C\u7F79\u7FB8\u8389\u88CF\u88E1\u91CC\u91D0\u96E2\u9BC9\u541D\u6F7E\u71D0\u7498\u85FA\u8EAA\u96A3\u9C57\u9E9F\u6797\u6DCB\u7433\u81E8\u9716\u782C"],
      ["d8a1", "\u7ACB\u7B20\u7C92\u6469\u746A\u75F2\u78BC\u78E8\u99AC\u9B54\u9EBB\u5BDE\u5E55\u6F20\u819C\u83AB\u9088\u4E07\u534D\u5A29\u5DD2\u5F4E\u6162\u633D\u6669\u66FC\u6EFF\u6F2B\u7063\u779E\u842C\u8513\u883B\u8F13\u9945\u9C3B\u551C\u62B9\u672B\u6CAB\u8309\u896A\u977A\u4EA1\u5984\u5FD8\u5FD9\u671B\u7DB2\u7F54\u8292\u832B\u83BD\u8F1E\u9099\u57CB\u59B9\u5A92\u5BD0\u6627\u679A\u6885\u6BCF\u7164\u7F75\u8CB7\u8CE3\u9081\u9B45\u8108\u8C8A\u964C\u9A40\u9EA5\u5B5F\u6C13\u731B\u76F2\u76DF\u840C\u51AA\u8993\u514D\u5195\u52C9\u68C9\u6C94\u7704\u7720\u7DBF\u7DEC\u9762\u9EB5\u6EC5"],
      ["d9a1", "\u8511\u51A5\u540D\u547D\u660E\u669D\u6927\u6E9F\u76BF\u7791\u8317\u84C2\u879F\u9169\u9298\u9CF4\u8882\u4FAE\u5192\u52DF\u59C6\u5E3D\u6155\u6478\u6479\u66AE\u67D0\u6A21\u6BCD\u6BDB\u725F\u7261\u7441\u7738\u77DB\u8017\u82BC\u8305\u8B00\u8B28\u8C8C\u6728\u6C90\u7267\u76EE\u7766\u7A46\u9DA9\u6B7F\u6C92\u5922\u6726\u8499\u536F\u5893\u5999\u5EDF\u63CF\u6634\u6773\u6E3A\u732B\u7AD7\u82D7\u9328\u52D9\u5DEB\u61AE\u61CB\u620A\u62C7\u64AB\u65E0\u6959\u6B66\u6BCB\u7121\u73F7\u755D\u7E46\u821E\u8302\u856A\u8AA3\u8CBF\u9727\u9D61\u58A8\u9ED8\u5011\u520E\u543B\u554F\u6587"],
      ["daa1", "\u6C76\u7D0A\u7D0B\u805E\u868A\u9580\u96EF\u52FF\u6C95\u7269\u5473\u5A9A\u5C3E\u5D4B\u5F4C\u5FAE\u672A\u68B6\u6963\u6E3C\u6E44\u7709\u7C73\u7F8E\u8587\u8B0E\u8FF7\u9761\u9EF4\u5CB7\u60B6\u610D\u61AB\u654F\u65FB\u65FC\u6C11\u6CEF\u739F\u73C9\u7DE1\u9594\u5BC6\u871C\u8B10\u525D\u535A\u62CD\u640F\u64B2\u6734\u6A38\u6CCA\u73C0\u749E\u7B94\u7C95\u7E1B\u818A\u8236\u8584\u8FEB\u96F9\u99C1\u4F34\u534A\u53CD\u53DB\u62CC\u642C\u6500\u6591\u69C3\u6CEE\u6F58\u73ED\u7554\u7622\u76E4\u76FC\u78D0\u78FB\u792C\u7D46\u822C\u87E0\u8FD4\u9812\u98EF\u52C3\u62D4\u64A5\u6E24\u6F51"],
      ["dba1", "\u767C\u8DCB\u91B1\u9262\u9AEE\u9B43\u5023\u508D\u574A\u59A8\u5C28\u5E47\u5F77\u623F\u653E\u65B9\u65C1\u6609\u678B\u699C\u6EC2\u78C5\u7D21\u80AA\u8180\u822B\u82B3\u84A1\u868C\u8A2A\u8B17\u90A6\u9632\u9F90\u500D\u4FF3\uF963\u57F9\u5F98\u62DC\u6392\u676F\u6E43\u7119\u76C3\u80CC\u80DA\u88F4\u88F5\u8919\u8CE0\u8F29\u914D\u966A\u4F2F\u4F70\u5E1B\u67CF\u6822\u767D\u767E\u9B44\u5E61\u6A0A\u7169\u71D4\u756A\uF964\u7E41\u8543\u85E9\u98DC\u4F10\u7B4F\u7F70\u95A5\u51E1\u5E06\u68B5\u6C3E\u6C4E\u6CDB\u72AF\u7BC4\u8303\u6CD5\u743A\u50FB\u5288\u58C1\u64D8\u6A97\u74A7\u7656"],
      ["dca1", "\u78A7\u8617\u95E2\u9739\uF965\u535E\u5F01\u8B8A\u8FA8\u8FAF\u908A\u5225\u77A5\u9C49\u9F08\u4E19\u5002\u5175\u5C5B\u5E77\u661E\u663A\u67C4\u68C5\u70B3\u7501\u75C5\u79C9\u7ADD\u8F27\u9920\u9A08\u4FDD\u5821\u5831\u5BF6\u666E\u6B65\u6D11\u6E7A\u6F7D\u73E4\u752B\u83E9\u88DC\u8913\u8B5C\u8F14\u4F0F\u50D5\u5310\u535C\u5B93\u5FA9\u670D\u798F\u8179\u832F\u8514\u8907\u8986\u8F39\u8F3B\u99A5\u9C12\u672C\u4E76\u4FF8\u5949\u5C01\u5CEF\u5CF0\u6367\u68D2\u70FD\u71A2\u742B\u7E2B\u84EC\u8702\u9022\u92D2\u9CF3\u4E0D\u4ED8\u4FEF\u5085\u5256\u526F\u5426\u5490\u57E0\u592B\u5A66"],
      ["dda1", "\u5B5A\u5B75\u5BCC\u5E9C\uF966\u6276\u6577\u65A7\u6D6E\u6EA5\u7236\u7B26\u7C3F\u7F36\u8150\u8151\u819A\u8240\u8299\u83A9\u8A03\u8CA0\u8CE6\u8CFB\u8D74\u8DBA\u90E8\u91DC\u961C\u9644\u99D9\u9CE7\u5317\u5206\u5429\u5674\u58B3\u5954\u596E\u5FFF\u61A4\u626E\u6610\u6C7E\u711A\u76C6\u7C89\u7CDE\u7D1B\u82AC\u8CC1\u96F0\uF967\u4F5B\u5F17\u5F7F\u62C2\u5D29\u670B\u68DA\u787C\u7E43\u9D6C\u4E15\u5099\u5315\u532A\u5351\u5983\u5A62\u5E87\u60B2\u618A\u6249\u6279\u6590\u6787\u69A7\u6BD4\u6BD6\u6BD7\u6BD8\u6CB8\uF968\u7435\u75FA\u7812\u7891\u79D5\u79D8\u7C83\u7DCB\u7FE1\u80A5"],
      ["dea1", "\u813E\u81C2\u83F2\u871A\u88E8\u8AB9\u8B6C\u8CBB\u9119\u975E\u98DB\u9F3B\u56AC\u5B2A\u5F6C\u658C\u6AB3\u6BAF\u6D5C\u6FF1\u7015\u725D\u73AD\u8CA7\u8CD3\u983B\u6191\u6C37\u8058\u9A01\u4E4D\u4E8B\u4E9B\u4ED5\u4F3A\u4F3C\u4F7F\u4FDF\u50FF\u53F2\u53F8\u5506\u55E3\u56DB\u58EB\u5962\u5A11\u5BEB\u5BFA\u5C04\u5DF3\u5E2B\u5F99\u601D\u6368\u659C\u65AF\u67F6\u67FB\u68AD\u6B7B\u6C99\u6CD7\u6E23\u7009\u7345\u7802\u793E\u7940\u7960\u79C1\u7BE9\u7D17\u7D72\u8086\u820D\u838E\u84D1\u86C7\u88DF\u8A50\u8A5E\u8B1D\u8CDC\u8D66\u8FAD\u90AA\u98FC\u99DF\u9E9D\u524A\uF969\u6714\uF96A"],
      ["dfa1", "\u5098\u522A\u5C71\u6563\u6C55\u73CA\u7523\u759D\u7B97\u849C\u9178\u9730\u4E77\u6492\u6BBA\u715E\u85A9\u4E09\uF96B\u6749\u68EE\u6E17\u829F\u8518\u886B\u63F7\u6F81\u9212\u98AF\u4E0A\u50B7\u50CF\u511F\u5546\u55AA\u5617\u5B40\u5C19\u5CE0\u5E38\u5E8A\u5EA0\u5EC2\u60F3\u6851\u6A61\u6E58\u723D\u7240\u72C0\u76F8\u7965\u7BB1\u7FD4\u88F3\u89F4\u8A73\u8C61\u8CDE\u971C\u585E\u74BD\u8CFD\u55C7\uF96C\u7A61\u7D22\u8272\u7272\u751F\u7525\uF96D\u7B19\u5885\u58FB\u5DBC\u5E8F\u5EB6\u5F90\u6055\u6292\u637F\u654D\u6691\u66D9\u66F8\u6816\u68F2\u7280\u745E\u7B6E\u7D6E\u7DD6\u7F72"],
      ["e0a1", "\u80E5\u8212\u85AF\u897F\u8A93\u901D\u92E4\u9ECD\u9F20\u5915\u596D\u5E2D\u60DC\u6614\u6673\u6790\u6C50\u6DC5\u6F5F\u77F3\u78A9\u84C6\u91CB\u932B\u4ED9\u50CA\u5148\u5584\u5B0B\u5BA3\u6247\u657E\u65CB\u6E32\u717D\u7401\u7444\u7487\u74BF\u766C\u79AA\u7DDA\u7E55\u7FA8\u817A\u81B3\u8239\u861A\u87EC\u8A75\u8DE3\u9078\u9291\u9425\u994D\u9BAE\u5368\u5C51\u6954\u6CC4\u6D29\u6E2B\u820C\u859B\u893B\u8A2D\u8AAA\u96EA\u9F67\u5261\u66B9\u6BB2\u7E96\u87FE\u8D0D\u9583\u965D\u651D\u6D89\u71EE\uF96E\u57CE\u59D3\u5BAC\u6027\u60FA\u6210\u661F\u665F\u7329\u73F9\u76DB\u7701\u7B6C"],
      ["e1a1", "\u8056\u8072\u8165\u8AA0\u9192\u4E16\u52E2\u6B72\u6D17\u7A05\u7B39\u7D30\uF96F\u8CB0\u53EC\u562F\u5851\u5BB5\u5C0F\u5C11\u5DE2\u6240\u6383\u6414\u662D\u68B3\u6CBC\u6D88\u6EAF\u701F\u70A4\u71D2\u7526\u758F\u758E\u7619\u7B11\u7BE0\u7C2B\u7D20\u7D39\u852C\u856D\u8607\u8A34\u900D\u9061\u90B5\u92B7\u97F6\u9A37\u4FD7\u5C6C\u675F\u6D91\u7C9F\u7E8C\u8B16\u8D16\u901F\u5B6B\u5DFD\u640D\u84C0\u905C\u98E1\u7387\u5B8B\u609A\u677E\u6DDE\u8A1F\u8AA6\u9001\u980C\u5237\uF970\u7051\u788E\u9396\u8870\u91D7\u4FEE\u53D7\u55FD\u56DA\u5782\u58FD\u5AC2\u5B88\u5CAB\u5CC0\u5E25\u6101"],
      ["e2a1", "\u620D\u624B\u6388\u641C\u6536\u6578\u6A39\u6B8A\u6C34\u6D19\u6F31\u71E7\u72E9\u7378\u7407\u74B2\u7626\u7761\u79C0\u7A57\u7AEA\u7CB9\u7D8F\u7DAC\u7E61\u7F9E\u8129\u8331\u8490\u84DA\u85EA\u8896\u8AB0\u8B90\u8F38\u9042\u9083\u916C\u9296\u92B9\u968B\u96A7\u96A8\u96D6\u9700\u9808\u9996\u9AD3\u9B1A\u53D4\u587E\u5919\u5B70\u5BBF\u6DD1\u6F5A\u719F\u7421\u74B9\u8085\u83FD\u5DE1\u5F87\u5FAA\u6042\u65EC\u6812\u696F\u6A53\u6B89\u6D35\u6DF3\u73E3\u76FE\u77AC\u7B4D\u7D14\u8123\u821C\u8340\u84F4\u8563\u8A62\u8AC4\u9187\u931E\u9806\u99B4\u620C\u8853\u8FF0\u9265\u5D07\u5D27"],
      ["e3a1", "\u5D69\u745F\u819D\u8768\u6FD5\u62FE\u7FD2\u8936\u8972\u4E1E\u4E58\u50E7\u52DD\u5347\u627F\u6607\u7E69\u8805\u965E\u4F8D\u5319\u5636\u59CB\u5AA4\u5C38\u5C4E\u5C4D\u5E02\u5F11\u6043\u65BD\u662F\u6642\u67BE\u67F4\u731C\u77E2\u793A\u7FC5\u8494\u84CD\u8996\u8A66\u8A69\u8AE1\u8C55\u8C7A\u57F4\u5BD4\u5F0F\u606F\u62ED\u690D\u6B96\u6E5C\u7184\u7BD2\u8755\u8B58\u8EFE\u98DF\u98FE\u4F38\u4F81\u4FE1\u547B\u5A20\u5BB8\u613C\u65B0\u6668\u71FC\u7533\u795E\u7D33\u814E\u81E3\u8398\u85AA\u85CE\u8703\u8A0A\u8EAB\u8F9B\uF971\u8FC5\u5931\u5BA4\u5BE6\u6089\u5BE9\u5C0B\u5FC3\u6C81"],
      ["e4a1", "\uF972\u6DF1\u700B\u751A\u82AF\u8AF6\u4EC0\u5341\uF973\u96D9\u6C0F\u4E9E\u4FC4\u5152\u555E\u5A25\u5CE8\u6211\u7259\u82BD\u83AA\u86FE\u8859\u8A1D\u963F\u96C5\u9913\u9D09\u9D5D\u580A\u5CB3\u5DBD\u5E44\u60E1\u6115\u63E1\u6A02\u6E25\u9102\u9354\u984E\u9C10\u9F77\u5B89\u5CB8\u6309\u664F\u6848\u773C\u96C1\u978D\u9854\u9B9F\u65A1\u8B01\u8ECB\u95BC\u5535\u5CA9\u5DD6\u5EB5\u6697\u764C\u83F4\u95C7\u58D3\u62BC\u72CE\u9D28\u4EF0\u592E\u600F\u663B\u6B83\u79E7\u9D26\u5393\u54C0\u57C3\u5D16\u611B\u66D6\u6DAF\u788D\u827E\u9698\u9744\u5384\u627C\u6396\u6DB2\u7E0A\u814B\u984D"],
      ["e5a1", "\u6AFB\u7F4C\u9DAF\u9E1A\u4E5F\u503B\u51B6\u591C\u60F9\u63F6\u6930\u723A\u8036\uF974\u91CE\u5F31\uF975\uF976\u7D04\u82E5\u846F\u84BB\u85E5\u8E8D\uF977\u4F6F\uF978\uF979\u58E4\u5B43\u6059\u63DA\u6518\u656D\u6698\uF97A\u694A\u6A23\u6D0B\u7001\u716C\u75D2\u760D\u79B3\u7A70\uF97B\u7F8A\uF97C\u8944\uF97D\u8B93\u91C0\u967D\uF97E\u990A\u5704\u5FA1\u65BC\u6F01\u7600\u79A6\u8A9E\u99AD\u9B5A\u9F6C\u5104\u61B6\u6291\u6A8D\u81C6\u5043\u5830\u5F66\u7109\u8A00\u8AFA\u5B7C\u8616\u4FFA\u513C\u56B4\u5944\u63A9\u6DF9\u5DAA\u696D\u5186\u4E88\u4F59\uF97F\uF980\uF981\u5982\uF982"],
      ["e6a1", "\uF983\u6B5F\u6C5D\uF984\u74B5\u7916\uF985\u8207\u8245\u8339\u8F3F\u8F5D\uF986\u9918\uF987\uF988\uF989\u4EA6\uF98A\u57DF\u5F79\u6613\uF98B\uF98C\u75AB\u7E79\u8B6F\uF98D\u9006\u9A5B\u56A5\u5827\u59F8\u5A1F\u5BB4\uF98E\u5EF6\uF98F\uF990\u6350\u633B\uF991\u693D\u6C87\u6CBF\u6D8E\u6D93\u6DF5\u6F14\uF992\u70DF\u7136\u7159\uF993\u71C3\u71D5\uF994\u784F\u786F\uF995\u7B75\u7DE3\uF996\u7E2F\uF997\u884D\u8EDF\uF998\uF999\uF99A\u925B\uF99B\u9CF6\uF99C\uF99D\uF99E\u6085\u6D85\uF99F\u71B1\uF9A0\uF9A1\u95B1\u53AD\uF9A2\uF9A3\uF9A4\u67D3\uF9A5\u708E\u7130\u7430\u8276\u82D2"],
      ["e7a1", "\uF9A6\u95BB\u9AE5\u9E7D\u66C4\uF9A7\u71C1\u8449\uF9A8\uF9A9\u584B\uF9AA\uF9AB\u5DB8\u5F71\uF9AC\u6620\u668E\u6979\u69AE\u6C38\u6CF3\u6E36\u6F41\u6FDA\u701B\u702F\u7150\u71DF\u7370\uF9AD\u745B\uF9AE\u74D4\u76C8\u7A4E\u7E93\uF9AF\uF9B0\u82F1\u8A60\u8FCE\uF9B1\u9348\uF9B2\u9719\uF9B3\uF9B4\u4E42\u502A\uF9B5\u5208\u53E1\u66F3\u6C6D\u6FCA\u730A\u777F\u7A62\u82AE\u85DD\u8602\uF9B6\u88D4\u8A63\u8B7D\u8C6B\uF9B7\u92B3\uF9B8\u9713\u9810\u4E94\u4F0D\u4FC9\u50B2\u5348\u543E\u5433\u55DA\u5862\u58BA\u5967\u5A1B\u5BE4\u609F\uF9B9\u61CA\u6556\u65FF\u6664\u68A7\u6C5A\u6FB3"],
      ["e8a1", "\u70CF\u71AC\u7352\u7B7D\u8708\u8AA4\u9C32\u9F07\u5C4B\u6C83\u7344\u7389\u923A\u6EAB\u7465\u761F\u7A69\u7E15\u860A\u5140\u58C5\u64C1\u74EE\u7515\u7670\u7FC1\u9095\u96CD\u9954\u6E26\u74E6\u7AA9\u7AAA\u81E5\u86D9\u8778\u8A1B\u5A49\u5B8C\u5B9B\u68A1\u6900\u6D63\u73A9\u7413\u742C\u7897\u7DE9\u7FEB\u8118\u8155\u839E\u8C4C\u962E\u9811\u66F0\u5F80\u65FA\u6789\u6C6A\u738B\u502D\u5A03\u6B6A\u77EE\u5916\u5D6C\u5DCD\u7325\u754F\uF9BA\uF9BB\u50E5\u51F9\u582F\u592D\u5996\u59DA\u5BE5\uF9BC\uF9BD\u5DA2\u62D7\u6416\u6493\u64FE\uF9BE\u66DC\uF9BF\u6A48\uF9C0\u71FF\u7464\uF9C1"],
      ["e9a1", "\u7A88\u7AAF\u7E47\u7E5E\u8000\u8170\uF9C2\u87EF\u8981\u8B20\u9059\uF9C3\u9080\u9952\u617E\u6B32\u6D74\u7E1F\u8925\u8FB1\u4FD1\u50AD\u5197\u52C7\u57C7\u5889\u5BB9\u5EB8\u6142\u6995\u6D8C\u6E67\u6EB6\u7194\u7462\u7528\u752C\u8073\u8338\u84C9\u8E0A\u9394\u93DE\uF9C4\u4E8E\u4F51\u5076\u512A\u53C8\u53CB\u53F3\u5B87\u5BD3\u5C24\u611A\u6182\u65F4\u725B\u7397\u7440\u76C2\u7950\u7991\u79B9\u7D06\u7FBD\u828B\u85D5\u865E\u8FC2\u9047\u90F5\u91EA\u9685\u96E8\u96E9\u52D6\u5F67\u65ED\u6631\u682F\u715C\u7A36\u90C1\u980A\u4E91\uF9C5\u6A52\u6B9E\u6F90\u7189\u8018\u82B8\u8553"],
      ["eaa1", "\u904B\u9695\u96F2\u97FB\u851A\u9B31\u4E90\u718A\u96C4\u5143\u539F\u54E1\u5713\u5712\u57A3\u5A9B\u5AC4\u5BC3\u6028\u613F\u63F4\u6C85\u6D39\u6E72\u6E90\u7230\u733F\u7457\u82D1\u8881\u8F45\u9060\uF9C6\u9662\u9858\u9D1B\u6708\u8D8A\u925E\u4F4D\u5049\u50DE\u5371\u570D\u59D4\u5A01\u5C09\u6170\u6690\u6E2D\u7232\u744B\u7DEF\u80C3\u840E\u8466\u853F\u875F\u885B\u8918\u8B02\u9055\u97CB\u9B4F\u4E73\u4F91\u5112\u516A\uF9C7\u552F\u55A9\u5B7A\u5BA5\u5E7C\u5E7D\u5EBE\u60A0\u60DF\u6108\u6109\u63C4\u6538\u6709\uF9C8\u67D4\u67DA\uF9C9\u6961\u6962\u6CB9\u6D27\uF9CA\u6E38\uF9CB"],
      ["eba1", "\u6FE1\u7336\u7337\uF9CC\u745C\u7531\uF9CD\u7652\uF9CE\uF9CF\u7DAD\u81FE\u8438\u88D5\u8A98\u8ADB\u8AED\u8E30\u8E42\u904A\u903E\u907A\u9149\u91C9\u936E\uF9D0\uF9D1\u5809\uF9D2\u6BD3\u8089\u80B2\uF9D3\uF9D4\u5141\u596B\u5C39\uF9D5\uF9D6\u6F64\u73A7\u80E4\u8D07\uF9D7\u9217\u958F\uF9D8\uF9D9\uF9DA\uF9DB\u807F\u620E\u701C\u7D68\u878D\uF9DC\u57A0\u6069\u6147\u6BB7\u8ABE\u9280\u96B1\u4E59\u541F\u6DEB\u852D\u9670\u97F3\u98EE\u63D6\u6CE3\u9091\u51DD\u61C9\u81BA\u9DF9\u4F9D\u501A\u5100\u5B9C\u610F\u61FF\u64EC\u6905\u6BC5\u7591\u77E3\u7FA9\u8264\u858F\u87FB\u8863\u8ABC"],
      ["eca1", "\u8B70\u91AB\u4E8C\u4EE5\u4F0A\uF9DD\uF9DE\u5937\u59E8\uF9DF\u5DF2\u5F1B\u5F5B\u6021\uF9E0\uF9E1\uF9E2\uF9E3\u723E\u73E5\uF9E4\u7570\u75CD\uF9E5\u79FB\uF9E6\u800C\u8033\u8084\u82E1\u8351\uF9E7\uF9E8\u8CBD\u8CB3\u9087\uF9E9\uF9EA\u98F4\u990C\uF9EB\uF9EC\u7037\u76CA\u7FCA\u7FCC\u7FFC\u8B1A\u4EBA\u4EC1\u5203\u5370\uF9ED\u54BD\u56E0\u59FB\u5BC5\u5F15\u5FCD\u6E6E\uF9EE\uF9EF\u7D6A\u8335\uF9F0\u8693\u8A8D\uF9F1\u976D\u9777\uF9F2\uF9F3\u4E00\u4F5A\u4F7E\u58F9\u65E5\u6EA2\u9038\u93B0\u99B9\u4EFB\u58EC\u598A\u59D9\u6041\uF9F4\uF9F5\u7A14\uF9F6\u834F\u8CC3\u5165\u5344"],
      ["eda1", "\uF9F7\uF9F8\uF9F9\u4ECD\u5269\u5B55\u82BF\u4ED4\u523A\u54A8\u59C9\u59FF\u5B50\u5B57\u5B5C\u6063\u6148\u6ECB\u7099\u716E\u7386\u74F7\u75B5\u78C1\u7D2B\u8005\u81EA\u8328\u8517\u85C9\u8AEE\u8CC7\u96CC\u4F5C\u52FA\u56BC\u65AB\u6628\u707C\u70B8\u7235\u7DBD\u828D\u914C\u96C0\u9D72\u5B71\u68E7\u6B98\u6F7A\u76DE\u5C91\u66AB\u6F5B\u7BB4\u7C2A\u8836\u96DC\u4E08\u4ED7\u5320\u5834\u58BB\u58EF\u596C\u5C07\u5E33\u5E84\u5F35\u638C\u66B2\u6756\u6A1F\u6AA3\u6B0C\u6F3F\u7246\uF9FA\u7350\u748B\u7AE0\u7CA7\u8178\u81DF\u81E7\u838A\u846C\u8523\u8594\u85CF\u88DD\u8D13\u91AC\u9577"],
      ["eea1", "\u969C\u518D\u54C9\u5728\u5BB0\u624D\u6750\u683D\u6893\u6E3D\u6ED3\u707D\u7E21\u88C1\u8CA1\u8F09\u9F4B\u9F4E\u722D\u7B8F\u8ACD\u931A\u4F47\u4F4E\u5132\u5480\u59D0\u5E95\u62B5\u6775\u696E\u6A17\u6CAE\u6E1A\u72D9\u732A\u75BD\u7BB8\u7D35\u82E7\u83F9\u8457\u85F7\u8A5B\u8CAF\u8E87\u9019\u90B8\u96CE\u9F5F\u52E3\u540A\u5AE1\u5BC2\u6458\u6575\u6EF4\u72C4\uF9FB\u7684\u7A4D\u7B1B\u7C4D\u7E3E\u7FDF\u837B\u8B2B\u8CCA\u8D64\u8DE1\u8E5F\u8FEA\u8FF9\u9069\u93D1\u4F43\u4F7A\u50B3\u5168\u5178\u524D\u526A\u5861\u587C\u5960\u5C08\u5C55\u5EDB\u609B\u6230\u6813\u6BBF\u6C08\u6FB1"],
      ["efa1", "\u714E\u7420\u7530\u7538\u7551\u7672\u7B4C\u7B8B\u7BAD\u7BC6\u7E8F\u8A6E\u8F3E\u8F49\u923F\u9293\u9322\u942B\u96FB\u985A\u986B\u991E\u5207\u622A\u6298\u6D59\u7664\u7ACA\u7BC0\u7D76\u5360\u5CBE\u5E97\u6F38\u70B9\u7C98\u9711\u9B8E\u9EDE\u63A5\u647A\u8776\u4E01\u4E95\u4EAD\u505C\u5075\u5448\u59C3\u5B9A\u5E40\u5EAD\u5EF7\u5F81\u60C5\u633A\u653F\u6574\u65CC\u6676\u6678\u67FE\u6968\u6A89\u6B63\u6C40\u6DC0\u6DE8\u6E1F\u6E5E\u701E\u70A1\u738E\u73FD\u753A\u775B\u7887\u798E\u7A0B\u7A7D\u7CBE\u7D8E\u8247\u8A02\u8AEA\u8C9E\u912D\u914A\u91D8\u9266\u92CC\u9320\u9706\u9756"],
      ["f0a1", "\u975C\u9802\u9F0E\u5236\u5291\u557C\u5824\u5E1D\u5F1F\u608C\u63D0\u68AF\u6FDF\u796D\u7B2C\u81CD\u85BA\u88FD\u8AF8\u8E44\u918D\u9664\u969B\u973D\u984C\u9F4A\u4FCE\u5146\u51CB\u52A9\u5632\u5F14\u5F6B\u63AA\u64CD\u65E9\u6641\u66FA\u66F9\u671D\u689D\u68D7\u69FD\u6F15\u6F6E\u7167\u71E5\u722A\u74AA\u773A\u7956\u795A\u79DF\u7A20\u7A95\u7C97\u7CDF\u7D44\u7E70\u8087\u85FB\u86A4\u8A54\u8ABF\u8D99\u8E81\u9020\u906D\u91E3\u963B\u96D5\u9CE5\u65CF\u7C07\u8DB3\u93C3\u5B58\u5C0A\u5352\u62D9\u731D\u5027\u5B97\u5F9E\u60B0\u616B\u68D5\u6DD9\u742E\u7A2E\u7D42\u7D9C\u7E31\u816B"],
      ["f1a1", "\u8E2A\u8E35\u937E\u9418\u4F50\u5750\u5DE6\u5EA7\u632B\u7F6A\u4E3B\u4F4F\u4F8F\u505A\u59DD\u80C4\u546A\u5468\u55FE\u594F\u5B99\u5DDE\u5EDA\u665D\u6731\u67F1\u682A\u6CE8\u6D32\u6E4A\u6F8D\u70B7\u73E0\u7587\u7C4C\u7D02\u7D2C\u7DA2\u821F\u86DB\u8A3B\u8A85\u8D70\u8E8A\u8F33\u9031\u914E\u9152\u9444\u99D0\u7AF9\u7CA5\u4FCA\u5101\u51C6\u57C8\u5BEF\u5CFB\u6659\u6A3D\u6D5A\u6E96\u6FEC\u710C\u756F\u7AE3\u8822\u9021\u9075\u96CB\u99FF\u8301\u4E2D\u4EF2\u8846\u91CD\u537D\u6ADB\u696B\u6C41\u847A\u589E\u618E\u66FE\u62EF\u70DD\u7511\u75C7\u7E52\u84B8\u8B49\u8D08\u4E4B\u53EA"],
      ["f2a1", "\u54AB\u5730\u5740\u5FD7\u6301\u6307\u646F\u652F\u65E8\u667A\u679D\u67B3\u6B62\u6C60\u6C9A\u6F2C\u77E5\u7825\u7949\u7957\u7D19\u80A2\u8102\u81F3\u829D\u82B7\u8718\u8A8C\uF9FC\u8D04\u8DBE\u9072\u76F4\u7A19\u7A37\u7E54\u8077\u5507\u55D4\u5875\u632F\u6422\u6649\u664B\u686D\u699B\u6B84\u6D25\u6EB1\u73CD\u7468\u74A1\u755B\u75B9\u76E1\u771E\u778B\u79E6\u7E09\u7E1D\u81FB\u852F\u8897\u8A3A\u8CD1\u8EEB\u8FB0\u9032\u93AD\u9663\u9673\u9707\u4F84\u53F1\u59EA\u5AC9\u5E19\u684E\u74C6\u75BE\u79E9\u7A92\u81A3\u86ED\u8CEA\u8DCC\u8FED\u659F\u6715\uF9FD\u57F7\u6F57\u7DDD\u8F2F"],
      ["f3a1", "\u93F6\u96C6\u5FB5\u61F2\u6F84\u4E14\u4F98\u501F\u53C9\u55DF\u5D6F\u5DEE\u6B21\u6B64\u78CB\u7B9A\uF9FE\u8E49\u8ECA\u906E\u6349\u643E\u7740\u7A84\u932F\u947F\u9F6A\u64B0\u6FAF\u71E6\u74A8\u74DA\u7AC4\u7C12\u7E82\u7CB2\u7E98\u8B9A\u8D0A\u947D\u9910\u994C\u5239\u5BDF\u64E6\u672D\u7D2E\u50ED\u53C3\u5879\u6158\u6159\u61FA\u65AC\u7AD9\u8B92\u8B96\u5009\u5021\u5275\u5531\u5A3C\u5EE0\u5F70\u6134\u655E\u660C\u6636\u66A2\u69CD\u6EC4\u6F32\u7316\u7621\u7A93\u8139\u8259\u83D6\u84BC\u50B5\u57F0\u5BC0\u5BE8\u5F69\u63A1\u7826\u7DB5\u83DC\u8521\u91C7\u91F5\u518A\u67F5\u7B56"],
      ["f4a1", "\u8CAC\u51C4\u59BB\u60BD\u8655\u501C\uF9FF\u5254\u5C3A\u617D\u621A\u62D3\u64F2\u65A5\u6ECC\u7620\u810A\u8E60\u965F\u96BB\u4EDF\u5343\u5598\u5929\u5DDD\u64C5\u6CC9\u6DFA\u7394\u7A7F\u821B\u85A6\u8CE4\u8E10\u9077\u91E7\u95E1\u9621\u97C6\u51F8\u54F2\u5586\u5FB9\u64A4\u6F88\u7DB4\u8F1F\u8F4D\u9435\u50C9\u5C16\u6CBE\u6DFB\u751B\u77BB\u7C3D\u7C64\u8A79\u8AC2\u581E\u59BE\u5E16\u6377\u7252\u758A\u776B\u8ADC\u8CBC\u8F12\u5EF3\u6674\u6DF8\u807D\u83C1\u8ACB\u9751\u9BD6\uFA00\u5243\u66FF\u6D95\u6EEF\u7DE0\u8AE6\u902E\u905E\u9AD4\u521D\u527F\u54E8\u6194\u6284\u62DB\u68A2"],
      ["f5a1", "\u6912\u695A\u6A35\u7092\u7126\u785D\u7901\u790E\u79D2\u7A0D\u8096\u8278\u82D5\u8349\u8549\u8C82\u8D85\u9162\u918B\u91AE\u4FC3\u56D1\u71ED\u77D7\u8700\u89F8\u5BF8\u5FD6\u6751\u90A8\u53E2\u585A\u5BF5\u60A4\u6181\u6460\u7E3D\u8070\u8525\u9283\u64AE\u50AC\u5D14\u6700\u589C\u62BD\u63A8\u690E\u6978\u6A1E\u6E6B\u76BA\u79CB\u82BB\u8429\u8ACF\u8DA8\u8FFD\u9112\u914B\u919C\u9310\u9318\u939A\u96DB\u9A36\u9C0D\u4E11\u755C\u795D\u7AFA\u7B51\u7BC9\u7E2E\u84C4\u8E59\u8E74\u8EF8\u9010\u6625\u693F\u7443\u51FA\u672E\u9EDC\u5145\u5FE0\u6C96\u87F2\u885D\u8877\u60B4\u81B5\u8403"],
      ["f6a1", "\u8D05\u53D6\u5439\u5634\u5A36\u5C31\u708A\u7FE0\u805A\u8106\u81ED\u8DA3\u9189\u9A5F\u9DF2\u5074\u4EC4\u53A0\u60FB\u6E2C\u5C64\u4F88\u5024\u55E4\u5CD9\u5E5F\u6065\u6894\u6CBB\u6DC4\u71BE\u75D4\u75F4\u7661\u7A1A\u7A49\u7DC7\u7DFB\u7F6E\u81F4\u86A9\u8F1C\u96C9\u99B3\u9F52\u5247\u52C5\u98ED\u89AA\u4E03\u67D2\u6F06\u4FB5\u5BE2\u6795\u6C88\u6D78\u741B\u7827\u91DD\u937C\u87C4\u79E4\u7A31\u5FEB\u4ED6\u54A4\u553E\u58AE\u59A5\u60F0\u6253\u62D6\u6736\u6955\u8235\u9640\u99B1\u99DD\u502C\u5353\u5544\u577C\uFA01\u6258\uFA02\u64E2\u666B\u67DD\u6FC1\u6FEF\u7422\u7438\u8A17"],
      ["f7a1", "\u9438\u5451\u5606\u5766\u5F48\u619A\u6B4E\u7058\u70AD\u7DBB\u8A95\u596A\u812B\u63A2\u7708\u803D\u8CAA\u5854\u642D\u69BB\u5B95\u5E11\u6E6F\uFA03\u8569\u514C\u53F0\u592A\u6020\u614B\u6B86\u6C70\u6CF0\u7B1E\u80CE\u82D4\u8DC6\u90B0\u98B1\uFA04\u64C7\u6FA4\u6491\u6504\u514E\u5410\u571F\u8A0E\u615F\u6876\uFA05\u75DB\u7B52\u7D71\u901A\u5806\u69CC\u817F\u892A\u9000\u9839\u5078\u5957\u59AC\u6295\u900F\u9B2A\u615D\u7279\u95D6\u5761\u5A46\u5DF4\u628A\u64AD\u64FA\u6777\u6CE2\u6D3E\u722C\u7436\u7834\u7F77\u82AD\u8DDB\u9817\u5224\u5742\u677F\u7248\u74E3\u8CA9\u8FA6\u9211"],
      ["f8a1", "\u962A\u516B\u53ED\u634C\u4F69\u5504\u6096\u6557\u6C9B\u6D7F\u724C\u72FD\u7A17\u8987\u8C9D\u5F6D\u6F8E\u70F9\u81A8\u610E\u4FBF\u504F\u6241\u7247\u7BC7\u7DE8\u7FE9\u904D\u97AD\u9A19\u8CB6\u576A\u5E73\u67B0\u840D\u8A55\u5420\u5B16\u5E63\u5EE2\u5F0A\u6583\u80BA\u853D\u9589\u965B\u4F48\u5305\u530D\u530F\u5486\u54FA\u5703\u5E03\u6016\u629B\u62B1\u6355\uFA06\u6CE1\u6D66\u75B1\u7832\u80DE\u812F\u82DE\u8461\u84B2\u888D\u8912\u900B\u92EA\u98FD\u9B91\u5E45\u66B4\u66DD\u7011\u7206\uFA07\u4FF5\u527D\u5F6A\u6153\u6753\u6A19\u6F02\u74E2\u7968\u8868\u8C79\u98C7\u98C4\u9A43"],
      ["f9a1", "\u54C1\u7A1F\u6953\u8AF7\u8C4A\u98A8\u99AE\u5F7C\u62AB\u75B2\u76AE\u88AB\u907F\u9642\u5339\u5F3C\u5FC5\u6CCC\u73CC\u7562\u758B\u7B46\u82FE\u999D\u4E4F\u903C\u4E0B\u4F55\u53A6\u590F\u5EC8\u6630\u6CB3\u7455\u8377\u8766\u8CC0\u9050\u971E\u9C15\u58D1\u5B78\u8650\u8B14\u9DB4\u5BD2\u6068\u608D\u65F1\u6C57\u6F22\u6FA3\u701A\u7F55\u7FF0\u9591\u9592\u9650\u97D3\u5272\u8F44\u51FD\u542B\u54B8\u5563\u558A\u6ABB\u6DB5\u7DD8\u8266\u929C\u9677\u9E79\u5408\u54C8\u76D2\u86E4\u95A4\u95D4\u965C\u4EA2\u4F09\u59EE\u5AE6\u5DF7\u6052\u6297\u676D\u6841\u6C86\u6E2F\u7F38\u809B\u822A"],
      ["faa1", "\uFA08\uFA09\u9805\u4EA5\u5055\u54B3\u5793\u595A\u5B69\u5BB3\u61C8\u6977\u6D77\u7023\u87F9\u89E3\u8A72\u8AE7\u9082\u99ED\u9AB8\u52BE\u6838\u5016\u5E78\u674F\u8347\u884C\u4EAB\u5411\u56AE\u73E6\u9115\u97FF\u9909\u9957\u9999\u5653\u589F\u865B\u8A31\u61B2\u6AF6\u737B\u8ED2\u6B47\u96AA\u9A57\u5955\u7200\u8D6B\u9769\u4FD4\u5CF4\u5F26\u61F8\u665B\u6CEB\u70AB\u7384\u73B9\u73FE\u7729\u774D\u7D43\u7D62\u7E23\u8237\u8852\uFA0A\u8CE2\u9249\u986F\u5B51\u7A74\u8840\u9801\u5ACC\u4FE0\u5354\u593E\u5CFD\u633E\u6D79\u72F9\u8105\u8107\u83A2\u92CF\u9830\u4EA8\u5144\u5211\u578B"],
      ["fba1", "\u5F62\u6CC2\u6ECE\u7005\u7050\u70AF\u7192\u73E9\u7469\u834A\u87A2\u8861\u9008\u90A2\u93A3\u99A8\u516E\u5F57\u60E0\u6167\u66B3\u8559\u8E4A\u91AF\u978B\u4E4E\u4E92\u547C\u58D5\u58FA\u597D\u5CB5\u5F27\u6236\u6248\u660A\u6667\u6BEB\u6D69\u6DCF\u6E56\u6EF8\u6F94\u6FE0\u6FE9\u705D\u72D0\u7425\u745A\u74E0\u7693\u795C\u7CCA\u7E1E\u80E1\u82A6\u846B\u84BF\u864E\u865F\u8774\u8B77\u8C6A\u93AC\u9800\u9865\u60D1\u6216\u9177\u5A5A\u660F\u6DF7\u6E3E\u743F\u9B42\u5FFD\u60DA\u7B0F\u54C4\u5F18\u6C5E\u6CD3\u6D2A\u70D8\u7D05\u8679\u8A0C\u9D3B\u5316\u548C\u5B05\u6A3A\u706B\u7575"],
      ["fca1", "\u798D\u79BE\u82B1\u83EF\u8A71\u8B41\u8CA8\u9774\uFA0B\u64F4\u652B\u78BA\u78BB\u7A6B\u4E38\u559A\u5950\u5BA6\u5E7B\u60A3\u63DB\u6B61\u6665\u6853\u6E19\u7165\u74B0\u7D08\u9084\u9A69\u9C25\u6D3B\u6ED1\u733E\u8C41\u95CA\u51F0\u5E4C\u5FA8\u604D\u60F6\u6130\u614C\u6643\u6644\u69A5\u6CC1\u6E5F\u6EC9\u6F62\u714C\u749C\u7687\u7BC1\u7C27\u8352\u8757\u9051\u968D\u9EC3\u532F\u56DE\u5EFB\u5F8A\u6062\u6094\u61F7\u6666\u6703\u6A9C\u6DEE\u6FAE\u7070\u736A\u7E6A\u81BE\u8334\u86D4\u8AA8\u8CC4\u5283\u7372\u5B96\u6A6B\u9404\u54EE\u5686\u5B5D\u6548\u6585\u66C9\u689F\u6D8D\u6DC6"],
      ["fda1", "\u723B\u80B4\u9175\u9A4D\u4FAF\u5019\u539A\u540E\u543C\u5589\u55C5\u5E3F\u5F8C\u673D\u7166\u73DD\u9005\u52DB\u52F3\u5864\u58CE\u7104\u718F\u71FB\u85B0\u8A13\u6688\u85A8\u55A7\u6684\u714A\u8431\u5349\u5599\u6BC1\u5F59\u5FBD\u63EE\u6689\u7147\u8AF1\u8F1D\u9EBE\u4F11\u643A\u70CB\u7566\u8667\u6064\u8B4E\u9DF8\u5147\u51F6\u5308\u6D36\u80F8\u9ED1\u6615\u6B23\u7098\u75D5\u5403\u5C79\u7D07\u8A16\u6B20\u6B3D\u6B46\u5438\u6070\u6D3D\u7FD5\u8208\u50D6\u51DE\u559C\u566B\u56CD\u59EC\u5B09\u5E0C\u6199\u6198\u6231\u665E\u66E6\u7199\u71B9\u71BA\u72A7\u79A7\u7A00\u7FB2\u8A70"]
    ];
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/tables/cp950.json
var require_cp9502 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/tables/cp950.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127],
      ["a140", "\u3000\uFF0C\u3001\u3002\uFF0E\u2027\uFF1B\uFF1A\uFF1F\uFF01\uFE30\u2026\u2025\uFE50\uFE51\uFE52\xB7\uFE54\uFE55\uFE56\uFE57\uFF5C\u2013\uFE31\u2014\uFE33\u2574\uFE34\uFE4F\uFF08\uFF09\uFE35\uFE36\uFF5B\uFF5D\uFE37\uFE38\u3014\u3015\uFE39\uFE3A\u3010\u3011\uFE3B\uFE3C\u300A\u300B\uFE3D\uFE3E\u3008\u3009\uFE3F\uFE40\u300C\u300D\uFE41\uFE42\u300E\u300F\uFE43\uFE44\uFE59\uFE5A"],
      ["a1a1", "\uFE5B\uFE5C\uFE5D\uFE5E\u2018\u2019\u201C\u201D\u301D\u301E\u2035\u2032\uFF03\uFF06\uFF0A\u203B\xA7\u3003\u25CB\u25CF\u25B3\u25B2\u25CE\u2606\u2605\u25C7\u25C6\u25A1\u25A0\u25BD\u25BC\u32A3\u2105\xAF\uFFE3\uFF3F\u02CD\uFE49\uFE4A\uFE4D\uFE4E\uFE4B\uFE4C\uFE5F\uFE60\uFE61\uFF0B\uFF0D\xD7\xF7\xB1\u221A\uFF1C\uFF1E\uFF1D\u2266\u2267\u2260\u221E\u2252\u2261\uFE62", 4, "\uFF5E\u2229\u222A\u22A5\u2220\u221F\u22BF\u33D2\u33D1\u222B\u222E\u2235\u2234\u2640\u2642\u2295\u2299\u2191\u2193\u2190\u2192\u2196\u2197\u2199\u2198\u2225\u2223\uFF0F"],
      ["a240", "\uFF3C\u2215\uFE68\uFF04\uFFE5\u3012\uFFE0\uFFE1\uFF05\uFF20\u2103\u2109\uFE69\uFE6A\uFE6B\u33D5\u339C\u339D\u339E\u33CE\u33A1\u338E\u338F\u33C4\xB0\u5159\u515B\u515E\u515D\u5161\u5163\u55E7\u74E9\u7CCE\u2581", 7, "\u258F\u258E\u258D\u258C\u258B\u258A\u2589\u253C\u2534\u252C\u2524\u251C\u2594\u2500\u2502\u2595\u250C\u2510\u2514\u2518\u256D"],
      ["a2a1", "\u256E\u2570\u256F\u2550\u255E\u256A\u2561\u25E2\u25E3\u25E5\u25E4\u2571\u2572\u2573\uFF10", 9, "\u2160", 9, "\u3021", 8, "\u5341\u5344\u5345\uFF21", 25, "\uFF41", 21],
      ["a340", "\uFF57\uFF58\uFF59\uFF5A\u0391", 16, "\u03A3", 6, "\u03B1", 16, "\u03C3", 6, "\u3105", 10],
      ["a3a1", "\u3110", 25, "\u02D9\u02C9\u02CA\u02C7\u02CB"],
      ["a3e1", "\u20AC"],
      ["a440", "\u4E00\u4E59\u4E01\u4E03\u4E43\u4E5D\u4E86\u4E8C\u4EBA\u513F\u5165\u516B\u51E0\u5200\u5201\u529B\u5315\u5341\u535C\u53C8\u4E09\u4E0B\u4E08\u4E0A\u4E2B\u4E38\u51E1\u4E45\u4E48\u4E5F\u4E5E\u4E8E\u4EA1\u5140\u5203\u52FA\u5343\u53C9\u53E3\u571F\u58EB\u5915\u5927\u5973\u5B50\u5B51\u5B53\u5BF8\u5C0F\u5C22\u5C38\u5C71\u5DDD\u5DE5\u5DF1\u5DF2\u5DF3\u5DFE\u5E72\u5EFE\u5F0B\u5F13\u624D"],
      ["a4a1", "\u4E11\u4E10\u4E0D\u4E2D\u4E30\u4E39\u4E4B\u5C39\u4E88\u4E91\u4E95\u4E92\u4E94\u4EA2\u4EC1\u4EC0\u4EC3\u4EC6\u4EC7\u4ECD\u4ECA\u4ECB\u4EC4\u5143\u5141\u5167\u516D\u516E\u516C\u5197\u51F6\u5206\u5207\u5208\u52FB\u52FE\u52FF\u5316\u5339\u5348\u5347\u5345\u535E\u5384\u53CB\u53CA\u53CD\u58EC\u5929\u592B\u592A\u592D\u5B54\u5C11\u5C24\u5C3A\u5C6F\u5DF4\u5E7B\u5EFF\u5F14\u5F15\u5FC3\u6208\u6236\u624B\u624E\u652F\u6587\u6597\u65A4\u65B9\u65E5\u66F0\u6708\u6728\u6B20\u6B62\u6B79\u6BCB\u6BD4\u6BDB\u6C0F\u6C34\u706B\u722A\u7236\u723B\u7247\u7259\u725B\u72AC\u738B\u4E19"],
      ["a540", "\u4E16\u4E15\u4E14\u4E18\u4E3B\u4E4D\u4E4F\u4E4E\u4EE5\u4ED8\u4ED4\u4ED5\u4ED6\u4ED7\u4EE3\u4EE4\u4ED9\u4EDE\u5145\u5144\u5189\u518A\u51AC\u51F9\u51FA\u51F8\u520A\u52A0\u529F\u5305\u5306\u5317\u531D\u4EDF\u534A\u5349\u5361\u5360\u536F\u536E\u53BB\u53EF\u53E4\u53F3\u53EC\u53EE\u53E9\u53E8\u53FC\u53F8\u53F5\u53EB\u53E6\u53EA\u53F2\u53F1\u53F0\u53E5\u53ED\u53FB\u56DB\u56DA\u5916"],
      ["a5a1", "\u592E\u5931\u5974\u5976\u5B55\u5B83\u5C3C\u5DE8\u5DE7\u5DE6\u5E02\u5E03\u5E73\u5E7C\u5F01\u5F18\u5F17\u5FC5\u620A\u6253\u6254\u6252\u6251\u65A5\u65E6\u672E\u672C\u672A\u672B\u672D\u6B63\u6BCD\u6C11\u6C10\u6C38\u6C41\u6C40\u6C3E\u72AF\u7384\u7389\u74DC\u74E6\u7518\u751F\u7528\u7529\u7530\u7531\u7532\u7533\u758B\u767D\u76AE\u76BF\u76EE\u77DB\u77E2\u77F3\u793A\u79BE\u7A74\u7ACB\u4E1E\u4E1F\u4E52\u4E53\u4E69\u4E99\u4EA4\u4EA6\u4EA5\u4EFF\u4F09\u4F19\u4F0A\u4F15\u4F0D\u4F10\u4F11\u4F0F\u4EF2\u4EF6\u4EFB\u4EF0\u4EF3\u4EFD\u4F01\u4F0B\u5149\u5147\u5146\u5148\u5168"],
      ["a640", "\u5171\u518D\u51B0\u5217\u5211\u5212\u520E\u5216\u52A3\u5308\u5321\u5320\u5370\u5371\u5409\u540F\u540C\u540A\u5410\u5401\u540B\u5404\u5411\u540D\u5408\u5403\u540E\u5406\u5412\u56E0\u56DE\u56DD\u5733\u5730\u5728\u572D\u572C\u572F\u5729\u5919\u591A\u5937\u5938\u5984\u5978\u5983\u597D\u5979\u5982\u5981\u5B57\u5B58\u5B87\u5B88\u5B85\u5B89\u5BFA\u5C16\u5C79\u5DDE\u5E06\u5E76\u5E74"],
      ["a6a1", "\u5F0F\u5F1B\u5FD9\u5FD6\u620E\u620C\u620D\u6210\u6263\u625B\u6258\u6536\u65E9\u65E8\u65EC\u65ED\u66F2\u66F3\u6709\u673D\u6734\u6731\u6735\u6B21\u6B64\u6B7B\u6C16\u6C5D\u6C57\u6C59\u6C5F\u6C60\u6C50\u6C55\u6C61\u6C5B\u6C4D\u6C4E\u7070\u725F\u725D\u767E\u7AF9\u7C73\u7CF8\u7F36\u7F8A\u7FBD\u8001\u8003\u800C\u8012\u8033\u807F\u8089\u808B\u808C\u81E3\u81EA\u81F3\u81FC\u820C\u821B\u821F\u826E\u8272\u827E\u866B\u8840\u884C\u8863\u897F\u9621\u4E32\u4EA8\u4F4D\u4F4F\u4F47\u4F57\u4F5E\u4F34\u4F5B\u4F55\u4F30\u4F50\u4F51\u4F3D\u4F3A\u4F38\u4F43\u4F54\u4F3C\u4F46\u4F63"],
      ["a740", "\u4F5C\u4F60\u4F2F\u4F4E\u4F36\u4F59\u4F5D\u4F48\u4F5A\u514C\u514B\u514D\u5175\u51B6\u51B7\u5225\u5224\u5229\u522A\u5228\u52AB\u52A9\u52AA\u52AC\u5323\u5373\u5375\u541D\u542D\u541E\u543E\u5426\u544E\u5427\u5446\u5443\u5433\u5448\u5442\u541B\u5429\u544A\u5439\u543B\u5438\u542E\u5435\u5436\u5420\u543C\u5440\u5431\u542B\u541F\u542C\u56EA\u56F0\u56E4\u56EB\u574A\u5751\u5740\u574D"],
      ["a7a1", "\u5747\u574E\u573E\u5750\u574F\u573B\u58EF\u593E\u599D\u5992\u59A8\u599E\u59A3\u5999\u5996\u598D\u59A4\u5993\u598A\u59A5\u5B5D\u5B5C\u5B5A\u5B5B\u5B8C\u5B8B\u5B8F\u5C2C\u5C40\u5C41\u5C3F\u5C3E\u5C90\u5C91\u5C94\u5C8C\u5DEB\u5E0C\u5E8F\u5E87\u5E8A\u5EF7\u5F04\u5F1F\u5F64\u5F62\u5F77\u5F79\u5FD8\u5FCC\u5FD7\u5FCD\u5FF1\u5FEB\u5FF8\u5FEA\u6212\u6211\u6284\u6297\u6296\u6280\u6276\u6289\u626D\u628A\u627C\u627E\u6279\u6273\u6292\u626F\u6298\u626E\u6295\u6293\u6291\u6286\u6539\u653B\u6538\u65F1\u66F4\u675F\u674E\u674F\u6750\u6751\u675C\u6756\u675E\u6749\u6746\u6760"],
      ["a840", "\u6753\u6757\u6B65\u6BCF\u6C42\u6C5E\u6C99\u6C81\u6C88\u6C89\u6C85\u6C9B\u6C6A\u6C7A\u6C90\u6C70\u6C8C\u6C68\u6C96\u6C92\u6C7D\u6C83\u6C72\u6C7E\u6C74\u6C86\u6C76\u6C8D\u6C94\u6C98\u6C82\u7076\u707C\u707D\u7078\u7262\u7261\u7260\u72C4\u72C2\u7396\u752C\u752B\u7537\u7538\u7682\u76EF\u77E3\u79C1\u79C0\u79BF\u7A76\u7CFB\u7F55\u8096\u8093\u809D\u8098\u809B\u809A\u80B2\u826F\u8292"],
      ["a8a1", "\u828B\u828D\u898B\u89D2\u8A00\u8C37\u8C46\u8C55\u8C9D\u8D64\u8D70\u8DB3\u8EAB\u8ECA\u8F9B\u8FB0\u8FC2\u8FC6\u8FC5\u8FC4\u5DE1\u9091\u90A2\u90AA\u90A6\u90A3\u9149\u91C6\u91CC\u9632\u962E\u9631\u962A\u962C\u4E26\u4E56\u4E73\u4E8B\u4E9B\u4E9E\u4EAB\u4EAC\u4F6F\u4F9D\u4F8D\u4F73\u4F7F\u4F6C\u4F9B\u4F8B\u4F86\u4F83\u4F70\u4F75\u4F88\u4F69\u4F7B\u4F96\u4F7E\u4F8F\u4F91\u4F7A\u5154\u5152\u5155\u5169\u5177\u5176\u5178\u51BD\u51FD\u523B\u5238\u5237\u523A\u5230\u522E\u5236\u5241\u52BE\u52BB\u5352\u5354\u5353\u5351\u5366\u5377\u5378\u5379\u53D6\u53D4\u53D7\u5473\u5475"],
      ["a940", "\u5496\u5478\u5495\u5480\u547B\u5477\u5484\u5492\u5486\u547C\u5490\u5471\u5476\u548C\u549A\u5462\u5468\u548B\u547D\u548E\u56FA\u5783\u5777\u576A\u5769\u5761\u5766\u5764\u577C\u591C\u5949\u5947\u5948\u5944\u5954\u59BE\u59BB\u59D4\u59B9\u59AE\u59D1\u59C6\u59D0\u59CD\u59CB\u59D3\u59CA\u59AF\u59B3\u59D2\u59C5\u5B5F\u5B64\u5B63\u5B97\u5B9A\u5B98\u5B9C\u5B99\u5B9B\u5C1A\u5C48\u5C45"],
      ["a9a1", "\u5C46\u5CB7\u5CA1\u5CB8\u5CA9\u5CAB\u5CB1\u5CB3\u5E18\u5E1A\u5E16\u5E15\u5E1B\u5E11\u5E78\u5E9A\u5E97\u5E9C\u5E95\u5E96\u5EF6\u5F26\u5F27\u5F29\u5F80\u5F81\u5F7F\u5F7C\u5FDD\u5FE0\u5FFD\u5FF5\u5FFF\u600F\u6014\u602F\u6035\u6016\u602A\u6015\u6021\u6027\u6029\u602B\u601B\u6216\u6215\u623F\u623E\u6240\u627F\u62C9\u62CC\u62C4\u62BF\u62C2\u62B9\u62D2\u62DB\u62AB\u62D3\u62D4\u62CB\u62C8\u62A8\u62BD\u62BC\u62D0\u62D9\u62C7\u62CD\u62B5\u62DA\u62B1\u62D8\u62D6\u62D7\u62C6\u62AC\u62CE\u653E\u65A7\u65BC\u65FA\u6614\u6613\u660C\u6606\u6602\u660E\u6600\u660F\u6615\u660A"],
      ["aa40", "\u6607\u670D\u670B\u676D\u678B\u6795\u6771\u679C\u6773\u6777\u6787\u679D\u6797\u676F\u6770\u677F\u6789\u677E\u6790\u6775\u679A\u6793\u677C\u676A\u6772\u6B23\u6B66\u6B67\u6B7F\u6C13\u6C1B\u6CE3\u6CE8\u6CF3\u6CB1\u6CCC\u6CE5\u6CB3\u6CBD\u6CBE\u6CBC\u6CE2\u6CAB\u6CD5\u6CD3\u6CB8\u6CC4\u6CB9\u6CC1\u6CAE\u6CD7\u6CC5\u6CF1\u6CBF\u6CBB\u6CE1\u6CDB\u6CCA\u6CAC\u6CEF\u6CDC\u6CD6\u6CE0"],
      ["aaa1", "\u7095\u708E\u7092\u708A\u7099\u722C\u722D\u7238\u7248\u7267\u7269\u72C0\u72CE\u72D9\u72D7\u72D0\u73A9\u73A8\u739F\u73AB\u73A5\u753D\u759D\u7599\u759A\u7684\u76C2\u76F2\u76F4\u77E5\u77FD\u793E\u7940\u7941\u79C9\u79C8\u7A7A\u7A79\u7AFA\u7CFE\u7F54\u7F8C\u7F8B\u8005\u80BA\u80A5\u80A2\u80B1\u80A1\u80AB\u80A9\u80B4\u80AA\u80AF\u81E5\u81FE\u820D\u82B3\u829D\u8299\u82AD\u82BD\u829F\u82B9\u82B1\u82AC\u82A5\u82AF\u82B8\u82A3\u82B0\u82BE\u82B7\u864E\u8671\u521D\u8868\u8ECB\u8FCE\u8FD4\u8FD1\u90B5\u90B8\u90B1\u90B6\u91C7\u91D1\u9577\u9580\u961C\u9640\u963F\u963B\u9644"],
      ["ab40", "\u9642\u96B9\u96E8\u9752\u975E\u4E9F\u4EAD\u4EAE\u4FE1\u4FB5\u4FAF\u4FBF\u4FE0\u4FD1\u4FCF\u4FDD\u4FC3\u4FB6\u4FD8\u4FDF\u4FCA\u4FD7\u4FAE\u4FD0\u4FC4\u4FC2\u4FDA\u4FCE\u4FDE\u4FB7\u5157\u5192\u5191\u51A0\u524E\u5243\u524A\u524D\u524C\u524B\u5247\u52C7\u52C9\u52C3\u52C1\u530D\u5357\u537B\u539A\u53DB\u54AC\u54C0\u54A8\u54CE\u54C9\u54B8\u54A6\u54B3\u54C7\u54C2\u54BD\u54AA\u54C1"],
      ["aba1", "\u54C4\u54C8\u54AF\u54AB\u54B1\u54BB\u54A9\u54A7\u54BF\u56FF\u5782\u578B\u57A0\u57A3\u57A2\u57CE\u57AE\u5793\u5955\u5951\u594F\u594E\u5950\u59DC\u59D8\u59FF\u59E3\u59E8\u5A03\u59E5\u59EA\u59DA\u59E6\u5A01\u59FB\u5B69\u5BA3\u5BA6\u5BA4\u5BA2\u5BA5\u5C01\u5C4E\u5C4F\u5C4D\u5C4B\u5CD9\u5CD2\u5DF7\u5E1D\u5E25\u5E1F\u5E7D\u5EA0\u5EA6\u5EFA\u5F08\u5F2D\u5F65\u5F88\u5F85\u5F8A\u5F8B\u5F87\u5F8C\u5F89\u6012\u601D\u6020\u6025\u600E\u6028\u604D\u6070\u6068\u6062\u6046\u6043\u606C\u606B\u606A\u6064\u6241\u62DC\u6316\u6309\u62FC\u62ED\u6301\u62EE\u62FD\u6307\u62F1\u62F7"],
      ["ac40", "\u62EF\u62EC\u62FE\u62F4\u6311\u6302\u653F\u6545\u65AB\u65BD\u65E2\u6625\u662D\u6620\u6627\u662F\u661F\u6628\u6631\u6624\u66F7\u67FF\u67D3\u67F1\u67D4\u67D0\u67EC\u67B6\u67AF\u67F5\u67E9\u67EF\u67C4\u67D1\u67B4\u67DA\u67E5\u67B8\u67CF\u67DE\u67F3\u67B0\u67D9\u67E2\u67DD\u67D2\u6B6A\u6B83\u6B86\u6BB5\u6BD2\u6BD7\u6C1F\u6CC9\u6D0B\u6D32\u6D2A\u6D41\u6D25\u6D0C\u6D31\u6D1E\u6D17"],
      ["aca1", "\u6D3B\u6D3D\u6D3E\u6D36\u6D1B\u6CF5\u6D39\u6D27\u6D38\u6D29\u6D2E\u6D35\u6D0E\u6D2B\u70AB\u70BA\u70B3\u70AC\u70AF\u70AD\u70B8\u70AE\u70A4\u7230\u7272\u726F\u7274\u72E9\u72E0\u72E1\u73B7\u73CA\u73BB\u73B2\u73CD\u73C0\u73B3\u751A\u752D\u754F\u754C\u754E\u754B\u75AB\u75A4\u75A5\u75A2\u75A3\u7678\u7686\u7687\u7688\u76C8\u76C6\u76C3\u76C5\u7701\u76F9\u76F8\u7709\u770B\u76FE\u76FC\u7707\u77DC\u7802\u7814\u780C\u780D\u7946\u7949\u7948\u7947\u79B9\u79BA\u79D1\u79D2\u79CB\u7A7F\u7A81\u7AFF\u7AFD\u7C7D\u7D02\u7D05\u7D00\u7D09\u7D07\u7D04\u7D06\u7F38\u7F8E\u7FBF\u8004"],
      ["ad40", "\u8010\u800D\u8011\u8036\u80D6\u80E5\u80DA\u80C3\u80C4\u80CC\u80E1\u80DB\u80CE\u80DE\u80E4\u80DD\u81F4\u8222\u82E7\u8303\u8305\u82E3\u82DB\u82E6\u8304\u82E5\u8302\u8309\u82D2\u82D7\u82F1\u8301\u82DC\u82D4\u82D1\u82DE\u82D3\u82DF\u82EF\u8306\u8650\u8679\u867B\u867A\u884D\u886B\u8981\u89D4\u8A08\u8A02\u8A03\u8C9E\u8CA0\u8D74\u8D73\u8DB4\u8ECD\u8ECC\u8FF0\u8FE6\u8FE2\u8FEA\u8FE5"],
      ["ada1", "\u8FED\u8FEB\u8FE4\u8FE8\u90CA\u90CE\u90C1\u90C3\u914B\u914A\u91CD\u9582\u9650\u964B\u964C\u964D\u9762\u9769\u97CB\u97ED\u97F3\u9801\u98A8\u98DB\u98DF\u9996\u9999\u4E58\u4EB3\u500C\u500D\u5023\u4FEF\u5026\u5025\u4FF8\u5029\u5016\u5006\u503C\u501F\u501A\u5012\u5011\u4FFA\u5000\u5014\u5028\u4FF1\u5021\u500B\u5019\u5018\u4FF3\u4FEE\u502D\u502A\u4FFE\u502B\u5009\u517C\u51A4\u51A5\u51A2\u51CD\u51CC\u51C6\u51CB\u5256\u525C\u5254\u525B\u525D\u532A\u537F\u539F\u539D\u53DF\u54E8\u5510\u5501\u5537\u54FC\u54E5\u54F2\u5506\u54FA\u5514\u54E9\u54ED\u54E1\u5509\u54EE\u54EA"],
      ["ae40", "\u54E6\u5527\u5507\u54FD\u550F\u5703\u5704\u57C2\u57D4\u57CB\u57C3\u5809\u590F\u5957\u5958\u595A\u5A11\u5A18\u5A1C\u5A1F\u5A1B\u5A13\u59EC\u5A20\u5A23\u5A29\u5A25\u5A0C\u5A09\u5B6B\u5C58\u5BB0\u5BB3\u5BB6\u5BB4\u5BAE\u5BB5\u5BB9\u5BB8\u5C04\u5C51\u5C55\u5C50\u5CED\u5CFD\u5CFB\u5CEA\u5CE8\u5CF0\u5CF6\u5D01\u5CF4\u5DEE\u5E2D\u5E2B\u5EAB\u5EAD\u5EA7\u5F31\u5F92\u5F91\u5F90\u6059"],
      ["aea1", "\u6063\u6065\u6050\u6055\u606D\u6069\u606F\u6084\u609F\u609A\u608D\u6094\u608C\u6085\u6096\u6247\u62F3\u6308\u62FF\u634E\u633E\u632F\u6355\u6342\u6346\u634F\u6349\u633A\u6350\u633D\u632A\u632B\u6328\u634D\u634C\u6548\u6549\u6599\u65C1\u65C5\u6642\u6649\u664F\u6643\u6652\u664C\u6645\u6641\u66F8\u6714\u6715\u6717\u6821\u6838\u6848\u6846\u6853\u6839\u6842\u6854\u6829\u68B3\u6817\u684C\u6851\u683D\u67F4\u6850\u6840\u683C\u6843\u682A\u6845\u6813\u6818\u6841\u6B8A\u6B89\u6BB7\u6C23\u6C27\u6C28\u6C26\u6C24\u6CF0\u6D6A\u6D95\u6D88\u6D87\u6D66\u6D78\u6D77\u6D59\u6D93"],
      ["af40", "\u6D6C\u6D89\u6D6E\u6D5A\u6D74\u6D69\u6D8C\u6D8A\u6D79\u6D85\u6D65\u6D94\u70CA\u70D8\u70E4\u70D9\u70C8\u70CF\u7239\u7279\u72FC\u72F9\u72FD\u72F8\u72F7\u7386\u73ED\u7409\u73EE\u73E0\u73EA\u73DE\u7554\u755D\u755C\u755A\u7559\u75BE\u75C5\u75C7\u75B2\u75B3\u75BD\u75BC\u75B9\u75C2\u75B8\u768B\u76B0\u76CA\u76CD\u76CE\u7729\u771F\u7720\u7728\u77E9\u7830\u7827\u7838\u781D\u7834\u7837"],
      ["afa1", "\u7825\u782D\u7820\u781F\u7832\u7955\u7950\u7960\u795F\u7956\u795E\u795D\u7957\u795A\u79E4\u79E3\u79E7\u79DF\u79E6\u79E9\u79D8\u7A84\u7A88\u7AD9\u7B06\u7B11\u7C89\u7D21\u7D17\u7D0B\u7D0A\u7D20\u7D22\u7D14\u7D10\u7D15\u7D1A\u7D1C\u7D0D\u7D19\u7D1B\u7F3A\u7F5F\u7F94\u7FC5\u7FC1\u8006\u8018\u8015\u8019\u8017\u803D\u803F\u80F1\u8102\u80F0\u8105\u80ED\u80F4\u8106\u80F8\u80F3\u8108\u80FD\u810A\u80FC\u80EF\u81ED\u81EC\u8200\u8210\u822A\u822B\u8228\u822C\u82BB\u832B\u8352\u8354\u834A\u8338\u8350\u8349\u8335\u8334\u834F\u8332\u8339\u8336\u8317\u8340\u8331\u8328\u8343"],
      ["b040", "\u8654\u868A\u86AA\u8693\u86A4\u86A9\u868C\u86A3\u869C\u8870\u8877\u8881\u8882\u887D\u8879\u8A18\u8A10\u8A0E\u8A0C\u8A15\u8A0A\u8A17\u8A13\u8A16\u8A0F\u8A11\u8C48\u8C7A\u8C79\u8CA1\u8CA2\u8D77\u8EAC\u8ED2\u8ED4\u8ECF\u8FB1\u9001\u9006\u8FF7\u9000\u8FFA\u8FF4\u9003\u8FFD\u9005\u8FF8\u9095\u90E1\u90DD\u90E2\u9152\u914D\u914C\u91D8\u91DD\u91D7\u91DC\u91D9\u9583\u9662\u9663\u9661"],
      ["b0a1", "\u965B\u965D\u9664\u9658\u965E\u96BB\u98E2\u99AC\u9AA8\u9AD8\u9B25\u9B32\u9B3C\u4E7E\u507A\u507D\u505C\u5047\u5043\u504C\u505A\u5049\u5065\u5076\u504E\u5055\u5075\u5074\u5077\u504F\u500F\u506F\u506D\u515C\u5195\u51F0\u526A\u526F\u52D2\u52D9\u52D8\u52D5\u5310\u530F\u5319\u533F\u5340\u533E\u53C3\u66FC\u5546\u556A\u5566\u5544\u555E\u5561\u5543\u554A\u5531\u5556\u554F\u5555\u552F\u5564\u5538\u552E\u555C\u552C\u5563\u5533\u5541\u5557\u5708\u570B\u5709\u57DF\u5805\u580A\u5806\u57E0\u57E4\u57FA\u5802\u5835\u57F7\u57F9\u5920\u5962\u5A36\u5A41\u5A49\u5A66\u5A6A\u5A40"],
      ["b140", "\u5A3C\u5A62\u5A5A\u5A46\u5A4A\u5B70\u5BC7\u5BC5\u5BC4\u5BC2\u5BBF\u5BC6\u5C09\u5C08\u5C07\u5C60\u5C5C\u5C5D\u5D07\u5D06\u5D0E\u5D1B\u5D16\u5D22\u5D11\u5D29\u5D14\u5D19\u5D24\u5D27\u5D17\u5DE2\u5E38\u5E36\u5E33\u5E37\u5EB7\u5EB8\u5EB6\u5EB5\u5EBE\u5F35\u5F37\u5F57\u5F6C\u5F69\u5F6B\u5F97\u5F99\u5F9E\u5F98\u5FA1\u5FA0\u5F9C\u607F\u60A3\u6089\u60A0\u60A8\u60CB\u60B4\u60E6\u60BD"],
      ["b1a1", "\u60C5\u60BB\u60B5\u60DC\u60BC\u60D8\u60D5\u60C6\u60DF\u60B8\u60DA\u60C7\u621A\u621B\u6248\u63A0\u63A7\u6372\u6396\u63A2\u63A5\u6377\u6367\u6398\u63AA\u6371\u63A9\u6389\u6383\u639B\u636B\u63A8\u6384\u6388\u6399\u63A1\u63AC\u6392\u638F\u6380\u637B\u6369\u6368\u637A\u655D\u6556\u6551\u6559\u6557\u555F\u654F\u6558\u6555\u6554\u659C\u659B\u65AC\u65CF\u65CB\u65CC\u65CE\u665D\u665A\u6664\u6668\u6666\u665E\u66F9\u52D7\u671B\u6881\u68AF\u68A2\u6893\u68B5\u687F\u6876\u68B1\u68A7\u6897\u68B0\u6883\u68C4\u68AD\u6886\u6885\u6894\u689D\u68A8\u689F\u68A1\u6882\u6B32\u6BBA"],
      ["b240", "\u6BEB\u6BEC\u6C2B\u6D8E\u6DBC\u6DF3\u6DD9\u6DB2\u6DE1\u6DCC\u6DE4\u6DFB\u6DFA\u6E05\u6DC7\u6DCB\u6DAF\u6DD1\u6DAE\u6DDE\u6DF9\u6DB8\u6DF7\u6DF5\u6DC5\u6DD2\u6E1A\u6DB5\u6DDA\u6DEB\u6DD8\u6DEA\u6DF1\u6DEE\u6DE8\u6DC6\u6DC4\u6DAA\u6DEC\u6DBF\u6DE6\u70F9\u7109\u710A\u70FD\u70EF\u723D\u727D\u7281\u731C\u731B\u7316\u7313\u7319\u7387\u7405\u740A\u7403\u7406\u73FE\u740D\u74E0\u74F6"],
      ["b2a1", "\u74F7\u751C\u7522\u7565\u7566\u7562\u7570\u758F\u75D4\u75D5\u75B5\u75CA\u75CD\u768E\u76D4\u76D2\u76DB\u7737\u773E\u773C\u7736\u7738\u773A\u786B\u7843\u784E\u7965\u7968\u796D\u79FB\u7A92\u7A95\u7B20\u7B28\u7B1B\u7B2C\u7B26\u7B19\u7B1E\u7B2E\u7C92\u7C97\u7C95\u7D46\u7D43\u7D71\u7D2E\u7D39\u7D3C\u7D40\u7D30\u7D33\u7D44\u7D2F\u7D42\u7D32\u7D31\u7F3D\u7F9E\u7F9A\u7FCC\u7FCE\u7FD2\u801C\u804A\u8046\u812F\u8116\u8123\u812B\u8129\u8130\u8124\u8202\u8235\u8237\u8236\u8239\u838E\u839E\u8398\u8378\u83A2\u8396\u83BD\u83AB\u8392\u838A\u8393\u8389\u83A0\u8377\u837B\u837C"],
      ["b340", "\u8386\u83A7\u8655\u5F6A\u86C7\u86C0\u86B6\u86C4\u86B5\u86C6\u86CB\u86B1\u86AF\u86C9\u8853\u889E\u8888\u88AB\u8892\u8896\u888D\u888B\u8993\u898F\u8A2A\u8A1D\u8A23\u8A25\u8A31\u8A2D\u8A1F\u8A1B\u8A22\u8C49\u8C5A\u8CA9\u8CAC\u8CAB\u8CA8\u8CAA\u8CA7\u8D67\u8D66\u8DBE\u8DBA\u8EDB\u8EDF\u9019\u900D\u901A\u9017\u9023\u901F\u901D\u9010\u9015\u901E\u9020\u900F\u9022\u9016\u901B\u9014"],
      ["b3a1", "\u90E8\u90ED\u90FD\u9157\u91CE\u91F5\u91E6\u91E3\u91E7\u91ED\u91E9\u9589\u966A\u9675\u9673\u9678\u9670\u9674\u9676\u9677\u966C\u96C0\u96EA\u96E9\u7AE0\u7ADF\u9802\u9803\u9B5A\u9CE5\u9E75\u9E7F\u9EA5\u9EBB\u50A2\u508D\u5085\u5099\u5091\u5080\u5096\u5098\u509A\u6700\u51F1\u5272\u5274\u5275\u5269\u52DE\u52DD\u52DB\u535A\u53A5\u557B\u5580\u55A7\u557C\u558A\u559D\u5598\u5582\u559C\u55AA\u5594\u5587\u558B\u5583\u55B3\u55AE\u559F\u553E\u55B2\u559A\u55BB\u55AC\u55B1\u557E\u5589\u55AB\u5599\u570D\u582F\u582A\u5834\u5824\u5830\u5831\u5821\u581D\u5820\u58F9\u58FA\u5960"],
      ["b440", "\u5A77\u5A9A\u5A7F\u5A92\u5A9B\u5AA7\u5B73\u5B71\u5BD2\u5BCC\u5BD3\u5BD0\u5C0A\u5C0B\u5C31\u5D4C\u5D50\u5D34\u5D47\u5DFD\u5E45\u5E3D\u5E40\u5E43\u5E7E\u5ECA\u5EC1\u5EC2\u5EC4\u5F3C\u5F6D\u5FA9\u5FAA\u5FA8\u60D1\u60E1\u60B2\u60B6\u60E0\u611C\u6123\u60FA\u6115\u60F0\u60FB\u60F4\u6168\u60F1\u610E\u60F6\u6109\u6100\u6112\u621F\u6249\u63A3\u638C\u63CF\u63C0\u63E9\u63C9\u63C6\u63CD"],
      ["b4a1", "\u63D2\u63E3\u63D0\u63E1\u63D6\u63ED\u63EE\u6376\u63F4\u63EA\u63DB\u6452\u63DA\u63F9\u655E\u6566\u6562\u6563\u6591\u6590\u65AF\u666E\u6670\u6674\u6676\u666F\u6691\u667A\u667E\u6677\u66FE\u66FF\u671F\u671D\u68FA\u68D5\u68E0\u68D8\u68D7\u6905\u68DF\u68F5\u68EE\u68E7\u68F9\u68D2\u68F2\u68E3\u68CB\u68CD\u690D\u6912\u690E\u68C9\u68DA\u696E\u68FB\u6B3E\u6B3A\u6B3D\u6B98\u6B96\u6BBC\u6BEF\u6C2E\u6C2F\u6C2C\u6E2F\u6E38\u6E54\u6E21\u6E32\u6E67\u6E4A\u6E20\u6E25\u6E23\u6E1B\u6E5B\u6E58\u6E24\u6E56\u6E6E\u6E2D\u6E26\u6E6F\u6E34\u6E4D\u6E3A\u6E2C\u6E43\u6E1D\u6E3E\u6ECB"],
      ["b540", "\u6E89\u6E19\u6E4E\u6E63\u6E44\u6E72\u6E69\u6E5F\u7119\u711A\u7126\u7130\u7121\u7136\u716E\u711C\u724C\u7284\u7280\u7336\u7325\u7334\u7329\u743A\u742A\u7433\u7422\u7425\u7435\u7436\u7434\u742F\u741B\u7426\u7428\u7525\u7526\u756B\u756A\u75E2\u75DB\u75E3\u75D9\u75D8\u75DE\u75E0\u767B\u767C\u7696\u7693\u76B4\u76DC\u774F\u77ED\u785D\u786C\u786F\u7A0D\u7A08\u7A0B\u7A05\u7A00\u7A98"],
      ["b5a1", "\u7A97\u7A96\u7AE5\u7AE3\u7B49\u7B56\u7B46\u7B50\u7B52\u7B54\u7B4D\u7B4B\u7B4F\u7B51\u7C9F\u7CA5\u7D5E\u7D50\u7D68\u7D55\u7D2B\u7D6E\u7D72\u7D61\u7D66\u7D62\u7D70\u7D73\u5584\u7FD4\u7FD5\u800B\u8052\u8085\u8155\u8154\u814B\u8151\u814E\u8139\u8146\u813E\u814C\u8153\u8174\u8212\u821C\u83E9\u8403\u83F8\u840D\u83E0\u83C5\u840B\u83C1\u83EF\u83F1\u83F4\u8457\u840A\u83F0\u840C\u83CC\u83FD\u83F2\u83CA\u8438\u840E\u8404\u83DC\u8407\u83D4\u83DF\u865B\u86DF\u86D9\u86ED\u86D4\u86DB\u86E4\u86D0\u86DE\u8857\u88C1\u88C2\u88B1\u8983\u8996\u8A3B\u8A60\u8A55\u8A5E\u8A3C\u8A41"],
      ["b640", "\u8A54\u8A5B\u8A50\u8A46\u8A34\u8A3A\u8A36\u8A56\u8C61\u8C82\u8CAF\u8CBC\u8CB3\u8CBD\u8CC1\u8CBB\u8CC0\u8CB4\u8CB7\u8CB6\u8CBF\u8CB8\u8D8A\u8D85\u8D81\u8DCE\u8DDD\u8DCB\u8DDA\u8DD1\u8DCC\u8DDB\u8DC6\u8EFB\u8EF8\u8EFC\u8F9C\u902E\u9035\u9031\u9038\u9032\u9036\u9102\u90F5\u9109\u90FE\u9163\u9165\u91CF\u9214\u9215\u9223\u9209\u921E\u920D\u9210\u9207\u9211\u9594\u958F\u958B\u9591"],
      ["b6a1", "\u9593\u9592\u958E\u968A\u968E\u968B\u967D\u9685\u9686\u968D\u9672\u9684\u96C1\u96C5\u96C4\u96C6\u96C7\u96EF\u96F2\u97CC\u9805\u9806\u9808\u98E7\u98EA\u98EF\u98E9\u98F2\u98ED\u99AE\u99AD\u9EC3\u9ECD\u9ED1\u4E82\u50AD\u50B5\u50B2\u50B3\u50C5\u50BE\u50AC\u50B7\u50BB\u50AF\u50C7\u527F\u5277\u527D\u52DF\u52E6\u52E4\u52E2\u52E3\u532F\u55DF\u55E8\u55D3\u55E6\u55CE\u55DC\u55C7\u55D1\u55E3\u55E4\u55EF\u55DA\u55E1\u55C5\u55C6\u55E5\u55C9\u5712\u5713\u585E\u5851\u5858\u5857\u585A\u5854\u586B\u584C\u586D\u584A\u5862\u5852\u584B\u5967\u5AC1\u5AC9\u5ACC\u5ABE\u5ABD\u5ABC"],
      ["b740", "\u5AB3\u5AC2\u5AB2\u5D69\u5D6F\u5E4C\u5E79\u5EC9\u5EC8\u5F12\u5F59\u5FAC\u5FAE\u611A\u610F\u6148\u611F\u60F3\u611B\u60F9\u6101\u6108\u614E\u614C\u6144\u614D\u613E\u6134\u6127\u610D\u6106\u6137\u6221\u6222\u6413\u643E\u641E\u642A\u642D\u643D\u642C\u640F\u641C\u6414\u640D\u6436\u6416\u6417\u6406\u656C\u659F\u65B0\u6697\u6689\u6687\u6688\u6696\u6684\u6698\u668D\u6703\u6994\u696D"],
      ["b7a1", "\u695A\u6977\u6960\u6954\u6975\u6930\u6982\u694A\u6968\u696B\u695E\u6953\u6979\u6986\u695D\u6963\u695B\u6B47\u6B72\u6BC0\u6BBF\u6BD3\u6BFD\u6EA2\u6EAF\u6ED3\u6EB6\u6EC2\u6E90\u6E9D\u6EC7\u6EC5\u6EA5\u6E98\u6EBC\u6EBA\u6EAB\u6ED1\u6E96\u6E9C\u6EC4\u6ED4\u6EAA\u6EA7\u6EB4\u714E\u7159\u7169\u7164\u7149\u7167\u715C\u716C\u7166\u714C\u7165\u715E\u7146\u7168\u7156\u723A\u7252\u7337\u7345\u733F\u733E\u746F\u745A\u7455\u745F\u745E\u7441\u743F\u7459\u745B\u745C\u7576\u7578\u7600\u75F0\u7601\u75F2\u75F1\u75FA\u75FF\u75F4\u75F3\u76DE\u76DF\u775B\u776B\u7766\u775E\u7763"],
      ["b840", "\u7779\u776A\u776C\u775C\u7765\u7768\u7762\u77EE\u788E\u78B0\u7897\u7898\u788C\u7889\u787C\u7891\u7893\u787F\u797A\u797F\u7981\u842C\u79BD\u7A1C\u7A1A\u7A20\u7A14\u7A1F\u7A1E\u7A9F\u7AA0\u7B77\u7BC0\u7B60\u7B6E\u7B67\u7CB1\u7CB3\u7CB5\u7D93\u7D79\u7D91\u7D81\u7D8F\u7D5B\u7F6E\u7F69\u7F6A\u7F72\u7FA9\u7FA8\u7FA4\u8056\u8058\u8086\u8084\u8171\u8170\u8178\u8165\u816E\u8173\u816B"],
      ["b8a1", "\u8179\u817A\u8166\u8205\u8247\u8482\u8477\u843D\u8431\u8475\u8466\u846B\u8449\u846C\u845B\u843C\u8435\u8461\u8463\u8469\u846D\u8446\u865E\u865C\u865F\u86F9\u8713\u8708\u8707\u8700\u86FE\u86FB\u8702\u8703\u8706\u870A\u8859\u88DF\u88D4\u88D9\u88DC\u88D8\u88DD\u88E1\u88CA\u88D5\u88D2\u899C\u89E3\u8A6B\u8A72\u8A73\u8A66\u8A69\u8A70\u8A87\u8A7C\u8A63\u8AA0\u8A71\u8A85\u8A6D\u8A62\u8A6E\u8A6C\u8A79\u8A7B\u8A3E\u8A68\u8C62\u8C8A\u8C89\u8CCA\u8CC7\u8CC8\u8CC4\u8CB2\u8CC3\u8CC2\u8CC5\u8DE1\u8DDF\u8DE8\u8DEF\u8DF3\u8DFA\u8DEA\u8DE4\u8DE6\u8EB2\u8F03\u8F09\u8EFE\u8F0A"],
      ["b940", "\u8F9F\u8FB2\u904B\u904A\u9053\u9042\u9054\u903C\u9055\u9050\u9047\u904F\u904E\u904D\u9051\u903E\u9041\u9112\u9117\u916C\u916A\u9169\u91C9\u9237\u9257\u9238\u923D\u9240\u923E\u925B\u924B\u9264\u9251\u9234\u9249\u924D\u9245\u9239\u923F\u925A\u9598\u9698\u9694\u9695\u96CD\u96CB\u96C9\u96CA\u96F7\u96FB\u96F9\u96F6\u9756\u9774\u9776\u9810\u9811\u9813\u980A\u9812\u980C\u98FC\u98F4"],
      ["b9a1", "\u98FD\u98FE\u99B3\u99B1\u99B4\u9AE1\u9CE9\u9E82\u9F0E\u9F13\u9F20\u50E7\u50EE\u50E5\u50D6\u50ED\u50DA\u50D5\u50CF\u50D1\u50F1\u50CE\u50E9\u5162\u51F3\u5283\u5282\u5331\u53AD\u55FE\u5600\u561B\u5617\u55FD\u5614\u5606\u5609\u560D\u560E\u55F7\u5616\u561F\u5608\u5610\u55F6\u5718\u5716\u5875\u587E\u5883\u5893\u588A\u5879\u5885\u587D\u58FD\u5925\u5922\u5924\u596A\u5969\u5AE1\u5AE6\u5AE9\u5AD7\u5AD6\u5AD8\u5AE3\u5B75\u5BDE\u5BE7\u5BE1\u5BE5\u5BE6\u5BE8\u5BE2\u5BE4\u5BDF\u5C0D\u5C62\u5D84\u5D87\u5E5B\u5E63\u5E55\u5E57\u5E54\u5ED3\u5ED6\u5F0A\u5F46\u5F70\u5FB9\u6147"],
      ["ba40", "\u613F\u614B\u6177\u6162\u6163\u615F\u615A\u6158\u6175\u622A\u6487\u6458\u6454\u64A4\u6478\u645F\u647A\u6451\u6467\u6434\u646D\u647B\u6572\u65A1\u65D7\u65D6\u66A2\u66A8\u669D\u699C\u69A8\u6995\u69C1\u69AE\u69D3\u69CB\u699B\u69B7\u69BB\u69AB\u69B4\u69D0\u69CD\u69AD\u69CC\u69A6\u69C3\u69A3\u6B49\u6B4C\u6C33\u6F33\u6F14\u6EFE\u6F13\u6EF4\u6F29\u6F3E\u6F20\u6F2C\u6F0F\u6F02\u6F22"],
      ["baa1", "\u6EFF\u6EEF\u6F06\u6F31\u6F38\u6F32\u6F23\u6F15\u6F2B\u6F2F\u6F88\u6F2A\u6EEC\u6F01\u6EF2\u6ECC\u6EF7\u7194\u7199\u717D\u718A\u7184\u7192\u723E\u7292\u7296\u7344\u7350\u7464\u7463\u746A\u7470\u746D\u7504\u7591\u7627\u760D\u760B\u7609\u7613\u76E1\u76E3\u7784\u777D\u777F\u7761\u78C1\u789F\u78A7\u78B3\u78A9\u78A3\u798E\u798F\u798D\u7A2E\u7A31\u7AAA\u7AA9\u7AED\u7AEF\u7BA1\u7B95\u7B8B\u7B75\u7B97\u7B9D\u7B94\u7B8F\u7BB8\u7B87\u7B84\u7CB9\u7CBD\u7CBE\u7DBB\u7DB0\u7D9C\u7DBD\u7DBE\u7DA0\u7DCA\u7DB4\u7DB2\u7DB1\u7DBA\u7DA2\u7DBF\u7DB5\u7DB8\u7DAD\u7DD2\u7DC7\u7DAC"],
      ["bb40", "\u7F70\u7FE0\u7FE1\u7FDF\u805E\u805A\u8087\u8150\u8180\u818F\u8188\u818A\u817F\u8182\u81E7\u81FA\u8207\u8214\u821E\u824B\u84C9\u84BF\u84C6\u84C4\u8499\u849E\u84B2\u849C\u84CB\u84B8\u84C0\u84D3\u8490\u84BC\u84D1\u84CA\u873F\u871C\u873B\u8722\u8725\u8734\u8718\u8755\u8737\u8729\u88F3\u8902\u88F4\u88F9\u88F8\u88FD\u88E8\u891A\u88EF\u8AA6\u8A8C\u8A9E\u8AA3\u8A8D\u8AA1\u8A93\u8AA4"],
      ["bba1", "\u8AAA\u8AA5\u8AA8\u8A98\u8A91\u8A9A\u8AA7\u8C6A\u8C8D\u8C8C\u8CD3\u8CD1\u8CD2\u8D6B\u8D99\u8D95\u8DFC\u8F14\u8F12\u8F15\u8F13\u8FA3\u9060\u9058\u905C\u9063\u9059\u905E\u9062\u905D\u905B\u9119\u9118\u911E\u9175\u9178\u9177\u9174\u9278\u9280\u9285\u9298\u9296\u927B\u9293\u929C\u92A8\u927C\u9291\u95A1\u95A8\u95A9\u95A3\u95A5\u95A4\u9699\u969C\u969B\u96CC\u96D2\u9700\u977C\u9785\u97F6\u9817\u9818\u98AF\u98B1\u9903\u9905\u990C\u9909\u99C1\u9AAF\u9AB0\u9AE6\u9B41\u9B42\u9CF4\u9CF6\u9CF3\u9EBC\u9F3B\u9F4A\u5104\u5100\u50FB\u50F5\u50F9\u5102\u5108\u5109\u5105\u51DC"],
      ["bc40", "\u5287\u5288\u5289\u528D\u528A\u52F0\u53B2\u562E\u563B\u5639\u5632\u563F\u5634\u5629\u5653\u564E\u5657\u5674\u5636\u562F\u5630\u5880\u589F\u589E\u58B3\u589C\u58AE\u58A9\u58A6\u596D\u5B09\u5AFB\u5B0B\u5AF5\u5B0C\u5B08\u5BEE\u5BEC\u5BE9\u5BEB\u5C64\u5C65\u5D9D\u5D94\u5E62\u5E5F\u5E61\u5EE2\u5EDA\u5EDF\u5EDD\u5EE3\u5EE0\u5F48\u5F71\u5FB7\u5FB5\u6176\u6167\u616E\u615D\u6155\u6182"],
      ["bca1", "\u617C\u6170\u616B\u617E\u61A7\u6190\u61AB\u618E\u61AC\u619A\u61A4\u6194\u61AE\u622E\u6469\u646F\u6479\u649E\u64B2\u6488\u6490\u64B0\u64A5\u6493\u6495\u64A9\u6492\u64AE\u64AD\u64AB\u649A\u64AC\u6499\u64A2\u64B3\u6575\u6577\u6578\u66AE\u66AB\u66B4\u66B1\u6A23\u6A1F\u69E8\u6A01\u6A1E\u6A19\u69FD\u6A21\u6A13\u6A0A\u69F3\u6A02\u6A05\u69ED\u6A11\u6B50\u6B4E\u6BA4\u6BC5\u6BC6\u6F3F\u6F7C\u6F84\u6F51\u6F66\u6F54\u6F86\u6F6D\u6F5B\u6F78\u6F6E\u6F8E\u6F7A\u6F70\u6F64\u6F97\u6F58\u6ED5\u6F6F\u6F60\u6F5F\u719F\u71AC\u71B1\u71A8\u7256\u729B\u734E\u7357\u7469\u748B\u7483"],
      ["bd40", "\u747E\u7480\u757F\u7620\u7629\u761F\u7624\u7626\u7621\u7622\u769A\u76BA\u76E4\u778E\u7787\u778C\u7791\u778B\u78CB\u78C5\u78BA\u78CA\u78BE\u78D5\u78BC\u78D0\u7A3F\u7A3C\u7A40\u7A3D\u7A37\u7A3B\u7AAF\u7AAE\u7BAD\u7BB1\u7BC4\u7BB4\u7BC6\u7BC7\u7BC1\u7BA0\u7BCC\u7CCA\u7DE0\u7DF4\u7DEF\u7DFB\u7DD8\u7DEC\u7DDD\u7DE8\u7DE3\u7DDA\u7DDE\u7DE9\u7D9E\u7DD9\u7DF2\u7DF9\u7F75\u7F77\u7FAF"],
      ["bda1", "\u7FE9\u8026\u819B\u819C\u819D\u81A0\u819A\u8198\u8517\u853D\u851A\u84EE\u852C\u852D\u8513\u8511\u8523\u8521\u8514\u84EC\u8525\u84FF\u8506\u8782\u8774\u8776\u8760\u8766\u8778\u8768\u8759\u8757\u874C\u8753\u885B\u885D\u8910\u8907\u8912\u8913\u8915\u890A\u8ABC\u8AD2\u8AC7\u8AC4\u8A95\u8ACB\u8AF8\u8AB2\u8AC9\u8AC2\u8ABF\u8AB0\u8AD6\u8ACD\u8AB6\u8AB9\u8ADB\u8C4C\u8C4E\u8C6C\u8CE0\u8CDE\u8CE6\u8CE4\u8CEC\u8CED\u8CE2\u8CE3\u8CDC\u8CEA\u8CE1\u8D6D\u8D9F\u8DA3\u8E2B\u8E10\u8E1D\u8E22\u8E0F\u8E29\u8E1F\u8E21\u8E1E\u8EBA\u8F1D\u8F1B\u8F1F\u8F29\u8F26\u8F2A\u8F1C\u8F1E"],
      ["be40", "\u8F25\u9069\u906E\u9068\u906D\u9077\u9130\u912D\u9127\u9131\u9187\u9189\u918B\u9183\u92C5\u92BB\u92B7\u92EA\u92AC\u92E4\u92C1\u92B3\u92BC\u92D2\u92C7\u92F0\u92B2\u95AD\u95B1\u9704\u9706\u9707\u9709\u9760\u978D\u978B\u978F\u9821\u982B\u981C\u98B3\u990A\u9913\u9912\u9918\u99DD\u99D0\u99DF\u99DB\u99D1\u99D5\u99D2\u99D9\u9AB7\u9AEE\u9AEF\u9B27\u9B45\u9B44\u9B77\u9B6F\u9D06\u9D09"],
      ["bea1", "\u9D03\u9EA9\u9EBE\u9ECE\u58A8\u9F52\u5112\u5118\u5114\u5110\u5115\u5180\u51AA\u51DD\u5291\u5293\u52F3\u5659\u566B\u5679\u5669\u5664\u5678\u566A\u5668\u5665\u5671\u566F\u566C\u5662\u5676\u58C1\u58BE\u58C7\u58C5\u596E\u5B1D\u5B34\u5B78\u5BF0\u5C0E\u5F4A\u61B2\u6191\u61A9\u618A\u61CD\u61B6\u61BE\u61CA\u61C8\u6230\u64C5\u64C1\u64CB\u64BB\u64BC\u64DA\u64C4\u64C7\u64C2\u64CD\u64BF\u64D2\u64D4\u64BE\u6574\u66C6\u66C9\u66B9\u66C4\u66C7\u66B8\u6A3D\u6A38\u6A3A\u6A59\u6A6B\u6A58\u6A39\u6A44\u6A62\u6A61\u6A4B\u6A47\u6A35\u6A5F\u6A48\u6B59\u6B77\u6C05\u6FC2\u6FB1\u6FA1"],
      ["bf40", "\u6FC3\u6FA4\u6FC1\u6FA7\u6FB3\u6FC0\u6FB9\u6FB6\u6FA6\u6FA0\u6FB4\u71BE\u71C9\u71D0\u71D2\u71C8\u71D5\u71B9\u71CE\u71D9\u71DC\u71C3\u71C4\u7368\u749C\u74A3\u7498\u749F\u749E\u74E2\u750C\u750D\u7634\u7638\u763A\u76E7\u76E5\u77A0\u779E\u779F\u77A5\u78E8\u78DA\u78EC\u78E7\u79A6\u7A4D\u7A4E\u7A46\u7A4C\u7A4B\u7ABA\u7BD9\u7C11\u7BC9\u7BE4\u7BDB\u7BE1\u7BE9\u7BE6\u7CD5\u7CD6\u7E0A"],
      ["bfa1", "\u7E11\u7E08\u7E1B\u7E23\u7E1E\u7E1D\u7E09\u7E10\u7F79\u7FB2\u7FF0\u7FF1\u7FEE\u8028\u81B3\u81A9\u81A8\u81FB\u8208\u8258\u8259\u854A\u8559\u8548\u8568\u8569\u8543\u8549\u856D\u856A\u855E\u8783\u879F\u879E\u87A2\u878D\u8861\u892A\u8932\u8925\u892B\u8921\u89AA\u89A6\u8AE6\u8AFA\u8AEB\u8AF1\u8B00\u8ADC\u8AE7\u8AEE\u8AFE\u8B01\u8B02\u8AF7\u8AED\u8AF3\u8AF6\u8AFC\u8C6B\u8C6D\u8C93\u8CF4\u8E44\u8E31\u8E34\u8E42\u8E39\u8E35\u8F3B\u8F2F\u8F38\u8F33\u8FA8\u8FA6\u9075\u9074\u9078\u9072\u907C\u907A\u9134\u9192\u9320\u9336\u92F8\u9333\u932F\u9322\u92FC\u932B\u9304\u931A"],
      ["c040", "\u9310\u9326\u9321\u9315\u932E\u9319\u95BB\u96A7\u96A8\u96AA\u96D5\u970E\u9711\u9716\u970D\u9713\u970F\u975B\u975C\u9766\u9798\u9830\u9838\u983B\u9837\u982D\u9839\u9824\u9910\u9928\u991E\u991B\u9921\u991A\u99ED\u99E2\u99F1\u9AB8\u9ABC\u9AFB\u9AED\u9B28\u9B91\u9D15\u9D23\u9D26\u9D28\u9D12\u9D1B\u9ED8\u9ED4\u9F8D\u9F9C\u512A\u511F\u5121\u5132\u52F5\u568E\u5680\u5690\u5685\u5687"],
      ["c0a1", "\u568F\u58D5\u58D3\u58D1\u58CE\u5B30\u5B2A\u5B24\u5B7A\u5C37\u5C68\u5DBC\u5DBA\u5DBD\u5DB8\u5E6B\u5F4C\u5FBD\u61C9\u61C2\u61C7\u61E6\u61CB\u6232\u6234\u64CE\u64CA\u64D8\u64E0\u64F0\u64E6\u64EC\u64F1\u64E2\u64ED\u6582\u6583\u66D9\u66D6\u6A80\u6A94\u6A84\u6AA2\u6A9C\u6ADB\u6AA3\u6A7E\u6A97\u6A90\u6AA0\u6B5C\u6BAE\u6BDA\u6C08\u6FD8\u6FF1\u6FDF\u6FE0\u6FDB\u6FE4\u6FEB\u6FEF\u6F80\u6FEC\u6FE1\u6FE9\u6FD5\u6FEE\u6FF0\u71E7\u71DF\u71EE\u71E6\u71E5\u71ED\u71EC\u71F4\u71E0\u7235\u7246\u7370\u7372\u74A9\u74B0\u74A6\u74A8\u7646\u7642\u764C\u76EA\u77B3\u77AA\u77B0\u77AC"],
      ["c140", "\u77A7\u77AD\u77EF\u78F7\u78FA\u78F4\u78EF\u7901\u79A7\u79AA\u7A57\u7ABF\u7C07\u7C0D\u7BFE\u7BF7\u7C0C\u7BE0\u7CE0\u7CDC\u7CDE\u7CE2\u7CDF\u7CD9\u7CDD\u7E2E\u7E3E\u7E46\u7E37\u7E32\u7E43\u7E2B\u7E3D\u7E31\u7E45\u7E41\u7E34\u7E39\u7E48\u7E35\u7E3F\u7E2F\u7F44\u7FF3\u7FFC\u8071\u8072\u8070\u806F\u8073\u81C6\u81C3\u81BA\u81C2\u81C0\u81BF\u81BD\u81C9\u81BE\u81E8\u8209\u8271\u85AA"],
      ["c1a1", "\u8584\u857E\u859C\u8591\u8594\u85AF\u859B\u8587\u85A8\u858A\u8667\u87C0\u87D1\u87B3\u87D2\u87C6\u87AB\u87BB\u87BA\u87C8\u87CB\u893B\u8936\u8944\u8938\u893D\u89AC\u8B0E\u8B17\u8B19\u8B1B\u8B0A\u8B20\u8B1D\u8B04\u8B10\u8C41\u8C3F\u8C73\u8CFA\u8CFD\u8CFC\u8CF8\u8CFB\u8DA8\u8E49\u8E4B\u8E48\u8E4A\u8F44\u8F3E\u8F42\u8F45\u8F3F\u907F\u907D\u9084\u9081\u9082\u9080\u9139\u91A3\u919E\u919C\u934D\u9382\u9328\u9375\u934A\u9365\u934B\u9318\u937E\u936C\u935B\u9370\u935A\u9354\u95CA\u95CB\u95CC\u95C8\u95C6\u96B1\u96B8\u96D6\u971C\u971E\u97A0\u97D3\u9846\u98B6\u9935\u9A01"],
      ["c240", "\u99FF\u9BAE\u9BAB\u9BAA\u9BAD\u9D3B\u9D3F\u9E8B\u9ECF\u9EDE\u9EDC\u9EDD\u9EDB\u9F3E\u9F4B\u53E2\u5695\u56AE\u58D9\u58D8\u5B38\u5F5D\u61E3\u6233\u64F4\u64F2\u64FE\u6506\u64FA\u64FB\u64F7\u65B7\u66DC\u6726\u6AB3\u6AAC\u6AC3\u6ABB\u6AB8\u6AC2\u6AAE\u6AAF\u6B5F\u6B78\u6BAF\u7009\u700B\u6FFE\u7006\u6FFA\u7011\u700F\u71FB\u71FC\u71FE\u71F8\u7377\u7375\u74A7\u74BF\u7515\u7656\u7658"],
      ["c2a1", "\u7652\u77BD\u77BF\u77BB\u77BC\u790E\u79AE\u7A61\u7A62\u7A60\u7AC4\u7AC5\u7C2B\u7C27\u7C2A\u7C1E\u7C23\u7C21\u7CE7\u7E54\u7E55\u7E5E\u7E5A\u7E61\u7E52\u7E59\u7F48\u7FF9\u7FFB\u8077\u8076\u81CD\u81CF\u820A\u85CF\u85A9\u85CD\u85D0\u85C9\u85B0\u85BA\u85B9\u85A6\u87EF\u87EC\u87F2\u87E0\u8986\u89B2\u89F4\u8B28\u8B39\u8B2C\u8B2B\u8C50\u8D05\u8E59\u8E63\u8E66\u8E64\u8E5F\u8E55\u8EC0\u8F49\u8F4D\u9087\u9083\u9088\u91AB\u91AC\u91D0\u9394\u938A\u9396\u93A2\u93B3\u93AE\u93AC\u93B0\u9398\u939A\u9397\u95D4\u95D6\u95D0\u95D5\u96E2\u96DC\u96D9\u96DB\u96DE\u9724\u97A3\u97A6"],
      ["c340", "\u97AD\u97F9\u984D\u984F\u984C\u984E\u9853\u98BA\u993E\u993F\u993D\u992E\u99A5\u9A0E\u9AC1\u9B03\u9B06\u9B4F\u9B4E\u9B4D\u9BCA\u9BC9\u9BFD\u9BC8\u9BC0\u9D51\u9D5D\u9D60\u9EE0\u9F15\u9F2C\u5133\u56A5\u58DE\u58DF\u58E2\u5BF5\u9F90\u5EEC\u61F2\u61F7\u61F6\u61F5\u6500\u650F\u66E0\u66DD\u6AE5\u6ADD\u6ADA\u6AD3\u701B\u701F\u7028\u701A\u701D\u7015\u7018\u7206\u720D\u7258\u72A2\u7378"],
      ["c3a1", "\u737A\u74BD\u74CA\u74E3\u7587\u7586\u765F\u7661\u77C7\u7919\u79B1\u7A6B\u7A69\u7C3E\u7C3F\u7C38\u7C3D\u7C37\u7C40\u7E6B\u7E6D\u7E79\u7E69\u7E6A\u7F85\u7E73\u7FB6\u7FB9\u7FB8\u81D8\u85E9\u85DD\u85EA\u85D5\u85E4\u85E5\u85F7\u87FB\u8805\u880D\u87F9\u87FE\u8960\u895F\u8956\u895E\u8B41\u8B5C\u8B58\u8B49\u8B5A\u8B4E\u8B4F\u8B46\u8B59\u8D08\u8D0A\u8E7C\u8E72\u8E87\u8E76\u8E6C\u8E7A\u8E74\u8F54\u8F4E\u8FAD\u908A\u908B\u91B1\u91AE\u93E1\u93D1\u93DF\u93C3\u93C8\u93DC\u93DD\u93D6\u93E2\u93CD\u93D8\u93E4\u93D7\u93E8\u95DC\u96B4\u96E3\u972A\u9727\u9761\u97DC\u97FB\u985E"],
      ["c440", "\u9858\u985B\u98BC\u9945\u9949\u9A16\u9A19\u9B0D\u9BE8\u9BE7\u9BD6\u9BDB\u9D89\u9D61\u9D72\u9D6A\u9D6C\u9E92\u9E97\u9E93\u9EB4\u52F8\u56A8\u56B7\u56B6\u56B4\u56BC\u58E4\u5B40\u5B43\u5B7D\u5BF6\u5DC9\u61F8\u61FA\u6518\u6514\u6519\u66E6\u6727\u6AEC\u703E\u7030\u7032\u7210\u737B\u74CF\u7662\u7665\u7926\u792A\u792C\u792B\u7AC7\u7AF6\u7C4C\u7C43\u7C4D\u7CEF\u7CF0\u8FAE\u7E7D\u7E7C"],
      ["c4a1", "\u7E82\u7F4C\u8000\u81DA\u8266\u85FB\u85F9\u8611\u85FA\u8606\u860B\u8607\u860A\u8814\u8815\u8964\u89BA\u89F8\u8B70\u8B6C\u8B66\u8B6F\u8B5F\u8B6B\u8D0F\u8D0D\u8E89\u8E81\u8E85\u8E82\u91B4\u91CB\u9418\u9403\u93FD\u95E1\u9730\u98C4\u9952\u9951\u99A8\u9A2B\u9A30\u9A37\u9A35\u9C13\u9C0D\u9E79\u9EB5\u9EE8\u9F2F\u9F5F\u9F63\u9F61\u5137\u5138\u56C1\u56C0\u56C2\u5914\u5C6C\u5DCD\u61FC\u61FE\u651D\u651C\u6595\u66E9\u6AFB\u6B04\u6AFA\u6BB2\u704C\u721B\u72A7\u74D6\u74D4\u7669\u77D3\u7C50\u7E8F\u7E8C\u7FBC\u8617\u862D\u861A\u8823\u8822\u8821\u881F\u896A\u896C\u89BD\u8B74"],
      ["c540", "\u8B77\u8B7D\u8D13\u8E8A\u8E8D\u8E8B\u8F5F\u8FAF\u91BA\u942E\u9433\u9435\u943A\u9438\u9432\u942B\u95E2\u9738\u9739\u9732\u97FF\u9867\u9865\u9957\u9A45\u9A43\u9A40\u9A3E\u9ACF\u9B54\u9B51\u9C2D\u9C25\u9DAF\u9DB4\u9DC2\u9DB8\u9E9D\u9EEF\u9F19\u9F5C\u9F66\u9F67\u513C\u513B\u56C8\u56CA\u56C9\u5B7F\u5DD4\u5DD2\u5F4E\u61FF\u6524\u6B0A\u6B61\u7051\u7058\u7380\u74E4\u758A\u766E\u766C"],
      ["c5a1", "\u79B3\u7C60\u7C5F\u807E\u807D\u81DF\u8972\u896F\u89FC\u8B80\u8D16\u8D17\u8E91\u8E93\u8F61\u9148\u9444\u9451\u9452\u973D\u973E\u97C3\u97C1\u986B\u9955\u9A55\u9A4D\u9AD2\u9B1A\u9C49\u9C31\u9C3E\u9C3B\u9DD3\u9DD7\u9F34\u9F6C\u9F6A\u9F94\u56CC\u5DD6\u6200\u6523\u652B\u652A\u66EC\u6B10\u74DA\u7ACA\u7C64\u7C63\u7C65\u7E93\u7E96\u7E94\u81E2\u8638\u863F\u8831\u8B8A\u9090\u908F\u9463\u9460\u9464\u9768\u986F\u995C\u9A5A\u9A5B\u9A57\u9AD3\u9AD4\u9AD1\u9C54\u9C57\u9C56\u9DE5\u9E9F\u9EF4\u56D1\u58E9\u652C\u705E\u7671\u7672\u77D7\u7F50\u7F88\u8836\u8839\u8862\u8B93\u8B92"],
      ["c640", "\u8B96\u8277\u8D1B\u91C0\u946A\u9742\u9748\u9744\u97C6\u9870\u9A5F\u9B22\u9B58\u9C5F\u9DF9\u9DFA\u9E7C\u9E7D\u9F07\u9F77\u9F72\u5EF3\u6B16\u7063\u7C6C\u7C6E\u883B\u89C0\u8EA1\u91C1\u9472\u9470\u9871\u995E\u9AD6\u9B23\u9ECC\u7064\u77DA\u8B9A\u9477\u97C9\u9A62\u9A65\u7E9C\u8B9C\u8EAA\u91C5\u947D\u947E\u947C\u9C77\u9C78\u9EF7\u8C54\u947F\u9E1A\u7228\u9A6A\u9B31\u9E1B\u9E1E\u7C72"],
      ["c940", "\u4E42\u4E5C\u51F5\u531A\u5382\u4E07\u4E0C\u4E47\u4E8D\u56D7\uFA0C\u5C6E\u5F73\u4E0F\u5187\u4E0E\u4E2E\u4E93\u4EC2\u4EC9\u4EC8\u5198\u52FC\u536C\u53B9\u5720\u5903\u592C\u5C10\u5DFF\u65E1\u6BB3\u6BCC\u6C14\u723F\u4E31\u4E3C\u4EE8\u4EDC\u4EE9\u4EE1\u4EDD\u4EDA\u520C\u531C\u534C\u5722\u5723\u5917\u592F\u5B81\u5B84\u5C12\u5C3B\u5C74\u5C73\u5E04\u5E80\u5E82\u5FC9\u6209\u6250\u6C15"],
      ["c9a1", "\u6C36\u6C43\u6C3F\u6C3B\u72AE\u72B0\u738A\u79B8\u808A\u961E\u4F0E\u4F18\u4F2C\u4EF5\u4F14\u4EF1\u4F00\u4EF7\u4F08\u4F1D\u4F02\u4F05\u4F22\u4F13\u4F04\u4EF4\u4F12\u51B1\u5213\u5209\u5210\u52A6\u5322\u531F\u534D\u538A\u5407\u56E1\u56DF\u572E\u572A\u5734\u593C\u5980\u597C\u5985\u597B\u597E\u5977\u597F\u5B56\u5C15\u5C25\u5C7C\u5C7A\u5C7B\u5C7E\u5DDF\u5E75\u5E84\u5F02\u5F1A\u5F74\u5FD5\u5FD4\u5FCF\u625C\u625E\u6264\u6261\u6266\u6262\u6259\u6260\u625A\u6265\u65EF\u65EE\u673E\u6739\u6738\u673B\u673A\u673F\u673C\u6733\u6C18\u6C46\u6C52\u6C5C\u6C4F\u6C4A\u6C54\u6C4B"],
      ["ca40", "\u6C4C\u7071\u725E\u72B4\u72B5\u738E\u752A\u767F\u7A75\u7F51\u8278\u827C\u8280\u827D\u827F\u864D\u897E\u9099\u9097\u9098\u909B\u9094\u9622\u9624\u9620\u9623\u4F56\u4F3B\u4F62\u4F49\u4F53\u4F64\u4F3E\u4F67\u4F52\u4F5F\u4F41\u4F58\u4F2D\u4F33\u4F3F\u4F61\u518F\u51B9\u521C\u521E\u5221\u52AD\u52AE\u5309\u5363\u5372\u538E\u538F\u5430\u5437\u542A\u5454\u5445\u5419\u541C\u5425\u5418"],
      ["caa1", "\u543D\u544F\u5441\u5428\u5424\u5447\u56EE\u56E7\u56E5\u5741\u5745\u574C\u5749\u574B\u5752\u5906\u5940\u59A6\u5998\u59A0\u5997\u598E\u59A2\u5990\u598F\u59A7\u59A1\u5B8E\u5B92\u5C28\u5C2A\u5C8D\u5C8F\u5C88\u5C8B\u5C89\u5C92\u5C8A\u5C86\u5C93\u5C95\u5DE0\u5E0A\u5E0E\u5E8B\u5E89\u5E8C\u5E88\u5E8D\u5F05\u5F1D\u5F78\u5F76\u5FD2\u5FD1\u5FD0\u5FED\u5FE8\u5FEE\u5FF3\u5FE1\u5FE4\u5FE3\u5FFA\u5FEF\u5FF7\u5FFB\u6000\u5FF4\u623A\u6283\u628C\u628E\u628F\u6294\u6287\u6271\u627B\u627A\u6270\u6281\u6288\u6277\u627D\u6272\u6274\u6537\u65F0\u65F4\u65F3\u65F2\u65F5\u6745\u6747"],
      ["cb40", "\u6759\u6755\u674C\u6748\u675D\u674D\u675A\u674B\u6BD0\u6C19\u6C1A\u6C78\u6C67\u6C6B\u6C84\u6C8B\u6C8F\u6C71\u6C6F\u6C69\u6C9A\u6C6D\u6C87\u6C95\u6C9C\u6C66\u6C73\u6C65\u6C7B\u6C8E\u7074\u707A\u7263\u72BF\u72BD\u72C3\u72C6\u72C1\u72BA\u72C5\u7395\u7397\u7393\u7394\u7392\u753A\u7539\u7594\u7595\u7681\u793D\u8034\u8095\u8099\u8090\u8092\u809C\u8290\u828F\u8285\u828E\u8291\u8293"],
      ["cba1", "\u828A\u8283\u8284\u8C78\u8FC9\u8FBF\u909F\u90A1\u90A5\u909E\u90A7\u90A0\u9630\u9628\u962F\u962D\u4E33\u4F98\u4F7C\u4F85\u4F7D\u4F80\u4F87\u4F76\u4F74\u4F89\u4F84\u4F77\u4F4C\u4F97\u4F6A\u4F9A\u4F79\u4F81\u4F78\u4F90\u4F9C\u4F94\u4F9E\u4F92\u4F82\u4F95\u4F6B\u4F6E\u519E\u51BC\u51BE\u5235\u5232\u5233\u5246\u5231\u52BC\u530A\u530B\u533C\u5392\u5394\u5487\u547F\u5481\u5491\u5482\u5488\u546B\u547A\u547E\u5465\u546C\u5474\u5466\u548D\u546F\u5461\u5460\u5498\u5463\u5467\u5464\u56F7\u56F9\u576F\u5772\u576D\u576B\u5771\u5770\u5776\u5780\u5775\u577B\u5773\u5774\u5762"],
      ["cc40", "\u5768\u577D\u590C\u5945\u59B5\u59BA\u59CF\u59CE\u59B2\u59CC\u59C1\u59B6\u59BC\u59C3\u59D6\u59B1\u59BD\u59C0\u59C8\u59B4\u59C7\u5B62\u5B65\u5B93\u5B95\u5C44\u5C47\u5CAE\u5CA4\u5CA0\u5CB5\u5CAF\u5CA8\u5CAC\u5C9F\u5CA3\u5CAD\u5CA2\u5CAA\u5CA7\u5C9D\u5CA5\u5CB6\u5CB0\u5CA6\u5E17\u5E14\u5E19\u5F28\u5F22\u5F23\u5F24\u5F54\u5F82\u5F7E\u5F7D\u5FDE\u5FE5\u602D\u6026\u6019\u6032\u600B"],
      ["cca1", "\u6034\u600A\u6017\u6033\u601A\u601E\u602C\u6022\u600D\u6010\u602E\u6013\u6011\u600C\u6009\u601C\u6214\u623D\u62AD\u62B4\u62D1\u62BE\u62AA\u62B6\u62CA\u62AE\u62B3\u62AF\u62BB\u62A9\u62B0\u62B8\u653D\u65A8\u65BB\u6609\u65FC\u6604\u6612\u6608\u65FB\u6603\u660B\u660D\u6605\u65FD\u6611\u6610\u66F6\u670A\u6785\u676C\u678E\u6792\u6776\u677B\u6798\u6786\u6784\u6774\u678D\u678C\u677A\u679F\u6791\u6799\u6783\u677D\u6781\u6778\u6779\u6794\u6B25\u6B80\u6B7E\u6BDE\u6C1D\u6C93\u6CEC\u6CEB\u6CEE\u6CD9\u6CB6\u6CD4\u6CAD\u6CE7\u6CB7\u6CD0\u6CC2\u6CBA\u6CC3\u6CC6\u6CED\u6CF2"],
      ["cd40", "\u6CD2\u6CDD\u6CB4\u6C8A\u6C9D\u6C80\u6CDE\u6CC0\u6D30\u6CCD\u6CC7\u6CB0\u6CF9\u6CCF\u6CE9\u6CD1\u7094\u7098\u7085\u7093\u7086\u7084\u7091\u7096\u7082\u709A\u7083\u726A\u72D6\u72CB\u72D8\u72C9\u72DC\u72D2\u72D4\u72DA\u72CC\u72D1\u73A4\u73A1\u73AD\u73A6\u73A2\u73A0\u73AC\u739D\u74DD\u74E8\u753F\u7540\u753E\u758C\u7598\u76AF\u76F3\u76F1\u76F0\u76F5\u77F8\u77FC\u77F9\u77FB\u77FA"],
      ["cda1", "\u77F7\u7942\u793F\u79C5\u7A78\u7A7B\u7AFB\u7C75\u7CFD\u8035\u808F\u80AE\u80A3\u80B8\u80B5\u80AD\u8220\u82A0\u82C0\u82AB\u829A\u8298\u829B\u82B5\u82A7\u82AE\u82BC\u829E\u82BA\u82B4\u82A8\u82A1\u82A9\u82C2\u82A4\u82C3\u82B6\u82A2\u8670\u866F\u866D\u866E\u8C56\u8FD2\u8FCB\u8FD3\u8FCD\u8FD6\u8FD5\u8FD7\u90B2\u90B4\u90AF\u90B3\u90B0\u9639\u963D\u963C\u963A\u9643\u4FCD\u4FC5\u4FD3\u4FB2\u4FC9\u4FCB\u4FC1\u4FD4\u4FDC\u4FD9\u4FBB\u4FB3\u4FDB\u4FC7\u4FD6\u4FBA\u4FC0\u4FB9\u4FEC\u5244\u5249\u52C0\u52C2\u533D\u537C\u5397\u5396\u5399\u5398\u54BA\u54A1\u54AD\u54A5\u54CF"],
      ["ce40", "\u54C3\u830D\u54B7\u54AE\u54D6\u54B6\u54C5\u54C6\u54A0\u5470\u54BC\u54A2\u54BE\u5472\u54DE\u54B0\u57B5\u579E\u579F\u57A4\u578C\u5797\u579D\u579B\u5794\u5798\u578F\u5799\u57A5\u579A\u5795\u58F4\u590D\u5953\u59E1\u59DE\u59EE\u5A00\u59F1\u59DD\u59FA\u59FD\u59FC\u59F6\u59E4\u59F2\u59F7\u59DB\u59E9\u59F3\u59F5\u59E0\u59FE\u59F4\u59ED\u5BA8\u5C4C\u5CD0\u5CD8\u5CCC\u5CD7\u5CCB\u5CDB"],
      ["cea1", "\u5CDE\u5CDA\u5CC9\u5CC7\u5CCA\u5CD6\u5CD3\u5CD4\u5CCF\u5CC8\u5CC6\u5CCE\u5CDF\u5CF8\u5DF9\u5E21\u5E22\u5E23\u5E20\u5E24\u5EB0\u5EA4\u5EA2\u5E9B\u5EA3\u5EA5\u5F07\u5F2E\u5F56\u5F86\u6037\u6039\u6054\u6072\u605E\u6045\u6053\u6047\u6049\u605B\u604C\u6040\u6042\u605F\u6024\u6044\u6058\u6066\u606E\u6242\u6243\u62CF\u630D\u630B\u62F5\u630E\u6303\u62EB\u62F9\u630F\u630C\u62F8\u62F6\u6300\u6313\u6314\u62FA\u6315\u62FB\u62F0\u6541\u6543\u65AA\u65BF\u6636\u6621\u6632\u6635\u661C\u6626\u6622\u6633\u662B\u663A\u661D\u6634\u6639\u662E\u670F\u6710\u67C1\u67F2\u67C8\u67BA"],
      ["cf40", "\u67DC\u67BB\u67F8\u67D8\u67C0\u67B7\u67C5\u67EB\u67E4\u67DF\u67B5\u67CD\u67B3\u67F7\u67F6\u67EE\u67E3\u67C2\u67B9\u67CE\u67E7\u67F0\u67B2\u67FC\u67C6\u67ED\u67CC\u67AE\u67E6\u67DB\u67FA\u67C9\u67CA\u67C3\u67EA\u67CB\u6B28\u6B82\u6B84\u6BB6\u6BD6\u6BD8\u6BE0\u6C20\u6C21\u6D28\u6D34\u6D2D\u6D1F\u6D3C\u6D3F\u6D12\u6D0A\u6CDA\u6D33\u6D04\u6D19\u6D3A\u6D1A\u6D11\u6D00\u6D1D\u6D42"],
      ["cfa1", "\u6D01\u6D18\u6D37\u6D03\u6D0F\u6D40\u6D07\u6D20\u6D2C\u6D08\u6D22\u6D09\u6D10\u70B7\u709F\u70BE\u70B1\u70B0\u70A1\u70B4\u70B5\u70A9\u7241\u7249\u724A\u726C\u7270\u7273\u726E\u72CA\u72E4\u72E8\u72EB\u72DF\u72EA\u72E6\u72E3\u7385\u73CC\u73C2\u73C8\u73C5\u73B9\u73B6\u73B5\u73B4\u73EB\u73BF\u73C7\u73BE\u73C3\u73C6\u73B8\u73CB\u74EC\u74EE\u752E\u7547\u7548\u75A7\u75AA\u7679\u76C4\u7708\u7703\u7704\u7705\u770A\u76F7\u76FB\u76FA\u77E7\u77E8\u7806\u7811\u7812\u7805\u7810\u780F\u780E\u7809\u7803\u7813\u794A\u794C\u794B\u7945\u7944\u79D5\u79CD\u79CF\u79D6\u79CE\u7A80"],
      ["d040", "\u7A7E\u7AD1\u7B00\u7B01\u7C7A\u7C78\u7C79\u7C7F\u7C80\u7C81\u7D03\u7D08\u7D01\u7F58\u7F91\u7F8D\u7FBE\u8007\u800E\u800F\u8014\u8037\u80D8\u80C7\u80E0\u80D1\u80C8\u80C2\u80D0\u80C5\u80E3\u80D9\u80DC\u80CA\u80D5\u80C9\u80CF\u80D7\u80E6\u80CD\u81FF\u8221\u8294\u82D9\u82FE\u82F9\u8307\u82E8\u8300\u82D5\u833A\u82EB\u82D6\u82F4\u82EC\u82E1\u82F2\u82F5\u830C\u82FB\u82F6\u82F0\u82EA"],
      ["d0a1", "\u82E4\u82E0\u82FA\u82F3\u82ED\u8677\u8674\u867C\u8673\u8841\u884E\u8867\u886A\u8869\u89D3\u8A04\u8A07\u8D72\u8FE3\u8FE1\u8FEE\u8FE0\u90F1\u90BD\u90BF\u90D5\u90C5\u90BE\u90C7\u90CB\u90C8\u91D4\u91D3\u9654\u964F\u9651\u9653\u964A\u964E\u501E\u5005\u5007\u5013\u5022\u5030\u501B\u4FF5\u4FF4\u5033\u5037\u502C\u4FF6\u4FF7\u5017\u501C\u5020\u5027\u5035\u502F\u5031\u500E\u515A\u5194\u5193\u51CA\u51C4\u51C5\u51C8\u51CE\u5261\u525A\u5252\u525E\u525F\u5255\u5262\u52CD\u530E\u539E\u5526\u54E2\u5517\u5512\u54E7\u54F3\u54E4\u551A\u54FF\u5504\u5508\u54EB\u5511\u5505\u54F1"],
      ["d140", "\u550A\u54FB\u54F7\u54F8\u54E0\u550E\u5503\u550B\u5701\u5702\u57CC\u5832\u57D5\u57D2\u57BA\u57C6\u57BD\u57BC\u57B8\u57B6\u57BF\u57C7\u57D0\u57B9\u57C1\u590E\u594A\u5A19\u5A16\u5A2D\u5A2E\u5A15\u5A0F\u5A17\u5A0A\u5A1E\u5A33\u5B6C\u5BA7\u5BAD\u5BAC\u5C03\u5C56\u5C54\u5CEC\u5CFF\u5CEE\u5CF1\u5CF7\u5D00\u5CF9\u5E29\u5E28\u5EA8\u5EAE\u5EAA\u5EAC\u5F33\u5F30\u5F67\u605D\u605A\u6067"],
      ["d1a1", "\u6041\u60A2\u6088\u6080\u6092\u6081\u609D\u6083\u6095\u609B\u6097\u6087\u609C\u608E\u6219\u6246\u62F2\u6310\u6356\u632C\u6344\u6345\u6336\u6343\u63E4\u6339\u634B\u634A\u633C\u6329\u6341\u6334\u6358\u6354\u6359\u632D\u6347\u6333\u635A\u6351\u6338\u6357\u6340\u6348\u654A\u6546\u65C6\u65C3\u65C4\u65C2\u664A\u665F\u6647\u6651\u6712\u6713\u681F\u681A\u6849\u6832\u6833\u683B\u684B\u684F\u6816\u6831\u681C\u6835\u682B\u682D\u682F\u684E\u6844\u6834\u681D\u6812\u6814\u6826\u6828\u682E\u684D\u683A\u6825\u6820\u6B2C\u6B2F\u6B2D\u6B31\u6B34\u6B6D\u8082\u6B88\u6BE6\u6BE4"],
      ["d240", "\u6BE8\u6BE3\u6BE2\u6BE7\u6C25\u6D7A\u6D63\u6D64\u6D76\u6D0D\u6D61\u6D92\u6D58\u6D62\u6D6D\u6D6F\u6D91\u6D8D\u6DEF\u6D7F\u6D86\u6D5E\u6D67\u6D60\u6D97\u6D70\u6D7C\u6D5F\u6D82\u6D98\u6D2F\u6D68\u6D8B\u6D7E\u6D80\u6D84\u6D16\u6D83\u6D7B\u6D7D\u6D75\u6D90\u70DC\u70D3\u70D1\u70DD\u70CB\u7F39\u70E2\u70D7\u70D2\u70DE\u70E0\u70D4\u70CD\u70C5\u70C6\u70C7\u70DA\u70CE\u70E1\u7242\u7278"],
      ["d2a1", "\u7277\u7276\u7300\u72FA\u72F4\u72FE\u72F6\u72F3\u72FB\u7301\u73D3\u73D9\u73E5\u73D6\u73BC\u73E7\u73E3\u73E9\u73DC\u73D2\u73DB\u73D4\u73DD\u73DA\u73D7\u73D8\u73E8\u74DE\u74DF\u74F4\u74F5\u7521\u755B\u755F\u75B0\u75C1\u75BB\u75C4\u75C0\u75BF\u75B6\u75BA\u768A\u76C9\u771D\u771B\u7710\u7713\u7712\u7723\u7711\u7715\u7719\u771A\u7722\u7727\u7823\u782C\u7822\u7835\u782F\u7828\u782E\u782B\u7821\u7829\u7833\u782A\u7831\u7954\u795B\u794F\u795C\u7953\u7952\u7951\u79EB\u79EC\u79E0\u79EE\u79ED\u79EA\u79DC\u79DE\u79DD\u7A86\u7A89\u7A85\u7A8B\u7A8C\u7A8A\u7A87\u7AD8\u7B10"],
      ["d340", "\u7B04\u7B13\u7B05\u7B0F\u7B08\u7B0A\u7B0E\u7B09\u7B12\u7C84\u7C91\u7C8A\u7C8C\u7C88\u7C8D\u7C85\u7D1E\u7D1D\u7D11\u7D0E\u7D18\u7D16\u7D13\u7D1F\u7D12\u7D0F\u7D0C\u7F5C\u7F61\u7F5E\u7F60\u7F5D\u7F5B\u7F96\u7F92\u7FC3\u7FC2\u7FC0\u8016\u803E\u8039\u80FA\u80F2\u80F9\u80F5\u8101\u80FB\u8100\u8201\u822F\u8225\u8333\u832D\u8344\u8319\u8351\u8325\u8356\u833F\u8341\u8326\u831C\u8322"],
      ["d3a1", "\u8342\u834E\u831B\u832A\u8308\u833C\u834D\u8316\u8324\u8320\u8337\u832F\u8329\u8347\u8345\u834C\u8353\u831E\u832C\u834B\u8327\u8348\u8653\u8652\u86A2\u86A8\u8696\u868D\u8691\u869E\u8687\u8697\u8686\u868B\u869A\u8685\u86A5\u8699\u86A1\u86A7\u8695\u8698\u868E\u869D\u8690\u8694\u8843\u8844\u886D\u8875\u8876\u8872\u8880\u8871\u887F\u886F\u8883\u887E\u8874\u887C\u8A12\u8C47\u8C57\u8C7B\u8CA4\u8CA3\u8D76\u8D78\u8DB5\u8DB7\u8DB6\u8ED1\u8ED3\u8FFE\u8FF5\u9002\u8FFF\u8FFB\u9004\u8FFC\u8FF6\u90D6\u90E0\u90D9\u90DA\u90E3\u90DF\u90E5\u90D8\u90DB\u90D7\u90DC\u90E4\u9150"],
      ["d440", "\u914E\u914F\u91D5\u91E2\u91DA\u965C\u965F\u96BC\u98E3\u9ADF\u9B2F\u4E7F\u5070\u506A\u5061\u505E\u5060\u5053\u504B\u505D\u5072\u5048\u504D\u5041\u505B\u504A\u5062\u5015\u5045\u505F\u5069\u506B\u5063\u5064\u5046\u5040\u506E\u5073\u5057\u5051\u51D0\u526B\u526D\u526C\u526E\u52D6\u52D3\u532D\u539C\u5575\u5576\u553C\u554D\u5550\u5534\u552A\u5551\u5562\u5536\u5535\u5530\u5552\u5545"],
      ["d4a1", "\u550C\u5532\u5565\u554E\u5539\u5548\u552D\u553B\u5540\u554B\u570A\u5707\u57FB\u5814\u57E2\u57F6\u57DC\u57F4\u5800\u57ED\u57FD\u5808\u57F8\u580B\u57F3\u57CF\u5807\u57EE\u57E3\u57F2\u57E5\u57EC\u57E1\u580E\u57FC\u5810\u57E7\u5801\u580C\u57F1\u57E9\u57F0\u580D\u5804\u595C\u5A60\u5A58\u5A55\u5A67\u5A5E\u5A38\u5A35\u5A6D\u5A50\u5A5F\u5A65\u5A6C\u5A53\u5A64\u5A57\u5A43\u5A5D\u5A52\u5A44\u5A5B\u5A48\u5A8E\u5A3E\u5A4D\u5A39\u5A4C\u5A70\u5A69\u5A47\u5A51\u5A56\u5A42\u5A5C\u5B72\u5B6E\u5BC1\u5BC0\u5C59\u5D1E\u5D0B\u5D1D\u5D1A\u5D20\u5D0C\u5D28\u5D0D\u5D26\u5D25\u5D0F"],
      ["d540", "\u5D30\u5D12\u5D23\u5D1F\u5D2E\u5E3E\u5E34\u5EB1\u5EB4\u5EB9\u5EB2\u5EB3\u5F36\u5F38\u5F9B\u5F96\u5F9F\u608A\u6090\u6086\u60BE\u60B0\u60BA\u60D3\u60D4\u60CF\u60E4\u60D9\u60DD\u60C8\u60B1\u60DB\u60B7\u60CA\u60BF\u60C3\u60CD\u60C0\u6332\u6365\u638A\u6382\u637D\u63BD\u639E\u63AD\u639D\u6397\u63AB\u638E\u636F\u6387\u6390\u636E\u63AF\u6375\u639C\u636D\u63AE\u637C\u63A4\u633B\u639F"],
      ["d5a1", "\u6378\u6385\u6381\u6391\u638D\u6370\u6553\u65CD\u6665\u6661\u665B\u6659\u665C\u6662\u6718\u6879\u6887\u6890\u689C\u686D\u686E\u68AE\u68AB\u6956\u686F\u68A3\u68AC\u68A9\u6875\u6874\u68B2\u688F\u6877\u6892\u687C\u686B\u6872\u68AA\u6880\u6871\u687E\u689B\u6896\u688B\u68A0\u6889\u68A4\u6878\u687B\u6891\u688C\u688A\u687D\u6B36\u6B33\u6B37\u6B38\u6B91\u6B8F\u6B8D\u6B8E\u6B8C\u6C2A\u6DC0\u6DAB\u6DB4\u6DB3\u6E74\u6DAC\u6DE9\u6DE2\u6DB7\u6DF6\u6DD4\u6E00\u6DC8\u6DE0\u6DDF\u6DD6\u6DBE\u6DE5\u6DDC\u6DDD\u6DDB\u6DF4\u6DCA\u6DBD\u6DED\u6DF0\u6DBA\u6DD5\u6DC2\u6DCF\u6DC9"],
      ["d640", "\u6DD0\u6DF2\u6DD3\u6DFD\u6DD7\u6DCD\u6DE3\u6DBB\u70FA\u710D\u70F7\u7117\u70F4\u710C\u70F0\u7104\u70F3\u7110\u70FC\u70FF\u7106\u7113\u7100\u70F8\u70F6\u710B\u7102\u710E\u727E\u727B\u727C\u727F\u731D\u7317\u7307\u7311\u7318\u730A\u7308\u72FF\u730F\u731E\u7388\u73F6\u73F8\u73F5\u7404\u7401\u73FD\u7407\u7400\u73FA\u73FC\u73FF\u740C\u740B\u73F4\u7408\u7564\u7563\u75CE\u75D2\u75CF"],
      ["d6a1", "\u75CB\u75CC\u75D1\u75D0\u768F\u7689\u76D3\u7739\u772F\u772D\u7731\u7732\u7734\u7733\u773D\u7725\u773B\u7735\u7848\u7852\u7849\u784D\u784A\u784C\u7826\u7845\u7850\u7964\u7967\u7969\u796A\u7963\u796B\u7961\u79BB\u79FA\u79F8\u79F6\u79F7\u7A8F\u7A94\u7A90\u7B35\u7B47\u7B34\u7B25\u7B30\u7B22\u7B24\u7B33\u7B18\u7B2A\u7B1D\u7B31\u7B2B\u7B2D\u7B2F\u7B32\u7B38\u7B1A\u7B23\u7C94\u7C98\u7C96\u7CA3\u7D35\u7D3D\u7D38\u7D36\u7D3A\u7D45\u7D2C\u7D29\u7D41\u7D47\u7D3E\u7D3F\u7D4A\u7D3B\u7D28\u7F63\u7F95\u7F9C\u7F9D\u7F9B\u7FCA\u7FCB\u7FCD\u7FD0\u7FD1\u7FC7\u7FCF\u7FC9\u801F"],
      ["d740", "\u801E\u801B\u8047\u8043\u8048\u8118\u8125\u8119\u811B\u812D\u811F\u812C\u811E\u8121\u8115\u8127\u811D\u8122\u8211\u8238\u8233\u823A\u8234\u8232\u8274\u8390\u83A3\u83A8\u838D\u837A\u8373\u83A4\u8374\u838F\u8381\u8395\u8399\u8375\u8394\u83A9\u837D\u8383\u838C\u839D\u839B\u83AA\u838B\u837E\u83A5\u83AF\u8388\u8397\u83B0\u837F\u83A6\u8387\u83AE\u8376\u839A\u8659\u8656\u86BF\u86B7"],
      ["d7a1", "\u86C2\u86C1\u86C5\u86BA\u86B0\u86C8\u86B9\u86B3\u86B8\u86CC\u86B4\u86BB\u86BC\u86C3\u86BD\u86BE\u8852\u8889\u8895\u88A8\u88A2\u88AA\u889A\u8891\u88A1\u889F\u8898\u88A7\u8899\u889B\u8897\u88A4\u88AC\u888C\u8893\u888E\u8982\u89D6\u89D9\u89D5\u8A30\u8A27\u8A2C\u8A1E\u8C39\u8C3B\u8C5C\u8C5D\u8C7D\u8CA5\u8D7D\u8D7B\u8D79\u8DBC\u8DC2\u8DB9\u8DBF\u8DC1\u8ED8\u8EDE\u8EDD\u8EDC\u8ED7\u8EE0\u8EE1\u9024\u900B\u9011\u901C\u900C\u9021\u90EF\u90EA\u90F0\u90F4\u90F2\u90F3\u90D4\u90EB\u90EC\u90E9\u9156\u9158\u915A\u9153\u9155\u91EC\u91F4\u91F1\u91F3\u91F8\u91E4\u91F9\u91EA"],
      ["d840", "\u91EB\u91F7\u91E8\u91EE\u957A\u9586\u9588\u967C\u966D\u966B\u9671\u966F\u96BF\u976A\u9804\u98E5\u9997\u509B\u5095\u5094\u509E\u508B\u50A3\u5083\u508C\u508E\u509D\u5068\u509C\u5092\u5082\u5087\u515F\u51D4\u5312\u5311\u53A4\u53A7\u5591\u55A8\u55A5\u55AD\u5577\u5645\u55A2\u5593\u5588\u558F\u55B5\u5581\u55A3\u5592\u55A4\u557D\u558C\u55A6\u557F\u5595\u55A1\u558E\u570C\u5829\u5837"],
      ["d8a1", "\u5819\u581E\u5827\u5823\u5828\u57F5\u5848\u5825\u581C\u581B\u5833\u583F\u5836\u582E\u5839\u5838\u582D\u582C\u583B\u5961\u5AAF\u5A94\u5A9F\u5A7A\u5AA2\u5A9E\u5A78\u5AA6\u5A7C\u5AA5\u5AAC\u5A95\u5AAE\u5A37\u5A84\u5A8A\u5A97\u5A83\u5A8B\u5AA9\u5A7B\u5A7D\u5A8C\u5A9C\u5A8F\u5A93\u5A9D\u5BEA\u5BCD\u5BCB\u5BD4\u5BD1\u5BCA\u5BCE\u5C0C\u5C30\u5D37\u5D43\u5D6B\u5D41\u5D4B\u5D3F\u5D35\u5D51\u5D4E\u5D55\u5D33\u5D3A\u5D52\u5D3D\u5D31\u5D59\u5D42\u5D39\u5D49\u5D38\u5D3C\u5D32\u5D36\u5D40\u5D45\u5E44\u5E41\u5F58\u5FA6\u5FA5\u5FAB\u60C9\u60B9\u60CC\u60E2\u60CE\u60C4\u6114"],
      ["d940", "\u60F2\u610A\u6116\u6105\u60F5\u6113\u60F8\u60FC\u60FE\u60C1\u6103\u6118\u611D\u6110\u60FF\u6104\u610B\u624A\u6394\u63B1\u63B0\u63CE\u63E5\u63E8\u63EF\u63C3\u649D\u63F3\u63CA\u63E0\u63F6\u63D5\u63F2\u63F5\u6461\u63DF\u63BE\u63DD\u63DC\u63C4\u63D8\u63D3\u63C2\u63C7\u63CC\u63CB\u63C8\u63F0\u63D7\u63D9\u6532\u6567\u656A\u6564\u655C\u6568\u6565\u658C\u659D\u659E\u65AE\u65D0\u65D2"],
      ["d9a1", "\u667C\u666C\u667B\u6680\u6671\u6679\u666A\u6672\u6701\u690C\u68D3\u6904\u68DC\u692A\u68EC\u68EA\u68F1\u690F\u68D6\u68F7\u68EB\u68E4\u68F6\u6913\u6910\u68F3\u68E1\u6907\u68CC\u6908\u6970\u68B4\u6911\u68EF\u68C6\u6914\u68F8\u68D0\u68FD\u68FC\u68E8\u690B\u690A\u6917\u68CE\u68C8\u68DD\u68DE\u68E6\u68F4\u68D1\u6906\u68D4\u68E9\u6915\u6925\u68C7\u6B39\u6B3B\u6B3F\u6B3C\u6B94\u6B97\u6B99\u6B95\u6BBD\u6BF0\u6BF2\u6BF3\u6C30\u6DFC\u6E46\u6E47\u6E1F\u6E49\u6E88\u6E3C\u6E3D\u6E45\u6E62\u6E2B\u6E3F\u6E41\u6E5D\u6E73\u6E1C\u6E33\u6E4B\u6E40\u6E51\u6E3B\u6E03\u6E2E\u6E5E"],
      ["da40", "\u6E68\u6E5C\u6E61\u6E31\u6E28\u6E60\u6E71\u6E6B\u6E39\u6E22\u6E30\u6E53\u6E65\u6E27\u6E78\u6E64\u6E77\u6E55\u6E79\u6E52\u6E66\u6E35\u6E36\u6E5A\u7120\u711E\u712F\u70FB\u712E\u7131\u7123\u7125\u7122\u7132\u711F\u7128\u713A\u711B\u724B\u725A\u7288\u7289\u7286\u7285\u728B\u7312\u730B\u7330\u7322\u7331\u7333\u7327\u7332\u732D\u7326\u7323\u7335\u730C\u742E\u742C\u7430\u742B\u7416"],
      ["daa1", "\u741A\u7421\u742D\u7431\u7424\u7423\u741D\u7429\u7420\u7432\u74FB\u752F\u756F\u756C\u75E7\u75DA\u75E1\u75E6\u75DD\u75DF\u75E4\u75D7\u7695\u7692\u76DA\u7746\u7747\u7744\u774D\u7745\u774A\u774E\u774B\u774C\u77DE\u77EC\u7860\u7864\u7865\u785C\u786D\u7871\u786A\u786E\u7870\u7869\u7868\u785E\u7862\u7974\u7973\u7972\u7970\u7A02\u7A0A\u7A03\u7A0C\u7A04\u7A99\u7AE6\u7AE4\u7B4A\u7B3B\u7B44\u7B48\u7B4C\u7B4E\u7B40\u7B58\u7B45\u7CA2\u7C9E\u7CA8\u7CA1\u7D58\u7D6F\u7D63\u7D53\u7D56\u7D67\u7D6A\u7D4F\u7D6D\u7D5C\u7D6B\u7D52\u7D54\u7D69\u7D51\u7D5F\u7D4E\u7F3E\u7F3F\u7F65"],
      ["db40", "\u7F66\u7FA2\u7FA0\u7FA1\u7FD7\u8051\u804F\u8050\u80FE\u80D4\u8143\u814A\u8152\u814F\u8147\u813D\u814D\u813A\u81E6\u81EE\u81F7\u81F8\u81F9\u8204\u823C\u823D\u823F\u8275\u833B\u83CF\u83F9\u8423\u83C0\u83E8\u8412\u83E7\u83E4\u83FC\u83F6\u8410\u83C6\u83C8\u83EB\u83E3\u83BF\u8401\u83DD\u83E5\u83D8\u83FF\u83E1\u83CB\u83CE\u83D6\u83F5\u83C9\u8409\u840F\u83DE\u8411\u8406\u83C2\u83F3"],
      ["dba1", "\u83D5\u83FA\u83C7\u83D1\u83EA\u8413\u83C3\u83EC\u83EE\u83C4\u83FB\u83D7\u83E2\u841B\u83DB\u83FE\u86D8\u86E2\u86E6\u86D3\u86E3\u86DA\u86EA\u86DD\u86EB\u86DC\u86EC\u86E9\u86D7\u86E8\u86D1\u8848\u8856\u8855\u88BA\u88D7\u88B9\u88B8\u88C0\u88BE\u88B6\u88BC\u88B7\u88BD\u88B2\u8901\u88C9\u8995\u8998\u8997\u89DD\u89DA\u89DB\u8A4E\u8A4D\u8A39\u8A59\u8A40\u8A57\u8A58\u8A44\u8A45\u8A52\u8A48\u8A51\u8A4A\u8A4C\u8A4F\u8C5F\u8C81\u8C80\u8CBA\u8CBE\u8CB0\u8CB9\u8CB5\u8D84\u8D80\u8D89\u8DD8\u8DD3\u8DCD\u8DC7\u8DD6\u8DDC\u8DCF\u8DD5\u8DD9\u8DC8\u8DD7\u8DC5\u8EEF\u8EF7\u8EFA"],
      ["dc40", "\u8EF9\u8EE6\u8EEE\u8EE5\u8EF5\u8EE7\u8EE8\u8EF6\u8EEB\u8EF1\u8EEC\u8EF4\u8EE9\u902D\u9034\u902F\u9106\u912C\u9104\u90FF\u90FC\u9108\u90F9\u90FB\u9101\u9100\u9107\u9105\u9103\u9161\u9164\u915F\u9162\u9160\u9201\u920A\u9225\u9203\u921A\u9226\u920F\u920C\u9200\u9212\u91FF\u91FD\u9206\u9204\u9227\u9202\u921C\u9224\u9219\u9217\u9205\u9216\u957B\u958D\u958C\u9590\u9687\u967E\u9688"],
      ["dca1", "\u9689\u9683\u9680\u96C2\u96C8\u96C3\u96F1\u96F0\u976C\u9770\u976E\u9807\u98A9\u98EB\u9CE6\u9EF9\u4E83\u4E84\u4EB6\u50BD\u50BF\u50C6\u50AE\u50C4\u50CA\u50B4\u50C8\u50C2\u50B0\u50C1\u50BA\u50B1\u50CB\u50C9\u50B6\u50B8\u51D7\u527A\u5278\u527B\u527C\u55C3\u55DB\u55CC\u55D0\u55CB\u55CA\u55DD\u55C0\u55D4\u55C4\u55E9\u55BF\u55D2\u558D\u55CF\u55D5\u55E2\u55D6\u55C8\u55F2\u55CD\u55D9\u55C2\u5714\u5853\u5868\u5864\u584F\u584D\u5849\u586F\u5855\u584E\u585D\u5859\u5865\u585B\u583D\u5863\u5871\u58FC\u5AC7\u5AC4\u5ACB\u5ABA\u5AB8\u5AB1\u5AB5\u5AB0\u5ABF\u5AC8\u5ABB\u5AC6"],
      ["dd40", "\u5AB7\u5AC0\u5ACA\u5AB4\u5AB6\u5ACD\u5AB9\u5A90\u5BD6\u5BD8\u5BD9\u5C1F\u5C33\u5D71\u5D63\u5D4A\u5D65\u5D72\u5D6C\u5D5E\u5D68\u5D67\u5D62\u5DF0\u5E4F\u5E4E\u5E4A\u5E4D\u5E4B\u5EC5\u5ECC\u5EC6\u5ECB\u5EC7\u5F40\u5FAF\u5FAD\u60F7\u6149\u614A\u612B\u6145\u6136\u6132\u612E\u6146\u612F\u614F\u6129\u6140\u6220\u9168\u6223\u6225\u6224\u63C5\u63F1\u63EB\u6410\u6412\u6409\u6420\u6424"],
      ["dda1", "\u6433\u6443\u641F\u6415\u6418\u6439\u6437\u6422\u6423\u640C\u6426\u6430\u6428\u6441\u6435\u642F\u640A\u641A\u6440\u6425\u6427\u640B\u63E7\u641B\u642E\u6421\u640E\u656F\u6592\u65D3\u6686\u668C\u6695\u6690\u668B\u668A\u6699\u6694\u6678\u6720\u6966\u695F\u6938\u694E\u6962\u6971\u693F\u6945\u696A\u6939\u6942\u6957\u6959\u697A\u6948\u6949\u6935\u696C\u6933\u693D\u6965\u68F0\u6978\u6934\u6969\u6940\u696F\u6944\u6976\u6958\u6941\u6974\u694C\u693B\u694B\u6937\u695C\u694F\u6951\u6932\u6952\u692F\u697B\u693C\u6B46\u6B45\u6B43\u6B42\u6B48\u6B41\u6B9B\uFA0D\u6BFB\u6BFC"],
      ["de40", "\u6BF9\u6BF7\u6BF8\u6E9B\u6ED6\u6EC8\u6E8F\u6EC0\u6E9F\u6E93\u6E94\u6EA0\u6EB1\u6EB9\u6EC6\u6ED2\u6EBD\u6EC1\u6E9E\u6EC9\u6EB7\u6EB0\u6ECD\u6EA6\u6ECF\u6EB2\u6EBE\u6EC3\u6EDC\u6ED8\u6E99\u6E92\u6E8E\u6E8D\u6EA4\u6EA1\u6EBF\u6EB3\u6ED0\u6ECA\u6E97\u6EAE\u6EA3\u7147\u7154\u7152\u7163\u7160\u7141\u715D\u7162\u7172\u7178\u716A\u7161\u7142\u7158\u7143\u714B\u7170\u715F\u7150\u7153"],
      ["dea1", "\u7144\u714D\u715A\u724F\u728D\u728C\u7291\u7290\u728E\u733C\u7342\u733B\u733A\u7340\u734A\u7349\u7444\u744A\u744B\u7452\u7451\u7457\u7440\u744F\u7450\u744E\u7442\u7446\u744D\u7454\u74E1\u74FF\u74FE\u74FD\u751D\u7579\u7577\u6983\u75EF\u760F\u7603\u75F7\u75FE\u75FC\u75F9\u75F8\u7610\u75FB\u75F6\u75ED\u75F5\u75FD\u7699\u76B5\u76DD\u7755\u775F\u7760\u7752\u7756\u775A\u7769\u7767\u7754\u7759\u776D\u77E0\u7887\u789A\u7894\u788F\u7884\u7895\u7885\u7886\u78A1\u7883\u7879\u7899\u7880\u7896\u787B\u797C\u7982\u797D\u7979\u7A11\u7A18\u7A19\u7A12\u7A17\u7A15\u7A22\u7A13"],
      ["df40", "\u7A1B\u7A10\u7AA3\u7AA2\u7A9E\u7AEB\u7B66\u7B64\u7B6D\u7B74\u7B69\u7B72\u7B65\u7B73\u7B71\u7B70\u7B61\u7B78\u7B76\u7B63\u7CB2\u7CB4\u7CAF\u7D88\u7D86\u7D80\u7D8D\u7D7F\u7D85\u7D7A\u7D8E\u7D7B\u7D83\u7D7C\u7D8C\u7D94\u7D84\u7D7D\u7D92\u7F6D\u7F6B\u7F67\u7F68\u7F6C\u7FA6\u7FA5\u7FA7\u7FDB\u7FDC\u8021\u8164\u8160\u8177\u815C\u8169\u815B\u8162\u8172\u6721\u815E\u8176\u8167\u816F"],
      ["dfa1", "\u8144\u8161\u821D\u8249\u8244\u8240\u8242\u8245\u84F1\u843F\u8456\u8476\u8479\u848F\u848D\u8465\u8451\u8440\u8486\u8467\u8430\u844D\u847D\u845A\u8459\u8474\u8473\u845D\u8507\u845E\u8437\u843A\u8434\u847A\u8443\u8478\u8432\u8445\u8429\u83D9\u844B\u842F\u8442\u842D\u845F\u8470\u8439\u844E\u844C\u8452\u846F\u84C5\u848E\u843B\u8447\u8436\u8433\u8468\u847E\u8444\u842B\u8460\u8454\u846E\u8450\u870B\u8704\u86F7\u870C\u86FA\u86D6\u86F5\u874D\u86F8\u870E\u8709\u8701\u86F6\u870D\u8705\u88D6\u88CB\u88CD\u88CE\u88DE\u88DB\u88DA\u88CC\u88D0\u8985\u899B\u89DF\u89E5\u89E4"],
      ["e040", "\u89E1\u89E0\u89E2\u89DC\u89E6\u8A76\u8A86\u8A7F\u8A61\u8A3F\u8A77\u8A82\u8A84\u8A75\u8A83\u8A81\u8A74\u8A7A\u8C3C\u8C4B\u8C4A\u8C65\u8C64\u8C66\u8C86\u8C84\u8C85\u8CCC\u8D68\u8D69\u8D91\u8D8C\u8D8E\u8D8F\u8D8D\u8D93\u8D94\u8D90\u8D92\u8DF0\u8DE0\u8DEC\u8DF1\u8DEE\u8DD0\u8DE9\u8DE3\u8DE2\u8DE7\u8DF2\u8DEB\u8DF4\u8F06\u8EFF\u8F01\u8F00\u8F05\u8F07\u8F08\u8F02\u8F0B\u9052\u903F"],
      ["e0a1", "\u9044\u9049\u903D\u9110\u910D\u910F\u9111\u9116\u9114\u910B\u910E\u916E\u916F\u9248\u9252\u9230\u923A\u9266\u9233\u9265\u925E\u9283\u922E\u924A\u9246\u926D\u926C\u924F\u9260\u9267\u926F\u9236\u9261\u9270\u9231\u9254\u9263\u9250\u9272\u924E\u9253\u924C\u9256\u9232\u959F\u959C\u959E\u959B\u9692\u9693\u9691\u9697\u96CE\u96FA\u96FD\u96F8\u96F5\u9773\u9777\u9778\u9772\u980F\u980D\u980E\u98AC\u98F6\u98F9\u99AF\u99B2\u99B0\u99B5\u9AAD\u9AAB\u9B5B\u9CEA\u9CED\u9CE7\u9E80\u9EFD\u50E6\u50D4\u50D7\u50E8\u50F3\u50DB\u50EA\u50DD\u50E4\u50D3\u50EC\u50F0\u50EF\u50E3\u50E0"],
      ["e140", "\u51D8\u5280\u5281\u52E9\u52EB\u5330\u53AC\u5627\u5615\u560C\u5612\u55FC\u560F\u561C\u5601\u5613\u5602\u55FA\u561D\u5604\u55FF\u55F9\u5889\u587C\u5890\u5898\u5886\u5881\u587F\u5874\u588B\u587A\u5887\u5891\u588E\u5876\u5882\u5888\u587B\u5894\u588F\u58FE\u596B\u5ADC\u5AEE\u5AE5\u5AD5\u5AEA\u5ADA\u5AED\u5AEB\u5AF3\u5AE2\u5AE0\u5ADB\u5AEC\u5ADE\u5ADD\u5AD9\u5AE8\u5ADF\u5B77\u5BE0"],
      ["e1a1", "\u5BE3\u5C63\u5D82\u5D80\u5D7D\u5D86\u5D7A\u5D81\u5D77\u5D8A\u5D89\u5D88\u5D7E\u5D7C\u5D8D\u5D79\u5D7F\u5E58\u5E59\u5E53\u5ED8\u5ED1\u5ED7\u5ECE\u5EDC\u5ED5\u5ED9\u5ED2\u5ED4\u5F44\u5F43\u5F6F\u5FB6\u612C\u6128\u6141\u615E\u6171\u6173\u6152\u6153\u6172\u616C\u6180\u6174\u6154\u617A\u615B\u6165\u613B\u616A\u6161\u6156\u6229\u6227\u622B\u642B\u644D\u645B\u645D\u6474\u6476\u6472\u6473\u647D\u6475\u6466\u64A6\u644E\u6482\u645E\u645C\u644B\u6453\u6460\u6450\u647F\u643F\u646C\u646B\u6459\u6465\u6477\u6573\u65A0\u66A1\u66A0\u669F\u6705\u6704\u6722\u69B1\u69B6\u69C9"],
      ["e240", "\u69A0\u69CE\u6996\u69B0\u69AC\u69BC\u6991\u6999\u698E\u69A7\u698D\u69A9\u69BE\u69AF\u69BF\u69C4\u69BD\u69A4\u69D4\u69B9\u69CA\u699A\u69CF\u69B3\u6993\u69AA\u69A1\u699E\u69D9\u6997\u6990\u69C2\u69B5\u69A5\u69C6\u6B4A\u6B4D\u6B4B\u6B9E\u6B9F\u6BA0\u6BC3\u6BC4\u6BFE\u6ECE\u6EF5\u6EF1\u6F03\u6F25\u6EF8\u6F37\u6EFB\u6F2E\u6F09\u6F4E\u6F19\u6F1A\u6F27\u6F18\u6F3B\u6F12\u6EED\u6F0A"],
      ["e2a1", "\u6F36\u6F73\u6EF9\u6EEE\u6F2D\u6F40\u6F30\u6F3C\u6F35\u6EEB\u6F07\u6F0E\u6F43\u6F05\u6EFD\u6EF6\u6F39\u6F1C\u6EFC\u6F3A\u6F1F\u6F0D\u6F1E\u6F08\u6F21\u7187\u7190\u7189\u7180\u7185\u7182\u718F\u717B\u7186\u7181\u7197\u7244\u7253\u7297\u7295\u7293\u7343\u734D\u7351\u734C\u7462\u7473\u7471\u7475\u7472\u7467\u746E\u7500\u7502\u7503\u757D\u7590\u7616\u7608\u760C\u7615\u7611\u760A\u7614\u76B8\u7781\u777C\u7785\u7782\u776E\u7780\u776F\u777E\u7783\u78B2\u78AA\u78B4\u78AD\u78A8\u787E\u78AB\u789E\u78A5\u78A0\u78AC\u78A2\u78A4\u7998\u798A\u798B\u7996\u7995\u7994\u7993"],
      ["e340", "\u7997\u7988\u7992\u7990\u7A2B\u7A4A\u7A30\u7A2F\u7A28\u7A26\u7AA8\u7AAB\u7AAC\u7AEE\u7B88\u7B9C\u7B8A\u7B91\u7B90\u7B96\u7B8D\u7B8C\u7B9B\u7B8E\u7B85\u7B98\u5284\u7B99\u7BA4\u7B82\u7CBB\u7CBF\u7CBC\u7CBA\u7DA7\u7DB7\u7DC2\u7DA3\u7DAA\u7DC1\u7DC0\u7DC5\u7D9D\u7DCE\u7DC4\u7DC6\u7DCB\u7DCC\u7DAF\u7DB9\u7D96\u7DBC\u7D9F\u7DA6\u7DAE\u7DA9\u7DA1\u7DC9\u7F73\u7FE2\u7FE3\u7FE5\u7FDE"],
      ["e3a1", "\u8024\u805D\u805C\u8189\u8186\u8183\u8187\u818D\u818C\u818B\u8215\u8497\u84A4\u84A1\u849F\u84BA\u84CE\u84C2\u84AC\u84AE\u84AB\u84B9\u84B4\u84C1\u84CD\u84AA\u849A\u84B1\u84D0\u849D\u84A7\u84BB\u84A2\u8494\u84C7\u84CC\u849B\u84A9\u84AF\u84A8\u84D6\u8498\u84B6\u84CF\u84A0\u84D7\u84D4\u84D2\u84DB\u84B0\u8491\u8661\u8733\u8723\u8728\u876B\u8740\u872E\u871E\u8721\u8719\u871B\u8743\u872C\u8741\u873E\u8746\u8720\u8732\u872A\u872D\u873C\u8712\u873A\u8731\u8735\u8742\u8726\u8727\u8738\u8724\u871A\u8730\u8711\u88F7\u88E7\u88F1\u88F2\u88FA\u88FE\u88EE\u88FC\u88F6\u88FB"],
      ["e440", "\u88F0\u88EC\u88EB\u899D\u89A1\u899F\u899E\u89E9\u89EB\u89E8\u8AAB\u8A99\u8A8B\u8A92\u8A8F\u8A96\u8C3D\u8C68\u8C69\u8CD5\u8CCF\u8CD7\u8D96\u8E09\u8E02\u8DFF\u8E0D\u8DFD\u8E0A\u8E03\u8E07\u8E06\u8E05\u8DFE\u8E00\u8E04\u8F10\u8F11\u8F0E\u8F0D\u9123\u911C\u9120\u9122\u911F\u911D\u911A\u9124\u9121\u911B\u917A\u9172\u9179\u9173\u92A5\u92A4\u9276\u929B\u927A\u92A0\u9294\u92AA\u928D"],
      ["e4a1", "\u92A6\u929A\u92AB\u9279\u9297\u927F\u92A3\u92EE\u928E\u9282\u9295\u92A2\u927D\u9288\u92A1\u928A\u9286\u928C\u9299\u92A7\u927E\u9287\u92A9\u929D\u928B\u922D\u969E\u96A1\u96FF\u9758\u977D\u977A\u977E\u9783\u9780\u9782\u977B\u9784\u9781\u977F\u97CE\u97CD\u9816\u98AD\u98AE\u9902\u9900\u9907\u999D\u999C\u99C3\u99B9\u99BB\u99BA\u99C2\u99BD\u99C7\u9AB1\u9AE3\u9AE7\u9B3E\u9B3F\u9B60\u9B61\u9B5F\u9CF1\u9CF2\u9CF5\u9EA7\u50FF\u5103\u5130\u50F8\u5106\u5107\u50F6\u50FE\u510B\u510C\u50FD\u510A\u528B\u528C\u52F1\u52EF\u5648\u5642\u564C\u5635\u5641\u564A\u5649\u5646\u5658"],
      ["e540", "\u565A\u5640\u5633\u563D\u562C\u563E\u5638\u562A\u563A\u571A\u58AB\u589D\u58B1\u58A0\u58A3\u58AF\u58AC\u58A5\u58A1\u58FF\u5AFF\u5AF4\u5AFD\u5AF7\u5AF6\u5B03\u5AF8\u5B02\u5AF9\u5B01\u5B07\u5B05\u5B0F\u5C67\u5D99\u5D97\u5D9F\u5D92\u5DA2\u5D93\u5D95\u5DA0\u5D9C\u5DA1\u5D9A\u5D9E\u5E69\u5E5D\u5E60\u5E5C\u7DF3\u5EDB\u5EDE\u5EE1\u5F49\u5FB2\u618B\u6183\u6179\u61B1\u61B0\u61A2\u6189"],
      ["e5a1", "\u619B\u6193\u61AF\u61AD\u619F\u6192\u61AA\u61A1\u618D\u6166\u61B3\u622D\u646E\u6470\u6496\u64A0\u6485\u6497\u649C\u648F\u648B\u648A\u648C\u64A3\u649F\u6468\u64B1\u6498\u6576\u657A\u6579\u657B\u65B2\u65B3\u66B5\u66B0\u66A9\u66B2\u66B7\u66AA\u66AF\u6A00\u6A06\u6A17\u69E5\u69F8\u6A15\u69F1\u69E4\u6A20\u69FF\u69EC\u69E2\u6A1B\u6A1D\u69FE\u6A27\u69F2\u69EE\u6A14\u69F7\u69E7\u6A40\u6A08\u69E6\u69FB\u6A0D\u69FC\u69EB\u6A09\u6A04\u6A18\u6A25\u6A0F\u69F6\u6A26\u6A07\u69F4\u6A16\u6B51\u6BA5\u6BA3\u6BA2\u6BA6\u6C01\u6C00\u6BFF\u6C02\u6F41\u6F26\u6F7E\u6F87\u6FC6\u6F92"],
      ["e640", "\u6F8D\u6F89\u6F8C\u6F62\u6F4F\u6F85\u6F5A\u6F96\u6F76\u6F6C\u6F82\u6F55\u6F72\u6F52\u6F50\u6F57\u6F94\u6F93\u6F5D\u6F00\u6F61\u6F6B\u6F7D\u6F67\u6F90\u6F53\u6F8B\u6F69\u6F7F\u6F95\u6F63\u6F77\u6F6A\u6F7B\u71B2\u71AF\u719B\u71B0\u71A0\u719A\u71A9\u71B5\u719D\u71A5\u719E\u71A4\u71A1\u71AA\u719C\u71A7\u71B3\u7298\u729A\u7358\u7352\u735E\u735F\u7360\u735D\u735B\u7361\u735A\u7359"],
      ["e6a1", "\u7362\u7487\u7489\u748A\u7486\u7481\u747D\u7485\u7488\u747C\u7479\u7508\u7507\u757E\u7625\u761E\u7619\u761D\u761C\u7623\u761A\u7628\u761B\u769C\u769D\u769E\u769B\u778D\u778F\u7789\u7788\u78CD\u78BB\u78CF\u78CC\u78D1\u78CE\u78D4\u78C8\u78C3\u78C4\u78C9\u799A\u79A1\u79A0\u799C\u79A2\u799B\u6B76\u7A39\u7AB2\u7AB4\u7AB3\u7BB7\u7BCB\u7BBE\u7BAC\u7BCE\u7BAF\u7BB9\u7BCA\u7BB5\u7CC5\u7CC8\u7CCC\u7CCB\u7DF7\u7DDB\u7DEA\u7DE7\u7DD7\u7DE1\u7E03\u7DFA\u7DE6\u7DF6\u7DF1\u7DF0\u7DEE\u7DDF\u7F76\u7FAC\u7FB0\u7FAD\u7FED\u7FEB\u7FEA\u7FEC\u7FE6\u7FE8\u8064\u8067\u81A3\u819F"],
      ["e740", "\u819E\u8195\u81A2\u8199\u8197\u8216\u824F\u8253\u8252\u8250\u824E\u8251\u8524\u853B\u850F\u8500\u8529\u850E\u8509\u850D\u851F\u850A\u8527\u851C\u84FB\u852B\u84FA\u8508\u850C\u84F4\u852A\u84F2\u8515\u84F7\u84EB\u84F3\u84FC\u8512\u84EA\u84E9\u8516\u84FE\u8528\u851D\u852E\u8502\u84FD\u851E\u84F6\u8531\u8526\u84E7\u84E8\u84F0\u84EF\u84F9\u8518\u8520\u8530\u850B\u8519\u852F\u8662"],
      ["e7a1", "\u8756\u8763\u8764\u8777\u87E1\u8773\u8758\u8754\u875B\u8752\u8761\u875A\u8751\u875E\u876D\u876A\u8750\u874E\u875F\u875D\u876F\u876C\u877A\u876E\u875C\u8765\u874F\u877B\u8775\u8762\u8767\u8769\u885A\u8905\u890C\u8914\u890B\u8917\u8918\u8919\u8906\u8916\u8911\u890E\u8909\u89A2\u89A4\u89A3\u89ED\u89F0\u89EC\u8ACF\u8AC6\u8AB8\u8AD3\u8AD1\u8AD4\u8AD5\u8ABB\u8AD7\u8ABE\u8AC0\u8AC5\u8AD8\u8AC3\u8ABA\u8ABD\u8AD9\u8C3E\u8C4D\u8C8F\u8CE5\u8CDF\u8CD9\u8CE8\u8CDA\u8CDD\u8CE7\u8DA0\u8D9C\u8DA1\u8D9B\u8E20\u8E23\u8E25\u8E24\u8E2E\u8E15\u8E1B\u8E16\u8E11\u8E19\u8E26\u8E27"],
      ["e840", "\u8E14\u8E12\u8E18\u8E13\u8E1C\u8E17\u8E1A\u8F2C\u8F24\u8F18\u8F1A\u8F20\u8F23\u8F16\u8F17\u9073\u9070\u906F\u9067\u906B\u912F\u912B\u9129\u912A\u9132\u9126\u912E\u9185\u9186\u918A\u9181\u9182\u9184\u9180\u92D0\u92C3\u92C4\u92C0\u92D9\u92B6\u92CF\u92F1\u92DF\u92D8\u92E9\u92D7\u92DD\u92CC\u92EF\u92C2\u92E8\u92CA\u92C8\u92CE\u92E6\u92CD\u92D5\u92C9\u92E0\u92DE\u92E7\u92D1\u92D3"],
      ["e8a1", "\u92B5\u92E1\u92C6\u92B4\u957C\u95AC\u95AB\u95AE\u95B0\u96A4\u96A2\u96D3\u9705\u9708\u9702\u975A\u978A\u978E\u9788\u97D0\u97CF\u981E\u981D\u9826\u9829\u9828\u9820\u981B\u9827\u98B2\u9908\u98FA\u9911\u9914\u9916\u9917\u9915\u99DC\u99CD\u99CF\u99D3\u99D4\u99CE\u99C9\u99D6\u99D8\u99CB\u99D7\u99CC\u9AB3\u9AEC\u9AEB\u9AF3\u9AF2\u9AF1\u9B46\u9B43\u9B67\u9B74\u9B71\u9B66\u9B76\u9B75\u9B70\u9B68\u9B64\u9B6C\u9CFC\u9CFA\u9CFD\u9CFF\u9CF7\u9D07\u9D00\u9CF9\u9CFB\u9D08\u9D05\u9D04\u9E83\u9ED3\u9F0F\u9F10\u511C\u5113\u5117\u511A\u5111\u51DE\u5334\u53E1\u5670\u5660\u566E"],
      ["e940", "\u5673\u5666\u5663\u566D\u5672\u565E\u5677\u571C\u571B\u58C8\u58BD\u58C9\u58BF\u58BA\u58C2\u58BC\u58C6\u5B17\u5B19\u5B1B\u5B21\u5B14\u5B13\u5B10\u5B16\u5B28\u5B1A\u5B20\u5B1E\u5BEF\u5DAC\u5DB1\u5DA9\u5DA7\u5DB5\u5DB0\u5DAE\u5DAA\u5DA8\u5DB2\u5DAD\u5DAF\u5DB4\u5E67\u5E68\u5E66\u5E6F\u5EE9\u5EE7\u5EE6\u5EE8\u5EE5\u5F4B\u5FBC\u619D\u61A8\u6196\u61C5\u61B4\u61C6\u61C1\u61CC\u61BA"],
      ["e9a1", "\u61BF\u61B8\u618C\u64D7\u64D6\u64D0\u64CF\u64C9\u64BD\u6489\u64C3\u64DB\u64F3\u64D9\u6533\u657F\u657C\u65A2\u66C8\u66BE\u66C0\u66CA\u66CB\u66CF\u66BD\u66BB\u66BA\u66CC\u6723\u6A34\u6A66\u6A49\u6A67\u6A32\u6A68\u6A3E\u6A5D\u6A6D\u6A76\u6A5B\u6A51\u6A28\u6A5A\u6A3B\u6A3F\u6A41\u6A6A\u6A64\u6A50\u6A4F\u6A54\u6A6F\u6A69\u6A60\u6A3C\u6A5E\u6A56\u6A55\u6A4D\u6A4E\u6A46\u6B55\u6B54\u6B56\u6BA7\u6BAA\u6BAB\u6BC8\u6BC7\u6C04\u6C03\u6C06\u6FAD\u6FCB\u6FA3\u6FC7\u6FBC\u6FCE\u6FC8\u6F5E\u6FC4\u6FBD\u6F9E\u6FCA\u6FA8\u7004\u6FA5\u6FAE\u6FBA\u6FAC\u6FAA\u6FCF\u6FBF\u6FB8"],
      ["ea40", "\u6FA2\u6FC9\u6FAB\u6FCD\u6FAF\u6FB2\u6FB0\u71C5\u71C2\u71BF\u71B8\u71D6\u71C0\u71C1\u71CB\u71D4\u71CA\u71C7\u71CF\u71BD\u71D8\u71BC\u71C6\u71DA\u71DB\u729D\u729E\u7369\u7366\u7367\u736C\u7365\u736B\u736A\u747F\u749A\u74A0\u7494\u7492\u7495\u74A1\u750B\u7580\u762F\u762D\u7631\u763D\u7633\u763C\u7635\u7632\u7630\u76BB\u76E6\u779A\u779D\u77A1\u779C\u779B\u77A2\u77A3\u7795\u7799"],
      ["eaa1", "\u7797\u78DD\u78E9\u78E5\u78EA\u78DE\u78E3\u78DB\u78E1\u78E2\u78ED\u78DF\u78E0\u79A4\u7A44\u7A48\u7A47\u7AB6\u7AB8\u7AB5\u7AB1\u7AB7\u7BDE\u7BE3\u7BE7\u7BDD\u7BD5\u7BE5\u7BDA\u7BE8\u7BF9\u7BD4\u7BEA\u7BE2\u7BDC\u7BEB\u7BD8\u7BDF\u7CD2\u7CD4\u7CD7\u7CD0\u7CD1\u7E12\u7E21\u7E17\u7E0C\u7E1F\u7E20\u7E13\u7E0E\u7E1C\u7E15\u7E1A\u7E22\u7E0B\u7E0F\u7E16\u7E0D\u7E14\u7E25\u7E24\u7F43\u7F7B\u7F7C\u7F7A\u7FB1\u7FEF\u802A\u8029\u806C\u81B1\u81A6\u81AE\u81B9\u81B5\u81AB\u81B0\u81AC\u81B4\u81B2\u81B7\u81A7\u81F2\u8255\u8256\u8257\u8556\u8545\u856B\u854D\u8553\u8561\u8558"],
      ["eb40", "\u8540\u8546\u8564\u8541\u8562\u8544\u8551\u8547\u8563\u853E\u855B\u8571\u854E\u856E\u8575\u8555\u8567\u8560\u858C\u8566\u855D\u8554\u8565\u856C\u8663\u8665\u8664\u879B\u878F\u8797\u8793\u8792\u8788\u8781\u8796\u8798\u8779\u8787\u87A3\u8785\u8790\u8791\u879D\u8784\u8794\u879C\u879A\u8789\u891E\u8926\u8930\u892D\u892E\u8927\u8931\u8922\u8929\u8923\u892F\u892C\u891F\u89F1\u8AE0"],
      ["eba1", "\u8AE2\u8AF2\u8AF4\u8AF5\u8ADD\u8B14\u8AE4\u8ADF\u8AF0\u8AC8\u8ADE\u8AE1\u8AE8\u8AFF\u8AEF\u8AFB\u8C91\u8C92\u8C90\u8CF5\u8CEE\u8CF1\u8CF0\u8CF3\u8D6C\u8D6E\u8DA5\u8DA7\u8E33\u8E3E\u8E38\u8E40\u8E45\u8E36\u8E3C\u8E3D\u8E41\u8E30\u8E3F\u8EBD\u8F36\u8F2E\u8F35\u8F32\u8F39\u8F37\u8F34\u9076\u9079\u907B\u9086\u90FA\u9133\u9135\u9136\u9193\u9190\u9191\u918D\u918F\u9327\u931E\u9308\u931F\u9306\u930F\u937A\u9338\u933C\u931B\u9323\u9312\u9301\u9346\u932D\u930E\u930D\u92CB\u931D\u92FA\u9325\u9313\u92F9\u92F7\u9334\u9302\u9324\u92FF\u9329\u9339\u9335\u932A\u9314\u930C"],
      ["ec40", "\u930B\u92FE\u9309\u9300\u92FB\u9316\u95BC\u95CD\u95BE\u95B9\u95BA\u95B6\u95BF\u95B5\u95BD\u96A9\u96D4\u970B\u9712\u9710\u9799\u9797\u9794\u97F0\u97F8\u9835\u982F\u9832\u9924\u991F\u9927\u9929\u999E\u99EE\u99EC\u99E5\u99E4\u99F0\u99E3\u99EA\u99E9\u99E7\u9AB9\u9ABF\u9AB4\u9ABB\u9AF6\u9AFA\u9AF9\u9AF7\u9B33\u9B80\u9B85\u9B87\u9B7C\u9B7E\u9B7B\u9B82\u9B93\u9B92\u9B90\u9B7A\u9B95"],
      ["eca1", "\u9B7D\u9B88\u9D25\u9D17\u9D20\u9D1E\u9D14\u9D29\u9D1D\u9D18\u9D22\u9D10\u9D19\u9D1F\u9E88\u9E86\u9E87\u9EAE\u9EAD\u9ED5\u9ED6\u9EFA\u9F12\u9F3D\u5126\u5125\u5122\u5124\u5120\u5129\u52F4\u5693\u568C\u568D\u5686\u5684\u5683\u567E\u5682\u567F\u5681\u58D6\u58D4\u58CF\u58D2\u5B2D\u5B25\u5B32\u5B23\u5B2C\u5B27\u5B26\u5B2F\u5B2E\u5B7B\u5BF1\u5BF2\u5DB7\u5E6C\u5E6A\u5FBE\u5FBB\u61C3\u61B5\u61BC\u61E7\u61E0\u61E5\u61E4\u61E8\u61DE\u64EF\u64E9\u64E3\u64EB\u64E4\u64E8\u6581\u6580\u65B6\u65DA\u66D2\u6A8D\u6A96\u6A81\u6AA5\u6A89\u6A9F\u6A9B\u6AA1\u6A9E\u6A87\u6A93\u6A8E"],
      ["ed40", "\u6A95\u6A83\u6AA8\u6AA4\u6A91\u6A7F\u6AA6\u6A9A\u6A85\u6A8C\u6A92\u6B5B\u6BAD\u6C09\u6FCC\u6FA9\u6FF4\u6FD4\u6FE3\u6FDC\u6FED\u6FE7\u6FE6\u6FDE\u6FF2\u6FDD\u6FE2\u6FE8\u71E1\u71F1\u71E8\u71F2\u71E4\u71F0\u71E2\u7373\u736E\u736F\u7497\u74B2\u74AB\u7490\u74AA\u74AD\u74B1\u74A5\u74AF\u7510\u7511\u7512\u750F\u7584\u7643\u7648\u7649\u7647\u76A4\u76E9\u77B5\u77AB\u77B2\u77B7\u77B6"],
      ["eda1", "\u77B4\u77B1\u77A8\u77F0\u78F3\u78FD\u7902\u78FB\u78FC\u78F2\u7905\u78F9\u78FE\u7904\u79AB\u79A8\u7A5C\u7A5B\u7A56\u7A58\u7A54\u7A5A\u7ABE\u7AC0\u7AC1\u7C05\u7C0F\u7BF2\u7C00\u7BFF\u7BFB\u7C0E\u7BF4\u7C0B\u7BF3\u7C02\u7C09\u7C03\u7C01\u7BF8\u7BFD\u7C06\u7BF0\u7BF1\u7C10\u7C0A\u7CE8\u7E2D\u7E3C\u7E42\u7E33\u9848\u7E38\u7E2A\u7E49\u7E40\u7E47\u7E29\u7E4C\u7E30\u7E3B\u7E36\u7E44\u7E3A\u7F45\u7F7F\u7F7E\u7F7D\u7FF4\u7FF2\u802C\u81BB\u81C4\u81CC\u81CA\u81C5\u81C7\u81BC\u81E9\u825B\u825A\u825C\u8583\u8580\u858F\u85A7\u8595\u85A0\u858B\u85A3\u857B\u85A4\u859A\u859E"],
      ["ee40", "\u8577\u857C\u8589\u85A1\u857A\u8578\u8557\u858E\u8596\u8586\u858D\u8599\u859D\u8581\u85A2\u8582\u8588\u8585\u8579\u8576\u8598\u8590\u859F\u8668\u87BE\u87AA\u87AD\u87C5\u87B0\u87AC\u87B9\u87B5\u87BC\u87AE\u87C9\u87C3\u87C2\u87CC\u87B7\u87AF\u87C4\u87CA\u87B4\u87B6\u87BF\u87B8\u87BD\u87DE\u87B2\u8935\u8933\u893C\u893E\u8941\u8952\u8937\u8942\u89AD\u89AF\u89AE\u89F2\u89F3\u8B1E"],
      ["eea1", "\u8B18\u8B16\u8B11\u8B05\u8B0B\u8B22\u8B0F\u8B12\u8B15\u8B07\u8B0D\u8B08\u8B06\u8B1C\u8B13\u8B1A\u8C4F\u8C70\u8C72\u8C71\u8C6F\u8C95\u8C94\u8CF9\u8D6F\u8E4E\u8E4D\u8E53\u8E50\u8E4C\u8E47\u8F43\u8F40\u9085\u907E\u9138\u919A\u91A2\u919B\u9199\u919F\u91A1\u919D\u91A0\u93A1\u9383\u93AF\u9364\u9356\u9347\u937C\u9358\u935C\u9376\u9349\u9350\u9351\u9360\u936D\u938F\u934C\u936A\u9379\u9357\u9355\u9352\u934F\u9371\u9377\u937B\u9361\u935E\u9363\u9367\u9380\u934E\u9359\u95C7\u95C0\u95C9\u95C3\u95C5\u95B7\u96AE\u96B0\u96AC\u9720\u971F\u9718\u971D\u9719\u979A\u97A1\u979C"],
      ["ef40", "\u979E\u979D\u97D5\u97D4\u97F1\u9841\u9844\u984A\u9849\u9845\u9843\u9925\u992B\u992C\u992A\u9933\u9932\u992F\u992D\u9931\u9930\u9998\u99A3\u99A1\u9A02\u99FA\u99F4\u99F7\u99F9\u99F8\u99F6\u99FB\u99FD\u99FE\u99FC\u9A03\u9ABE\u9AFE\u9AFD\u9B01\u9AFC\u9B48\u9B9A\u9BA8\u9B9E\u9B9B\u9BA6\u9BA1\u9BA5\u9BA4\u9B86\u9BA2\u9BA0\u9BAF\u9D33\u9D41\u9D67\u9D36\u9D2E\u9D2F\u9D31\u9D38\u9D30"],
      ["efa1", "\u9D45\u9D42\u9D43\u9D3E\u9D37\u9D40\u9D3D\u7FF5\u9D2D\u9E8A\u9E89\u9E8D\u9EB0\u9EC8\u9EDA\u9EFB\u9EFF\u9F24\u9F23\u9F22\u9F54\u9FA0\u5131\u512D\u512E\u5698\u569C\u5697\u569A\u569D\u5699\u5970\u5B3C\u5C69\u5C6A\u5DC0\u5E6D\u5E6E\u61D8\u61DF\u61ED\u61EE\u61F1\u61EA\u61F0\u61EB\u61D6\u61E9\u64FF\u6504\u64FD\u64F8\u6501\u6503\u64FC\u6594\u65DB\u66DA\u66DB\u66D8\u6AC5\u6AB9\u6ABD\u6AE1\u6AC6\u6ABA\u6AB6\u6AB7\u6AC7\u6AB4\u6AAD\u6B5E\u6BC9\u6C0B\u7007\u700C\u700D\u7001\u7005\u7014\u700E\u6FFF\u7000\u6FFB\u7026\u6FFC\u6FF7\u700A\u7201\u71FF\u71F9\u7203\u71FD\u7376"],
      ["f040", "\u74B8\u74C0\u74B5\u74C1\u74BE\u74B6\u74BB\u74C2\u7514\u7513\u765C\u7664\u7659\u7650\u7653\u7657\u765A\u76A6\u76BD\u76EC\u77C2\u77BA\u78FF\u790C\u7913\u7914\u7909\u7910\u7912\u7911\u79AD\u79AC\u7A5F\u7C1C\u7C29\u7C19\u7C20\u7C1F\u7C2D\u7C1D\u7C26\u7C28\u7C22\u7C25\u7C30\u7E5C\u7E50\u7E56\u7E63\u7E58\u7E62\u7E5F\u7E51\u7E60\u7E57\u7E53\u7FB5\u7FB3\u7FF7\u7FF8\u8075\u81D1\u81D2"],
      ["f0a1", "\u81D0\u825F\u825E\u85B4\u85C6\u85C0\u85C3\u85C2\u85B3\u85B5\u85BD\u85C7\u85C4\u85BF\u85CB\u85CE\u85C8\u85C5\u85B1\u85B6\u85D2\u8624\u85B8\u85B7\u85BE\u8669\u87E7\u87E6\u87E2\u87DB\u87EB\u87EA\u87E5\u87DF\u87F3\u87E4\u87D4\u87DC\u87D3\u87ED\u87D8\u87E3\u87A4\u87D7\u87D9\u8801\u87F4\u87E8\u87DD\u8953\u894B\u894F\u894C\u8946\u8950\u8951\u8949\u8B2A\u8B27\u8B23\u8B33\u8B30\u8B35\u8B47\u8B2F\u8B3C\u8B3E\u8B31\u8B25\u8B37\u8B26\u8B36\u8B2E\u8B24\u8B3B\u8B3D\u8B3A\u8C42\u8C75\u8C99\u8C98\u8C97\u8CFE\u8D04\u8D02\u8D00\u8E5C\u8E62\u8E60\u8E57\u8E56\u8E5E\u8E65\u8E67"],
      ["f140", "\u8E5B\u8E5A\u8E61\u8E5D\u8E69\u8E54\u8F46\u8F47\u8F48\u8F4B\u9128\u913A\u913B\u913E\u91A8\u91A5\u91A7\u91AF\u91AA\u93B5\u938C\u9392\u93B7\u939B\u939D\u9389\u93A7\u938E\u93AA\u939E\u93A6\u9395\u9388\u9399\u939F\u938D\u93B1\u9391\u93B2\u93A4\u93A8\u93B4\u93A3\u93A5\u95D2\u95D3\u95D1\u96B3\u96D7\u96DA\u5DC2\u96DF\u96D8\u96DD\u9723\u9722\u9725\u97AC\u97AE\u97A8\u97AB\u97A4\u97AA"],
      ["f1a1", "\u97A2\u97A5\u97D7\u97D9\u97D6\u97D8\u97FA\u9850\u9851\u9852\u98B8\u9941\u993C\u993A\u9A0F\u9A0B\u9A09\u9A0D\u9A04\u9A11\u9A0A\u9A05\u9A07\u9A06\u9AC0\u9ADC\u9B08\u9B04\u9B05\u9B29\u9B35\u9B4A\u9B4C\u9B4B\u9BC7\u9BC6\u9BC3\u9BBF\u9BC1\u9BB5\u9BB8\u9BD3\u9BB6\u9BC4\u9BB9\u9BBD\u9D5C\u9D53\u9D4F\u9D4A\u9D5B\u9D4B\u9D59\u9D56\u9D4C\u9D57\u9D52\u9D54\u9D5F\u9D58\u9D5A\u9E8E\u9E8C\u9EDF\u9F01\u9F00\u9F16\u9F25\u9F2B\u9F2A\u9F29\u9F28\u9F4C\u9F55\u5134\u5135\u5296\u52F7\u53B4\u56AB\u56AD\u56A6\u56A7\u56AA\u56AC\u58DA\u58DD\u58DB\u5912\u5B3D\u5B3E\u5B3F\u5DC3\u5E70"],
      ["f240", "\u5FBF\u61FB\u6507\u6510\u650D\u6509\u650C\u650E\u6584\u65DE\u65DD\u66DE\u6AE7\u6AE0\u6ACC\u6AD1\u6AD9\u6ACB\u6ADF\u6ADC\u6AD0\u6AEB\u6ACF\u6ACD\u6ADE\u6B60\u6BB0\u6C0C\u7019\u7027\u7020\u7016\u702B\u7021\u7022\u7023\u7029\u7017\u7024\u701C\u702A\u720C\u720A\u7207\u7202\u7205\u72A5\u72A6\u72A4\u72A3\u72A1\u74CB\u74C5\u74B7\u74C3\u7516\u7660\u77C9\u77CA\u77C4\u77F1\u791D\u791B"],
      ["f2a1", "\u7921\u791C\u7917\u791E\u79B0\u7A67\u7A68\u7C33\u7C3C\u7C39\u7C2C\u7C3B\u7CEC\u7CEA\u7E76\u7E75\u7E78\u7E70\u7E77\u7E6F\u7E7A\u7E72\u7E74\u7E68\u7F4B\u7F4A\u7F83\u7F86\u7FB7\u7FFD\u7FFE\u8078\u81D7\u81D5\u8264\u8261\u8263\u85EB\u85F1\u85ED\u85D9\u85E1\u85E8\u85DA\u85D7\u85EC\u85F2\u85F8\u85D8\u85DF\u85E3\u85DC\u85D1\u85F0\u85E6\u85EF\u85DE\u85E2\u8800\u87FA\u8803\u87F6\u87F7\u8809\u880C\u880B\u8806\u87FC\u8808\u87FF\u880A\u8802\u8962\u895A\u895B\u8957\u8961\u895C\u8958\u895D\u8959\u8988\u89B7\u89B6\u89F6\u8B50\u8B48\u8B4A\u8B40\u8B53\u8B56\u8B54\u8B4B\u8B55"],
      ["f340", "\u8B51\u8B42\u8B52\u8B57\u8C43\u8C77\u8C76\u8C9A\u8D06\u8D07\u8D09\u8DAC\u8DAA\u8DAD\u8DAB\u8E6D\u8E78\u8E73\u8E6A\u8E6F\u8E7B\u8EC2\u8F52\u8F51\u8F4F\u8F50\u8F53\u8FB4\u9140\u913F\u91B0\u91AD\u93DE\u93C7\u93CF\u93C2\u93DA\u93D0\u93F9\u93EC\u93CC\u93D9\u93A9\u93E6\u93CA\u93D4\u93EE\u93E3\u93D5\u93C4\u93CE\u93C0\u93D2\u93E7\u957D\u95DA\u95DB\u96E1\u9729\u972B\u972C\u9728\u9726"],
      ["f3a1", "\u97B3\u97B7\u97B6\u97DD\u97DE\u97DF\u985C\u9859\u985D\u9857\u98BF\u98BD\u98BB\u98BE\u9948\u9947\u9943\u99A6\u99A7\u9A1A\u9A15\u9A25\u9A1D\u9A24\u9A1B\u9A22\u9A20\u9A27\u9A23\u9A1E\u9A1C\u9A14\u9AC2\u9B0B\u9B0A\u9B0E\u9B0C\u9B37\u9BEA\u9BEB\u9BE0\u9BDE\u9BE4\u9BE6\u9BE2\u9BF0\u9BD4\u9BD7\u9BEC\u9BDC\u9BD9\u9BE5\u9BD5\u9BE1\u9BDA\u9D77\u9D81\u9D8A\u9D84\u9D88\u9D71\u9D80\u9D78\u9D86\u9D8B\u9D8C\u9D7D\u9D6B\u9D74\u9D75\u9D70\u9D69\u9D85\u9D73\u9D7B\u9D82\u9D6F\u9D79\u9D7F\u9D87\u9D68\u9E94\u9E91\u9EC0\u9EFC\u9F2D\u9F40\u9F41\u9F4D\u9F56\u9F57\u9F58\u5337\u56B2"],
      ["f440", "\u56B5\u56B3\u58E3\u5B45\u5DC6\u5DC7\u5EEE\u5EEF\u5FC0\u5FC1\u61F9\u6517\u6516\u6515\u6513\u65DF\u66E8\u66E3\u66E4\u6AF3\u6AF0\u6AEA\u6AE8\u6AF9\u6AF1\u6AEE\u6AEF\u703C\u7035\u702F\u7037\u7034\u7031\u7042\u7038\u703F\u703A\u7039\u7040\u703B\u7033\u7041\u7213\u7214\u72A8\u737D\u737C\u74BA\u76AB\u76AA\u76BE\u76ED\u77CC\u77CE\u77CF\u77CD\u77F2\u7925\u7923\u7927\u7928\u7924\u7929"],
      ["f4a1", "\u79B2\u7A6E\u7A6C\u7A6D\u7AF7\u7C49\u7C48\u7C4A\u7C47\u7C45\u7CEE\u7E7B\u7E7E\u7E81\u7E80\u7FBA\u7FFF\u8079\u81DB\u81D9\u820B\u8268\u8269\u8622\u85FF\u8601\u85FE\u861B\u8600\u85F6\u8604\u8609\u8605\u860C\u85FD\u8819\u8810\u8811\u8817\u8813\u8816\u8963\u8966\u89B9\u89F7\u8B60\u8B6A\u8B5D\u8B68\u8B63\u8B65\u8B67\u8B6D\u8DAE\u8E86\u8E88\u8E84\u8F59\u8F56\u8F57\u8F55\u8F58\u8F5A\u908D\u9143\u9141\u91B7\u91B5\u91B2\u91B3\u940B\u9413\u93FB\u9420\u940F\u9414\u93FE\u9415\u9410\u9428\u9419\u940D\u93F5\u9400\u93F7\u9407\u940E\u9416\u9412\u93FA\u9409\u93F8\u940A\u93FF"],
      ["f540", "\u93FC\u940C\u93F6\u9411\u9406\u95DE\u95E0\u95DF\u972E\u972F\u97B9\u97BB\u97FD\u97FE\u9860\u9862\u9863\u985F\u98C1\u98C2\u9950\u994E\u9959\u994C\u994B\u9953\u9A32\u9A34\u9A31\u9A2C\u9A2A\u9A36\u9A29\u9A2E\u9A38\u9A2D\u9AC7\u9ACA\u9AC6\u9B10\u9B12\u9B11\u9C0B\u9C08\u9BF7\u9C05\u9C12\u9BF8\u9C40\u9C07\u9C0E\u9C06\u9C17\u9C14\u9C09\u9D9F\u9D99\u9DA4\u9D9D\u9D92\u9D98\u9D90\u9D9B"],
      ["f5a1", "\u9DA0\u9D94\u9D9C\u9DAA\u9D97\u9DA1\u9D9A\u9DA2\u9DA8\u9D9E\u9DA3\u9DBF\u9DA9\u9D96\u9DA6\u9DA7\u9E99\u9E9B\u9E9A\u9EE5\u9EE4\u9EE7\u9EE6\u9F30\u9F2E\u9F5B\u9F60\u9F5E\u9F5D\u9F59\u9F91\u513A\u5139\u5298\u5297\u56C3\u56BD\u56BE\u5B48\u5B47\u5DCB\u5DCF\u5EF1\u61FD\u651B\u6B02\u6AFC\u6B03\u6AF8\u6B00\u7043\u7044\u704A\u7048\u7049\u7045\u7046\u721D\u721A\u7219\u737E\u7517\u766A\u77D0\u792D\u7931\u792F\u7C54\u7C53\u7CF2\u7E8A\u7E87\u7E88\u7E8B\u7E86\u7E8D\u7F4D\u7FBB\u8030\u81DD\u8618\u862A\u8626\u861F\u8623\u861C\u8619\u8627\u862E\u8621\u8620\u8629\u861E\u8625"],
      ["f640", "\u8829\u881D\u881B\u8820\u8824\u881C\u882B\u884A\u896D\u8969\u896E\u896B\u89FA\u8B79\u8B78\u8B45\u8B7A\u8B7B\u8D10\u8D14\u8DAF\u8E8E\u8E8C\u8F5E\u8F5B\u8F5D\u9146\u9144\u9145\u91B9\u943F\u943B\u9436\u9429\u943D\u943C\u9430\u9439\u942A\u9437\u942C\u9440\u9431\u95E5\u95E4\u95E3\u9735\u973A\u97BF\u97E1\u9864\u98C9\u98C6\u98C0\u9958\u9956\u9A39\u9A3D\u9A46\u9A44\u9A42\u9A41\u9A3A"],
      ["f6a1", "\u9A3F\u9ACD\u9B15\u9B17\u9B18\u9B16\u9B3A\u9B52\u9C2B\u9C1D\u9C1C\u9C2C\u9C23\u9C28\u9C29\u9C24\u9C21\u9DB7\u9DB6\u9DBC\u9DC1\u9DC7\u9DCA\u9DCF\u9DBE\u9DC5\u9DC3\u9DBB\u9DB5\u9DCE\u9DB9\u9DBA\u9DAC\u9DC8\u9DB1\u9DAD\u9DCC\u9DB3\u9DCD\u9DB2\u9E7A\u9E9C\u9EEB\u9EEE\u9EED\u9F1B\u9F18\u9F1A\u9F31\u9F4E\u9F65\u9F64\u9F92\u4EB9\u56C6\u56C5\u56CB\u5971\u5B4B\u5B4C\u5DD5\u5DD1\u5EF2\u6521\u6520\u6526\u6522\u6B0B\u6B08\u6B09\u6C0D\u7055\u7056\u7057\u7052\u721E\u721F\u72A9\u737F\u74D8\u74D5\u74D9\u74D7\u766D\u76AD\u7935\u79B4\u7A70\u7A71\u7C57\u7C5C\u7C59\u7C5B\u7C5A"],
      ["f740", "\u7CF4\u7CF1\u7E91\u7F4F\u7F87\u81DE\u826B\u8634\u8635\u8633\u862C\u8632\u8636\u882C\u8828\u8826\u882A\u8825\u8971\u89BF\u89BE\u89FB\u8B7E\u8B84\u8B82\u8B86\u8B85\u8B7F\u8D15\u8E95\u8E94\u8E9A\u8E92\u8E90\u8E96\u8E97\u8F60\u8F62\u9147\u944C\u9450\u944A\u944B\u944F\u9447\u9445\u9448\u9449\u9446\u973F\u97E3\u986A\u9869\u98CB\u9954\u995B\u9A4E\u9A53\u9A54\u9A4C\u9A4F\u9A48\u9A4A"],
      ["f7a1", "\u9A49\u9A52\u9A50\u9AD0\u9B19\u9B2B\u9B3B\u9B56\u9B55\u9C46\u9C48\u9C3F\u9C44\u9C39\u9C33\u9C41\u9C3C\u9C37\u9C34\u9C32\u9C3D\u9C36\u9DDB\u9DD2\u9DDE\u9DDA\u9DCB\u9DD0\u9DDC\u9DD1\u9DDF\u9DE9\u9DD9\u9DD8\u9DD6\u9DF5\u9DD5\u9DDD\u9EB6\u9EF0\u9F35\u9F33\u9F32\u9F42\u9F6B\u9F95\u9FA2\u513D\u5299\u58E8\u58E7\u5972\u5B4D\u5DD8\u882F\u5F4F\u6201\u6203\u6204\u6529\u6525\u6596\u66EB\u6B11\u6B12\u6B0F\u6BCA\u705B\u705A\u7222\u7382\u7381\u7383\u7670\u77D4\u7C67\u7C66\u7E95\u826C\u863A\u8640\u8639\u863C\u8631\u863B\u863E\u8830\u8832\u882E\u8833\u8976\u8974\u8973\u89FE"],
      ["f840", "\u8B8C\u8B8E\u8B8B\u8B88\u8C45\u8D19\u8E98\u8F64\u8F63\u91BC\u9462\u9455\u945D\u9457\u945E\u97C4\u97C5\u9800\u9A56\u9A59\u9B1E\u9B1F\u9B20\u9C52\u9C58\u9C50\u9C4A\u9C4D\u9C4B\u9C55\u9C59\u9C4C\u9C4E\u9DFB\u9DF7\u9DEF\u9DE3\u9DEB\u9DF8\u9DE4\u9DF6\u9DE1\u9DEE\u9DE6\u9DF2\u9DF0\u9DE2\u9DEC\u9DF4\u9DF3\u9DE8\u9DED\u9EC2\u9ED0\u9EF2\u9EF3\u9F06\u9F1C\u9F38\u9F37\u9F36\u9F43\u9F4F"],
      ["f8a1", "\u9F71\u9F70\u9F6E\u9F6F\u56D3\u56CD\u5B4E\u5C6D\u652D\u66ED\u66EE\u6B13\u705F\u7061\u705D\u7060\u7223\u74DB\u74E5\u77D5\u7938\u79B7\u79B6\u7C6A\u7E97\u7F89\u826D\u8643\u8838\u8837\u8835\u884B\u8B94\u8B95\u8E9E\u8E9F\u8EA0\u8E9D\u91BE\u91BD\u91C2\u946B\u9468\u9469\u96E5\u9746\u9743\u9747\u97C7\u97E5\u9A5E\u9AD5\u9B59\u9C63\u9C67\u9C66\u9C62\u9C5E\u9C60\u9E02\u9DFE\u9E07\u9E03\u9E06\u9E05\u9E00\u9E01\u9E09\u9DFF\u9DFD\u9E04\u9EA0\u9F1E\u9F46\u9F74\u9F75\u9F76\u56D4\u652E\u65B8\u6B18\u6B19\u6B17\u6B1A\u7062\u7226\u72AA\u77D8\u77D9\u7939\u7C69\u7C6B\u7CF6\u7E9A"],
      ["f940", "\u7E98\u7E9B\u7E99\u81E0\u81E1\u8646\u8647\u8648\u8979\u897A\u897C\u897B\u89FF\u8B98\u8B99\u8EA5\u8EA4\u8EA3\u946E\u946D\u946F\u9471\u9473\u9749\u9872\u995F\u9C68\u9C6E\u9C6D\u9E0B\u9E0D\u9E10\u9E0F\u9E12\u9E11\u9EA1\u9EF5\u9F09\u9F47\u9F78\u9F7B\u9F7A\u9F79\u571E\u7066\u7C6F\u883C\u8DB2\u8EA6\u91C3\u9474\u9478\u9476\u9475\u9A60\u9C74\u9C73\u9C71\u9C75\u9E14\u9E13\u9EF6\u9F0A"],
      ["f9a1", "\u9FA4\u7068\u7065\u7CF7\u866A\u883E\u883D\u883F\u8B9E\u8C9C\u8EA9\u8EC9\u974B\u9873\u9874\u98CC\u9961\u99AB\u9A64\u9A66\u9A67\u9B24\u9E15\u9E17\u9F48\u6207\u6B1E\u7227\u864C\u8EA8\u9482\u9480\u9481\u9A69\u9A68\u9B2E\u9E19\u7229\u864B\u8B9F\u9483\u9C79\u9EB7\u7675\u9A6B\u9C7A\u9E1D\u7069\u706A\u9EA4\u9F7E\u9F49\u9F98\u7881\u92B9\u88CF\u58BB\u6052\u7CA7\u5AFA\u2554\u2566\u2557\u2560\u256C\u2563\u255A\u2569\u255D\u2552\u2564\u2555\u255E\u256A\u2561\u2558\u2567\u255B\u2553\u2565\u2556\u255F\u256B\u2562\u2559\u2568\u255C\u2551\u2550\u256D\u256E\u2570\u256F\u2593"]
    ];
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/tables/big5-added.json
var require_big5_added2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/tables/big5-added.json"(exports2, module2) {
    module2.exports = [
      ["8740", "\u43F0\u4C32\u4603\u45A6\u4578\u{27267}\u4D77\u45B3\u{27CB1}\u4CE2\u{27CC5}\u3B95\u4736\u4744\u4C47\u4C40\u{242BF}\u{23617}\u{27352}\u{26E8B}\u{270D2}\u4C57\u{2A351}\u474F\u45DA\u4C85\u{27C6C}\u4D07\u4AA4\u46A1\u{26B23}\u7225\u{25A54}\u{21A63}\u{23E06}\u{23F61}\u664D\u56FB"],
      ["8767", "\u7D95\u591D\u{28BB9}\u3DF4\u9734\u{27BEF}\u5BDB\u{21D5E}\u5AA4\u3625\u{29EB0}\u5AD1\u5BB7\u5CFC\u676E\u8593\u{29945}\u7461\u749D\u3875\u{21D53}\u{2369E}\u{26021}\u3EEC"],
      ["87a1", "\u{258DE}\u3AF5\u7AFC\u9F97\u{24161}\u{2890D}\u{231EA}\u{20A8A}\u{2325E}\u430A\u8484\u9F96\u942F\u4930\u8613\u5896\u974A\u9218\u79D0\u7A32\u6660\u6A29\u889D\u744C\u7BC5\u6782\u7A2C\u524F\u9046\u34E6\u73C4\u{25DB9}\u74C6\u9FC7\u57B3\u492F\u544C\u4131\u{2368E}\u5818\u7A72\u{27B65}\u8B8F\u46AE\u{26E88}\u4181\u{25D99}\u7BAE\u{224BC}\u9FC8\u{224C1}\u{224C9}\u{224CC}\u9FC9\u8504\u{235BB}\u40B4\u9FCA\u44E1\u{2ADFF}\u62C1\u706E\u9FCB"],
      ["8840", "\u31C0", 4, "\u{2010C}\u31C5\u{200D1}\u{200CD}\u31C6\u31C7\u{200CB}\u{21FE8}\u31C8\u{200CA}\u31C9\u31CA\u31CB\u31CC\u{2010E}\u31CD\u31CE\u0100\xC1\u01CD\xC0\u0112\xC9\u011A\xC8\u014C\xD3\u01D1\xD2\u0FFF\xCA\u0304\u1EBE\u0FFF\xCA\u030C\u1EC0\xCA\u0101\xE1\u01CE\xE0\u0251\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA"],
      ["88a1", "\u01DC\xFC\u0FFF\xEA\u0304\u1EBF\u0FFF\xEA\u030C\u1EC1\xEA\u0261\u23DA\u23DB"],
      ["8940", "\u{2A3A9}\u{21145}"],
      ["8943", "\u650A"],
      ["8946", "\u4E3D\u6EDD\u9D4E\u91DF"],
      ["894c", "\u{27735}\u6491\u4F1A\u4F28\u4FA8\u5156\u5174\u519C\u51E4\u52A1\u52A8\u533B\u534E\u53D1\u53D8\u56E2\u58F0\u5904\u5907\u5932\u5934\u5B66\u5B9E\u5B9F\u5C9A\u5E86\u603B\u6589\u67FE\u6804\u6865\u6D4E\u70BC\u7535\u7EA4\u7EAC\u7EBA\u7EC7\u7ECF\u7EDF\u7F06\u7F37\u827A\u82CF\u836F\u89C6\u8BBE\u8BE2\u8F66\u8F67\u8F6E"],
      ["89a1", "\u7411\u7CFC\u7DCD\u6946\u7AC9\u5227"],
      ["89ab", "\u918C\u78B8\u915E\u80BC"],
      ["89b0", "\u8D0B\u80F6\u{209E7}"],
      ["89b5", "\u809F\u9EC7\u4CCD\u9DC9\u9E0C\u4C3E\u{29DF6}\u{2700E}\u9E0A\u{2A133}\u35C1"],
      ["89c1", "\u6E9A\u823E\u7519"],
      ["89c5", "\u4911\u9A6C\u9A8F\u9F99\u7987\u{2846C}\u{21DCA}\u{205D0}\u{22AE6}\u4E24\u4E81\u4E80\u4E87\u4EBF\u4EEB\u4F37\u344C\u4FBD\u3E48\u5003\u5088\u347D\u3493\u34A5\u5186\u5905\u51DB\u51FC\u5205\u4E89\u5279\u5290\u5327\u35C7\u53A9\u3551\u53B0\u3553\u53C2\u5423\u356D\u3572\u3681\u5493\u54A3\u54B4\u54B9\u54D0\u54EF\u5518\u5523\u5528\u3598\u553F\u35A5\u35BF\u55D7\u35C5"],
      ["8a40", "\u{27D84}\u5525"],
      ["8a43", "\u{20C42}\u{20D15}\u{2512B}\u5590\u{22CC6}\u39EC\u{20341}\u8E46\u{24DB8}\u{294E5}\u4053\u{280BE}\u777A\u{22C38}\u3A34\u47D5\u{2815D}\u{269F2}\u{24DEA}\u64DD\u{20D7C}\u{20FB4}\u{20CD5}\u{210F4}\u648D\u8E7E\u{20E96}\u{20C0B}\u{20F64}\u{22CA9}\u{28256}\u{244D3}"],
      ["8a64", "\u{20D46}\u{29A4D}\u{280E9}\u47F4\u{24EA7}\u{22CC2}\u9AB2\u3A67\u{295F4}\u3FED\u3506\u{252C7}\u{297D4}\u{278C8}\u{22D44}\u9D6E\u9815"],
      ["8a76", "\u43D9\u{260A5}\u64B4\u54E3\u{22D4C}\u{22BCA}\u{21077}\u39FB\u{2106F}"],
      ["8aa1", "\u{266DA}\u{26716}\u{279A0}\u64EA\u{25052}\u{20C43}\u8E68\u{221A1}\u{28B4C}\u{20731}"],
      ["8aac", "\u480B\u{201A9}\u3FFA\u5873\u{22D8D}"],
      ["8ab2", "\u{245C8}\u{204FC}\u{26097}\u{20F4C}\u{20D96}\u5579\u40BB\u43BA"],
      ["8abb", "\u4AB4\u{22A66}\u{2109D}\u81AA\u98F5\u{20D9C}\u6379\u39FE\u{22775}\u8DC0\u56A1\u647C\u3E43"],
      ["8ac9", "\u{2A601}\u{20E09}\u{22ACF}\u{22CC9}"],
      ["8ace", "\u{210C8}\u{239C2}\u3992\u3A06\u{2829B}\u3578\u{25E49}\u{220C7}\u5652\u{20F31}\u{22CB2}\u{29720}\u34BC\u6C3D\u{24E3B}"],
      ["8adf", "\u{27574}\u{22E8B}\u{22208}\u{2A65B}\u{28CCD}\u{20E7A}\u{20C34}\u{2681C}\u7F93\u{210CF}\u{22803}\u{22939}\u35FB\u{251E3}\u{20E8C}\u{20F8D}\u{20EAA}\u3F93\u{20F30}\u{20D47}\u{2114F}\u{20E4C}"],
      ["8af6", "\u{20EAB}\u{20BA9}\u{20D48}\u{210C0}\u{2113D}\u3FF9\u{22696}\u6432\u{20FAD}"],
      ["8b40", "\u{233F4}\u{27639}\u{22BCE}\u{20D7E}\u{20D7F}\u{22C51}\u{22C55}\u3A18\u{20E98}\u{210C7}\u{20F2E}\u{2A632}\u{26B50}\u{28CD2}\u{28D99}\u{28CCA}\u95AA\u54CC\u82C4\u55B9"],
      ["8b55", "\u{29EC3}\u9C26\u9AB6\u{2775E}\u{22DEE}\u7140\u816D\u80EC\u5C1C\u{26572}\u8134\u3797\u535F\u{280BD}\u91B6\u{20EFA}\u{20E0F}\u{20E77}\u{20EFB}\u35DD\u{24DEB}\u3609\u{20CD6}\u56AF\u{227B5}\u{210C9}\u{20E10}\u{20E78}\u{21078}\u{21148}\u{28207}\u{21455}\u{20E79}\u{24E50}\u{22DA4}\u5A54\u{2101D}\u{2101E}\u{210F5}\u{210F6}\u579C\u{20E11}"],
      ["8ba1", "\u{27694}\u{282CD}\u{20FB5}\u{20E7B}\u{2517E}\u3703\u{20FB6}\u{21180}\u{252D8}\u{2A2BD}\u{249DA}\u{2183A}\u{24177}\u{2827C}\u5899\u5268\u361A\u{2573D}\u7BB2\u5B68\u4800\u4B2C\u9F27\u49E7\u9C1F\u9B8D\u{25B74}\u{2313D}\u55FB\u35F2\u5689\u4E28\u5902\u{21BC1}\u{2F878}\u9751\u{20086}\u4E5B\u4EBB\u353E\u5C23\u5F51\u5FC4\u38FA\u624C\u6535\u6B7A\u6C35\u6C3A\u706C\u722B\u4E2C\u72AD\u{248E9}\u7F52\u793B\u7CF9\u7F53\u{2626A}\u34C1"],
      ["8bde", "\u{2634B}\u8002\u8080\u{26612}\u{26951}\u535D\u8864\u89C1\u{278B2}\u8BA0\u8D1D\u9485\u9578\u957F\u95E8\u{28E0F}\u97E6\u9875\u98CE\u98DE\u9963\u{29810}\u9C7C\u9E1F\u9EC4\u6B6F\uF907\u4E37\u{20087}\u961D\u6237\u94A2"],
      ["8c40", "\u503B\u6DFE\u{29C73}\u9FA6\u3DC9\u888F\u{2414E}\u7077\u5CF5\u4B20\u{251CD}\u3559\u{25D30}\u6122\u{28A32}\u8FA7\u91F6\u7191\u6719\u73BA\u{23281}\u{2A107}\u3C8B\u{21980}\u4B10\u78E4\u7402\u51AE\u{2870F}\u4009\u6A63\u{2A2BA}\u4223\u860F\u{20A6F}\u7A2A\u{29947}\u{28AEA}\u9755\u704D\u5324\u{2207E}\u93F4\u76D9\u{289E3}\u9FA7\u77DD\u4EA3\u4FF0\u50BC\u4E2F\u4F17\u9FA8\u5434\u7D8B\u5892\u58D0\u{21DB6}\u5E92\u5E99\u5FC2\u{22712}\u658B"],
      ["8ca1", "\u{233F9}\u6919\u6A43\u{23C63}\u6CFF"],
      ["8ca7", "\u7200\u{24505}\u738C\u3EDB\u{24A13}\u5B15\u74B9\u8B83\u{25CA4}\u{25695}\u7A93\u7BEC\u7CC3\u7E6C\u82F8\u8597\u9FA9\u8890\u9FAA\u8EB9\u9FAB\u8FCF\u855F\u99E0\u9221\u9FAC\u{28DB9}\u{2143F}\u4071\u42A2\u5A1A"],
      ["8cc9", "\u9868\u676B\u4276\u573D"],
      ["8cce", "\u85D6\u{2497B}\u82BF\u{2710D}\u4C81\u{26D74}\u5D7B\u{26B15}\u{26FBE}\u9FAD\u9FAE\u5B96\u9FAF\u66E7\u7E5B\u6E57\u79CA\u3D88\u44C3\u{23256}\u{22796}\u439A\u4536"],
      ["8ce6", "\u5CD5\u{23B1A}\u8AF9\u5C78\u3D12\u{23551}\u5D78\u9FB2\u7157\u4558\u{240EC}\u{21E23}\u4C77\u3978\u344A\u{201A4}\u{26C41}\u8ACC\u4FB4\u{20239}\u59BF\u816C\u9856\u{298FA}\u5F3B"],
      ["8d40", "\u{20B9F}"],
      ["8d42", "\u{221C1}\u{2896D}\u4102\u46BB\u{29079}\u3F07\u9FB3\u{2A1B5}\u40F8\u37D6\u46F7\u{26C46}\u417C\u{286B2}\u{273FF}\u456D\u38D4\u{2549A}\u4561\u451B\u4D89\u4C7B\u4D76\u45EA\u3FC8\u{24B0F}\u3661\u44DE\u44BD\u41ED\u5D3E\u5D48\u5D56\u3DFC\u380F\u5DA4\u5DB9\u3820\u3838\u5E42\u5EBD\u5F25\u5F83\u3908\u3914\u393F\u394D\u60D7\u613D\u5CE5\u3989\u61B7\u61B9\u61CF\u39B8\u622C\u6290\u62E5\u6318\u39F8\u56B1"],
      ["8da1", "\u3A03\u63E2\u63FB\u6407\u645A\u3A4B\u64C0\u5D15\u5621\u9F9F\u3A97\u6586\u3ABD\u65FF\u6653\u3AF2\u6692\u3B22\u6716\u3B42\u67A4\u6800\u3B58\u684A\u6884\u3B72\u3B71\u3B7B\u6909\u6943\u725C\u6964\u699F\u6985\u3BBC\u69D6\u3BDD\u6A65\u6A74\u6A71\u6A82\u3BEC\u6A99\u3BF2\u6AAB\u6AB5\u6AD4\u6AF6\u6B81\u6BC1\u6BEA\u6C75\u6CAA\u3CCB\u6D02\u6D06\u6D26\u6D81\u3CEF\u6DA4\u6DB1\u6E15\u6E18\u6E29\u6E86\u{289C0}\u6EBB\u6EE2\u6EDA\u9F7F\u6EE8\u6EE9\u6F24\u6F34\u3D46\u{23F41}\u6F81\u6FBE\u3D6A\u3D75\u71B7\u5C99\u3D8A\u702C\u3D91\u7050\u7054\u706F\u707F\u7089\u{20325}\u43C1\u35F1\u{20ED8}"],
      ["8e40", "\u{23ED7}\u57BE\u{26ED3}\u713E\u{257E0}\u364E\u69A2\u{28BE9}\u5B74\u7A49\u{258E1}\u{294D9}\u7A65\u7A7D\u{259AC}\u7ABB\u7AB0\u7AC2\u7AC3\u71D1\u{2648D}\u41CA\u7ADA\u7ADD\u7AEA\u41EF\u54B2\u{25C01}\u7B0B\u7B55\u7B29\u{2530E}\u{25CFE}\u7BA2\u7B6F\u839C\u{25BB4}\u{26C7F}\u7BD0\u8421\u7B92\u7BB8\u{25D20}\u3DAD\u{25C65}\u8492\u7BFA\u7C06\u7C35\u{25CC1}\u7C44\u7C83\u{24882}\u7CA6\u667D\u{24578}\u7CC9\u7CC7\u7CE6\u7C74\u7CF3\u7CF5\u7CCE"],
      ["8ea1", "\u7E67\u451D\u{26E44}\u7D5D\u{26ED6}\u748D\u7D89\u7DAB\u7135\u7DB3\u7DD2\u{24057}\u{26029}\u7DE4\u3D13\u7DF5\u{217F9}\u7DE5\u{2836D}\u7E1D\u{26121}\u{2615A}\u7E6E\u7E92\u432B\u946C\u7E27\u7F40\u7F41\u7F47\u7936\u{262D0}\u99E1\u7F97\u{26351}\u7FA3\u{21661}\u{20068}\u455C\u{23766}\u4503\u{2833A}\u7FFA\u{26489}\u8005\u8008\u801D\u8028\u802F\u{2A087}\u{26CC3}\u803B\u803C\u8061\u{22714}\u4989\u{26626}\u{23DE3}\u{266E8}\u6725\u80A7\u{28A48}\u8107\u811A\u58B0\u{226F6}\u6C7F\u{26498}\u{24FB8}\u64E7\u{2148A}\u8218\u{2185E}\u6A53\u{24A65}\u{24A95}\u447A\u8229\u{20B0D}\u{26A52}\u{23D7E}\u4FF9\u{214FD}\u84E2\u8362\u{26B0A}\u{249A7}\u{23530}\u{21773}\u{23DF8}\u82AA\u691B\u{2F994}\u41DB"],
      ["8f40", "\u854B\u82D0\u831A\u{20E16}\u{217B4}\u36C1\u{2317D}\u{2355A}\u827B\u82E2\u8318\u{23E8B}\u{26DA3}\u{26B05}\u{26B97}\u{235CE}\u3DBF\u831D\u55EC\u8385\u450B\u{26DA5}\u83AC\u83C1\u83D3\u347E\u{26ED4}\u6A57\u855A\u3496\u{26E42}\u{22EEF}\u8458\u{25BE4}\u8471\u3DD3\u44E4\u6AA7\u844A\u{23CB5}\u7958\u84A8\u{26B96}\u{26E77}\u{26E43}\u84DE\u840F\u8391\u44A0\u8493\u84E4\u{25C91}\u4240\u{25CC0}\u4543\u8534\u5AF2\u{26E99}\u4527\u8573\u4516\u67BF\u8616"],
      ["8fa1", "\u{28625}\u{2863B}\u85C1\u{27088}\u8602\u{21582}\u{270CD}\u{2F9B2}\u456A\u8628\u3648\u{218A2}\u53F7\u{2739A}\u867E\u8771\u{2A0F8}\u87EE\u{22C27}\u87B1\u87DA\u880F\u5661\u866C\u6856\u460F\u8845\u8846\u{275E0}\u{23DB9}\u{275E4}\u885E\u889C\u465B\u88B4\u88B5\u63C1\u88C5\u7777\u{2770F}\u8987\u898A\u89A6\u89A9\u89A7\u89BC\u{28A25}\u89E7\u{27924}\u{27ABD}\u8A9C\u7793\u91FE\u8A90\u{27A59}\u7AE9\u{27B3A}\u{23F8F}\u4713\u{27B38}\u717C\u8B0C\u8B1F\u{25430}\u{25565}\u8B3F\u8B4C\u8B4D\u8AA9\u{24A7A}\u8B90\u8B9B\u8AAF\u{216DF}\u4615\u884F\u8C9B\u{27D54}\u{27D8F}\u{2F9D4}\u3725\u{27D53}\u8CD6\u{27D98}\u{27DBD}\u8D12\u8D03\u{21910}\u8CDB\u705C\u8D11\u{24CC9}\u3ED0\u8D77"],
      ["9040", "\u8DA9\u{28002}\u{21014}\u{2498A}\u3B7C\u{281BC}\u{2710C}\u7AE7\u8EAD\u8EB6\u8EC3\u92D4\u8F19\u8F2D\u{28365}\u{28412}\u8FA5\u9303\u{2A29F}\u{20A50}\u8FB3\u492A\u{289DE}\u{2853D}\u{23DBB}\u5EF8\u{23262}\u8FF9\u{2A014}\u{286BC}\u{28501}\u{22325}\u3980\u{26ED7}\u9037\u{2853C}\u{27ABE}\u9061\u{2856C}\u{2860B}\u90A8\u{28713}\u90C4\u{286E6}\u90AE\u90FD\u9167\u3AF0\u91A9\u91C4\u7CAC\u{28933}\u{21E89}\u920E\u6C9F\u9241\u9262\u{255B9}\u92B9\u{28AC6}\u{23C9B}\u{28B0C}\u{255DB}"],
      ["90a1", "\u{20D31}\u932C\u936B\u{28AE1}\u{28BEB}\u708F\u5AC3\u{28AE2}\u{28AE5}\u4965\u9244\u{28BEC}\u{28C39}\u{28BFF}\u9373\u945B\u8EBC\u9585\u95A6\u9426\u95A0\u6FF6\u42B9\u{2267A}\u{286D8}\u{2127C}\u{23E2E}\u49DF\u6C1C\u967B\u9696\u416C\u96A3\u{26ED5}\u61DA\u96B6\u78F5\u{28AE0}\u96BD\u53CC\u49A1\u{26CB8}\u{20274}\u{26410}\u{290AF}\u{290E5}\u{24AD1}\u{21915}\u{2330A}\u9731\u8642\u9736\u4A0F\u453D\u4585\u{24AE9}\u7075\u5B41\u971B\u975C\u{291D5}\u9757\u5B4A\u{291EB}\u975F\u9425\u50D0\u{230B7}\u{230BC}\u9789\u979F\u97B1\u97BE\u97C0\u97D2\u97E0\u{2546C}\u97EE\u741C\u{29433}\u97FF\u97F5\u{2941D}\u{2797A}\u4AD1\u9834\u9833\u984B\u9866\u3B0E\u{27175}\u3D51\u{20630}\u{2415C}"],
      ["9140", "\u{25706}\u98CA\u98B7\u98C8\u98C7\u4AFF\u{26D27}\u{216D3}\u55B0\u98E1\u98E6\u98EC\u9378\u9939\u{24A29}\u4B72\u{29857}\u{29905}\u99F5\u9A0C\u9A3B\u9A10\u9A58\u{25725}\u36C4\u{290B1}\u{29BD5}\u9AE0\u9AE2\u{29B05}\u9AF4\u4C0E\u9B14\u9B2D\u{28600}\u5034\u9B34\u{269A8}\u38C3\u{2307D}\u9B50\u9B40\u{29D3E}\u5A45\u{21863}\u9B8E\u{2424B}\u9C02\u9BFF\u9C0C\u{29E68}\u9DD4\u{29FB7}\u{2A192}\u{2A1AB}\u{2A0E1}\u{2A123}\u{2A1DF}\u9D7E\u9D83\u{2A134}\u9E0E\u6888"],
      ["91a1", "\u9DC4\u{2215B}\u{2A193}\u{2A220}\u{2193B}\u{2A233}\u9D39\u{2A0B9}\u{2A2B4}\u9E90\u9E95\u9E9E\u9EA2\u4D34\u9EAA\u9EAF\u{24364}\u9EC1\u3B60\u39E5\u3D1D\u4F32\u37BE\u{28C2B}\u9F02\u9F08\u4B96\u9424\u{26DA2}\u9F17\u9F16\u9F39\u569F\u568A\u9F45\u99B8\u{2908B}\u97F2\u847F\u9F62\u9F69\u7ADC\u9F8E\u7216\u4BBE\u{24975}\u{249BB}\u7177\u{249F8}\u{24348}\u{24A51}\u739E\u{28BDA}\u{218FA}\u799F\u{2897E}\u{28E36}\u9369\u93F3\u{28A44}\u92EC\u9381\u93CB\u{2896C}\u{244B9}\u7217\u3EEB\u7772\u7A43\u70D0\u{24473}\u{243F8}\u717E\u{217EF}\u70A3\u{218BE}\u{23599}\u3EC7\u{21885}\u{2542F}\u{217F8}\u3722\u{216FB}\u{21839}\u36E1\u{21774}\u{218D1}\u{25F4B}\u3723\u{216C0}\u575B\u{24A25}\u{213FE}\u{212A8}"],
      ["9240", "\u{213C6}\u{214B6}\u8503\u{236A6}\u8503\u8455\u{24994}\u{27165}\u{23E31}\u{2555C}\u{23EFB}\u{27052}\u44F4\u{236EE}\u{2999D}\u{26F26}\u67F9\u3733\u3C15\u3DE7\u586C\u{21922}\u6810\u4057\u{2373F}\u{240E1}\u{2408B}\u{2410F}\u{26C21}\u54CB\u569E\u{266B1}\u5692\u{20FDF}\u{20BA8}\u{20E0D}\u93C6\u{28B13}\u939C\u4EF8\u512B\u3819\u{24436}\u4EBC\u{20465}\u{2037F}\u4F4B\u4F8A\u{25651}\u5A68\u{201AB}\u{203CB}\u3999\u{2030A}\u{20414}\u3435\u4F29\u{202C0}\u{28EB3}\u{20275}\u8ADA\u{2020C}\u4E98"],
      ["92a1", "\u50CD\u510D\u4FA2\u4F03\u{24A0E}\u{23E8A}\u4F42\u502E\u506C\u5081\u4FCC\u4FE5\u5058\u50FC\u5159\u515B\u515D\u515E\u6E76\u{23595}\u{23E39}\u{23EBF}\u6D72\u{21884}\u{23E89}\u51A8\u51C3\u{205E0}\u44DD\u{204A3}\u{20492}\u{20491}\u8D7A\u{28A9C}\u{2070E}\u5259\u52A4\u{20873}\u52E1\u936E\u467A\u718C\u{2438C}\u{20C20}\u{249AC}\u{210E4}\u69D1\u{20E1D}\u7479\u3EDE\u7499\u7414\u7456\u7398\u4B8E\u{24ABC}\u{2408D}\u53D0\u3584\u720F\u{240C9}\u55B4\u{20345}\u54CD\u{20BC6}\u571D\u925D\u96F4\u9366\u57DD\u578D\u577F\u363E\u58CB\u5A99\u{28A46}\u{216FA}\u{2176F}\u{21710}\u5A2C\u59B8\u928F\u5A7E\u5ACF\u5A12\u{25946}\u{219F3}\u{21861}\u{24295}\u36F5\u6D05\u7443\u5A21\u{25E83}"],
      ["9340", "\u5A81\u{28BD7}\u{20413}\u93E0\u748C\u{21303}\u7105\u4972\u9408\u{289FB}\u93BD\u37A0\u5C1E\u5C9E\u5E5E\u5E48\u{21996}\u{2197C}\u{23AEE}\u5ECD\u5B4F\u{21903}\u{21904}\u3701\u{218A0}\u36DD\u{216FE}\u36D3\u812A\u{28A47}\u{21DBA}\u{23472}\u{289A8}\u5F0C\u5F0E\u{21927}\u{217AB}\u5A6B\u{2173B}\u5B44\u8614\u{275FD}\u8860\u607E\u{22860}\u{2262B}\u5FDB\u3EB8\u{225AF}\u{225BE}\u{29088}\u{26F73}\u61C0\u{2003E}\u{20046}\u{2261B}\u6199\u6198\u6075\u{22C9B}\u{22D07}\u{246D4}\u{2914D}"],
      ["93a1", "\u6471\u{24665}\u{22B6A}\u3A29\u{22B22}\u{23450}\u{298EA}\u{22E78}\u6337\u{2A45B}\u64B6\u6331\u63D1\u{249E3}\u{22D67}\u62A4\u{22CA1}\u643B\u656B\u6972\u3BF4\u{2308E}\u{232AD}\u{24989}\u{232AB}\u550D\u{232E0}\u{218D9}\u{2943F}\u66CE\u{23289}\u{231B3}\u3AE0\u4190\u{25584}\u{28B22}\u{2558F}\u{216FC}\u{2555B}\u{25425}\u78EE\u{23103}\u{2182A}\u{23234}\u3464\u{2320F}\u{23182}\u{242C9}\u668E\u{26D24}\u666B\u4B93\u6630\u{27870}\u{21DEB}\u6663\u{232D2}\u{232E1}\u661E\u{25872}\u38D1\u{2383A}\u{237BC}\u3B99\u{237A2}\u{233FE}\u74D0\u3B96\u678F\u{2462A}\u68B6\u681E\u3BC4\u6ABE\u3863\u{237D5}\u{24487}\u6A33\u6A52\u6AC9\u6B05\u{21912}\u6511\u6898\u6A4C\u3BD7\u6A7A\u6B57\u{23FC0}\u{23C9A}\u93A0\u92F2\u{28BEA}\u{28ACB}"],
      ["9440", "\u9289\u{2801E}\u{289DC}\u9467\u6DA5\u6F0B\u{249EC}\u6D67\u{23F7F}\u3D8F\u6E04\u{2403C}\u5A3D\u6E0A\u5847\u6D24\u7842\u713B\u{2431A}\u{24276}\u70F1\u7250\u7287\u7294\u{2478F}\u{24725}\u5179\u{24AA4}\u{205EB}\u747A\u{23EF8}\u{2365F}\u{24A4A}\u{24917}\u{25FE1}\u3F06\u3EB1\u{24ADF}\u{28C23}\u{23F35}\u60A7\u3EF3\u74CC\u743C\u9387\u7437\u449F\u{26DEA}\u4551\u7583\u3F63\u{24CD9}\u{24D06}\u3F58\u7555\u7673\u{2A5C6}\u3B19\u7468\u{28ACC}\u{249AB}\u{2498E}\u3AFB"],
      ["94a1", "\u3DCD\u{24A4E}\u3EFF\u{249C5}\u{248F3}\u91FA\u5732\u9342\u{28AE3}\u{21864}\u50DF\u{25221}\u{251E7}\u7778\u{23232}\u770E\u770F\u777B\u{24697}\u{23781}\u3A5E\u{248F0}\u7438\u749B\u3EBF\u{24ABA}\u{24AC7}\u40C8\u{24A96}\u{261AE}\u9307\u{25581}\u781E\u788D\u7888\u78D2\u73D0\u7959\u{27741}\u{256E3}\u410E\u799B\u8496\u79A5\u6A2D\u{23EFA}\u7A3A\u79F4\u416E\u{216E6}\u4132\u9235\u79F1\u{20D4C}\u{2498C}\u{20299}\u{23DBA}\u{2176E}\u3597\u556B\u3570\u36AA\u{201D4}\u{20C0D}\u7AE2\u5A59\u{226F5}\u{25AAF}\u{25A9C}\u5A0D\u{2025B}\u78F0\u5A2A\u{25BC6}\u7AFE\u41F9\u7C5D\u7C6D\u4211\u{25BB3}\u{25EBC}\u{25EA6}\u7CCD\u{249F9}\u{217B0}\u7C8E\u7C7C\u7CAE\u6AB2\u7DDC\u7E07\u7DD3\u7F4E\u{26261}"],
      ["9540", "\u{2615C}\u{27B48}\u7D97\u{25E82}\u426A\u{26B75}\u{20916}\u67D6\u{2004E}\u{235CF}\u57C4\u{26412}\u{263F8}\u{24962}\u7FDD\u7B27\u{2082C}\u{25AE9}\u{25D43}\u7B0C\u{25E0E}\u99E6\u8645\u9A63\u6A1C\u{2343F}\u39E2\u{249F7}\u{265AD}\u9A1F\u{265A0}\u8480\u{27127}\u{26CD1}\u44EA\u8137\u4402\u80C6\u8109\u8142\u{267B4}\u98C3\u{26A42}\u8262\u8265\u{26A51}\u8453\u{26DA7}\u8610\u{2721B}\u5A86\u417F\u{21840}\u5B2B\u{218A1}\u5AE4\u{218D8}\u86A0\u{2F9BC}\u{23D8F}\u882D\u{27422}\u5A02"],
      ["95a1", "\u886E\u4F45\u8887\u88BF\u88E6\u8965\u894D\u{25683}\u8954\u{27785}\u{27784}\u{28BF5}\u{28BD9}\u{28B9C}\u{289F9}\u3EAD\u84A3\u46F5\u46CF\u37F2\u8A3D\u8A1C\u{29448}\u5F4D\u922B\u{24284}\u65D4\u7129\u70C4\u{21845}\u9D6D\u8C9F\u8CE9\u{27DDC}\u599A\u77C3\u59F0\u436E\u36D4\u8E2A\u8EA7\u{24C09}\u8F30\u8F4A\u42F4\u6C58\u6FBB\u{22321}\u489B\u6F79\u6E8B\u{217DA}\u9BE9\u36B5\u{2492F}\u90BB\u9097\u5571\u4906\u91BB\u9404\u{28A4B}\u4062\u{28AFC}\u9427\u{28C1D}\u{28C3B}\u84E5\u8A2B\u9599\u95A7\u9597\u9596\u{28D34}\u7445\u3EC2\u{248FF}\u{24A42}\u{243EA}\u3EE7\u{23225}\u968F\u{28EE7}\u{28E66}\u{28E65}\u3ECC\u{249ED}\u{24A78}\u{23FEE}\u7412\u746B\u3EFC\u9741\u{290B0}"],
      ["9640", "\u6847\u4A1D\u{29093}\u{257DF}\u975D\u9368\u{28989}\u{28C26}\u{28B2F}\u{263BE}\u92BA\u5B11\u8B69\u493C\u73F9\u{2421B}\u979B\u9771\u9938\u{20F26}\u5DC1\u{28BC5}\u{24AB2}\u981F\u{294DA}\u92F6\u{295D7}\u91E5\u44C0\u{28B50}\u{24A67}\u{28B64}\u98DC\u{28A45}\u3F00\u922A\u4925\u8414\u993B\u994D\u{27B06}\u3DFD\u999B\u4B6F\u99AA\u9A5C\u{28B65}\u{258C8}\u6A8F\u9A21\u5AFE\u9A2F\u{298F1}\u4B90\u{29948}\u99BC\u4BBD\u4B97\u937D\u5872\u{21302}\u5822\u{249B8}"],
      ["96a1", "\u{214E8}\u7844\u{2271F}\u{23DB8}\u68C5\u3D7D\u9458\u3927\u6150\u{22781}\u{2296B}\u6107\u9C4F\u9C53\u9C7B\u9C35\u9C10\u9B7F\u9BCF\u{29E2D}\u9B9F\u{2A1F5}\u{2A0FE}\u9D21\u4CAE\u{24104}\u9E18\u4CB0\u9D0C\u{2A1B4}\u{2A0ED}\u{2A0F3}\u{2992F}\u9DA5\u84BD\u{26E12}\u{26FDF}\u{26B82}\u85FC\u4533\u{26DA4}\u{26E84}\u{26DF0}\u8420\u85EE\u{26E00}\u{237D7}\u{26064}\u79E2\u{2359C}\u{23640}\u492D\u{249DE}\u3D62\u93DB\u92BE\u9348\u{202BF}\u78B9\u9277\u944D\u4FE4\u3440\u9064\u{2555D}\u783D\u7854\u78B6\u784B\u{21757}\u{231C9}\u{24941}\u369A\u4F72\u6FDA\u6FD9\u701E\u701E\u5414\u{241B5}\u57BB\u58F3\u578A\u9D16\u57D7\u7134\u34AF\u{241AC}\u71EB\u{26C40}\u{24F97}\u5B28\u{217B5}\u{28A49}"],
      ["9740", "\u610C\u5ACE\u5A0B\u42BC\u{24488}\u372C\u4B7B\u{289FC}\u93BB\u93B8\u{218D6}\u{20F1D}\u8472\u{26CC0}\u{21413}\u{242FA}\u{22C26}\u{243C1}\u5994\u{23DB7}\u{26741}\u7DA8\u{2615B}\u{260A4}\u{249B9}\u{2498B}\u{289FA}\u92E5\u73E2\u3EE9\u74B4\u{28B63}\u{2189F}\u3EE1\u{24AB3}\u6AD8\u73F3\u73FB\u3ED6\u{24A3E}\u{24A94}\u{217D9}\u{24A66}\u{203A7}\u{21424}\u{249E5}\u7448\u{24916}\u70A5\u{24976}\u9284\u73E6\u935F\u{204FE}\u9331\u{28ACE}\u{28A16}\u9386\u{28BE7}\u{255D5}\u4935\u{28A82}\u716B"],
      ["97a1", "\u{24943}\u{20CFF}\u56A4\u{2061A}\u{20BEB}\u{20CB8}\u5502\u79C4\u{217FA}\u7DFE\u{216C2}\u{24A50}\u{21852}\u452E\u9401\u370A\u{28AC0}\u{249AD}\u59B0\u{218BF}\u{21883}\u{27484}\u5AA1\u36E2\u{23D5B}\u36B0\u925F\u5A79\u{28A81}\u{21862}\u9374\u3CCD\u{20AB4}\u4A96\u398A\u50F4\u3D69\u3D4C\u{2139C}\u7175\u42FB\u{28218}\u6E0F\u{290E4}\u44EB\u6D57\u{27E4F}\u7067\u6CAF\u3CD6\u{23FED}\u{23E2D}\u6E02\u6F0C\u3D6F\u{203F5}\u7551\u36BC\u34C8\u4680\u3EDA\u4871\u59C4\u926E\u493E\u8F41\u{28C1C}\u{26BC0}\u5812\u57C8\u36D6\u{21452}\u70FE\u{24362}\u{24A71}\u{22FE3}\u{212B0}\u{223BD}\u68B9\u6967\u{21398}\u{234E5}\u{27BF4}\u{236DF}\u{28A83}\u{237D6}\u{233FA}\u{24C9F}\u6A1A\u{236AD}\u{26CB7}\u843E\u44DF\u44CE"],
      ["9840", "\u{26D26}\u{26D51}\u{26C82}\u{26FDE}\u6F17\u{27109}\u833D\u{2173A}\u83ED\u{26C80}\u{27053}\u{217DB}\u5989\u5A82\u{217B3}\u5A61\u5A71\u{21905}\u{241FC}\u372D\u59EF\u{2173C}\u36C7\u718E\u9390\u669A\u{242A5}\u5A6E\u5A2B\u{24293}\u6A2B\u{23EF9}\u{27736}\u{2445B}\u{242CA}\u711D\u{24259}\u{289E1}\u4FB0\u{26D28}\u5CC2\u{244CE}\u{27E4D}\u{243BD}\u6A0C\u{24256}\u{21304}\u70A6\u7133\u{243E9}\u3DA5\u6CDF\u{2F825}\u{24A4F}\u7E65\u59EB\u5D2F\u3DF3\u5F5C\u{24A5D}\u{217DF}\u7DA4\u8426"],
      ["98a1", "\u5485\u{23AFA}\u{23300}\u{20214}\u577E\u{208D5}\u{20619}\u3FE5\u{21F9E}\u{2A2B6}\u7003\u{2915B}\u5D70\u738F\u7CD3\u{28A59}\u{29420}\u4FC8\u7FE7\u72CD\u7310\u{27AF4}\u7338\u7339\u{256F6}\u7341\u7348\u3EA9\u{27B18}\u906C\u71F5\u{248F2}\u73E1\u81F6\u3ECA\u770C\u3ED1\u6CA2\u56FD\u7419\u741E\u741F\u3EE2\u3EF0\u3EF4\u3EFA\u74D3\u3F0E\u3F53\u7542\u756D\u7572\u758D\u3F7C\u75C8\u75DC\u3FC0\u764D\u3FD7\u7674\u3FDC\u767A\u{24F5C}\u7188\u5623\u8980\u5869\u401D\u7743\u4039\u6761\u4045\u35DB\u7798\u406A\u406F\u5C5E\u77BE\u77CB\u58F2\u7818\u70B9\u781C\u40A8\u7839\u7847\u7851\u7866\u8448\u{25535}\u7933\u6803\u7932\u4103"],
      ["9940", "\u4109\u7991\u7999\u8FBB\u7A06\u8FBC\u4167\u7A91\u41B2\u7ABC\u8279\u41C4\u7ACF\u7ADB\u41CF\u4E21\u7B62\u7B6C\u7B7B\u7C12\u7C1B\u4260\u427A\u7C7B\u7C9C\u428C\u7CB8\u4294\u7CED\u8F93\u70C0\u{20CCF}\u7DCF\u7DD4\u7DD0\u7DFD\u7FAE\u7FB4\u729F\u4397\u8020\u8025\u7B39\u802E\u8031\u8054\u3DCC\u57B4\u70A0\u80B7\u80E9\u43ED\u810C\u732A\u810E\u8112\u7560\u8114\u4401\u3B39\u8156\u8159\u815A"],
      ["99a1", "\u4413\u583A\u817C\u8184\u4425\u8193\u442D\u81A5\u57EF\u81C1\u81E4\u8254\u448F\u82A6\u8276\u82CA\u82D8\u82FF\u44B0\u8357\u9669\u698A\u8405\u70F5\u8464\u60E3\u8488\u4504\u84BE\u84E1\u84F8\u8510\u8538\u8552\u453B\u856F\u8570\u85E0\u4577\u8672\u8692\u86B2\u86EF\u9645\u878B\u4606\u4617\u88AE\u88FF\u8924\u8947\u8991\u{27967}\u8A29\u8A38\u8A94\u8AB4\u8C51\u8CD4\u8CF2\u8D1C\u4798\u585F\u8DC3\u47ED\u4EEE\u8E3A\u55D8\u5754\u8E71\u55F5\u8EB0\u4837\u8ECE\u8EE2\u8EE4\u8EED\u8EF2\u8FB7\u8FC1\u8FCA\u8FCC\u9033\u99C4\u48AD\u98E0\u9213\u491E\u9228\u9258\u926B\u92B1\u92AE\u92BF"],
      ["9a40", "\u92E3\u92EB\u92F3\u92F4\u92FD\u9343\u9384\u93AD\u4945\u4951\u9EBF\u9417\u5301\u941D\u942D\u943E\u496A\u9454\u9479\u952D\u95A2\u49A7\u95F4\u9633\u49E5\u67A0\u4A24\u9740\u4A35\u97B2\u97C2\u5654\u4AE4\u60E8\u98B9\u4B19\u98F1\u5844\u990E\u9919\u51B4\u991C\u9937\u9942\u995D\u9962\u4B70\u99C5\u4B9D\u9A3C\u9B0F\u7A83\u9B69\u9B81\u9BDD\u9BF1\u9BF4\u4C6D\u9C20\u376F\u{21BC2}\u9D49\u9C3A"],
      ["9aa1", "\u9EFE\u5650\u9D93\u9DBD\u9DC0\u9DFC\u94F6\u8FB6\u9E7B\u9EAC\u9EB1\u9EBD\u9EC6\u94DC\u9EE2\u9EF1\u9EF8\u7AC8\u9F44\u{20094}\u{202B7}\u{203A0}\u691A\u94C3\u59AC\u{204D7}\u5840\u94C1\u37B9\u{205D5}\u{20615}\u{20676}\u{216BA}\u5757\u7173\u{20AC2}\u{20ACD}\u{20BBF}\u546A\u{2F83B}\u{20BCB}\u549E\u{20BFB}\u{20C3B}\u{20C53}\u{20C65}\u{20C7C}\u60E7\u{20C8D}\u567A\u{20CB5}\u{20CDD}\u{20CED}\u{20D6F}\u{20DB2}\u{20DC8}\u6955\u9C2F\u87A5\u{20E04}\u{20E0E}\u{20ED7}\u{20F90}\u{20F2D}\u{20E73}\u5C20\u{20FBC}\u5E0B\u{2105C}\u{2104F}\u{21076}\u671E\u{2107B}\u{21088}\u{21096}\u3647\u{210BF}\u{210D3}\u{2112F}\u{2113B}\u5364\u84AD\u{212E3}\u{21375}\u{21336}\u8B81\u{21577}\u{21619}\u{217C3}\u{217C7}\u4E78\u70BB\u{2182D}\u{2196A}"],
      ["9b40", "\u{21A2D}\u{21A45}\u{21C2A}\u{21C70}\u{21CAC}\u{21EC8}\u62C3\u{21ED5}\u{21F15}\u7198\u6855\u{22045}\u69E9\u36C8\u{2227C}\u{223D7}\u{223FA}\u{2272A}\u{22871}\u{2294F}\u82FD\u{22967}\u{22993}\u{22AD5}\u89A5\u{22AE8}\u8FA0\u{22B0E}\u97B8\u{22B3F}\u9847\u9ABD\u{22C4C}"],
      ["9b62", "\u{22C88}\u{22CB7}\u{25BE8}\u{22D08}\u{22D12}\u{22DB7}\u{22D95}\u{22E42}\u{22F74}\u{22FCC}\u{23033}\u{23066}\u{2331F}\u{233DE}\u5FB1\u6648\u66BF\u{27A79}\u{23567}\u{235F3}\u7201\u{249BA}\u77D7\u{2361A}\u{23716}\u7E87\u{20346}\u58B5\u670E"],
      ["9ba1", "\u6918\u{23AA7}\u{27657}\u{25FE2}\u{23E11}\u{23EB9}\u{275FE}\u{2209A}\u48D0\u4AB8\u{24119}\u{28A9A}\u{242EE}\u{2430D}\u{2403B}\u{24334}\u{24396}\u{24A45}\u{205CA}\u51D2\u{20611}\u599F\u{21EA8}\u3BBE\u{23CFF}\u{24404}\u{244D6}\u5788\u{24674}\u399B\u{2472F}\u{285E8}\u{299C9}\u3762\u{221C3}\u8B5E\u{28B4E}\u99D6\u{24812}\u{248FB}\u{24A15}\u7209\u{24AC0}\u{20C78}\u5965\u{24EA5}\u{24F86}\u{20779}\u8EDA\u{2502C}\u528F\u573F\u7171\u{25299}\u{25419}\u{23F4A}\u{24AA7}\u55BC\u{25446}\u{2546E}\u{26B52}\u91D4\u3473\u{2553F}\u{27632}\u{2555E}\u4718\u{25562}\u{25566}\u{257C7}\u{2493F}\u{2585D}\u5066\u34FB\u{233CC}\u60DE\u{25903}\u477C\u{28948}\u{25AAE}\u{25B89}\u{25C06}\u{21D90}\u57A1\u7151\u6FB6\u{26102}\u{27C12}\u9056\u{261B2}\u{24F9A}\u8B62\u{26402}\u{2644A}"],
      ["9c40", "\u5D5B\u{26BF7}\u8F36\u{26484}\u{2191C}\u8AEA\u{249F6}\u{26488}\u{23FEF}\u{26512}\u4BC0\u{265BF}\u{266B5}\u{2271B}\u9465\u{257E1}\u6195\u5A27\u{2F8CD}\u4FBB\u56B9\u{24521}\u{266FC}\u4E6A\u{24934}\u9656\u6D8F\u{26CBD}\u3618\u8977\u{26799}\u{2686E}\u{26411}\u{2685E}\u71DF\u{268C7}\u7B42\u{290C0}\u{20A11}\u{26926}\u9104\u{26939}\u7A45\u9DF0\u{269FA}\u9A26\u{26A2D}\u365F\u{26469}\u{20021}\u7983\u{26A34}\u{26B5B}\u5D2C\u{23519}\u83CF\u{26B9D}\u46D0\u{26CA4}\u753B\u8865\u{26DAE}\u58B6"],
      ["9ca1", "\u371C\u{2258D}\u{2704B}\u{271CD}\u3C54\u{27280}\u{27285}\u9281\u{2217A}\u{2728B}\u9330\u{272E6}\u{249D0}\u6C39\u949F\u{27450}\u{20EF8}\u8827\u88F5\u{22926}\u{28473}\u{217B1}\u6EB8\u{24A2A}\u{21820}\u39A4\u36B9\u5C10\u79E3\u453F\u66B6\u{29CAD}\u{298A4}\u8943\u{277CC}\u{27858}\u56D6\u40DF\u{2160A}\u39A1\u{2372F}\u{280E8}\u{213C5}\u71AD\u8366\u{279DD}\u{291A8}\u5A67\u4CB7\u{270AF}\u{289AB}\u{279FD}\u{27A0A}\u{27B0B}\u{27D66}\u{2417A}\u7B43\u797E\u{28009}\u6FB5\u{2A2DF}\u6A03\u{28318}\u53A2\u{26E07}\u93BF\u6836\u975D\u{2816F}\u{28023}\u{269B5}\u{213ED}\u{2322F}\u{28048}\u5D85\u{28C30}\u{28083}\u5715\u9823\u{28949}\u5DAB\u{24988}\u65BE\u69D5\u53D2\u{24AA5}\u{23F81}\u3C11\u6736\u{28090}\u{280F4}\u{2812E}\u{21FA1}\u{2814F}"],
      ["9d40", "\u{28189}\u{281AF}\u{2821A}\u{28306}\u{2832F}\u{2838A}\u35CA\u{28468}\u{286AA}\u48FA\u63E6\u{28956}\u7808\u9255\u{289B8}\u43F2\u{289E7}\u43DF\u{289E8}\u{28B46}\u{28BD4}\u59F8\u{28C09}\u8F0B\u{28FC5}\u{290EC}\u7B51\u{29110}\u{2913C}\u3DF7\u{2915E}\u{24ACA}\u8FD0\u728F\u568B\u{294E7}\u{295E9}\u{295B0}\u{295B8}\u{29732}\u{298D1}\u{29949}\u{2996A}\u{299C3}\u{29A28}\u{29B0E}\u{29D5A}\u{29D9B}\u7E9F\u{29EF8}\u{29F23}\u4CA4\u9547\u{2A293}\u71A2\u{2A2FF}\u4D91\u9012\u{2A5CB}\u4D9C\u{20C9C}\u8FBE\u55C1"],
      ["9da1", "\u8FBA\u{224B0}\u8FB9\u{24A93}\u4509\u7E7F\u6F56\u6AB1\u4EEA\u34E4\u{28B2C}\u{2789D}\u373A\u8E80\u{217F5}\u{28024}\u{28B6C}\u{28B99}\u{27A3E}\u{266AF}\u3DEB\u{27655}\u{23CB7}\u{25635}\u{25956}\u4E9A\u{25E81}\u{26258}\u56BF\u{20E6D}\u8E0E\u5B6D\u{23E88}\u{24C9E}\u63DE\u62D0\u{217F6}\u{2187B}\u6530\u562D\u{25C4A}\u541A\u{25311}\u3DC6\u{29D98}\u4C7D\u5622\u561E\u7F49\u{25ED8}\u5975\u{23D40}\u8770\u4E1C\u{20FEA}\u{20D49}\u{236BA}\u8117\u9D5E\u8D18\u763B\u9C45\u764E\u77B9\u9345\u5432\u8148\u82F7\u5625\u8132\u8418\u80BD\u55EA\u7962\u5643\u5416\u{20E9D}\u35CE\u5605\u55F1\u66F1\u{282E2}\u362D\u7534\u55F0\u55BA\u5497\u5572\u{20C41}\u{20C96}\u5ED0\u{25148}\u{20E76}\u{22C62}"],
      ["9e40", "\u{20EA2}\u9EAB\u7D5A\u55DE\u{21075}\u629D\u976D\u5494\u8CCD\u71F6\u9176\u63FC\u63B9\u63FE\u5569\u{22B43}\u9C72\u{22EB3}\u519A\u34DF\u{20DA7}\u51A7\u544D\u551E\u5513\u7666\u8E2D\u{2688A}\u75B1\u80B6\u8804\u8786\u88C7\u81B6\u841C\u{210C1}\u44EC\u7304\u{24706}\u5B90\u830B\u{26893}\u567B\u{226F4}\u{27D2F}\u{241A3}\u{27D73}\u{26ED0}\u{272B6}\u9170\u{211D9}\u9208\u{23CFC}\u{2A6A9}\u{20EAC}\u{20EF9}\u7266\u{21CA2}\u474E\u{24FC2}\u{27FF9}\u{20FEB}\u40FA"],
      ["9ea1", "\u9C5D\u651F\u{22DA0}\u48F3\u{247E0}\u{29D7C}\u{20FEC}\u{20E0A}\u6062\u{275A3}\u{20FED}"],
      ["9ead", "\u{26048}\u{21187}\u71A3\u7E8E\u9D50\u4E1A\u4E04\u3577\u5B0D\u6CB2\u5367\u36AC\u39DC\u537D\u36A5\u{24618}\u589A\u{24B6E}\u822D\u544B\u57AA\u{25A95}\u{20979}"],
      ["9ec5", "\u3A52\u{22465}\u7374\u{29EAC}\u4D09\u9BED\u{23CFE}\u{29F30}\u4C5B\u{24FA9}\u{2959E}\u{29FDE}\u845C\u{23DB6}\u{272B2}\u{267B3}\u{23720}\u632E\u7D25\u{23EF7}\u{23E2C}\u3A2A\u9008\u52CC\u3E74\u367A\u45E9\u{2048E}\u7640\u5AF0\u{20EB6}\u787A\u{27F2E}\u58A7\u40BF\u567C\u9B8B\u5D74\u7654\u{2A434}\u9E85\u4CE1\u75F9\u37FB\u6119\u{230DA}\u{243F2}"],
      ["9ef5", "\u565D\u{212A9}\u57A7\u{24963}\u{29E06}\u5234\u{270AE}\u35AD\u6C4A\u9D7C"],
      ["9f40", "\u7C56\u9B39\u57DE\u{2176C}\u5C53\u64D3\u{294D0}\u{26335}\u{27164}\u86AD\u{20D28}\u{26D22}\u{24AE2}\u{20D71}"],
      ["9f4f", "\u51FE\u{21F0F}\u5D8E\u9703\u{21DD1}\u9E81\u904C\u7B1F\u9B02\u5CD1\u7BA3\u6268\u6335\u9AFF\u7BCF\u9B2A\u7C7E\u9B2E\u7C42\u7C86\u9C15\u7BFC\u9B09\u9F17\u9C1B\u{2493E}\u9F5A\u5573\u5BC3\u4FFD\u9E98\u4FF2\u5260\u3E06\u52D1\u5767\u5056\u59B7\u5E12\u97C8\u9DAB\u8F5C\u5469\u97B4\u9940\u97BA\u532C\u6130"],
      ["9fa1", "\u692C\u53DA\u9C0A\u9D02\u4C3B\u9641\u6980\u50A6\u7546\u{2176D}\u99DA\u5273"],
      ["9fae", "\u9159\u9681\u915C"],
      ["9fb2", "\u9151\u{28E97}\u637F\u{26D23}\u6ACA\u5611\u918E\u757A\u6285\u{203FC}\u734F\u7C70\u{25C21}\u{23CFD}"],
      ["9fc1", "\u{24919}\u76D6\u9B9D\u4E2A\u{20CD4}\u83BE\u8842"],
      ["9fc9", "\u5C4A\u69C0\u50ED\u577A\u521F\u5DF5\u4ECE\u6C31\u{201F2}\u4F39\u549C\u54DA\u529A\u8D82\u35FE\u5F0C\u35F3"],
      ["9fdb", "\u6B52\u917C\u9FA5\u9B97\u982E\u98B4\u9ABA\u9EA8\u9E84\u717A\u7B14"],
      ["9fe7", "\u6BFA\u8818\u7F78"],
      ["9feb", "\u5620\u{2A64A}\u8E77\u9F53"],
      ["9ff0", "\u8DD4\u8E4F\u9E1C\u8E01\u6282\u{2837D}\u8E28\u8E75\u7AD3\u{24A77}\u7A3E\u78D8\u6CEA\u8A67\u7607"],
      ["a040", "\u{28A5A}\u9F26\u6CCE\u87D6\u75C3\u{2A2B2}\u7853\u{2F840}\u8D0C\u72E2\u7371\u8B2D\u7302\u74F1\u8CEB\u{24ABB}\u862F\u5FBA\u88A0\u44B7"],
      ["a055", "\u{2183B}\u{26E05}"],
      ["a058", "\u8A7E\u{2251B}"],
      ["a05b", "\u60FD\u7667\u9AD7\u9D44\u936E\u9B8F\u87F5"],
      ["a063", "\u880F\u8CF7\u732C\u9721\u9BB0\u35D6\u72B2\u4C07\u7C51\u994A\u{26159}\u6159\u4C04\u9E96\u617D"],
      ["a073", "\u575F\u616F\u62A6\u6239\u62CE\u3A5C\u61E2\u53AA\u{233F5}\u6364\u6802\u35D2"],
      ["a0a1", "\u5D57\u{28BC2}\u8FDA\u{28E39}"],
      ["a0a6", "\u50D9\u{21D46}\u7906\u5332\u9638\u{20F3B}\u4065"],
      ["a0ae", "\u77FE"],
      ["a0b0", "\u7CC2\u{25F1A}\u7CDA\u7A2D\u8066\u8063\u7D4D\u7505\u74F2\u8994\u821A\u670C\u8062\u{27486}\u805B\u74F0\u8103\u7724\u8989\u{267CC}\u7553\u{26ED1}\u87A9\u87CE\u81C8\u878C\u8A49\u8CAD\u8B43\u772B\u74F8\u84DA\u3635\u69B2\u8DA6"],
      ["a0d4", "\u89A9\u7468\u6DB9\u87C1\u{24011}\u74E7\u3DDB\u7176\u60A4\u619C\u3CD1\u7162\u6077"],
      ["a0e2", "\u7F71\u{28B2D}\u7250\u60E9\u4B7E\u5220\u3C18\u{23CC7}\u{25ED7}\u{27656}\u{25531}\u{21944}\u{212FE}\u{29903}\u{26DDC}\u{270AD}\u5CC1\u{261AD}\u{28A0F}\u{23677}\u{200EE}\u{26846}\u{24F0E}\u4562\u5B1F\u{2634C}\u9F50\u9EA6\u{2626B}"],
      ["a3c0", "\u2400", 31, "\u2421"],
      ["c6a1", "\u2460", 9, "\u2474", 9, "\u2170", 9, "\u4E36\u4E3F\u4E85\u4EA0\u5182\u5196\u51AB\u52F9\u5338\u5369\u53B6\u590A\u5B80\u5DDB\u2F33\u5E7F\u5EF4\u5F50\u5F61\u6534\u65E0\u7592\u7676\u8FB5\u96B6\xA8\u02C6\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\uFF3B\uFF3D\u273D\u3041", 23],
      ["c740", "\u3059", 58, "\u30A1\u30A2\u30A3\u30A4"],
      ["c7a1", "\u30A5", 81, "\u0410", 5, "\u0401\u0416", 4],
      ["c840", "\u041B", 26, "\u0451\u0436", 25, "\u21E7\u21B8\u21B9\u31CF\u{200CC}\u4E5A\u{2008A}\u5202\u4491"],
      ["c8a1", "\u9FB0\u5188\u9FB1\u{27607}"],
      ["c8cd", "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u309B\u309C\u2E80\u2E84\u2E86\u2E87\u2E88\u2E8A\u2E8C\u2E8D\u2E95\u2E9C\u2E9D\u2EA5\u2EA7\u2EAA\u2EAC\u2EAE\u2EB6\u2EBC\u2EBE\u2EC6\u2ECA\u2ECC\u2ECD\u2ECF\u2ED6\u2ED7\u2EDE\u2EE3"],
      ["c8f5", "\u0283\u0250\u025B\u0254\u0275\u0153\xF8\u014B\u028A\u026A"],
      ["f9fe", "\uFFED"],
      ["fa40", "\u{20547}\u92DB\u{205DF}\u{23FC5}\u854C\u42B5\u73EF\u51B5\u3649\u{24942}\u{289E4}\u9344\u{219DB}\u82EE\u{23CC8}\u783C\u6744\u62DF\u{24933}\u{289AA}\u{202A0}\u{26BB3}\u{21305}\u4FAB\u{224ED}\u5008\u{26D29}\u{27A84}\u{23600}\u{24AB1}\u{22513}\u5029\u{2037E}\u5FA4\u{20380}\u{20347}\u6EDB\u{2041F}\u507D\u5101\u347A\u510E\u986C\u3743\u8416\u{249A4}\u{20487}\u5160\u{233B4}\u516A\u{20BFF}\u{220FC}\u{202E5}\u{22530}\u{2058E}\u{23233}\u{21983}\u5B82\u877D\u{205B3}\u{23C99}\u51B2\u51B8"],
      ["faa1", "\u9D34\u51C9\u51CF\u51D1\u3CDC\u51D3\u{24AA6}\u51B3\u51E2\u5342\u51ED\u83CD\u693E\u{2372D}\u5F7B\u520B\u5226\u523C\u52B5\u5257\u5294\u52B9\u52C5\u7C15\u8542\u52E0\u860D\u{26B13}\u5305\u{28ADE}\u5549\u6ED9\u{23F80}\u{20954}\u{23FEC}\u5333\u5344\u{20BE2}\u6CCB\u{21726}\u681B\u73D5\u604A\u3EAA\u38CC\u{216E8}\u71DD\u44A2\u536D\u5374\u{286AB}\u537E\u537F\u{21596}\u{21613}\u77E6\u5393\u{28A9B}\u53A0\u53AB\u53AE\u73A7\u{25772}\u3F59\u739C\u53C1\u53C5\u6C49\u4E49\u57FE\u53D9\u3AAB\u{20B8F}\u53E0\u{23FEB}\u{22DA3}\u53F6\u{20C77}\u5413\u7079\u552B\u6657\u6D5B\u546D\u{26B53}\u{20D74}\u555D\u548F\u54A4\u47A6\u{2170D}\u{20EDD}\u3DB4\u{20D4D}"],
      ["fb40", "\u{289BC}\u{22698}\u5547\u4CED\u542F\u7417\u5586\u55A9\u5605\u{218D7}\u{2403A}\u4552\u{24435}\u66B3\u{210B4}\u5637\u66CD\u{2328A}\u66A4\u66AD\u564D\u564F\u78F1\u56F1\u9787\u53FE\u5700\u56EF\u56ED\u{28B66}\u3623\u{2124F}\u5746\u{241A5}\u6C6E\u708B\u5742\u36B1\u{26C7E}\u57E6\u{21416}\u5803\u{21454}\u{24363}\u5826\u{24BF5}\u585C\u58AA\u3561\u58E0\u58DC\u{2123C}\u58FB\u5BFF\u5743\u{2A150}\u{24278}\u93D3\u35A1\u591F\u68A6\u36C3\u6E59"],
      ["fba1", "\u{2163E}\u5A24\u5553\u{21692}\u8505\u59C9\u{20D4E}\u{26C81}\u{26D2A}\u{217DC}\u59D9\u{217FB}\u{217B2}\u{26DA6}\u6D71\u{21828}\u{216D5}\u59F9\u{26E45}\u5AAB\u5A63\u36E6\u{249A9}\u5A77\u3708\u5A96\u7465\u5AD3\u{26FA1}\u{22554}\u3D85\u{21911}\u3732\u{216B8}\u5E83\u52D0\u5B76\u6588\u5B7C\u{27A0E}\u4004\u485D\u{20204}\u5BD5\u6160\u{21A34}\u{259CC}\u{205A5}\u5BF3\u5B9D\u4D10\u5C05\u{21B44}\u5C13\u73CE\u5C14\u{21CA5}\u{26B28}\u5C49\u48DD\u5C85\u5CE9\u5CEF\u5D8B\u{21DF9}\u{21E37}\u5D10\u5D18\u5D46\u{21EA4}\u5CBA\u5DD7\u82FC\u382D\u{24901}\u{22049}\u{22173}\u8287\u3836\u3BC2\u5E2E\u6A8A\u5E75\u5E7A\u{244BC}\u{20CD3}\u53A6\u4EB7\u5ED0\u53A8\u{21771}\u5E09\u5EF4\u{28482}"],
      ["fc40", "\u5EF9\u5EFB\u38A0\u5EFC\u683E\u941B\u5F0D\u{201C1}\u{2F894}\u3ADE\u48AE\u{2133A}\u5F3A\u{26888}\u{223D0}\u5F58\u{22471}\u5F63\u97BD\u{26E6E}\u5F72\u9340\u{28A36}\u5FA7\u5DB6\u3D5F\u{25250}\u{21F6A}\u{270F8}\u{22668}\u91D6\u{2029E}\u{28A29}\u6031\u6685\u{21877}\u3963\u3DC7\u3639\u5790\u{227B4}\u7971\u3E40\u609E\u60A4\u60B3\u{24982}\u{2498F}\u{27A53}\u74A4\u50E1\u5AA0\u6164\u8424\u6142\u{2F8A6}\u{26ED2}\u6181\u51F4\u{20656}\u6187\u5BAA\u{23FB7}"],
      ["fca1", "\u{2285F}\u61D3\u{28B9D}\u{2995D}\u61D0\u3932\u{22980}\u{228C1}\u6023\u615C\u651E\u638B\u{20118}\u62C5\u{21770}\u62D5\u{22E0D}\u636C\u{249DF}\u3A17\u6438\u63F8\u{2138E}\u{217FC}\u6490\u6F8A\u{22E36}\u9814\u{2408C}\u{2571D}\u64E1\u64E5\u947B\u3A66\u643A\u3A57\u654D\u6F16\u{24A28}\u{24A23}\u6585\u656D\u655F\u{2307E}\u65B5\u{24940}\u4B37\u65D1\u40D8\u{21829}\u65E0\u65E3\u5FDF\u{23400}\u6618\u{231F7}\u{231F8}\u6644\u{231A4}\u{231A5}\u664B\u{20E75}\u6667\u{251E6}\u6673\u6674\u{21E3D}\u{23231}\u{285F4}\u{231C8}\u{25313}\u77C5\u{228F7}\u99A4\u6702\u{2439C}\u{24A21}\u3B2B\u69FA\u{237C2}\u675E\u6767\u6762\u{241CD}\u{290ED}\u67D7\u44E9\u6822\u6E50\u923C\u6801\u{233E6}\u{26DA0}\u685D"],
      ["fd40", "\u{2346F}\u69E1\u6A0B\u{28ADF}\u6973\u68C3\u{235CD}\u6901\u6900\u3D32\u3A01\u{2363C}\u3B80\u67AC\u6961\u{28A4A}\u42FC\u6936\u6998\u3BA1\u{203C9}\u8363\u5090\u69F9\u{23659}\u{2212A}\u6A45\u{23703}\u6A9D\u3BF3\u67B1\u6AC8\u{2919C}\u3C0D\u6B1D\u{20923}\u60DE\u6B35\u6B74\u{227CD}\u6EB5\u{23ADB}\u{203B5}\u{21958}\u3740\u5421\u{23B5A}\u6BE1\u{23EFC}\u6BDC\u6C37\u{2248B}\u{248F1}\u{26B51}\u6C5A\u8226\u6C79\u{23DBC}\u44C5\u{23DBD}\u{241A4}\u{2490C}\u{24900}"],
      ["fda1", "\u{23CC9}\u36E5\u3CEB\u{20D32}\u9B83\u{231F9}\u{22491}\u7F8F\u6837\u{26D25}\u{26DA1}\u{26DEB}\u6D96\u6D5C\u6E7C\u6F04\u{2497F}\u{24085}\u{26E72}\u8533\u{26F74}\u51C7\u6C9C\u6E1D\u842E\u{28B21}\u6E2F\u{23E2F}\u7453\u{23F82}\u79CC\u6E4F\u5A91\u{2304B}\u6FF8\u370D\u6F9D\u{23E30}\u6EFA\u{21497}\u{2403D}\u4555\u93F0\u6F44\u6F5C\u3D4E\u6F74\u{29170}\u3D3B\u6F9F\u{24144}\u6FD3\u{24091}\u{24155}\u{24039}\u{23FF0}\u{23FB4}\u{2413F}\u51DF\u{24156}\u{24157}\u{24140}\u{261DD}\u704B\u707E\u70A7\u7081\u70CC\u70D5\u70D6\u70DF\u4104\u3DE8\u71B4\u7196\u{24277}\u712B\u7145\u5A88\u714A\u716E\u5C9C\u{24365}\u714F\u9362\u{242C1}\u712C\u{2445A}\u{24A27}\u{24A22}\u71BA\u{28BE8}\u70BD\u720E"],
      ["fe40", "\u9442\u7215\u5911\u9443\u7224\u9341\u{25605}\u722E\u7240\u{24974}\u68BD\u7255\u7257\u3E55\u{23044}\u680D\u6F3D\u7282\u732A\u732B\u{24823}\u{2882B}\u48ED\u{28804}\u7328\u732E\u73CF\u73AA\u{20C3A}\u{26A2E}\u73C9\u7449\u{241E2}\u{216E7}\u{24A24}\u6623\u36C5\u{249B7}\u{2498D}\u{249FB}\u73F7\u7415\u6903\u{24A26}\u7439\u{205C3}\u3ED7\u745C\u{228AD}\u7460\u{28EB2}\u7447\u73E4\u7476\u83B9\u746C\u3730\u7474\u93F1\u6A2C\u7482\u4953\u{24A8C}"],
      ["fea1", "\u{2415F}\u{24A79}\u{28B8F}\u5B46\u{28C03}\u{2189E}\u74C8\u{21988}\u750E\u74E9\u751E\u{28ED9}\u{21A4B}\u5BD7\u{28EAC}\u9385\u754D\u754A\u7567\u756E\u{24F82}\u3F04\u{24D13}\u758E\u745D\u759E\u75B4\u7602\u762C\u7651\u764F\u766F\u7676\u{263F5}\u7690\u81EF\u37F8\u{26911}\u{2690E}\u76A1\u76A5\u76B7\u76CC\u{26F9F}\u8462\u{2509D}\u{2517D}\u{21E1C}\u771E\u7726\u7740\u64AF\u{25220}\u7758\u{232AC}\u77AF\u{28964}\u{28968}\u{216C1}\u77F4\u7809\u{21376}\u{24A12}\u68CA\u78AF\u78C7\u78D3\u96A5\u792E\u{255E0}\u78D7\u7934\u78B1\u{2760C}\u8FB8\u8884\u{28B2B}\u{26083}\u{2261C}\u7986\u8900\u6902\u7980\u{25857}\u799D\u{27B39}\u793C\u79A9\u6E2A\u{27126}\u3EA8\u79C6\u{2910D}\u79D4"]
    ];
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/dbcs-data.js
var require_dbcs_data2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/dbcs-data.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      // == Japanese/ShiftJIS ====================================================
      // All japanese encodings are based on JIS X set of standards:
      // JIS X 0201 - Single-byte encoding of ASCII + ¥ + Kana chars at 0xA1-0xDF.
      // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. 
      //              Has several variations in 1978, 1983, 1990 and 1997.
      // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead.
      // JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233.
      //              2 planes, first is superset of 0208, second - revised 0212.
      //              Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx)
      // Byte encodings are:
      //  * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte
      //               encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC.
      //               Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI.
      //  * EUC-JP:    Up to 3 bytes per character. Used mostly on *nixes.
      //               0x00-0x7F       - lower part of 0201
      //               0x8E, 0xA1-0xDF - upper part of 0201
      //               (0xA1-0xFE)x2   - 0208 plane (94x94).
      //               0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94).
      //  * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon.
      //               Used as-is in ISO2022 family.
      //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, 
      //                0201-1976 Roman, 0208-1978, 0208-1983.
      //  * ISO2022-JP-1: Adds esc seq for 0212-1990.
      //  * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7.
      //  * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2.
      //  * ISO2022-JP-2004: Adds 0213-2004 Plane 1.
      //
      // After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes.
      //
      // Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html
      "shiftjis": {
        type: "_dbcs",
        table: function() {
          return require_shiftjis2();
        },
        encodeAdd: { "\xA5": 92, "\u203E": 126 },
        encodeSkipVals: [{ from: 60736, to: 63808 }]
      },
      "csshiftjis": "shiftjis",
      "mskanji": "shiftjis",
      "sjis": "shiftjis",
      "windows31j": "shiftjis",
      "ms31j": "shiftjis",
      "xsjis": "shiftjis",
      "windows932": "shiftjis",
      "ms932": "shiftjis",
      "932": "shiftjis",
      "cp932": "shiftjis",
      "eucjp": {
        type: "_dbcs",
        table: function() {
          return require_eucjp2();
        },
        encodeAdd: { "\xA5": 92, "\u203E": 126 }
      },
      // TODO: KDDI extension to Shift_JIS
      // TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes.
      // TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars.
      // == Chinese/GBK ==========================================================
      // http://en.wikipedia.org/wiki/GBK
      // We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder
      // Oldest GB2312 (1981, ~7600 chars) is a subset of CP936
      "gb2312": "cp936",
      "gb231280": "cp936",
      "gb23121980": "cp936",
      "csgb2312": "cp936",
      "csiso58gb231280": "cp936",
      "euccn": "cp936",
      // Microsoft's CP936 is a subset and approximation of GBK.
      "windows936": "cp936",
      "ms936": "cp936",
      "936": "cp936",
      "cp936": {
        type: "_dbcs",
        table: function() {
          return require_cp9362();
        }
      },
      // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other.
      "gbk": {
        type: "_dbcs",
        table: function() {
          return require_cp9362().concat(require_gbk_added2());
        }
      },
      "xgbk": "gbk",
      "isoir58": "gbk",
      // GB18030 is an algorithmic extension of GBK.
      // Main source: https://www.w3.org/TR/encoding/#gbk-encoder
      // http://icu-project.org/docs/papers/gb18030.html
      // http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml
      // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0
      "gb18030": {
        type: "_dbcs",
        table: function() {
          return require_cp9362().concat(require_gbk_added2());
        },
        gb18030: function() {
          return require_gb18030_ranges2();
        },
        encodeSkipVals: [128],
        encodeAdd: { "\u20AC": 41699 }
      },
      "chinese": "gb18030",
      // == Korean ===============================================================
      // EUC-KR, KS_C_5601 and KS X 1001 are exactly the same.
      "windows949": "cp949",
      "ms949": "cp949",
      "949": "cp949",
      "cp949": {
        type: "_dbcs",
        table: function() {
          return require_cp9492();
        }
      },
      "cseuckr": "cp949",
      "csksc56011987": "cp949",
      "euckr": "cp949",
      "isoir149": "cp949",
      "korean": "cp949",
      "ksc56011987": "cp949",
      "ksc56011989": "cp949",
      "ksc5601": "cp949",
      // == Big5/Taiwan/Hong Kong ================================================
      // There are lots of tables for Big5 and cp950. Please see the following links for history:
      // http://moztw.org/docs/big5/  http://www.haible.de/bruno/charsets/conversion-tables/Big5.html
      // Variations, in roughly number of defined chars:
      //  * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT
      //  * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/
      //  * Big5-2003 (Taiwan standard) almost superset of cp950.
      //  * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers.
      //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. 
      //    many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years.
      //    Plus, it has 4 combining sequences.
      //    Seems that Mozilla refused to support it for 10 yrs. https://bugzilla.mozilla.org/show_bug.cgi?id=162431 https://bugzilla.mozilla.org/show_bug.cgi?id=310299
      //    because big5-hkscs is the only encoding to include astral characters in non-algorithmic way.
      //    Implementations are not consistent within browsers; sometimes labeled as just big5.
      //    MS Internet Explorer switches from big5 to big5-hkscs when a patch applied.
      //    Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31
      //    In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s.
      //    Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt
      //                   http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt
      // 
      // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder
      // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong.
      "windows950": "cp950",
      "ms950": "cp950",
      "950": "cp950",
      "cp950": {
        type: "_dbcs",
        table: function() {
          return require_cp9502();
        }
      },
      // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus.
      "big5": "big5hkscs",
      "big5hkscs": {
        type: "_dbcs",
        table: function() {
          return require_cp9502().concat(require_big5_added2());
        },
        encodeSkipVals: [41676]
      },
      "cnbig5": "big5hkscs",
      "csbig5": "big5hkscs",
      "xxbig5": "big5hkscs"
    };
  }
});

// node_modules/compressing/node_modules/iconv-lite/encodings/index.js
var require_encodings2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/encodings/index.js"(exports2, module2) {
    "use strict";
    var modules = [
      require_internal2(),
      require_utf322(),
      require_utf162(),
      require_utf72(),
      require_sbcs_codec2(),
      require_sbcs_data2(),
      require_sbcs_data_generated2(),
      require_dbcs_codec2(),
      require_dbcs_data2()
    ];
    for (i = 0; i < modules.length; i++) {
      module2 = modules[i];
      for (enc in module2)
        if (Object.prototype.hasOwnProperty.call(module2, enc))
          exports2[enc] = module2[enc];
    }
    var module2;
    var enc;
    var i;
  }
});

// node_modules/compressing/node_modules/iconv-lite/lib/streams.js
var require_streams2 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/lib/streams.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require("buffer").Buffer;
    var Transform = require("stream").Transform;
    module2.exports = function(iconv) {
      iconv.encodeStream = function encodeStream(encoding, options) {
        return new IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options);
      };
      iconv.decodeStream = function decodeStream(encoding, options) {
        return new IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options);
      };
      iconv.supportsStreams = true;
      iconv.IconvLiteEncoderStream = IconvLiteEncoderStream;
      iconv.IconvLiteDecoderStream = IconvLiteDecoderStream;
      iconv._collect = IconvLiteDecoderStream.prototype.collect;
    };
    function IconvLiteEncoderStream(conv, options) {
      this.conv = conv;
      options = options || {};
      options.decodeStrings = false;
      Transform.call(this, options);
    }
    IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, {
      constructor: { value: IconvLiteEncoderStream }
    });
    IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) {
      if (typeof chunk != "string")
        return done(new Error("Iconv encoding stream needs strings as its input."));
      try {
        var res = this.conv.write(chunk);
        if (res && res.length) this.push(res);
        done();
      } catch (e) {
        done(e);
      }
    };
    IconvLiteEncoderStream.prototype._flush = function(done) {
      try {
        var res = this.conv.end();
        if (res && res.length) this.push(res);
        done();
      } catch (e) {
        done(e);
      }
    };
    IconvLiteEncoderStream.prototype.collect = function(cb) {
      var chunks = [];
      this.on("error", cb);
      this.on("data", function(chunk) {
        chunks.push(chunk);
      });
      this.on("end", function() {
        cb(null, Buffer3.concat(chunks));
      });
      return this;
    };
    function IconvLiteDecoderStream(conv, options) {
      this.conv = conv;
      options = options || {};
      options.encoding = this.encoding = "utf8";
      Transform.call(this, options);
    }
    IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, {
      constructor: { value: IconvLiteDecoderStream }
    });
    IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {
      if (!Buffer3.isBuffer(chunk))
        return done(new Error("Iconv decoding stream needs buffers as its input."));
      try {
        var res = this.conv.write(chunk);
        if (res && res.length) this.push(res, this.encoding);
        done();
      } catch (e) {
        done(e);
      }
    };
    IconvLiteDecoderStream.prototype._flush = function(done) {
      try {
        var res = this.conv.end();
        if (res && res.length) this.push(res, this.encoding);
        done();
      } catch (e) {
        done(e);
      }
    };
    IconvLiteDecoderStream.prototype.collect = function(cb) {
      var res = "";
      this.on("error", cb);
      this.on("data", function(chunk) {
        res += chunk;
      });
      this.on("end", function() {
        cb(null, res);
      });
      return this;
    };
  }
});

// node_modules/compressing/node_modules/iconv-lite/lib/extend-node.js
var require_extend_node = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/lib/extend-node.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require("buffer").Buffer;
    module2.exports = function(iconv) {
      var original = void 0;
      iconv.supportsNodeEncodingsExtension = !(Buffer3.from || new Buffer3(0) instanceof Uint8Array);
      iconv.extendNodeEncodings = function extendNodeEncodings() {
        if (original) return;
        original = {};
        if (!iconv.supportsNodeEncodingsExtension) {
          console.error("ACTION NEEDED: require('iconv-lite').extendNodeEncodings() is not supported in your version of Node");
          console.error("See more info at https://github.com/ashtuchkin/iconv-lite/wiki/Node-v4-compatibility");
          return;
        }
        var nodeNativeEncodings = {
          "hex": true,
          "utf8": true,
          "utf-8": true,
          "ascii": true,
          "binary": true,
          "base64": true,
          "ucs2": true,
          "ucs-2": true,
          "utf16le": true,
          "utf-16le": true
        };
        Buffer3.isNativeEncoding = function(enc) {
          return enc && nodeNativeEncodings[enc.toLowerCase()];
        };
        var SlowBuffer = require("buffer").SlowBuffer;
        original.SlowBufferToString = SlowBuffer.prototype.toString;
        SlowBuffer.prototype.toString = function(encoding, start, end) {
          encoding = String(encoding || "utf8").toLowerCase();
          if (Buffer3.isNativeEncoding(encoding))
            return original.SlowBufferToString.call(this, encoding, start, end);
          if (typeof start == "undefined") start = 0;
          if (typeof end == "undefined") end = this.length;
          return iconv.decode(this.slice(start, end), encoding);
        };
        original.SlowBufferWrite = SlowBuffer.prototype.write;
        SlowBuffer.prototype.write = function(string5, offset, length, encoding) {
          if (isFinite(offset)) {
            if (!isFinite(length)) {
              encoding = length;
              length = void 0;
            }
          } else {
            var swap = encoding;
            encoding = offset;
            offset = length;
            length = swap;
          }
          offset = +offset || 0;
          var remaining = this.length - offset;
          if (!length) {
            length = remaining;
          } else {
            length = +length;
            if (length > remaining) {
              length = remaining;
            }
          }
          encoding = String(encoding || "utf8").toLowerCase();
          if (Buffer3.isNativeEncoding(encoding))
            return original.SlowBufferWrite.call(this, string5, offset, length, encoding);
          if (string5.length > 0 && (length < 0 || offset < 0))
            throw new RangeError("attempt to write beyond buffer bounds");
          var buf = iconv.encode(string5, encoding);
          if (buf.length < length) length = buf.length;
          buf.copy(this, offset, 0, length);
          return length;
        };
        original.BufferIsEncoding = Buffer3.isEncoding;
        Buffer3.isEncoding = function(encoding) {
          return Buffer3.isNativeEncoding(encoding) || iconv.encodingExists(encoding);
        };
        original.BufferByteLength = Buffer3.byteLength;
        Buffer3.byteLength = SlowBuffer.byteLength = function(str, encoding) {
          encoding = String(encoding || "utf8").toLowerCase();
          if (Buffer3.isNativeEncoding(encoding))
            return original.BufferByteLength.call(this, str, encoding);
          return iconv.encode(str, encoding).length;
        };
        original.BufferToString = Buffer3.prototype.toString;
        Buffer3.prototype.toString = function(encoding, start, end) {
          encoding = String(encoding || "utf8").toLowerCase();
          if (Buffer3.isNativeEncoding(encoding))
            return original.BufferToString.call(this, encoding, start, end);
          if (typeof start == "undefined") start = 0;
          if (typeof end == "undefined") end = this.length;
          return iconv.decode(this.slice(start, end), encoding);
        };
        original.BufferWrite = Buffer3.prototype.write;
        Buffer3.prototype.write = function(string5, offset, length, encoding) {
          var _offset = offset, _length3 = length, _encoding = encoding;
          if (isFinite(offset)) {
            if (!isFinite(length)) {
              encoding = length;
              length = void 0;
            }
          } else {
            var swap = encoding;
            encoding = offset;
            offset = length;
            length = swap;
          }
          encoding = String(encoding || "utf8").toLowerCase();
          if (Buffer3.isNativeEncoding(encoding))
            return original.BufferWrite.call(this, string5, _offset, _length3, _encoding);
          offset = +offset || 0;
          var remaining = this.length - offset;
          if (!length) {
            length = remaining;
          } else {
            length = +length;
            if (length > remaining) {
              length = remaining;
            }
          }
          if (string5.length > 0 && (length < 0 || offset < 0))
            throw new RangeError("attempt to write beyond buffer bounds");
          var buf = iconv.encode(string5, encoding);
          if (buf.length < length) length = buf.length;
          buf.copy(this, offset, 0, length);
          return length;
        };
        if (iconv.supportsStreams) {
          var Readable2 = require("stream").Readable;
          original.ReadableSetEncoding = Readable2.prototype.setEncoding;
          Readable2.prototype.setEncoding = function setEncoding(enc, options) {
            this._readableState.decoder = iconv.getDecoder(enc, options);
            this._readableState.encoding = enc;
          };
          Readable2.prototype.collect = iconv._collect;
        }
      };
      iconv.undoExtendNodeEncodings = function undoExtendNodeEncodings() {
        if (!iconv.supportsNodeEncodingsExtension)
          return;
        if (!original)
          throw new Error("require('iconv-lite').undoExtendNodeEncodings(): Nothing to undo; extendNodeEncodings() is not called.");
        delete Buffer3.isNativeEncoding;
        var SlowBuffer = require("buffer").SlowBuffer;
        SlowBuffer.prototype.toString = original.SlowBufferToString;
        SlowBuffer.prototype.write = original.SlowBufferWrite;
        Buffer3.isEncoding = original.BufferIsEncoding;
        Buffer3.byteLength = original.BufferByteLength;
        Buffer3.prototype.toString = original.BufferToString;
        Buffer3.prototype.write = original.BufferWrite;
        if (iconv.supportsStreams) {
          var Readable2 = require("stream").Readable;
          Readable2.prototype.setEncoding = original.ReadableSetEncoding;
          delete Readable2.prototype.collect;
        }
        original = void 0;
      };
    };
  }
});

// node_modules/compressing/node_modules/iconv-lite/lib/index.js
var require_lib7 = __commonJS({
  "node_modules/compressing/node_modules/iconv-lite/lib/index.js"(exports2, module2) {
    "use strict";
    var Buffer3 = require_safer().Buffer;
    var bomHandling = require_bom_handling2();
    var iconv = module2.exports;
    iconv.encodings = null;
    iconv.defaultCharUnicode = "\uFFFD";
    iconv.defaultCharSingleByte = "?";
    iconv.encode = function encode6(str, encoding, options) {
      str = "" + (str || "");
      var encoder = iconv.getEncoder(encoding, options);
      var res = encoder.write(str);
      var trail = encoder.end();
      return trail && trail.length > 0 ? Buffer3.concat([res, trail]) : res;
    };
    iconv.decode = function decode4(buf, encoding, options) {
      if (typeof buf === "string") {
        if (!iconv.skipDecodeWarning) {
          console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
          iconv.skipDecodeWarning = true;
        }
        buf = Buffer3.from("" + (buf || ""), "binary");
      }
      var decoder = iconv.getDecoder(encoding, options);
      var res = decoder.write(buf);
      var trail = decoder.end();
      return trail ? res + trail : res;
    };
    iconv.encodingExists = function encodingExists(enc) {
      try {
        iconv.getCodec(enc);
        return true;
      } catch (e) {
        return false;
      }
    };
    iconv.toEncoding = iconv.encode;
    iconv.fromEncoding = iconv.decode;
    iconv._codecDataCache = {};
    iconv.getCodec = function getCodec(encoding) {
      if (!iconv.encodings)
        iconv.encodings = require_encodings2();
      var enc = iconv._canonicalizeEncoding(encoding);
      var codecOptions = {};
      while (true) {
        var codec3 = iconv._codecDataCache[enc];
        if (codec3)
          return codec3;
        var codecDef = iconv.encodings[enc];
        switch (typeof codecDef) {
          case "string":
            enc = codecDef;
            break;
          case "object":
            for (var key in codecDef)
              codecOptions[key] = codecDef[key];
            if (!codecOptions.encodingName)
              codecOptions.encodingName = enc;
            enc = codecDef.type;
            break;
          case "function":
            if (!codecOptions.encodingName)
              codecOptions.encodingName = enc;
            codec3 = new codecDef(codecOptions, iconv);
            iconv._codecDataCache[codecOptions.encodingName] = codec3;
            return codec3;
          default:
            throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
        }
      }
    };
    iconv._canonicalizeEncoding = function(encoding) {
      return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
    };
    iconv.getEncoder = function getEncoder(encoding, options) {
      var codec3 = iconv.getCodec(encoding), encoder = new codec3.encoder(options, codec3);
      if (codec3.bomAware && options && options.addBOM)
        encoder = new bomHandling.PrependBOM(encoder, options);
      return encoder;
    };
    iconv.getDecoder = function getDecoder(encoding, options) {
      var codec3 = iconv.getCodec(encoding), decoder = new codec3.decoder(options, codec3);
      if (codec3.bomAware && !(options && options.stripBOM === false))
        decoder = new bomHandling.StripBOM(decoder, options);
      return decoder;
    };
    var nodeVer = typeof process !== "undefined" && process.versions && process.versions.node;
    if (nodeVer) {
      nodeVerArr = nodeVer.split(".").map(Number);
      if (nodeVerArr[0] > 0 || nodeVerArr[1] >= 10) {
        require_streams2()(iconv);
      }
      require_extend_node()(iconv);
    }
    var nodeVerArr;
    if (false) {
      console.error("iconv-lite warning: javascript files use encoding different from utf-8. See https://github.com/ashtuchkin/iconv-lite/wiki/Javascript-source-file-encodings for more info.");
    }
  }
});

// node_modules/compressing/lib/zip/uncompress_stream.js
var require_uncompress_stream = __commonJS({
  "node_modules/compressing/lib/zip/uncompress_stream.js"(exports2, module2) {
    "use strict";
    var debug = require("util").debuglog("compressing/zip/uncompress_stream");
    var yauzl = require_yauzl();
    var stream4 = require("stream");
    var UncompressBaseStream = require_base_write_stream();
    var utils = require_utils13();
    var iconv;
    var YAUZL_CALLBACK = /* @__PURE__ */ Symbol("ZipUncompressStream#yauzlCallback");
    var STRIP_NAME = /* @__PURE__ */ Symbol("ZipUncompressStream#stripName");
    var DEFAULTS2 = { lazyEntries: true, decodeStrings: false };
    function modeFromEntry(entry) {
      const attr = entry.externalFileAttributes >> 16 || 33188;
      return [
        448,
        56,
        7
        /* S_IRWXO */
      ].map((mask) => attr & mask).reduce(
        (a, b) => a + b,
        attr & 61440
        /* S_IFMT */
      );
    }
    var ZipUncompressStream = class extends UncompressBaseStream {
      constructor(opts) {
        opts = opts || {};
        super(opts);
        this._chunks = [];
        this._strip = Number(opts.strip) || 0;
        this._zipFileNameEncoding = opts.zipFileNameEncoding || "utf8";
        if (this._zipFileNameEncoding === "utf-8") {
          this._zipFileNameEncoding = "utf8";
        }
        this._finalCallback = (err) => {
          if (err) {
            debug("finalCallback, error: %j", err);
            return this.emit("error", err);
          }
          this.emit("finish");
        };
        this[YAUZL_CALLBACK] = this[YAUZL_CALLBACK].bind(this);
        const sourceType = utils.sourceType(opts.source);
        const yauzlOpts = this._yauzlOpts = Object.assign({}, DEFAULTS2, opts.yauzl);
        debug("sourceType: %s, yauzlOpts: %j", sourceType, yauzlOpts);
        if (sourceType === "file") {
          yauzl.open(opts.source, yauzlOpts, this[YAUZL_CALLBACK]);
          return;
        }
        if (sourceType === "buffer") {
          yauzl.fromBuffer(opts.source, yauzlOpts, this[YAUZL_CALLBACK]);
          return;
        }
        if (sourceType === "stream") {
          utils.streamToBuffer(opts.source).then((buf) => yauzl.fromBuffer(buf, yauzlOpts, this[YAUZL_CALLBACK])).catch((e) => this.emit("error", e));
          return;
        }
      }
      _write(chunk, _encoding, callback) {
        this._chunks.push(chunk);
        debug("write size: %d, chunks: %d", chunk.length, this._chunks.length);
        callback();
      }
      _final(callback) {
        const buf = Buffer.concat(this._chunks);
        debug("final, buf size: %d, chunks: %d", buf.length, this._chunks.length);
        this._finalCallback = callback;
        yauzl.fromBuffer(buf, this._yauzlOpts, this[YAUZL_CALLBACK]);
      }
      [YAUZL_CALLBACK](err, zipFile) {
        if (err) {
          debug("yauzl error", err);
          return this._finalCallback(err);
        }
        zipFile.readEntry();
        zipFile.on("entry", (entry) => {
          const mode = modeFromEntry(entry);
          if (Buffer.isBuffer(entry.fileName)) {
            if (this._zipFileNameEncoding === "utf8") {
              entry.fileName = entry.fileName.toString();
            } else {
              if (!iconv) {
                iconv = require_lib7();
              }
              entry.fileName = iconv.decode(entry.fileName, this._zipFileNameEncoding);
            }
          }
          const type = /[\\\/]$/.test(entry.fileName) ? "directory" : "file";
          const name28 = entry.fileName = this[STRIP_NAME](entry.fileName, type);
          const header = { name: name28, type, yauzl: entry, mode };
          if (type === "file") {
            zipFile.openReadStream(entry, (err2, readStream2) => {
              if (err2) {
                debug("file, error: %j", err2);
                return this._finalCallback(err2);
              }
              debug("file, header: %j", header);
              this.emit("entry", header, readStream2, next);
            });
          } else {
            const placeholder = new stream4.Readable({ read() {
            } });
            debug("directory, header: %j", header);
            this.emit("entry", header, placeholder, next);
            setImmediate(() => placeholder.emit("end"));
          }
        }).on("end", () => this._finalCallback()).on("error", (err2) => this._finalCallback(err2));
        function next() {
          zipFile.readEntry();
        }
      }
      [STRIP_NAME](fileName, type) {
        return utils.stripFileName(this._strip, fileName, type);
      }
    };
    module2.exports = ZipUncompressStream;
  }
});

// node_modules/compressing/lib/zip/index.js
var require_zip = __commonJS({
  "node_modules/compressing/lib/zip/index.js"(exports2) {
    "use strict";
    var utils = require_utils13();
    var ZipStream = require_stream10();
    var ZipFileStream = require_file_stream();
    var ZipUncompressStream = require_uncompress_stream();
    exports2.Stream = ZipStream;
    exports2.FileStream = ZipFileStream;
    exports2.UncompressStream = ZipUncompressStream;
    exports2.compressDir = utils.makeCompressDirFn(ZipStream);
    exports2.compressFile = utils.makeFileProcessFn(ZipFileStream);
    exports2.uncompress = utils.makeUncompressFn(ZipUncompressStream);
    exports2.decompress = utils.makeUncompressFn(ZipUncompressStream);
  }
});

// node_modules/streamifier/lib/index.js
var require_lib8 = __commonJS({
  "node_modules/streamifier/lib/index.js"(exports2, module2) {
    "use strict";
    var util4 = require("util");
    var stream4 = require("stream");
    module2.exports.createReadStream = function(object4, options) {
      return new MultiStream(object4, options);
    };
    var MultiStream = function(object4, options) {
      if (object4 instanceof Buffer || typeof object4 === "string") {
        options = options || {};
        stream4.Readable.call(this, {
          highWaterMark: options.highWaterMark,
          encoding: options.encoding
        });
      } else {
        stream4.Readable.call(this, { objectMode: true });
      }
      this._object = object4;
    };
    util4.inherits(MultiStream, stream4.Readable);
    MultiStream.prototype._read = function() {
      this.push(this._object);
      this._object = null;
    };
  }
});

// node_modules/compressing/lib/gzip/file_stream.js
var require_file_stream2 = __commonJS({
  "node_modules/compressing/lib/gzip/file_stream.js"(exports2, module2) {
    "use strict";
    var fs34 = require("fs");
    var zlib2 = require("zlib");
    var utils = require_utils13();
    var streamifier = require_lib8();
    var GzipFileStream = class extends zlib2.Gzip {
      constructor(opts) {
        opts = opts || {};
        super(opts.zlib);
        const sourceType = utils.sourceType(opts.source);
        if (sourceType === "file") {
          const stream4 = fs34.createReadStream(opts.source, opts.fs);
          stream4.on("error", (err) => this.emit("error", err));
          stream4.pipe(this);
          return;
        }
        if (sourceType === "buffer") {
          const stream4 = streamifier.createReadStream(opts.source, opts.streamifier);
          stream4.on("error", (err) => this.emit("error", err));
          stream4.pipe(this);
          return;
        }
        if (sourceType === "stream") {
          opts.source.on("error", (err) => this.emit("error", err));
          opts.source.pipe(this);
        }
      }
    };
    module2.exports = GzipFileStream;
  }
});

// node_modules/compressing/lib/gzip/uncompress_stream.js
var require_uncompress_stream2 = __commonJS({
  "node_modules/compressing/lib/gzip/uncompress_stream.js"(exports2, module2) {
    "use strict";
    var fs34 = require("fs");
    var zlib2 = require("zlib");
    var utils = require_utils13();
    var streamifier = require_lib8();
    var GzipUncompressStream = class extends zlib2.Unzip {
      constructor(opts) {
        opts = opts || {};
        super(opts.zlib);
        const sourceType = utils.sourceType(opts.source);
        if (sourceType === "file") {
          const stream4 = fs34.createReadStream(opts.source, opts.fs);
          stream4.on("error", (err) => this.emit("error", err));
          stream4.pipe(this);
          return;
        }
        if (sourceType === "buffer") {
          const stream4 = streamifier.createReadStream(opts.source, opts.streamifier);
          stream4.on("error", (err) => this.emit("error", err));
          stream4.pipe(this);
          return;
        }
        if (sourceType === "stream") {
          opts.source.on("error", (err) => this.emit("error", err));
          opts.source.pipe(this);
        }
      }
    };
    module2.exports = GzipUncompressStream;
  }
});

// node_modules/compressing/lib/gzip/index.js
var require_gzip = __commonJS({
  "node_modules/compressing/lib/gzip/index.js"(exports2) {
    "use strict";
    var utils = require_utils13();
    var GzipFileStream = require_file_stream2();
    var GzipUncompressStream = require_uncompress_stream2();
    exports2.FileStream = GzipFileStream;
    exports2.UncompressStream = GzipUncompressStream;
    exports2.compressFile = utils.makeFileProcessFn(GzipFileStream);
    exports2.uncompress = utils.makeFileProcessFn(GzipUncompressStream);
    exports2.decompress = utils.makeFileProcessFn(GzipUncompressStream);
  }
});

// node_modules/compressing/lib/tar/file_stream.js
var require_file_stream3 = __commonJS({
  "node_modules/compressing/lib/tar/file_stream.js"(exports2, module2) {
    "use strict";
    var fs34 = require("fs");
    var path33 = require("path");
    var stream4 = require("stream");
    var tar = require_tar_stream();
    var utils = require_utils13();
    var ready = require_get_ready();
    var TarFileStream = class extends stream4.Transform {
      constructor(opts) {
        super(opts);
        const pack = tar.pack();
        pack.on("data", (chunk) => this.push(chunk));
        pack.on("end", () => this.ready(true));
        const sourceType = utils.sourceType(opts.source);
        if (sourceType === "file") {
          fs34.stat(opts.source, (err, stat) => {
            if (err) return this.emit("error", err);
            this.entry = pack.entry({ name: opts.relativePath || path33.basename(opts.source), size: stat.size, mode: stat.mode & 511 }, (err2) => {
              if (err2) return this.emit("error", err2);
              pack.finalize();
            });
            const stream5 = fs34.createReadStream(opts.source, opts.fs);
            stream5.on("error", (err2) => this.emit("error", err2));
            stream5.pipe(this);
          });
        } else if (sourceType === "buffer") {
          if (!opts.relativePath) return this.emit("error", "opts.relativePath is required if opts.source is a buffer");
          pack.entry({ name: opts.relativePath }, opts.source);
          pack.finalize();
          this.end();
        } else {
          if (!opts.relativePath) return process.nextTick(() => this.emit("error", "opts.relativePath is required"));
          if (opts.size) {
            this.entry = pack.entry({ name: opts.relativePath, size: opts.size }, (err) => {
              if (err) return this.emit("error", err);
              pack.finalize();
            });
          } else {
            if (!opts.suppressSizeWarning) {
              console.warn("You should specify the size of streamming data by opts.size to prevent all streaming data from loading into memory. If you are sure about memory cost, pass opts.suppressSizeWarning: true to suppress this warning");
            }
            const buf = [];
            this.entry = new stream4.Writable({
              write(chunk, _, callback) {
                buf.push(chunk);
                callback();
              }
            });
            this.entry.on("finish", () => {
              pack.entry({ name: opts.relativePath }, Buffer.concat(buf));
              pack.finalize();
            });
          }
          if (sourceType === "stream") {
            opts.source.on("error", (err) => this.emit("error", err));
            opts.source.pipe(this);
          }
        }
      }
      _transform(chunk, encoding, callback) {
        if (this.entry) {
          this.entry.write(chunk, encoding, callback);
        }
      }
      _flush(callback) {
        if (this.entry) {
          this.entry.end();
        }
        this.ready(callback);
      }
    };
    ready.mixin(TarFileStream.prototype);
    module2.exports = TarFileStream;
  }
});

// node_modules/compressing/lib/tar/uncompress_stream.js
var require_uncompress_stream3 = __commonJS({
  "node_modules/compressing/lib/tar/uncompress_stream.js"(exports2, module2) {
    "use strict";
    var fs34 = require("fs");
    var tar = require_tar_stream();
    var utils = require_utils13();
    var streamifier = require_lib8();
    var TarUncompressStream = class extends tar.extract {
      constructor(opts) {
        opts = opts || {};
        super(opts);
        const sourceType = utils.sourceType(opts.source);
        if (sourceType === "file") {
          const stream4 = fs34.createReadStream(opts.source, opts.fs);
          stream4.on("error", (err) => this.emit("error", err));
          stream4.pipe(this);
          return;
        }
        if (sourceType === "buffer") {
          const stream4 = streamifier.createReadStream(opts.source, opts.streamifier);
          stream4.on("error", (err) => this.emit("error", err));
          stream4.pipe(this);
          return;
        }
        if (sourceType === "stream") {
          opts.source.on("error", (err) => this.emit("error", err));
          opts.source.pipe(this);
        }
      }
    };
    module2.exports = TarUncompressStream;
  }
});

// node_modules/compressing/lib/tar/index.js
var require_tar = __commonJS({
  "node_modules/compressing/lib/tar/index.js"(exports2) {
    "use strict";
    var utils = require_utils13();
    var TarStream = require_stream9();
    var TarFileStream = require_file_stream3();
    var TarUncompressStream = require_uncompress_stream3();
    exports2.Stream = TarStream;
    exports2.FileStream = TarFileStream;
    exports2.UncompressStream = TarUncompressStream;
    exports2.compressDir = utils.makeCompressDirFn(TarStream);
    exports2.compressFile = utils.makeFileProcessFn(TarFileStream);
    exports2.uncompress = utils.makeUncompressFn(TarUncompressStream);
    exports2.decompress = utils.makeUncompressFn(TarUncompressStream);
  }
});

// node_modules/compressing/lib/tgz/stream.js
var require_stream11 = __commonJS({
  "node_modules/compressing/lib/tgz/stream.js"(exports2, module2) {
    "use strict";
    var tar = require_tar();
    var gzip = require_gzip();
    var BaseStream = require_base_stream();
    var TgzStream = class extends BaseStream {
      constructor(opts) {
        super(opts);
        const tarStream = this._tarStream = new tar.Stream();
        tarStream.on("error", (err) => this.emit("error", err));
        const gzipStream = new gzip.FileStream();
        gzipStream.on("end", () => this.push(null));
        gzipStream.on("data", (chunk) => this.push(chunk));
        gzipStream.on("error", (err) => this.emit("error", err));
        tarStream.pipe(gzipStream);
      }
      addEntry(entry, opts) {
        this._tarStream.addEntry(entry, opts);
      }
    };
    module2.exports = TgzStream;
  }
});

// node_modules/compressing/lib/tgz/file_stream.js
var require_file_stream4 = __commonJS({
  "node_modules/compressing/lib/tgz/file_stream.js"(exports2, module2) {
    "use strict";
    var tar = require_tar();
    var gzip = require_gzip();
    var utils = require_utils13();
    var stream4 = require("stream");
    var { pipeline: pump } = require("stream");
    var ready = require_get_ready();
    var TgzFileStream = class extends stream4.Transform {
      constructor(opts) {
        opts = opts || {};
        super(opts);
        const sourceType = this._sourceType = utils.sourceType(opts.source);
        const tarStream = this._tarStream = new tar.FileStream(opts);
        opts = utils.clone(opts);
        delete opts.source;
        const gzipStream = new gzip.FileStream(opts);
        gzipStream.on("data", (chunk) => {
          this.push(chunk);
        });
        gzipStream.on("end", () => this.ready(true));
        pump(tarStream, gzipStream, (err) => {
          err && this.emit("error", err);
        });
        if (sourceType !== "stream" && sourceType !== void 0) {
          this.end();
        }
      }
      _transform(chunk, encoding, callback) {
        this._tarStream.write(chunk, encoding, callback);
      }
      _flush(callback) {
        if (this._sourceType === "stream" || this._sourceType === void 0) {
          this._tarStream.end();
        }
        this.ready(callback);
      }
    };
    ready.mixin(TgzFileStream.prototype);
    module2.exports = TgzFileStream;
  }
});

// node_modules/flushwritable/lib/FlushWritable.js
var require_FlushWritable = __commonJS({
  "node_modules/flushwritable/lib/FlushWritable.js"(exports2, module2) {
    "use strict";
    var EventEmitter3 = require("events").EventEmitter;
    var Writable = require("stream").Writable;
    var util4 = require("util");
    function FlushWritable(opts) {
      Writable.call(this, opts);
    }
    util4.inherits(FlushWritable, Writable);
    FlushWritable.prototype.emit = function(evt) {
      if (evt === "finish" && this._flush && !Writable.prototype._flush) {
        this._flush(function(err) {
          if (err)
            EventEmitter3.prototype.emit.call(this, "error", err);
          else
            EventEmitter3.prototype.emit.call(this, "finish");
        }.bind(this));
      } else {
        var args = Array.prototype.slice.call(arguments);
        EventEmitter3.prototype.emit.apply(this, args);
      }
    };
    module2.exports = FlushWritable;
  }
});

// node_modules/compressing/lib/tgz/uncompress_stream.js
var require_uncompress_stream4 = __commonJS({
  "node_modules/compressing/lib/tgz/uncompress_stream.js"(exports2, module2) {
    "use strict";
    var fs34 = require("fs");
    var utils = require_utils13();
    var ready = require_get_ready();
    var streamifier = require_lib8();
    var FlushWritable = require_FlushWritable();
    var GzipUncompressStream = require_gzip().UncompressStream;
    var TarUncompressStream = require_tar().UncompressStream;
    var TgzUncompressStream = class extends FlushWritable {
      constructor(opts) {
        opts = opts || {};
        super(opts);
        const newOpts = utils.clone(opts);
        newOpts.source = void 0;
        this._gzipStream = new GzipUncompressStream(newOpts).on("error", (err) => this.emit("error", err));
        const tarStream = new TarUncompressStream(newOpts).on("finish", () => this.ready(true)).on("entry", this.emit.bind(this, "entry")).on("error", (err) => this.emit("error", err));
        this._gzipStream.pipe(tarStream);
        const sourceType = utils.sourceType(opts.source);
        if (sourceType === "file") {
          const stream4 = fs34.createReadStream(opts.source, opts.fs);
          stream4.on("error", (err) => this.emit("error", err));
          stream4.pipe(this);
          return;
        }
        if (sourceType === "buffer") {
          const stream4 = streamifier.createReadStream(opts.source, opts.streamifier);
          stream4.on("error", (err) => this.emit("error", err));
          stream4.pipe(this);
          return;
        }
        if (sourceType === "stream") {
          opts.source.on("error", (err) => this.emit("error", err));
          opts.source.pipe(this);
        }
      }
      _write(chunk, encoding, callback) {
        this._gzipStream.write(chunk, encoding, callback);
      }
      _flush(callback) {
        this._gzipStream.end();
        this.ready(callback);
      }
    };
    ready.mixin(TgzUncompressStream.prototype);
    module2.exports = TgzUncompressStream;
  }
});

// node_modules/compressing/lib/tgz/index.js
var require_tgz = __commonJS({
  "node_modules/compressing/lib/tgz/index.js"(exports2) {
    "use strict";
    var utils = require_utils13();
    var TgzStream = require_stream11();
    var TgzFileStream = require_file_stream4();
    var TgzUncompressStream = require_uncompress_stream4();
    exports2.Stream = TgzStream;
    exports2.FileStream = TgzFileStream;
    exports2.UncompressStream = TgzUncompressStream;
    exports2.compressDir = utils.makeCompressDirFn(TgzStream);
    exports2.compressFile = utils.makeFileProcessFn(TgzFileStream);
    exports2.uncompress = utils.makeUncompressFn(TgzUncompressStream);
    exports2.decompress = utils.makeUncompressFn(TgzUncompressStream);
  }
});

// node_modules/compressing/index.js
var require_compressing = __commonJS({
  "node_modules/compressing/index.js"(exports2) {
    "use strict";
    exports2.zip = require_zip();
    exports2.gzip = require_gzip();
    exports2.tar = require_tar();
    exports2.tgz = require_tgz();
  }
});

// src/routes/script/exportScript.ts
var import_express113, import_compressing, router113, exportScript_default;
var init_exportScript = __esm({
  "src/routes/script/exportScript.ts"() {
    "use strict";
    import_express113 = __toESM(require_express2());
    init_utils3();
    init_zod();
    import_compressing = __toESM(require_compressing());
    init_middleware();
    router113 = import_express113.default.Router();
    exportScript_default = router113.post(
      "/",
      validateFields({
        id: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { id } = req.body;
        const scripts = await utils_default.db("o_script").whereIn("id", id);
        const textList = scripts.map((s) => ({ name: s.name, text: s.content }));
        const zipStream = new import_compressing.default.zip.Stream();
        textList.forEach((item) => {
          zipStream.addEntry(Buffer.from(item.text), { relativePath: `${item.name}.txt` });
        });
        res.setHeader("Content-Type", "application/zip");
        res.setHeader("Content-Disposition", `attachment; filename=scripts.zip`);
        zipStream.pipe(res);
      }
    );
  }
});

// src/routes/script/extractAssets.ts
function chunkArray(arr, groupSize) {
  const chunks = [];
  for (let i = 0; i < arr.length; i += 5) {
    chunks.push(arr.slice(i, i + 5));
  }
  const groupChunks = [];
  for (let i = 0; i < chunks.length; i += groupSize) {
    groupChunks.push(chunks.slice(i, i + groupSize));
  }
  return groupChunks;
}
var import_express114, router114, NewAssetSchema, ExistingAssetRefSchema, AssetSchema, extractAssets_default;
var init_extractAssets = __esm({
  "src/routes/script/extractAssets.ts"() {
    "use strict";
    import_express114 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    init_dist22();
    init_userConfig();
    router114 = import_express114.default.Router();
    NewAssetSchema = external_exports.object({
      name: external_exports.string().describe("\u8D44\u4EA7\u540D\u79F0,\u4EC5\u4E3A\u540D\u79F0\u4E0D\u505A\u5176\u4ED6\u4EFB\u4F55\u8868\u8FF0"),
      desc: external_exports.string().describe("\u8D44\u4EA7\u63CF\u8FF0"),
      type: external_exports.enum(["role", "tool", "scene"]).describe("\u8D44\u4EA7\u7C7B\u578B"),
      scriptIds: external_exports.array(external_exports.number()).describe("\u4F7F\u7528\u8BE5\u8D44\u4EA7\u7684\u5267\u672Cid\u6570\u7EC4")
    });
    ExistingAssetRefSchema = external_exports.object({
      name: external_exports.string().describe("\u5DF2\u6709\u8D44\u4EA7\u7684\u540D\u79F0,\u5FC5\u987B\u4E0E\u5DF2\u6709\u8D44\u4EA7\u5217\u8868\u4E2D\u7684\u540D\u79F0\u5B8C\u5168\u4E00\u81F4"),
      scriptIds: external_exports.array(external_exports.number()).describe("\u4F7F\u7528\u8BE5\u8D44\u4EA7\u7684\u5267\u672Cid\u6570\u7EC4")
    });
    AssetSchema = external_exports.object({
      name: external_exports.string().describe("\u8D44\u4EA7\u540D\u79F0,\u4EC5\u4E3A\u540D\u79F0\u4E0D\u505A\u5176\u4ED6\u4EFB\u4F55\u8868\u8FF0"),
      desc: external_exports.string().describe("\u8D44\u4EA7\u63CF\u8FF0"),
      type: external_exports.enum(["role", "tool", "scene"]).describe("\u8D44\u4EA7\u7C7B\u578B")
    });
    extractAssets_default = router114.post(
      "/",
      validateFields({
        scriptIds: external_exports.array(external_exports.number()),
        projectId: external_exports.number(),
        groupSize: external_exports.number().min(1).optional()
      }),
      async (req, res) => {
        const { scriptIds, projectId, groupSize = 5 } = req.body;
        if (!scriptIds.length) return res.status(400).send(error50("\u8BF7\u5148\u9009\u62E9\u5267\u672C"));
        const scripts = await utils_default.db("o_script").whereIn("id", scriptIds);
        const scriptMap = new Map(scripts.map((s) => [s.id, s]));
        await utils_default.db("o_script").whereIn("id", scriptIds).update({
          extractState: 2
        });
        const errors = [];
        let successCount = 0;
        const scriptGroups = chunkArray(scriptIds, groupSize);
        async function persistGroupResult(result) {
          console.log("%c Line:84 \u{1F36A} result", "background:#6ec1c2", result);
          if (!result) return;
          const { batchScriptIds, newAssets, existingRefs } = result;
          if (!newAssets.length && !existingRefs.length) return;
          const existingAssets = await utils_default.db("o_assets").where("projectId", projectId).select("id", "name");
          const existingMap = new Map(existingAssets.map((a) => [a.name, a.id]));
          const toInsert = newAssets.filter((asset) => !existingMap.has(asset.name));
          if (toInsert.length) {
            await utils_default.db("o_assets").insert(
              toInsert.map((asset) => ({
                name: asset.name,
                type: asset.type,
                describe: asset.desc,
                projectId,
                startTime: Date.now()
              }))
            );
          }
          const allAssets = await utils_default.db("o_assets").where("projectId", projectId).select("id", "name");
          const nameToId = new Map(allAssets.map((a) => [a.name, a.id]));
          const scriptAssetRows = [];
          for (const asset of newAssets) {
            const assetId = nameToId.get(asset.name);
            if (assetId) {
              for (const sid of asset.scriptIds) {
                scriptAssetRows.push({ scriptId: sid, assetId });
              }
            }
          }
          for (const ref of existingRefs) {
            const assetId = nameToId.get(ref.name);
            if (assetId) {
              for (const sid of ref.scriptIds) {
                scriptAssetRows.push({ scriptId: sid, assetId });
              }
            }
          }
          const uniqueRows = [...new Map(scriptAssetRows.map((r) => [`${r.scriptId}_${r.assetId}`, r])).values()];
          await utils_default.db("o_scriptAssets").whereIn("scriptId", batchScriptIds).delete();
          if (uniqueRows.length) {
            await utils_default.db("o_scriptAssets").insert(uniqueRows);
          }
          await utils_default.db("o_script").whereIn("id", batchScriptIds).update({
            extractState: 1,
            errorReason: null
          });
        }
        res.send(success3("\u5F00\u59CB\u63D0\u53D6\u8D44\u4EA7"));
        function processGroup(group) {
          group.map(async (itemIds) => {
            const validScripts = [];
            for (const scriptIds2 of itemIds) {
              for (const scriptId of scriptIds2) {
                const script = scriptMap.get(scriptId);
                if (!script) {
                  errors.push({ scriptId, error: "\u672A\u627E\u5230\u5BF9\u5E94\u5267\u672C" });
                  await utils_default.db("o_script").where("id", scriptId).update({ extractState: -1, errorReason: "\u672A\u627E\u5230\u5BF9\u5E94\u5267\u672C" });
                } else {
                  const item = await utils_default.db("o_script").where("id", scriptId).select("extractState").first();
                  if (item?.extractState == 2) {
                    validScripts.push({ id: scriptId, script });
                  }
                }
              }
            }
            if (!validScripts.length) return;
            const validScriptIds = validScripts.map((v) => v.id);
            await utils_default.db("o_script").whereIn("id", validScriptIds).update({
              extractState: 0
              // 正在提取
            });
            const existingAssets = await utils_default.db("o_assets").where("projectId", projectId).select("name", "type");
            const existingAssetsList = existingAssets.map((a) => `${a.name}(${a.type})`).join("\u3001");
            const scriptsContent = validScripts.map(({ id, script }) => `===== \u3010\u5267\u672CID: ${id}\u3011${script.name || ""} =====
${script.content}`).join("\n\n");
            let collectedNew = [];
            let collectedExisting = [];
            try {
              const resultTool = tool({
                description: "\u8FD4\u56DE\u7ED3\u679C\u65F6\u5FC5\u987B\u8C03\u7528\u8FD9\u4E2A\u5DE5\u5177",
                inputSchema: jsonSchema(
                  external_exports.object({
                    newAssets: external_exports.array(NewAssetSchema).describe("\u65B0\u53D1\u73B0\u7684\u8D44\u4EA7\u5217\u8868\uFF08\u4E0D\u5728\u5DF2\u6709\u8D44\u4EA7\u5217\u8868\u4E2D\u7684\uFF09\uFF0C\u9700\u8981\u5B8C\u6574\u7684 prompt\u3001name\u3001desc\u3001type \u548C\u4F7F\u7528\u8BE5\u8D44\u4EA7\u7684 scriptIds"),
                    existingAssetRefs: external_exports.array(ExistingAssetRefSchema).describe("\u5DF2\u6709\u8D44\u4EA7\u7684\u5F15\u7528\u5217\u8868\uFF08\u5728\u5DF2\u6709\u8D44\u4EA7\u5217\u8868\u4E2D\u5DF2\u5B58\u5728\u7684\uFF09\uFF0C\u53EA\u9700\u7ED9\u51FA\u8D44\u4EA7\u540D\u79F0\u548C\u4F7F\u7528\u8BE5\u8D44\u4EA7\u7684 scriptIds")
                  }).toJSONSchema()
                ),
                execute: async ({ newAssets, existingAssetRefs }) => {
                  if (newAssets?.length) collectedNew = newAssets;
                  if (existingAssetRefs?.length) collectedExisting = existingAssetRefs;
                  return "\u65E0\u9700\u56DE\u590D\u7528\u6237\u4EFB\u4F55\u5185\u5BB9";
                }
              });
              const promptData = await getPromptForUser("scriptAssetExtraction");
              const scriptAssetExtraction = promptData?.data ?? void 0;
              const existingHint = existingAssetsList ? `

\u3010\u5DF2\u6709\u8D44\u4EA7\u5217\u8868\u3011\uFF1A${existingAssetsList}
\u5BF9\u4E8E\u5DF2\u6709\u8D44\u4EA7\uFF0C\u5982\u679C\u5728\u5267\u672C\u4E2D\u51FA\u73B0\uFF0C\u53EA\u9700\u5728 existingAssetRefs \u4E2D\u7ED9\u51FA\u8D44\u4EA7\u540D\u79F0\u548C\u5BF9\u5E94\u7684 scriptIds \u6570\u7EC4\u5373\u53EF\uFF0C\u65E0\u9700\u91CD\u590D\u751F\u6210 desc/type\u3002\u5BF9\u4E8E\u65B0\u53D1\u73B0\u7684\u8D44\u4EA7\uFF08\u4E0D\u5728\u5DF2\u6709\u5217\u8868\u4E2D\uFF09\uFF0C\u8BF7\u5728 newAssets \u4E2D\u7ED9\u51FA\u5B8C\u6574\u4FE1\u606F\u3002` : "";
              const output = await utils_default.Ai.Text("universalAi").invoke({
                messages: [
                  {
                    role: "system",
                    content: scriptAssetExtraction + "\n\n\u63D0\u53D6\u5267\u672C\u4E2D\u6D89\u53CA\u7684\u8D44\u4EA7\uFF08\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177\uFF09\uFF0C\u53C2\u8003\u6280\u80FD script_assets_extract \u89C4\u8303\uFF0C\u7ED3\u679C\u5FC5\u987B\u901A\u8FC7 resultTool \u5DE5\u5177\u8FD4\u56DE\u3002\n\n\u6CE8\u610F\uFF1A\u672C\u6B21\u4F1A\u540C\u65F6\u63D0\u4F9B\u591A\u96C6\u5267\u672C\uFF0C\u6BCF\u96C6\u5267\u672C\u4EE5 ===== \u3010\u5267\u672CID: xxx\u3011 ===== \u5206\u9694\u3002\u4F60\u9700\u8981\u5206\u6790\u6BCF\u96C6\u5267\u672C\u4F7F\u7528\u4E86\u54EA\u4E9B\u8D44\u4EA7\uFF0C\u5E76\u5728\u8F93\u51FA\u4E2D\u7528 scriptIds \u6570\u7EC4\u6807\u660E\u6BCF\u4E2A\u8D44\u4EA7\u5728\u54EA\u4E9B\u5267\u672C\u4E2D\u51FA\u73B0\u3002"
                  },
                  {
                    role: "user",
                    content: `\u5F53\u524D\u5DF2\u6709\u8D44\u4EA7\u5217\u8868\uFF1A${existingHint}

\u8BF7\u6839\u636E\u4EE5\u4E0B${validScripts.length}\u96C6\u5267\u672C\u63D0\u53D6\u5BF9\u5E94\u7684\u5267\u672C\u8D44\u4EA7\uFF08\u89D2\u8272\u3001\u573A\u666F\u3001\u9053\u5177\uFF09:

${scriptsContent}`
                  }
                ],
                tools: { resultTool }
              });
              await persistGroupResult({
                batchScriptIds: validScriptIds,
                newAssets: collectedNew,
                existingRefs: collectedExisting
              });
            } catch (e) {
              console.error(`[extractAssets] group=[${validScriptIds.join(",")}] \u63D0\u53D6\u5931\u8D25:`, e);
              for (const { id, script } of validScripts) {
                errors.push({ scriptId: id, error: (script.name || "") + ":" + utils_default.error(e).message });
                await utils_default.db("o_script").where("id", id).update({ extractState: -1, errorReason: utils_default.error(e).message });
              }
              return;
            }
            if (!collectedNew.length && !collectedExisting.length) {
              for (const { id } of validScripts) {
                errors.push({ scriptId: id, error: "AI \u672A\u8FD4\u56DE\u4EFB\u4F55\u8D44\u4EA7" });
                await utils_default.db("o_script").where("id", id).update({ extractState: -1, errorReason: "AI \u672A\u8FD4\u56DE\u4EFB\u4F55\u8D44\u4EA7" });
              }
              return;
            }
          });
        }
        processGroup(scriptGroups);
      }
    );
  }
});

// src/routes/script/getAiRegex.ts
var import_express115, router115, getAiRegex_default;
var init_getAiRegex = __esm({
  "src/routes/script/getAiRegex.ts"() {
    "use strict";
    import_express115 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router115 = import_express115.default.Router();
    getAiRegex_default = router115.post(
      "/",
      validateFields({
        content: external_exports.string()
      }),
      async (req, res) => {
        const { content } = req.body;
        const systemPrompt = `\u4F60\u662F\u4E00\u4E2A\u6B63\u5219\u8868\u8FBE\u5F0F\u4E13\u5BB6\u3002\u7528\u6237\u4F1A\u63D0\u4F9B\u4E00\u6BB5\u5267\u672C\u6587\u672C\uFF0C\u4F60\u9700\u8981\u5206\u6790\u5176\u4E2D\u7684\u96C6/\u7AE0\u8282\u5206\u9694\u6A21\u5F0F\uFF0C\u8FD4\u56DE\u4E00\u4E2AJavaScript\u6B63\u5219\u8868\u8FBE\u5F0F\u5B57\u7B26\u4E32\u3002

\u8981\u6C42\uFF1A
1. \u6B63\u5219\u5FC5\u987B\u5305\u542B\u4E24\u4E2A\u6355\u83B7\u7EC4\uFF1A\u7B2C\u4E00\u4E2A\u6355\u83B7\u7EC4\u5339\u914D\u96C6\u6570/\u7AE0\u8282\u7F16\u53F7\uFF08\u6570\u5B57\u6216\u4E2D\u6587\u6570\u5B57\uFF09\uFF0C\u7B2C\u4E8C\u4E2A\u6355\u83B7\u7EC4\u5339\u914D\u8BE5\u96C6\u7684\u6807\u9898/\u540D\u79F0\uFF08scriptName\uFF09\u3002
2. \u8FD4\u56DE\u683C\u5F0F\u4E3A /\u6B63\u5219\u8868\u8FBE\u5F0F/g\uFF0C\u4F8B\u5982\uFF1A/\u7B2Cs*([0-9\u4E00\u4E8C\u4E09\u56DB\u4E94\u516D\u4E03\u516B\u4E5D\u5341\u767E\u5343\u4E07]+)s*\u96C6s*([^
\r]*)/g
3. \u53EA\u8FD4\u56DE\u6B63\u5219\u8868\u8FBE\u5F0F\u5B57\u7B26\u4E32\u672C\u8EAB\uFF0C\u4E0D\u8981\u6709\u4EFB\u4F55\u5176\u4ED6\u89E3\u91CA\u6587\u5B57\u6216markdown\u683C\u5F0F\u3002
4. \u5982\u679C\u6587\u672C\u4E2D\u6CA1\u6709\u660E\u663E\u7684\u7AE0\u8282\u5206\u9694\u6A21\u5F0F\uFF0C\u8FD4\u56DE\u7A7A\u5B57\u7B26\u4E32\u3002`;
        const resText = await utils_default.Ai.Text("universalAi").invoke({
          system: systemPrompt,
          messages: [
            {
              role: "user",
              content: content.slice(0, 2e3)
            }
          ]
        });
        const result = (resText.text || "").trim();
        res.status(200).send(success3(result));
      }
    );
  }
});

// src/routes/script/getScrptApi.ts
var import_express116, router116, getScrptApi_default;
var init_getScrptApi = __esm({
  "src/routes/script/getScrptApi.ts"() {
    "use strict";
    import_express116 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router116 = import_express116.default.Router();
    getScrptApi_default = router116.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        name: external_exports.string().optional()
      }),
      async (req, res) => {
        const { projectId, name: name28 } = req.body;
        let query = utils_default.db("o_script").where("projectId", projectId).select("*");
        if (name28) {
          query = query.andWhere("name", "like", `%${name28}%`);
        }
        const data = await query;
        const assetsData = await utils_default.db("o_assets").leftJoin("o_scriptAssets", "o_assets.id", "o_scriptAssets.assetId").whereIn(
          "o_scriptAssets.scriptId",
          data.map((i) => i.id)
        ).select("o_assets.id", "o_assets.name", "o_scriptAssets.scriptId");
        const scriptAssetsMap = {};
        assetsData.forEach((i) => {
          if (scriptAssetsMap[i.scriptId]) {
            scriptAssetsMap[i.scriptId].push({ id: i.id, name: i.name });
          } else {
            scriptAssetsMap[i.scriptId] = [{ id: i.id, name: i.name }];
          }
        });
        const returnData = data.map((i) => ({
          id: i.id,
          name: i.name,
          content: i.content,
          extractState: i.extractState,
          errorReason: i.errorReason,
          createTime: i.createTime,
          relatedAssets: scriptAssetsMap[i.id] || []
        }));
        res.status(200).send(success3(returnData));
      }
    );
  }
});

// src/routes/script/pollScriptAssets.ts
var import_express117, router117, pollScriptAssets_default;
var init_pollScriptAssets = __esm({
  "src/routes/script/pollScriptAssets.ts"() {
    "use strict";
    import_express117 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router117 = import_express117.default.Router();
    pollScriptAssets_default = router117.post(
      "/",
      validateFields({
        ids: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { ids } = req.body;
        const data = await utils_default.db("o_script").whereIn("id", ids).whereNot("extractState", "\u751F\u6210\u4E2D").select("id", "extractState", "errorReason");
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/script/updateScript.ts
var import_express118, router118, updateScript_default;
var init_updateScript = __esm({
  "src/routes/script/updateScript.ts"() {
    "use strict";
    import_express118 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    router118 = import_express118.default.Router();
    updateScript_default = router118.post(
      "/",
      validateFields({
        id: external_exports.number(),
        name: external_exports.string(),
        content: external_exports.string(),
        assets: external_exports.array(external_exports.number())
      }),
      async (req, res) => {
        const { id, name: name28, content, assets } = req.body;
        await utils_default.db("o_script").where({ id }).update({
          name: name28,
          content
        });
        if (assets.length) {
          const assetsData = await utils_default.db("o_assets").whereIn("id", assets).select();
          await utils_default.db("o_scriptAssets").where({ scriptId: id }).delete();
          if (assetsData.length) {
            const insertData = assetsData.map((item) => {
              return {
                scriptId: id,
                assetId: item.id
              };
            });
            await utils_default.db("o_scriptAssets").insert(insertData);
          }
        }
        res.status(200).send(success3({ message: "\u7F16\u8F91\u5267\u672C\u6210\u529F" }));
      }
    );
  }
});

// src/routes/scriptAgent/getPlanData.ts
var import_express119, router119, getPlanData_default;
var init_getPlanData = __esm({
  "src/routes/scriptAgent/getPlanData.ts"() {
    "use strict";
    import_express119 = __toESM(require_express2());
    init_responseFormat();
    init_utils3();
    init_zod();
    init_middleware();
    router119 = import_express119.default.Router();
    getPlanData_default = router119.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        agentType: external_exports.enum(["scriptAgent"])
      }),
      async (req, res) => {
        const { projectId, agentType } = req.body;
        const row = await utils_default.db("o_agentWorkData").where({ projectId, key: agentType }).first();
        if (!row) {
          const [id] = await utils_default.db("o_agentWorkData").insert({
            projectId,
            key: agentType,
            data: JSON.stringify({
              storySkeleton: "",
              adaptationStrategy: ""
            })
          });
          return res.status(200).send(
            success3({
              data: {
                storySkeleton: "",
                adaptationStrategy: ""
              },
              id
            })
          );
        }
        const data = JSON.parse(row.data ?? "{}");
        data.script = await utils_default.db("o_script").where({ projectId }).select("id", "name", "content");
        res.status(200).send(success3({ data, id: row.id }));
      }
    );
  }
});

// src/routes/scriptAgent/setPlanData.ts
var import_express120, router120, setPlanData_default;
var init_setPlanData = __esm({
  "src/routes/scriptAgent/setPlanData.ts"() {
    "use strict";
    import_express120 = __toESM(require_express2());
    init_responseFormat();
    init_utils3();
    init_zod();
    init_middleware();
    router120 = import_express120.default.Router();
    setPlanData_default = router120.post(
      "/",
      validateFields({
        projectId: external_exports.number(),
        agentType: external_exports.enum(["scriptAgent"]),
        data: external_exports.object({
          storySkeleton: external_exports.string(),
          adaptationStrategy: external_exports.string()
        })
      }),
      async (req, res) => {
        const { projectId, agentType, data } = req.body;
        await utils_default.db("o_agentWorkData").where({ projectId, key: agentType }).update({
          data: JSON.stringify(data)
        });
        const script = data.script;
        await Promise.all(
          script.map(async (s) => {
            const row = await utils_default.db("o_script").where({ projectId, name: s.name }).first();
            if (row) {
              await utils_default.db("o_script").where({ id: row.id }).update({ content: s.content });
            } else {
              await utils_default.db("o_script").insert({ projectId, name: s.name, content: s.content });
            }
          })
        );
        res.status(200).send(success3());
      }
    );
  }
});

// src/routes/scriptAgent/updateData.ts
var import_express121, router121, updateData_default;
var init_updateData = __esm({
  "src/routes/scriptAgent/updateData.ts"() {
    "use strict";
    import_express121 = __toESM(require_express2());
    init_responseFormat();
    init_utils3();
    init_zod();
    init_middleware();
    router121 = import_express121.default.Router();
    updateData_default = router121.post(
      "/",
      validateFields({
        id: external_exports.number(),
        data: external_exports.object({
          storySkeleton: external_exports.string(),
          adaptationStrategy: external_exports.string(),
          script: external_exports.array(
            external_exports.object({
              id: external_exports.number(),
              content: external_exports.string()
            })
          )
        })
      }),
      async (req, res) => {
        const { id, data } = req.body;
        await utils_default.db("o_agentWorkData").where({ id }).update({
          data: JSON.stringify(data)
        });
        res.status(200).send(success3("\u66F4\u65B0\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/about/checkUpdate.ts
var import_express122, import_fs14, import_path21, router122, APP_VERSION2, checkUpdate_default;
var init_checkUpdate = __esm({
  "src/routes/setting/about/checkUpdate.ts"() {
    "use strict";
    import_express122 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_zod();
    import_fs14 = __toESM(require("fs"));
    import_path21 = __toESM(require("path"));
    router122 = import_express122.default.Router();
    APP_VERSION2 = (() => {
      if (true) {
        return "1.1.7";
      }
      const pkgPath = import_path21.default.resolve(process.cwd(), "package.json");
      const pkg = JSON.parse(import_fs14.default.readFileSync(pkgPath, "utf8"));
      return pkg.version;
    })();
    checkUpdate_default = router122.post(
      "/",
      validateFields({
        source: external_exports.enum(["toonflow", "github", "gitee", "atomgit"]),
        url: external_exports.url().nullable().optional()
      }),
      async (req, res) => {
        const { source, url: url4 } = req.body;
        const getUrl = url4 ?? "https://toonflow.oss-cn-beijing.aliyuncs.com/update.json";
        const versionInfo = await fetch(getUrl).then((res2) => res2.json());
        if (!versionInfo) return res.status(400).send(error50("\u65E0\u6CD5\u83B7\u53D6\u7248\u672C\u4FE1\u606F"));
        const { version: tagger, time: time4, data } = versionInfo;
        const sourceData = data[source];
        if (!sourceData) return res.status(400).send(error50("\u65E0\u6CD5\u83B7\u53D6\u8BE5\u6E90\u7684\u4E0B\u8F7D\u4FE1\u606F"));
        const platformType = {
          win32: "windows",
          darwin: "macos",
          linux: "linux"
        };
        const zipItem = sourceData.find((d) => d.type === "zip");
        const installerItem = sourceData.find((d) => d.type === platformType[process.platform]);
        const taggerList = tagger.split(".").map(Number);
        const currentVersionList = APP_VERSION2.split(".").map(Number);
        if (taggerList[0] > currentVersionList[0]) {
          if (!installerItem) return res.status(400).send(error50("\u8BE5\u6E90\u6682\u65E0\u9002\u7528\u4E8E\u5F53\u524D\u7CFB\u7EDF\u7684\u5B89\u88C5\u5305"));
          return res.status(200).send(success3({ needUpdate: true, latestVersion: tagger, reinstall: true, time: time4, url: installerItem.url, version: tagger }));
        }
        if (taggerList[1] > currentVersionList[1]) {
          if (!installerItem) return res.status(400).send(error50("\u8BE5\u6E90\u6682\u65E0\u9002\u7528\u4E8E\u5F53\u524D\u7CFB\u7EDF\u7684\u5B89\u88C5\u5305"));
          return res.status(200).send(success3({ needUpdate: true, latestVersion: tagger, reinstall: true, time: time4, url: installerItem.url, version: tagger }));
        }
        if (taggerList[2] > currentVersionList[2]) {
          if (!zipItem) return res.status(400).send(error50("\u8BE5\u6E90\u6682\u65E0\u589E\u91CF\u66F4\u65B0\u5305"));
          return res.status(200).send(success3({ needUpdate: true, latestVersion: tagger, reinstall: false, time: time4, url: zipItem.url, version: tagger }));
        }
        return res.status(200).send(success3({ needUpdate: false, latestVersion: tagger, reinstall: false, time: time4, version: tagger }));
      }
    );
  }
});

// src/routes/setting/about/downloadApp.ts
var import_express123, import_fs15, import_compressing2, router123, downloadApp_default;
var init_downloadApp = __esm({
  "src/routes/setting/about/downloadApp.ts"() {
    "use strict";
    import_express123 = __toESM(require_express2());
    init_zod();
    init_middleware();
    init_utils3();
    import_fs15 = __toESM(require("fs"));
    init_axios2();
    import_compressing2 = __toESM(require_compressing());
    init_responseFormat();
    router123 = import_express123.default.Router();
    downloadApp_default = router123.post(
      "/",
      validateFields({
        url: zod_default.url(),
        reinstall: zod_default.boolean(),
        version: zod_default.string()
      }),
      async (req, res) => {
        const { reinstall, url: url4, version: version3 } = req.body;
        if (reinstall) {
          res.status(200).send(success3("\u8BF7\u5728\u6D4F\u89C8\u5668\u4E2D\u624B\u52A8\u4E0B\u8F7D\u5E76\u5B89\u88C5\u6700\u65B0\u7248\u672C"));
        } else {
          const rootDir = utils_default.getPath(["temp"]);
          import_fs15.default.mkdirSync(rootDir, { recursive: true });
          const zip = await axios_default.get(url4, { responseType: "arraybuffer" }).then((res2) => res2.data);
          import_fs15.default.writeFileSync(`${rootDir}/latest.zip`, zip);
          await import_compressing2.default.zip.uncompress(`${rootDir}/latest.zip`, rootDir);
          const dataDir = utils_default.getPath();
          import_fs15.default.cpSync(rootDir, dataDir, { recursive: true, force: true });
          import_fs15.default.rmSync(rootDir, { recursive: true, force: true });
          res.status(200).send(success3(`\u66F4\u65B0${version3}\u6210\u529F\uFF0C5\u79D2\u540E\u91CD\u542F`));
        }
      }
    );
  }
});

// src/routes/setting/agentDeploy/agentSetKey.ts
var import_express124, router124, agentSetKey_default;
var init_agentSetKey = __esm({
  "src/routes/setting/agentDeploy/agentSetKey.ts"() {
    "use strict";
    import_express124 = __toESM(require_express2());
    init_responseFormat();
    init_utils3();
    init_zod();
    init_middleware();
    init_userConfig();
    router124 = import_express124.default.Router();
    agentSetKey_default = router124.post(
      "/",
      validateFields({
        key: external_exports.string().optional()
      }),
      async (req, res) => {
        const { key } = req.body;
        const userId = requireRequestUserId(req);
        const vendorConfigData = await getVendorConfigForUser("toonflow", userId);
        if (!vendorConfigData) return res.status(500).send(error50("\u672A\u627E\u5230\u8BE5\u4F9B\u5E94\u5546\u914D\u7F6E"));
        if (!vendorConfigData.inputValues) return res.status(500).send(error50("\u672A\u627E\u5230\u6A21\u578B\u914D\u7F6E\u6570\u636E"));
        const inputValue = parseJson(vendorConfigData.inputValues, {});
        inputValue.apiKey = key;
        await setUserVendorConfig(userId, "toonflow", {
          inputValues: JSON.stringify(inputValue),
          enable: 1
        });
        try {
          const resText = await utils_default.Ai.Text(`toonflow:claude-haiku-4-5-20251001`).invoke({
            prompt: "1+1\u7B49\u4E8E\u51E0\uFF1F,\u8BF7\u76F4\u63A5\u56DE\u7B542\uFF0C\u4E0D\u8981\u89E3\u91CA"
          });
          if (resText.text) {
            await setUserAgentDeploy(userId, "scriptAgent", {
              model: "claude-sonnet-4-6",
              modelName: "toonflow:claude-sonnet-4-6",
              vendorId: "toonflow"
            });
            await setUserAgentDeploy(userId, "productionAgent", {
              model: "claude-sonnet-4-6",
              modelName: "toonflow:claude-sonnet-4-6",
              vendorId: "toonflow"
            });
            await setUserAgentDeploy(userId, "universalAi", {
              model: "claude-haiku-4-5",
              modelName: "toonflow:claude-haiku-4-5-20251001",
              vendorId: "toonflow"
            });
            res.status(200).send(success3("\u4E00\u952E\u586B\u5165\u6210\u529F"));
          }
        } catch (err) {
          console.error(err);
          inputValue.apiKey = "";
          await setUserVendorConfig(userId, "toonflow", { inputValues: JSON.stringify(inputValue) });
          res.status(400).send(error50("KEY\u65E0\u6548\uFF0C\u8BF7\u91CD\u65B0\u8F93\u5165"));
        }
      }
    );
  }
});

// src/routes/setting/agentDeploy/deployAgentModel.ts
var import_express125, router125, deployAgentModel_default;
var init_deployAgentModel = __esm({
  "src/routes/setting/agentDeploy/deployAgentModel.ts"() {
    "use strict";
    import_express125 = __toESM(require_express2());
    init_responseFormat();
    init_utils3();
    init_zod();
    init_middleware();
    init_userConfig();
    router125 = import_express125.default.Router();
    deployAgentModel_default = router125.post(
      "/",
      validateFields({
        id: external_exports.number(),
        name: external_exports.string(),
        model: external_exports.string(),
        modelName: external_exports.string(),
        vendorId: external_exports.string().nullable(),
        desc: external_exports.string(),
        temperature: external_exports.number().optional(),
        maxOutputTokens: external_exports.number().optional()
      }),
      async (req, res) => {
        const { id, model, modelName, vendorId, temperature, maxOutputTokens } = req.body;
        const userId = requireRequestUserId(req);
        const baseDeploy = await utils_default.db("o_agentDeploy").where({ id }).first();
        if (!baseDeploy?.key) return res.status(400).send(error50("\u672A\u627E\u5230Agent\u914D\u7F6E\u6A21\u677F"));
        await setUserAgentDeploy(userId, baseDeploy.key, { model, modelName, vendorId, temperature, maxOutputTokens });
        res.status(200).send(success3("\u914D\u7F6E\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/agentDeploy/getAgentDeploy.ts
var import_express126, router126, getAgentDeploy_default;
var init_getAgentDeploy = __esm({
  "src/routes/setting/agentDeploy/getAgentDeploy.ts"() {
    "use strict";
    import_express126 = __toESM(require_express2());
    init_responseFormat();
    init_userConfig();
    router126 = import_express126.default.Router();
    getAgentDeploy_default = router126.post("/", async (req, res) => {
      const userId = requireRequestUserId(req);
      const allData = await getAllAgentDeployForUser(userId);
      const qrdinaryData = allData.filter((item) => !item.key?.includes(":"));
      const advancedData = allData.filter((item) => item.key?.includes(":"));
      res.status(200).send(success3({ qrdinaryData, advancedData }));
    });
  }
});

// src/routes/setting/agentDeploy/getAgentUseMode.ts
var import_express127, router127, getAgentUseMode_default;
var init_getAgentUseMode = __esm({
  "src/routes/setting/agentDeploy/getAgentUseMode.ts"() {
    "use strict";
    import_express127 = __toESM(require_express2());
    init_responseFormat();
    init_userConfig();
    router127 = import_express127.default.Router();
    getAgentUseMode_default = router127.get("/", async (req, res) => {
      const userId = requireRequestUserId(req);
      const useMode = await getUserSettingValue("agentUseMode", userId);
      res.status(200).send(success3(useMode || "0"));
    });
  }
});

// src/routes/setting/agentDeploy/updateUseMode.ts
var import_express128, router128, updateUseMode_default;
var init_updateUseMode = __esm({
  "src/routes/setting/agentDeploy/updateUseMode.ts"() {
    "use strict";
    import_express128 = __toESM(require_express2());
    init_zod();
    init_responseFormat();
    init_middleware();
    init_userConfig();
    router128 = import_express128.default.Router();
    updateUseMode_default = router128.post(
      "/",
      validateFields({
        agentUseMode: external_exports.string()
      }),
      async (req, res) => {
        const { agentUseMode } = req.body;
        const userId = requireRequestUserId(req);
        await setUserSettingValue(userId, "agentUseMode", agentUseMode);
        res.status(200).send(success3("\u4FDD\u5B58\u8BBE\u7F6E\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/dbConfig/clearData.ts
var import_express129, router129, clearData_default;
var init_clearData = __esm({
  "src/routes/setting/dbConfig/clearData.ts"() {
    "use strict";
    import_express129 = __toESM(require_express2());
    init_responseFormat();
    init_db();
    init_initDB();
    router129 = import_express129.default.Router();
    clearData_default = router129.get("/", async (req, res) => {
      try {
        const tables = await db.raw(
          `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'knex_%'`
        );
        await db.raw("PRAGMA foreign_keys = OFF");
        for (const table of tables) {
          await db.schema.dropTableIfExists(table.name);
        }
        await db.raw("PRAGMA foreign_keys = ON");
        await initDB_default(db);
        res.status(200).send(success3("\u6570\u636E\u5E93\u5DF2\u6E05\u7A7A\u5E76\u91CD\u65B0\u521D\u59CB\u5316"));
      } catch (err) {
        res.status(500).send(error50(err?.message || "\u6E05\u9664\u5931\u8D25"));
      }
    });
  }
});

// src/routes/setting/dbConfig/clearTable.ts
var import_express130, router130, clearTable_default;
var init_clearTable = __esm({
  "src/routes/setting/dbConfig/clearTable.ts"() {
    "use strict";
    import_express130 = __toESM(require_express2());
    init_responseFormat();
    init_db();
    router130 = import_express130.default.Router();
    clearTable_default = router130.post("/", async (req, res) => {
      try {
        const { tableName } = req.body;
        if (!tableName || typeof tableName !== "string") {
          return res.status(400).send(error50("\u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8868\u540D"));
        }
        const tableExists = await db.raw(
          `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
          [tableName]
        );
        if (tableExists.length === 0) {
          return res.status(400).send(error50("\u8868\u4E0D\u5B58\u5728"));
        }
        await db.raw(`DELETE FROM "${tableName}"`);
        res.status(200).send(success3(`\u8868 ${tableName} \u5DF2\u6E05\u7A7A`));
      } catch (err) {
        res.status(500).send(error50(err?.message || "\u6E05\u7A7A\u8868\u5931\u8D25"));
      }
    });
  }
});

// src/routes/setting/dbConfig/dbInfo.ts
var import_express131, router131, dbInfo_default;
var init_dbInfo = __esm({
  "src/routes/setting/dbConfig/dbInfo.ts"() {
    "use strict";
    import_express131 = __toESM(require_express2());
    init_responseFormat();
    init_db();
    router131 = import_express131.default.Router();
    dbInfo_default = router131.get("/", async (req, res) => {
      try {
        const tables = await db.raw(
          `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'knex_%'`
        );
        const tableInfo = [];
        for (const table of tables) {
          const countResult = await db.raw(`SELECT COUNT(*) as count FROM "${table.name}"`);
          tableInfo.push({
            name: table.name,
            rowCount: countResult[0]?.count ?? 0
          });
        }
        res.status(200).send(success3(tableInfo));
      } catch (err) {
        res.status(500).send(error50(err?.message || "\u83B7\u53D6\u6570\u636E\u5E93\u4FE1\u606F\u5931\u8D25"));
      }
    });
  }
});

// src/routes/setting/dbConfig/exportData.ts
var import_express132, router132, exportData_default;
var init_exportData = __esm({
  "src/routes/setting/dbConfig/exportData.ts"() {
    "use strict";
    import_express132 = __toESM(require_express2());
    init_responseFormat();
    init_db();
    router132 = import_express132.default.Router();
    exportData_default = router132.get("/", async (req, res) => {
      try {
        const tables = await db.raw(
          `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'knex_%'`
        );
        const data = {};
        for (const table of tables) {
          data[table.name] = await db.raw(`SELECT * FROM "${table.name}"`);
        }
        const exportData = {
          exportTime: Date.now(),
          tables: data
        };
        res.setHeader("Content-Type", "application/json");
        res.setHeader("Content-Disposition", `attachment; filename=toonflow-backup-${Date.now()}.json`);
        res.status(200).send(JSON.stringify(exportData, null, 2));
      } catch (err) {
        res.status(500).send(error50(err?.message || "\u5BFC\u51FA\u5931\u8D25"));
      }
    });
  }
});

// src/routes/setting/dbConfig/importData.ts
var import_express133, router133, importData_default;
var init_importData = __esm({
  "src/routes/setting/dbConfig/importData.ts"() {
    "use strict";
    import_express133 = __toESM(require_express2());
    init_responseFormat();
    init_db();
    init_initDB();
    router133 = import_express133.default.Router();
    importData_default = router133.post("/", async (req, res) => {
      try {
        const { tables: importTables } = req.body;
        if (!importTables || typeof importTables !== "object") {
          return res.status(400).send(error50("\u65E0\u6548\u7684\u5BFC\u5165\u6570\u636E\u683C\u5F0F"));
        }
        const existingTables = await db.raw(
          `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'knex_%'`
        );
        await db.raw("PRAGMA foreign_keys = OFF");
        for (const table of existingTables) {
          await db.schema.dropTableIfExists(table.name);
        }
        await db.raw("PRAGMA foreign_keys = ON");
        await initDB_default(db);
        await db.raw("PRAGMA foreign_keys = OFF");
        for (const [tableName, rows] of Object.entries(importTables)) {
          if (!Array.isArray(rows) || rows.length === 0) continue;
          const tableExists = await db.raw(
            `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
            [tableName]
          );
          if (tableExists.length === 0) continue;
          await db.raw(`DELETE FROM "${tableName}"`);
          for (let i = 0; i < rows.length; i += 100) {
            const batch = rows.slice(i, i + 100);
            await db(tableName).insert(batch);
          }
        }
        await db.raw("PRAGMA foreign_keys = ON");
        res.status(200).send(success3("\u6570\u636E\u5E93\u5BFC\u5165\u6210\u529F"));
      } catch (err) {
        res.status(500).send(error50(err?.message || "\u5BFC\u5165\u5931\u8D25"));
      }
    });
  }
});

// src/routes/setting/dev/getSwitchAiDevTool.ts
var import_express134, router134, getSwitchAiDevTool_default;
var init_getSwitchAiDevTool = __esm({
  "src/routes/setting/dev/getSwitchAiDevTool.ts"() {
    "use strict";
    import_express134 = __toESM(require_express2());
    init_responseFormat();
    init_userConfig();
    router134 = import_express134.default.Router();
    getSwitchAiDevTool_default = router134.get("/", async (req, res) => {
      const userId = requireRequestUserId(req);
      const switchAiDevTool = await getUserSettingValue("switchAiDevTool", userId);
      res.status(200).send(success3(switchAiDevTool || "0"));
    });
  }
});

// src/routes/setting/dev/updateSwitchAiDevTool.ts
var import_express135, router135, updateSwitchAiDevTool_default;
var init_updateSwitchAiDevTool = __esm({
  "src/routes/setting/dev/updateSwitchAiDevTool.ts"() {
    "use strict";
    import_express135 = __toESM(require_express2());
    init_zod();
    init_responseFormat();
    init_middleware();
    init_userConfig();
    router135 = import_express135.default.Router();
    updateSwitchAiDevTool_default = router135.post(
      "/",
      validateFields({
        switchAiDevTool: external_exports.string()
      }),
      async (req, res) => {
        const { switchAiDevTool } = req.body;
        const userId = requireRequestUserId(req);
        await setUserSettingValue(userId, "switchAiDevTool", switchAiDevTool);
        res.status(200).send(success3("\u4FDD\u5B58\u8BBE\u7F6E\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/fileManagement/openFolder.ts
var import_express136, import_child_process, router136, openFolder_default;
var init_openFolder = __esm({
  "src/routes/setting/fileManagement/openFolder.ts"() {
    "use strict";
    import_express136 = __toESM(require_express2());
    init_zod();
    import_child_process = require("child_process");
    init_responseFormat();
    init_middleware();
    init_getPath();
    init_utils3();
    router136 = import_express136.default.Router();
    openFolder_default = router136.post(
      "/",
      validateFields({
        path: external_exports.string()
      }),
      async (req, res) => {
        if (!isEletron()) {
          return res.status(400).send(error50("\u4EC5\u652F\u6301\u5BA2\u6237\u7AEF\u6253\u5F00\u6587\u4EF6\u5939"));
        }
        const { path: folderPath } = req.body;
        const platform = process.platform;
        const target = utils_default.getPath(folderPath);
        const cmd = platform === "win32" ? `explorer "${target}"` : platform === "darwin" ? `open "${target}"` : `xdg-open "${target}"`;
        (0, import_child_process.exec)(cmd, (err) => {
          if (err) {
            return res.status(200).send(error50(err.message));
          }
          res.status(200).send(success3("\u6253\u5F00\u6587\u4EF6\u5939\u6210\u529F"));
        });
      }
    );
  }
});

// src/routes/setting/getTextModel.ts
var import_express137, router137, getTextModel_default;
var init_getTextModel = __esm({
  "src/routes/setting/getTextModel.ts"() {
    "use strict";
    import_express137 = __toESM(require_express2());
    init_responseFormat();
    router137 = import_express137.default.Router();
    getTextModel_default = router137.post(
      "/",
      async (req, res) => {
        res.status(200).send(success3("123"));
      }
    );
  }
});

// src/routes/setting/loginConfig/getUser.ts
var import_express138, router138, getUser_default;
var init_getUser = __esm({
  "src/routes/setting/loginConfig/getUser.ts"() {
    "use strict";
    import_express138 = __toESM(require_express2());
    init_utils3();
    init_auth();
    init_responseFormat();
    router138 = import_express138.default.Router();
    getUser_default = router138.get("/", async (req, res) => {
      const user = getCurrentUser(req);
      const data = await utils_default.db("o_user").where("id", user.id).select("id", "name", "phone").first();
      res.status(200).send(success3(data ? publicUser(data) : null));
    });
  }
});

// src/routes/setting/loginConfig/updateUserPwd.ts
var import_express139, router139, updateUserPwd_default;
var init_updateUserPwd = __esm({
  "src/routes/setting/loginConfig/updateUserPwd.ts"() {
    "use strict";
    import_express139 = __toESM(require_express2());
    init_utils3();
    init_zod();
    init_responseFormat();
    init_middleware();
    init_auth();
    init_password();
    router139 = import_express139.default.Router();
    updateUserPwd_default = router139.post(
      "/",
      validateFields({
        name: external_exports.string(),
        password: external_exports.string().optional().nullable(),
        id: external_exports.number().optional().nullable()
      }),
      async (req, res) => {
        const user = getCurrentUser(req);
        const name28 = String(req.body.name || "").trim();
        const password = String(req.body.password || "");
        if (password && (password.length < 6 || password.length > 64)) {
          return res.status(400).send(error50("\u5BC6\u7801\u957F\u5EA6\u9700\u4E3A 6-64 \u4F4D"));
        }
        const exists = await utils_default.db("o_user").where("name", name28).whereNot("id", user.id).first();
        if (exists) return res.status(400).send(error50("\u7528\u6237\u540D\u5DF2\u5B58\u5728"));
        const updateData = { name: name28 };
        if (password) updateData.password = await hashPassword(password);
        await utils_default.db("o_user").where("id", user.id).update(updateData);
        res.status(200).send(success3("\u4FDD\u5B58\u8BBE\u7F6E\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/memoryConfig/delAllMemory.ts
var import_express140, router140, delAllMemory_default;
var init_delAllMemory = __esm({
  "src/routes/setting/memoryConfig/delAllMemory.ts"() {
    "use strict";
    import_express140 = __toESM(require_express2());
    init_responseFormat();
    init_utils3();
    init_userConfig();
    router140 = import_express140.default.Router();
    delAllMemory_default = router140.post("/", async (req, res) => {
      const userId = requireRequestUserId(req);
      const projectIds = (await utils_default.db("o_project").where({ userId }).select("id")).map((item) => item.id).filter(Boolean);
      for (const projectId of projectIds) {
        await utils_default.db("memories").where("isolationKey", "like", `${projectId}:%`).del();
      }
      res.status(200).send(success3(true));
    });
  }
});

// src/routes/setting/memoryConfig/getMemory.ts
var import_express141, router141, getMemory_default2;
var init_getMemory2 = __esm({
  "src/routes/setting/memoryConfig/getMemory.ts"() {
    "use strict";
    import_express141 = __toESM(require_express2());
    init_responseFormat();
    init_userConfig();
    router141 = import_express141.default.Router();
    getMemory_default2 = router141.get("/", async (req, res) => {
      const userId = requireRequestUserId(req);
      const keys2 = [
        "messagesPerSummary",
        "shortTermLimit",
        "summaryMaxLength",
        "summaryLimit",
        "ragLimit",
        "deepRetrieveSummaryLimit",
        "modelOnnxFile",
        "modelDtype"
      ];
      const settingData = await Promise.all(keys2.map(async (key) => ({ key, value: await getUserSettingValue(key, userId) })));
      if (!settingData) return res.status(400).send(error50(`\u83B7\u53D6\u8BB0\u5FC6\u914D\u7F6E\u5931\u8D25`));
      const memoryObj = {};
      settingData.forEach((i) => {
        if (i.key && i.value) {
          let value = i.value;
          if (i.key == "modelOnnxFile") {
            value = JSON.parse(i.value);
          } else if (i.key != "modelDtype") {
            value = Number(value);
          }
          memoryObj[i.key] = value;
        }
      });
      res.status(200).send(success3({ ...memoryObj }));
    });
  }
});

// src/routes/setting/memoryConfig/sureMemory.ts
var import_express142, router142, sureMemory_default;
var init_sureMemory = __esm({
  "src/routes/setting/memoryConfig/sureMemory.ts"() {
    "use strict";
    import_express142 = __toESM(require_express2());
    init_zod();
    init_responseFormat();
    init_middleware();
    init_userConfig();
    router142 = import_express142.default.Router();
    sureMemory_default = router142.post(
      "/",
      validateFields({
        messagesPerSummary: external_exports.number(),
        shortTermLimit: external_exports.number(),
        summaryMaxLength: external_exports.number(),
        summaryLimit: external_exports.number(),
        ragLimit: external_exports.number(),
        deepRetrieveSummaryLimit: external_exports.number(),
        modelOnnxFile: external_exports.array(external_exports.string()),
        modelDtype: external_exports.string()
      }),
      async (req, res) => {
        const { messagesPerSummary, shortTermLimit, summaryMaxLength, summaryLimit, ragLimit, deepRetrieveSummaryLimit, modelOnnxFile, modelDtype } = req.body;
        const userId = requireRequestUserId(req);
        const upsert2 = async (key, value) => {
          await setUserSettingValue(userId, key, value);
        };
        await upsert2("messagesPerSummary", String(messagesPerSummary));
        await upsert2("shortTermLimit", String(shortTermLimit));
        await upsert2("summaryMaxLength", String(summaryMaxLength));
        await upsert2("summaryLimit", String(summaryLimit));
        await upsert2("ragLimit", String(ragLimit));
        await upsert2("deepRetrieveSummaryLimit", String(deepRetrieveSummaryLimit));
        await upsert2("modelOnnxFile", JSON.stringify(modelOnnxFile));
        await upsert2("modelDtype", modelDtype);
        res.status(200).send(success3("\u4FDD\u5B58\u8BBE\u7F6E\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/modelMap/bindingPrompt.ts
var import_express143, router143, bindingPrompt_default;
var init_bindingPrompt = __esm({
  "src/routes/setting/modelMap/bindingPrompt.ts"() {
    "use strict";
    import_express143 = __toESM(require_express2());
    init_responseFormat();
    init_zod();
    init_middleware();
    init_userConfig();
    router143 = import_express143.default.Router();
    bindingPrompt_default = router143.post(
      "/",
      validateFields({
        vendorId: external_exports.string(),
        model: external_exports.string(),
        path: external_exports.string(),
        fileName: external_exports.string()
      }),
      async (req, res) => {
        const { vendorId, model, path: path33, fileName } = req.body;
        const userId = requireRequestUserId(req);
        await setUserModelPromptBinding(userId, vendorId, model, { fileName, path: path33 });
        res.status(200).send(success3("\u7ED1\u5B9A\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/modelMap/deletePrompt.ts
var import_express144, import_promises7, import_path22, router144, deletePrompt_default;
var init_deletePrompt = __esm({
  "src/routes/setting/modelMap/deletePrompt.ts"() {
    "use strict";
    import_express144 = __toESM(require_express2());
    init_responseFormat();
    init_zod();
    init_middleware();
    import_promises7 = __toESM(require("fs/promises"));
    import_path22 = __toESM(require("path"));
    init_userConfig();
    init_userStorage();
    router144 = import_express144.default.Router();
    deletePrompt_default = router144.post(
      "/",
      validateFields({
        path: external_exports.string()
      }),
      async (req, res) => {
        const { path: filePath } = req.body;
        const userId = requireRequestUserId(req);
        const modelPromptRoot = getUserModelPromptRoot(userId);
        const resolvedRoot = import_path22.default.resolve(modelPromptRoot);
        const resolvedFile = import_path22.default.resolve(modelPromptRoot, filePath);
        if (!resolvedFile.startsWith(resolvedRoot + import_path22.default.sep)) {
          return res.status(400).send(error50("\u975E\u6CD5\u8DEF\u5F84"));
        }
        try {
          await import_promises7.default.access(resolvedFile);
        } catch {
          return res.status(404).send(error50("\u6587\u4EF6\u4E0D\u5B58\u5728"));
        }
        await import_promises7.default.unlink(resolvedFile);
        res.status(200).send(success3("\u5220\u9664\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/modelMap/getImageAndVideoModel.ts
var import_express145, router145, getImageAndVideoModel_default;
var init_getImageAndVideoModel = __esm({
  "src/routes/setting/modelMap/getImageAndVideoModel.ts"() {
    "use strict";
    import_express145 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_userConfig();
    router145 = import_express145.default.Router();
    getImageAndVideoModel_default = router145.post("/", async (req, res) => {
      const userId = requireRequestUserId(req);
      const vendorIds = await getEnabledVendorIdsForUser(userId);
      if (!vendorIds.length) {
        return res.status(404).send({ error: "\u6A21\u578B\u672A\u627E\u5230" });
      }
      const data = await Promise.all(
        vendorIds.map(async (vendorId) => {
          const vendor = utils_default.vendor.getVendor(vendorId);
          const promptList = await getModelPromptBindingsForUser(vendor.id, userId);
          const promptMap = new Map(promptList.map((p3) => [p3.model, { fileName: p3.fileName, path: p3.path }]));
          const models = await utils_default.vendor.getModelList(vendorId);
          const filteredModels = models.filter((m) => m.type === "video").map((m) => ({
            name: m.name,
            type: m.type,
            model: m.modelName,
            ...promptMap.get(m.modelName) ? { ...promptMap.get(m.modelName) } : {}
          }));
          return {
            id: vendorId,
            name: vendor.name,
            promptList: filteredModels
          };
        })
      );
      res.status(200).send(success3(data));
    });
  }
});

// src/routes/setting/modelMap/getPromptList.ts
var import_express146, import_fast_glob3, import_promises8, import_path23, router146, getPromptList_default;
var init_getPromptList = __esm({
  "src/routes/setting/modelMap/getPromptList.ts"() {
    "use strict";
    import_express146 = __toESM(require_express2());
    init_responseFormat();
    import_fast_glob3 = __toESM(require_out4());
    import_promises8 = __toESM(require("fs/promises"));
    import_path23 = __toESM(require("path"));
    init_userConfig();
    init_userStorage();
    router146 = import_express146.default.Router();
    getPromptList_default = router146.get("/", async (req, res) => {
      const userId = requireRequestUserId(req);
      const modelPromptRoot = getUserModelPromptRoot(userId);
      await import_promises8.default.mkdir(modelPromptRoot, { recursive: true });
      const entries = await (0, import_fast_glob3.default)("**/*.md", {
        cwd: modelPromptRoot.replace(/\\/g, "/"),
        onlyFiles: true
      });
      const result = await Promise.all(
        entries.map(async (entry) => {
          const fullPath = import_path23.default.join(modelPromptRoot, entry);
          const content = await import_promises8.default.readFile(fullPath, "utf-8");
          const name28 = import_path23.default.basename(entry, ".md");
          const type = entry.includes("/") ? entry.split("/")[0] : "";
          return { path: entry, name: name28, type, data: content };
        })
      );
      res.status(200).send(success3(result));
    });
  }
});

// src/routes/setting/modelMap/savePrompt.ts
var import_express147, import_promises9, import_path24, router147, savePrompt_default;
var init_savePrompt = __esm({
  "src/routes/setting/modelMap/savePrompt.ts"() {
    "use strict";
    import_express147 = __toESM(require_express2());
    init_responseFormat();
    init_zod();
    init_middleware();
    import_promises9 = __toESM(require("fs/promises"));
    import_path24 = __toESM(require("path"));
    init_userConfig();
    init_userStorage();
    router147 = import_express147.default.Router();
    savePrompt_default = router147.post(
      "/",
      validateFields({
        name: external_exports.string().min(1),
        data: external_exports.string(),
        type: external_exports.enum(["image", "video"])
      }),
      async (req, res) => {
        const { name: name28, data, type } = req.body;
        const userId = requireRequestUserId(req);
        const modelPromptRoot = getUserModelPromptRoot(userId);
        const dir = import_path24.default.join(modelPromptRoot, type);
        await import_promises9.default.mkdir(dir, { recursive: true });
        const filePath = import_path24.default.join(dir, `${name28}.md`);
        await import_promises9.default.writeFile(filePath, data, "utf-8");
        res.status(200).send(success3("\u4FDD\u5B58\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/modelMap/updatePrompt.ts
var import_express148, import_promises10, import_path25, router148, updatePrompt_default;
var init_updatePrompt = __esm({
  "src/routes/setting/modelMap/updatePrompt.ts"() {
    "use strict";
    import_express148 = __toESM(require_express2());
    init_responseFormat();
    init_zod();
    init_middleware();
    import_promises10 = __toESM(require("fs/promises"));
    import_path25 = __toESM(require("path"));
    init_userConfig();
    init_userStorage();
    router148 = import_express148.default.Router();
    updatePrompt_default = router148.post(
      "/",
      validateFields({
        name: external_exports.string().min(1),
        data: external_exports.string(),
        type: external_exports.enum(["image", "video"])
      }),
      async (req, res) => {
        const { name: name28, data, type } = req.body;
        const userId = requireRequestUserId(req);
        const modelPromptRoot = getUserModelPromptRoot(userId);
        const filePath = import_path25.default.join(modelPromptRoot, type, `${name28}.md`);
        const resolvedRoot = import_path25.default.resolve(modelPromptRoot);
        const resolvedFile = import_path25.default.resolve(filePath);
        if (!resolvedFile.startsWith(resolvedRoot + import_path25.default.sep)) {
          return res.status(400).send(error50("\u975E\u6CD5\u8DEF\u5F84"));
        }
        try {
          await import_promises10.default.access(resolvedFile);
        } catch {
          return res.status(404).send(error50("\u6587\u4EF6\u4E0D\u5B58\u5728"));
        }
        await import_promises10.default.writeFile(resolvedFile, data, "utf-8");
        res.status(200).send(success3("\u66F4\u65B0\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/promptManage/getPrompt.ts
var import_express149, router149, getPrompt_default;
var init_getPrompt = __esm({
  "src/routes/setting/promptManage/getPrompt.ts"() {
    "use strict";
    import_express149 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_userConfig();
    router149 = import_express149.default.Router();
    getPrompt_default = router149.post("/", async (req, res) => {
      const userId = requireRequestUserId(req);
      const list2 = await utils_default.db("o_prompt").select("*");
      const userPrompts = await utils_default.db("o_userPrompt").where({ userId }).select("*");
      const userPromptMap = new Map(userPrompts.map((item) => [item.promptId, item.useData]));
      const data = await Promise.all(
        list2.map(async (item) => {
          const userData = item.id ? userPromptMap.get(item.id) : void 0;
          return {
            ...item,
            useData: userData ?? null,
            data: userData ?? item.data
          };
        })
      );
      res.status(200).send(success3(data));
    });
  }
});

// src/routes/setting/promptManage/updatePrompt.ts
var import_express150, router150, updatePrompt_default2;
var init_updatePrompt2 = __esm({
  "src/routes/setting/promptManage/updatePrompt.ts"() {
    "use strict";
    import_express150 = __toESM(require_express2());
    init_zod();
    init_responseFormat();
    init_middleware();
    init_userConfig();
    router150 = import_express150.default.Router();
    updatePrompt_default2 = router150.post(
      "/",
      validateFields({
        id: external_exports.number()
      }),
      async (req, res) => {
        const { id, data } = req.body;
        const userId = requireRequestUserId(req);
        await setUserPrompt(userId, id, data);
        res.status(200).send(success3(123));
      }
    );
  }
});

// src/routes/setting/skillManagement/getSkillContent.ts
var import_express151, import_path26, fs29, router151, getSkillContent_default;
var init_getSkillContent = __esm({
  "src/routes/setting/skillManagement/getSkillContent.ts"() {
    "use strict";
    import_express151 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_zod();
    init_is_path_inside();
    init_utils3();
    import_path26 = __toESM(require("path"));
    fs29 = __toESM(require("fs"));
    router151 = import_express151.default.Router();
    getSkillContent_default = router151.post(
      "/",
      validateFields({
        path: external_exports.string()
      }),
      async (req, res) => {
        const { path: path33 } = req.body;
        const skillsRoot = utils_default.getPath(["skills"]);
        const filePath = import_path26.default.join(skillsRoot, path33);
        if (!isPathInside(filePath, skillsRoot)) {
          return res.status(400).send(error50("\u65E0\u6548\u7684\u8DEF\u5F84"));
        }
        const raw = await fs29.promises.readFile(filePath, "utf-8");
        res.status(200).send(success3(raw));
      }
    );
  }
});

// src/routes/setting/skillManagement/getSkillList.ts
var import_express152, import_fast_glob4, router152, getSkillList_default;
var init_getSkillList = __esm({
  "src/routes/setting/skillManagement/getSkillList.ts"() {
    "use strict";
    import_express152 = __toESM(require_express2());
    init_responseFormat();
    import_fast_glob4 = __toESM(require_out4());
    init_utils3();
    router152 = import_express152.default.Router();
    getSkillList_default = router152.post("/", async (req, res) => {
      const skillsRoot = utils_default.getPath(["skills"]);
      const entries = await (0, import_fast_glob4.default)("**/*.md", {
        cwd: skillsRoot.replace(/\\/g, "/"),
        onlyFiles: true
      });
      res.status(200).send(success3(entries));
    });
  }
});

// src/routes/setting/skillManagement/saveSkillContent.ts
var import_express153, import_path27, fs30, router153, saveSkillContent_default;
var init_saveSkillContent = __esm({
  "src/routes/setting/skillManagement/saveSkillContent.ts"() {
    "use strict";
    import_express153 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_zod();
    init_is_path_inside();
    init_utils3();
    import_path27 = __toESM(require("path"));
    fs30 = __toESM(require("fs"));
    router153 = import_express153.default.Router();
    saveSkillContent_default = router153.post(
      "/",
      validateFields({
        path: external_exports.string(),
        content: external_exports.string()
      }),
      async (req, res) => {
        const { path: path33, content } = req.body;
        const skillsRoot = utils_default.getPath(["skills"]);
        const filePath = import_path27.default.join(skillsRoot, path33);
        if (!isPathInside(filePath, skillsRoot)) {
          return res.status(400).send(error50("\u65E0\u6548\u7684\u8DEF\u5F84"));
        }
        if (!fs30.existsSync(filePath)) {
          return res.status(400).send(error50("\u6587\u4EF6\u4E0D\u5B58\u5728"));
        }
        const raw = await fs30.promises.writeFile(filePath, content, "utf-8");
        res.status(200).send(success3(raw));
      }
    );
  }
});

// src/routes/setting/vendorConfig/addVendor.ts
var import_express154, import_sucrase4, router154, vendorConfigSchema, addVendor_default;
var init_addVendor = __esm({
  "src/routes/setting/vendorConfig/addVendor.ts"() {
    "use strict";
    import_express154 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_utils3();
    init_zod();
    import_sucrase4 = __toESM(require_dist5());
    router154 = import_express154.default.Router();
    vendorConfigSchema = external_exports.object({
      id: external_exports.string(),
      author: external_exports.string(),
      description: external_exports.string().optional(),
      name: external_exports.string(),
      icon: external_exports.string().optional(),
      inputs: external_exports.array(
        external_exports.object({
          key: external_exports.string(),
          label: external_exports.string(),
          type: external_exports.enum(["text", "password", "url"]),
          required: external_exports.boolean(),
          placeholder: external_exports.string().optional()
        })
      ),
      inputValues: external_exports.record(external_exports.string(), external_exports.string()),
      models: external_exports.array(
        external_exports.discriminatedUnion("type", [
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("text"),
            think: external_exports.boolean()
          }),
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("image"),
            mode: external_exports.array(external_exports.enum(["text", "singleImage", "multiReference"]))
          }),
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("video"),
            mode: external_exports.array(
              external_exports.union([
                external_exports.enum(["singleImage", "startEndRequired", "endFrameOptional", "startFrameOptional", "text", "audioReference", "videoReference"]),
                external_exports.array(external_exports.string().regex(/^(videoReference|imageReference|audioReference):\d+$/))
              ])
            ),
            audio: external_exports.union([external_exports.literal("optional"), external_exports.boolean()]),
            durationResolutionMap: external_exports.array(
              external_exports.object({
                duration: external_exports.array(external_exports.number()),
                resolution: external_exports.array(external_exports.string())
              })
            )
          })
        ])
      )
    });
    addVendor_default = router154.post(
      "/",
      validateFields({
        tsCode: external_exports.string()
      }),
      async (req, res) => {
        const { tsCode } = req.body;
        const jsCode = (0, import_sucrase4.transform)(tsCode, { transforms: ["typescript"] }).code;
        const exports2 = utils_default.vm(jsCode);
        if (!exports2) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FA\u5BF9\u8C61"));
        if (!exports2.textRequest) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FA\u6587\u672C\u8BF7\u6C42\u5BF9\u8C61"));
        if (!exports2.imageRequest) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FA\u56FE\u50CF\u8BF7\u6C42\u5BF9\u8C61"));
        if (!exports2.videoRequest) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FA\u89C6\u9891\u8BF7\u6C42\u5BF9\u8C61"));
        if (!exports2.vendor) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FAvendor\u5BF9\u8C61"));
        const vendor = exports2.vendor;
        const result = vendorConfigSchema.safeParse(vendor);
        if (!result.success) {
          const issueLines = result.error.issues.map((issue3, index) => {
            const path33 = issue3.path.length ? issue3.path.join(".") : "root";
            let detail = issue3.message;
            if (issue3.code === "invalid_union") {
              const unionDetails = [
                ...new Set(
                  issue3.errors.flat().map((e) => e.message).filter(Boolean)
                )
              ];
              if (unionDetails.length > 0) {
                detail = `${issue3.message}\uFF08${unionDetails.join("\uFF1B")}\uFF09`;
              }
            }
            return `${index + 1}. ${path33}: ${detail}`;
          });
          return res.status(400).send(error50(`vendor\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF0C\u5171 ${issueLines.length} \u5904:
${issueLines.join("\n")}`));
        }
        if (vendor.id.includes(":")) return res.status(400).send(error50("id\u4E0D\u80FD\u5305\u542B\u82F1\u6587\u5192\u53F7"));
        const data = await utils_default.db("o_vendorConfig").where("id", vendor.id).first();
        if (data) return res.status(500).send(error50("\u4F9B\u5E94\u5546id\u5DF2\u5B58\u5728"));
        const [id] = await utils_default.db("o_vendorConfig").insert({
          id: vendor.id,
          inputValues: JSON.stringify(vendor.inputValues ?? {}),
          models: JSON.stringify([]),
          enable: vendor.id == "toonflow" ? 1 : 0
        });
        utils_default.vendor.writeCode(vendor.id, tsCode);
        res.status(200).send(success3(result.data));
      }
    );
  }
});

// src/routes/setting/vendorConfig/addVendorModel.ts
var import_express155, router155, addVendorModel_default;
var init_addVendorModel = __esm({
  "src/routes/setting/vendorConfig/addVendorModel.ts"() {
    "use strict";
    import_express155 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_zod();
    init_userConfig();
    router155 = import_express155.default.Router();
    addVendorModel_default = router155.post(
      "/",
      validateFields({
        id: external_exports.string(),
        model: external_exports.discriminatedUnion("type", [
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("text"),
            think: external_exports.boolean()
          }),
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("image"),
            mode: external_exports.array(external_exports.enum(["text", "singleImage", "multiReference"]))
          }),
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("video"),
            mode: external_exports.array(
              external_exports.union([
                external_exports.enum(["singleImage", "startEndRequired", "endFrameOptional", "startFrameOptional", "text", "audioReference", "videoReference"]),
                external_exports.array(external_exports.string().regex(/^(videoReference|imageReference|audioReference):\d+$/))
              ])
            ),
            audio: external_exports.union([external_exports.literal("optional"), external_exports.boolean()]),
            durationResolutionMap: external_exports.array(
              external_exports.object({
                duration: external_exports.array(external_exports.number()),
                resolution: external_exports.array(external_exports.string())
              })
            )
          })
        ])
      }),
      async (req, res) => {
        const { id, model } = req.body;
        const userId = requireRequestUserId(req);
        const existingModels = await getEditableVendorModels(userId, id);
        existingModels.push(model);
        await setUserVendorConfig(userId, id, {
          models: JSON.stringify(existingModels)
        });
        res.status(200).send(success3("\u66F4\u65B0\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/vendorConfig/deleteVendor.ts
var import_express156, import_path28, import_fs16, router156, deleteVendor_default;
var init_deleteVendor = __esm({
  "src/routes/setting/vendorConfig/deleteVendor.ts"() {
    "use strict";
    import_express156 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    import_path28 = __toESM(require("path"));
    import_fs16 = __toESM(require("fs"));
    init_utils3();
    init_zod();
    router156 = import_express156.default.Router();
    deleteVendor_default = router156.post(
      "/",
      validateFields({
        id: external_exports.string()
      }),
      async (req, res) => {
        const { id } = req.body;
        await utils_default.db("o_vendorConfig").where("id", id).del();
        await utils_default.db("o_agentDeploy").where("vendorId", id).update({
          model: null,
          vendorId: null
        });
        import_fs16.default.rmSync(import_path28.default.join(utils_default.getPath("vendor"), `${id}.ts`), { recursive: true, force: true });
        res.status(200).send(success3("\u5220\u9664\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/vendorConfig/delVendorModel.ts
var import_express157, router157, delVendorModel_default;
var init_delVendorModel = __esm({
  "src/routes/setting/vendorConfig/delVendorModel.ts"() {
    "use strict";
    import_express157 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_zod();
    init_userConfig();
    router157 = import_express157.default.Router();
    delVendorModel_default = router157.post(
      "/",
      validateFields({
        id: external_exports.string(),
        modelName: external_exports.string()
      }),
      async (req, res) => {
        const { id, modelName } = req.body;
        const userId = requireRequestUserId(req);
        const existingModels = await getEditableVendorModels(userId, id);
        if (!existingModels.some((model) => model.modelName === modelName)) {
          return res.status(400).send(error50("\u57FA\u672C\u6A21\u578B\u4E0D\u5141\u8BB8\u5220\u9664"));
        }
        const updatedModels = existingModels.filter((model) => model.modelName !== modelName);
        await setUserVendorConfig(userId, id, {
          models: JSON.stringify(updatedModels)
        });
        res.status(200).send(success3("\u66F4\u65B0\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/vendorConfig/enableVendor.ts
var import_express158, router158, enableVendor_default;
var init_enableVendor = __esm({
  "src/routes/setting/vendorConfig/enableVendor.ts"() {
    "use strict";
    import_express158 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_zod();
    init_userConfig();
    router158 = import_express158.default.Router();
    enableVendor_default = router158.post(
      "/",
      validateFields({
        id: external_exports.string(),
        enable: external_exports.number()
      }),
      async (req, res) => {
        const { id, enable } = req.body;
        const userId = requireRequestUserId(req);
        await setUserVendorConfig(userId, id, { enable });
        res.status(200).send(success3("\u66F4\u65B0\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/vendorConfig/getCodeByLink.ts
var import_express159, router159, getCodeByLink_default;
var init_getCodeByLink = __esm({
  "src/routes/setting/vendorConfig/getCodeByLink.ts"() {
    "use strict";
    import_express159 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_zod();
    router159 = import_express159.default.Router();
    getCodeByLink_default = router159.post(
      "/",
      validateFields({
        link: external_exports.string()
      }),
      async (req, res) => {
        const { link } = req.body;
        const text2 = await fetch(link).then((res2) => res2.text());
        res.status(200).send(success3(text2));
      }
    );
  }
});

// src/routes/setting/vendorConfig/getVendorList.ts
var import_express160, router160, getVendorList_default;
var init_getVendorList = __esm({
  "src/routes/setting/vendorConfig/getVendorList.ts"() {
    "use strict";
    import_express160 = __toESM(require_express2());
    init_responseFormat();
    init_utils3();
    init_userConfig();
    router160 = import_express160.default.Router();
    getVendorList_default = router160.post("/", async (req, res) => {
      const userId = requireRequestUserId(req);
      const data = await utils_default.db("o_vendorConfig").select("*");
      const list2 = (await Promise.all(
        data.map(async (item) => {
          const userConfig = await getVendorConfigForUser(item.id, userId);
          const vendor = utils_default.vendor.getVendor(item.id);
          if (!vendor) {
            await utils_default.db("o_vendorConfig").where("id", item.id).delete();
            return null;
          }
          ;
          return {
            ...userConfig,
            inputValues: {
              ...vendor.inputValues ?? {},
              ...parseJson(userConfig?.inputValues, {})
            },
            models: await utils_default.vendor.getModelList(item.id),
            code: utils_default.vendor.getCode(item.id),
            description: vendor.description ?? "",
            inputs: vendor.inputs,
            author: vendor.author,
            name: vendor.name,
            version: vendor.version ?? "1.0"
          };
        })
      )).filter((i) => Boolean(i));
      list2.sort((a, b) => a.id === "toonflow" ? -1 : b.id === "toonflow" ? 1 : 0);
      res.status(200).send(success3(list2));
    });
  }
});

// src/routes/setting/vendorConfig/modelTest.ts
var import_express161, router161, modelTest_default;
var init_modelTest = __esm({
  "src/routes/setting/vendorConfig/modelTest.ts"() {
    "use strict";
    import_express161 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_utils3();
    init_zod();
    init_dist22();
    init_userConfig();
    router161 = import_express161.default.Router();
    modelTest_default = router161.post(
      "/",
      validateFields({
        modelName: external_exports.string(),
        type: external_exports.enum(["text", "video", "image"]),
        id: external_exports.string()
      }),
      async (req, res) => {
        const { modelName, type, id } = req.body;
        const userId = requireRequestUserId(req);
        try {
          const requestFn = {
            text: { fnName: "textRequest" },
            image: {
              fnName: "imageRequest",
              modelData: {
                prompt: "\u4E00\u5F2016:9\u6BD4\u4F8B\u7684\u56FE\u7247\uFF0C\u5B8C\u7F8E\u7B49\u5206\u4E3A2x2\u56DB\u5BAB\u683C\u5E03\u5C40\uFF0C\u5404\u533A\u57DF\u65E0\u7F1D\u8854\u63A5\uFF1A\n\u5DE6\u4E0A\u5BAB\u683C\uFF1A\u4E00\u53EA\u53EF\u7231\u7684\u732B\uFF0C\u6BDB\u53D1\u84EC\u677E\uFF0C\u773C\u775B\u660E\u4EAE\uFF0C\u59FF\u6001\u4FCF\u76AE\n\u53F3\u4E0A\u5BAB\u683C\uFF1A\u4E00\u53EA\u53CB\u5584\u7684\u72D7\uFF0C\u91D1\u6BDB\u72AC\uFF0C\u8868\u60C5\u6109\u60A6\uFF0C\u6447\u7740\u5C3E\u5DF4\n\u5DE6\u4E0B\u5BAB\u683C\uFF1A\u4E00\u5934\u5065\u58EE\u7684\u725B\uFF0C\u7530\u56ED\u80CC\u666F\uFF0C\u76EE\u5149\u6E29\u548C\uFF0C\u76AE\u6BDB\u5149\u6CFD\n\u53F3\u4E0B\u5BAB\u683C\uFF1A\u4E00\u5339\u9A8F\u9A6C\uFF0C\u59FF\u6001\u4F18\u96C5\uFF0C\u9B03\u6BDB\u98D8\u9038\uFF0C\u808C\u8089\u5065\u7F8E\n\u98CE\u683C\u8981\u6C42\uFF1A\u56DB\u4E2A\u5BAB\u683C\u98CE\u683C\u7EDF\u4E00\uFF0C\u8272\u5F69\u9C9C\u8273\u9971\u548C\uFF0C\u9AD8\u6E05\u753B\u8D28\uFF0C\u7EC6\u8282\u6E05\u6670\u9510\u5229\uFF0C\u4E13\u4E1A\u63D2\u753B\u98CE\u683C\uFF0C\u7EBF\u6761\u5E72\u51C0\uFF0C\u7EDF\u4E00\u7684\u5DE6\u4E0A\u65B9\u5149\u6E90\uFF0C\u67D4\u548C\u9634\u5F71\uFF0C\u548C\u8C10\u914D\u8272\uFF0C\u5361\u901A/\u534A\u5199\u5B9E\u98CE\u683C\uFF0C\u5BAB\u683C\u95F4\u7528\u767D\u8272\u6216\u6D45\u7070\u7EC6\u7EBF\u5206\u9694",
                //图片提示词
                referenceList: [],
                //输入的图片提示词
                size: "1K",
                // 图片尺寸
                aspectRatio: "16:9"
              }
            },
            video: { fnName: "videoRequest", modelData: {} }
          };
          const vendorConfigData = await getVendorConfigForUser(id, userId);
          if (!vendorConfigData) return res.status(500).send(error50("\u672A\u627E\u5230\u8BE5\u4F9B\u5E94\u5546\u914D\u7F6E"));
          if (!vendorConfigData.models) return res.status(500).send(error50("\u672A\u627E\u5230\u6A21\u578B\u5217\u8868"));
          const modelList = await utils_default.vendor.getModelList(vendorConfigData.id);
          const selectedModel = modelList.find((i) => i.modelName == modelName);
          if (type == "video") {
            requestFn["video"].modelData = {
              model: modelName,
              duration: selectedModel.durationResolutionMap[0].duration[0],
              resolution: selectedModel.durationResolutionMap[0].resolution[0],
              aspectRatio: "16:9",
              prompt: "A shirtless middle-aged man with a horse head is standing in a supermarket, carefully comparing two identical bottles of shampoo for 3 seconds, then suddenly bursts into tears, drops to his knees dramatically, a flock of pigeons explodes out of nowhere from behind him, the supermarket lights flicker, an old grandma nearby continues shopping completely unbothered, the horse head man instantly stops crying, puts both shampoo bottles back, and moonwalks away disappearing into the vegetable section. Security camera footage style, slightly grainy, 5 seconds.",
              referenceList: [],
              audio: false,
              mode: "text"
            };
          }
          const reqConfig = requestFn[type];
          const getWeatherTool = tool({
            description: "Get the weather in a location",
            inputSchema: jsonSchema(
              external_exports.object({
                location: external_exports.string().describe("The location to get the weather for")
              }).toJSONSchema()
            ),
            execute: async ({ location }) => {
              return {
                location,
                temperature: 72 + Math.floor(Math.random() * 21) - 10
              };
            }
          });
          if (type == "text") {
            const { textStream } = await utils_default.Ai.Text(`${id}:${modelName}`).stream({
              prompt: "\u8BF7\u8C03\u7528\u5DE5\u5177\u83B7\u53D6\u706B\u661F\u7684\u5929\u6C14\uFF0C\u5E76\u56DE\u7B54\u6211\u591A\u5C11\u6C14\u6E29",
              tools: { getWeatherTool }
            });
            let fullResponse = "";
            for await (const chunk of textStream) {
              fullResponse += chunk;
            }
            if (!fullResponse) return res.status(500).send(error50("\u6A21\u578B\u672A\u8FD4\u56DE\u7ED3\u679C"));
            res.status(200).send(success3(fullResponse));
          } else {
            const aiTypeFn = {
              image: "Image",
              video: "Video"
            };
            const reqFn = await utils_default.Ai[aiTypeFn[type]](`${id}:${modelName}`).run({
              ...reqConfig.modelData
            });
            await reqFn.save(type == "video" ? "test.mp4" : "testImage.jpg");
            const resultUrl = await utils_default.oss.getFileUrl(type == "video" ? "test.mp4" : "testImage.jpg");
            res.status(200).send(success3(resultUrl));
          }
        } catch (err) {
          console.error(err);
          const msg = utils_default.error(err).message;
          console.error(msg);
          res.status(500).send(error50(msg));
        }
      }
    );
  }
});

// src/routes/setting/vendorConfig/modelTest/imageTest.ts
var import_express162, router162, imageTest_default;
var init_imageTest = __esm({
  "src/routes/setting/vendorConfig/modelTest/imageTest.ts"() {
    "use strict";
    import_express162 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_utils3();
    init_zod();
    init_userConfig();
    router162 = import_express162.default.Router();
    imageTest_default = router162.post(
      "/",
      validateFields({
        modelName: external_exports.string(),
        id: external_exports.string(),
        imageBase64: external_exports.string().optional(),
        prompt: external_exports.string()
      }),
      async (req, res) => {
        const { modelName, imageBase64, id, prompt } = req.body;
        const userId = requireRequestUserId(req);
        try {
          const vendorConfigData = await getVendorConfigForUser(id, userId);
          if (!vendorConfigData) return res.status(500).send(error50("\u672A\u627E\u5230\u8BE5\u4F9B\u5E94\u5546\u914D\u7F6E"));
          if (!vendorConfigData.models) return res.status(500).send(error50("\u672A\u627E\u5230\u6A21\u578B\u5217\u8868"));
          const reqFn = await utils_default.Ai.Image(`${id}:${modelName}`).run({
            prompt,
            referenceList: [{ type: "image", base64: imageBase64 }],
            //输入的图片提示词
            size: "1K",
            // 图片尺寸
            aspectRatio: "16:9"
          });
          await reqFn.save("testImage.jpg");
          const resultUrl = await utils_default.oss.getFileUrl("testImage.jpg");
          res.status(200).send(success3(resultUrl));
        } catch (err) {
          console.error(err);
          const msg = utils_default.error(err).message;
          console.error(msg);
          res.status(500).send(error50(msg));
        }
      }
    );
  }
});

// src/routes/setting/vendorConfig/modelTest/textTest.ts
var import_express163, router163, textTest_default;
var init_textTest = __esm({
  "src/routes/setting/vendorConfig/modelTest/textTest.ts"() {
    "use strict";
    import_express163 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_utils3();
    init_zod();
    init_dist22();
    init_userConfig();
    router163 = import_express163.default.Router();
    textTest_default = router163.post(
      "/",
      validateFields({
        modelName: external_exports.string(),
        id: external_exports.string(),
        messages: external_exports.array(
          external_exports.object({
            role: external_exports.enum(["user", "assistant"]),
            content: external_exports.string()
          })
        )
      }),
      async (req, res) => {
        const { modelName, messages, id } = req.body;
        const userId = requireRequestUserId(req);
        try {
          const vendorConfigData = await getVendorConfigForUser(id, userId);
          if (!vendorConfigData) return res.status(500).send(error50("\u672A\u627E\u5230\u8BE5\u4F9B\u5E94\u5546\u914D\u7F6E"));
          if (!vendorConfigData.models) return res.status(500).send(error50("\u672A\u627E\u5230\u6A21\u578B\u5217\u8868"));
          const modelList = await utils_default.vendor.getModelList(vendorConfigData.id);
          const getWeatherTool = tool({
            description: "Get the weather in a location",
            inputSchema: jsonSchema(
              external_exports.object({
                location: external_exports.string().describe("The location to get the weather for")
              }).toJSONSchema()
            ),
            execute: async ({ location }) => {
              return {
                location,
                temperature: 72 + Math.floor(Math.random() * 21) - 10
              };
            }
          });
          const data = await utils_default.Ai.Text(`${id}:${modelName}`).invoke({
            messages,
            tools: { getWeatherTool }
          });
          console.log("%c Line:46 \u{1F350} data", "background:#6ec1c2", data);
          if (!data) return res.status(500).send(error50("\u6A21\u578B\u672A\u8FD4\u56DE\u7ED3\u679C"));
          res.status(200).send(success3({ thinking: data.reasoningText, content: data.text }));
        } catch (err) {
          console.error(err);
          const msg = utils_default.error(err).message;
          console.error(msg);
          res.status(500).send(error50(msg));
        }
      }
    );
  }
});

// src/routes/setting/vendorConfig/modelTest/videoTest.ts
var import_express164, router164, videoTest_default;
var init_videoTest = __esm({
  "src/routes/setting/vendorConfig/modelTest/videoTest.ts"() {
    "use strict";
    import_express164 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_utils3();
    init_zod();
    init_userConfig();
    router164 = import_express164.default.Router();
    videoTest_default = router164.post(
      "/",
      validateFields({
        modelName: external_exports.string(),
        id: external_exports.string(),
        mode: external_exports.string(),
        prompt: external_exports.string(),
        videos: external_exports.array(
          external_exports.object({
            type: external_exports.string(),
            base64: external_exports.string()
          })
        ),
        audios: external_exports.array(
          external_exports.object({
            type: external_exports.string(),
            base64: external_exports.string()
          })
        ),
        images: external_exports.array(
          external_exports.object({
            type: external_exports.string(),
            base64: external_exports.string()
          })
        )
      }),
      async (req, res) => {
        const { modelName, id, mode, prompt, images, videos, audios } = req.body;
        const userId = requireRequestUserId(req);
        try {
          const vendorConfigData = await getVendorConfigForUser(id, userId);
          if (!vendorConfigData) return res.status(500).send(error50("\u672A\u627E\u5230\u8BE5\u4F9B\u5E94\u5546\u914D\u7F6E"));
          if (!vendorConfigData.models) return res.status(500).send(error50("\u672A\u627E\u5230\u6A21\u578B\u5217\u8868"));
          const modelList = await utils_default.vendor.getModelList(vendorConfigData.id);
          const selectedModel = modelList.find((i) => i.modelName == modelName);
          let modeData = [];
          if (Array.isArray(mode)) {
          } else if (typeof mode === "string" && mode.startsWith('["') && mode.endsWith('"]')) {
            try {
              modeData = JSON.parse(mode);
            } catch (e) {
            }
          }
          const reqFn = await utils_default.Ai.Video(`${id}:${modelName}`).run({
            duration: selectedModel.durationResolutionMap[0].duration[0],
            resolution: selectedModel.durationResolutionMap[0].resolution[0],
            aspectRatio: "16:9",
            prompt,
            referenceList: [...images, ...videos, ...audios],
            audio: typeof selectedModel.audio == "boolean" ? selectedModel.audio : true,
            mode: modeData.length > 0 ? modeData : mode
          });
          await reqFn.save("test.mp4");
          const resultUrl = await utils_default.oss.getFileUrl("test.mp4");
          res.status(200).send(success3(resultUrl));
        } catch (err) {
          console.error(err);
          const msg = utils_default.error(err).message;
          console.error(msg);
          res.status(500).send(error50(msg));
        }
      }
    );
  }
});

// src/routes/setting/vendorConfig/updateCode.ts
var import_express165, import_sucrase5, router165, vendorConfigSchema2, updateCode_default;
var init_updateCode = __esm({
  "src/routes/setting/vendorConfig/updateCode.ts"() {
    "use strict";
    import_express165 = __toESM(require_express2());
    init_serialize_error();
    init_responseFormat();
    init_middleware();
    init_utils3();
    init_zod();
    import_sucrase5 = __toESM(require_dist5());
    router165 = import_express165.default.Router();
    vendorConfigSchema2 = external_exports.object({
      id: external_exports.string(),
      author: external_exports.string(),
      description: external_exports.string().optional(),
      name: external_exports.string(),
      icon: external_exports.string().optional(),
      inputs: external_exports.array(
        external_exports.object({
          key: external_exports.string(),
          label: external_exports.string(),
          type: external_exports.enum(["text", "password", "url"]),
          required: external_exports.boolean(),
          placeholder: external_exports.string().optional()
        })
      ),
      inputValues: external_exports.record(external_exports.string(), external_exports.string()),
      models: external_exports.array(
        external_exports.discriminatedUnion("type", [
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("text"),
            think: external_exports.boolean()
          }),
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("image"),
            mode: external_exports.array(external_exports.enum(["text", "singleImage", "multiReference"]))
          }),
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("video"),
            mode: external_exports.array(
              external_exports.union([
                external_exports.enum(["singleImage", "startEndRequired", "endFrameOptional", "startFrameOptional", "text", "audioReference", "videoReference"]),
                external_exports.array(external_exports.string().regex(/^(videoReference|imageReference|audioReference):\d+$/))
              ])
            ),
            audio: external_exports.union([external_exports.literal("optional"), external_exports.boolean()]),
            durationResolutionMap: external_exports.array(
              external_exports.object({
                duration: external_exports.array(external_exports.number()),
                resolution: external_exports.array(external_exports.string())
              })
            )
          })
        ])
      )
    });
    updateCode_default = router165.post(
      "/",
      validateFields({
        id: external_exports.string(),
        tsCode: external_exports.string()
      }),
      async (req, res) => {
        try {
          const { tsCode, id } = req.body;
          const jsCode = (0, import_sucrase5.transform)(tsCode, { transforms: ["typescript"] }).code;
          const exports2 = utils_default.vm(jsCode);
          if (!exports2) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FA\u5BF9\u8C61"));
          if (!exports2.textRequest) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FA\u6587\u672C\u8BF7\u6C42\u5BF9\u8C61"));
          if (!exports2.imageRequest) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FA\u56FE\u50CF\u8BF7\u6C42\u5BF9\u8C61"));
          if (!exports2.videoRequest) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FA\u89C6\u9891\u8BF7\u6C42\u5BF9\u8C61"));
          if (!exports2.vendor) return res.status(400).send(success3("\u811A\u672C\u6587\u4EF6\u5FC5\u987B\u5BFC\u51FAvendor\u5BF9\u8C61"));
          const vendor = exports2.vendor;
          const result = vendorConfigSchema2.safeParse(vendor);
          if (!result.success) {
            const errorMsg = result.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
            return res.status(400).send(error50(`vendor\u914D\u7F6E\u6821\u9A8C\u5931\u8D25: ${errorMsg}`));
          }
          await utils_default.db("o_vendorConfig").where("id", id).update({
            models: JSON.stringify(vendor.models ?? [])
          });
          utils_default.vendor.writeCode(id, tsCode);
          res.status(200).send(success3(result.data));
        } catch (err) {
          console.log(err);
          res.status(400).send(error50(serializeError(err).message || "\u672A\u77E5\u9519\u8BEF"));
        }
      }
    );
  }
});

// src/routes/setting/vendorConfig/updateVendorInputs.ts
var import_express166, router166, updateVendorInputs_default;
var init_updateVendorInputs = __esm({
  "src/routes/setting/vendorConfig/updateVendorInputs.ts"() {
    "use strict";
    import_express166 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_zod();
    init_userConfig();
    router166 = import_express166.default.Router();
    updateVendorInputs_default = router166.post(
      "/",
      validateFields({
        id: external_exports.string(),
        inputValues: external_exports.record(external_exports.string(), external_exports.string())
      }),
      async (req, res) => {
        const { id, inputValues } = req.body;
        const userId = requireRequestUserId(req);
        await setUserVendorConfig(userId, id, {
          inputValues: JSON.stringify(inputValues)
        });
        res.status(200).send(success3("\u66F4\u65B0\u6210\u529F"));
      }
    );
  }
});

// src/routes/setting/vendorConfig/upVendorModel.ts
var import_express167, router167, upVendorModel_default;
var init_upVendorModel = __esm({
  "src/routes/setting/vendorConfig/upVendorModel.ts"() {
    "use strict";
    import_express167 = __toESM(require_express2());
    init_responseFormat();
    init_middleware();
    init_zod();
    init_userConfig();
    router167 = import_express167.default.Router();
    upVendorModel_default = router167.post(
      "/",
      validateFields({
        id: external_exports.string(),
        modelName: external_exports.string(),
        model: external_exports.discriminatedUnion("type", [
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("text"),
            think: external_exports.boolean()
          }),
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("image"),
            mode: external_exports.array(external_exports.enum(["text", "singleImage", "multiReference"]))
          }),
          external_exports.object({
            name: external_exports.string(),
            modelName: external_exports.string(),
            type: external_exports.literal("video"),
            mode: external_exports.array(
              external_exports.union([
                external_exports.enum(["singleImage", "startEndRequired", "endFrameOptional", "startFrameOptional", "text", "audioReference", "videoReference"]),
                external_exports.array(external_exports.string().regex(/^(videoReference|imageReference|audioReference):\d+$/))
              ])
            ),
            audio: external_exports.union([external_exports.literal("optional"), external_exports.boolean()]),
            durationResolutionMap: external_exports.array(
              external_exports.object({
                duration: external_exports.array(external_exports.number()),
                resolution: external_exports.array(external_exports.string())
              })
            )
          })
        ])
      }),
      async (req, res) => {
        const { id, modelName, model } = req.body;
        const userId = requireRequestUserId(req);
        const existingModels = await getEditableVendorModels(userId, id);
        const modelIndex = existingModels.findIndex((m) => m.modelName === modelName);
        if (modelIndex === -1) {
          existingModels.push(model);
        } else {
          existingModels[modelIndex] = model;
        }
        await setUserVendorConfig(userId, id, {
          models: JSON.stringify(existingModels)
        });
        res.status(200).send(success3("\u66F4\u65B0\u6210\u529F"));
      }
    );
  }
});

// src/routes/task/getProject.ts
var import_express168, router168, getProject_default2;
var init_getProject2 = __esm({
  "src/routes/task/getProject.ts"() {
    "use strict";
    import_express168 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_auth();
    router168 = import_express168.default.Router();
    getProject_default2 = router168.post("/", async (req, res) => {
      const user = getCurrentUser(req);
      const list2 = await utils_default.db("o_project").where("userId", user.id).select("id", "name").groupBy("id", "name");
      const data = list2.filter((item) => item.name);
      res.status(200).send(success3(data));
    });
  }
});

// src/routes/task/getTaskApi.ts
var import_express169, router169, getTaskApi_default;
var init_getTaskApi = __esm({
  "src/routes/task/getTaskApi.ts"() {
    "use strict";
    import_express169 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_middleware();
    init_zod();
    init_auth();
    router169 = import_express169.default.Router();
    getTaskApi_default = router169.post(
      "/",
      validateFields({
        state: external_exports.string().optional().nullable(),
        taskClass: external_exports.string().optional().nullable(),
        projectId: external_exports.number().optional().nullable(),
        page: external_exports.number(),
        limit: external_exports.number()
      }),
      async (req, res) => {
        const { taskClass, state, projectId, page = 1, limit = 10 } = req.body;
        const user = getCurrentUser(req);
        const offset = (page - 1) * limit;
        const data = await utils_default.db("o_tasks").leftJoin("o_project", "o_project.id", "o_tasks.projectId").where("o_project.userId", user.id).andWhere((qb) => {
          if (taskClass) {
            qb.andWhere("o_tasks.taskClass", taskClass);
          }
          if (state) {
            qb.andWhere("o_tasks.state", state);
          }
          if (projectId) {
            qb.andWhere("o_tasks.projectId", projectId);
          }
        }).select("o_tasks.*", "o_project.* ").offset(offset).limit(limit).orderBy("o_tasks.id", "desc");
        const totalQuery = await utils_default.db("o_tasks").leftJoin("o_project", "o_project.id", "o_tasks.projectId").where("o_project.userId", user.id).andWhere((qb) => {
          if (taskClass) {
            qb.andWhere("o_tasks.taskClass", taskClass);
          }
          if (projectId) {
            qb.andWhere("o_tasks.projectId", projectId);
          }
          if (state) {
            qb.andWhere("o_tasks.state", state);
          }
        }).count("* as total").first();
        res.status(200).send(success3({ data, total: totalQuery?.total }));
      }
    );
  }
});

// src/routes/task/getTaskCategories.ts
var import_express170, router170, getTaskCategories_default;
var init_getTaskCategories = __esm({
  "src/routes/task/getTaskCategories.ts"() {
    "use strict";
    import_express170 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    router170 = import_express170.default.Router();
    getTaskCategories_default = router170.post("/", async (req, res) => {
      const list2 = await utils_default.db("o_tasks").select("taskClass").groupBy("taskClass");
      const data = list2.filter((item) => item.taskClass);
      res.status(200).send(success3(data));
    });
  }
});

// src/routes/task/taskDetails.ts
var import_express171, router171, taskDetails_default;
var init_taskDetails = __esm({
  "src/routes/task/taskDetails.ts"() {
    "use strict";
    import_express171 = __toESM(require_express2());
    init_utils3();
    init_responseFormat();
    init_middleware();
    init_zod();
    router171 = import_express171.default.Router();
    taskDetails_default = router171.post(
      "/",
      validateFields({
        taskId: external_exports.number()
      }),
      async (req, res) => {
        const { taskId } = req.body;
        const data = await utils_default.db("o_tasks").where("id", taskId).select("*").first();
        res.status(200).send(success3(data));
      }
    );
  }
});

// src/routes/test/test.ts
var import_express172, import_fs17, router172, test_default;
var init_test = __esm({
  "src/routes/test/test.ts"() {
    "use strict";
    import_express172 = __toESM(require_express2());
    init_utils3();
    import_fs17 = __toESM(require("fs"));
    router172 = import_express172.default.Router();
    test_default = router172.get("/", async (req, res) => {
      return res.send("ok");
      const test2 = await utils_default.db("o_vendorConfig").select("*");
      import_fs17.default.writeFileSync("test.json", JSON.stringify(test2, null, 2));
      res.send(test2);
    });
  }
});

// src/router.ts
var router_exports = {};
__export(router_exports, {
  default: () => router_default
});
var router_default;
var init_router = __esm({
  "src/router.ts"() {
    "use strict";
    init_clearMemory();
    init_getMemory();
    init_addArtStyle();
    init_editArtStyle();
    init_extractStylePrompt();
    init_getArtStyle();
    init_addAssets();
    init_addAudioAssets();
    init_batchDelete();
    init_batchGenerationData();
    init_delAssets();
    init_delImage();
    init_getAssetsApi();
    init_getImage();
    init_getMaterialData();
    init_pollingImageAssets();
    init_pollingPromptAssets();
    init_saveAssets();
    init_updateAssets();
    init_updateAudioAssets();
    init_uploadClip();
    init_batchGenerateImageAssets();
    init_batchPolishAssetsPrompt();
    init_cancelGenerate();
    init_generateAssets();
    init_polishAssetsPrompt();
    init_getBigImage();
    init_batchBindAudio();
    init_getAllAssets();
    init_pollingAudio();
    init_updateAssetsAudio();
    init_generalStatistics();
    init_getSingleProject();
    init_updateProject();
    init_login();
    init_me();
    init_register();
    init_resetPassword();
    init_sendSmsCode();
    init_getModelDetail();
    init_getModelList();
    init_addNovel();
    init_batchDeleteNovel();
    init_delNovel();
    init_batchDeleteEvent();
    init_deletEvent();
    init_generateEvents();
    init_getEvent();
    init_getNovel();
    init_getNovelData();
    init_getNovelEventState();
    init_getNovelIndex();
    init_updateNovel();
    init_deleteAllData();
    init_getVersion();
    init_batchGenerateAssetsImage();
    init_deleteAssetsDireve();
    init_pollingImage();
    init_updateAssetsUrl();
    init_generateFlowImage();
    init_getImageDefaultModle();
    init_getImageFlow();
    init_saveImageFlow();
    init_updateImageFlow();
    init_uploadImage();
    init_getFlowData();
    init_getStoryboardData();
    init_saveFlowData();
    init_addStoryboard();
    init_batchAddStoryboardInfo();
    init_batchDelete2();
    init_batchGenerateImage();
    init_downPreviewImage();
    init_editStoryboardInfo();
    init_getStoryboardData2();
    init_pollingImage2();
    init_previewImage();
    init_removeFrame();
    init_updateStoryboardUrl();
    init_addTrack();
    init_batchGeneratePrompt();
    init_batchGenerateVideo();
    init_checkVideoStateList();
    init_deleteTrack();
    init_delVideo();
    init_generateVideo();
    init_generateVideoPrompt();
    init_getAudioBindAssetsList();
    init_getFileUrl();
    init_getGenerateData();
    init_getVideoList();
    init_selectVideo();
    init_updateVideoDuration();
    init_updateVideoPrompt();
    init_addDirectorManual();
    init_addProject();
    init_addVisualManual();
    init_deleteDirectorManual();
    init_deleteVisualManual();
    init_delProject();
    init_editDirectorlManual();
    init_editProject();
    init_editVisualManual();
    init_getModelDetails();
    init_getProject();
    init_getSingleProject2();
    init_getVisualManual();
    init_queryDirectorManual();
    init_visualManual();
    init_addScript();
    init_batchAddScript();
    init_delScript();
    init_exportScript();
    init_extractAssets();
    init_getAiRegex();
    init_getScrptApi();
    init_pollScriptAssets();
    init_updateScript();
    init_getPlanData();
    init_setPlanData();
    init_updateData();
    init_checkUpdate();
    init_downloadApp();
    init_agentSetKey();
    init_deployAgentModel();
    init_getAgentDeploy();
    init_getAgentUseMode();
    init_updateUseMode();
    init_clearData();
    init_clearTable();
    init_dbInfo();
    init_exportData();
    init_importData();
    init_getSwitchAiDevTool();
    init_updateSwitchAiDevTool();
    init_openFolder();
    init_getTextModel();
    init_getUser();
    init_updateUserPwd();
    init_delAllMemory();
    init_getMemory2();
    init_sureMemory();
    init_bindingPrompt();
    init_deletePrompt();
    init_getImageAndVideoModel();
    init_getPromptList();
    init_savePrompt();
    init_updatePrompt();
    init_getPrompt();
    init_updatePrompt2();
    init_getSkillContent();
    init_getSkillList();
    init_saveSkillContent();
    init_addVendor();
    init_addVendorModel();
    init_deleteVendor();
    init_delVendorModel();
    init_enableVendor();
    init_getCodeByLink();
    init_getVendorList();
    init_modelTest();
    init_imageTest();
    init_textTest();
    init_videoTest();
    init_updateCode();
    init_updateVendorInputs();
    init_upVendorModel();
    init_getProject2();
    init_getTaskApi();
    init_getTaskCategories();
    init_taskDetails();
    init_test();
    router_default = async (app2) => {
      app2.use("/api/agents/clearMemory", clearMemory_default);
      app2.use("/api/agents/getMemory", getMemory_default);
      app2.use("/api/artStyle/addArtStyle", addArtStyle_default);
      app2.use("/api/artStyle/editArtStyle", editArtStyle_default);
      app2.use("/api/artStyle/extractStylePrompt", extractStylePrompt_default);
      app2.use("/api/artStyle/getArtStyle", getArtStyle_default);
      app2.use("/api/assets/addAssets", addAssets_default);
      app2.use("/api/assets/addAudioAssets", addAudioAssets_default);
      app2.use("/api/assets/batchDelete", batchDelete_default);
      app2.use("/api/assets/batchGenerationData", batchGenerationData_default);
      app2.use("/api/assets/delAssets", delAssets_default);
      app2.use("/api/assets/delImage", delImage_default);
      app2.use("/api/assets/getAssetsApi", getAssetsApi_default);
      app2.use("/api/assets/getImage", getImage_default);
      app2.use("/api/assets/getMaterialData", getMaterialData_default);
      app2.use("/api/assets/pollingImageAssets", pollingImageAssets_default);
      app2.use("/api/assets/pollingPromptAssets", pollingPromptAssets_default);
      app2.use("/api/assets/saveAssets", saveAssets_default);
      app2.use("/api/assets/updateAssets", updateAssets_default);
      app2.use("/api/assets/updateAudioAssets", updateAudioAssets_default);
      app2.use("/api/assets/uploadClip", uploadClip_default);
      app2.use("/api/assetsGenerate/batchGenerateImageAssets", batchGenerateImageAssets_default);
      app2.use("/api/assetsGenerate/batchPolishAssetsPrompt", batchPolishAssetsPrompt_default);
      app2.use("/api/assetsGenerate/cancelGenerate", cancelGenerate_default);
      app2.use("/api/assetsGenerate/generateAssets", generateAssets_default);
      app2.use("/api/assetsGenerate/polishAssetsPrompt", polishAssetsPrompt_default);
      app2.use("/api/common/getBigImage", getBigImage_default);
      app2.use("/api/cornerScape/batchBindAudio", batchBindAudio_default);
      app2.use("/api/cornerScape/getAllAssets", getAllAssets_default);
      app2.use("/api/cornerScape/pollingAudio", pollingAudio_default);
      app2.use("/api/cornerScape/updateAssetsAudio", updateAssetsAudio_default);
      app2.use("/api/general/generalStatistics", generalStatistics_default);
      app2.use("/api/general/getSingleProject", getSingleProject_default);
      app2.use("/api/general/updateProject", updateProject_default);
      app2.use("/api/login/login", login_default);
      app2.use("/api/login/me", me_default);
      app2.use("/api/login/register", register_default);
      app2.use("/api/login/resetPassword", resetPassword_default);
      app2.use("/api/login/sendSmsCode", sendSmsCode_default);
      app2.use("/api/modelSelect/getModelDetail", getModelDetail_default);
      app2.use("/api/modelSelect/getModelList", getModelList_default);
      app2.use("/api/novel/addNovel", addNovel_default);
      app2.use("/api/novel/batchDeleteNovel", batchDeleteNovel_default);
      app2.use("/api/novel/delNovel", delNovel_default);
      app2.use("/api/novel/event/batchDeleteEvent", batchDeleteEvent_default);
      app2.use("/api/novel/event/deletEvent", deletEvent_default);
      app2.use("/api/novel/event/generateEvents", generateEvents_default);
      app2.use("/api/novel/event/getEvent", getEvent_default);
      app2.use("/api/novel/getNovel", getNovel_default);
      app2.use("/api/novel/getNovelData", getNovelData_default);
      app2.use("/api/novel/getNovelEventState", getNovelEventState_default);
      app2.use("/api/novel/getNovelIndex", getNovelIndex_default);
      app2.use("/api/novel/updateNovel", updateNovel_default);
      app2.use("/api/other/deleteAllData", deleteAllData_default);
      app2.use("/api/other/getVersion", getVersion_default);
      app2.use("/api/production/assets/batchGenerateAssetsImage", batchGenerateAssetsImage_default);
      app2.use("/api/production/assets/deleteAssetsDireve", deleteAssetsDireve_default);
      app2.use("/api/production/assets/pollingImage", pollingImage_default);
      app2.use("/api/production/assets/updateAssetsUrl", updateAssetsUrl_default);
      app2.use("/api/production/editImage/generateFlowImage", generateFlowImage_default);
      app2.use("/api/production/editImage/getImageDefaultModle", getImageDefaultModle_default);
      app2.use("/api/production/editImage/getImageFlow", getImageFlow_default);
      app2.use("/api/production/editImage/saveImageFlow", saveImageFlow_default);
      app2.use("/api/production/editImage/updateImageFlow", updateImageFlow_default);
      app2.use("/api/production/editImage/uploadImage", uploadImage_default);
      app2.use("/api/production/getFlowData", getFlowData_default);
      app2.use("/api/production/getStoryboardData", getStoryboardData_default);
      app2.use("/api/production/saveFlowData", saveFlowData_default);
      app2.use("/api/production/storyboard/addStoryboard", addStoryboard_default);
      app2.use("/api/production/storyboard/batchAddStoryboardInfo", batchAddStoryboardInfo_default);
      app2.use("/api/production/storyboard/batchDelete", batchDelete_default2);
      app2.use("/api/production/storyboard/batchGenerateImage", batchGenerateImage_default);
      app2.use("/api/production/storyboard/downPreviewImage", downPreviewImage_default);
      app2.use("/api/production/storyboard/editStoryboardInfo", editStoryboardInfo_default);
      app2.use("/api/production/storyboard/getStoryboardData", getStoryboardData_default2);
      app2.use("/api/production/storyboard/pollingImage", pollingImage_default2);
      app2.use("/api/production/storyboard/previewImage", previewImage_default);
      app2.use("/api/production/storyboard/removeFrame", removeFrame_default);
      app2.use("/api/production/storyboard/updateStoryboardUrl", updateStoryboardUrl_default);
      app2.use("/api/production/workbench/addTrack", addTrack_default);
      app2.use("/api/production/workbench/batchGeneratePrompt", batchGeneratePrompt_default);
      app2.use("/api/production/workbench/batchGenerateVideo", batchGenerateVideo_default);
      app2.use("/api/production/workbench/checkVideoStateList", checkVideoStateList_default);
      app2.use("/api/production/workbench/deleteTrack", deleteTrack_default);
      app2.use("/api/production/workbench/delVideo", delVideo_default);
      app2.use("/api/production/workbench/generateVideo", generateVideo_default);
      app2.use("/api/production/workbench/generateVideoPrompt", generateVideoPrompt_default);
      app2.use("/api/production/workbench/getAudioBindAssetsList", getAudioBindAssetsList_default);
      app2.use("/api/production/workbench/getFileUrl", getFileUrl_default);
      app2.use("/api/production/workbench/getGenerateData", getGenerateData_default);
      app2.use("/api/production/workbench/getVideoList", getVideoList_default);
      app2.use("/api/production/workbench/selectVideo", selectVideo_default);
      app2.use("/api/production/workbench/updateVideoDuration", updateVideoDuration_default);
      app2.use("/api/production/workbench/updateVideoPrompt", updateVideoPrompt_default);
      app2.use("/api/project/addDirectorManual", addDirectorManual_default);
      app2.use("/api/project/addProject", addProject_default);
      app2.use("/api/project/addVisualManual", addVisualManual_default);
      app2.use("/api/project/deleteDirectorManual", deleteDirectorManual_default);
      app2.use("/api/project/deleteVisualManual", deleteVisualManual_default);
      app2.use("/api/project/delProject", delProject_default);
      app2.use("/api/project/editDirectorlManual", editDirectorlManual_default);
      app2.use("/api/project/editProject", editProject_default);
      app2.use("/api/project/editVisualManual", editVisualManual_default);
      app2.use("/api/project/getModelDetails", getModelDetails_default);
      app2.use("/api/project/getProject", getProject_default);
      app2.use("/api/project/getSingleProject", getSingleProject_default2);
      app2.use("/api/project/getVisualManual", getVisualManual_default);
      app2.use("/api/project/queryDirectorManual", queryDirectorManual_default);
      app2.use("/api/project/visualManual", visualManual_default);
      app2.use("/api/script/addScript", addScript_default);
      app2.use("/api/script/batchAddScript", batchAddScript_default);
      app2.use("/api/script/delScript", delScript_default);
      app2.use("/api/script/exportScript", exportScript_default);
      app2.use("/api/script/extractAssets", extractAssets_default);
      app2.use("/api/script/getAiRegex", getAiRegex_default);
      app2.use("/api/script/getScrptApi", getScrptApi_default);
      app2.use("/api/script/pollScriptAssets", pollScriptAssets_default);
      app2.use("/api/script/updateScript", updateScript_default);
      app2.use("/api/scriptAgent/getPlanData", getPlanData_default);
      app2.use("/api/scriptAgent/setPlanData", setPlanData_default);
      app2.use("/api/scriptAgent/updateData", updateData_default);
      app2.use("/api/setting/about/checkUpdate", checkUpdate_default);
      app2.use("/api/setting/about/downloadApp", downloadApp_default);
      app2.use("/api/setting/agentDeploy/agentSetKey", agentSetKey_default);
      app2.use("/api/setting/agentDeploy/deployAgentModel", deployAgentModel_default);
      app2.use("/api/setting/agentDeploy/getAgentDeploy", getAgentDeploy_default);
      app2.use("/api/setting/agentDeploy/getAgentUseMode", getAgentUseMode_default);
      app2.use("/api/setting/agentDeploy/updateUseMode", updateUseMode_default);
      app2.use("/api/setting/dbConfig/clearData", clearData_default);
      app2.use("/api/setting/dbConfig/clearTable", clearTable_default);
      app2.use("/api/setting/dbConfig/dbInfo", dbInfo_default);
      app2.use("/api/setting/dbConfig/exportData", exportData_default);
      app2.use("/api/setting/dbConfig/importData", importData_default);
      app2.use("/api/setting/dev/getSwitchAiDevTool", getSwitchAiDevTool_default);
      app2.use("/api/setting/dev/updateSwitchAiDevTool", updateSwitchAiDevTool_default);
      app2.use("/api/setting/fileManagement/openFolder", openFolder_default);
      app2.use("/api/setting/getTextModel", getTextModel_default);
      app2.use("/api/setting/loginConfig/getUser", getUser_default);
      app2.use("/api/setting/loginConfig/updateUserPwd", updateUserPwd_default);
      app2.use("/api/setting/memoryConfig/delAllMemory", delAllMemory_default);
      app2.use("/api/setting/memoryConfig/getMemory", getMemory_default2);
      app2.use("/api/setting/memoryConfig/sureMemory", sureMemory_default);
      app2.use("/api/setting/modelMap/bindingPrompt", bindingPrompt_default);
      app2.use("/api/setting/modelMap/deletePrompt", deletePrompt_default);
      app2.use("/api/setting/modelMap/getImageAndVideoModel", getImageAndVideoModel_default);
      app2.use("/api/setting/modelMap/getPromptList", getPromptList_default);
      app2.use("/api/setting/modelMap/savePrompt", savePrompt_default);
      app2.use("/api/setting/modelMap/updatePrompt", updatePrompt_default);
      app2.use("/api/setting/promptManage/getPrompt", getPrompt_default);
      app2.use("/api/setting/promptManage/updatePrompt", updatePrompt_default2);
      app2.use("/api/setting/skillManagement/getSkillContent", getSkillContent_default);
      app2.use("/api/setting/skillManagement/getSkillList", getSkillList_default);
      app2.use("/api/setting/skillManagement/saveSkillContent", saveSkillContent_default);
      app2.use("/api/setting/vendorConfig/addVendor", addVendor_default);
      app2.use("/api/setting/vendorConfig/addVendorModel", addVendorModel_default);
      app2.use("/api/setting/vendorConfig/deleteVendor", deleteVendor_default);
      app2.use("/api/setting/vendorConfig/delVendorModel", delVendorModel_default);
      app2.use("/api/setting/vendorConfig/enableVendor", enableVendor_default);
      app2.use("/api/setting/vendorConfig/getCodeByLink", getCodeByLink_default);
      app2.use("/api/setting/vendorConfig/getVendorList", getVendorList_default);
      app2.use("/api/setting/vendorConfig/modelTest", modelTest_default);
      app2.use("/api/setting/vendorConfig/modelTest/imageTest", imageTest_default);
      app2.use("/api/setting/vendorConfig/modelTest/textTest", textTest_default);
      app2.use("/api/setting/vendorConfig/modelTest/videoTest", videoTest_default);
      app2.use("/api/setting/vendorConfig/updateCode", updateCode_default);
      app2.use("/api/setting/vendorConfig/updateVendorInputs", updateVendorInputs_default);
      app2.use("/api/setting/vendorConfig/upVendorModel", upVendorModel_default);
      app2.use("/api/task/getProject", getProject_default2);
      app2.use("/api/task/getTaskApi", getTaskApi_default);
      app2.use("/api/task/getTaskCategories", getTaskCategories_default);
      app2.use("/api/task/taskDetails", taskDetails_default);
      app2.use("/api/test/test", test_default);
    };
  }
});

// src/app.ts
var app_exports = {};
__export(app_exports, {
  closeServe: () => closeServe,
  default: () => startServe
});
module.exports = __toCommonJS(app_exports);

// src/err.ts
init_serialize_error();
process.on("unhandledRejection", (reason, promise3) => {
  console.error("[\u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD]");
  if (reason instanceof Error) {
    console.error("\u9519\u8BEF\u540D\u79F0:", reason.name);
    console.error("\u9519\u8BEF\u6D88\u606F:", reason.message);
    console.error("\u5806\u6808\u4FE1\u606F:", reason.stack);
    console.error("\u5E8F\u5217\u5316\u8BE6\u60C5:", JSON.stringify(serializeError(reason), null, 2));
  } else {
    console.error("\u539F\u56E0:", reason);
    console.error("\u7C7B\u578B:", typeof reason);
    try {
      console.error("JSON:", JSON.stringify(reason, null, 2));
    } catch {
      console.error("(\u65E0\u6CD5\u5E8F\u5217\u5316)");
    }
  }
  console.error("Promise:", promise3);
});
process.on("uncaughtException", (error73) => {
  console.error("[\u672A\u6355\u83B7\u7684\u5F02\u5E38]");
  console.error("\u9519\u8BEF\u540D\u79F0:", error73.name);
  console.error("\u9519\u8BEF\u6D88\u606F:", error73.message);
  console.error("\u5806\u6808\u4FE1\u606F:", error73.stack);
  console.error("\u5E8F\u5217\u5316\u8BE6\u60C5:", JSON.stringify(serializeError(error73), null, 2));
});

// src/env.ts
var import_dotenv = __toESM(require_main());
import_dotenv.default.config({ path: ".env.local" });
import_dotenv.default.config({ path: "env.production" });
import_dotenv.default.config();
var isElectron = typeof process.versions?.electron !== "undefined";
var isPackaged = false;
if (isElectron) {
  const { app: app2 } = require("electron");
  isPackaged = app2.isPackaged;
}
var env = process.env.NODE_ENV;
if (!env) {
  if (isElectron) process.env.NODE_ENV = "prod";
  else process.env.NODE_ENV = "dev";
  console.log(`[\u73AF\u5883\u53D8\u91CF\uFF1A${process.env.NODE_ENV}]`);
}

// src/app.ts
var import_express173 = __toESM(require_express2());

// node_modules/socket.io/wrapper.mjs
var import_dist = __toESM(require_dist3(), 1);
var { Server, Namespace, Socket } = import_dist.default;

// src/app.ts
var import_node_http = __toESM(require("node:http"));
var import_express_ws = __toESM(require_express_ws());
var import_morgan = __toESM(require_morgan());
var import_cors = __toESM(require_lib3());

// src/core.ts
var import_fast_glob = __toESM(require_out4());
var import_path = __toESM(require("path"));
var import_promises = require("fs/promises");
var import_crypto = __toESM(require("crypto"));
function fileNameToRoutePath(fileName) {
  let routePath = fileName.replace(/\.(ts)$/, "");
  routePath = routePath.split(import_path.default.sep).join("/");
  routePath = routePath.replace(/\[([^\]]+)\]/g, (_, p1) => p1.startsWith("...") ? "*" : `:${p1}`);
  if (routePath === "index") return "/";
  routePath = routePath.replace(/\/index$/, "");
  routePath = "/" + routePath.replace(/\/+/g, "/").replace(/\/$/, "");
  return routePath;
}
async function generateRouter() {
  let entries = await (0, import_fast_glob.default)(["src/routes/**/*.ts"]);
  entries = entries.sort((a, b) => a.localeCompare(b));
  const importLines = [];
  const routeModulePairs = [];
  entries.forEach((entry, i) => {
    const varName = `route${i + 1}`;
    let importPath = import_path.default.relative("src", entry).replace(/\\/g, "/");
    if (!importPath.startsWith(".")) importPath = "./" + importPath;
    importPath = importPath.replace(/\.ts$/, "");
    importLines.push(`import ${varName} from "${importPath}";`);
    const routeKey = import_path.default.relative("src/routes", entry).replace(/\\/g, "/");
    const routePath = fileNameToRoutePath(routeKey);
    routeModulePairs.push({ routePath, varName, entry });
  });
  const routerData = JSON.stringify(routeModulePairs.map(({ routePath, varName }) => ({ routePath, varName })));
  const hash3 = import_crypto.default.createHash("md5").update(routerData).digest("hex");
  let content = `// @routes-hash ${hash3}
import { Express } from "express";

`;
  content += `${importLines.join("\n")}

`;
  content += `export default async (app: Express) => {
`;
  for (const { routePath, varName } of routeModulePairs) {
    content += `  app.use("/api${routePath}", ${varName});
`;
  }
  content += `}
`;
  let needWrite = true;
  try {
    const current = await (0, import_promises.readFile)("src/router.ts", "utf8");
    const match = current.match(/^\/\/\s*@routes-hash\s*([a-z0-9]+)\n/);
    const currentHash = match ? match[1] : null;
    if (currentHash === hash3) {
      needWrite = false;
    }
  } catch {
    needWrite = true;
  }
  if (needWrite) await (0, import_promises.writeFile)("src/router.ts", content, "utf8");
}

// src/app.ts
var import_path29 = __toESM(require("path"));
var import_fs18 = __toESM(require("fs"));
init_utils3();

// src/socket/routes/productionAgent.ts
init_utils3();

// src/agents/productionAgent/index.ts
init_zod();
init_dist22();
init_utils3();

// src/utils/agent/memory.ts
init_utils3();
init_dist_node();
init_embedding();
init_dist22();
init_zod();
init_userConfig();
var DEFAULTS = {
  messagesPerSummary: 3,
  // 每累积多少条message触发一次summary生成
  summaryMaxLength: 500,
  // summary最大字符长度
  shortTermLimit: 5,
  // get()返回的近期未总结message条数
  summaryLimit: 10,
  // get()返回的summary条数
  ragLimit: 3,
  // get()向量相似搜索返回的message条数
  deepRetrieveSummaryLimit: 5
  // deepRetrieve()向量召回summary的条数
};
function vectorSearch(rows, queryEmbedding, limit) {
  return rows.map((row) => {
    const emb = JSON.parse(row.embedding ?? "[]");
    return { ...row, similarity: cosineSimilarity(queryEmbedding, emb) };
  }).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
}
var Memory = class {
  agentType;
  isolationKey;
  constructor(agentType, isolationKey) {
    this.agentType = agentType;
    this.isolationKey = isolationKey;
  }
  async generateSummary(contents) {
    const { summaryMaxLength } = await this.getConfigData({ summaryMaxLength: DEFAULTS.summaryMaxLength });
    const { text: text2 } = await utils_default.Ai.Text(this.agentType).invoke({
      system: `\u4F60\u662F\u4E00\u4E2A\u8BB0\u5FC6\u538B\u7F29\u52A9\u624B\u3002\u8BF7\u5C06\u4EE5\u4E0B\u591A\u6761\u8BB0\u5FC6\u5185\u5BB9\u538B\u7F29\u4E3A\u4E00\u6BB5\u7B80\u6D01\u7684\u6458\u8981\uFF0C\u4E0D\u8D85\u8FC7${summaryMaxLength}\u4E2A\u5B57\u7B26\u3002\u53EA\u8F93\u51FA\u6458\u8981\u5185\u5BB9\uFF0C\u4E0D\u8981\u52A0\u4EFB\u4F55\u524D\u7F00\u6216\u89E3\u91CA\u3002`,
      messages: [{ role: "user", content: contents.map((c, i) => `${i + 1}. ${c}`).join("\n") }]
    });
    return text2.slice(0, Number(summaryMaxLength));
  }
  async judgeSummaryRelevance(keyword, summaries) {
    const list2 = summaries.map((s) => `[${s.id}] ${s.content}`).join("\n");
    const { text: text2 } = await utils_default.Ai.Text(this.agentType).invoke({
      system: '\u4F60\u662F\u4E00\u4E2A\u4FE1\u606F\u68C0\u7D22\u52A9\u624B\u3002\u7528\u6237\u4F1A\u7ED9\u4F60\u4E00\u4E2A\u5173\u952E\u8BCD\u548C\u4E00\u7EC4\u6458\u8981\uFF0C\u8BF7\u5224\u65AD\u54EA\u4E9B\u6458\u8981\u53EF\u80FD\u5305\u542B\u4E0E\u5173\u952E\u8BCD\u76F8\u5173\u7684\u8BE6\u7EC6\u4FE1\u606F\u3002\u53EA\u8FD4\u56DE\u76F8\u5173\u6458\u8981\u7684id\u5217\u8868\uFF0C\u7528JSON\u6570\u7EC4\u683C\u5F0F\uFF0C\u4F8B\u5982 ["id1","id2"]\u3002\u4E0D\u8981\u89E3\u91CA\u3002',
      messages: [{ role: "user", content: `\u5173\u952E\u8BCD: ${keyword}

\u6458\u8981\u5217\u8868:
${list2}` }]
    });
    try {
      const ids = JSON.parse(text2);
      if (Array.isArray(ids)) return ids.map(String);
    } catch {
    }
    return [];
  }
  async getConfigData(defaults2) {
    const keys2 = Object.keys(defaults2);
    const result = { ...defaults2 };
    for (const key of keys2) {
      const raw = await getUserSettingValue(key);
      if (raw == null) continue;
      const num = Number(raw);
      result[key] = Number.isNaN(num) ? raw : num;
    }
    return result;
  }
  async add(role = "user", content, options) {
    const { messagesPerSummary } = await this.getConfigData({ messagesPerSummary: DEFAULTS.messagesPerSummary });
    const id = v4_default();
    const embedding = await getEmbedding(content);
    const isolationKey = this.isolationKey;
    await utils_default.db("memories").insert({
      id,
      isolationKey,
      type: "message",
      role,
      name: options?.name,
      content,
      embedding: JSON.stringify(embedding),
      relatedMessageIds: null,
      summarized: 0,
      createTime: options?.createTime ?? Date.now()
    });
    const unsummarized = await utils_default.db("memories").where({ isolationKey, type: "message", summarized: 0 }).orderBy("createTime", "asc");
    if (unsummarized.length >= Number(messagesPerSummary)) {
      const batch = unsummarized.slice(0, Number(messagesPerSummary));
      const batchIds = batch.map((m) => m.id);
      const batchContents = batch.map((m) => m.content);
      const summaryContent = await this.generateSummary(batchContents);
      const summaryEmbedding = await getEmbedding(summaryContent);
      const summaryId = v4_default();
      await utils_default.db("memories").insert({
        id: summaryId,
        isolationKey,
        type: "summary",
        content: summaryContent,
        embedding: JSON.stringify(summaryEmbedding),
        relatedMessageIds: JSON.stringify(batchIds),
        summarized: 0,
        createTime: Date.now()
      });
      await utils_default.db("memories").whereIn("id", batchIds).update({ summarized: 1 });
    }
  }
  async get(text2) {
    const { shortTermLimit, summaryLimit, ragLimit } = await this.getConfigData({
      shortTermLimit: DEFAULTS.shortTermLimit,
      summaryLimit: DEFAULTS.summaryLimit,
      ragLimit: DEFAULTS.ragLimit
    });
    const isolationKey = this.isolationKey;
    const shortTerm = await utils_default.db("memories").where({ isolationKey, type: "message", summarized: 0 }).orderBy("createTime", "desc").limit(Number(shortTermLimit));
    shortTerm.reverse();
    const summaries = await utils_default.db("memories").where({ isolationKey, type: "summary" }).orderBy("createTime", "desc").limit(Number(summaryLimit));
    summaries.reverse();
    const queryEmbedding = await getEmbedding(text2);
    const allMessages = await utils_default.db("memories").where({ isolationKey, type: "message" });
    const ragResults = vectorSearch(allMessages, queryEmbedding, Number(ragLimit));
    return {
      shortTerm: shortTerm.map((m) => ({ id: m.id, role: m.role, name: m.name, content: m.content, createTime: m.createTime })),
      summaries: summaries.map((s) => ({
        id: s.id,
        content: s.content,
        relatedMessageIds: JSON.parse(s.relatedMessageIds || "[]"),
        createTime: s.createTime
      })),
      rag: ragResults.map((r) => ({ id: r.id, content: r.content, similarity: r.similarity }))
    };
  }
  async deepRetrieve(keyword) {
    const { deepRetrieveSummaryLimit } = await this.getConfigData({ deepRetrieveSummaryLimit: DEFAULTS.deepRetrieveSummaryLimit });
    const isolationKey = this.isolationKey;
    const queryEmbedding = await getEmbedding(keyword);
    const allSummaries = await utils_default.db("memories").where({ isolationKey, type: "summary" });
    const topSummaries = vectorSearch(allSummaries, queryEmbedding, Number(deepRetrieveSummaryLimit));
    if (topSummaries.length === 0) return [];
    const relevantIds = await this.judgeSummaryRelevance(
      keyword,
      topSummaries.map((s) => ({ id: s.id, content: s.content }))
    );
    if (relevantIds.length === 0) return [];
    const relevantSummaries = topSummaries.filter((s) => relevantIds.includes(s.id));
    const messageIds = relevantSummaries.flatMap((s) => JSON.parse(s.relatedMessageIds || "[]"));
    if (messageIds.length === 0) return [];
    const messages = await utils_default.db("memories").whereIn("id", messageIds).orderBy("createTime", "asc");
    return messages.map((m) => ({ id: m.id, content: m.content, createTime: m.createTime }));
  }
  getTools() {
    return {
      deepRetrieve: tool({
        description: "\u6DF1\u5EA6\u68C0\u7D22\u8BB0\u5FC6\uFF1A\u5F53\u4F60\u9700\u8981\u56DE\u5FC6\u4E0E\u67D0\u4E2A\u5173\u952E\u8BCD\u76F8\u5173\u7684\u8BE6\u7EC6\u5386\u53F2\u4FE1\u606F\u65F6\u4F7F\u7528\u6B64\u5DE5\u5177",
        inputSchema: jsonSchema(
          external_exports.object({
            keyword: external_exports.string().describe("\u8981\u68C0\u7D22\u7684\u5173\u952E\u8BCD")
          }).toJSONSchema()
        ),
        execute: async ({ keyword }) => {
          const results = await this.deepRetrieve(keyword);
          if (results.length === 0) return { found: false, message: "\u672A\u627E\u5230\u76F8\u5173\u8BB0\u5FC6" };
          return { found: true, memories: results.map((r) => r.content) };
        }
      })
    };
  }
};
var memory_default = Memory;

// src/utils/agent/skillsTools.ts
init_zod();
init_dist22();
var import_path9 = __toESM(require("path"));
init_is_path_inside();
init_getPath();
var fs10 = __toESM(require("fs"));
var import_fast_glob2 = __toESM(require_out4());
function toUnixPath(filePath) {
  return filePath.replace(/\\/g, "/");
}
function ensureNonEmptyBody(body, fallback) {
  const trimmed = body.trim();
  return trimmed.length > 0 ? trimmed : fallback;
}
function parseFrontmatter(content) {
  const match = content.match(/^\uFEFF?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/);
  if (!match?.[1]) {
    throw new Error(`\u6280\u80FD\u6587\u4EF6\u7F3A\u5C11\u6709\u6548\u7684 frontmatter\uFF0C\u786E\u4FDD\u4EE5 --- \u5305\u88F9\u5E76\u5305\u542B name \u548C description \u5B57\u6BB5\u3002${content}`);
  }
  const result = {};
  const lines = match[1].split(/\r?\n/);
  for (let i = 0; i < lines.length; ) {
    const line = lines[i];
    const trimmed = line.trim();
    if (!trimmed || trimmed.startsWith("#")) {
      i++;
      continue;
    }
    const keyMatch = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
    if (!keyMatch) {
      i++;
      continue;
    }
    const key = keyMatch[1].trim();
    const rawValue = (keyMatch[2] ?? "").trim();
    i++;
    if (!key) continue;
    if (/^[>|][+-]?[0-9]*$/.test(rawValue)) {
      const isFolded = rawValue.startsWith(">");
      const blockLines = [];
      let blockIndent = null;
      while (i < lines.length) {
        const current = lines[i];
        const currentTrimmed = current.trim();
        if (currentTrimmed === "") {
          if (blockIndent !== null) blockLines.push("");
          i++;
          continue;
        }
        const currentIndent = current.match(/^\s*/)?.[0].length ?? 0;
        if (blockIndent === null) {
          blockIndent = currentIndent;
        }
        if (currentIndent < blockIndent) break;
        blockLines.push(current.slice(blockIndent));
        i++;
      }
      result[key] = isFolded ? blockLines.join("\n").replace(/\n{2,}/g, "\n\n").replace(/([^\n])\n([^\n])/g, "$1 $2").trim() : blockLines.join("\n").trim();
      continue;
    }
    const unquoted = rawValue.replace(/^(['"])([\s\S]*)\1$/, "$2");
    result[key] = unquoted;
  }
  if (!result.name || !result.description) {
    throw new Error(`\u6280\u80FD\u6587\u4EF6\u7F3A\u5C11\u5FC5\u8981\u5B57\u6BB5: name \u6216 description\uFF0C\u786E\u4FDD frontmatter \u5305\u542B\u8FD9\u4E24\u4E2A\u5B57\u6BB5\u3002${content}`);
  }
  return { name: result.name, description: result.description };
}
function createSkillTools(skills, skillPaths, rootDir = getPath_default("skills")) {
  const activated = /* @__PURE__ */ new Set();
  const skillsRootDir = import_path9.default.resolve(rootDir);
  const skillNames = skills.map((s) => s.name);
  const skillMap = new Map(skillPaths.mainSkill.map((s) => [s.name, s]));
  return {
    activate_skill: tool({
      description: `\u6FC0\u6D3B\u4E00\u4E2A\u6280\u80FD\uFF0C\u52A0\u8F7D\u5176\u5B8C\u6574\u6307\u4EE4\u548C\u6346\u7ED1\u8D44\u6E90\u5217\u8868\u5230\u4E0A\u4E0B\u6587\u3002\u53EF\u7528\u6280\u80FD\uFF1A${skillNames.join(", ")}`,
      inputSchema: jsonSchema(
        external_exports.object({
          name: external_exports.enum(skillNames).describe("\u8981\u6FC0\u6D3B\u7684\u6280\u80FD\u540D\u79F0")
        }).toJSONSchema()
      ),
      execute: async ({ name: name28 }) => {
        if (activated.has(name28)) {
          console.log(`\u26A1[\u4E3B\u6280\u80FD] \u2139\uFE0F \u6280\u80FD "${name28}" \u5DF2\u6FC0\u6D3B\uFF0C\u8DF3\u8FC7\u91CD\u590D\u6CE8\u5165`);
          return { alreadyActive: true, message: `\u6280\u80FD "${name28}" \u5DF2\u6FC0\u6D3B\uFF0C\u65E0\u9700\u91CD\u590D\u52A0\u8F7D` };
        }
        const matched = skillMap.get(name28);
        if (!matched) return { error: `\u672A\u627E\u5230\u6280\u80FD "${name28}"` };
        let raw = "";
        try {
          raw = await fs10.promises.readFile(matched.path, "utf-8");
          console.log(`\u26A1[\u4E3B\u6280\u80FD] \u2713 \u5DF2\u8BFB\u53D6\u4E3B\u6280\u80FD\u6587\u4EF6\uFF1A ${matched.path}\uFF08${raw.length} \u5B57\u7B26\uFF09`);
        } catch (error73) {
          console.log(`\u26A1[\u4E3B\u6280\u80FD] \u2717 \u8BFB\u53D6\u5931\u8D25\uFF1A\u672A\u627E\u5230\u6587\u4EF6 "${matched.path}"`);
        }
        activated.add(name28);
        console.log(`\u26A1[\u4E3B\u6280\u80FD] \u2713 \u6280\u80FD "${name28}" \u5DF2\u6FC0\u6D3B`);
        const body = ensureNonEmptyBody(raw.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, ""), "\u8BE5\u6280\u80FD\u6587\u4EF6\u65E0\u6B63\u6587\u5185\u5BB9\u3002");
        let content = "";
        content = `<skill_content name="${name28}">
`;
        content += body + "\n\n";
        content += "\u4F7F\u7528 read_skill_file \u5DE5\u5177\u8BFB\u53D6\u8D44\u6E90\u6587\u4EF6\u3002\n";
        if (skillPaths.secondarySkills.length > 0) {
          content += "\n<skill_resources>\n";
          for (const path33 of skillPaths.secondarySkills) {
            content += `  <file>${path33}</file>
`;
          }
          content += "</skill_resources>\n";
        }
        content += "</skill_content>";
        return { content };
      }
    }),
    read_skill_file: tool({
      description: "\u8BFB\u53D6\u5DF2\u6FC0\u6D3B\u6280\u80FD\u76EE\u5F55\u4E0B\u7684\u8D44\u6E90\u6587\u4EF6\u3002\u4F20\u5165 activate_skill \u8FD4\u56DE\u7684 skill_resources \u4E2D\u7684\u6587\u4EF6\u8DEF\u5F84\u3002",
      inputSchema: jsonSchema(
        external_exports.object({
          filePath: external_exports.string().describe("\u8D44\u6E90\u6587\u4EF6\u7684\u76F8\u5BF9\u8DEF\u5F84\uFF0C\u6765\u81EA activate_skill \u8FD4\u56DE\u7684 skill_resources")
        }).toJSONSchema()
      ),
      execute: async ({ filePath }) => {
        const normalizedInputPath = toUnixPath(filePath).trim();
        if (!normalizedInputPath) {
          console.log(`\u{1F4D6}[\u6280\u6CD5\u6587\u4EF6] \u2717 filePath \u4E0D\u80FD\u4E3A\u7A7A`);
          return { error: "filePath \u4E0D\u80FD\u4E3A\u7A7A" };
        }
        const fullPath = import_path9.default.resolve(import_path9.default.join(skillsRootDir, normalizedInputPath));
        if (!(fullPath === skillsRootDir || isPathInside(fullPath, skillsRootDir))) {
          console.log(`\u{1F4D6}[\u6280\u6CD5\u6587\u4EF6] \u2717 \u8DEF\u5F84\u8D8A\u754C\u5DF2\u62E6\u622A\uFF1A"${filePath}" \u8D85\u51FA\u6280\u80FD\u76EE\u5F55\u8303\u56F4`);
          return { error: "Access denied: path is outside skill directory" };
        }
        let body = "";
        try {
          body = await fs10.promises.readFile(fullPath, "utf-8");
          console.log(`\u{1F4D6}[\u6280\u6CD5\u6587\u4EF6] \u2713 \u5DF2\u8BFB\u53D6\u6587\u4EF6\uFF1A ${filePath}\uFF08${body.length} \u5B57\u7B26\uFF09`);
        } catch {
          console.log(`\u{1F4D6}[\u6280\u6CD5\u6587\u4EF6] \u2717 \u8BFB\u53D6\u5931\u8D25\uFF1A\u672A\u627E\u5230\u6587\u4EF6 "${filePath}"`);
          return { error: `File not found: ${filePath}` };
        }
        const safeBody = ensureNonEmptyBody(body, "\u8BE5\u8D44\u6E90\u6587\u4EF6\u4E3A\u7A7A\u3002");
        let content = "";
        content = `<skill_content>
`;
        content += safeBody + "\n\n";
        content += "\u53EF\u4EE5\u4F7F\u7528 read_skill_file \u5DE5\u5177\u8BFB\u53D6\u8D44\u6E90\u6587\u4EF6\u3002\n";
        if (skillPaths.tertiarySkills.length > 0) {
          content += "\n<skill_resources>\n";
          for (const path33 of skillPaths.tertiarySkills) {
            content += `  <file>${path33}</file>
`;
          }
          content += "</skill_resources>\n";
        }
        content += "</skill_content>";
        return { content };
      }
    })
  };
}
async function scanSkills(folderPath) {
  const unixPath = toUnixPath(folderPath);
  const entries = await (0, import_fast_glob2.default)(unixPath, {
    onlyFiles: true,
    absolute: true
  });
  return entries;
}

// src/agents/productionAgent/tools.ts
init_dist22();
init_zod();
init_utils3();
var deriveAssetSchema = external_exports.object({
  id: external_exports.number().describe("\u884D\u751F\u8D44\u4EA7ID,\u5982\u679C\u65B0\u589E\u5219\u4E3A\u7A7A"),
  assetsId: external_exports.number().describe("\u5173\u8054\u7684\u8D44\u4EA7ID"),
  prompt: external_exports.string().describe("\u751F\u6210\u63D0\u793A\u8BCD"),
  name: external_exports.string().describe("\u884D\u751F\u8D44\u4EA7\u540D\u79F0"),
  desc: external_exports.string().describe("\u884D\u751F\u8D44\u4EA7\u63CF\u8FF0"),
  src: external_exports.string().nullable().describe("\u884D\u751F\u8D44\u4EA7\u8D44\u6E90\u8DEF\u5F84"),
  state: external_exports.enum(["\u672A\u751F\u6210", "\u751F\u6210\u4E2D", "\u5DF2\u5B8C\u6210", "\u751F\u6210\u5931\u8D25"]).describe("\u884D\u751F\u8D44\u4EA7\u751F\u6210\u72B6\u6001"),
  type: external_exports.enum(["role", "tool", "scene", "clip"]).describe("\u884D\u751F\u8D44\u4EA7\u7C7B\u578B")
});
var assetItemSchema = external_exports.object({
  id: external_exports.number().describe("\u8D44\u4EA7\u552F\u4E00\u6807\u8BC6"),
  name: external_exports.string().describe("\u8D44\u4EA7\u540D\u79F0"),
  type: external_exports.enum(["role", "tool", "scene", "clip"]).describe("\u8D44\u4EA7\u7C7B\u578B"),
  prompt: external_exports.string().describe("\u751F\u6210\u63D0\u793A\u8BCD"),
  desc: external_exports.string().describe("\u8D44\u4EA7\u63CF\u8FF0"),
  derive: external_exports.array(deriveAssetSchema).describe("\u884D\u751F\u8D44\u4EA7\u5217\u8868")
});
var storyboardSchema = external_exports.object({
  id: external_exports.number().describe("\u5206\u955CID\uFF0C\u5FC5\u987B\u4E3A\u771F\u5B9Eid"),
  duration: external_exports.number().describe("\u6301\u7EED\u65F6\u957F(\u79D2)"),
  prompt: external_exports.string().describe("\u751F\u6210\u63D0\u793A\u8BCD"),
  associateAssetsIds: external_exports.array(external_exports.number()).describe("\u5173\u8054\u8D44\u4EA7ID\u5217\u8868"),
  src: external_exports.string().nullable().describe("\u5206\u955C\u8D44\u6E90\u8DEF\u5F84"),
  index: external_exports.number().nullable().optional().describe("\u5206\u955C\u6392\u5E8F\u5B57\u6BB5")
});
var workbenchDataSchema = external_exports.object({
  name: external_exports.string().describe("\u9879\u76EE\u540D\u79F0"),
  duration: external_exports.string().describe("\u89C6\u9891\u65F6\u957F"),
  resolution: external_exports.string().describe("\u5206\u8FA8\u7387"),
  fps: external_exports.string().describe("\u5E27\u7387"),
  cover: external_exports.string().optional().describe("\u5C01\u9762\u56FE\u7247\u8DEF\u5F84"),
  gradient: external_exports.string().optional().describe("\u6E10\u53D8\u8272\u914D\u7F6E")
});
var posterItemSchema = external_exports.object({
  id: external_exports.number().describe("\u6D77\u62A5ID"),
  image: external_exports.string().describe("\u6D77\u62A5\u56FE\u7247\u8DEF\u5F84")
});
var flowDataSchema = external_exports.object({
  script: external_exports.string().describe("\u5267\u672C\u5185\u5BB9"),
  scriptPlan: external_exports.string().describe("\u62CD\u6444\u8BA1\u5212"),
  assets: external_exports.array(assetItemSchema).describe("\u884D\u751F\u8D44\u4EA7"),
  storyboardTable: external_exports.string().describe("\u5206\u955C\u8868"),
  storyboard: external_exports.array(storyboardSchema).describe("\u5206\u955C\u9762\u677F")
});
var keySchema = external_exports.enum(Object.keys(flowDataSchema.shape));
var flowDataKeyLabels = Object.fromEntries(
  Object.entries(flowDataSchema.shape).map(([key, schema]) => [key, schema.description ?? key])
);
var tools_default = (toolCpnfig) => {
  const { resTool, toolsNames, msg } = toolCpnfig;
  const { socket } = resTool;
  const tools = {
    get_flowData: tool({
      description: "\u83B7\u53D6\u5DE5\u4F5C\u533A\u6570\u636E",
      inputSchema: jsonSchema(
        external_exports.object({
          key: keySchema.describe("\u6570\u636Ekey")
        }).toJSONSchema()
      ),
      execute: async ({ key }) => {
        const thinking = msg.thinking(`\u6B63\u5728\u83B7\u53D6${flowDataKeyLabels[key]}\u5DE5\u4F5C\u533A\u6570\u636E...`);
        console.log("[tools] get_flowData", key);
        const flowData = await new Promise((resolve3) => socket.emit("getFlowData", { key }, (res) => resolve3(res)));
        thinking.appendText(`\u83B7\u53D6\u5230${flowDataKeyLabels[key]}:
` + JSON.stringify(flowData[key], null, 2));
        thinking.updateTitle(`\u83B7\u53D6${flowDataKeyLabels[key]}\u5B8C\u6210`);
        thinking.complete();
        return flowData[key];
      }
    }),
    add_deriveAsset: tool({
      description: "\u65B0\u589E\u6216\u66F4\u65B0\u884D\u751F\u8D44\u4EA7",
      inputSchema: jsonSchema(
        external_exports.object({
          assetsId: external_exports.number().describe("\u5173\u8054\u7684\u8D44\u4EA7ID"),
          id: external_exports.number().nullable().describe("\u884D\u751F\u8D44\u4EA7ID,\u5982\u679C\u65B0\u589E\u5219\u4E3A\u7A7A"),
          name: external_exports.string().describe("\u884D\u751F\u8D44\u4EA7\u540D\u79F0"),
          desc: external_exports.string().describe("\u884D\u751F\u8D44\u4EA7\u63CF\u8FF0")
        }).toJSONSchema()
      ),
      execute: async (raw) => {
        const idRaw = raw.id;
        const normalizedId = idRaw === "null" || idRaw === "" || idRaw === void 0 ? null : idRaw;
        const deriveAsset = { ...raw, id: normalizedId };
        const thinking = msg.thinking("\u6B63\u5728\u64CD\u4F5C\u8D44\u4EA7...");
        const { projectId, scriptId } = resTool.data;
        const startTime = Date.now();
        const parentAssets = await utils_default.db("o_assets").where("id", deriveAsset.assetsId).select("id", "type").first();
        if (!parentAssets) return "\u5173\u8054\u7684\u8D44\u4EA7\u4E0D\u5B58\u5728";
        const data = {
          id: deriveAsset.id ?? void 0,
          assetsId: deriveAsset.assetsId,
          projectId,
          name: deriveAsset.name,
          type: parentAssets.type,
          describe: deriveAsset.desc,
          startTime
        };
        if (deriveAsset.id) {
          await utils_default.db("o_assets").where("id", deriveAsset.id).update(data);
          thinking.appendText(`\u5DF2\u66F4\u65B0\u884D\u751F\u8D44\u4EA7\uFF0CID: ${deriveAsset.id}
`);
        } else {
          const [insertedId] = await utils_default.db("o_assets").insert(data);
          data.id = insertedId;
          await utils_default.db("o_scriptAssets").insert({ scriptId, assetId: insertedId });
          thinking.appendText(`\u5DF2\u65B0\u589E\u884D\u751F\u8D44\u4EA7\uFF0CID: ${insertedId}
`);
        }
        const res = await new Promise((resolve3) => socket.emit("addDeriveAsset", data, (res2) => resolve3(res2)));
        thinking.updateTitle("\u8D44\u4EA7\u64CD\u4F5C\u5B8C\u6210");
        thinking.complete();
        return res ?? "\u64CD\u4F5C\u6210\u529F";
      }
    }),
    del_deriveAsset: tool({
      description: "\u5220\u9664\u884D\u751F\u8D44\u4EA7",
      inputSchema: jsonSchema(
        external_exports.object({
          assetsId: external_exports.number().describe("\u5173\u8054\u7684\u8D44\u4EA7ID"),
          id: external_exports.number().describe("\u884D\u751F\u8D44\u4EA7ID")
        }).toJSONSchema()
      ),
      execute: async ({ assetsId, id }) => {
        const thinking = msg.thinking("\u6B63\u5728\u64CD\u4F5C\u8D44\u4EA7...");
        const { scriptId } = resTool.data;
        await utils_default.db("o_assets").where("id", id).del();
        await utils_default.db("o_scriptAssets").where({ scriptId, assetId: id }).del();
        thinking.appendText(`\u5DF2\u5220\u9664\u884D\u751F\u8D44\u4EA7\uFF0CID: ${id}
`);
        const res = await new Promise((resolve3) => socket.emit("delDeriveAsset", { assetsId, id }, (res2) => resolve3(res2)));
        thinking.updateTitle("\u8D44\u4EA7\u64CD\u4F5C\u5B8C\u6210");
        thinking.complete();
        return res ?? "\u5220\u9664\u6210\u529F";
      }
    }),
    generate_deriveAsset: tool({
      description: "\u751F\u6210\u884D\u751F\u8D44\u4EA7\u56FE\u7247",
      inputSchema: jsonSchema(
        external_exports.object({
          ids: external_exports.array(external_exports.number()).describe("\u9700\u8981\u751F\u6210\u7684 \u884D\u751F\u8D44\u4EA7ID")
        }).toJSONSchema()
      ),
      execute: async ({ ids }) => {
        const thinking = msg.thinking("\u6B63\u5728\u751F\u6210\u884D\u751F\u8D44\u4EA7...");
        new Promise((resolve3) => socket.emit("generateDeriveAsset", { ids }, (res) => resolve3(res))).then((res) => {
          thinking.appendText(`\u5DF2\u751F\u6210\u884D\u751F\u8D44\u4EA7\uFF0CID: ${JSON.stringify(res, null, 2)}
`);
          thinking.updateTitle("\u884D\u751F\u8D44\u4EA7\u5F00\u59CB\u5B8C\u6210");
          thinking.complete();
        }).catch((e) => {
          thinking.appendText("\u884D\u751F\u8D44\u4EA7\u751F\u6210\u5931\u8D25:\n" + utils_default.error(e).message);
          thinking.updateTitle("\u884D\u751F\u8D44\u4EA7\u751F\u6210\u5931\u8D25");
          thinking.complete();
        });
        return "\u5F00\u59CB\u751F\u6210\u884D\u751F\u8D44\u4EA7";
      }
    }),
    generate_storyboard: tool({
      description: "\u751F\u6210\u5206\u955C\u56FE\u7247",
      inputSchema: jsonSchema(
        external_exports.object({
          ids: external_exports.array(external_exports.number()).describe("\u5FC5\u987B\u83B7\u53D6\u771F\u5B9E\u7684\u5206\u955CID\uFF0C\u652F\u6301\u6279\u91CF\u751F\u6210")
        }).toJSONSchema()
      ),
      execute: async ({ ids }) => {
        const thinking = msg.thinking("\u6B63\u5728\u751F\u6210\u5206\u955C...");
        new Promise((resolve3) => socket.emit("generateStoryboard", { ids }, (res) => resolve3(res))).then((res) => {
          thinking.appendText("\u751F\u6210\u7684\u5206\u955C\u6570\u636E:\n" + JSON.stringify(res, null, 2));
          thinking.updateTitle("\u5206\u955C\u751F\u6210\u5B8C\u6210");
          thinking.complete();
        }).catch((e) => {
          thinking.appendText("\u5206\u955C\u751F\u6210\u5931\u8D25:\n" + utils_default.error(e).message);
          thinking.updateTitle("\u5206\u955C\u751F\u6210\u5931\u8D25");
          thinking.complete();
        });
        return "\u5F00\u59CB\u751F\u6210\u5206\u955C";
      }
    })
  };
  return toolsNames ? Object.fromEntries(Object.entries(tools).filter(([n]) => toolsNames.includes(n))) : tools;
};

// src/agents/productionAgent/index.ts
var fs11 = __toESM(require("fs"));
var import_path10 = __toESM(require("path"));
function buildMemPrompt(mem) {
  let memoryContext = "";
  if (mem.rag.length) {
    memoryContext += `[\u76F8\u5173\u8BB0\u5FC6]
${mem.rag.map((r) => r.content).join("\n")}`;
  }
  if (mem.summaries.length) {
    if (memoryContext) memoryContext += "\n\n";
    memoryContext += `[\u5386\u53F2\u6458\u8981]
${mem.summaries.map((s, i) => `${i + 1}. ${s.content}`).join("\n")}`;
  }
  if (mem.shortTerm.length) {
    if (memoryContext) memoryContext += "\n\n";
    memoryContext += `[\u8FD1\u671F\u5BF9\u8BDD]
${mem.shortTerm.map((m) => `${m.role}: ${m.content}`).join("\n")}`;
  }
  return `## Memory
\u4EE5\u4E0B\u662F\u4F60\u5BF9\u7528\u6237\u7684\u8BB0\u5FC6\uFF0C\u53EF\u4F5C\u4E3A\u53C2\u8003\u4F46\u4E0D\u8981\u4E3B\u52A8\u63D0\u53CA\uFF1A
${memoryContext}`;
}
async function runDecisionAI(ctx) {
  const { isolationKey, text: text2, abortSignal } = ctx;
  const memory = new memory_default("productionAgent", isolationKey);
  await memory.add("user", text2);
  const skill = import_path10.default.join(utils_default.getPath("skills"), "production_agent_decision.md");
  const prompt = await fs11.promises.readFile(skill, "utf-8");
  const projectInfo = await utils_default.db("o_project").where("id", ctx.resTool.data.projectId).first();
  if (!projectInfo) throw new Error(`\u9879\u76EE\u4E0D\u5B58\u5728\uFF0CID: ${ctx.resTool.data.projectId}`);
  const [_, imageModelName] = projectInfo.imageModel.split(/:(.+)/);
  const [id, videoModelName] = projectInfo.videoModel.split(/:(.+)/);
  const models = await utils_default.vendor.getModelList(id);
  if (!models.length) throw new Error(`\u9879\u76EE\u4F7F\u7528\u7684\u6A21\u578B\u4E0D\u5B58\u5728\uFF0CID: ${projectInfo.videoModel}`);
  let videoMode = "";
  try {
    videoMode = JSON.parse(projectInfo.mode ?? "");
  } catch (e) {
    videoMode = projectInfo.mode ?? "";
  }
  const isRef = Array.isArray(videoMode) ? true : false;
  const modelInfo = `\u9879\u76EE\u4F7F\u7528\u7684\u6A21\u578B\u5982\u4E0B\uFF1A
\u56FE\u50CF\u6A21\u578B\uFF1A${imageModelName}
\u89C6\u9891\u6A21\u578B\uFF1A${videoModelName}
\u591A\u53C2\uFF1A${isRef ? "\u662F" : "\u5426"}`;
  const mem = buildMemPrompt(await memory.get(text2));
  const { fullStream } = await utils_default.Ai.Text("productionAgent:decisionAgent", ctx.thinkConfig.think, ctx.thinkConfig.thinlLevel).stream({
    messages: [
      { role: "system", content: prompt },
      { role: "assistant", content: mem + "\n" + modelInfo },
      { role: "user", content: text2 }
    ],
    abortSignal,
    tools: {
      ...memory.getTools(),
      ...tools_default({ resTool: ctx.resTool, msg: ctx.msg }),
      ...await createSubAgent(ctx)
    },
    onFinish: async (completion) => {
      await memory.add("assistant:decision", removeAllXmlTags(completion.text));
    }
  });
  let currentMsg = ctx.msg;
  await consumeFullStream(fullStream, currentMsg, () => {
    if (ctx.msg === currentMsg) return currentMsg;
    currentMsg.complete();
    currentMsg = ctx.msg;
    return currentMsg;
  });
}
async function createSubAgent(parentCtx) {
  const { resTool, abortSignal } = parentCtx;
  const memory = new memory_default("productionAgent", parentCtx.isolationKey);
  async function runAgent({
    key,
    prompt,
    system,
    name: name28,
    memoryKey,
    tools: extraTools,
    messages
  }) {
    parentCtx.msg.complete();
    const subMsg = resTool.newMessage("assistant", name28);
    const { fullStream } = await utils_default.Ai.Text(key, parentCtx.thinkConfig.think, parentCtx.thinkConfig.thinlLevel).stream({
      system,
      messages: messages ?? [{ role: "user", content: prompt }],
      abortSignal,
      tools: { ...extraTools, ...tools_default({ resTool, msg: subMsg }) }
    });
    const fullResponse = await consumeFullStream(fullStream, subMsg);
    if (fullResponse.trim()) {
      await memory.add(memoryKey, removeAllXmlTags(fullResponse), {
        name: name28,
        createTime: new Date(subMsg.datetime).getTime()
      });
    }
    parentCtx.msg = resTool.newMessage("assistant", "\u89C6\u9891\u7B56\u5212");
    return fullResponse;
  }
  const promptInput = external_exports.object({
    prompt: external_exports.string().describe("\u4EA4\u7ED9\u5B50Agent\u7684\u4EFB\u52A1\u7B80\u7EA6\u63CF\u8FF0\uFF0C100\u5B57\u4EE5\u5185")
  }).toJSONSchema();
  const projectInfo = await utils_default.db("o_project").where("id", resTool.data.projectId).first();
  if (!projectInfo) throw new Error(`\u9879\u76EE\u4E0D\u5B58\u5728\uFF0CID: ${resTool.data.projectId}`);
  const artSkills = await createArtSkills(projectInfo?.artStyle, projectInfo?.directorManual);
  const [_, imageModelName] = projectInfo.imageModel.split(/:(.+)/);
  const [id, videoModelName] = projectInfo.videoModel.split(/:(.+)/);
  const models = await utils_default.vendor.getModelList(id);
  if (!models.length) throw new Error(`\u9879\u76EE\u4F7F\u7528\u7684\u6A21\u578B\u4E0D\u5B58\u5728\uFF0CID: ${projectInfo.videoModel}`);
  let videoMode = "";
  try {
    videoMode = JSON.parse(projectInfo.mode ?? "");
  } catch (e) {
    videoMode = projectInfo.mode ?? "";
  }
  const isRef = Array.isArray(videoMode) ? true : false;
  const modelInfo = `\u9879\u76EE\u4F7F\u7528\u7684\u6A21\u578B\u5982\u4E0B\uFF1A
\u56FE\u50CF\u6A21\u578B\uFF1A${imageModelName}
\u89C6\u9891\u6A21\u578B\uFF1A${videoModelName}
\u591A\u53C2\uFF1A${isRef ? "\u662F" : "\u5426"}`;
  const run_sub_agent_derive_assets = tool({
    description: "\u8FD0\u884C\u6267\u884CsubAgent\u6765\u5B8C\u6210\u884D\u751F\u8D44\u4EA7\u5206\u6790\u4E0E\u4FE1\u606F\u5199\u5165\u76F8\u5173\u4EFB\u52A1",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path10.default.join(utils_default.getPath("skills"), "production_execution_derive_assets.md");
      const systemPrompt = await fs11.promises.readFile(skill, "utf-8");
      return runAgent({
        key: "productionAgent:deriveAssetsAgent",
        prompt,
        system: systemPrompt,
        name: "\u6267\u884C\u5BFC\u6F14",
        memoryKey: "assistant:execution",
        messages: [
          { role: "assistant", content: artSkills.prompt + `
${modelInfo}` },
          { role: "user", content: prompt }
        ],
        tools: { activate_skill: artSkills.tools.activate_skill }
      });
    }
  });
  const run_sub_agent_generate_assets = tool({
    description: "\u8FD0\u884C\u6267\u884CsubAgent\u6765\u5B8C\u6210\u884D\u751F\u8D44\u4EA7\u56FE\u7247\u751F\u6210\u76F8\u5173\u4EFB\u52A1",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path10.default.join(utils_default.getPath("skills"), "production_execution_generate_assets.md");
      const systemPrompt = await fs11.promises.readFile(skill, "utf-8");
      return runAgent({
        key: "productionAgent:generateAssetsAgent",
        prompt,
        system: systemPrompt,
        name: "\u6267\u884C\u5BFC\u6F14",
        memoryKey: "assistant:execution",
        messages: [
          { role: "assistant", content: artSkills.prompt + `
${modelInfo}` },
          { role: "user", content: prompt }
        ],
        tools: { activate_skill: artSkills.tools.activate_skill }
      });
    }
  });
  const run_sub_agent_director_plan = tool({
    description: "\u8FD0\u884C\u6267\u884CsubAgent\u6765\u5B8C\u6210\u5BFC\u6F14\u89C4\u5212\u76F8\u5173\u4EFB\u52A1",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path10.default.join(utils_default.getPath("skills"), "production_execution_director_plan.md");
      const systemPrompt = await fs11.promises.readFile(skill, "utf-8");
      const addPrompt = "\n\u4F60\u5FC5\u987B\u4F7F\u7528\u5982\u4E0BXML\u683C\u5F0F\u5199\u5165\u5DE5\u4F5C\u533A\uFF1A\n```\n<scriptPlan>\u5185\u5BB9</scriptPlan>\n```";
      return runAgent({
        key: "productionAgent:directorPlanAgent",
        prompt,
        system: systemPrompt + addPrompt,
        name: "\u6267\u884C\u5BFC\u6F14",
        memoryKey: "assistant:execution",
        messages: [
          { role: "assistant", content: artSkills.prompt + `
${modelInfo}` },
          { role: "user", content: prompt + addPrompt }
        ],
        tools: { activate_skill: artSkills.tools.activate_skill }
      });
    }
  });
  const run_sub_agent_storyboard_gen = tool({
    description: "\u8FD0\u884C\u6267\u884CsubAgent\u6765\u5B8C\u6210\u5206\u955C\u56FE\u751F\u6210\u76F8\u5173\u4EFB\u52A1",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path10.default.join(utils_default.getPath("skills"), "production_execution_storyboard_gen.md");
      const systemPrompt = await fs11.promises.readFile(skill, "utf-8");
      return runAgent({
        key: "productionAgent:storyboardGenAgent",
        prompt,
        system: systemPrompt,
        name: "\u6267\u884C\u5BFC\u6F14",
        memoryKey: "assistant:execution",
        messages: [
          { role: "assistant", content: artSkills.prompt + `
${modelInfo}` },
          { role: "user", content: prompt }
        ],
        tools: { activate_skill: artSkills.tools.activate_skill }
      });
    }
  });
  const productionSkills = await useProductionSkills(projectInfo?.artStyle, projectInfo?.directorManual);
  const run_sub_agent_storyboard_panel = tool({
    description: "\u8FD0\u884C\u6267\u884CsubAgent\u6765\u5B8C\u6210\u5206\u955C\u9762\u677F\u5199\u5165\u76F8\u5173\u4EFB\u52A1",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path10.default.join(utils_default.getPath("skills"), "production_execution_storyboard_panel.md");
      const systemPrompt = await fs11.promises.readFile(skill, "utf-8");
      const addPrompt = "\n\u4F60\u5FC5\u987B\u4F7F\u7528\u5982\u4E0BXML\u683C\u5F0F\u5199\u5165\u5DE5\u4F5C\u533A\uFF1A\n```\n<storyboardItem videoDesc='\u89C6\u9891\u63CF\u8FF0' prompt=\u63D0\u793A\u8BCD\u5185\u5BB9 track='\u5206\u7EC4' shouldGenerateImage='true/false' duration='\u89C6\u9891\u63A8\u8350\u65F6\u95F4' associateAssetsIds='[\u8BE5\u5206\u955C\u6240\u9700\u7684\u8D44\u4EA7ID\u5217\u8868]'></storyboardItem>\n```";
      return runAgent({
        key: "productionAgent:storyboardPanelAgent",
        prompt,
        system: systemPrompt + addPrompt,
        name: "\u6267\u884C\u5BFC\u6F14",
        memoryKey: "assistant:execution",
        messages: [
          { role: "assistant", content: productionSkills.prompt + `
${modelInfo}` },
          { role: "user", content: prompt + addPrompt }
        ],
        tools: { activate_skill: productionSkills.tools.activate_skill }
      });
    }
  });
  const run_sub_agent_storyboard_table = tool({
    description: "\u8FD0\u884C\u6267\u884CsubAgent\u6765\u5B8C\u6210\u5206\u955C\u8868\u6784\u5EFA\u76F8\u5173\u4EFB\u52A1",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path10.default.join(utils_default.getPath("skills"), "production_execution_storyboard_table.md");
      const systemPrompt = await fs11.promises.readFile(skill, "utf-8");
      const addPrompt = "\n\u4F60\u5FC5\u987B\u4F7F\u7528\u5982\u4E0BXML\u683C\u5F0F\u5199\u5165\u5DE5\u4F5C\u533A\uFF1A\n```\n<storyboardTable>\u5185\u5BB9</storyboardTable>\n```";
      return runAgent({
        key: "productionAgent:storyboardTableAgent",
        prompt,
        system: systemPrompt + addPrompt,
        name: "\u6267\u884C\u5BFC\u6F14",
        memoryKey: "assistant:execution",
        messages: [
          { role: "assistant", content: productionSkills.prompt + `
${modelInfo}` },
          { role: "user", content: prompt + addPrompt }
        ],
        tools: { activate_skill: productionSkills.tools.activate_skill }
      });
    }
  });
  const run_sub_agent_supervision = tool({
    description: "\u8FD0\u884C\u76D1\u7763\u5C42subAgent\u6267\u884C\u72EC\u7ACB\u4EFB\u52A1\uFF0C\u5B8C\u6210\u540E\u8FD4\u56DE\u7ED3\u679C",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path10.default.join(utils_default.getPath("skills"), "production_agent_supervision.md");
      const systemPrompt = await fs11.promises.readFile(skill, "utf-8");
      return runAgent({
        key: "productionAgent:supervisionAgent",
        prompt,
        system: systemPrompt,
        name: "\u76D1\u5236",
        memoryKey: "assistant:supervision"
      });
    }
  });
  return {
    run_sub_agent_derive_assets,
    run_sub_agent_generate_assets,
    run_sub_agent_director_plan,
    run_sub_agent_storyboard_gen,
    run_sub_agent_storyboard_panel,
    run_sub_agent_storyboard_table,
    run_sub_agent_supervision
  };
}
async function createArtSkills(artName, storyName) {
  const artWorkerPath = utils_default.getPath(["skills", "art_skills", artName, "driector_skills"]);
  const storyWorkerPath = utils_default.getPath(["skills", "story_skills", storyName, "driector_skills"]);
  const skillList = [...await scanSkills(artWorkerPath + "/*.md"), ...await scanSkills(storyWorkerPath + "/*.md")];
  const mainSkills = [];
  for (const skillPath of skillList) {
    if (!fs11.existsSync(skillPath)) throw new Error(`\u4E3B\u6280\u80FD\u6587\u4EF6\u4E0D\u5B58\u5728: ${skillPath}`);
    const content = await fs11.promises.readFile(skillPath, "utf-8");
    const parsed = parseFrontmatter(content);
    mainSkills.push({ path: skillPath, ...parsed });
  }
  const res = {
    prompt: `## Skills
\u4EE5\u4E0B\u6280\u80FD\u63D0\u4F9B\u4E86\u4E13\u4E1A\u4EFB\u52A1\u7684\u4E13\u7528\u6307\u4EE4\u3002
\u5F53\u4EFB\u52A1\u4E0E\u67D0\u4E2A\u6280\u80FD\u7684\u63CF\u8FF0\u5339\u914D\u65F6\uFF0C\u8C03\u7528 activate_skill \u5DE5\u5177\u5E76\u4F20\u5165\u6280\u80FD\u540D\u79F0\u6765\u52A0\u8F7D\u5B8C\u6574\u6307\u4EE4\u3002
${buildSkillPrompt(mainSkills)}`,
    tools: createSkillTools(mainSkills, { mainSkill: mainSkills, secondarySkills: [], tertiarySkills: [] })
  };
  return res;
}
async function consumeFullStream(fullStream, initialMsg, syncMsg) {
  let msg = initialMsg;
  let text2 = msg.text();
  let thinking = null;
  let thinkTime = 0;
  let fullResponse = "";
  try {
    for await (const chunk of fullStream) {
      await new Promise((resolve3) => setTimeout(() => resolve3(), 1));
      if (syncMsg) {
        const newMsg = syncMsg();
        if (newMsg !== msg) {
          msg = newMsg;
          text2 = msg.text();
        }
      }
      if (chunk.type === "reasoning-start") {
        thinkTime = Date.now();
        thinking = msg.thinking("\u601D\u8003\u4E2D...");
      } else if (chunk.type === "reasoning-delta") {
        thinking?.append(chunk.text);
      } else if (chunk.type === "reasoning-end") {
        thinkTime = Date.now() - thinkTime;
        thinking?.updateTitle(`\u601D\u8003\u5B8C\u6BD5\uFF08${(thinkTime / 1e3).toFixed(1)} \u79D2\uFF09`);
        thinking?.complete();
        thinking = null;
      } else if (chunk.type === "text-delta") {
        text2.append(chunk.text);
        fullResponse += chunk.text;
      } else if (chunk.type === "error") {
        throw chunk.error;
      }
    }
    text2.complete();
    msg.complete();
  } catch (err) {
    thinking?.complete();
    const errMsg = err?.message ?? String(err);
    text2.append(errMsg);
    text2.error();
    msg.error();
    throw err;
  }
  return fullResponse;
}
function removeAllXmlTags(text2) {
  text2 = text2.replace(/<([a-zA-Z][\w-]*)(\s+[^>]*)?>([\s\S]*?)<\/\1>/g, "");
  text2 = text2.replace(/<([a-zA-Z][\w-]*)(\s+[^>]*)?\/>/g, "");
  text2 = text2.replace(/<\/?[a-zA-Z][\w-]*(\s+[^>]*)?>/g, "");
  return text2.trim();
}
function buildSkillPrompt(skills) {
  const skillEntries = skills.map((s) => `  <skill>
    <name>${s.name}</name>
    <description>${s.description}</description>
  </skill>`).join("\n");
  return `
<available_skills>
${skillEntries}
</available_skills>`;
}
async function useProductionSkills(artName, storyName) {
  const artWorkerPath = utils_default.getPath(["skills", "art_skills", artName, "driector_skills"]);
  const storyWorkerPath = utils_default.getPath(["skills", "story_skills", storyName, "driector_skills"]);
  const productionPath = utils_default.getPath(["skills", "production_skills"]);
  const skillList = [
    ...await scanSkills(artWorkerPath + "/*.md"),
    ...await scanSkills(storyWorkerPath + "/*.md"),
    ...await scanSkills(productionPath + "/*.md")
  ];
  const mainSkills = [];
  for (const skillPath of skillList) {
    if (!fs11.existsSync(skillPath)) throw new Error(`\u4E3B\u6280\u80FD\u6587\u4EF6\u4E0D\u5B58\u5728: ${skillPath}`);
    const content = await fs11.promises.readFile(skillPath, "utf-8");
    const parsed = parseFrontmatter(content);
    mainSkills.push({ path: skillPath, ...parsed });
  }
  const res = {
    prompt: `## Skills
\u4EE5\u4E0B\u6280\u80FD\u63D0\u4F9B\u4E86\u4E13\u4E1A\u4EFB\u52A1\u7684\u4E13\u7528\u6307\u4EE4\u3002
\u5F53\u4EFB\u52A1\u4E0E\u67D0\u4E2A\u6280\u80FD\u7684\u63CF\u8FF0\u5339\u914D\u65F6\uFF0C\u8C03\u7528 activate_skill \u5DE5\u5177\u5E76\u4F20\u5165\u6280\u80FD\u540D\u79F0\u6765\u52A0\u8F7D\u5B8C\u6574\u6307\u4EE4\u3002
${buildSkillPrompt(mainSkills)}`,
    tools: createSkillTools(mainSkills, { mainSkill: mainSkills, secondarySkills: [], tertiarySkills: [] })
  };
  return res;
}

// src/socket/resTool.ts
init_utils3();
var ResTool = class {
  socket;
  data;
  constructor(socket, data = {}) {
    this.socket = socket;
    this.data = data;
  }
  // 创建新消息
  newMessage(role = "assistant", name28) {
    const messageId = utils_default.uuid();
    const datetime4 = (/* @__PURE__ */ new Date()).toISOString();
    this.socket.emit("message", {
      id: messageId,
      role,
      name: name28,
      status: "pending",
      datetime: datetime4,
      content: []
    });
    return new MessageBuilder(this.socket, messageId, role, name28, datetime4);
  }
  // 发送错误消息
  sendError(messageId, error73) {
    this.socket.emit("message:update", {
      id: messageId,
      status: "error",
      ext: { error: error73 }
    });
  }
  // 发送完成状态
  sendComplete(messageId) {
    this.socket.emit("message:update", {
      id: messageId,
      status: "complete"
    });
  }
};
var MessageBuilder = class {
  socket;
  messageId;
  messageRole;
  messageName;
  messageDatetime;
  constructor(socket, messageId, role, name28, datetime4) {
    this.socket = socket;
    this.messageId = messageId;
    this.messageRole = role;
    this.messageName = name28;
    this.messageDatetime = datetime4 ?? (/* @__PURE__ */ new Date()).toISOString();
  }
  get id() {
    return this.messageId;
  }
  get role() {
    return this.messageRole;
  }
  get name() {
    return this.messageName;
  }
  get datetime() {
    return this.messageDatetime;
  }
  // 更新消息状态
  updateStatus(status) {
    this.socket.emit("message:update", {
      id: this.messageId,
      status
    });
    return this;
  }
  // 添加文本内容
  text(initialText = "") {
    const contentId = utils_default.uuid();
    const content = {
      type: "text",
      id: contentId,
      data: "",
      status: "pending"
    };
    this.socket.emit("content:add", {
      messageId: this.messageId,
      content
    });
    const stream4 = new AutoThinkingTextStream(this.socket, this.messageId, contentId, this);
    if (initialText) {
      stream4.append(initialText);
    }
    return stream4;
  }
  // 添加 Markdown 内容
  markdown(initialText = "") {
    const contentId = utils_default.uuid();
    const content = {
      type: "markdown",
      id: contentId,
      data: initialText,
      status: "pending"
    };
    this.socket.emit("content:add", {
      messageId: this.messageId,
      content
    });
    return new ContentStream(this.socket, this.messageId, contentId, "markdown");
  }
  // 添加思考内容
  thinking(title = "\u601D\u8003\u4E2D...") {
    const contentId = utils_default.uuid();
    const content = {
      type: "thinking",
      id: contentId,
      data: { title, text: "" },
      status: "pending"
    };
    this.socket.emit("content:add", {
      messageId: this.messageId,
      content
    });
    return new ThinkingStream(this.socket, this.messageId, contentId);
  }
  // 添加搜索内容
  search(title = "\u641C\u7D22\u4E2D...") {
    const contentId = utils_default.uuid();
    const content = {
      type: "search",
      id: contentId,
      data: { title, references: [] },
      status: "pending"
    };
    this.socket.emit("content:add", {
      messageId: this.messageId,
      content
    });
    return new SearchStream(this.socket, this.messageId, contentId);
  }
  // 添加图片内容
  image(data) {
    const contentId = utils_default.uuid();
    const content = {
      type: "image",
      id: contentId,
      data,
      status: "complete"
    };
    this.socket.emit("content:add", {
      messageId: this.messageId,
      content
    });
    return this;
  }
  // 添加建议内容
  suggestion(suggestions) {
    const contentId = utils_default.uuid();
    const content = {
      type: "suggestion",
      id: contentId,
      data: suggestions,
      status: "complete"
    };
    this.socket.emit("content:add", {
      messageId: this.messageId,
      content
    });
    return this;
  }
  // 添加工具调用内容
  toolCall(data) {
    const contentId = utils_default.uuid();
    const content = {
      type: "toolcall",
      id: contentId,
      data: { ...data, parentMessageId: this.messageId },
      status: "pending"
    };
    this.socket.emit("content:add", {
      messageId: this.messageId,
      content
    });
    return new ToolCallStream(this.socket, this.messageId, contentId, data.toolCallId);
  }
  // 添加活动内容
  activity(activityType, content) {
    const contentId = utils_default.uuid();
    const activityContent = {
      type: "activity",
      id: contentId,
      data: {
        activityType,
        messageId: this.messageId,
        content
      },
      status: "complete"
    };
    this.socket.emit("content:add", {
      messageId: this.messageId,
      content: activityContent
    });
    return this;
  }
  // 添加推理内容
  reasoning() {
    const contentId = utils_default.uuid();
    const content = {
      type: "reasoning",
      id: contentId,
      data: [],
      status: "pending"
    };
    this.socket.emit("content:add", {
      messageId: this.messageId,
      content
    });
    return new ReasoningBuilder(this.socket, this.messageId, contentId);
  }
  // 完成消息
  complete() {
    this.socket.emit("message:update", {
      id: this.messageId,
      status: "complete"
    });
  }
  // 停止消息
  stop() {
    this.socket.emit("message:update", {
      id: this.messageId,
      status: "stop"
    });
  }
  // 错误
  error(errorMsg) {
    this.socket.emit("message:update", {
      id: this.messageId,
      status: "error",
      ext: errorMsg ? { error: errorMsg } : void 0
    });
  }
};
var ContentStream = class {
  socket;
  messageId;
  contentId;
  contentType;
  constructor(socket, messageId, contentId, contentType) {
    this.socket = socket;
    this.messageId = messageId;
    this.contentId = contentId;
    this.contentType = contentType;
  }
  get id() {
    return this.contentId;
  }
  // 流式追加数据
  append(chunk) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: this.contentType,
      data: chunk,
      strategy: "append",
      status: "streaming"
    });
    return this;
  }
  // 合并/替换数据
  merge(data) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: this.contentType,
      data,
      strategy: "merge",
      status: "streaming"
    });
    return this;
  }
  // 完成内容
  complete(finalData) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: this.contentType,
      data: finalData,
      status: "complete"
    });
    return this;
  }
  // 错误
  error() {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      status: "error"
    });
    return this;
  }
};
var ThinkingStream = class extends ContentStream {
  constructor(socket, messageId, contentId) {
    super(socket, messageId, contentId, "thinking");
  }
  // 追加思考文本
  appendText(chunk) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "thinking",
      data: { text: chunk },
      strategy: "append",
      status: "streaming"
    });
    return this;
  }
  // 更新标题
  updateTitle(title) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "thinking",
      data: { title },
      strategy: "merge",
      status: "streaming"
    });
    return this;
  }
};
var AutoThinkingTextStream = class _AutoThinkingTextStream extends ContentStream {
  static OPEN_TAG = "<think>";
  static CLOSE_TAG = "</think>";
  messageBuilder;
  pending = "";
  inThinking = false;
  thinkingStream = null;
  thinkingBuffer = "";
  thinkingStartTime = 0;
  constructor(socket, messageId, contentId, messageBuilder) {
    super(socket, messageId, contentId, "text");
    this.messageBuilder = messageBuilder;
  }
  /**
   * 检查 str 的尾部是否是 tag 的某个非空真前缀。
   * 返回需要保留的尾部字符数（0 表示不需要缓冲）。
   */
  static tailPrefixLen(str, tag) {
    const maxCheck = Math.min(str.length, tag.length - 1);
    for (let len = maxCheck; len >= 1; len--) {
      if (str.endsWith(tag.slice(0, len))) {
        return len;
      }
    }
    return 0;
  }
  append(chunk) {
    if (!chunk) return this;
    let rest = this.pending + chunk;
    this.pending = "";
    while (rest.length > 0) {
      if (!this.inThinking) {
        const openIndex = rest.indexOf(_AutoThinkingTextStream.OPEN_TAG);
        if (openIndex >= 0) {
          this.flushText(rest.slice(0, openIndex));
          this.inThinking = true;
          this.thinkingStartTime = Date.now();
          this.thinkingBuffer = "";
          this.ensureThinkingStream();
          rest = rest.slice(openIndex + _AutoThinkingTextStream.OPEN_TAG.length);
          continue;
        }
        const keep = _AutoThinkingTextStream.tailPrefixLen(rest, _AutoThinkingTextStream.OPEN_TAG);
        if (keep > 0) {
          this.flushText(rest.slice(0, rest.length - keep));
          this.pending = rest.slice(rest.length - keep);
        } else {
          this.flushText(rest);
        }
        break;
      } else {
        const closeIndex = rest.indexOf(_AutoThinkingTextStream.CLOSE_TAG);
        if (closeIndex >= 0) {
          this.flushThinking(rest.slice(0, closeIndex));
          this.finishThinking();
          rest = rest.slice(closeIndex + _AutoThinkingTextStream.CLOSE_TAG.length);
          continue;
        }
        const keep = _AutoThinkingTextStream.tailPrefixLen(rest, _AutoThinkingTextStream.CLOSE_TAG);
        if (keep > 0) {
          this.flushThinking(rest.slice(0, rest.length - keep));
          this.pending = rest.slice(rest.length - keep);
        } else {
          this.flushThinking(rest);
        }
        break;
      }
    }
    return this;
  }
  complete(finalData) {
    if (finalData) {
      this.append(finalData);
    }
    if (this.pending) {
      if (this.inThinking) {
        this.flushThinking(this.pending);
      } else {
        this.flushText(this.pending);
      }
      this.pending = "";
    }
    this.finishThinking();
    super.complete();
    return this;
  }
  error() {
    if (this.thinkingStream) {
      this.thinkingStream.error();
      this.thinkingStream = null;
    }
    this.pending = "";
    this.thinkingBuffer = "";
    this.inThinking = false;
    return super.error();
  }
  /** 输出普通文本 */
  flushText(text2) {
    if (!text2) return;
    super.append(text2);
  }
  /** 输出思考文本：累积完整内容，用 merge 策略发送，避免前端 append 丢失 */
  flushThinking(text2) {
    if (!text2) return;
    this.thinkingBuffer += text2;
    this.ensureThinkingStream().merge({ title: "\u601D\u8003\u4E2D...", text: this.thinkingBuffer });
  }
  ensureThinkingStream() {
    if (!this.thinkingStream) {
      this.thinkingStartTime = Date.now();
      this.thinkingStream = this.messageBuilder.thinking("\u601D\u8003\u4E2D...");
    }
    return this.thinkingStream;
  }
  finishThinking() {
    if (this.thinkingStream) {
      const elapsed = ((Date.now() - this.thinkingStartTime) / 1e3).toFixed(1);
      this.thinkingStream.updateTitle(`\u601D\u8003\u5B8C\u6BD5\uFF08${elapsed}\u79D2\uFF09`);
      this.thinkingStream.complete({ title: `\u601D\u8003\u5B8C\u6BD5\uFF08${elapsed}\u79D2\uFF09`, text: this.thinkingBuffer });
      this.thinkingStream = null;
      this.thinkingBuffer = "";
    }
    this.inThinking = false;
  }
};
var SearchStream = class extends ContentStream {
  constructor(socket, messageId, contentId) {
    super(socket, messageId, contentId, "search");
  }
  // 添加引用
  addReference(ref) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "search",
      data: { references: [ref] },
      strategy: "append",
      status: "streaming"
    });
    return this;
  }
  // 批量添加引用
  addReferences(refs) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "search",
      data: { references: refs },
      strategy: "append",
      status: "streaming"
    });
    return this;
  }
  // 更新标题
  updateTitle(title) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "search",
      data: { title },
      strategy: "merge",
      status: "streaming"
    });
    return this;
  }
};
var ToolCallStream = class extends ContentStream {
  toolCallId;
  constructor(socket, messageId, contentId, toolCallId) {
    super(socket, messageId, contentId, "toolcall");
    this.toolCallId = toolCallId;
  }
  // 追加参数块
  appendArgs(chunk) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "toolcall",
      data: { toolCallId: this.toolCallId, args: chunk },
      strategy: "append",
      status: "streaming"
    });
    return this;
  }
  // 追加结果块
  appendResult(chunk) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "toolcall",
      data: { toolCallId: this.toolCallId, chunk },
      strategy: "append",
      status: "streaming"
    });
    return this;
  }
  // 设置完整结果
  setResult(result) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "toolcall",
      data: { toolCallId: this.toolCallId, result },
      strategy: "merge",
      status: "complete"
    });
    return this;
  }
  // 更新事件类型
  updateEventType(eventType) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "toolcall",
      data: { toolCallId: this.toolCallId, eventType },
      strategy: "merge",
      status: "streaming"
    });
    return this;
  }
};
var ReasoningBuilder = class {
  socket;
  messageId;
  contentId;
  constructor(socket, messageId, contentId) {
    this.socket = socket;
    this.messageId = messageId;
    this.contentId = contentId;
  }
  // 添加子内容
  addContent(content) {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "reasoning",
      data: [content],
      strategy: "append",
      status: "streaming"
    });
    return this;
  }
  // 完成推理
  complete() {
    this.socket.emit("content:update", {
      messageId: this.messageId,
      contentId: this.contentId,
      type: "reasoning",
      status: "complete"
    });
    return this;
  }
};
var resTool_default = ResTool;

// src/socket/routes/productionAgent.ts
init_auth();
init_requestContext();
var productionAgent_default = (nsp) => {
  nsp.on("connection", async (socket) => {
    const token = socket.handshake.auth.token;
    const authUser = await verifyAuthToken(token);
    const projectId = Number(socket.handshake.auth.projectId);
    if (!authUser || !projectId || !await assertProjectAccess(projectId, authUser.id)) {
      console.log("[productionAgent] \u8FDE\u63A5\u5931\u8D25\uFF0Ctoken\u65E0\u6548");
      socket.disconnect();
      return;
    }
    let isolationKey = socket.handshake.auth.isolationKey;
    if (!isolationKey) {
      console.log("[productionAgent] \u8FDE\u63A5\u5931\u8D25\uFF0C\u7F3A\u5C11 isolationKey");
      socket.disconnect();
      return;
    }
    console.log("[productionAgent] \u5DF2\u8FDE\u63A5:", socket.id);
    let resTool = new resTool_default(socket, {
      projectId,
      scriptId: socket.handshake.auth.scriptId
    });
    let abortController = null;
    const thinkConfig = {
      think: false,
      thinlLevel: 0
    };
    socket.on("updateContext", async (data, callback) => {
      if (!await assertProjectAccess(Number(data.projectId), authUser.id)) {
        callback?.({ success: false, message: "\u65E0\u6743\u8BBF\u95EE\u8BE5\u9879\u76EE" });
        return;
      }
      isolationKey = data.isolationKey;
      resTool = new resTool_default(socket, {
        projectId: data.projectId,
        scriptId: data.scriptId
      });
      console.log("[productionAgent] \u4E0A\u4E0B\u6587\u5DF2\u66F4\u65B0:", isolationKey);
      callback?.({ success: true });
    });
    socket.on("chat", async (data) => {
      const { content } = data;
      abortController?.abort();
      abortController = new AbortController();
      const currentController = abortController;
      const msg = resTool.newMessage("assistant", "\u89C6\u9891\u7B56\u5212");
      const ctx = {
        socket,
        isolationKey,
        text: content,
        userMessageTime: new Date(msg.datetime).getTime() - 1,
        abortSignal: currentController.signal,
        resTool,
        msg,
        thinkConfig
      };
      try {
        await runWithRequestContext({ userId: authUser.id }, () => runDecisionAI(ctx));
      } catch (err) {
        if (err.name !== "AbortError" && !currentController.signal.aborted) {
          console.error("[productionAgent] chat error:", utils_default.error(err).message);
        }
      } finally {
        if (abortController === currentController) {
          abortController = null;
        }
      }
    });
    socket.on("updateThinkConfig", (data) => {
      thinkConfig.think = data.think;
      thinkConfig.thinlLevel = data.thinlLevel;
      console.log("[productionAgent] \u66F4\u65B0\u601D\u8003\u914D\u7F6E:", thinkConfig);
    });
    socket.on("stop", () => {
      abortController?.abort();
      abortController = null;
    });
  });
  nsp.on("disconnect", (socket) => {
    console.log("[productionAgent] \u5DF2\u65AD\u5F00\u8FDE\u63A5:", socket.id);
  });
};

// src/socket/routes/scriptAgent.ts
init_utils3();

// src/agents/scriptAgent/index.ts
init_dist22();
init_zod();
init_utils3();

// src/agents/scriptAgent/tools.ts
init_dist22();
init_utils3();
init_zod();
var ScriptSchema = external_exports.object({
  name: external_exports.string().describe("\u5267\u672C\u540D\u79F0"),
  content: external_exports.string().describe("\u5267\u672C\u5185\u5BB9")
});
var planData = external_exports.object({
  storySkeleton: external_exports.string().describe("\u6545\u4E8B\u9AA8\u67B6"),
  adaptationStrategy: external_exports.string().describe("\u6539\u7F16\u7B56\u7565"),
  script: external_exports.string().describe("\u5267\u672C\u5185\u5BB9")
});
var keySchema2 = external_exports.enum(Object.keys(planData.shape));
var planDataKeyLabels = Object.fromEntries(
  Object.entries(planData.shape).map(([key, schema]) => [key, schema.description ?? key])
);
var tools_default2 = (toolCpnfig) => {
  const { resTool, toolsNames, msg } = toolCpnfig;
  const { socket } = resTool;
  const tools = {
    get_novel_events: tool({
      description: "\u83B7\u53D6\u7AE0\u8282\u4E8B\u4EF6",
      inputSchema: jsonSchema(
        external_exports.object({
          chapterIndexs: external_exports.array(external_exports.number()).describe("\u7AE0\u8282\u7684\u7F16\u53F7")
        }).toJSONSchema()
      ),
      execute: async ({ chapterIndexs }) => {
        console.log("[tools] get_novel_events", chapterIndexs);
        const thinking = msg.thinking("\u6B63\u5728\u67E5\u8BE2\u7AE0\u8282\u4E8B\u4EF6...");
        const data = await utils_default.db("o_novel").where("projectId", resTool.data.projectId).select("id", "chapterIndex as index", "reel", "chapter", "chapterData", "event", "eventState").whereIn("chapterIndex", chapterIndexs);
        thinking.appendText("\u6B63\u5728\u67E5\u8BE2\u7AE0\u8282\u7F16\u53F7: " + chapterIndexs.join(","));
        const eventString = data.map((i) => [`\u7B2C${i.index}\u7AE0\uFF0C\u6807\u9898:${i.chapter}\uFF0C\u4E8B\u4EF6:${i.event}`].join("\n")).join("\n");
        thinking.appendText("\u67E5\u8BE2\u7ED3\u679C:\n" + eventString);
        thinking.updateTitle("\u67E5\u8BE2\u7AE0\u8282\u4E8B\u4EF6\u5B8C\u6210");
        thinking.complete();
        return eventString ?? "\u65E0\u6570\u636E";
      }
    }),
    get_planData: tool({
      description: "\u83B7\u53D6\u5DE5\u4F5C\u533A\u6570\u636E",
      inputSchema: jsonSchema(
        external_exports.object({
          key: keySchema2.describe("\u6570\u636Ekey")
        }).toJSONSchema()
      ),
      execute: async ({ key }) => {
        console.log("[tools] get_planData", key);
        const thinking = msg.thinking(`\u6B63\u5728\u83B7\u53D6${planDataKeyLabels[key]}\u5DE5\u4F5C\u533A\u6570\u636E...`);
        const planData2 = await new Promise((resolve3) => socket.emit("getPlanData", { key }, (res) => resolve3(res)));
        thinking.appendText(`\u83B7\u53D6\u5230${planDataKeyLabels[key]}:
` + planData2[key]);
        thinking.updateTitle(`\u83B7\u53D6${planDataKeyLabels[key]}\u5B8C\u6210`);
        thinking.complete();
        return planData2[key] ?? "\u65E0\u6570\u636E";
      }
    }),
    get_novel_text: tool({
      description: "\u83B7\u53D6\u5C0F\u8BF4\u7AE0\u8282\u539F\u59CB\u6587\u672C\u5185\u5BB9",
      inputSchema: jsonSchema(
        external_exports.object({
          chapterIndex: external_exports.string().describe("\u7AE0\u8282\u7F16\u53F7")
        }).toJSONSchema()
      ),
      execute: async ({ chapterIndex }) => {
        console.log("[tools] get_novel_text", "[tools] get_novel_text", chapterIndex);
        const thinking = msg.thinking(`\u6B63\u5728\u83B7\u53D6\u5C0F\u8BF4\u7AE0\u8282\u539F\u6587...`);
        const data = await utils_default.db("o_novel").where("projectId", resTool.data.projectId).where({ chapterIndex }).select("chapterData").first();
        const text2 = data && data?.chapterData ? data.chapterData : "";
        thinking.appendText(`\u83B7\u53D6\u5230\u539F\u6587:
` + text2);
        thinking.updateTitle(`\u83B7\u53D6\u5C0F\u8BF4\u7AE0\u8282\u539F\u6587\u5B8C\u6210`);
        thinking.complete();
        return text2 ?? "\u65E0\u6570\u636E";
      }
    }),
    get_script_content: tool({
      description: "\u83B7\u53D6\u5267\u672C\u672C\u5185\u5BB9",
      inputSchema: jsonSchema(
        external_exports.object({
          ids: external_exports.array(external_exports.string()).describe("\u811A\u672Cid")
        }).toJSONSchema()
      ),
      execute: async ({ ids }) => {
        console.log("[tools] get_script_content", "[tools] get_script_content", ids);
        const thinking = msg.thinking(`\u6B63\u5728\u83B7\u53D6\u811A\u672C\u5185\u5BB9...`);
        const data = await utils_default.db("o_script").whereIn("id", ids).select("content", "name");
        const text2 = data && data.length ? data.map((d) => `<scriptItem name="${d.name}">${d.content}</scriptItem>`).join("\n") : "";
        thinking.appendText(`\u83B7\u53D6\u5230\u811A\u672C\u5185\u5BB9:
` + JSON.stringify(data, null, 2));
        thinking.updateTitle(`\u83B7\u53D6\u811A\u672C\u5185\u5BB9\u5B8C\u6210`);
        thinking.complete();
        return text2 ?? "\u65E0\u6570\u636E";
      }
    })
  };
  return toolsNames ? Object.fromEntries(Object.entries(tools).filter(([n]) => toolsNames.includes(n))) : tools;
};

// src/agents/scriptAgent/index.ts
var fs12 = __toESM(require("fs"));
var import_path11 = __toESM(require("path"));
function buildMemPrompt2(mem) {
  let memoryContext = "";
  if (mem.rag.length) {
    memoryContext += `[\u76F8\u5173\u8BB0\u5FC6]
${mem.rag.map((r) => r.content).join("\n")}`;
  }
  if (mem.summaries.length) {
    if (memoryContext) memoryContext += "\n\n";
    memoryContext += `[\u5386\u53F2\u6458\u8981]
${mem.summaries.map((s, i) => `${i + 1}. ${s.content}`).join("\n")}`;
  }
  if (mem.shortTerm.length) {
    if (memoryContext) memoryContext += "\n\n";
    memoryContext += `[\u8FD1\u671F\u5BF9\u8BDD]
${mem.shortTerm.map((m) => `${m.role}: ${m.content}`).join("\n")}`;
  }
  return `## Memory
\u4EE5\u4E0B\u662F\u4F60\u5BF9\u7528\u6237\u7684\u8BB0\u5FC6\uFF0C\u53EF\u4F5C\u4E3A\u53C2\u8003\u4F46\u4E0D\u8981\u4E3B\u52A8\u63D0\u53CA\uFF1A
${memoryContext}`;
}
async function runDecisionAI2(ctx) {
  const { isolationKey, text: text2, userMessageTime, abortSignal, resTool } = ctx;
  const memory = new memory_default("scriptAgent", isolationKey);
  await memory.add("user", text2, { createTime: userMessageTime });
  const skill = import_path11.default.join(utils_default.getPath("skills"), "script_agent_decision.md");
  const prompt = await fs12.promises.readFile(skill, "utf-8");
  const mem = buildMemPrompt2(await memory.get(text2));
  const projectData = await utils_default.db("o_project").where("id", resTool.data.projectId).first();
  const novelData = await utils_default.db("o_novel").where("projectId", resTool.data.projectId).select("chapterIndex");
  const projectInfo = [
    "## \u9879\u76EE\u4FE1\u606F",
    `\u5C0F\u8BF4\u540D\u79F0\uFF1A${projectData?.name ?? "\u672A\u77E5"}`,
    `\u5C0F\u8BF4\u7C7B\u578B\uFF1A${projectData?.type ?? "\u672A\u77E5"}`,
    `\u5C0F\u8BF4\u7B80\u4ECB\uFF1A${projectData?.intro ?? "\u65E0"}`,
    `\u76EE\u6807\u6539\u7F16\u5F71\u89C6\u89C6\u89C9\u624B\u518C|\u753B\u98CE\uFF1A${projectData?.artStyle ?? "\u65E0"}`,
    `\u76EE\u6807\u6539\u7F16\u89C6\u9891\u753B\u5E45\uFF1A${projectData?.videoRatio ?? "16:9"}`,
    `\u7AE0\u8282\u6570\u91CF\uFF1A${novelData.length}\u7AE0`
  ].join("\n");
  const { fullStream } = await utils_default.Ai.Text("scriptAgent:decisionAgent", ctx.thinkConfig.think, ctx.thinkConfig.thinlLevel).stream({
    messages: [
      { role: "system", content: prompt },
      { role: "assistant", content: projectInfo + "\n" + mem },
      { role: "user", content: text2 }
    ],
    abortSignal,
    tools: {
      ...memory.getTools(),
      ...tools_default2({ resTool: ctx.resTool, msg: ctx.msg }),
      ...createSubAgent2(ctx)
    },
    onFinish: async (completion) => {
      await memory.add("assistant:decision", removeAllXmlTags2(completion.text));
    }
  });
  let currentMsg = ctx.msg;
  await consumeFullStream2(fullStream, currentMsg, () => {
    if (ctx.msg === currentMsg) return currentMsg;
    currentMsg.complete();
    currentMsg = ctx.msg;
    return currentMsg;
  });
}
function createSubAgent2(parentCtx) {
  const { resTool, abortSignal } = parentCtx;
  const memory = new memory_default("scriptAgent", parentCtx.isolationKey);
  async function runAgent({
    key,
    prompt,
    system,
    name: name28,
    memoryKey,
    tools: extraTools,
    messages
  }) {
    parentCtx.msg.complete();
    const subMsg = resTool.newMessage("assistant", name28);
    const { fullStream } = await utils_default.Ai.Text(key, parentCtx.thinkConfig.think, parentCtx.thinkConfig.thinlLevel).stream({
      system,
      messages: messages ?? [{ role: "user", content: prompt }],
      abortSignal,
      tools: { ...extraTools, ...tools_default2({ resTool, msg: subMsg }) }
    });
    const fullResponse = await consumeFullStream2(fullStream, subMsg);
    if (fullResponse.trim()) {
      await memory.add(memoryKey, removeAllXmlTags2(fullResponse), {
        name: name28,
        createTime: new Date(subMsg.datetime).getTime()
      });
    }
    parentCtx.msg = resTool.newMessage("assistant", "\u89C6\u9891\u7B56\u5212");
    return fullResponse;
  }
  const promptInput = external_exports.object({
    prompt: external_exports.string().describe("\u4EA4\u7ED9\u5B50Agent\u7684\u4EFB\u52A1\u7B80\u7EA6\u63CF\u8FF0\uFF0C100\u5B57\u4EE5\u5185")
  }).toJSONSchema();
  const run_sub_agent_storySkeleton = tool({
    description: "\u8FD0\u884C\u6267\u884CsubAgent\u6765\u5B8C\u6210\u6545\u4E8B\u9AA8\u67B6\u76F8\u5173\u4EFB\u52A1",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path11.default.join(utils_default.getPath("skills"), "script_execution_skeleton.md");
      const systemPrompt = await fs12.promises.readFile(skill, "utf-8");
      const formatPrompt = "\n\u4F60\u5FC5\u987B\u4F7F\u7528\u5982\u4E0BXML\u683C\u5F0F\u5199\u5165\u5DE5\u4F5C\u533A\uFF1A\n<storySkeleton>\u6545\u4E8B\u9AA8\u67B6\u5185\u5BB9</storySkeleton>";
      return runAgent({
        key: "scriptAgent:storySkeletonAgent",
        prompt,
        system: systemPrompt + formatPrompt,
        name: "\u7F16\u5267",
        memoryKey: "assistant:execution:storySkeleton",
        messages: [{ role: "user", content: prompt + formatPrompt }]
      });
    }
  });
  const run_sub_agent_adaptationStrategy = tool({
    description: "\u8FD0\u884C\u6267\u884CsubAgent\u6765\u5B8C\u6210\u6539\u7F16\u7B56\u7565\u76F8\u5173\u4EFB\u52A1",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path11.default.join(utils_default.getPath("skills"), "script_execution_adaptation.md");
      const systemPrompt = await fs12.promises.readFile(skill, "utf-8");
      const formatPrompt = "\n\u4F60\u5FC5\u987B\u4F7F\u7528\u5982\u4E0BXML\u683C\u5F0F\u5199\u5165\u5DE5\u4F5C\u533A\uFF1A\n<adaptationStrategy>\u6539\u7F16\u7B56\u7565\u5185\u5BB9</adaptationStrategy>";
      return runAgent({
        key: "scriptAgent:adaptationStrategyAgent",
        prompt,
        system: systemPrompt + formatPrompt,
        name: "\u7F16\u5267",
        memoryKey: "assistant:execution:adaptationStrategy",
        messages: [{ role: "user", content: prompt + formatPrompt }]
      });
    }
  });
  const run_sub_agent_script = tool({
    description: "\u8FD0\u884C\u6267\u884CsubAgent\u6765\u5B8C\u6210\u5267\u672C\u76F8\u5173\u4EFB\u52A1",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path11.default.join(utils_default.getPath("skills"), "script_execution_script.md");
      const systemPrompt = await fs12.promises.readFile(skill, "utf-8");
      const scriptList = await utils_default.db("o_script").where("projectId", resTool.data.projectId).select("id", "name");
      const scriptPrompt = ["## \u53EF\u7528\u5267\u672C(ID:\u540D\u79F0)", scriptList.map((s) => `${s.id}:${(s.name || "").replace(/[,:]/g, "")}`).join(","), ""].join(
        "\n"
      );
      const novelData = await utils_default.db("o_novel").where("projectId", resTool.data.projectId).select("chapterIndex");
      const formatPrompt = `
\u4F60\u5FC5\u987B\u4F7F\u7528\u5982\u4E0BXML\u683C\u5F0F\u5199\u5165\u5DE5\u4F5C\u533A\uFF1A
XML\u4E0D\u5F97\u6DFB\u52A0\u4EFB\u4F55\u989D\u5916\u6807\u7B7E<scriptItem name="\u5267\u672C\u540D\u79F0">\u5267\u672C\u5185\u5BB9</scriptItem><scriptItem name="\u5267\u672C\u540D\u79F0">\u5267\u672C\u5185\u5BB9</scriptItem><scriptItem name="\u5267\u672C\u540D\u79F0">\u5267\u672C\u5185\u5BB9</scriptItem>`;
      return runAgent({
        key: "scriptAgent:scriptAgent",
        prompt,
        system: systemPrompt + formatPrompt,
        messages: [
          { role: "assistant", content: scriptPrompt + `\u7AE0\u8282\u6570\u91CF\uFF1A${novelData.length}\u7AE0` },
          { role: "user", content: prompt + formatPrompt }
        ],
        name: "\u7F16\u5267",
        memoryKey: "assistant:execution:script"
      });
    }
  });
  const run_supervision_agent = tool({
    description: "\u8FD0\u884C\u76D1\u7763\u5C42subAgent\u6267\u884C\u72EC\u7ACB\u4EFB\u52A1\uFF0C\u5B8C\u6210\u540E\u8FD4\u56DE\u7ED3\u679C",
    inputSchema: jsonSchema(promptInput),
    execute: async ({ prompt }) => {
      const skill = import_path11.default.join(utils_default.getPath("skills"), "script_agent_supervision.md");
      const systemPrompt = await fs12.promises.readFile(skill, "utf-8");
      return runAgent({
        key: "scriptAgent:supervisionAgent",
        prompt,
        system: systemPrompt,
        name: "\u7F16\u8F91",
        memoryKey: "assistant:supervision"
      });
    }
  });
  return {
    run_sub_agent_storySkeleton,
    run_sub_agent_adaptationStrategy,
    run_sub_agent_script,
    run_supervision_agent
  };
}
async function consumeFullStream2(fullStream, initialMsg, syncMsg) {
  let msg = initialMsg;
  let text2 = msg.text();
  let thinking = null;
  let thinkTime = 0;
  let fullResponse = "";
  try {
    for await (const chunk of fullStream) {
      await new Promise((resolve3) => setTimeout(() => resolve3(), 1));
      if (syncMsg) {
        const newMsg = syncMsg();
        if (newMsg !== msg) {
          msg = newMsg;
          text2 = msg.text();
        }
      }
      if (chunk.type === "reasoning-start") {
        thinkTime = Date.now();
        thinking = msg.thinking("\u601D\u8003\u4E2D...");
      } else if (chunk.type === "reasoning-delta") {
        thinking?.append(chunk.text);
      } else if (chunk.type === "reasoning-end") {
        thinkTime = Date.now() - thinkTime;
        thinking?.updateTitle(`\u601D\u8003\u5B8C\u6BD5\uFF08${(thinkTime / 1e3).toFixed(1)} \u79D2\uFF09`);
        thinking?.complete();
        thinking = null;
      } else if (chunk.type === "text-delta") {
        text2.append(chunk.text);
        fullResponse += chunk.text;
      } else if (chunk.type === "error") {
        throw chunk.error;
      }
    }
    text2.complete();
    msg.complete();
  } catch (err) {
    thinking?.complete();
    const errMsg = err?.message ?? String(err);
    text2.append(errMsg);
    text2.error();
    msg.error();
    throw err;
  }
  return fullResponse;
}
function removeAllXmlTags2(text2) {
  text2 = text2.replace(/<([a-zA-Z][\w-]*)(\s+[^>]*)?>([\s\S]*?)<\/\1>/g, "");
  text2 = text2.replace(/<([a-zA-Z][\w-]*)(\s+[^>]*)?\/>/g, "");
  text2 = text2.replace(/<\/?[a-zA-Z][\w-]*(\s+[^>]*)?>/g, "");
  return text2.trim();
}

// src/socket/routes/scriptAgent.ts
init_auth();
init_requestContext();
var scriptAgent_default = (nsp) => {
  nsp.on("connection", async (socket) => {
    const token = socket.handshake.auth.token;
    const authUser = await verifyAuthToken(token);
    const projectId = Number(socket.handshake.auth.projectId);
    if (!authUser || !projectId || !await assertProjectAccess(projectId, authUser.id)) {
      console.log("[scriptAgent] \u8FDE\u63A5\u5931\u8D25\uFF0Ctoken\u65E0\u6548");
      socket.disconnect();
      return;
    }
    const isolationKey = socket.handshake.auth.isolationKey;
    if (!isolationKey) {
      console.log("[scriptAgent] \u8FDE\u63A5\u5931\u8D25\uFF0C\u7F3A\u5C11 isolationKey");
      socket.disconnect();
      return;
    }
    console.log("[scriptAgent] \u5DF2\u8FDE\u63A5:", socket.id);
    const resTool = new resTool_default(socket, {
      projectId
    });
    let abortController = null;
    const thinkConfig = {
      think: false,
      thinlLevel: 0
    };
    socket.on("chat", async (data) => {
      const { content } = data;
      abortController?.abort();
      abortController = new AbortController();
      const currentController = abortController;
      const msg = resTool.newMessage("assistant", "\u7EDF\u7B79");
      const ctx = {
        socket,
        isolationKey,
        text: content,
        userMessageTime: new Date(msg.datetime).getTime() - 1,
        abortSignal: currentController.signal,
        resTool,
        msg,
        thinkConfig
      };
      try {
        await runWithRequestContext({ userId: authUser.id }, () => runDecisionAI2(ctx));
      } catch (err) {
        if (err.name !== "AbortError" && !currentController.signal.aborted) {
          console.error("[scriptAgent] chat error:", utils_default.error(err).message);
          msg.error(utils_default.error(err).message);
        }
      } finally {
        if (abortController === currentController) {
          abortController = null;
        }
      }
    });
    socket.on("updateThinkConfig", (data) => {
      thinkConfig.think = data.think;
      thinkConfig.thinlLevel = data.thinlLevel;
      console.log("[scriptAgent] \u66F4\u65B0\u601D\u8003\u914D\u7F6E:", thinkConfig);
    });
    socket.on("stop", () => {
      abortController?.abort();
      abortController = null;
    });
  });
  nsp.on("disconnect", (socket) => {
    console.log("[scriptAgent] \u5DF2\u65AD\u5F00\u8FDE\u63A5:", socket.id);
  });
};

// src/socket/index.ts
var socket_default = (io2) => {
  const routes = {
    productionAgent: productionAgent_default,
    scriptAgent: scriptAgent_default
  };
  for (const [name28, handler] of Object.entries(routes)) {
    const nsp = io2.of(`/api/socket/${name28}`);
    handler(nsp);
    console.log(`[Socket] \u6CE8\u518C\u547D\u540D\u7A7A\u95F4: /api/socket/${name28}`);
  }
};

// src/app.ts
init_getPath();
init_auth();

// src/lib/workspaceAccess.ts
init_utils3();
init_auth();
function toNumber(value) {
  const numberValue = Number(value);
  return Number.isFinite(numberValue) ? numberValue : null;
}
function toNumberList(value) {
  if (!Array.isArray(value)) return [];
  return value.map(toNumber).filter((item) => item != null);
}
async function projectIdsFromTable(table, ids) {
  ids = ids.filter(Number.isFinite);
  if (!ids.length) return [];
  return utils_default.db(table).whereIn("id", ids).select("projectId").then((rows) => rows.map((row) => row.projectId));
}
async function projectIdsFromImage(ids) {
  ids = ids.filter(Number.isFinite);
  if (!ids.length) return [];
  return utils_default.db("o_image").leftJoin("o_assets", "o_assets.id", "o_image.assetsId").whereIn("o_image.id", ids).select("o_assets.projectId").then((rows) => rows.map((row) => row.projectId));
}
async function projectIdsFromEvents(ids) {
  ids = ids.filter(Number.isFinite);
  if (!ids.length) return [];
  return utils_default.db("o_eventChapter").leftJoin("o_novel", "o_novel.id", "o_eventChapter.novelId").whereIn("o_eventChapter.eventId", ids).select("o_novel.projectId").then((rows) => rows.map((row) => row.projectId));
}
async function projectIdsFromFlow(ids) {
  ids = ids.filter(Number.isFinite);
  if (!ids.length) return [];
  const [assetRows, storyboardRows] = await Promise.all([
    utils_default.db("o_assets").whereIn("flowId", ids).select("projectId"),
    utils_default.db("o_storyboard").whereIn("flowId", ids).select("projectId")
  ]);
  return [...assetRows, ...storyboardRows].map((row) => row.projectId);
}
async function projectIdsFromWorkbenchItems(req) {
  const items = Array.isArray(req.body?.items) ? req.body.items : [];
  const assetIds = items.filter((item) => item.sources === "assets").map((item) => Number(item.id));
  const storyboardIds = items.filter((item) => item.sources === "storyboard").map((item) => Number(item.id));
  const [assets, storyboards] = await Promise.all([projectIdsFromTable("o_assets", assetIds), projectIdsFromTable("o_storyboard", storyboardIds)]);
  return [...assets, ...storyboards];
}
var projectIdAliases = {
  "/api/project/delProject": ["id"],
  "/api/project/editProject": ["id"],
  "/api/project/getSingleProject": ["id"],
  "/api/general/getSingleProject": ["id"],
  "/api/general/updateProject": ["id"]
};
var resourceLookups = {
  "/api/assets/delAssets": (req) => projectIdsFromTable("o_assets", [Number(req.body?.id)]),
  "/api/assets/updateAssets": (req) => projectIdsFromTable("o_assets", [Number(req.body?.id)]),
  "/api/assets/getImage": (req) => projectIdsFromTable("o_assets", [Number(req.body?.assetsId)]),
  "/api/assets/delImage": (req) => projectIdsFromImage([Number(req.body?.id)]),
  "/api/assetsGenerate/cancelGenerate": (req) => projectIdsFromImage([Number(req.body?.id)]),
  "/api/script/delScript": (req) => projectIdsFromTable("o_script", toNumberList(req.body?.ids)),
  "/api/script/exportScript": (req) => projectIdsFromTable("o_script", toNumberList(req.body?.id)),
  "/api/script/pollScriptAssets": (req) => projectIdsFromTable("o_script", toNumberList(req.body?.ids)),
  "/api/script/updateScript": (req) => projectIdsFromTable("o_script", [Number(req.body?.id)]),
  "/api/novel/batchDeleteNovel": (req) => projectIdsFromTable("o_novel", toNumberList(req.body?.ids)),
  "/api/novel/delNovel": (req) => projectIdsFromTable("o_novel", [Number(req.body?.id)]),
  "/api/novel/getNovelEventState": (req) => projectIdsFromTable("o_novel", toNumberList(req.body?.ids)),
  "/api/novel/updateNovel": (req) => projectIdsFromTable("o_novel", [Number(req.body?.id)]),
  "/api/novel/event/batchDeleteEvent": (req) => projectIdsFromEvents(toNumberList(req.body?.ids)),
  "/api/novel/event/deletEvent": (req) => projectIdsFromEvents([Number(req.body?.id)]),
  "/api/production/assets/pollingImage": (req) => projectIdsFromTable("o_assets", toNumberList(req.body?.ids)),
  "/api/production/assets/updateAssetsUrl": (req) => projectIdsFromTable("o_assets", [Number(req.body?.id)]),
  "/api/production/storyboard/editStoryboardInfo": (req) => projectIdsFromTable("o_storyboard", [Number(req.body?.id)]),
  "/api/production/storyboard/pollingImage": (req) => projectIdsFromTable("o_storyboard", toNumberList(req.body?.ids)),
  "/api/production/storyboard/previewImage": (req) => projectIdsFromTable("o_storyboard", toNumberList(req.body?.storyboardIds)),
  "/api/production/storyboard/removeFrame": (req) => projectIdsFromTable("o_storyboard", [Number(req.body?.id)]),
  "/api/production/storyboard/updateStoryboardUrl": (req) => projectIdsFromTable("o_storyboard", [Number(req.body?.id)]),
  "/api/production/workbench/deleteTrack": (req) => projectIdsFromTable("o_videoTrack", [Number(req.body?.id)]),
  "/api/production/workbench/delVideo": (req) => projectIdsFromTable("o_video", [Number(req.body?.id)]),
  "/api/production/workbench/getAudioBindAssetsList": (req) => projectIdsFromTable("o_assets", toNumberList(req.body?.assetsIds)),
  "/api/production/workbench/getFileUrl": projectIdsFromWorkbenchItems,
  "/api/production/workbench/selectVideo": (req) => projectIdsFromTable("o_videoTrack", [Number(req.body?.trackId)]),
  "/api/production/workbench/updateVideoDuration": (req) => projectIdsFromTable("o_videoTrack", [Number(req.body?.id)]),
  "/api/production/workbench/updateVideoPrompt": (req) => projectIdsFromTable("o_videoTrack", [Number(req.body?.id)]),
  "/api/production/editImage/getImageFlow": (req) => projectIdsFromFlow([Number(req.body?.id)]),
  "/api/production/editImage/updateImageFlow": (req) => projectIdsFromFlow([Number(req.body?.flowId)]),
  "/api/scriptAgent/updateData": (req) => projectIdsFromTable("o_agentWorkData", [Number(req.body?.id)]),
  "/api/task/taskDetails": (req) => projectIdsFromTable("o_tasks", [Number(req.body?.taskId)])
};
async function getRequestProjectIds(req) {
  const projectIds = /* @__PURE__ */ new Set();
  const directProjectId = toNumber(req.body?.projectId ?? req.query?.projectId);
  if (directProjectId != null) projectIds.add(directProjectId);
  for (const key of projectIdAliases[req.path] ?? []) {
    const value = toNumber(req.body?.[key] ?? req.query?.[key]);
    if (value != null) projectIds.add(value);
  }
  const lookup = resourceLookups[req.path];
  if (lookup) {
    const resolvedProjectIds = await lookup(req);
    resolvedProjectIds.forEach((projectId) => {
      const value = toNumber(projectId);
      if (value != null) projectIds.add(value);
    });
  }
  return Array.from(projectIds);
}
async function requestHasProjectAccess(req, userId) {
  const projectIds = await getRequestProjectIds(req);
  for (const projectId of projectIds) {
    if (!await assertProjectAccess(projectId, userId)) return false;
  }
  return true;
}

// src/app.ts
init_requestContext();
init_responseFormat();
var app = (0, import_express173.default)();
var server = import_node_http.default.createServer(app);
async function checkPermissions() {
  if (!isEletron()) return true;
  const userDataPath = utils_default.getPath();
  try {
    import_fs18.default.mkdirSync(userDataPath, { recursive: true });
    const testFile = import_path29.default.join(userDataPath, ".access_test");
    import_fs18.default.writeFileSync(testFile, "test");
    import_fs18.default.unlinkSync(testFile);
  } catch (e) {
    const { dialog, app: app2 } = require("electron");
    const { response } = await dialog.showMessageBox({
      type: "warning",
      title: "\u6743\u9650\u4E0D\u8DB3",
      message: "\u5E94\u7528\u65E0\u6CD5\u8BBF\u95EE\u6570\u636E\u76EE\u5F55",
      detail: `\u65E0\u6CD5\u8BFB\u5199\u4EE5\u4E0B\u76EE\u5F55\uFF1A
${userDataPath}

\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u6388\u4E88\u6743\u9650\uFF0C\u6216\u4EE5\u7BA1\u7406\u5458\u8EAB\u4EFD\u8FD0\u884C\u672C\u7A0B\u5E8F\u3002`,
      buttons: ["\u786E\u8BA4\u9000\u51FA"],
      defaultId: 0
    });
    if (response === 0) {
      app2.quit();
    }
  }
}
async function startServe(randomPort = false) {
  await checkPermissions();
  await utils_default.writeVersion();
  const io2 = new Server(server, { cors: { origin: "*" } });
  socket_default(io2);
  if (process.env.NODE_ENV == "dev") await generateRouter();
  (0, import_express_ws.default)(app);
  app.use((0, import_morgan.default)("dev"));
  app.use((0, import_cors.default)({ origin: "*" }));
  app.use(import_express173.default.json({ limit: "100mb" }));
  app.use(import_express173.default.urlencoded({ extended: true, limit: "100mb" }));
  const ossDir = utils_default.getPath("oss");
  if (!import_fs18.default.existsSync(ossDir)) {
    import_fs18.default.mkdirSync(ossDir, { recursive: true });
  }
  console.log("\u6587\u4EF6\u76EE\u5F55:", ossDir);
  app.use("/oss", import_express173.default.static(ossDir, { acceptRanges: false }));
  const skillsDir = utils_default.getPath("skills");
  if (!import_fs18.default.existsSync(skillsDir)) {
    import_fs18.default.mkdirSync(skillsDir, { recursive: true });
  }
  console.log("\u6587\u4EF6\u76EE\u5F55:", skillsDir);
  app.use(
    "/skills",
    (req, res, next) => {
      /\.(jpe?g|png|gif|webp|svg|ico|bmp)$/i.test(req.path) ? next() : res.status(403).end();
    },
    import_express173.default.static(skillsDir, { acceptRanges: false })
  );
  const assetsDir = utils_default.getPath("assets");
  if (!import_fs18.default.existsSync(assetsDir)) {
    import_fs18.default.mkdirSync(assetsDir, { recursive: true });
  }
  console.log("\u6587\u4EF6\u76EE\u5F55:", assetsDir);
  app.use("/assets", import_express173.default.static(assetsDir, { acceptRanges: false }));
  const webDir = utils_default.getPath("web");
  if (import_fs18.default.existsSync(webDir)) {
    console.log("\u9759\u6001\u7F51\u7AD9\u76EE\u5F55:", webDir);
    app.use(import_express173.default.static(webDir, { acceptRanges: false }));
  } else {
    console.warn("\u9759\u6001\u7F51\u7AD9\u76EE\u5F55\u4E0D\u5B58\u5728:", webDir);
  }
  app.use(async (req, res, next) => {
    if (req.path === "/api/login/login" || req.path === "/api/login/register" || req.path === "/api/login/sendSmsCode" || req.path === "/api/login/resetPassword") {
      return next();
    }
    const rawToken = req.headers.authorization || req.query.token || "";
    const token = normalizeBearerToken(rawToken);
    if (!token) return res.status(401).send({ message: "\u672A\u63D0\u4F9Btoken" });
    const authUser = await verifyAuthToken(rawToken);
    if (!authUser) {
      return res.status(401).send({ message: "\u65E0\u6548\u7684token" });
    }
    req.user = authUser;
    const canAccessProject = await requestHasProjectAccess(req, authUser.id);
    if (!canAccessProject) {
      return res.status(403).send({ message: "\u65E0\u6743\u8BBF\u95EE\u8BE5\u9879\u76EE" });
    }
    runWithRequestContext({ userId: authUser.id }, () => next());
  });
  const router173 = await Promise.resolve().then(() => (init_router(), router_exports));
  await router173.default(app);
  app.use((_, res, next) => {
    return res.status(404).send({ message: "API 404 Not Found" });
  });
  app.use((err, _, res, next) => {
    if (res.headersSent) return next(err);
    const normalizedError = utils_default.error(err);
    const status = Number(err?.status || err?.statusCode || normalizedError.status || 500);
    const message = normalizedError.message || "\u8BF7\u6C42\u5931\u8D25";
    res.locals.message = message;
    res.locals.error = err;
    console.error(err);
    res.status(Number.isFinite(status) ? status : 500).send(error50(message));
  });
  const port = randomPort ? 0 : 10588;
  return await new Promise((resolve3) => {
    server.listen(port, async () => {
      const address = server.address();
      const realPort = typeof address === "string" ? address : address?.port;
      console.log(`[\u670D\u52A1\u542F\u52A8\u6210\u529F]: http://localhost:${realPort}`);
      resolve3(realPort);
    });
  });
}
function closeServe() {
  return new Promise((resolve3, reject) => {
    if (server) {
      server.close((err) => {
        if (err) return reject(err);
        console.log("[\u670D\u52A1\u5DF2\u5173\u95ED]");
        resolve3();
      });
    } else {
      resolve3();
    }
  });
}
var isElectron2 = typeof process.versions?.electron !== "undefined";
if (!isElectron2) startServe();
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  closeServe
});
/*! Bundled license information:

depd/index.js:
  (*!
   * depd
   * Copyright(c) 2014-2018 Douglas Christopher Wilson
   * MIT Licensed
   *)

statuses/index.js:
  (*!
   * statuses
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

toidentifier/index.js:
  (*!
   * toidentifier
   * Copyright(c) 2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

http-errors/index.js:
  (*!
   * http-errors
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

bytes/index.js:
  (*!
   * bytes
   * Copyright(c) 2012-2014 TJ Holowaychuk
   * Copyright(c) 2015 Jed Watson
   * MIT Licensed
   *)

unpipe/index.js:
  (*!
   * unpipe
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

raw-body/index.js:
  (*!
   * raw-body
   * Copyright(c) 2013-2014 Jonathan Ong
   * Copyright(c) 2014-2022 Douglas Christopher Wilson
   * MIT Licensed
   *)

ee-first/index.js:
  (*!
   * ee-first
   * Copyright(c) 2014 Jonathan Ong
   * MIT Licensed
   *)

on-finished/index.js:
on-finished/index.js:
  (*!
   * on-finished
   * Copyright(c) 2013 Jonathan Ong
   * Copyright(c) 2014 Douglas Christopher Wilson
   * MIT Licensed
   *)

content-type/index.js:
  (*!
   * content-type
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

mime-db/index.js:
mime-db/index.js:
mime-db/index.js:
  (*!
   * mime-db
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2015-2022 Douglas Christopher Wilson
   * MIT Licensed
   *)

mime-types/index.js:
mime-types/index.js:
mime-types/index.js:
  (*!
   * mime-types
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

media-typer/index.js:
  (*!
   * media-typer
   * Copyright(c) 2014-2017 Douglas Christopher Wilson
   * MIT Licensed
   *)

type-is/index.js:
  (*!
   * type-is
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

body-parser/lib/read.js:
body-parser/lib/types/raw.js:
body-parser/lib/types/text.js:
body-parser/index.js:
  (*!
   * body-parser
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

body-parser/lib/types/json.js:
body-parser/lib/types/urlencoded.js:
  (*!
   * body-parser
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

encodeurl/index.js:
  (*!
   * encodeurl
   * Copyright(c) 2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

escape-html/index.js:
  (*!
   * escape-html
   * Copyright(c) 2012-2013 TJ Holowaychuk
   * Copyright(c) 2015 Andreas Lubbe
   * Copyright(c) 2015 Tiancheng "Timothy" Gu
   * MIT Licensed
   *)

parseurl/index.js:
  (*!
   * parseurl
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2014-2017 Douglas Christopher Wilson
   * MIT Licensed
   *)

finalhandler/index.js:
  (*!
   * finalhandler
   * Copyright(c) 2014-2022 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/view.js:
express/lib/application.js:
express/lib/request.js:
express/lib/express.js:
express/index.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

etag/index.js:
  (*!
   * etag
   * Copyright(c) 2014-2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

forwarded/index.js:
  (*!
   * forwarded
   * Copyright(c) 2014-2017 Douglas Christopher Wilson
   * MIT Licensed
   *)

proxy-addr/index.js:
  (*!
   * proxy-addr
   * Copyright(c) 2014-2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/utils.js:
express/lib/response.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

router/lib/layer.js:
router/lib/route.js:
router/index.js:
  (*!
   * router
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2022 Douglas Christopher Wilson
   * MIT Licensed
   *)

negotiator/index.js:
negotiator/index.js:
  (*!
   * negotiator
   * Copyright(c) 2012 Federico Romero
   * Copyright(c) 2012-2014 Isaac Z. Schlueter
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

accepts/index.js:
accepts/index.js:
  (*!
   * accepts
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

fresh/index.js:
  (*!
   * fresh
   * Copyright(c) 2012 TJ Holowaychuk
   * Copyright(c) 2016-2017 Douglas Christopher Wilson
   * MIT Licensed
   *)

range-parser/index.js:
  (*!
   * range-parser
   * Copyright(c) 2012-2014 TJ Holowaychuk
   * Copyright(c) 2015-2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

content-disposition/index.js:
  (*!
   * content-disposition
   * Copyright(c) 2014-2017 Douglas Christopher Wilson
   * MIT Licensed
   *)

cookie/index.js:
  (*!
   * cookie
   * Copyright(c) 2012-2014 Roman Shtylman
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

send/index.js:
  (*!
   * send
   * Copyright(c) 2012 TJ Holowaychuk
   * Copyright(c) 2014-2022 Douglas Christopher Wilson
   * MIT Licensed
   *)

vary/index.js:
  (*!
   * vary
   * Copyright(c) 2014-2017 Douglas Christopher Wilson
   * MIT Licensed
   *)

serve-static/index.js:
  (*!
   * serve-static
   * Copyright(c) 2010 Sencha Inc.
   * Copyright(c) 2011 TJ Holowaychuk
   * Copyright(c) 2014-2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

base64id/lib/base64id.js:
  (*!
   * base64id v0.1.0
   *)

engine.io/build/parser-v3/utf8.js:
  (*! https://mths.be/utf8js v2.1.2 by @mathias *)

object-assign/index.js:
  (*
  object-assign
  (c) Sindre Sorhus
  @license MIT
  *)

basic-auth/index.js:
  (*!
   * basic-auth
   * Copyright(c) 2013 TJ Holowaychuk
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2015-2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

on-headers/index.js:
  (*!
   * on-headers
   * Copyright(c) 2014 Douglas Christopher Wilson
   * MIT Licensed
   *)

morgan/index.js:
  (*!
   * morgan
   * Copyright(c) 2010 Sencha Inc.
   * Copyright(c) 2011 TJ Holowaychuk
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2014-2017 Douglas Christopher Wilson
   * MIT Licensed
   *)

is-extglob/index.js:
  (*!
   * is-extglob <https://github.com/jonschlinkert/is-extglob>
   *
   * Copyright (c) 2014-2016, Jon Schlinkert.
   * Licensed under the MIT License.
   *)

is-glob/index.js:
  (*!
   * is-glob <https://github.com/jonschlinkert/is-glob>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   *)

is-number/index.js:
  (*!
   * is-number <https://github.com/jonschlinkert/is-number>
   *
   * Copyright (c) 2014-present, Jon Schlinkert.
   * Released under the MIT License.
   *)

to-regex-range/index.js:
  (*!
   * to-regex-range <https://github.com/micromatch/to-regex-range>
   *
   * Copyright (c) 2015-present, Jon Schlinkert.
   * Released under the MIT License.
   *)

fill-range/index.js:
  (*!
   * fill-range <https://github.com/jonschlinkert/fill-range>
   *
   * Copyright (c) 2014-present, Jon Schlinkert.
   * Licensed under the MIT License.
   *)

queue-microtask/index.js:
  (*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)

run-parallel/index.js:
  (*! run-parallel. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)

lodash-es/lodash.js:
  (**
   * @license
   * Lodash (Custom Build) <https://lodash.com/>
   * Build: `lodash modularize exports="es" -o ./`
   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
   * Released under MIT license <https://lodash.com/license>
   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
   *)

safe-buffer/index.js:
  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
*/